@fishjam-cloud/webrtc-client 0.14.0

package/dist/webrtc-client/tests/events/connectedEvent.test.js

@@ -0,0 +1,70 @@
+import { faker } from '@faker-js/faker';
+import { expect, it, vi } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createConnectedEvent, createEmptyEndpoint, createTrackWithSimulcast, exampleTrackId } from '../fixtures';
+it('Connecting to empty room produce event', () => new Promise((done) => {
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEvent();
+    webRTCEndpoint.on('connected', (peerId, _peersInRoom) => {
+        expect(connected.endpointId).toBe(peerId);
+        expect(Object.keys(connected.endpointIdToEndpoint).length).toBe(1);
+        done('');
+    });
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+}));
+it('Connecting to empty room set internal state', () => () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    // When
+    const connected = createConnectedEvent();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    // Then
+    const localEndpointId = webRTCEndpoint['getEndpointId']();
+    expect(localEndpointId).toBe(connected.endpointId);
+});
+it('Connecting to room with one peer', () => new Promise((done) => {
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEvent();
+    connected.endpointIdToEndpoint = {
+        ...connected.endpointIdToEndpoint,
+        [faker.string.uuid()]: createEmptyEndpoint(),
+    };
+    webRTCEndpoint.on('connected', (peerId, _peersInRoom) => {
+        expect(connected.endpointId).toBe(peerId);
+        expect(Object.keys(connected.endpointIdToEndpoint).length).toBe(2);
+        done('');
+    });
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+}));
+it('Connecting to room with one peer with one track', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const trackAddedCallback = vi.fn((_x) => null);
+    const connectedCallback = vi.fn((_peerId, _peersInRoom) => null);
+    const connected = createConnectedEvent();
+    const otherEndpoint = createEmptyEndpoint();
+    otherEndpoint.trackIdToTrack = { [exampleTrackId]: createTrackWithSimulcast() };
+    connected.endpointIdToEndpoint = {
+        ...connected.endpointIdToEndpoint,
+        [faker.string.uuid()]: otherEndpoint,
+    };
+    webRTCEndpoint.on('connected', (peerId, remotePeersInRoom) => {
+        connectedCallback(peerId, remotePeersInRoom);
+        expect(peerId).toBe(connected.endpointId);
+        expect(remotePeersInRoom.length).toBe(1);
+    });
+    webRTCEndpoint.on('trackAdded', (ctx) => {
+        trackAddedCallback(ctx);
+        expect(ctx.trackId).toBe(exampleTrackId);
+        expect(ctx.simulcastConfig?.enabled).toBe(otherEndpoint.trackIdToTrack[exampleTrackId].simulcastConfig?.enabled);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    // Then
+    const remoteTracks = webRTCEndpoint.getRemoteTracks();
+    expect(Object.values(remoteTracks).length).toBe(1);
+    expect(trackAddedCallback.mock.calls).toHaveLength(1);
+    expect(connectedCallback.mock.calls).toHaveLength(1);
+}));

package/dist/webrtc-client/tests/events/encodingSwitchedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/encodingSwitchedEvent.test.js

