@microsoft/live-share-media 1.0.0-preview.1 → 1.0.0-preview.4

package/src/test/GroupPlaybackPosition.spec.ts

@@ -3,168 +3,281 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import 'mocha';
-import { strict as assert } from 'assert';
-import { IParticipant, ParticipantRole, SimulatedBroadcastHub, SimulatedCollaborationSpace } from '@microsoft/teams-collaboration';
-import { GroupPlaybackTrack } from './GroupPlaybackTrack';
-import { GroupTransportState, ITransportState } from './GroupTransportState';
-import { GroupPlaybackPosition, ICurrentPlaybackPosition } from './GroupPlaybackPosition';
-import { CoordinationWaitPoint, ExtendedMediaMetadata, ExtendedMediaSessionPlaybackState } from '../MediaSessionExtensions';
-import { TimeInterval } from '../internals';
-
-function createTransportUpdate(space: SimulatedCollaborationSpace, playbackState: ExtendedMediaSessionPlaybackState, startPosition: number): ITransportState {
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    IParticipant,
+    ParticipantRole,
+    SimulatedBroadcastHub,
+    SimulatedCollaborationSpace,
+} from "@microsoft/teams-collaboration";
+import { GroupPlaybackTrack } from "./GroupPlaybackTrack";
+import { GroupTransportState, ITransportState } from "./GroupTransportState";
+import {
+    GroupPlaybackPosition,
+    ICurrentPlaybackPosition,
+} from "./GroupPlaybackPosition";
+import {
+    CoordinationWaitPoint,
+    ExtendedMediaMetadata,
+    ExtendedMediaSessionPlaybackState,
+} from "../MediaSessionExtensions";
+import { TimeInterval } from "../internals";
+
+function createTransportUpdate(
+    space: SimulatedCollaborationSpace,
+    playbackState: ExtendedMediaSessionPlaybackState,
+    startPosition: number
+): ITransportState {
     return {
         playbackState: playbackState,
         startPosition: startPosition,
         timestamp: space.clock.getTime(),
-        socketId: space.socket.id
+        socketId: space.socket.id,
     };
 }
 
