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

package/src/test/GroupPlaybackTrack.spec.ts

@@ -3,64 +3,120 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import 'mocha';
-import { strict as assert } from 'assert';
-import { IParticipant, ParticipantRole, Deferred } from '@microsoft/teams-collaboration';
-import { GroupPlaybackTrack, GroupPlaybackTrackEvents, ITrackChangeEvent } from '../internals/GroupPlaybackTrack';
-import { ExtendedMediaMetadata } from '../MediaSessionExtensions';
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    IParticipant,
+    ParticipantRole,
+    Deferred,
+} from "@microsoft/teams-collaboration";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+    ITrackChangeEvent,
+} from "../internals/GroupPlaybackTrack";
+import { ExtendedMediaMetadata } from "../MediaSessionExtensions";
 
-describe('GroupPlaybackTrack', () => {
-    const user1: IParticipant = { participantId: 'user1', role: ParticipantRole.organizer };
-    const user2: IParticipant = { participantId: 'user2', role: ParticipantRole.participant };
+describe("GroupPlaybackTrack", () => {
+    const user1: IParticipant = {
+        participantId: "user1",
+        role: ParticipantRole.organizer,
+    };
+    const user2: IParticipant = {
+        participantId: "user2",
+        role: ParticipantRole.participant,
+    };
 
-    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;
 
     it('should fire "trackChange" event when no media', async () => {
         const done = new Deferred();
         const playbackTrack = new GroupPlaybackTrack(() => null);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            try {
-                assert(event.metadata, `no metadata`);
-                assert(event.metadata.trackIdentifier == 'track1', `wrong track`);
-                done.resolve();
-            } catch(err) {
-                done.reject(err);
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                try {
+                    assert(event.metadata, `no metadata`);
+                    assert(
+                        event.metadata.trackIdentifier == "track1",
+                        `wrong track`
+                    );
+                    done.resolve();
+                } catch (err) {
+                    done.reject(err);
+                }
             }
+        );
 
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 1,
+            socketId: "a",
         });
 
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 1, socketId: 'a'});
-
         await done.promise;
     });
 
-    it('should switch tracks', async () => {
+    it("should switch tracks", async () => {
         let cnt = 0;
         let metadata: ExtendedMediaMetadata = null;
         const playbackTrack = new GroupPlaybackTrack(() => metadata);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            cnt++;
-            metadata = event.metadata;
-        });
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                cnt++;
+                metadata = event.metadata;
+            }
+        );
 
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 1, socketId: 'a'});
-        await playbackTrack.updateTrack({ metadata: track2, waitPoints: [], timestamp: 2, socketId: 'b'});
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 1,
+            socketId: "a",
+        });
+        await playbackTrack.updateTrack({
+            metadata: track2,
+            waitPoints: [],
+            timestamp: 2,
+            socketId: "b",
+        });
         assert(cnt == 2, `called trackChange event ${cnt} times`);
-        assert(metadata.trackIdentifier == 'track2', `wrong track set`);
+        assert(metadata.trackIdentifier == "track2", `wrong track set`);
     });
 
-    it('should ignore track changes with older timestamps', async () => {
+    it("should ignore track changes with older timestamps", async () => {
         let cnt = 0;
         let metadata: ExtendedMediaMetadata = null;
         const playbackTrack = new GroupPlaybackTrack(() => metadata);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            cnt++;
-            metadata = event.metadata;
-        });
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                cnt++;
+                metadata = event.metadata;
+            }
+        );
 
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 3, socketId: 'a'});
-        await playbackTrack.updateTrack({ metadata: track2, waitPoints: [], timestamp: 2, socketId: 'b'});
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 3,
+            socketId: "a",
+        });
+        await playbackTrack.updateTrack({
+            metadata: track2,
+            waitPoints: [],
+            timestamp: 2,
+            socketId: "b",
+        });
         assert(cnt == 1, `called trackChange event ${cnt} times`);
     });
-});
+});

package/src/test/SharedMediaSession.spec.ts

