@amazon/vinyl 1.2.0 → 1.2.2

package/dist/unit/types/current/drm/DrmControllerImpl.test.js

@@ -2,9 +2,9 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, EXCESSIVE_SESSION_COUNT, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
-import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, utf16ToUint16Array, } from '@amazon/vinyl-util';
+import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, setUserAgent, utf16ToUint16Array, } from '@amazon/vinyl-util';
 import { flushPromises, implementEventFakes, MockHTMLAudioElement, MockMediaError, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
 import { MockCommonEme, MockCommonMediaKeys, MockCommonMediaKeySession, MockCommonMediaKeySystemAccess, } from '@amazon/vinyl/vinylTestUtil';
 var createSpy = jasmine.createSpy;
@@ -331,6 +331,17 @@ describe('DrmControllerImpl', () => {
                 expect(sessions.map((session) => session.dispose.calls.count())).toEqual([1, 1, 1, 1, 1, 1]); // Expect all sessions to have been disposed
                 expect(drmController.activeSessions).toEqual(0);
             });
+            it('does not close sessions again after dispose', async () => {
+                const abort = new Abort();
+                drmController.setBufferingDrmInfo(drmInfo, abort);
+                await emitEncrypted();
+                const session = mediaKeys.createSession.calls.mostRecent()
+                    .returnValue;
+                drmController.dispose();
+                const disposeCount = session.dispose.calls.count();
+                abort.abort();
+                expect(session.dispose.calls.count()).toBe(disposeCount);
+            });
         });
     });
     describe('when an encrypted event is observed', () => {
@@ -1048,6 +1059,24 @@ describe('DrmControllerImpl', () => {
             expect(drmController.isEmeSupported()).toBeFalse();
         });
     });
+    describe('excessive sessions', () => {
+        it('warns once when the open session count exceeds the threshold', async () => {
+            drmController.setBufferingDrmInfo(drmInfo);
+            // Distinct init data per event so each opens its own session.
+            for (let i = 0; i < EXCESSIVE_SESSION_COUNT; i++) {
+                await emitEncrypted(new Uint8Array([i]));
+            }
+            expect(drmController.activeSessions).toBe(EXCESSIVE_SESSION_COUNT);
+            expect(logger.value.warn).not.toHaveBeenCalled();
+            // Crossing the threshold warns.
+            await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT]));
+            expect(drmController.activeSessions).toBe(EXCESSIVE_SESSION_COUNT + 1);
+            expect(logger.value.warn).toHaveBeenCalledTimes(1);
+            // Further sessions past the threshold don't re-warn.
+            await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT + 1]));
+            expect(logger.value.warn).toHaveBeenCalledTimes(1);
+        });
+    });
     describe('closeSessions', () => {
         it('clears active sessions', async () => {
             const sessionCloseSpy = createEventSpy(drmController, 'sessionClose');
@@ -1275,6 +1304,71 @@ describe('DrmControllerImpl', () => {
             ]);
         });
     });