-function createPositionUpdate(space: SimulatedCollaborationSpace, playbackState: ExtendedMediaSessionPlaybackState, position: number, waitPoint?: CoordinationWaitPoint, duration?: number): ICurrentPlaybackPosition {
+function createPositionUpdate(
+    space: SimulatedCollaborationSpace,
+    playbackState: ExtendedMediaSessionPlaybackState,
+    position: number,
+    waitPoint?: CoordinationWaitPoint,
+    duration?: number
+): ICurrentPlaybackPosition {
     return {
         playbackState: playbackState,
         waitPoint: waitPoint,
         position: position,
         duration: duration,
         timestamp: space.clock.getTime(),
-        socketId: space.socket.id
+        socketId: space.socket.id,
     };
 }
 
-function subtractSeconds<T extends { timestamp: number; }>(seconds: number, update: T): T {
-    update.timestamp -= (seconds * 1000);
+function subtractSeconds<T extends { timestamp: number }>(
+    seconds: number,
+    update: T
+): T {
+    update.timestamp -= seconds * 1000;
     return update;
-} 
+}
 
-function addSeconds<T extends { timestamp: number; }>(seconds: number, update: T): T {
-    update.timestamp += (seconds * 1000);
+function addSeconds<T extends { timestamp: number }>(
+    seconds: number,
+    update: T
+): T {
+    update.timestamp += seconds * 1000;
     return update;
-} 
+}
 
-describe('GroupPlaybackPosition', () => {
+describe("GroupPlaybackPosition", () => {
     const hub = new SimulatedBroadcastHub();
 
-    const user1: IParticipant = { participantId: 'user1', role: ParticipantRole.organizer };
+    const user1: IParticipant = {
+        participantId: "user1",
+        role: ParticipantRole.organizer,
+    };
     const space1 = new SimulatedCollaborationSpace(user1, hub);
-    const user2: IParticipant = { participantId: 'user2', role: ParticipantRole.participant };
+    const user2: IParticipant = {
+        participantId: "user2",
+        role: ParticipantRole.participant,
+    };
     const space2 = new SimulatedCollaborationSpace(user2, hub);
 
-    const track1 = { trackIdentifier: 'track1', title: 'Test Track 1' } as ExtendedMediaMetadata;
-    const track2 = { trackIdentifier: 'track2', title: 'Test Track 2' } as ExtendedMediaMetadata;
+    const track1 = {
+        trackIdentifier: "track1",
+        title: "Test Track 1",
+    } as ExtendedMediaMetadata;
+    const track2 = {
+        trackIdentifier: "track2",
+        title: "Test Track 2",
+    } as ExtendedMediaMetadata;
 
     const updateInterval = new TimeInterval(10);
 
-    it('should start with 0 clients', async () => {
+    it("should start with 0 clients", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         try {
             assert(playbackPosition.totalClients == 0, `wrong client count`);
-            assert(playbackPosition.localPosition == undefined, `wrong position`);
+            assert(
+                playbackPosition.localPosition == undefined,
+                `wrong position`
+            );
         } finally {
             await space1.leave();
         }
     });
 
-    it('should find local position', async () => {
+    it("should find local position", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         try {
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'none', 0.0));
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "none", 0.0)
+            );
 
             assert(playbackPosition.totalClients == 1, `wrong client count`);
-            assert(playbackPosition.localPosition != undefined, `local position not found`);
+            assert(
+                playbackPosition.localPosition != undefined,
+                `local position not found`
+            );
         } finally {
             await space1.leave();
         }
     });
 
-    it('should update local position', async () => {
+    it("should update local position", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         try {
-            const position = createPositionUpdate(space1, 'none', 0.0);
+            const position = createPositionUpdate(space1, "none", 0.0);
             await playbackPosition.UpdatePlaybackPosition(position);
 
-            const newPosition = addSeconds(1.0, createPositionUpdate(space1, 'none', 0.0));
+            const newPosition = addSeconds(
+                1.0,
+                createPositionUpdate(space1, "none", 0.0)
+            );
             await playbackPosition.UpdatePlaybackPosition(newPosition);
 
             assert(playbackPosition.totalClients == 1, `wrong client count`);
-            assert(playbackPosition.localPosition != undefined, `local position not found`);
-            assert(playbackPosition.localPosition.timestamp == newPosition.timestamp, `position not updated`);
+            assert(
+                playbackPosition.localPosition != undefined,
+                `local position not found`
+            );
+            assert(
+                playbackPosition.localPosition.timestamp ==
+                    newPosition.timestamp,
+                `position not updated`
+            );
         } finally {
             await space1.leave();
         }
     });
 
-    it('should ignore older position updates', async () => {
+    it("should ignore older position updates", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         try {
-            const position = createPositionUpdate(space1, 'none', 0.0);
+            const position = createPositionUpdate(space1, "none", 0.0);
             await playbackPosition.UpdatePlaybackPosition(position);
 
-            const newPosition = subtractSeconds(1.0, createPositionUpdate(space1, 'none', 0.0));
+            const newPosition = subtractSeconds(
+                1.0,
+                createPositionUpdate(space1, "none", 0.0)
+            );
             await playbackPosition.UpdatePlaybackPosition(newPosition);
 
             assert(playbackPosition.totalClients == 1, `wrong client count`);
-            assert(playbackPosition.localPosition != undefined, `local position not found`);
-            assert(playbackPosition.localPosition.timestamp == position.timestamp, `position not updated`);
+            assert(
+                playbackPosition.localPosition != undefined,
+                `local position not found`
+            );
+            assert(
+                playbackPosition.localPosition.timestamp == position.timestamp,
+                `position not updated`
+            );
         } finally {
             await space1.leave();
         }
     });
 
-    it('should track other client positions', async () => {
+    it("should track other client positions", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         await space2.join();
         try {
-            const position1 = createPositionUpdate(space1, 'none', 0.0);
+            const position1 = createPositionUpdate(space1, "none", 0.0);
             await playbackPosition.UpdatePlaybackPosition(position1);
 
-            const position2 = addSeconds(1.0, createPositionUpdate(space2, 'none', 0.0));
+            const position2 = addSeconds(
+                1.0,
+                createPositionUpdate(space2, "none", 0.0)
+            );
             await playbackPosition.UpdatePlaybackPosition(position2);
 
             assert(playbackPosition.totalClients == 2, `wrong client count`);
-            assert(playbackPosition.localPosition != undefined, `local position not found`);
-            assert(playbackPosition.localPosition.timestamp == position1.timestamp, `position not updated`);
+            assert(
+                playbackPosition.localPosition != undefined,
+                `local position not found`
+            );
+            assert(
+                playbackPosition.localPosition.timestamp == position1.timestamp,
+                `position not updated`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
 
-    it('should enumerate client positions', async () => {
+    it("should enumerate client positions", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'none', 0.0));
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(updateInterval.seconds, createPositionUpdate(space2, 'none', 0.0)));
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "none", 0.0)
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    updateInterval.seconds,
+                    createPositionUpdate(space2, "none", 0.0)
+                )
+            );
 
             let cnt = 0;
             playbackPosition.forEach((position, projectedPosition) => {
-                assert(position.position == 0.0, `wrong position ${position.position}`);
-                assert(projectedPosition == 0.0, `wrong projected position ${projectedPosition}`);
+                assert(
+                    position.position == 0.0,
+                    `wrong position ${position.position}`
+                );
+                assert(
+                    projectedPosition == 0.0,
+                    `wrong projected position ${projectedPosition}`
+                );
                 cnt++;
             });
 
@@ -175,21 +288,38 @@ describe('GroupPlaybackPosition', () => {
         }
     });
 
-    it('should ignore stale positions', async () => {
+    it("should ignore stale positions", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, updateInterval);
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            updateInterval
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'none', 0.0));
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(updateInterval.seconds * 3, createPositionUpdate(space2, 'none', 0.0)));
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "none", 0.0)
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    updateInterval.seconds * 3,
+                    createPositionUpdate(space2, "none", 0.0)
+                )
+            );
 
             let cnt = 0;
             playbackPosition.forEach((position, projectedPosition) => {
-                assert(position.position == 0.0, `wrong position ${position.position}`);
-                assert(projectedPosition == 0.0, `wrong projected position ${projectedPosition}`);
+                assert(
+                    position.position == 0.0,
+                    `wrong position ${position.position}`
+                );
+                assert(
+                    projectedPosition == 0.0,
+                    `wrong projected position ${projectedPosition}`
+                );
                 cnt++;
             });
 
@@ -200,19 +330,34 @@ describe('GroupPlaybackPosition', () => {
         }
     });
 
-    it('should project position when playing', async () => {
+    it("should project position when playing", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         try {
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(1.0, createPositionUpdate(space1, 'playing', 0.0)));
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    1.0,
+                    createPositionUpdate(space1, "playing", 0.0)
+                )
+            );
 
             let cnt = 0;
             playbackPosition.forEach((position, projectedPosition) => {
-                assert(position.position == 0.0, `wrong position ${position.position}`);
-                assert(projectedPosition >= 1.0, `wrong projected position ${projectedPosition}`);
+                assert(
+                    position.position == 0.0,
+                    `wrong position ${position.position}`
+                );
+                assert(
+                    projectedPosition >= 1.0,
+                    `wrong projected position ${projectedPosition}`
+                );
                 cnt++;
             });
 
@@ -222,119 +367,234 @@ describe('GroupPlaybackPosition', () => {
         }
     });
 
-    it('should compute max playback position relative to transport state', async () => {
+    it("should compute max playback position relative to transport state", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         try {
-            assert(playbackPosition.maxPosition == 0.0, `wrong starting position of ${playbackPosition.maxPosition}`);
-
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-
-            assert(playbackPosition.maxPosition >= 2.0, `wrong projected position of ${playbackPosition.maxPosition}`);
+            assert(
+                playbackPosition.maxPosition == 0.0,
+                `wrong starting position of ${playbackPosition.maxPosition}`
+            );
+
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+
+            assert(
+                playbackPosition.maxPosition >= 2.0,
+                `wrong projected position of ${playbackPosition.maxPosition}`
+            );
         } finally {
             await space1.leave();
         }
     });
 
-    it('should compute target position relative to other client positions', async () => {
+    it("should compute target position relative to other client positions", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         await space2.join();
         try {
-            assert(playbackPosition.targetPosition == 0.0, `wrong starting position of ${playbackPosition.targetPosition}`);
-
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'playing', 0.0));
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(1.0, createPositionUpdate(space2, 'playing', 0.0)));
+            assert(
+                playbackPosition.targetPosition == 0.0,
+                `wrong starting position of ${playbackPosition.targetPosition}`
+            );
+
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "playing", 0.0)
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    1.0,
+                    createPositionUpdate(space2, "playing", 0.0)
+                )
+            );
 
             // We're sometimes getting back a target position of 0.999 instead of 1.0 (some sort of rounding error)
