spec: add MediaHandler unit tests

Signed-off-by: László Várady <[email protected]>

Author: MrAnno

spec/test-utils/webrtc.ts

@@ -88,7 +88,13 @@ export class MockRTCRtpSender {
 }
 
 export class MockMediaStreamTrack {
-    constructor(public readonly id: string, public readonly kind: "audio" | "video", public enabled = true) { }
+    constructor(
+        public readonly id: string,
+        public readonly kind: "audio" | "video",
+        public enabled = true,
+        public settings = {}) { }
+
+    getSettings() { return { deviceId: this.id, ...this.settings }; }
 
     stop() { }
 }
@@ -126,8 +132,6 @@ export class MockMediaStream extends MockEventTarget {
         super();
     }
 
-
-
     getTracks() { return this.tracks; }
     getAudioTracks() { return this.tracks.filter((track) => track.kind === "audio"); }
     getVideoTracks() { return this.tracks.filter((track) => track.kind === "video"); }
@@ -138,6 +142,28 @@ export class MockMediaStream extends MockEventTarget {
     removeTrack(track: MockMediaStreamTrack) { this.tracks.splice(this.tracks.indexOf(track), 1); }
 }
 
+export class MockMediaDevices extends MockEventTarget {
+    public async enumerateDevices(): Promise<Array<MockMediaDeviceInfo>> {
+        return [
+            new MockMediaDeviceInfo("audioinput"),
+            new MockMediaDeviceInfo("audiooutput"),
+            new MockMediaDeviceInfo("videoinput"),
+        ];
+    }
+
+    public async getDisplayMedia(constraints): Promise<MockMediaStream> {
+        return new MockMediaStream("mock_stream", [new MockMediaStreamTrack("display_track", "video")]);
+    }
+
+    public async getUserMedia(constraints) {
+        const tracks = [];
+        if (constraints.audio) tracks.push(new MockMediaStreamTrack("audio_track", "audio", true, constraints.audio));
+        if (constraints.video) tracks.push(new MockMediaStreamTrack("video_track", "video", true, constraints.video));
+
+        return new MockMediaStream("mock_stream", tracks);
+    }
+}
+
 export class MockMediaDeviceInfo {
     constructor(
         public kind: "audioinput" | "audiooutput" | "videoinput",

spec/unit/webrtc/mediaHandler.spec.ts

@@ -0,0 +1,64 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MediaHandler } from "../../../src/webrtc/mediaHandler";
+import { TestClient } from "../../TestClient";
+import { MockMediaDevices } from "../../test-utils/webrtc";
+
+describe("MediaHandler", () => {
+    let client: TestClient;
+    let mediaHandler: MediaHandler;
+
+    beforeEach(() => {
+        client = new TestClient("@alice:foo", "somedevice", "token", undefined, {});
+        mediaHandler = new MediaHandler(client.client);
+        client.client["mediaHandler"] = mediaHandler;
+
+        // @ts-ignore Mock
+        global.navigator = { mediaDevices: new MockMediaDevices() };
+    });
+
+    afterEach(() => {
+        mediaHandler.stopAllStreams();
+        client.stop();
+    });
+
+    describe("getUserMediaStream", () => {
+        it("should provide audio/video streams with appropriate defaults", async () => {
+            const stream = await mediaHandler.getUserMediaStream(true, true);
+            expect(stream.getAudioTracks().length).toBeGreaterThan(0);
+            expect(stream.getVideoTracks().length).toBeGreaterThan(0);
+
+            expect(() => { mediaHandler.stopUserMediaStream(stream); }).not.toThrow();
+        });
+
+        it("should provide media stream with advanced audio settings when requested", async () => {
+            await mediaHandler.setAudioSettings({
+                autoGainControl: false,
+                echoCancellation: true,
+                noiseSuppression: false,
+            });
+
+            const stream = await mediaHandler.getUserMediaStream(true, true);
+            expect(stream.getAudioTracks().length).toBeGreaterThan(0);
+
+            const actualAudioSettings = stream.getAudioTracks()[0].getSettings();
+            expect(actualAudioSettings).toHaveProperty("autoGainControl.ideal", false);
+            expect(actualAudioSettings).toHaveProperty("echoCancellation.ideal", true);
+            expect(actualAudioSettings).toHaveProperty("noiseSuppression.ideal", false);
+        });
+    });
+});