@@ -3,12 +3,19 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import 'mocha';
-import { strict as assert } from 'assert';
-import { CollaborationSpace, CollaborationSpaceEvents, Deferred } from '@microsoft/teams-collaboration';
-import { LastMediaPositionState } from '../LiveMediaSessionCoordinator';
-import { ExtendedMediaMetadata, ExtendedMediaSessionActionDetails } from '../MediaSessionExtensions';
-import { SharedMediaSession } from '../LiveMediaSession';
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    CollaborationSpace,
+    CollaborationSpaceEvents,
+    Deferred,
+} from "@microsoft/teams-collaboration";
+import { LastMediaPositionState } from "../LiveMediaSessionCoordinator";
+import {
+    ExtendedMediaMetadata,
+    ExtendedMediaSessionActionDetails,
+} from "../MediaSessionExtensions";
+import { SharedMediaSession } from "../LiveMediaSession";
 
 export class TestMediaSession extends SharedMediaSession {
     private done = new Deferred<ExtendedMediaSessionActionDetails>();
@@ -17,30 +24,45 @@ export class TestMediaSession extends SharedMediaSession {
     private playbackStarted: number = 0;
     private playbackPosition: number = 0.0;
 
-    constructor(space: CollaborationSpace,  metadata?: ExtendedMediaMetadata|null, playbackState?: MediaSessionPlaybackState, positionState?: LastMediaPositionState) {
+    constructor(
+        space: CollaborationSpace,
+        metadata?: ExtendedMediaMetadata | null,
+        playbackState?: MediaSessionPlaybackState,
+        positionState?: LastMediaPositionState
+    ) {
         super(space);
         this.space = space;
-        if (metadata) { this.metadata = metadata; }
-        if (playbackState) { this.playbackState = playbackState; }
+        if (metadata) {
+            this.metadata = metadata;
+        }
+        if (playbackState) {
+            this.playbackState = playbackState;
+        }
         if (positionState) {
-            this.playbackPosition = positionState.position != undefined ? positionState.position : 0.0;
+            this.playbackPosition =
+                positionState.position != undefined
+                    ? positionState.position
+                    : 0.0;
             this.duration = positionState.duration;
-            this.playbackRate = positionState.playbackRate != undefined ? positionState.playbackRate : 1;
+            this.playbackRate =
+                positionState.playbackRate != undefined
+                    ? positionState.playbackRate
+                    : 1;
         }
 
-        this.setActionHandler('play', details => {
+        this.setActionHandler("play", (details) => {
             this.play();
             this.done.resolve(details);
         });
-        this.setActionHandler('pause', details => {
+        this.setActionHandler("pause", (details) => {
             this.pause();
             this.done.resolve(details);
         });
-        this.setActionHandler('seekto', details => {
+        this.setActionHandler("seekto", (details) => {
             this.currentTime = details.seekTime;
             this.done.resolve(details);
         });
-        this.setActionHandler('settrack', details => {
+        this.setActionHandler("settrack", (details) => {
             this.done.resolve(details);
         });
 
@@ -56,17 +78,17 @@ export class TestMediaSession extends SharedMediaSession {
     public playbackRate: number = 1;
 
     public get playing(): boolean {
-        return this.playbackState == 'playing';
+        return this.playbackState == "playing";
     }
 
     public get paused(): boolean {
-        return this.playbackState != 'playing';
+        return this.playbackState != "playing";
     }
 
     public get currentTime(): number {
-        if (this.playbackState == 'playing') {
+        if (this.playbackState == "playing") {
             const now = this.space.clock.getTime();
-            return this.playbackPosition + ((now - this.playbackStarted) / 1000);
+            return this.playbackPosition + (now - this.playbackStarted) / 1000;
         } else {
             return this.playbackPosition;
         }
@@ -76,20 +98,28 @@ export class TestMediaSession extends SharedMediaSession {
         const startState = this.playbackState;
         this.pause();
         this.playbackPosition = value;
-        if (startState == 'playing') {
+        if (startState == "playing") {
             this.play();
         } else {
-            this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
+            this.setPositionState({
+                position: this.currentTime,
+                duration: this.duration,
+                playbackRate: this.playbackRate,
+            });
         }
     }
 
     public play(): void {
-        if (this.playbackState != 'playing') {
+        if (this.playbackState != "playing") {
             this.playbackStarted = this.space.clock.getTime();
-            this.playbackState = 'playing';
+            this.playbackState = "playing";
             this.playbackTimer = setInterval(() => {
-                this.playbackState = 'playing';
-                this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
+                this.playbackState = "playing";
+                this.setPositionState({
+                    position: this.currentTime,
+                    duration: this.duration,
+                    playbackRate: this.playbackRate,
+                });
             }, 60);
         }
     }
@@ -101,11 +131,17 @@ export class TestMediaSession extends SharedMediaSession {
         }
 
         this.playbackPosition = this.currentTime;
-        this.playbackState = 'paused';
-        this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
+        this.playbackState = "paused";
+        this.setPositionState({
+            position: this.currentTime,
+            duration: this.duration,
+            playbackRate: this.playbackRate,
+        });
     }
 
-    public async waitForAction(handler: (details: ExtendedMediaSessionActionDetails) => Promise<void>): Promise<void> {
+    public async waitForAction(
+        handler: (details: ExtendedMediaSessionActionDetails) => Promise<void>
+    ): Promise<void> {
         const details = await this.done.promise;
         this.done = new Deferred<ExtendedMediaSessionActionDetails>();
         await handler(details);

package/src/test/SharedMediaSessionCoordinator.spec.ts

@@ -3,33 +3,45 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import 'mocha';
-import { strict as assert } from 'assert';
-import { SimulatedBroadcastHub, SimulatedCollaborationSpace, IParticipant, ParticipantRole, Deferred } from '@microsoft/teams-collaboration';
-import { ExtendedMediaMetadata } from './MediaSessionExtensions';
-import { ICurrentPlaybackPosition } from './coordinatorState';
-import { TestMediaSession } from './SharedMediaSession.spec';
-
-describe('SharedMediaSessionCoordinator', () => {
-    const user1: IParticipant = { participantId: 'user1', role: ParticipantRole.organizer };
-    const user2: IParticipant = { participantId: 'user2', role: ParticipantRole.participant };
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    SimulatedBroadcastHub,
+    SimulatedCollaborationSpace,
+    IParticipant,
+    ParticipantRole,
+    Deferred,
+} from "@microsoft/teams-collaboration";
+import { ExtendedMediaMetadata } from "./MediaSessionExtensions";
+import { ICurrentPlaybackPosition } from "./coordinatorState";
+import { TestMediaSession } from "./SharedMediaSession.spec";
+
+describe("SharedMediaSessionCoordinator", () => {
+    const user1: IParticipant = {
+        participantId: "user1",
+        role: ParticipantRole.organizer,
+    };
+    const user2: IParticipant = {
+        participantId: "user2",
+        role: ParticipantRole.participant,
+    };
     const testTrack: ExtendedMediaMetadata = {
-        trackIdentifier: 'https://example.org/test.mp3',
-        title: 'Test Title',
-        album: 'Test Album',
-        artist: 'The Testers',
-        artwork: []
+        trackIdentifier: "https://example.org/test.mp3",
+        title: "Test Title",
+        album: "Test Album",
+        artist: "The Testers",
+        artwork: [],
     };
     const leaderPosition: Partial<ICurrentPlaybackPosition> = {
-        playbackState: 'playing',
+        playbackState: "playing",
         position: 25.0,
-        duration: 600.0
+        duration: 600.0,
     };
 
     const laggerPosition: Partial<ICurrentPlaybackPosition> = {
-        playbackState: 'playing',
+        playbackState: "playing",
         position: 20.0,
-        duration: 600.0
+        duration: 600.0,
     };
 
     it('should send "joined" event when joined.', async () => {
@@ -41,10 +53,14 @@ describe('SharedMediaSessionCoordinator', () => {
             let cnt = 0;
             const session = new TestMediaSession(space1);
             await space2.join();
-            space2.socket.addBroadcastListener(session.name, 'joined', async (event) => {
-                cnt++;
-            });
-    
+            space2.socket.addBroadcastListener(
+                session.name,
+                "joined",
+                async (event) => {
+                    cnt++;
+                }
+            );
+
             await space1.join();
             assert(cnt == 1, `joined event not sent`);
         } finally {
@@ -64,12 +80,16 @@ describe('SharedMediaSessionCoordinator', () => {
             const session = new TestMediaSession(space1, testTrack);
             session.coordinator.positionUpdateInterval = 0.02;
             await space2.join();
-            space2.socket.addBroadcastListener(session.name, 'positionUpdate', async (event) => {
-                cnt++;
-                if (cnt > 1) {
-                    done.resolve();
+            space2.socket.addBroadcastListener(
+                session.name,
+                "positionUpdate",
+                async (event) => {
+                    cnt++;
+                    if (cnt > 1) {
+                        done.resolve();
+                    }
                 }
-            });
+            );
 
             await session.coordinator.join();
             await session.coordinator.play();
@@ -88,7 +108,7 @@ describe('SharedMediaSessionCoordinator', () => {
         try {
             const session1 = new TestMediaSession(space1, testTrack);
             const session2 = new TestMediaSession(space2, testTrack);
-            
+
             await space1.join();
             await space2.join();
 
@@ -100,7 +120,7 @@ describe('SharedMediaSessionCoordinator', () => {
 
             // Wait for action to be broadcast
             await session2.waitForAction(async (details) => {
-                assert(details.action == 'play', `wrong action received`);
+                assert(details.action == "play", `wrong action received`);
             });
         } finally {
             await space1.leave();
@@ -116,7 +136,7 @@ describe('SharedMediaSessionCoordinator', () => {
         try {
             const session1 = new TestMediaSession(space1, testTrack);
             const session2 = new TestMediaSession(space2, testTrack);
-            
+
             await session1.coordinator.join();
             await space2.join();
 
@@ -125,12 +145,12 @@ describe('SharedMediaSessionCoordinator', () => {
 
             // Wait for action to be broadcast
             await session2.waitForAction(async (details) => {
-                assert(details.action == 'play', `didn't start playback`);
-                
+                assert(details.action == "play", `didn't start playback`);
+
                 // Pause playback
                 await session1.coordinator.pause();
                 await session2.waitForAction(async (details) => {
-                    assert(details.action == 'pause', `didn't pause playback`);
+                    assert(details.action == "pause", `didn't pause playback`);
                 });
             });
         } finally {
@@ -147,7 +167,7 @@ describe('SharedMediaSessionCoordinator', () => {
         try {
             const session1 = new TestMediaSession(space1, testTrack);
             const session2 = new TestMediaSession(space2, testTrack);
-            
+
             await session1.coordinator.join();
             await space2.join();
 
@@ -156,13 +176,19 @@ describe('SharedMediaSessionCoordinator', () => {
 
             // Wait for action to be broadcast
             await session2.waitForAction(async (details) => {
-                assert(details.action == 'play', `didn't start playback`);
-                
+                assert(details.action == "play", `didn't start playback`);
+
                 // Seek to position
                 await session1.coordinator.seekTo(2.3);
                 await session2.waitForAction(async (details) => {
-                    assert(details.action == 'seekto', `wong action received "${details.action}"`);
-                    assert(details.seekTime >= 2.3, `wrong seek position "${details.seekTime}"`)
+                    assert(
+                        details.action == "seekto",
+                        `wong action received "${details.action}"`
+                    );
+                    assert(
+                        details.seekTime >= 2.3,
+                        `wrong seek position "${details.seekTime}"`
+                    );
                 });
             });
         } finally {
@@ -179,7 +205,7 @@ describe('SharedMediaSessionCoordinator', () => {
         try {
             const session1 = new TestMediaSession(space1);
             const session2 = new TestMediaSession(space2);
-            
+
             await space1.join();
             await space2.join();
 
@@ -188,9 +214,24 @@ describe('SharedMediaSessionCoordinator', () => {
 
             // Wait for action to be broadcast
             await session2.waitForAction(async (details) => {
-                assert(details.action == 'settrack', `wrong action received "${details.action}"`);
-                assert(JSON.stringify(session1.metadata) == JSON.stringify(testTrack), `session1 has wrong track: ${JSON.stringify(session1.metadata)}`);
-                assert(JSON.stringify(session2.metadata) == JSON.stringify(testTrack), `session2 has wrong track: ${JSON.stringify(session2.metadata)}`);
+                assert(
+                    details.action == "settrack",
+                    `wrong action received "${details.action}"`
+                );
+                assert(
+                    JSON.stringify(session1.metadata) ==
+                        JSON.stringify(testTrack),
+                    `session1 has wrong track: ${JSON.stringify(
+                        session1.metadata
+                    )}`
+                );
+                assert(
+                    JSON.stringify(session2.metadata) ==
+                        JSON.stringify(testTrack),
+                    `session2 has wrong track: ${JSON.stringify(
+                        session2.metadata
+                    )}`
+                );
             });
         } finally {
             await space1.leave();
@@ -210,7 +251,7 @@ describe('SharedMediaSessionCoordinator', () => {
     //         const session2 = new TestMediaSession(testTrack, laggerPosition);
     //         const coordinator2 = new SharedMediaSessionCoordinator(space2, session2, session2.name);
     //         coordinator2.positionUpdateInterval = 0.02;
-            
+
     //         await session1.coordinator.join();
     //         await coordinator2.join();
 
@@ -227,5 +268,4 @@ describe('SharedMediaSessionCoordinator', () => {
     //         await space2.leave();
     //     }
     // });
-
-});
+});