mediasoup-client 3.7.0 → 3.7.2

package/lib/{tests → test}/test.js

@@ -37,15 +37,108 @@ const FakeHandler_1 = require("../handlers/FakeHandler");
 const fakeParameters = __importStar(require("./fakeParameters"));
 const uaTestCases_1 = require("./uaTestCases");
 const { Device, detectDevice, parseScalabilityMode, debug } = mediasoupClient;
-let device;
-let sendTransport;
-let recvTransport;
-let audioProducer;
-let videoProducer;
-let audioConsumer;
-let videoConsumer;
-let dataProducer;
-let dataConsumer;
+const ctx = {};
+beforeEach(async () => {
+    ctx.device = new Device({
+        handlerFactory: FakeHandler_1.FakeHandler.createFactory(fakeParameters),
+    });
+    ctx.loadedDevice = new Device({
+        handlerFactory: FakeHandler_1.FakeHandler.createFactory(fakeParameters),
+    });
+    const routerRtpCapabilities = fakeParameters.generateRouterRtpCapabilities();
+    // Only load loadedDevice.
+    await ctx.loadedDevice.load({ routerRtpCapabilities });
+    const { id, iceParameters, iceCandidates, dtlsParameters, sctpParameters } = fakeParameters.generateTransportRemoteParameters();
+    ctx.sendTransport = ctx.loadedDevice.createSendTransport({
+        id,
+        iceParameters,
+        iceCandidates,
+        dtlsParameters,
+        sctpParameters,
+    });
+    ctx.connectedSendTransport = ctx.loadedDevice.createSendTransport({
+        id,
+        iceParameters,
+        iceCandidates,
+        dtlsParameters,
+        sctpParameters,
+    });
+    ctx.connectedSendTransport.on('connect', 
+    // eslint-disable-next-line no-shadow, @typescript-eslint/no-unused-vars
+    ({ dtlsParameters }, callback /* errback */) => {
+        setTimeout(callback);
+    });
+    ctx.connectedSendTransport.on('produce', 
+    // eslint-disable-next-line no-shadow, @typescript-eslint/no-unused-vars
+    ({ kind, rtpParameters, appData }, callback /* errback */) => {
+        // eslint-disable-next-line no-shadow
+        const id = fakeParameters.generateProducerRemoteParameters().id;
+        setTimeout(() => callback({ id }));
+    });
+    ctx.connectedSendTransport.on('producedata', (
+    // eslint-disable-next-line no-shadow, @typescript-eslint/no-unused-vars
+    { sctpStreamParameters, label, protocol, appData }, callback /* errback */) => {
+        // eslint-disable-next-line no-shadow
+        const id = fakeParameters.generateDataProducerRemoteParameters().id;
+        setTimeout(() => callback({ id }));
+    });
+    ctx.recvTransport = ctx.loadedDevice.createRecvTransport({
+        id,
+        iceParameters,
+        iceCandidates,
+        dtlsParameters,
+        sctpParameters,
+    });
+    ctx.connectedRecvTransport = ctx.loadedDevice.createRecvTransport({
+        id,
+        iceParameters,
+        iceCandidates,
+        dtlsParameters,
+        sctpParameters,
+    });
+    ctx.connectedRecvTransport.on('connect', 
+    // eslint-disable-next-line no-shadow, @typescript-eslint/no-unused-vars
+    ({ dtlsParameters }, callback /* errback */) => {
+        setTimeout(callback);
+    });
+    const audioTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
+    ctx.audioProducer = await ctx.connectedSendTransport.produce({
+        track: audioTrack,
+        stopTracks: false,
+    });
+    const videoTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'video' });
+    ctx.videoProducer = await ctx.connectedSendTransport.produce({
+        track: videoTrack,
+    });
+    const audioConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'audio/opus',
+    });
+    ctx.audioConsumer = await ctx.connectedRecvTransport.consume({
+        id: audioConsumerRemoteParameters.id,
+        producerId: audioConsumerRemoteParameters.producerId,
+        kind: audioConsumerRemoteParameters.kind,
+        rtpParameters: audioConsumerRemoteParameters.rtpParameters,
+    });
+    const videoConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'video/VP8',
+    });
+    ctx.videoConsumer = await ctx.connectedRecvTransport.consume({
+        id: videoConsumerRemoteParameters.id,
+        producerId: videoConsumerRemoteParameters.producerId,
+        kind: videoConsumerRemoteParameters.kind,
+        rtpParameters: videoConsumerRemoteParameters.rtpParameters,
+    });
+    ctx.dataProducer = await ctx.connectedSendTransport.produceData({
+        ordered: false,
+        maxPacketLifeTime: 5555,
+    });
+    const dataConsumerRemoteParameters = fakeParameters.generateDataConsumerRemoteParameters();
+    ctx.dataConsumer = await ctx.connectedRecvTransport.consumeData({
+        id: dataConsumerRemoteParameters.id,
+        dataProducerId: dataConsumerRemoteParameters.dataProducerId,
+        sctpStreamParameters: dataConsumerRemoteParameters.sctpStreamParameters,
+    });
+});
 test('mediasoup-client exposes debug dependency', () => {
     expect(typeof debug).toBe('function');
 }, 500);