@@ -0,0 +1,60 @@
+import { expect, it } from 'vitest';
+import { Variant, WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createEncodingSwitchedEvent, exampleEndpointId, exampleTrackId, notExistingEndpointId, notExistingTrackId, } from '../fixtures';
+import { setupRoom } from '../utils';
+it('Change existing track encoding', () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const initialTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(initialTrackEncoding).toBe(undefined);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        trackVariantSwitched: createEncodingSwitchedEvent(exampleEndpointId, exampleTrackId, Variant.VARIANT_MEDIUM),
+    }));
+    // Then
+    const finalTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(finalTrackEncoding).toBe(Variant.VARIANT_MEDIUM);
+});
+it('Changing track encoding when endpoint exist but track does not exist', () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const initialTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(initialTrackEncoding).toBe(undefined);
+    // When
+    expect(() => webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        trackVariantSwitched: createEncodingSwitchedEvent(exampleEndpointId, notExistingTrackId, Variant.VARIANT_MEDIUM),
+    }))).rejects.toThrow(`Track ${notExistingTrackId} not found`);
+});
+it('Changing track encoding when endpoint does not exist but track exist in other endpoint', () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const initialTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(initialTrackEncoding).toBe(undefined);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        trackVariantSwitched: createEncodingSwitchedEvent(notExistingEndpointId, exampleTrackId, Variant.VARIANT_MEDIUM),
+    }));
+    // Then
+    const finalTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(finalTrackEncoding).toBe(Variant.VARIANT_MEDIUM);
+});
+it('Change existing track encoding produces event', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const initialTrackEncoding = webRTCEndpoint.getRemoteTracks()[exampleTrackId].encoding;
+    expect(initialTrackEncoding).toBe(undefined);
+    webRTCEndpoint.getRemoteTracks()[exampleTrackId].on('encodingChanged', (context) => {
+        // Then
+        expect(context.encoding).toBe(Variant.VARIANT_MEDIUM);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        trackVariantSwitched: createEncodingSwitchedEvent(exampleEndpointId, exampleTrackId, Variant.VARIANT_MEDIUM),
+    }));
+}));

package/dist/webrtc-client/tests/events/endpointAddedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/endpointAddedEvent.test.js

@@ -0,0 +1,57 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createConnectedEvent, createConnectedEventWithOneEndpoint, createEndpointAdded, exampleEndpointId, } from '../fixtures';
+import { mockRTCPeerConnection } from '../mocks';
+it('Add endpoint to empty state', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEvent() }));
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointAdded: createEndpointAdded(exampleEndpointId) }));
+    // Then
+    const endpoints = webRTCEndpoint.getRemoteEndpoints();
+    expect(Object.values(endpoints).length).toBe(1);
+});
+it('Add another endpoint', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint() }));
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointAdded: createEndpointAdded(exampleEndpointId) }));
+    // Then
+    const endpoints = webRTCEndpoint.getRemoteEndpoints();
+    expect(Object.values(endpoints).length).toBe(2);
+});
+it('Add endpoint produces event', () => new Promise((done) => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint() }));
+    const endpointAdded = createEndpointAdded(exampleEndpointId);
+    webRTCEndpoint.on('endpointAdded', (endpoint) => {
+        // Then
+        expect(endpoint.id).toBe(endpointAdded.endpointId);
+        expect(endpoint.metadata).toBe(undefined);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointAdded }));
+}));
+it('Parses the metadata', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEvent() }));
+    const metadata = {
+        goodStuff: 'ye',
+    };
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointAdded: createEndpointAdded(exampleEndpointId, metadata) }));
+    // Then
+    const endpoints = webRTCEndpoint.getRemoteEndpoints();
+    const addedEndpoint = endpoints[exampleEndpointId];
+    expect(addedEndpoint.metadata).toEqual(metadata);
+});

package/dist/webrtc-client/tests/events/endpointRemovedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/endpointRemovedEvent.test.js

@@ -0,0 +1,64 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createConnectedEventWithOneEndpoint, createEndpointRemoved, exampleEndpointId, exampleTrackId, notExistingEndpointId, } from '../fixtures';
+import { mockRTCPeerConnection } from '../mocks';
+import { setupRoom } from '../utils';
+it('Remove the endpoint that does not exist', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint(exampleEndpointId) }));
+    // When
+    expect(() => webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(notExistingEndpointId) })))
+        // Then
+        .rejects.toThrow(`Endpoint ${notExistingEndpointId} not found`);
+});
+it('Remove current peer', () => new Promise((done) => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const currentPeerId = 'currentPeerId';
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint(exampleEndpointId, currentPeerId) }));
+    webRTCEndpoint.on('disconnected', () => {
+        // Then
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(currentPeerId) }));
+}));
+it('Remove existing endpoint should remove it from remote endpoints', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint(exampleEndpointId) }));
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }));
+    // Then
+    const endpoints = webRTCEndpoint.getRemoteEndpoints();
+    expect(Object.values(endpoints).length).toBe(0);
+});
+it('Remove existing endpoint should remove all tracks', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }));
+    // Then
+    const tracks = webRTCEndpoint.getRemoteTracks();
+    expect(Object.values(tracks).length).toBe(0);
+});
+it('Remove existing endpoint should emit trackRemoved event', () => new Promise((done) => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    webRTCEndpoint.on('trackRemoved', (trackContext) => {
+        // Then
+        expect(trackContext.trackId).toBe(exampleTrackId);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointRemoved: createEndpointRemoved(exampleEndpointId) }));
+}));

