@microsoft/live-share-media 2.0.0-internal.7 → 2.0.0-internal.9

package/bin/test/test/LiveMediaSession_Synchronizer.spec.js

@@ -1,669 +0,0 @@
-"use strict";
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const TestUtils_1 = require("./TestUtils");
-const assert_1 = require("assert");
-const internal_1 = require("@fluidframework/test-utils/internal");
-const live_share_1 = require("@microsoft/live-share");
-const internal_2 = require("@microsoft/live-share/internal");
-const MediaPlayerSynchronizer_1 = require("../MediaPlayerSynchronizer");
-const test_utils_1 = require("@live-share-private/test-utils");
-function getObjects(getTestObjectProvider_1) {
-    return __awaiter(this, arguments, void 0, function* (getTestObjectProvider, updateInterval = 10000, timestampProvider = new live_share_1.LocalTimestampProvider()) {
-        const host = live_share_1.TestLiveShareHost.create();
-        let liveRuntime1 = new internal_2.MockLiveShareRuntime(false, updateInterval, host, timestampProvider);
-        let liveRuntime2 = new internal_2.MockLiveShareRuntime(false, updateInterval, host, timestampProvider);
-        let ObjectProxy1 = (0, internal_2.getLiveDataObjectKind)(TestUtils_1.TestLiveMediaSession, liveRuntime1);
-        let ObjectProxy2 = (0, internal_2.getLiveDataObjectKind)(TestUtils_1.TestLiveMediaSession, liveRuntime2);
-        yield liveRuntime1.start();
-        yield liveRuntime2.start();
-        let provider = getTestObjectProvider();
-        let container1 = yield provider.createContainer(ObjectProxy1.factory);
-        let object1 = yield (0, internal_1.getContainerEntryPointBackCompat)(container1);
-        object1.coordinator.positionUpdateInterval = 0.02;
-        let container2 = yield provider.loadContainer(ObjectProxy2.factory);
-        let object2 = yield (0, internal_1.getContainerEntryPointBackCompat)(container2);
-        object2.coordinator.positionUpdateInterval = 0.02;
-        // need to be connected to send signals
-        if (!container1.connect) {
-            yield new Promise((resolve) => container1.once("connected", resolve));
-        }
-        if (!container2.connect) {
-            yield new Promise((resolve) => container2.once("connected", resolve));
-        }
-        const setObjectRoles = (clientId, roles) => __awaiter(this, void 0, void 0, function* () {
-            host.addClient(clientId, roles);
-        });
-        const dispose = () => {
-            var _a, _b;
-            object1.dispose();
-            object2.dispose();
-            (_a = container1.disconnect) === null || _a === void 0 ? void 0 : _a.call(container1);
-            (_b = container2.disconnect) === null || _b === void 0 ? void 0 : _b.call(container2);
-            liveRuntime1.stop();
-            liveRuntime2.stop();
-        };
-        return {
-            object1,
-            object2,
-            dispose,
-            setObjectRoles,
-        };
-    });
-}
-(0, test_utils_1.describeCompat)("LiveMediaSession Using MediaPlayerSynchronizer", (getTestObjectProvider) => {
-    it("should play and pause on both", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize();
-        yield object2.initialize();
-        const expectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "pause",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise = assertExpectedEvents(sync2, expectedEventOrder);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(100);
-        yield sync2.pause();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "pause");
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.1));
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should seek forward and play then pause", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize();
-        yield object2.initialize();
-        const expectedEventOrder = [
-            {
-                action: "seekto",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "pause",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise = assertExpectedEvents(sync2, expectedEventOrder);
-        yield sync1.seekTo(2);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(100);
-        yield sync2.pause();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "pause");
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 2.1));
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should play then seek forward then pause", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize();
-        yield object2.initialize();
-        const expectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "seekto",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "pause",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise = assertExpectedEvents(sync2, expectedEventOrder);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(100);
-        yield sync1.seekTo(2);
-        yield (0, internal_2.waitForDelay)(100);
-        yield sync2.pause();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "pause");
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 2.1));
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should play then seek backwards then keep playing", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize();
-        yield object2.initialize();
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(200);
-        yield sync2.seekTo(0.05);
-        yield (0, internal_2.waitForDelay)(100);
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.15));
-        dispose();
-    }));
-    it("should change playback rate", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize();
-        yield object2.initialize();
-        const expectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "ratechange",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise = assertExpectedEvents(sync2, expectedEventOrder);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield sync2.setPlaybackRate(2);
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "ratechange");
-        yield (0, internal_2.waitForDelay)(100);
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.2));
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should only let organizer play, pause, seek", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose, setObjectRoles } = yield getObjects(getTestObjectProvider);
-        setObjectRoles(yield object1.clientId(), [
-            live_share_1.UserMeetingRole.organizer,
-        ]);
-        setObjectRoles(yield object2.clientId(), [
-            live_share_1.UserMeetingRole.attendee,
-        ]);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        yield object2.initialize([live_share_1.UserMeetingRole.organizer]);
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        yield assertRoleError(() => sync2.play());
-        yield assertRoleError(() => sync2.seekTo(100));
-        yield assertRoleError(() => sync2.pause());
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield sync1.pause();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "pause");
-        yield sync1.seekTo(100);
-        // wait till the next event loop
-        yield (0, internal_2.waitForDelay)(1);
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 100));
-        dispose();
-    }));
-    it("should setTrack", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        yield object2.initialize([live_share_1.UserMeetingRole.organizer]);
-        const expectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "settrack",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise = assertExpectedEvents(sync2, expectedEventOrder);
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(100);
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.1));
-        const metadata = {
-            trackIdentifier: "testTrackId",
-            liveStream: false,
-            album: "",
-            artist: "",
-            artwork: [],
-            title: "",
-        };
-        yield sync1.setTrack(metadata);
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "load");
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should beginSeek and suspend till endSeek", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        yield object2.initialize([live_share_1.UserMeetingRole.organizer]);
-        const object1ExpectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object2.clientId(),
-                local: false,
-                source: "user",
-                ignoreReason: "localusersuspended", // emitted by group action, but ignored with reason "localusersuspended".
-            },
-            {
-                action: "seekto",
-                clientId: yield object1.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const object2ExpectedEventOrder = [
-            {
-                action: "play",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "user",
-            },
-            {
-                action: "seekto",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise1 = assertExpectedEvents(sync1, object1ExpectedEventOrder);
-        const eventAssertPromise2 = assertExpectedEvents(sync2, object2ExpectedEventOrder);
-        yield sync1.beginSeek();
-        yield sync2.play();
-        yield assertActionOccurred([testMediaPlayer2], "play");
-        yield (0, internal_2.waitForDelay)(100);
-        // should not be synced
-        isAtExpectedTime(testMediaPlayer1, 0);
-        isAtExpectedTime(testMediaPlayer2, 0.1);
-        yield sync1.endSeek(0.4);
-        // wait till the next event loop
-        yield (0, internal_2.waitForDelay)(1);
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.4));
-        yield eventAssertPromise1;
-        yield eventAssertPromise2;
-        dispose();
-    }));
-    it("should not load twice", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        const expectedEventOrder = [
-            {
-                action: "settrack",
-                clientId: yield object1.clientId(),
-                local: true,
-                source: "user",
-            },
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const eventAssertPromise = assertExpectedEvents(sync1, expectedEventOrder);
-        const metadata = {
-            trackIdentifier: "testTrackId",
-            liveStream: false,
-            album: "",
-            artist: "",
-            artwork: [],
-            title: "",
-        };
-        yield sync1.setTrack(metadata, [{ position: 1000 }]);
-        yield assertActionOccurred([testMediaPlayer1], "load");
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1], "play");
-        yield eventAssertPromise;
-        dispose();
-    }));
-    it("should suspend at waitpoint with DIFFERENT player for ad", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testAdPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        const testAdPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        yield object2.initialize([live_share_1.UserMeetingRole.organizer]);
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        object2.synchronize(testMediaPlayer2);
-        const waitPoints = [{ position: 0.7 }];
-        const metadata = {
-            trackIdentifier: "testTrackId",
-            liveStream: false,
-            album: "",
-            artist: "",
-            artwork: [],
-            title: "",
-        };
-        const adFinished1 = new internal_2.Deferred();
-        const adFinished2 = new internal_2.Deferred();
-        object1.setActionHandler("wait", (details) => __awaiter(void 0, void 0, void 0, function* () {
-            // pause content
-            testMediaPlayer1.pause();
-            testAdPlayer1.src = "testAdId";
-            // load ad
-            testAdPlayer1.load();
-            yield assertActionOccurred([testAdPlayer1], "load");
-            // play ad
-            testAdPlayer1.play();
-            yield assertActionOccurred([testAdPlayer1], "play");
-            yield (0, internal_2.waitForDelay)(500);
-            (0, assert_1.strict)(isAtExpectedTime(testAdPlayer1, 0.5));
-            adFinished1.resolve();
-            details.suspension.end();
-        }));
-        object2.setActionHandler("wait", (details) => __awaiter(void 0, void 0, void 0, function* () {
-            // pause content
-            testMediaPlayer2.pause();
-            testAdPlayer2.src = "testAdId";
-            // load ad
-            testAdPlayer2.load();
-            yield assertActionOccurred([testAdPlayer2], "load");
-            // play ad
-            testAdPlayer2.play();
-            yield assertActionOccurred([testAdPlayer2], "play");
-            yield (0, internal_2.waitForDelay)(500);
-            (0, assert_1.strict)(isAtExpectedTime(testAdPlayer2, 0.5));
-            adFinished2.resolve();
-            details.suspension.end();
-        }));
-        yield sync1.setTrack(metadata, waitPoints);
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "load");
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        // expect pause from waitpoint actionHandler
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "pause");
-        // wait for ad to play
-        yield Promise.all([adFinished1.promise, adFinished2.promise]);
-        (0, assert_1.strict)(testMediaPlayer1.src === metadata.trackIdentifier);
-        (0, assert_1.strict)(testMediaPlayer2.src === metadata.trackIdentifier);
-        (0, assert_1.strict)(testMediaPlayer1.paused === true);
-        (0, assert_1.strict)(testMediaPlayer2.paused === true);
-        // sdk checks for waitpoints ever 500ms
-        const waitPointVariance = 0.5;
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.7, waitPointVariance));
-        dispose();
-    }));
-    it("should suspend at waitpoint with SAME player for ad", () => __awaiter(void 0, void 0, void 0, function* () {
-        // Using the same player for an ad is not recommended
-        // see unit test titled "should suspend at waitpoint with DIFFERENT player for ad" for recommended approach
-        // it can still be done with the same player, described below
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider);
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer();
-        yield object1.initialize([live_share_1.UserMeetingRole.organizer]);
-        yield object2.initialize([live_share_1.UserMeetingRole.organizer]);
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        object2.synchronize(testMediaPlayer2);
-        const waitPoints = [{ position: 0.7 }];
-        const metadata = {
-            trackIdentifier: "testTrackId",
-            liveStream: false,
-            album: "",
-            artist: "",
-            artwork: [],
-            title: "",
-        };
-        const adFinished1 = new internal_2.Deferred();
-        const adFinished2 = new internal_2.Deferred();
-        object1.setActionHandler("wait", (details) => __awaiter(void 0, void 0, void 0, function* () {
-            testMediaPlayer1.src = "testAdId";
-            // load ad
-            testMediaPlayer1.load();
-            yield assertActionOccurred([testMediaPlayer1], "load");
-            // play ad
-            testMediaPlayer1.play();
-            yield assertActionOccurred([testMediaPlayer1], "play");
-            yield (0, internal_2.waitForDelay)(500);
-            (0, assert_1.strict)(isAtExpectedTime(testMediaPlayer1, 0.5));
-            adFinished1.resolve();
-            // MUST reset src and currentTime if using the same mediaPlayer before ending the suspension
-            testMediaPlayer1.src = metadata.trackIdentifier;
-            testMediaPlayer1.load(); // will put in paused state in test implementation
-            testMediaPlayer1.currentTime =
-                details.suspension.waitPoint.position;
-            details.suspension.end();
-        }));
-        object2.setActionHandler("wait", (details) => __awaiter(void 0, void 0, void 0, function* () {
-            testMediaPlayer2.src = "testAdId";
-            // load ad
-            testMediaPlayer2.load();
-            yield assertActionOccurred([testMediaPlayer2], "load");
-            // play ad
-            testMediaPlayer2.play();
-            yield assertActionOccurred([testMediaPlayer2], "play");
-            yield (0, internal_2.waitForDelay)(500);
-            (0, assert_1.strict)(isAtExpectedTime(testMediaPlayer2, 0.5));
-            adFinished2.resolve();
-            // MUST reset src and currentTime if using the same mediaPlayer before ending the suspension
-            testMediaPlayer2.src = metadata.trackIdentifier;
-            testMediaPlayer2.load(); // will put in paused state in test implementation
-            testMediaPlayer2.currentTime =
-                details.suspension.waitPoint.position;
-            details.suspension.end();
-        }));
-        yield sync1.setTrack(metadata, waitPoints);
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "load");
-        yield sync1.play();
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "play");
-        // wait for ad to play
-        yield Promise.all([adFinished1.promise, adFinished2.promise]);
-        // check original src was loaded again
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "load");
-        (0, assert_1.strict)(testMediaPlayer1.src === metadata.trackIdentifier);
-        (0, assert_1.strict)(testMediaPlayer2.src === metadata.trackIdentifier);
-        // checked should be paused at waitpoint
-        (0, assert_1.strict)(testMediaPlayer1.paused === true);
-        (0, assert_1.strict)(testMediaPlayer2.paused === true);
-        // sdk checks for waitpoints ever 500ms, but not specifying the variance here,
-        // because video will roll back to waitpoint position (rewinding up to 500ms)
-        (0, assert_1.strict)(isSynced(testMediaPlayer1, testMediaPlayer2, 0.7));
-        dispose();
-    }));
-    it("client should catchup to leader", () => __awaiter(void 0, void 0, void 0, function* () {
-        const { object1, object2, dispose } = yield getObjects(getTestObjectProvider, 10000, new TestUtils_1.TestMediaTimeStampProvider());
-        const catchupTriggered = new internal_2.Deferred();
-        const metadata = {
-            trackIdentifier: "testTrackId",
-            liveStream: false,
-            album: "",
-            artist: "",
-            artwork: [],
-            title: "",
-        };
-        const testMediaPlayer1 = new TestUtils_1.TestMediaPlayer();
-        const testMediaPlayer2 = new TestUtils_1.TestMediaPlayer((currentTime) => {
-            console.log("currentTime", currentTime);
-            if (isSynced(testMediaPlayer1, testMediaPlayer2, testMediaPlayer1.currentTime) &&
-                currentTime >= 1) {
-                catchupTriggered.resolve();
-            }
-        });
-        yield object1.initialize();
-        yield object2.initialize();
-        const object1ExpectedEventOrder = [
-            {
-                action: "settrack",
-                clientId: yield object1.clientId(),
-                local: true,
-                source: "user",
-            },
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: true,
-                source: "user",
-            },
-        ];
-        const object2ExpectedEventOrder = [
-            {
-                action: "settrack",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "user",
-            },
-            {
-                action: "catchup",
-                clientId: yield object2.clientId(),
-                local: true,
-                source: "system",
-            },
-            {
-                action: "play",
-                clientId: yield object1.clientId(),
-                local: false,
-                source: "system",
-            },
-        ];
-        const sync1 = object1.synchronize(testMediaPlayer1);
-        const sync2 = object2.synchronize(testMediaPlayer2);
-        const eventAssertPromise1 = assertExpectedEvents(sync1, object1ExpectedEventOrder);
-        const eventAssertPromise2 = assertExpectedEvents(sync2, object2ExpectedEventOrder);
-        yield sync1.setTrack(metadata);
-        yield assertActionOccurred([testMediaPlayer1, testMediaPlayer2], "load");
-        yield sync1.play();
-        // simulate testMediaPlayer2 getting behind
-        setInterval(() => {
-            testMediaPlayer2.pause();
-        }, 100);
-        yield catchupTriggered.promise;
-        yield eventAssertPromise1;
-        yield eventAssertPromise2;
-        dispose();
-    }));
-});
-function isSynced(player1, player2, expectedTime, maxVariance = 10) {
-    console.log(player1.currentTime, player2.currentTime);
-    return (isAtExpectedTime(player1, expectedTime, maxVariance) &&
-        isAtExpectedTime(player2, expectedTime, maxVariance));
-}
-function isAtExpectedTime(player, expectedTime, maxVariance = 10) {
-    return Math.abs(player.currentTime - expectedTime) <= maxVariance;
-}
-function assertRoleError(command) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield command();
-            (0, assert_1.strict)(false);
-        }
-        catch (e) {
-            if ((0, internal_2.isErrorLike)(e)) {
-                console.log(e);
-                (0, assert_1.strict)(e.message.includes('The local user doesn\'t have a role of ["Organizer"]'));
-            }
-            else {
-                (0, assert_1.strict)(false);
-            }
-        }
-    });
-}
-function assertActionOccurred(players, expectedAction) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const actions = yield Promise.all(players.map((player) => player.waitForAction()));
-        actions.forEach((action) => {
-            (0, assert_1.strict)(action === expectedAction);
-        });
-    });
-}
-function assertExpectedEvents(synchronizer, expectedEventOrder) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let deferred = new internal_2.Deferred();
-        let eventCount = 0;
-        let timeout;
-        synchronizer.addEventListener(MediaPlayerSynchronizer_1.MediaPlayerSynchronizerEvents.groupaction, (evt) => {
-            try {
-                const details = evt.details;
-                (0, assert_1.strict)(evt.error === undefined, evt.error);
-                const expectedEvent = expectedEventOrder[eventCount];
-                (0, assert_1.strict)(details.action === expectedEvent.action, `unexpected action: should be ${expectedEvent.action}, instead is ${details.action}`);
-                (0, assert_1.strict)(details.clientId ===
-                    expectedEventOrder[eventCount].clientId, `unexpected sender clientId: should be ${expectedEvent.clientId}, instead is ${details.clientId}`);
-                (0, assert_1.strict)(details.local === expectedEventOrder[eventCount].local, `unexpected locality: should be ${expectedEvent.local}, instead is ${details.local}`);
-                (0, assert_1.strict)(details.source === expectedEventOrder[eventCount].source, `unexpected source: should be ${expectedEvent.source}, instead is ${details.source}`);
-                eventCount += 1;
-            }
-            catch (error) {
-                deferred.reject(new Error(`error for event: ${JSON.stringify(evt)}, eventCount ${eventCount}, ${error}`));
-            }
-            if (eventCount === expectedEventOrder.length) {
-                timeout = setTimeout(() => {
-                    deferred.resolve();
-                }, 200);
-            }
-            else if (eventCount > expectedEventOrder.length) {
-                deferred.reject(new Error(`more events than expected, ${evt}`));
-            }
-        });
-        return deferred.promise;
-    });
-}
-//# sourceMappingURL=LiveMediaSession_Synchronizer.spec.js.map