@@ -53,102 +146,89 @@ test('detectDevice() returns nothing in Node', () => {
     expect(detectDevice()).toBe(undefined);
 });
 test('create a Device in Node without custom handlerName/handlerFactory throws UnsupportedError', () => {
-    expect(() => new Device())
-        .toThrow(errors_1.UnsupportedError);
+    expect(() => new Device()).toThrow(errors_1.UnsupportedError);
 });
 test('create a Device with an unknown handlerName string throws TypeError', () => {
     // @ts-ignore
-    expect(() => new Device({ handlerName: 'FooBrowser666' }))
-        .toThrow(TypeError);
+    expect(() => new Device({ handlerName: 'FooBrowser666' })).toThrow(TypeError);
 });
 test('create a Device in Node with a valid handlerFactory succeeds', () => {
-    device = new Device({ handlerFactory: FakeHandler_1.FakeHandler.createFactory(fakeParameters) });
+    const device = new Device({
+        handlerFactory: FakeHandler_1.FakeHandler.createFactory(fakeParameters),
+    });
     expect(typeof device).toBe('object');
     expect(device.handlerName).toBe('FakeHandler');
     expect(device.loaded).toBe(false);
 });
 test('device.rtpCapabilities getter throws InvalidStateError if not loaded', () => {
-    expect(() => device.rtpCapabilities)
-        .toThrow(errors_1.InvalidStateError);
+    expect(() => ctx.device.rtpCapabilities).toThrow(errors_1.InvalidStateError);
 });
 test('device.sctpCapabilities getter throws InvalidStateError if not loaded', () => {
-    expect(() => device.sctpCapabilities)
-        .toThrow(errors_1.InvalidStateError);
+    expect(() => ctx.device.sctpCapabilities).toThrow(errors_1.InvalidStateError);
 });
 test('device.canProduce() throws InvalidStateError if not loaded', () => {
-    expect(() => device.canProduce('audio'))
-        .toThrow(errors_1.InvalidStateError);
+    expect(() => ctx.device.canProduce('audio')).toThrow(errors_1.InvalidStateError);
 });
 test('device.createSendTransport() throws InvalidStateError if not loaded', () => {
     const { id, iceParameters, iceCandidates, dtlsParameters, sctpParameters } = fakeParameters.generateTransportRemoteParameters();
-    expect(() => device.createSendTransport({
+    expect(() => ctx.device.createSendTransport({
         id,
         iceParameters,
         iceCandidates,
         dtlsParameters,
-        sctpParameters
-    }))
-        .toThrow(errors_1.InvalidStateError);
+        sctpParameters,
+    })).toThrow(errors_1.InvalidStateError);
 });
 test('device.load() without routerRtpCapabilities rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(device.load({}))
-        .rejects
-        .toThrow(TypeError);
-    expect(device.loaded).toBe(false);
+    await expect(ctx.device.load({})).rejects.toThrow(TypeError);
+    expect(ctx.device.loaded).toBe(false);
 }, 500);
 test('device.load() with invalid routerRtpCapabilities rejects with TypeError', async () => {
-    // Clonse fake router RTP capabilities to make them invalid.
+    // Clone fake router RTP capabilities to make them invalid.
     const routerRtpCapabilities = utils.clone(fakeParameters.generateRouterRtpCapabilities());
     for (const codec of routerRtpCapabilities.codecs) {
         // @ts-ignore
         delete codec.mimeType;
     }
-    await expect(device.load({ routerRtpCapabilities }))
-        .rejects
-        .toThrow(TypeError);
-    expect(device.loaded).toBe(false);
+    await expect(ctx.device.load({ routerRtpCapabilities })).rejects.toThrow(TypeError);
+    expect(ctx.device.loaded).toBe(false);
 }, 500);
 test('device.load() succeeds', async () => {
     // Assume we get the router RTP capabilities.
     const routerRtpCapabilities = fakeParameters.generateRouterRtpCapabilities();
-    await expect(device.load({ routerRtpCapabilities }))
-        .resolves
-        .toBe(undefined);
-    expect(device.loaded).toBe(true);
+    await expect(ctx.device.load({ routerRtpCapabilities })).resolves.toBe(undefined);
+    expect(ctx.device.loaded).toBe(true);
 }, 500);
 test('device.load() rejects with InvalidStateError if already loaded', async () => {
-    // @ts-ignore
-    await expect(device.load({}))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
-    expect(device.loaded).toBe(true);
+    const routerRtpCapabilities = fakeParameters.generateRouterRtpCapabilities();
+    await expect(ctx.loadedDevice.load({ routerRtpCapabilities })).rejects.toThrow(errors_1.InvalidStateError);
+    expect(ctx.loadedDevice.loaded).toBe(true);
 }, 500);
 test('device.rtpCapabilities getter succeeds', () => {
-    expect(typeof device.rtpCapabilities).toBe('object');
+    expect(typeof ctx.loadedDevice.rtpCapabilities).toBe('object');
 });
 test('device.sctpCapabilities getter succeeds', () => {
-    expect(typeof device.sctpCapabilities).toBe('object');
+    expect(typeof ctx.loadedDevice.sctpCapabilities).toBe('object');
 });
 test('device.canProduce() with "audio"/"video" kind returns true', () => {
-    expect(device.canProduce('audio')).toBe(true);
-    expect(device.canProduce('video')).toBe(true);
+    expect(ctx.loadedDevice.canProduce('audio')).toBe(true);
+    expect(ctx.loadedDevice.canProduce('video')).toBe(true);
 });
 test('device.canProduce() with invalid kind throws TypeError', () => {
     // @ts-ignore
-    expect(() => device.canProduce('chicken'))
-        .toThrow(TypeError);
+    expect(() => ctx.loadedDevice.canProduce('chicken')).toThrow(TypeError);
 });
 test('device.createSendTransport() for sending media succeeds', () => {
     // Assume we create a transport in the server and get its remote parameters.
     const { id, iceParameters, iceCandidates, dtlsParameters, sctpParameters } = fakeParameters.generateTransportRemoteParameters();
-    sendTransport = device.createSendTransport({
+    const sendTransport = ctx.loadedDevice.createSendTransport({
         id,
         iceParameters,
         iceCandidates,
         dtlsParameters,
         sctpParameters,
-        appData: { foo: 123 }
+        appData: { foo: 123 },
     });
     expect(typeof sendTransport).toBe('object');
     expect(sendTransport.id).toBe(id);
@@ -162,12 +242,12 @@ test('device.createSendTransport() for sending media succeeds', () => {
 test('device.createRecvTransport() for receiving media succeeds', () => {
     // Assume we create a transport in the server and get its remote parameters.
     const { id, iceParameters, iceCandidates, dtlsParameters, sctpParameters } = fakeParameters.generateTransportRemoteParameters();
-    recvTransport = device.createRecvTransport({
+    const recvTransport = ctx.loadedDevice.createRecvTransport({
         id,
         iceParameters,
         iceCandidates,
         dtlsParameters,
-        sctpParameters
+        sctpParameters,
     });
     expect(typeof recvTransport).toBe('object');
     expect(recvTransport.id).toBe(id);
@@ -180,95 +260,58 @@ test('device.createRecvTransport() for receiving media succeeds', () => {
 });
 test('device.createSendTransport() with missing remote Transport parameters throws TypeError', () => {
     // @ts-ignore
-    expect(() => device.createSendTransport({ id: '1234' }))
-        .toThrow(TypeError);
+    expect(() => ctx.loadedDevice.createSendTransport({ id: '1234' })).toThrow(TypeError);
+    expect(() => 
     // @ts-ignore
-    expect(() => device.createSendTransport({ id: '1234', iceParameters: {} }))
-        .toThrow(TypeError);
-    expect(() => device.createSendTransport({
+    ctx.loadedDevice.createSendTransport({ id: '1234', iceParameters: {} })).toThrow(TypeError);
+    expect(() => ctx.loadedDevice.createSendTransport({
         id: '1234',
         // @ts-ignore
         iceParameters: {},
-        iceCandidates: []
-    }))
-        .toThrow(TypeError);
+        iceCandidates: [],
+    })).toThrow(TypeError);
 });
 test('device.createRecvTransport() with a non object appData throws TypeError', () => {
     const { id, iceParameters, iceCandidates, dtlsParameters, sctpParameters } = fakeParameters.generateTransportRemoteParameters();
-    expect(() => device.createRecvTransport({
+    expect(() => ctx.loadedDevice.createRecvTransport({
         id,
         iceParameters,
         iceCandidates,
         dtlsParameters,
         sctpParameters,
         // @ts-ignore
-        appData: 1234
-    }))
-        .toThrow(TypeError);
+        appData: 1234,
+    })).toThrow(TypeError);
 });
-test('transport.produce() without "connect" listener rejects', async () => {
+test('transport.produce() without "produce" listener rejects', async () => {
     const audioTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
-    await expect(sendTransport.produce({ track: audioTrack }))
-        .rejects
-        .toThrow(Error);
+    ctx.sendTransport.removeAllListeners('produce');
+    await expect(ctx.sendTransport.produce({ track: audioTrack })).rejects.toThrow(Error);
 }, 500);
 test('transport.produce() succeeds', async () => {
     const audioTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
     const videoTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'video' });
-    let audioProducerId;
-    let videoProducerId;
     let connectEventNumTimesCalled = 0;
     let produceEventNumTimesCalled = 0;
-    // eslint-disable-next-line no-unused-vars
-    sendTransport.on('connect', ({ dtlsParameters }, callback /* errback */) => {
-        connectEventNumTimesCalled++;
-        expect(typeof dtlsParameters).toBe('object');
-        // Emulate communication with the server and success response (no response
-        // data needed).
-        setTimeout(callback);
-    });
-    // eslint-disable-next-line no-unused-vars
-    sendTransport.on('produce', ({ kind, rtpParameters, appData }, callback /* errback */) => {
-        produceEventNumTimesCalled++;
-        expect(typeof kind).toBe('string');
-        expect(typeof rtpParameters).toBe('object');
-        let id;
-        switch (kind) {
-            case 'audio':
-                {
-                    expect(appData).toEqual({ foo: 'FOO' });
-                    id = fakeParameters.generateProducerRemoteParameters().id;
-                    audioProducerId = id;
-                    break;
-                }
-            case 'video':
-                {
-                    expect(appData).toEqual({});
-                    id = fakeParameters.generateProducerRemoteParameters().id;
-                    videoProducerId = id;
-                    break;
-                }
-            default:
-                {
-                    throw new Error('unknown kind');
-                }
-        }
-        // Emulate communication with the server and success response with Producer
-        // remote parameters.
-        setTimeout(() => callback({ id }));
-    });
     let codecs;
     let headerExtensions;
     let encodings;
     let rtcp;
     // Pause the audio track before creating its Producer.
     audioTrack.enabled = false;
+    ctx.connectedSendTransport.prependListener('connect', () => ++connectEventNumTimesCalled);
+    ctx.connectedSendTransport.prependListener('produce', () => ++produceEventNumTimesCalled);
     // Use stopTracks: false.
-    audioProducer = await sendTransport.produce({ track: audioTrack, stopTracks: false, appData: { foo: 'FOO' } });
-    expect(connectEventNumTimesCalled).toBe(1);
+    const audioProducer = await ctx.connectedSendTransport.produce({
+        track: audioTrack,
+        stopTracks: false,
+        appData: { foo: 'FOO' },
+    });
+    // 'connect' event should not have been called since it was in beforeEach already.
+    expect(connectEventNumTimesCalled).toBe(0);
     expect(produceEventNumTimesCalled).toBe(1);
     expect(typeof audioProducer).toBe('object');
-    expect(audioProducer.id).toBe(audioProducerId);
+    expect(typeof audioProducer.id).toBe('string');
     expect(audioProducer.closed).toBe(false);
     expect(audioProducer.kind).toBe('audio');
     expect(audioProducer.track).toBe(audioTrack);
@@ -281,13 +324,11 @@ test('transport.produce() succeeds', async () => {
         payloadType: 111,
         clockRate: 48000,
         channels: 2,
-        rtcpFeedback: [
-            { type: 'transport-cc', parameter: '' }
-        ],
+        rtcpFeedback: [{ type: 'transport-cc', parameter: '' }],
         parameters: {
             minptime: 10,
-            useinbandfec: 1
-        }
+            useinbandfec: 1,
+        },
     });
     headerExtensions = audioProducer.rtpParameters.headerExtensions;
     expect(headerExtensions).toEqual([
@@ -295,14 +336,14 @@ test('transport.produce() succeeds', async () => {
             uri: 'urn:ietf:params:rtp-hdrext:sdes:mid',
             id: 1,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level',
             id: 10,
             encrypt: false,
-            parameters: {}
-        }
+            parameters: {},
+        },
     ]);
     encodings = audioProducer.rtpParameters.encodings;
     expect(Array.isArray(encodings)).toBe(true);
@@ -318,22 +359,19 @@ test('transport.produce() succeeds', async () => {
     expect(audioProducer.appData).toEqual({ foo: 'FOO' });
     // Reset the audio paused state.
     audioProducer.resume();
-    const videoEncodings = [
-        { maxBitrate: 100000 },
-        { maxBitrate: 500000 }
-    ];
+    const videoEncodings = [{ maxBitrate: 100000 }, { maxBitrate: 500000 }];
     // Note that stopTracks is not give so it's true by default.
     // Use disableTrackOnPause: false and zeroRtpOnPause: true
-    videoProducer = await sendTransport.produce({
+    const videoProducer = await ctx.connectedSendTransport.produce({
         track: videoTrack,
         encodings: videoEncodings,
         disableTrackOnPause: false,
-        zeroRtpOnPause: true
+        zeroRtpOnPause: true,
     });
-    expect(connectEventNumTimesCalled).toBe(1);
+    expect(connectEventNumTimesCalled).toBe(0);
     expect(produceEventNumTimesCalled).toBe(2);
     expect(typeof videoProducer).toBe('object');
-    expect(videoProducer.id).toBe(videoProducerId);
+    expect(typeof videoProducer.id).toBe('string');
     expect(videoProducer.closed).toBe(false);
     expect(videoProducer.kind).toBe('video');
     expect(videoProducer.track).toBe(videoTrack);
@@ -350,11 +388,11 @@ test('transport.produce() succeeds', async () => {
             { type: 'transport-cc', parameter: '' },
             { type: 'ccm', parameter: 'fir' },
             { type: 'nack', parameter: '' },
-            { type: 'nack', parameter: 'pli' }
+            { type: 'nack', parameter: 'pli' },
         ],
         parameters: {
-            baz: '1234abcd'
-        }
+            baz: '1234abcd',
+        },
     });
     expect(codecs[1]).toEqual({
         mimeType: 'video/rtx',
@@ -362,8 +400,8 @@ test('transport.produce() succeeds', async () => {
         clockRate: 90000,
         rtcpFeedback: [],
         parameters: {
-            apt: 96
-        }
+            apt: 96,
+        },
     });
     headerExtensions = videoProducer.rtpParameters.headerExtensions;
     expect(headerExtensions).toEqual([
@@ -371,32 +409,32 @@ test('transport.produce() succeeds', async () => {
             uri: 'urn:ietf:params:rtp-hdrext:sdes:mid',
             id: 1,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
             id: 3,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
             id: 5,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:3gpp:video-orientation',
             id: 4,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:ietf:params:rtp-hdrext:toffset',
             id: 2,
             encrypt: false,
-            parameters: {}
-        }
+            parameters: {},
+        },
     ]);
     encodings = videoProducer.rtpParameters.encodings;
     expect(Array.isArray(encodings)).toBe(true);
@@ -417,58 +455,47 @@ test('transport.produce() succeeds', async () => {
     expect(videoProducer.paused).toBe(false);
     expect(videoProducer.maxSpatialLayer).toBe(undefined);
     expect(videoProducer.appData).toEqual({});
-    sendTransport.removeAllListeners('connect');
-    sendTransport.removeAllListeners('produce');
 }, 500);
 test('transport.produce() without track rejects with TypeError', async () => {
-    await expect(sendTransport.produce({}))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.sendTransport.produce({})).rejects.toThrow(TypeError);
 }, 500);
 test('transport.produce() in a receiving Transport rejects with UnsupportedError', async () => {
     const track = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
-    await expect(recvTransport.produce({ track }))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
+    await expect(ctx.recvTransport.produce({ track })).rejects.toThrow(errors_1.UnsupportedError);
 }, 500);
 test('transport.produce() with an ended track rejects with InvalidStateError', async () => {
     const track = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
     track.stop();
-    await expect(sendTransport.produce({ track }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    await expect(ctx.sendTransport.produce({ track })).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.produce() with a non object appData rejects with TypeError', async () => {
     const track = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
+    await expect(
     // @ts-ignore
-    await expect(sendTransport.produce({ track, appData: true }))
-        .rejects
-        .toThrow(TypeError);
+    ctx.sendTransport.produce({ track, appData: true })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consume() succeeds', async () => {
-    const audioConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'audio/opus' });
-    const videoConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' });
-    let connectEventNumTimesCalled = 0;
-    // eslint-disable-next-line no-unused-vars
-    recvTransport.on('connect', ({ dtlsParameters }, callback /* errback */) => {
-        connectEventNumTimesCalled++;
-        expect(typeof dtlsParameters).toBe('object');
-        // Emulate communication with the server and success response (no response
-        // data needed).
-        setTimeout(callback);
+    const audioConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'audio/opus',
     });
+    const videoConsumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'video/VP8',
+    });
+    let connectEventNumTimesCalled = 0;
     let codecs;
     let headerExtensions;
     let encodings;
     let rtcp;
-    audioConsumer = await recvTransport.consume({
+    ctx.connectedRecvTransport.prependListener('connect', () => ++connectEventNumTimesCalled);
+    const audioConsumer = await ctx.connectedRecvTransport.consume({
         id: audioConsumerRemoteParameters.id,
         producerId: audioConsumerRemoteParameters.producerId,
         kind: audioConsumerRemoteParameters.kind,
         rtpParameters: audioConsumerRemoteParameters.rtpParameters,
-        appData: { bar: 'BAR' }
+        appData: { bar: 'BAR' },
     });
-    expect(connectEventNumTimesCalled).toBe(1);
+    // 'connect' event should not have been called since it was in beforeEach already.
+    expect(connectEventNumTimesCalled).toBe(0);
     expect(typeof audioConsumer).toBe('object');
     expect(audioConsumer.id).toBe(audioConsumerRemoteParameters.id);
     expect(audioConsumer.producerId).toBe(audioConsumerRemoteParameters.producerId);
@@ -484,13 +511,11 @@ test('transport.consume() succeeds', async () => {
         payloadType: 100,
         clockRate: 48000,
         channels: 2,
-        rtcpFeedback: [
-            { type: 'transport-cc', parameter: '' }
-        ],
+        rtcpFeedback: [{ type: 'transport-cc', parameter: '' }],
         parameters: {
             useinbandfec: 1,
-            foo: 'bar'
-        }
+            foo: 'bar',
+        },
     });
     headerExtensions = audioConsumer.rtpParameters.headerExtensions;
     expect(headerExtensions).toEqual([
@@ -498,20 +523,20 @@ test('transport.consume() succeeds', async () => {
             uri: 'urn:ietf:params:rtp-hdrext:sdes:mid',
             id: 1,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
             id: 5,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:ietf:params:rtp-hdrext:ssrc-audio-level',
             id: 10,
             encrypt: false,
-            parameters: {}
-        }
+            parameters: {},
+        },
     ]);
     encodings = audioConsumer.rtpParameters.encodings;
     expect(Array.isArray(encodings)).toBe(true);
@@ -519,18 +544,18 @@ test('transport.consume() succeeds', async () => {
     expect(typeof encodings?.[0]).toBe('object');
     expect(Object.keys(encodings[0])).toEqual(['ssrc', 'dtx']);
     expect(typeof encodings[0].ssrc).toBe('number');
-    rtcp = audioProducer.rtpParameters.rtcp;
+    rtcp = audioConsumer.rtpParameters.rtcp;
     expect(typeof rtcp).toBe('object');
     expect(typeof rtcp?.cname).toBe('string');
     expect(audioConsumer.paused).toBe(false);
     expect(audioConsumer.appData).toEqual({ bar: 'BAR' });
-    videoConsumer = await recvTransport.consume({
+    const videoConsumer = await ctx.connectedRecvTransport.consume({
         id: videoConsumerRemoteParameters.id,
         producerId: videoConsumerRemoteParameters.producerId,
         kind: videoConsumerRemoteParameters.kind,
-        rtpParameters: videoConsumerRemoteParameters.rtpParameters
+        rtpParameters: videoConsumerRemoteParameters.rtpParameters,
     });
-    expect(connectEventNumTimesCalled).toBe(1);
+    expect(connectEventNumTimesCalled).toBe(0);
     expect(typeof videoConsumer).toBe('object');
     expect(videoConsumer.id).toBe(videoConsumerRemoteParameters.id);
     expect(videoConsumer.producerId).toBe(videoConsumerRemoteParameters.producerId);
@@ -550,11 +575,11 @@ test('transport.consume() succeeds', async () => {
             { type: 'nack', parameter: 'pli' },
             { type: 'ccm', parameter: 'fir' },
             { type: 'goog-remb', parameter: '' },
-            { type: 'transport-cc', parameter: '' }
+            { type: 'transport-cc', parameter: '' },
         ],
         parameters: {
-            'x-google-start-bitrate': 1500
-        }
+            'x-google-start-bitrate': 1500,
+        },
     });
     expect(codecs[1]).toEqual({
         mimeType: 'video/rtx',
@@ -562,8 +587,8 @@ test('transport.consume() succeeds', async () => {
         clockRate: 90000,
         rtcpFeedback: [],
         parameters: {
-            apt: 101
-        }
+            apt: 101,
+        },
     });
     headerExtensions = videoConsumer.rtpParameters.headerExtensions;
     expect(headerExtensions).toEqual([
@@ -571,32 +596,32 @@ test('transport.consume() succeeds', async () => {
             uri: 'urn:ietf:params:rtp-hdrext:sdes:mid',
             id: 1,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time',
             id: 4,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01',
             id: 5,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:3gpp:video-orientation',
             id: 11,
             encrypt: false,
-            parameters: {}
+            parameters: {},
         },
         {
             uri: 'urn:ietf:params:rtp-hdrext:toffset',
             id: 12,
             encrypt: false,
-            parameters: {}
-        }
+            parameters: {},
+        },
     ]);
     encodings = videoConsumer.rtpParameters.encodings;
     expect(Array.isArray(encodings)).toBe(true);
@@ -612,15 +637,19 @@ test('transport.consume() succeeds', async () => {
     expect(typeof rtcp?.cname).toBe('string');
     expect(videoConsumer.paused).toBe(false);
     expect(videoConsumer.appData).toEqual({});
-    recvTransport.removeAllListeners('connect');
 }, 500);
 test('transport.consume() batches consumers created in same macrotask into the same task', async () => {
-    const videoConsumerRemoteParameters1 = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' });
-    const videoConsumerRemoteParameters2 = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' });
-    const pushSpy = jest.spyOn(recvTransport._awaitQueue, 'push');
+    const videoConsumerRemoteParameters1 = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'video/VP8',
+    });
+    const videoConsumerRemoteParameters2 = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'video/VP8',
+    });
+    // @ts-ignore
+    const pushSpy = jest.spyOn(ctx.connectedRecvTransport._awaitQueue, 'push');
     const waitForConsumer = (id) => {
-        return new Promise((resolve) => {
-            recvTransport.observer.on('newconsumer', (consumer) => {
+        return new Promise(resolve => {
+            ctx.connectedRecvTransport.observer.on('newconsumer', consumer => {
                 if (consumer.id === id) {
                     resolve();
                 }
@@ -629,114 +658,95 @@ test('transport.consume() batches consumers created in same macrotask into the s
     };
     const allConsumersCreated = Promise.all([
         waitForConsumer(videoConsumerRemoteParameters1.id),
-        waitForConsumer(videoConsumerRemoteParameters2.id)
+        waitForConsumer(videoConsumerRemoteParameters2.id),
     ]);
     await Promise.all([
-        recvTransport.consume({
+        ctx.connectedRecvTransport.consume({
             id: videoConsumerRemoteParameters1.id,
             producerId: videoConsumerRemoteParameters1.producerId,
             kind: videoConsumerRemoteParameters1.kind,
-            rtpParameters: videoConsumerRemoteParameters1.rtpParameters
+            rtpParameters: videoConsumerRemoteParameters1.rtpParameters,
         }),
-        recvTransport.consume({
+        ctx.connectedRecvTransport.consume({
             id: videoConsumerRemoteParameters2.id,
             producerId: videoConsumerRemoteParameters2.producerId,
             kind: videoConsumerRemoteParameters2.kind,
-            rtpParameters: videoConsumerRemoteParameters2.rtpParameters
-        })
+            rtpParameters: videoConsumerRemoteParameters2.rtpParameters,
+        }),
     ]);
     await allConsumersCreated;
     expect(pushSpy).toBeCalledTimes(1);
 }, 500);
 test('transport.consume() without remote Consumer parameters rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(recvTransport.consume({}))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.recvTransport.consume({})).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consume() with missing remote Consumer parameters rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(recvTransport.consume({ id: '1234' }))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.recvTransport.consume({ id: '1234' })).rejects.toThrow(TypeError);
+    await expect(
     // @ts-ignore
-    await expect(recvTransport.consume({ id: '1234', producerId: '4444' }))
-        .rejects
-        .toThrow(TypeError);
-    await expect(recvTransport.consume(
+    ctx.recvTransport.consume({ id: '1234', producerId: '4444' })).rejects.toThrow(TypeError);
+    await expect(ctx.recvTransport.consume(
     // @ts-ignore
     {
         id: '1234',
         producerId: '4444',
-        kind: 'audio'
-    }))
-        .rejects
-        .toThrow(TypeError);
-    await expect(recvTransport.consume(
+        kind: 'audio',
+    })).rejects.toThrow(TypeError);
+    await expect(ctx.recvTransport.consume(
     // @ts-ignore
     {
         id: '1234',
         producerId: '4444',
-        kind: 'audio'
-    }))
-        .rejects
-        .toThrow(TypeError);
+        kind: 'audio',
+    })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consume() in a sending Transport rejects with UnsupportedError', async () => {
-    const { id, producerId, kind, rtpParameters } = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'audio/opus' });
-    await expect(sendTransport.consume({
+    const { id, producerId, kind, rtpParameters } = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'audio/opus',
+    });
+    await expect(ctx.sendTransport.consume({
         id,
         producerId,
         kind,
-        rtpParameters
-    }))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
+        rtpParameters,
+    })).rejects.toThrow(errors_1.UnsupportedError);
 }, 500);
 test('transport.consume() with unsupported rtpParameters rejects with UnsupportedError', async () => {
-    const { id, producerId, kind, rtpParameters } = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'audio/ISAC' });
-    await expect(sendTransport.consume({
+    const { id, producerId, kind, rtpParameters } = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'audio/ISAC',
+    });
+    await expect(ctx.sendTransport.consume({
         id,
         producerId,
         kind,
-        rtpParameters
-    }))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
+        rtpParameters,
+    })).rejects.toThrow(errors_1.UnsupportedError);
 }, 500);
 test('transport.consume() with a non object appData rejects with TypeError', async () => {
-    const consumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'audio/opus' });
+    const consumerRemoteParameters = fakeParameters.generateConsumerRemoteParameters({
+        codecMimeType: 'audio/opus',
+    });
+    await expect(
     // @ts-ignore
-    await expect(recvTransport.consume({ consumerRemoteParameters, appData: true }))
-        .rejects
-        .toThrow(TypeError);
+    ctx.recvTransport.consume({ consumerRemoteParameters, appData: true })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.produceData() succeeds', async () => {
-    let dataProducerId;
     let produceDataEventNumTimesCalled = 0;
-    // eslint-disable-next-line no-unused-vars
-    sendTransport.on('producedata', ({ sctpStreamParameters, label, protocol, appData }, callback /* errback */) => {
+    ctx.connectedSendTransport.prependListener('producedata', () => {
         produceDataEventNumTimesCalled++;
-        expect(typeof sctpStreamParameters).toBe('object');
-        expect(label).toBe('FOO');
-        expect(protocol).toBe('BAR');
-        expect(appData).toEqual({ foo: 'FOO' });
-        const id = fakeParameters.generateDataProducerRemoteParameters().id;
-        dataProducerId = id;
-        // Emulate communication with the server and success response with Producer
-        // remote parameters.
-        setTimeout(() => callback({ id }));
     });
-    dataProducer = await sendTransport.produceData({
+    const dataProducer = await ctx.connectedSendTransport.produceData({
         ordered: false,
         maxPacketLifeTime: 5555,
         label: 'FOO',
         protocol: 'BAR',
-        appData: { foo: 'FOO' }
+        appData: { foo: 'FOO' },
     });
     expect(produceDataEventNumTimesCalled).toBe(1);
     expect(typeof dataProducer).toBe('object');
-    expect(dataProducer.id).toBe(dataProducerId);
+    expect(typeof dataProducer.id).toBe('string');
     expect(dataProducer.closed).toBe(false);
     expect(typeof dataProducer.sctpStreamParameters).toBe('object');
     expect(typeof dataProducer.sctpStreamParameters.streamId).toBe('number');
@@ -745,28 +755,24 @@ test('transport.produceData() succeeds', async () => {
     expect(dataProducer.sctpStreamParameters.maxRetransmits).toBe(undefined);
     expect(dataProducer.label).toBe('FOO');
     expect(dataProducer.protocol).toBe('BAR');
-    sendTransport.removeAllListeners('producedata');
 }, 500);
 test('transport.produceData() in a receiving Transport rejects with UnsupportedError', async () => {
-    await expect(recvTransport.produceData({}))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
+    await expect(ctx.recvTransport.produceData({})).rejects.toThrow(errors_1.UnsupportedError);
 }, 500);
 test('transport.produceData() with a non object appData rejects with TypeError', async () => {
+    await expect(
     // @ts-ignore
-    await expect(sendTransport.produceData({ appData: true }))
-        .rejects
-        .toThrow(TypeError);
+    ctx.sendTransport.produceData({ appData: true })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consumeData() succeeds', async () => {
     const dataConsumerRemoteParameters = fakeParameters.generateDataConsumerRemoteParameters();
-    dataConsumer = await recvTransport.consumeData({
+    const dataConsumer = await ctx.connectedRecvTransport.consumeData({
         id: dataConsumerRemoteParameters.id,
         dataProducerId: dataConsumerRemoteParameters.dataProducerId,
         sctpStreamParameters: dataConsumerRemoteParameters.sctpStreamParameters,
         label: 'FOO',
         protocol: 'BAR',
-        appData: { bar: 'BAR' }
+        appData: { bar: 'BAR' },
     });
     expect(typeof dataConsumer).toBe('object');
     expect(dataConsumer.id).toBe(dataConsumerRemoteParameters.id);
@@ -779,66 +785,52 @@ test('transport.consumeData() succeeds', async () => {
 }, 500);
 test('transport.consumeData() without remote DataConsumer parameters rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(recvTransport.consumeData({}))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.recvTransport.consumeData({})).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consumeData() with missing remote DataConsumer parameters rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(recvTransport.consumeData({ id: '1234' }))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.recvTransport.consumeData({ id: '1234' })).rejects.toThrow(TypeError);
+    await expect(
     // @ts-ignore
-    await expect(recvTransport.consumeData({ id: '1234', dataProducerId: '4444' }))
-        .rejects
-        .toThrow(TypeError);
+    ctx.recvTransport.consumeData({ id: '1234', dataProducerId: '4444' })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.consumeData() in a sending Transport rejects with UnsupportedError', async () => {
     const { id, dataProducerId, sctpStreamParameters } = fakeParameters.generateDataConsumerRemoteParameters();
-    await expect(sendTransport.consumeData({
+    await expect(ctx.sendTransport.consumeData({
         id,
         dataProducerId,
-        sctpStreamParameters
-    }))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
+        sctpStreamParameters,
+    })).rejects.toThrow(errors_1.UnsupportedError);
 }, 500);
 test('transport.consumeData() with a non object appData rejects with TypeError', async () => {
     const dataConsumerRemoteParameters = fakeParameters.generateDataConsumerRemoteParameters();
-    // @ts-ignore
-    await expect(recvTransport.consumeData({ dataConsumerRemoteParameters, appData: true }))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.recvTransport.consumeData({
+        dataConsumerRemoteParameters,
+        // @ts-ignore
+        appData: true,
+    })).rejects.toThrow(TypeError);
 }, 500);
 test('transport.getStats() succeeds', async () => {
-    const stats = await sendTransport.getStats();
+    const stats = await ctx.sendTransport.getStats();
     expect(typeof stats).toBe('object');
 }, 500);
 test('transport.restartIce() succeeds', async () => {
-    await expect(sendTransport.restartIce({
+    await expect(ctx.sendTransport.restartIce({
         iceParameters: {
             usernameFragment: 'foo',
-            password: 'xxx'
-        }
-    }))
-        .resolves
-        .toBe(undefined);
+            password: 'xxx',
+        },
+    })).resolves.toBe(undefined);
 }, 500);
 test('transport.restartIce() without remote iceParameters rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(sendTransport.restartIce({}))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.sendTransport.restartIce({})).rejects.toThrow(TypeError);
 }, 500);
 test('transport.updateIceServers() succeeds', async () => {
-    await expect(sendTransport.updateIceServers({ iceServers: [] }))
-        .resolves
-        .toBe(undefined);
+    await expect(ctx.sendTransport.updateIceServers({ iceServers: [] })).resolves.toBe(undefined);
 }, 500);
 test('transport.updateIceServers() without iceServers rejects with TypeError', async () => {
-    await expect(sendTransport.updateIceServers({}))
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.sendTransport.updateIceServers({})).rejects.toThrow(TypeError);
 }, 500);
 test('ICE gathering state change fires "icegatheringstatechange" in live Transport', () => {
     // NOTE: These tests are a bit flaky and we should isolate them. FakeHandler
@@ -846,341 +838,284 @@ test('ICE gathering state change fires "icegatheringstatechange" in live Transpo
     // private setupTransport() method is called (which has happens many times in
     // tests above already). So here we have to reset it manually to test things.
     // @ts-ignore
-    sendTransport.handler.setIceGatheringState('new');
+    ctx.sendTransport.handler.setIceGatheringState('new');
     // @ts-ignore
-    sendTransport.handler.setConnectionState('new');
+    ctx.sendTransport.handler.setConnectionState('new');
     let iceGatheringStateChangeEventNumTimesCalled = 0;
     let connectionStateChangeEventNumTimesCalled = 0;
-    sendTransport.on('icegatheringstatechange', (iceGatheringState) => {
+    ctx.sendTransport.on('icegatheringstatechange', iceGatheringState => {
         iceGatheringStateChangeEventNumTimesCalled++;
         expect(iceGatheringState).toBe('complete');
-        expect(sendTransport.iceGatheringState).toBe('complete');
-        expect(sendTransport.connectionState).toBe('new');
+        expect(ctx.sendTransport.iceGatheringState).toBe('complete');
+        expect(ctx.sendTransport.connectionState).toBe('new');
     });
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    sendTransport.on('connectionstatechange', (connectionState) => {
+    ctx.sendTransport.on('connectionstatechange', connectionState => {
         connectionStateChangeEventNumTimesCalled++;
     });
     // @ts-ignore
-    sendTransport.handler.setIceGatheringState('complete');
+    ctx.sendTransport.handler.setIceGatheringState('complete');
     expect(iceGatheringStateChangeEventNumTimesCalled).toBe(1);
     expect(connectionStateChangeEventNumTimesCalled).toBe(0);
-    expect(sendTransport.iceGatheringState).toBe('complete');
-    expect(sendTransport.connectionState).toBe('new');
-    sendTransport.removeAllListeners('icegatheringstatechange');
-    sendTransport.removeAllListeners('connectionstatechange');
+    expect(ctx.sendTransport.iceGatheringState).toBe('complete');
+    expect(ctx.sendTransport.connectionState).toBe('new');
 });
 test('connection state change fires "connectionstatechange" in live Transport', () => {
     let connectionStateChangeEventNumTimesCalled = 0;
-    sendTransport.on('connectionstatechange', (connectionState) => {
+    ctx.sendTransport.on('connectionstatechange', connectionState => {
         connectionStateChangeEventNumTimesCalled++;
         expect(connectionState).toBe('completed');
     });
     // @ts-ignore
-    sendTransport.handler.setConnectionState('completed');
+    ctx.sendTransport.handler.setConnectionState('completed');
     expect(connectionStateChangeEventNumTimesCalled).toBe(1);
-    expect(sendTransport.connectionState).toBe('completed');
-    sendTransport.removeAllListeners('connectionstatechange');
+    expect(ctx.sendTransport.connectionState).toBe('completed');
 });
 test('producer.pause() succeeds', () => {
-    videoProducer.pause();
-    expect(videoProducer.paused).toBe(true);
-    // Track will be still enabled due to disableTrackOnPause: false.
-    expect(videoProducer.track?.enabled).toBe(true);
+    ctx.videoProducer.pause();
+    expect(ctx.videoProducer.paused).toBe(true);
+    expect(ctx.videoProducer.track?.enabled).toBe(false);
 });
 test('producer.resume() succeeds', () => {
-    videoProducer.resume();
-    expect(videoProducer.paused).toBe(false);
-    expect(videoProducer.track?.enabled).toBe(true);
+    ctx.videoProducer.resume();
+    expect(ctx.videoProducer.paused).toBe(false);
+    expect(ctx.videoProducer.track?.enabled).toBe(true);
 });
 test('producer.replaceTrack() with a new track succeeds', async () => {
     // Have the audio Producer paused.
-    audioProducer.pause();
-    const audioProducerPreviousTrack = audioProducer.track;
+    ctx.audioProducer.pause();
+    const audioProducerPreviousTrack = ctx.audioProducer.track;
     const newAudioTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
-    await expect(audioProducer.replaceTrack({ track: newAudioTrack }))
-        .resolves
-        .toBe(undefined);
+    await expect(ctx.audioProducer.replaceTrack({ track: newAudioTrack })).resolves.toBe(undefined);
     // Previous track must be 'live' due to stopTracks: false.
     expect(audioProducerPreviousTrack?.readyState).toBe('live');
-    expect(audioProducer.track?.readyState).toBe('live');
-    expect(audioProducer.track).not.toBe(audioProducerPreviousTrack);
-    expect(audioProducer.track).toBe(newAudioTrack);
+    expect(ctx.audioProducer.track?.readyState).toBe('live');
+    expect(ctx.audioProducer.track).not.toBe(audioProducerPreviousTrack);
+    expect(ctx.audioProducer.track).toBe(newAudioTrack);
     // Producer was already paused.
-    expect(audioProducer.paused).toBe(true);
+    expect(ctx.audioProducer.paused).toBe(true);
     // Reset the audio paused state.
-    audioProducer.resume();
-    const videoProducerPreviousTrack = videoProducer.track;
+    ctx.audioProducer.resume();
+    const videoProducerPreviousTrack = ctx.videoProducer.track;
     const newVideoTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'video' });
-    await expect(videoProducer.replaceTrack({ track: newVideoTrack }))
-        .resolves
-        .toBe(undefined);
+    await expect(ctx.videoProducer.replaceTrack({ track: newVideoTrack })).resolves.toBe(undefined);
     // Previous track must be 'ended' due to stopTracks: true.
     expect(videoProducerPreviousTrack?.readyState).toBe('ended');
-    expect(videoProducer.track).not.toBe(videoProducerPreviousTrack);
-    expect(videoProducer.track).toBe(newVideoTrack);
-    expect(videoProducer.paused).toBe(false);
+    expect(ctx.videoProducer.track).not.toBe(videoProducerPreviousTrack);
+    expect(ctx.videoProducer.track).toBe(newVideoTrack);
+    expect(ctx.videoProducer.paused).toBe(false);
 }, 500);
 test('producer.replaceTrack() with null succeeds', async () => {
     // Have the audio Producer paused.
-    audioProducer.pause();
-    const audioProducerPreviousTrack = audioProducer.track;
-    await expect(audioProducer.replaceTrack({ track: null }))
-        .resolves
-        .toBe(undefined);
+    ctx.audioProducer.pause();
+    const audioProducerPreviousTrack = ctx.audioProducer.track;
+    await expect(ctx.audioProducer.replaceTrack({ track: null })).resolves.toBe(undefined);
     // Previous track must be 'live' due to stopTracks: false.
     expect(audioProducerPreviousTrack?.readyState).toBe('live');
-    expect(audioProducer.track).toBeNull();
+    expect(ctx.audioProducer.track).toBeNull();
     // Producer was already paused.
-    expect(audioProducer.paused).toBe(true);
+    expect(ctx.audioProducer.paused).toBe(true);
     // Reset the audio paused state.
-    audioProducer.resume();
-    expect(audioProducer.paused).toBe(false);
+    ctx.audioProducer.resume();
+    expect(ctx.audioProducer.paused).toBe(false);
     // Manually "mute" the original audio track.
     audioProducerPreviousTrack.enabled = false;
     // Set the original audio track back.
-    await expect(audioProducer.replaceTrack({ track: audioProducerPreviousTrack }))
-        .resolves
-        .toBe(undefined);
+    await expect(ctx.audioProducer.replaceTrack({ track: audioProducerPreviousTrack })).resolves.toBe(undefined);
     // The given audio track was muted but the Producer was not, so the track
     // must not be muted now.
-    expect(audioProducer.paused).toBe(false);
+    expect(ctx.audioProducer.paused).toBe(false);
     expect(audioProducerPreviousTrack?.enabled).toBe(true);
     // Reset the audio paused state.
-    audioProducer.resume();
+    ctx.audioProducer.resume();
 }, 500);
 test('producer.replaceTrack() with an ended track rejects with InvalidStateError', async () => {
     const track = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
     track.stop();
-    await expect(videoProducer.replaceTrack({ track }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    await expect(ctx.videoProducer.replaceTrack({ track })).rejects.toThrow(errors_1.InvalidStateError);
     expect(track.readyState).toBe('ended');
-    expect(videoProducer.track?.readyState).toBe('live');
+    expect(ctx.videoProducer.track?.readyState).toBe('live');
 }, 500);
 test('producer.replaceTrack() with the same track succeeds', async () => {
-    await expect(audioProducer.replaceTrack({ track: audioProducer.track }))
-        .resolves
-        .toBe(undefined);
-    expect(audioProducer.track?.readyState).toBe('live');
+    await expect(ctx.audioProducer.replaceTrack({ track: ctx.audioProducer.track })).resolves.toBe(undefined);
+    expect(ctx.audioProducer.track?.readyState).toBe('live');
 }, 500);
 test('producer.setMaxSpatialLayer() succeeds', async () => {
-    await expect(videoProducer.setMaxSpatialLayer(0))
-        .resolves
-        .toBe(undefined);
-    expect(videoProducer.maxSpatialLayer).toBe(0);
+    await expect(ctx.videoProducer.setMaxSpatialLayer(0)).resolves.toBe(undefined);
+    expect(ctx.videoProducer.maxSpatialLayer).toBe(0);
 }, 500);
 test('producer.setMaxSpatialLayer() in an audio Producer rejects with UnsupportedError', async () => {
-    await expect(audioProducer.setMaxSpatialLayer(1))
-        .rejects
-        .toThrow(errors_1.UnsupportedError);
-    expect(audioProducer.maxSpatialLayer).toBe(undefined);
+    await expect(ctx.audioProducer.setMaxSpatialLayer(1)).rejects.toThrow(errors_1.UnsupportedError);
+    expect(ctx.audioProducer.maxSpatialLayer).toBe(undefined);
 }, 500);
 test('producer.setMaxSpatialLayer() with invalid spatialLayer rejects with TypeError', async () => {
+    await expect(
     // @ts-ignore
-    await expect(videoProducer.setMaxSpatialLayer('chicken'))
-        .rejects
-        .toThrow(TypeError);
+    ctx.videoProducer.setMaxSpatialLayer('chicken')).rejects.toThrow(TypeError);
 }, 500);
 test('producer.setMaxSpatialLayer() without spatialLayer rejects with TypeError', async () => {
     // @ts-ignore
-    await expect(videoProducer.setMaxSpatialLayer())
-        .rejects
-        .toThrow(TypeError);
+    await expect(ctx.videoProducer.setMaxSpatialLayer()).rejects.toThrow(TypeError);
 }, 500);
 test('producer.setRtpEncodingParameters() succeeds', async () => {
-    await expect(videoProducer.setRtpEncodingParameters({ scaleResolutionDownBy: 2 }))
-        .resolves
-        .toBe(undefined);
-    expect(videoProducer.maxSpatialLayer).toBe(0);
+    await expect(ctx.videoProducer.setRtpEncodingParameters({ scaleResolutionDownBy: 2 })).resolves.toBe(undefined);
 }, 500);
 test('producer.getStats() succeeds', async () => {
-    const stats = await videoProducer.getStats();
+    const stats = await ctx.videoProducer.getStats();
     expect(typeof stats).toBe('object');
 }, 500);
 test('consumer.resume() succeeds', () => {
-    videoConsumer.resume();
-    expect(videoConsumer.paused).toBe(false);
+    ctx.videoConsumer.resume();
+    expect(ctx.videoConsumer.paused).toBe(false);
 });
 test('consumer.pause() succeeds', () => {
-    videoConsumer.pause();
-    expect(videoConsumer.paused).toBe(true);
+    ctx.videoConsumer.pause();
+    expect(ctx.videoConsumer.paused).toBe(true);
 });
 test('consumer.getStats() succeeds', async () => {
-    const stats = await videoConsumer.getStats();
+    const stats = await ctx.videoConsumer.getStats();
     expect(typeof stats).toBe('object');
 }, 500);
 test('producer.close() succeed', () => {
-    audioProducer.close();
-    expect(audioProducer.closed).toBe(true);
+    ctx.audioProducer.close();
+    expect(ctx.audioProducer.closed).toBe(true);
     // Track will be still 'live' due to stopTracks: false.
-    expect(audioProducer.track?.readyState).toBe('live');
+    expect(ctx.audioProducer.track?.readyState).toBe('live');
 });
 test('producer.replaceTrack() rejects with InvalidStateError if closed', async () => {
     const audioTrack = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
-    await expect(audioProducer.replaceTrack({ track: audioTrack }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.audioProducer.close();
+    await expect(ctx.audioProducer.replaceTrack({ track: audioTrack })).rejects.toThrow(errors_1.InvalidStateError);
     expect(audioTrack.readyState).toBe('live');
 }, 500);
 test('producer.getStats() rejects with InvalidStateError if closed', async () => {
-    await expect(audioProducer.getStats())
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.audioProducer.close();
+    await expect(ctx.audioProducer.getStats()).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('consumer.close() succeed', () => {
-    audioConsumer.close();
-    expect(audioConsumer.closed).toBe(true);
-    expect(audioConsumer.track.readyState).toBe('ended');
+    ctx.audioConsumer.close();
+    expect(ctx.audioConsumer.closed).toBe(true);
+    expect(ctx.audioConsumer.track.readyState).toBe('ended');
 });
 test('consumer.getStats() rejects with InvalidStateError if closed', async () => {
-    await expect(audioConsumer.getStats())
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.audioConsumer.close();
+    await expect(ctx.audioConsumer.getStats()).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('dataProducer.close() succeed', () => {
-    dataProducer.close();
-    expect(dataProducer.closed).toBe(true);
+    ctx.dataProducer.close();
+    expect(ctx.dataProducer.closed).toBe(true);
 });
 test('dataConsumer.close() succeed', () => {
-    dataConsumer.close();
-    expect(dataConsumer.closed).toBe(true);
+    ctx.dataConsumer.close();
+    expect(ctx.dataConsumer.closed).toBe(true);
 });
 test('remotetely stopped track fires "trackended" in live Producers/Consumers', () => {
     let audioProducerTrackendedEventCalled = false;
     let videoProducerTrackendedEventCalled = false;
     let audiosConsumerTrackendedEventCalled = false;
     let videoConsumerTrackendedEventCalled = false;
-    audioProducer.on('trackended', () => {
+    ctx.audioProducer.on('trackended', () => {
         audioProducerTrackendedEventCalled = true;
     });
-    videoProducer.on('trackended', () => {
+    ctx.videoProducer.on('trackended', () => {
         videoProducerTrackendedEventCalled = true;
     });
-    audioConsumer.on('trackended', () => {
+    ctx.audioConsumer.on('trackended', () => {
         audiosConsumerTrackendedEventCalled = true;
     });
-    videoConsumer.on('trackended', () => {
+    ctx.videoConsumer.on('trackended', () => {
         videoConsumerTrackendedEventCalled = true;
     });
     // @ts-ignore
-    audioProducer.track.remoteStop();
-    // Audio Producer was already closed.
-    expect(audioProducerTrackendedEventCalled).toBe(false);
+    ctx.audioProducer.track.remoteStop();
+    expect(audioProducerTrackendedEventCalled).toBe(true);
+    // Let's close the video producer.
+    ctx.videoProducer.close();
     // @ts-ignore
-    videoProducer.track.remoteStop();
-    expect(videoProducerTrackendedEventCalled).toBe(true);
+    ctx.videoProducer.track.remoteStop();
+    expect(videoProducerTrackendedEventCalled).toBe(false);
     // @ts-ignore
-    audioConsumer.track.remoteStop();
-    // Audio Consumer was already closed.
-    expect(audiosConsumerTrackendedEventCalled).toBe(false);
+    ctx.audioConsumer.track.remoteStop();
+    expect(audiosConsumerTrackendedEventCalled).toBe(true);
     // @ts-ignore
-    videoConsumer.track.remoteStop();
+    ctx.videoConsumer.track.remoteStop();
     expect(videoConsumerTrackendedEventCalled).toBe(true);
-    audioProducer.removeAllListeners();
-    videoProducer.removeAllListeners();
-    audioConsumer.removeAllListeners();
-    videoConsumer.removeAllListeners();
 });
 test('transport.close() fires "transportclose" in live Producers/Consumers', () => {
     let audioProducerTransportcloseEventCalled = false;
     let videoProducerTransportcloseEventCalled = false;
     let audioConsumerTransportcloseEventCalled = false;
     let videoConsumerTransportcloseEventCalled = false;
-    audioProducer.on('transportclose', () => {
+    ctx.audioProducer.on('transportclose', () => {
         audioProducerTransportcloseEventCalled = true;
     });
-    videoProducer.on('transportclose', () => {
+    ctx.videoProducer.on('transportclose', () => {
         videoProducerTransportcloseEventCalled = true;
     });
-    audioConsumer.on('transportclose', () => {
+    ctx.audioConsumer.on('transportclose', () => {
         audioConsumerTransportcloseEventCalled = true;
     });
-    videoConsumer.on('transportclose', () => {
+    ctx.videoConsumer.on('transportclose', () => {
         videoConsumerTransportcloseEventCalled = true;
     });
-    // Audio Producer was already closed.
-    expect(audioProducer.closed).toBe(true);
-    expect(videoProducer.closed).toBe(false);
-    sendTransport.close();
-    expect(sendTransport.closed).toBe(true);
-    expect(videoProducer.closed).toBe(true);
-    // Audio Producer was already closed.
-    expect(audioProducerTransportcloseEventCalled).toBe(false);
+    ctx.connectedSendTransport.close();
+    expect(ctx.connectedSendTransport.closed).toBe(true);
+    expect(ctx.videoProducer.closed).toBe(true);
+    expect(audioProducerTransportcloseEventCalled).toBe(true);
     expect(videoProducerTransportcloseEventCalled).toBe(true);
-    // Audio Consumer was already closed.
-    expect(audioConsumer.closed).toBe(true);
-    expect(videoConsumer.closed).toBe(false);
-    recvTransport.close();
-    expect(recvTransport.closed).toBe(true);
-    expect(videoConsumer.closed).toBe(true);
-    // Audio Consumer was already closed.
-    expect(audioConsumerTransportcloseEventCalled).toBe(false);
-    expect(videoConsumerTransportcloseEventCalled).toBe(true);
-    audioProducer.removeAllListeners();
-    videoProducer.removeAllListeners();
-    audioConsumer.removeAllListeners();
-    videoConsumer.removeAllListeners();
+    // Let's close the video consumer.
+    ctx.videoConsumer.close();
+    ctx.connectedRecvTransport.close();
+    expect(ctx.connectedRecvTransport.closed).toBe(true);
+    expect(ctx.videoConsumer.closed).toBe(true);
+    expect(audioConsumerTransportcloseEventCalled).toBe(true);
+    expect(videoConsumerTransportcloseEventCalled).toBe(false);
 });
 test('transport.produce() rejects with InvalidStateError if closed', async () => {
     const track = new fake_mediastreamtrack_1.FakeMediaStreamTrack({ kind: 'audio' });
-    // Add noop listener to avoid the method fail.
-    sendTransport.on('produce', () => { });
-    await expect(sendTransport.produce({ track, stopTracks: false }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.connectedSendTransport.close();
+    await expect(ctx.connectedSendTransport.produce({ track, stopTracks: false })).rejects.toThrow(errors_1.InvalidStateError);
     // The track must be 'live' due to stopTracks: false.
     expect(track.readyState).toBe('live');
-    sendTransport.removeAllListeners('produce');
 }, 500);
 test('transport.consume() rejects with InvalidStateError if closed', async () => {
+    ctx.connectedRecvTransport.close();
     // @ts-ignore
-    await expect(recvTransport.consume({}))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
-    recvTransport.removeAllListeners();
+    await expect(ctx.connectedRecvTransport.consume({})).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.produceData() rejects with InvalidStateError if closed', async () => {
-    // Add noop listener to avoid the method fail.
-    sendTransport.on('producedata', () => { });
-    await expect(sendTransport.produceData({}))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
-    sendTransport.removeAllListeners('producedata');
+    ctx.connectedSendTransport.close();
+    await expect(ctx.connectedSendTransport.produceData({})).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.consumeData() rejects with InvalidStateError if closed', async () => {
+    ctx.connectedRecvTransport.close();
     // @ts-ignore
-    await expect(recvTransport.consumeData({}))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    await expect(ctx.connectedRecvTransport.consumeData({})).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.getStats() rejects with InvalidStateError if closed', async () => {
-    await expect(sendTransport.getStats())
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.connectedSendTransport.close();
+    await expect(ctx.connectedSendTransport.getStats()).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.restartIce() rejects with InvalidStateError if closed', async () => {
+    ctx.connectedSendTransport.close();
+    await expect(
     // @ts-ignore
-    await expect(sendTransport.restartIce({ ieParameters: {} }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.connectedSendTransport.restartIce({ ieParameters: {} })).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('transport.updateIceServers() rejects with InvalidStateError if closed', async () => {
-    await expect(sendTransport.updateIceServers({ iceServers: [] }))
-        .rejects
-        .toThrow(errors_1.InvalidStateError);
+    ctx.connectedSendTransport.close();
+    await expect(ctx.connectedSendTransport.updateIceServers({ iceServers: [] })).rejects.toThrow(errors_1.InvalidStateError);
 }, 500);
 test('connection state change does not fire "connectionstatechange" in closed Transport', () => {
     let connectionStateChangeEventNumTimesCalled = 0;
-    // eslint-disable-next-line no-unused-vars
-    sendTransport.on('connectionstatechange', ( /* connectionState */) => {
+    ctx.connectedSendTransport.on('connectionstatechange', ( /* connectionState */) => {
         connectionStateChangeEventNumTimesCalled++;
     });
+    ctx.connectedSendTransport.close();
     // @ts-ignore
-    sendTransport.handler.setConnectionState('disconnected');
+    ctx.connectedSendTransport.handler.setConnectionState('disconnected');
     expect(connectionStateChangeEventNumTimesCalled).toBe(0);
-    expect(sendTransport.connectionState).toBe('disconnected');
-    sendTransport.removeAllListeners('connectionstatechange');
+    expect(ctx.connectedSendTransport.connectionState).toBe('disconnected');
 });
 test('RemoteSdp properly handles multiple streams of the same type in planB', async () => {
     let sdp = undefined;
@@ -1189,9 +1124,11 @@ test('RemoteSdp properly handles multiple streams of the same type in planB', as
     await remoteSdp.receive({
         mid: 'video',
         kind: 'video',
-        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' }).rtpParameters,
+        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({
+            codecMimeType: 'video/VP8',
+        }).rtpParameters,
         streamId: 'streamId-1',
-        trackId: 'trackId-1'
+        trackId: 'trackId-1',
     });
     sdp = remoteSdp.getSdp();
     sdpObject = sdpTransform.parse(sdp);
@@ -1206,9 +1143,11 @@ test('RemoteSdp properly handles multiple streams of the same type in planB', as
     await remoteSdp.receive({
         mid: 'video',
         kind: 'video',
-        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/H264' }).rtpParameters,
+        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({
+            codecMimeType: 'video/H264',
+        }).rtpParameters,
         streamId: 'streamId-2',
-        trackId: 'trackId-2'
+        trackId: 'trackId-2',
     });
     sdp = remoteSdp.getSdp();
     sdpObject = sdpTransform.parse(sdp);
@@ -1226,7 +1165,9 @@ test('RemoteSdp properly handles multiple streams of the same type in planB', as
     expect(sdpObject.media[0].ssrcs?.length).toBe(8);
     await remoteSdp.planBStopReceiving({
         mid: 'video',
-        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/H264' }).rtpParameters
+        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({
+            codecMimeType: 'video/H264',
+        }).rtpParameters,
     });
     sdp = remoteSdp.getSdp();
     sdpObject = sdpTransform.parse(sdp);
@@ -1250,9 +1191,11 @@ test('RemoteSdp does not duplicate codec descriptions', async () => {
     await remoteSdp.receive({
         mid: 'video',
         kind: 'video',
-        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' }).rtpParameters,
+        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({
+            codecMimeType: 'video/VP8',
+        }).rtpParameters,
         streamId: 'streamId-1',
-        trackId: 'trackId-1'
+        trackId: 'trackId-1',
     });
     sdp = remoteSdp.getSdp();
     sdpObject = sdpTransform.parse(sdp);
@@ -1267,9 +1210,11 @@ test('RemoteSdp does not duplicate codec descriptions', async () => {
     await remoteSdp.receive({
         mid: 'video',
         kind: 'video',
-        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({ codecMimeType: 'video/VP8' }).rtpParameters,
+        offerRtpParameters: fakeParameters.generateConsumerRemoteParameters({
+            codecMimeType: 'video/VP8',
+        }).rtpParameters,
         streamId: 'streamId-1',
-        trackId: 'trackId-1'
+        trackId: 'trackId-1',
     });
     sdp = remoteSdp.getSdp();
     sdpObject = sdpTransform.parse(sdp);
@@ -1283,25 +1228,51 @@ test('RemoteSdp does not duplicate codec descriptions', async () => {
     expect(sdpObject.media[0].ssrcs?.length).toBe(8);
 }, 500);
 test('parseScalabilityMode() works', () => {
-    expect(parseScalabilityMode('L1T3')).toEqual({ spatialLayers: 1, temporalLayers: 3 });
-    expect(parseScalabilityMode('L3T2_KEY')).toEqual({ spatialLayers: 3, temporalLayers: 2 });
-    expect(parseScalabilityMode('S2T3')).toEqual({ spatialLayers: 2, temporalLayers: 3 });
-    expect(parseScalabilityMode('foo')).toEqual({ spatialLayers: 1, temporalLayers: 1 });
-    expect(parseScalabilityMode()).toEqual({ spatialLayers: 1, temporalLayers: 1 });
-    expect(parseScalabilityMode('S0T3')).toEqual({ spatialLayers: 1, temporalLayers: 1 });
-    expect(parseScalabilityMode('S1T0')).toEqual({ spatialLayers: 1, temporalLayers: 1 });
-    expect(parseScalabilityMode('L20T3')).toEqual({ spatialLayers: 20, temporalLayers: 3 });
-    expect(parseScalabilityMode('S200T3')).toEqual({ spatialLayers: 1, temporalLayers: 1 });
+    expect(parseScalabilityMode('L1T3')).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 3,
+    });
+    expect(parseScalabilityMode('L3T2_KEY')).toEqual({
+        spatialLayers: 3,
+        temporalLayers: 2,
+    });
+    expect(parseScalabilityMode('S2T3')).toEqual({
+        spatialLayers: 2,
+        temporalLayers: 3,
+    });
+    expect(parseScalabilityMode('foo')).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 1,
+    });
+    expect(parseScalabilityMode()).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 1,
+    });
+    expect(parseScalabilityMode('S0T3')).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 1,
+    });
+    expect(parseScalabilityMode('S1T0')).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 1,
+    });
+    expect(parseScalabilityMode('L20T3')).toEqual({
+        spatialLayers: 20,
+        temporalLayers: 3,
+    });
+    expect(parseScalabilityMode('S200T3')).toEqual({
+        spatialLayers: 1,
+        temporalLayers: 1,
+    });
 });
 describe('detectDevice() assigns proper handler based on UserAgent', () => {
     const originalNavigator = global.navigator;
     for (const uaTestCase of uaTestCases_1.uaTestCases) {
         test(uaTestCase.desc, () => {
             // @ts-ignore
-            global.navigator =
-                {
-                    userAgent: uaTestCase.ua
-                };
+            global.navigator = {
+                userAgent: uaTestCase.ua,
+            };
             const originalRTCRtpTransceiver = global.RTCRtpTransceiver;
             if (uaTestCase.expect === 'Safari12') {
                 global.RTCRtpTransceiver = class Dummy {