package/dist/webrtc-client/tests/events/endpointUpdatedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/endpointUpdatedEvent.test.js

@@ -0,0 +1,78 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createConnectedEvent, createConnectedEventWithOneEndpoint, createEndpointUpdatedPeerMetadata, exampleEndpointId, notExistingEndpointId, } from '../fixtures';
+import { mockRTCPeerConnection } from '../mocks';
+it('Update existing endpoint metadata', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEventWithOneEndpoint(exampleEndpointId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    // When
+    const metadata = {
+        newField: 'new field value',
+    };
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointUpdated: createEndpointUpdatedPeerMetadata(exampleEndpointId, metadata) }));
+    // Then
+    const endpoint = webRTCEndpoint.getRemoteEndpoints()[exampleEndpointId];
+    expect(endpoint.metadata).toMatchObject(metadata);
+});
+it('Update existing endpoint produce event', () => new Promise((done) => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint(exampleEndpointId) }));
+    const metadata = {
+        newField: 'new field value',
+    };
+    webRTCEndpoint.on('endpointUpdated', (endpoint) => {
+        // Then
+        expect(endpoint.metadata).toMatchObject(metadata);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointUpdated: createEndpointUpdatedPeerMetadata(exampleEndpointId, metadata) }));
+}));
+it('Update existing endpoint with undefined metadata', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connectedMediaEvent = createConnectedEventWithOneEndpoint(exampleEndpointId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: connectedMediaEvent }));
+    // When
+    const metadata = undefined;
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointUpdated: createEndpointUpdatedPeerMetadata(exampleEndpointId, metadata) }));
+    // Then
+    const endpoint = webRTCEndpoint.getRemoteEndpoints()[exampleEndpointId];
+    expect(endpoint.metadata).toBe(undefined);
+});
+it('Update endpoint that not exist', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: createConnectedEvent() }));
+    // When
+    const metadata = {
+        newField: 'new field value',
+    };
+    expect(() => webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        endpointUpdated: createEndpointUpdatedPeerMetadata(notExistingEndpointId, metadata),
+    }))).rejects.toThrow(`Endpoint ${notExistingEndpointId} not found`);
+});
+it('Parse metadata on endpoint update', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connectedMediaEvent = createConnectedEventWithOneEndpoint(exampleEndpointId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: connectedMediaEvent }));
+    // When
+    const metadata = {
+        goodStuff: 'ye',
+    };
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ endpointUpdated: createEndpointUpdatedPeerMetadata(exampleEndpointId, metadata) }));
+    // Then
+    const endpoints = webRTCEndpoint.getRemoteEndpoints();
+    const addedEndpoint = Object.values(endpoints)[0];
+    expect(addedEndpoint.metadata).toEqual({ goodStuff: 'ye' });
+});

package/dist/webrtc-client/tests/events/trackAddedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/trackAddedEvent.test.js