-            assert(playbackPosition.targetPosition > 0.9 && playbackPosition.targetPosition < 2.0, `wrong target position of ${playbackPosition.targetPosition}`);
+            assert(
+                playbackPosition.targetPosition > 0.9 &&
+                    playbackPosition.targetPosition < 2.0,
+                `wrong target position of ${playbackPosition.targetPosition}`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
 
-    it('should limit max and target position by media duration', async () => {
+    it("should limit max and target position by media duration", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'playing', 0.0, undefined, 0.5));
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(1.0, createPositionUpdate(space2, 'playing', 0.0, undefined, 0.5)));
-
-            assert(playbackPosition.maxPosition == 0.5, `wrong max position ${playbackPosition.maxPosition}`);
-            assert(playbackPosition.targetPosition == 0.5, `wrong target position ${playbackPosition.targetPosition}`);
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "playing", 0.0, undefined, 0.5)
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    1.0,
+                    createPositionUpdate(space2, "playing", 0.0, undefined, 0.5)
+                )
+            );
+
+            assert(
+                playbackPosition.maxPosition == 0.5,
+                `wrong max position ${playbackPosition.maxPosition}`
+            );
+            assert(
+                playbackPosition.targetPosition == 0.5,
+                `wrong target position ${playbackPosition.targetPosition}`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
 
-    it('should count number of waiting clients', async () => {
+    it("should count number of waiting clients", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'suspended', 2.0, { position: 2.0 }));
-            await playbackPosition.UpdatePlaybackPosition(subtractSeconds(1.0, createPositionUpdate(space2, 'playing', 0.0, undefined)));
-
-            assert(playbackPosition.clientsWaiting == 2, `wrong count ${playbackPosition.clientsWaiting}`);
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "suspended", 2.0, {
+                    position: 2.0,
+                })
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                subtractSeconds(
+                    1.0,
+                    createPositionUpdate(space2, "playing", 0.0, undefined)
+                )
+            );
+
+            assert(
+                playbackPosition.clientsWaiting == 2,
+                `wrong count ${playbackPosition.clientsWaiting}`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
 
-    it('should drop waiting count after suspension ends', async () => {
+    it("should drop waiting count after suspension ends", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'waiting', 2.0, { position: 2.0 }));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space2, 'suspended', 2.0, { position: 2.0 }));
-
-            assert(playbackPosition.clientsWaiting == 1, `wrong count ${playbackPosition.clientsWaiting}`);
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "waiting", 2.0, { position: 2.0 })
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space2, "suspended", 2.0, {
+                    position: 2.0,
+                })
+            );
+
+            assert(
+                playbackPosition.clientsWaiting == 1,
+                `wrong count ${playbackPosition.clientsWaiting}`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
 
-    it('should drop waiting count to 0 after all clients reach wait point', async () => {
+    it("should drop waiting count to 0 after all clients reach wait point", async () => {
         const playbackTrack = new GroupPlaybackTrack(() => track1);
         const transportState = new GroupTransportState(playbackTrack);
-        const playbackPosition = new GroupPlaybackPosition(transportState, space1, new TimeInterval(1000));
+        const playbackPosition = new GroupPlaybackPosition(
+            transportState,
+            space1,
+            new TimeInterval(1000)
+        );
 
         await space1.join();
         await space2.join();
         try {
-            await transportState.updateState(subtractSeconds(2.0, createTransportUpdate(space1, 'playing', 0.0)));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space1, 'waiting', 2.0, { position: 2.0 }));
-            await playbackPosition.UpdatePlaybackPosition(createPositionUpdate(space2, 'waiting', 2.0, { position: 2.0 }));
-
-            assert(playbackPosition.clientsWaiting == 0, `wrong count ${playbackPosition.clientsWaiting}`);
+            await transportState.updateState(
+                subtractSeconds(
+                    2.0,
+                    createTransportUpdate(space1, "playing", 0.0)
+                )
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space1, "waiting", 2.0, { position: 2.0 })
+            );
+            await playbackPosition.UpdatePlaybackPosition(
+                createPositionUpdate(space2, "waiting", 2.0, { position: 2.0 })
+            );
+
+            assert(
+                playbackPosition.clientsWaiting == 0,
+                `wrong count ${playbackPosition.clientsWaiting}`
+            );
         } finally {
             await space1.leave();
             await space2.leave();
         }
     });
-});
+});