mockrtc 0.1.0

package/test/integration/close-steps.spec.ts

@@ -0,0 +1,39 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Tim Perry <tim@httptoolkit.tech>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    MockRTC,
+    waitForState,
+} from '../test-setup';
+
+describe("Close steps", function () {
+
+    this.timeout(10000); // Closing can take ~5 seconds to be recognized on the client
+
+    const mockRTC = MockRTC.getRemote();
+
+    beforeEach(() => mockRTC.start());
+    afterEach(() => mockRTC.stop());
+
+    it("should be able to close a connection immediately", async () => {
+        const mockPeer = await mockRTC.buildPeer()
+            .thenClose();
+
+        const localConnection = new RTCPeerConnection();
+
+        const receivedMessages: string[] = [];
+        const testChannel = localConnection.createDataChannel('data-channel');
+        testChannel.addEventListener('message', (event) => { receivedMessages.push(event.data) });
+
+        const localOffer = await localConnection.createOffer();
+        await localConnection.setLocalDescription(localOffer);
+        const { answer } = await mockPeer.answerOffer(localOffer);
+        await localConnection.setRemoteDescription(answer);
+
+        await waitForState(localConnection, 'connected');
+        await waitForState(localConnection, 'disconnected');
+    });
+
+});

package/test/integration/connection-setup.spec.ts