@@ -0,0 +1,84 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { deserializePeerMediaEvent, serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createAddTrackMediaEvent, createAnswerData, createConnectedEventWithOneEndpoint, createCustomOfferDataEventWithOneVideoTrack, exampleTrackId, } from '../fixtures';
+import { mockRTCPeerConnection } from '../mocks';
+it('Connect to room with one endpoint then addTrack produce event', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const eventWithOneEndpoint = createConnectedEventWithOneEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected: eventWithOneEndpoint }));
+    const [otherEndpointId] = Object.entries(eventWithOneEndpoint.endpointIdToEndpoint).find(([id]) => id !== eventWithOneEndpoint.endpointId);
+    const tracksAdded = createAddTrackMediaEvent(otherEndpointId, exampleTrackId);
+    webRTCEndpoint.on('trackAdded', (ctx) => {
+        expect(ctx.trackId).toBe(exampleTrackId);
+        expect(ctx.endpoint.id).toBe(tracksAdded.endpointId);
+        expect(ctx.simulcastConfig?.enabled).toBe(tracksAdded.trackIdToTrack[exampleTrackId].simulcastConfig?.enabled);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksAdded }));
+    // Then
+    const remoteTracks = webRTCEndpoint.getRemoteTracks();
+    expect(Object.values(remoteTracks).length).toBe(1);
+}));
+it('Correctly parses track metadata', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEventWithOneEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    const otherEndpointId = Object.keys(connected.endpointIdToEndpoint).find((id) => id !== connected.endpointId);
+    const tracksAdded = createAddTrackMediaEvent(otherEndpointId, exampleTrackId, {
+        peer: { goodStuff: 'ye', extraFluff: 'nah' },
+    });
+    webRTCEndpoint.on('trackAdded', (ctx) => {
+        // Then
+        expect(ctx.metadata).toEqual({ peer: { goodStuff: 'ye', extraFluff: 'nah' } });
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksAdded }));
+}));
+it('tracksAdded -> handle offerData with one video track from server', () => new Promise((done) => {
+    // Given
+    const { addTransceiverCallback } = mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEventWithOneEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    const otherEndpointId = Object.keys(connected.endpointIdToEndpoint).find((id) => id !== connected.endpointId);
+    const trackAddedEvent = createAddTrackMediaEvent(otherEndpointId, exampleTrackId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksAdded: trackAddedEvent }));
+    const offerData = createCustomOfferDataEventWithOneVideoTrack();
+    webRTCEndpoint.on('sendMediaEvent', (mediaEvent) => {
+        const event = deserializePeerMediaEvent(mediaEvent);
+        expect(event.sdpOffer).toBeDefined();
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ offerData }));
+    // Then
+    // todo
+    //  if there is no connection: Setup callbacks else restartIce
+    expect(addTransceiverCallback.mock.calls).toHaveLength(1);
+    expect(addTransceiverCallback.mock.calls[0][0]).toBe('video');
+    const transceivers = webRTCEndpoint['connectionManager'].getConnection().getTransceivers();
+    expect(transceivers.length).toBe(1);
+    expect(transceivers[0].direction).toBe('recvonly');
+}));
+it('tracksAdded -> offerData with one track -> handle sdpAnswer data with one video track from server', () => {
+    // Given
+    mockRTCPeerConnection();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const connected = createConnectedEventWithOneEndpoint();
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ connected }));
+    const otherEndpointId = Object.keys(connected.endpointIdToEndpoint).find((id) => id !== connected.endpointId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksAdded: createAddTrackMediaEvent(otherEndpointId, exampleTrackId) }));
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ offerData: createCustomOfferDataEventWithOneVideoTrack() }));
+    // When
+    const sdpAnswer = createAnswerData(exampleTrackId);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ sdpAnswer }));
+    // Then
+    const midToTrackId = webRTCEndpoint['local']['getMidToTrackId']();
+    // midToTrackId?.size should be undefined because the local peer doesn't offer anything
+    expect(midToTrackId?.size).toBe(undefined);
+});

package/dist/webrtc-client/tests/events/trackRemovedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/trackRemovedEvent.test.js