+    describe('ChromeOS verified media path', () => {
+        // ChromeOS only enables the verified media path (VMP) when a video
+        // capability is present, so audio-only content must advertise a dummy
+        // avc1 video capability alongside its audio capability.
+        const chromeOsUserAgent = 'Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        const chromeUserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36';
+        it('adds avc1 video capabilities for audio content on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            expect(commonEme.requestMediaKeySystemAccess).toHaveBeenCalledOnceWith(DrmKeySystem.WIDEVINE, [
+                {
+                    initDataTypes: ['cenc'],
+                    audioCapabilities: [
+                        {
+                            contentType: 'audio/mp4',
+                            encryptionScheme: 'cenc',
+                            robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                        },
+                    ],
+                    videoCapabilities: [
+                        {
+                            contentType: 'video/mp4; codecs="avc1.4d401f"',
+                            robustness: DrmRobustness.SW_SECURE_DECODE,
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('does not add video capabilities for audio content off ChromeOS', async () => {
+            setUserAgent(chromeUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'audio',
+                mimeType: 'audio/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toBeUndefined();
+        });
+        it('does not alter video content capabilities on ChromeOS', async () => {
+            setUserAgent(chromeOsUserAgent);
+            drmController.setBufferingDrmInfo({
+                ...drmInfo,
+                contentType: 'video',
+                mimeType: 'video/mp4',
+            });
+            await emitEncrypted();
+            const config = commonEme.requestMediaKeySystemAccess.calls.mostRecent()
+                .args[1][0];
+            expect(config.videoCapabilities).toEqual([
+                {
+                    contentType: 'video/mp4',
+                    encryptionScheme: 'cenc',
+                    robustness: DrmRobustness.SW_SECURE_CRYPTO,
+                },
+            ]);
+            expect(config.audioCapabilities).toBeUndefined();
+        });
+    });
     describe('when a session has been created', () => {
         beforeEach(async () => {
             drmController.setBufferingDrmInfo(drmInfo);

package/dist/unit/types/current/playback/createStallDetector.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createStallDetector.test.d.ts.map

package/dist/unit/types/current/playback/createStallDetector.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStallDetector.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/playback/createStallDetector.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/playback/createStallDetector.test.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallDetector } from '@amazon/vinyl';
+import { implementEventFakes, MockHTMLAudioElement, mockEvent, MockTimeRanges, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallDetector', () => {
+    const clock = useMockTime();
+    let media;
+    let fabricatePlaying;
+    let stop;
+    beforeEach(() => {
+        media = new MockHTMLAudioElement();
+        implementEventFakes(media);
+        media.play.and.returnValue(Promise.resolve());
+        media.paused = false;
+        media.ended = false;
+        media.readyState = media.HAVE_ENOUGH_DATA;
+        media.currentTime = 10;
+        media.buffered = new MockTimeRanges([[0, 100]]);
+        fabricatePlaying = jasmine.createSpy('fabricatePlaying');
+    });
+    afterEach(() => {
+        stop?.();
+    });
+    function detect(overrides = {}) {
+        stop = createStallDetector(media, { fabricatePlaying, ...overrides });
+    }
+    /** Advances the mock clock by `n` default poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++) {
+            await clock.tick(0.25);
+        }
+    }
+    describe('a stall inside ready buffered data', () => {
+        it('nudges the play head once frozen past the stall threshold', async () => {
+            detect();
+            // Threshold is 0.75s = three polls; the third nudges by stallSkip.
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('does not recover before the stall threshold', async () => {
+            detect();
+            await poll(2);
+            expect(media.currentTime).toBe(10);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('nudges even when the ready state is low (iOS reports a stale readyState)', async () => {
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('keeps nudging, then gives up after maxAttempts', async () => {
+            detect();
+            // Default maxAttempts is 3, so at most three nudges (one every 3 polls).
+            await poll(12);
+            expect(media.currentTime).toBeCloseTo(10.3);
+            // Further polls do nothing; the detector has stopped.
+            await poll(6);
+            expect(media.currentTime).toBeCloseTo(10.3);
+        });
+    });
+    describe('a stall with no data at the playhead', () => {
+        it('does not recover when the playhead is outside all buffered ranges', async () => {
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('does not recover at the end of buffered data', async () => {
+            // Within the default end margin (0.5s) of the buffer end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+        it('nudges at the end of the media (stuck end-of-track on src)', async () => {
+            // Buffer ends at the media duration: no more data is coming, so a
+            // freeze here is a stuck end-of-track and a nudge drives it to end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            media.duration = 10.3;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('nudges outside buffered ranges when nudgeUnbuffered is set', async () => {
+            // WebKit path: re-issue the seek even though buffered looks empty.
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect({ nudgeUnbuffered: true });
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('stops when the source is emptied', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('emptied'));
+            // Stopped: a later freeze in buffered data is not nudged.
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    describe('fabricating a playing event', () => {
+        it('fabricates when the head progresses without a playing event', async () => {
+            detect();
+            media.currentTime = 20;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+            // Detector stopped; a later freeze is not recovered.
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('does not fabricate when a real playing event fired and it keeps progressing', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            media.currentTime = 20;
+            await poll(6);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('fabricates after reviving a stall even if a playing event fired earlier', async () => {
+            // iOS pattern: a playing event fires, then playback stalls.
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1); // nudged (recovered)
+            // The recovery revives playback.
+            media.currentTime = 11;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('when the element is not advancing by design', () => {
+        it('does not recover while paused', async () => {
+            media.paused = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+        it('does not recover once ended', async () => {
+            media.ended = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    it('honors provided options', async () => {
+        detect({
+            pollInterval: 0.5,
+            stallThreshold: 1,
+            bufferEndMargin: 0.2,
+            stallSkip: 0.25,
+            maxAttempts: 1,
+        });
+        // Threshold 1s = two 0.5s polls; one nudge of 0.25, then it gives up.
+        for (let i = 0; i < 6; i++)
+            await clock.tick(0.5);
+        expect(media.currentTime).toBeCloseTo(10.25);
+    });
+});

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createStallMonitor.test.d.ts.map

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStallMonitor.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/playback/createStallMonitor.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/playback/createStallMonitor.test.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallMonitor, StallEndedReason, } from '@amazon/vinyl';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallMonitor', () => {
+    const clock = useMockTime();
+    let host;
+    let onStallEntered;
+    let onStallEnded;
+    let stop;
+    beforeEach(() => {
+        host = new EventHostImpl();
+        onStallEntered = jasmine.createSpy('onStallEntered');
+        onStallEnded = jasmine.createSpy('onStallEnded');
+    });
+    afterEach(() => stop?.());
+    function monitor(overrides = {}) {
+        stop = createStallMonitor(host, { onStallEntered, onStallEnded }, overrides);
+    }
+    /** Advances the mock clock by `n` default (0.25s) poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++)
+            await clock.tick(0.25);
+    }
+    it('does not report a stall before playback is observed', async () => {
+        monitor();
+        // No 'playing' has been observed (e.g. initial load / awaiting a seek).
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('reports a stall once the play head is frozen past the threshold', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(1); // 1s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('honors a configurable threshold', async () => {
+        monitor({ stallThreshold: 2 });
+        host.dispatch('playing', {});
+        await poll(4); // 1s < 2s
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(4); // 2s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not report a stall while timeUpdates keep arriving', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        for (let i = 0; i < 10; i++) {
+            await poll(2); // 0.5s, under the threshold
+            host.dispatch('timeUpdate', { previous: i, current: i + 1 });
+        }
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('ends a stall with reason "playing" when the play head advances, measuring from the last timeUpdate', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        await poll(4); // frozen another 1s (total 2s)
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        const info = onStallEnded.calls.mostRecent().args[0];
+        expect(info.reason).toBe(StallEndedReason.PLAYING);
+        expect(info.duration).toBeCloseTo(2, 1);
+    });
+    for (const [event, reason] of [
+        ['pause', StallEndedReason.PAUSE],
+        ['seeking', StallEndedReason.SEEKING],
+        ['emptied', StallEndedReason.EMPTIED],
+    ]) {
+        it(`ends a stall with reason "${reason}" on ${event}`, async () => {
+            monitor();
+            host.dispatch('playing', {});
+            await poll(4); // stallEntered
+            expect(onStallEntered).toHaveBeenCalledTimes(1);
+            host.dispatch(event, {});
+            expect(onStallEnded).toHaveBeenCalledTimes(1);
+            expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(reason);
+        });
+    }
+    it('ends a stall with reason "playing" when a playing event fires (resume without a timeUpdate)', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4); // stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A 'playing' event (rather than a timeUpdate) signals the resume.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(StallEndedReason.PLAYING);
+    });
+    it('suspends detection after a seek until playback is observed again', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('seeking', {}); // suspends; observedPlaying = false
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+        // Once playback is observed again, detection resumes.
+        host.dispatch('playing', {});
+        await poll(4);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('reports each stall/recovery cycle', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 0, current: 1 }); // resume 1
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume 2
+        expect(onStallEntered).toHaveBeenCalledTimes(2);
+        expect(onStallEnded).toHaveBeenCalledTimes(2);
+    });
+    it('does not end and re-detect a stall on a non-advancing timeUpdate', async () => {
+        // Browsers emit `timeUpdate` even while the play head is frozen, with an unchanged (or
+        // briefly backward) currentTime. These must not be treated as progress, or the stall is
+        // ended and immediately re-detected, doubling the reported events.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 4, current: 5 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Still frozen: currentTime hasn't advanced (unchanged, backward, or sub-epsilon jitter).
+        host.dispatch('timeUpdate', { previous: 5, current: 5 });
+        host.dispatch('timeUpdate', { previous: 5, current: 4.99 });
+        host.dispatch('timeUpdate', { previous: 5, current: 5 + 1e-9 });
+        await poll(4);
+        expect(onStallEnded).not.toHaveBeenCalled();
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A real forward advance ends the stall exactly once.
+        host.dispatch('timeUpdate', { previous: 5, current: 6 });
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not re-detect a stall immediately after resuming via a playing event', async () => {
+        // Resuming via `playing` must restart the freeze clock. Otherwise the poll, still seeing
+        // the stale pre-freeze progress time, immediately re-enters a stall before the first
+        // post-resume timeUpdate arrives — an extra, spurious stall.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Resume with a 'playing' event and no timeUpdate yet.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        // The freeze clock reset on resume, so a sub-threshold gap is not a new stall.
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('stops reporting after disposal', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        stop();
+        stop = undefined; // disposal is single-shot; don't dispose again in afterEach
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+});

package/dist/unit/types/current/streaming/ManifestControllerImpl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ManifestControllerImpl.test.d.ts.map

package/dist/unit/types/current/streaming/ManifestControllerImpl.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifestControllerImpl.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/streaming/ManifestControllerImpl.test.ts"],"names":[],"mappings":""}

package/dist/unit/types/current/streaming/ManifestControllerImpl.test.js

@@ -0,0 +1,197 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from '@amazon/vinyl-util';
+import { ManifestControllerImpl } from '@amazon/vinyl';
+import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { expectNothing, flushPromises, } from '@amazon/vinyl-util/browserTestUtil';
+var createSpy = jasmine.createSpy;
+describe('ManifestControllerImpl', () => {
+    let manifestProvider;
+    beforeEach(() => {
+        manifestProvider = createSpy('manifestProvider');
+        manifestProvider.and.resolveTo(mockHlsManifestData);
+    });
+    function createManifestController() {
+        return new ManifestControllerImpl({ manifestProvider });
+    }
+    it('has a toStringTag', () => {
+        const controller = createManifestController();
+        expect(String(controller)).toContain('ManifestControllerImpl');
+    });
+    it('has a logPrefix', () => {
+        const controller = createManifestController();
+        expect(controller.logPrefix).toBe('ManifestControllerImpl');
+    });
+    describe('refresh', () => {
+        it('reloads the manifest', () => {
+            const controller = createManifestController();
+            controller.refresh();
+            expect(manifestProvider).toHaveBeenCalledTimes(2);
+        });
+        it('notifies observers', () => {
+            const controller = createManifestController();
+            const observer = createSpy('observer');
+            controller.onData(observer);
+            observer.calls.reset();
+            controller.refresh();
+            expect(observer).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('value', () => {
+        it('resolves to the manifest data', async () => {
+            const controller = createManifestController();
+            const result = await controller.value;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+            expect(result.baseUrl).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('getValue', () => {
+        it('returns the same as value', () => {
+            const controller = createManifestController();
+            expect(controller.getValue()).toBe(controller.value);
+        });
+    });
+    describe('changeId', () => {
+        it('increments when manifest is refreshed', () => {
+            const controller = createManifestController();
+            const initial = controller.changeId;
+            controller.refresh();
+            expect(controller.changeId).toBe(initial + 1);
+        });
+    });
+    describe('pick', () => {
+        it('returns a sub-observable', () => {
+            const controller = createManifestController();
+            const thenPick = controller.pick('then');
+            expect(thenPick.value).toEqual(jasmine.any(Function));
+        });
+    });
+    describe('map', () => {
+        it('returns a mapped observable', async () => {
+            const controller = createManifestController();
+            const mapped = controller.map(async (promise) => {
+                const data = await promise;
+                return data.baseUrl;
+            });
+            expect(await mapped.value).toBe(mockHlsManifestData.baseUrl);
+        });
+    });
+    describe('disposed', () => {
+        it('returns false before dispose', () => {
+            const controller = createManifestController();
+            expect(controller.disposed).toBe(false);
+        });
+        it('returns true after dispose', () => {
+            const controller = createManifestController();
+            controller.dispose();
+            expect(controller.disposed).toBe(true);
+        });
+    });
+    describe('value - pending', () => {
+        it('resolves pending manifest', async () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const valuePromise = controller.value;
+            deferred.resolve(mockHlsManifestData);
+            const result = await valuePromise;
+            expect(result.mainPlaylist).toBe(mockHlsManifestData.mainPlaylist);
+        });
+    });
+    describe('when manifest provider rejects', () => {
+        it('does not cause an unhandled rejection', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            createManifestController();
+            await flushPromises();
+            expectNothing();
+        });
+        it('rejects the value', async () => {
+            manifestProvider.and.rejectWith(new Error('expected'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejectedWithError('expected');
+        });
+    });
+    describe('error', () => {
+        it('is null when manifest loads successfully', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            expect(controller.error).toBeNull();
+        });
+        it('is set when manifest provider rejects', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).toEqual(jasmine.objectContaining({ message: 'test error' }));
+        });
+        it('is cleared after refresh', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            expect(controller.error).not.toBeNull();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.refresh();
+            expect(controller.error).toBeNull();
+        });
+    });
+    describe('reset', () => {
+        it('refreshes manifest when there was an error', async () => {
+            manifestProvider.and.rejectWith(new Error('test error'));
+            const controller = createManifestController();
+            await expectAsync(controller.value).toBeRejected();
+            manifestProvider.and.resolveTo(mockHlsManifestData);
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(2);
+        });
+        it('does nothing when no error occurred', () => {
+            const controller = createManifestController();
+            const initialCallCount = manifestProvider.calls.count();
+            controller.reset();
+            expect(manifestProvider.calls.count()).toBe(initialCallCount);
+        });
+    });
+    describe('load span metrics', () => {
+        it('dispatches loadSpanMeasured on the initial manifest fetch', async () => {
+            const controller = createManifestController();
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            await controller.value;
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(jasmine.objectContaining({
+                kind: 'manifest',
+                startTime: jasmine.any(Number),
+                endTime: jasmine.any(Number),
+            }));
+        });
+        it('does not re-measure on refresh', async () => {
+            const controller = createManifestController();
+            await controller.value;
+            const spy = createSpy('loadSpanMeasured');
+            controller.on('loadSpanMeasured', spy);
+            controller.refresh();
+            await controller.value;
+            await flushPromises();
+            expect(spy).not.toHaveBeenCalled();
+        });
+        it('reports listeners', () => {
+            const controller = createManifestController();
+            expect(controller.hasAnyListeners()).toBeFalse();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeFalse();
+            controller.on('loadSpanMeasured', createSpy('loadSpanMeasured'));
+            expect(controller.hasAnyListeners()).toBeTrue();
+            expect(controller.hasListeners('loadSpanMeasured')).toBeTrue();
+        });
+    });
+    describe('dispose', () => {
+        it('aborts current request', () => {
+            const deferred = new Deferred();
+            manifestProvider.and.returnValue(deferred);
+            const controller = createManifestController();
+            const abort = manifestProvider.calls.first()
+                .args[0];
+            controller.dispose();
+            expect(abort.aborted()).toBeTrue();
+        });
+    });
+});