@@ -0,0 +1,230 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Tim Perry <tim@httptoolkit.tech>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { expect } from 'chai';
+import * as SDP from 'sdp-transform';
+import { MockRTC, waitForState } from '../test-setup';
+
+describe("When connecting, MockRTC", function () {
+
+    const mockRTC = MockRTC.getRemote();
+
+    beforeEach(() => mockRTC.start());
+    afterEach(() => mockRTC.stop());
+
+    it("should be able create an offer and accept an answer", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const localConnection = new RTCPeerConnection();
+
+        const { offer, setAnswer } = await mockPeer.createOffer();
+        await localConnection.setRemoteDescription(offer);
+
+        const localAnswer = await localConnection.createAnswer();
+        await localConnection.setLocalDescription(localAnswer);
+        await setAnswer(localAnswer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+    });
+
+    it("should be able to answer a real local offer", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const localConnection = new RTCPeerConnection();
+        localConnection.createDataChannel("dataChannel");
+
+        const localOffer = await localConnection.createOffer();
+        await localConnection.setLocalDescription(localOffer);
+
+        const { answer } = await mockPeer.answerOffer(localOffer);
+        await localConnection.setRemoteDescription(answer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+    });
+
+    it("should be able to renegotiate after a mock offer was accepted", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const localConnection = new RTCPeerConnection();
+
+        const { offer, setAnswer, session } = await mockPeer.createOffer();
+        await localConnection.setRemoteDescription(offer);
+
+        const localAnswer = await localConnection.createAnswer();
+        await localConnection.setLocalDescription(localAnswer);
+        await setAnswer(localAnswer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+
+        // Renegotiate:
+        const updatedOffer = await localConnection.createOffer({ offerToReceiveAudio: true });
+        localConnection.setLocalDescription(updatedOffer);
+
+        const updatedAnswer = await session.answerOffer(updatedOffer);
+        await localConnection.setRemoteDescription(updatedAnswer);
+
+        const updatedDescription = localConnection.currentLocalDescription;
+        const updatedMedia = SDP.parse(updatedDescription!.sdp).media;
+        expect(updatedMedia.map(m => m.type)).to.include('audio');
+    });
+
+    it("should be able to renegotiate after answering a local offer", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const localConnection = new RTCPeerConnection();
+        localConnection.createDataChannel("dataChannel");
+
+        const localOffer = await localConnection.createOffer();
+        await localConnection.setLocalDescription(localOffer);
+        const { answer, session } = await mockPeer.answerOffer(localOffer);
+        await localConnection.setRemoteDescription(answer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+
+        // Renegotiate:
+        const updatedOffer = await localConnection.createOffer({ offerToReceiveAudio: true });
+        localConnection.setLocalDescription(updatedOffer);
+        const updatedAnswer = await session.answerOffer(updatedOffer);
+        await localConnection.setRemoteDescription(updatedAnswer);
+
+        const updatedDescription = localConnection.currentLocalDescription;
+        const updatedMedia = SDP.parse(updatedDescription!.sdp).media;
+        expect(updatedMedia.map(m => m.type)).to.include('audio');
+    });
+
+    it("should be able to create a mock offer that mirrors an existing SDP", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const rawSdpToMirror = await (async () => {
+            // Wrapped in a function for clarity that this is separate, just for SDP setup:
+            const demoConn = new RTCPeerConnection();
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            const tracks = stream.getTracks();
+            demoConn.addTrack(tracks[0]);
+            return (await demoConn.createOffer({ offerToReceiveVideo: true })).sdp!;
+        })();
+        const originalSdp = SDP.parse(rawSdpToMirror);
+
+        const { offer, setAnswer } = await mockPeer.createOffer({ mirrorSDP: rawSdpToMirror });
+
+        const localConnection = new RTCPeerConnection();
+        await localConnection.setRemoteDescription(offer);
+        const localAnswer = await localConnection.createAnswer();
+        await localConnection.setLocalDescription(localAnswer);
+        await setAnswer(localAnswer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+
+        // The remote description we accepted should match the originally mirrored SDP:
+        const remoteDescription = localConnection.currentRemoteDescription;
+        const remoteMedia = SDP.parse(remoteDescription!.sdp).media;
+
+        expect(remoteMedia.map(m => [
+            m.mid, m.type, m.protocol, m.direction
+        ])).to.deep.equal([
+            [0, 'audio', 'UDP/TLS/RTP/SAVPF', 'sendrecv'],
+            [1, 'video', 'UDP/TLS/RTP/SAVPF', 'recvonly']
+        ]);
+
+        // Check each individual media field. These are the fields that will be passed through when
+        // proxying (i.e. they're not linked to a specific peer, unlike the fingerprint etc).
+        ['video', 'audio'].forEach((media) => {
+            const originalMedia = originalSdp.media.find(({ type }) => type === media)!;
+            const remoteAgreedMedia = remoteMedia.find(({ type }) => type === media)!;
+            ([
+                'msid',
+                'protocol',
+                'ext',
+                'payloads',
+                'ssrcs', // <-- Especially important, SSRC->mid is how both peers map RTP to track
+                'ssrcGroups',
+                'rtp',
+                'fmtp',
+                'rtcp',
+                'rtcpFb'
+            ] as const).forEach((field) => {
+                expect(remoteAgreedMedia[field]).to.deep.equal(originalMedia[field],
+                    `Failed to mirror ${media} ${field}`
+                );
+            });
+        });
+
+        // The local description is the locally-generated answer, so flips the media direction:
+        const localDescription = localConnection.currentLocalDescription;
+        const localMedia = SDP.parse(localDescription!.sdp).media;
+        expect(localMedia.map(m => [
+            m.mid, m.type, m.protocol, m.direction
+        ])).to.deep.equal([
+            [0, 'audio', 'UDP/TLS/RTP/SAVPF', 'recvonly'], // Only receive - no local audio to send
+            [1, 'video', 'UDP/TLS/RTP/SAVPF', 'inactive'] // Inactive - no video to send & remote is recvonly
+        ]);
+    });
+
+    it("should be able to create a mock answer that mirrors an existing SDP", async () => {
+        const mockPeer = await mockRTC.buildPeer().waitForNextMessage().thenSend('Goodbye');
+
+        const localConnection = new RTCPeerConnection();
+        const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+        const tracks = stream.getTracks();
+        localConnection.addTrack(tracks[0]);
+
+        const localOffer = await localConnection.createOffer();
+        await localConnection.setLocalDescription(localOffer);
+
+        const rawSdpToMirror = await (async () => {
+            // Wrapped in a function for clarity that this is separate, just for SDP setup:
+            const demoConn = new RTCPeerConnection();
+            demoConn.setRemoteDescription(localOffer);
+            demoConn.addTrack(tracks[0]);
+            return (await demoConn.createAnswer()).sdp!;
+        })();
+        const originalSdp = SDP.parse(rawSdpToMirror);
+
+        const { answer } = await mockPeer.answerOffer(localOffer, {
+            mirrorSDP: rawSdpToMirror
+        });
+        localConnection.setRemoteDescription(answer);
+
+        // Wait until the connection opens successfully:
+        await waitForState(localConnection, 'connected');
+
+        // The remote description we accepted should match the originally mirrored SDP:
+        const remoteDescription = localConnection.currentRemoteDescription;
+        const remoteMedia = SDP.parse(remoteDescription!.sdp).media;
+
+        expect(remoteMedia.map(m => [
+            m.mid, m.type, m.protocol, m.direction
+        ])).to.deep.equal([
+            [0, 'video', 'UDP/TLS/RTP/SAVPF', 'sendrecv']
+        ]);
+
+        // Check that the video has correct data in the fields that will be passed through when
+        // proxying (i.e. they're not linked to a specific peer, unlike the fingerprint etc).
+        const originalVideo = originalSdp.media[0];
+        const remoteAgreedVideo = remoteMedia[0];
+        ([
+            'msid',
+            'protocol',
+            'ext',
+            'payloads',
+            'ssrcs', // <-- Especially important, SSRC->mid is how both peers map RTP to track
+            'ssrcGroups',
+            'rtp',
+            'fmtp',
+            'rtcp',
+            'rtcpFb'
+        ] as const).forEach((field) => {
+            expect(remoteAgreedVideo[field]).to.deep.equal(originalVideo[field],
+                `Failed to mirror video ${field}`
+            );
+        });
+    });
+
+});