@@ -0,0 +1,26 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createTracksRemovedEvent, exampleEndpointId, exampleTrackId } from '../fixtures';
+import { setupRoomWithMocks } from '../utils';
+it('Remove tracks event should emit event', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoomWithMocks(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    webRTCEndpoint.on('trackRemoved', (trackContext) => {
+        // Then
+        expect(trackContext.trackId).toBe(exampleTrackId);
+        done('');
+    });
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksRemoved: createTracksRemovedEvent(exampleEndpointId, [exampleTrackId]) }));
+}));
+it('Remove tracks event should remove from local state', () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoomWithMocks(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ tracksRemoved: createTracksRemovedEvent(exampleEndpointId, [exampleTrackId]) }));
+    const tracks = webRTCEndpoint.getRemoteTracks();
+    expect(Object.values(tracks).length).toBe(0);
+});

package/dist/webrtc-client/tests/events/trackUpdatedEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/trackUpdatedEvent.test.js

@@ -0,0 +1,77 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createTrackUpdatedEvent, exampleEndpointId, exampleTrackId, notExistingEndpointId } from '../fixtures';
+import { setupRoom } from '../utils';
+it(`Updating existing track emits events`, () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    webRTCEndpoint.on('trackUpdated', (context) => {
+        // Then
+        expect(context.metadata).toEqual(metadata);
+        done('');
+    });
+    const metadata = {
+        name: 'New name',
+    };
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ trackUpdated: createTrackUpdatedEvent(exampleTrackId, exampleEndpointId, metadata) }));
+}));
+it(`Updating existing track changes track metadata`, () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const metadata = {
+        name: 'New name',
+    };
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ trackUpdated: createTrackUpdatedEvent(exampleTrackId, exampleEndpointId, metadata) }));
+    // Then
+    const track = webRTCEndpoint.getRemoteTracks()[exampleTrackId];
+    expect(track.metadata).toEqual(metadata);
+});
+it('Correctly parses track metadata', () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const metadata = {
+        goodStuff: 'ye',
+    };
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ trackUpdated: createTrackUpdatedEvent(exampleTrackId, exampleEndpointId, metadata) }));
+    // Then
+    const track = webRTCEndpoint.getRemoteTracks()[exampleTrackId];
+    expect(track.metadata).toEqual({ goodStuff: 'ye' });
+});
+it.todo(`Webrtc endpoint skips updating local endpoint metadata`, () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const metadata = {
+        name: 'New name',
+    };
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ trackUpdated: createTrackUpdatedEvent(exampleTrackId, exampleEndpointId, metadata) }));
+    // Then
+    // todo How should empty metadata be handled?
+    //  - empty object {}
+    //  - null
+    //  - undefined
+    // expect(track.metadata).toBe(value.data.otherEndpoints[0].metadata as any)
+    // TODO: write the rest of the test once we expose webrtc.getLocalEndpoints() function
+});
+it(`Updating track with invalid endpoint id throws error`, () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    const metadata = {
+        name: 'New name',
+    };
+    // When
+    expect(() => webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        trackUpdated: createTrackUpdatedEvent(exampleTrackId, notExistingEndpointId, metadata),
+    })))
+        // Then
+        .rejects.toThrow(`Endpoint ${notExistingEndpointId} not found`);
+});

package/dist/webrtc-client/tests/events/vadNotificationEvent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/events/vadNotificationEvent.test.js

@@ -0,0 +1,42 @@
+import { MediaEvent_VadNotification_Status } from '@fishjam-cloud/protobufs/server';
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createCustomVadNotificationEvent, exampleEndpointId, exampleTrackId } from '../fixtures';
+import { setupRoom } from '../utils';
+it(`Changing VAD notification to "speech" on existing track id`, () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        vadNotification: createCustomVadNotificationEvent(exampleTrackId, MediaEvent_VadNotification_Status.STATUS_SPEECH),
+    }));
+    // Then
+    const track = webRTCEndpoint.getRemoteTracks()[exampleTrackId];
+    expect(track.vadStatus).toBe('speech');
+});
+it(`Changing VAD notification to "silence" on existing track id`, () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({
+        vadNotification: createCustomVadNotificationEvent(exampleTrackId, MediaEvent_VadNotification_Status.STATUS_SILENCE),
+    }));
+    // Then
+    const track = webRTCEndpoint.getRemoteTracks()[exampleTrackId];
+    expect(track.vadStatus).toBe('silence');
+});
+it(`Changing VAD notification emits event`, () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    setupRoom(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    webRTCEndpoint.getRemoteTracks()[exampleTrackId].on('voiceActivityChanged', (context) => {
+        expect(context.vadStatus).toBe('speech');
+        done('');
+    });
+    // When
+    const vadNotification = createCustomVadNotificationEvent(exampleTrackId, MediaEvent_VadNotification_Status.STATUS_SPEECH);
+    webRTCEndpoint.receiveMediaEvent(serializeServerMediaEvent({ vadNotification }));
+}));