package/test/integration/echo-steps.spec.ts

@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Tim Perry <tim@httptoolkit.tech>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    MockRTC,
+    expect,
+    delay,
+    waitForChannelOpen
+} from '../test-setup';
+
+describe("Echo steps", function () {
+
+    const mockRTC = MockRTC.getRemote();
+
+    beforeEach(() => mockRTC.start());
+    afterEach(() => mockRTC.stop());
+
+    it("should be able to echo messages across multiple data channels", async () => {
+        const mockPeer = await mockRTC.buildPeer()
+            .thenEcho();
+
+        const localConnection = new RTCPeerConnection();
+        const dataChannel1 = localConnection.createDataChannel("dataChannel1");
+
+        const localOffer = await localConnection.createOffer();
+        await localConnection.setLocalDescription(localOffer);
+        const { answer } = await mockPeer.answerOffer(localOffer);
+        await localConnection.setRemoteDescription(answer);
+
+        let messages: Array<any> = [];
+        dataChannel1.addEventListener('message', (event) => messages.push("1: " + event.data));
+
+        await waitForChannelOpen(dataChannel1);
+        dataChannel1.send('Test message 1');
+
+        const dataChannel2 = localConnection.createDataChannel("dataChannel2");
+        dataChannel2.addEventListener('message', (event) => messages.push("2: " + event.data));
+        await waitForChannelOpen(dataChannel2);
+        await delay(10); // Delay to guarantee ordering
+        dataChannel2.send('Test message 2');
+
+        await delay(10); // Delay to guarantee ordering
+        dataChannel1.send('Test message 3');
+
+        await delay(50); // Delay to guarantee delivery
+
+        expect(messages).to.deep.equal([
+            '1: Test message 1',
+            '2: Test message 2',
+            '1: Test message 3',
+        ]);
+    });
+
+    it("should be able to echo media", async () => {
+        const mockPeer = await mockRTC.buildPeer()
+            .thenEcho();
+
+        // Create a connection to send & receive video:
+        const localConn = new RTCPeerConnection();
+        const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+        localConn.addTrack(stream.getTracks()[0], stream);
+
+        // Turn incoming tracks into readable streams of frames:
+        const mediaStreamPromise = new Promise<ReadableStream<VideoFrame>>((resolve) => {
+            localConn.addEventListener('track', ({ track }) => {
+                const streamProcessor = new MediaStreamTrackProcessor({
+                    track: track as MediaStreamVideoTrack
+                });
+                resolve(streamProcessor.readable);
+            });
+        });
+
+        // Complete the connection with the mock peer:
+        const localOffer = await localConn.createOffer({ offerToReceiveVideo: true });
+        await localConn.setLocalDescription(localOffer);
+        const { answer } = await mockPeer.answerOffer(localOffer);
+        await localConn.setRemoteDescription(answer);
+
+        // Check we receive the expected echoed video:
+        const localMedia = await mediaStreamPromise;
+        const { value: localFrame } = await localMedia!.getReader().read();
+        expect(localFrame!.displayHeight).to.be.greaterThanOrEqual(240);
+        expect(localFrame!.displayWidth).to.be.greaterThanOrEqual(320);
+    });
+
+});