package/dist/webrtc-client/tests/fixtures.d.ts

@@ -0,0 +1,27 @@
+import type { MediaEvent_Track, MediaEvent_VadNotification_Status } from '@fishjam-cloud/protobufs/server';
+import { MediaEvent_Connected, MediaEvent_Endpoint, MediaEvent_EndpointAdded, MediaEvent_EndpointRemoved, MediaEvent_EndpointUpdated, MediaEvent_OfferData, MediaEvent_SdpAnswer, MediaEvent_TracksAdded, MediaEvent_TracksRemoved, MediaEvent_TrackUpdated, MediaEvent_TrackVariantSwitched, MediaEvent_VadNotification } from '@fishjam-cloud/protobufs/server';
+import { FakeMediaStreamTrack } from 'fake-mediastreamtrack';
+import { Variant } from '../src';
+export declare const exampleEndpointId = "exampleEndpointId";
+export declare const notExistingEndpointId = "notExistingEndpointId";
+export declare const exampleTrackId = "exampleTrackId";
+export declare const notExistingTrackId = "notExistingTrackId";
+export declare const mockTrack: FakeMediaStreamTrack;
+export declare const stream: any;
+export declare const createTrackWithSimulcast: (metadata?: unknown) => MediaEvent_Track;
+export declare const createEmptyEndpoint: () => MediaEvent_Endpoint;
+export declare const createConnectedEvent: (endpointId?: string) => MediaEvent_Connected;
+export declare const createEncodingSwitchedEvent: (endpointId: string, trackId: string, variant: Variant) => MediaEvent_TrackVariantSwitched;
+export declare const createCustomVadNotificationEvent: (trackId: string, status: MediaEvent_VadNotification_Status) => MediaEvent_VadNotification;
+export declare const createTrackUpdatedEvent: (trackId: string, endpointId: string, metadata: unknown) => MediaEvent_TrackUpdated;
+export declare const createEndpointAdded: (endpointId: string, metadata?: unknown) => MediaEvent_EndpointAdded;
+export declare const createEndpointRemoved: (endpointId: string) => MediaEvent_EndpointRemoved;
+export declare const createConnectedEventWithOneEndpoint: (endpointId?: string, localEndpointId?: string) => MediaEvent_Connected;
+export declare const createConnectedEventWithOneEndpointWithOneTrack: (remoteEndpointId: string, trackId: string, localEndpointId?: string) => MediaEvent_Connected;
+export declare const createAddTrackMediaEvent: (endpointId: string, trackId: string, metadata?: any) => MediaEvent_TracksAdded;
+export declare const createTracksRemovedEvent: (endpointId: string, trackIds: string[]) => MediaEvent_TracksRemoved;
+export declare const createCustomOfferDataEventWithOneVideoTrack: () => MediaEvent_OfferData;
+export declare const createAddLocalTrackSDPOffer: () => MediaEvent_OfferData;
+export declare const createAnswerData: (trackId: string) => MediaEvent_SdpAnswer;
+export declare const createAddLocalTrackAnswerData: (trackId: string) => MediaEvent_SdpAnswer;
+export declare const createEndpointUpdatedPeerMetadata: (endpointId: string, metadata: unknown) => MediaEvent_EndpointUpdated;