@amazon/vinyl 1.1.1 → 2.0.0

package/dist/unit/types/current/index.js

@@ -1,104 +1,123 @@
 /** Auto-generated from build scripts */
+import './ad/AdController.test';
+import './ad/AdControllerImpl.test';
+import './ad/defaultAdLoadOptionsResolver.test';
+import './ad/discoverHlsInterstitials.test';
+import './client/CapabilitiesImpl.test';
+export * from './client/userAgent/userAgentExpectations';
+import './drm/CencEncryptionScheme.test';
+import './drm/commonEme/CommonEme.test';
+import './drm/commonEme/createDrmErrorHandler.test';
+import './drm/commonEme/MsCommonEme.test';
+import './drm/commonEme/StandardCommonEme.test';
+import './drm/commonEme/WebKitCommonEme.test';
+import './drm/CommonEmeFactory.test';
+import './drm/DrmControllerImpl.test';
+import './drm/DrmKeySystem.test';
+import './drm/DrmKeySystemResolver.test';
+import './drm/error/DrmError.test';
+import './drm/licenseProvider/defaultLicenseProvider.test';
+import './drm/util/createFairPlaySessionInitData.test';
+import './drm/util/extractContentId.test';
+import './drm/util/unpackPlayReadyChallenge.test';
+import './event/ChangeEvent.test';
+import './global/configureVinylGlobal.test';
+import './global/environment.test';
+import './global/globalRef.test';
+import './global/PlayerRegistry.test';
+import './patch/media/MediaElementPatchOptions.test';
+import './patch/media/patches/createPreventStallsPatch.test';
+import './patch/media/patches/createUnreliablePlaybackEventsPatch.test';
+import './patch/media/patchMediaElement.test';
+import './playback/error/InvalidSeekError.test';
+import './playback/error/ReportableMediaError.test';
+import './playback/logging/mediaErrorToJson.test';
+import './playback/logging/playbackStateLoggingHandler.test';
+import './playback/nextEventHasMetadata.test';
+import './playback/PlaybackControllerImpl.test';
+import './playback/PlaybackSourceImpl.test';
+import './playback/ReadonlyPlaybackController.test';
 import './setup';
-import './vinylTestUtil/util/playback/createEventSpy.test';
-import './vinyl/playerConfigFactory.test';
-import './vinyl/createVinylFactories.test';
-import './vinyl/VinylPlayer.test';
-import './util/media/sourceBuffer.test';
-import './util/media/mediaSource.test';
-import './util/media/getAudioContext.test';
-import './track/createVinylTrackFactories.test';
-import './track/createSegmentDataProvider.test';
-import './track/TrackFactory.test';
-import './track/TrackController.test';
-import './track/TrackBase.test';
+import './streaming/abr/QualitySelectorImpl.test';
+import './streaming/buffering/BufferingController.test';
+import './streaming/buffering/codecDenylist.test';
+import './streaming/buffering/error/SourceBufferError.test';
+import './streaming/buffering/MediaSourceController.test';
+import './streaming/buffering/SourceBufferController.test';
+import './streaming/ContentStream.test';
+import './streaming/createAllowedContentTypesValue.test';
+import './streaming/createDefaultMediaTimelineTransformer.test';
+import './streaming/DescriptorRecord.test';
+import './streaming/loudness/LoudnessNormalizationControllerImpl.test';
+import './streaming/ManifestControllerImpl.test';
+import './streaming/MediaQualityMetadata.test';
+import './streaming/MediaTimeline.test';
+import './streaming/mediaTimelineAccessibilityFilter.test';
+import './streaming/mediaTimelineFilter.test';
+import './streaming/mediaTimelineLanguageFilter.test';
+import './streaming/MseTrack.test';
+import './streaming/SegmentControllerImpl.test';
+import './streaming/SegmentDataSlot.test';
+import './streaming/SegmentPrefetch.test';
+import './streaming/StreamingEventMap.test';
+import './streaming/util/segment.test';
+import './text/discoverDashTextTracks.test';
+import './text/discoverHlsTextTracks.test';
+import './text/parseWebVtt.test';
+import './text/pickPreferredTextTrack.test';
+import './text/SidecarTextTrackController.test';
+import './text/SidecarTextTrackLoader.test';
+import './text/VttCueStyle.test';
 import './track/AutoResetController.test';
-import './track/source/SourceTrackBase.test';
-import './track/source/SourceTrack.test';
-import './track/source/SourceObjectTrack.test';
-import './track/source/FixedPlaybackQuality.test';
-import './track/mse/codec.test';
-import './track/hls/createUrlHlsManifestProvider.test';
-import './track/hls/createHlsFactories.test';
-import './track/hls/createHlsContentTypesValue.test';
-import './track/hls/createHlsContentStreamFactories.test';
-import './track/hls/createDefaultHlsManifestTransformer.test';
-import './track/hls/buildHlsMediaTimeline.test';
-import './track/hls/HlsTrack.test';
-import './track/hls/HlsMediaQualityMetadataResolver.test';
-import './track/hls/HlsManifestController.test';
-import './track/hls/util/hlsSegmentTime.test';
-import './track/hls/util/hlsByteRangeToMediaRange.test';
-import './track/filters/sampleRateFilter.test';
-import './track/filters/resourceTypeFilter.test';
-import './track/filters/languageFilter.test';
-import './track/filters/keySystemFilter.test';
-import './track/dash/urlDashManifestProvider.test';
-import './track/dash/manifestTransformUtils.test';
-import './track/dash/createSegmentControllerFactory.test';
-import './track/dash/createDefaultDashManifestTransformer.test';
-import './track/dash/createDashManifestProvider.test';
-import './track/dash/createDashFactories.test';
-import './track/dash/createDashContentTypesValue.test';
-import './track/dash/createDashContentStreamFactories.test';
+import './track/createSegmentDataProvider.test';
+import './track/createVinylTrackFactories.test';
 import './track/dash/buildDashMediaTimeline.test';
-import './track/dash/DashTrack.test';
+import './track/dash/createDashContentStreamFactories.test';
+import './track/dash/createDashContentTypesValue.test';
+import './track/dash/createDashFactories.test';
+import './track/dash/createDashManifestProvider.test';
+import './track/dash/createDefaultDashManifestTransformer.test';
+import './track/dash/createSegmentControllerFactory.test';
 import './track/dash/DashMediaQualityMetadataResolver.test';
-import './track/dash/DashManifestController.test';
-import './track/dash/util/uriResolution.test';
-import './track/dash/util/mpd.test';
-import './track/dash/util/mimeType.test';
+import './track/dash/DashTrack.test';
+import './track/dash/manifestTransformUtils.test';
 import './track/dash/timeline/DashRepresentationSegmentProvider.test';
-import './streaming/mediaTimelineLanguageFilter.test';
-import './streaming/mediaTimelineFilter.test';
-import './streaming/createDefaultMediaTimelineTransformer.test';
-import './streaming/StreamingEventMap.test';
-import './streaming/SegmentPrefetch.test';
-import './streaming/SegmentDataSlot.test';
-import './streaming/SegmentControllerImpl.test';
-import './streaming/MseTrack.test';
-import './streaming/MediaTimeline.test';
-import './streaming/MediaQualityMetadata.test';
-import './streaming/DescriptorRecord.test';
-import './streaming/ContentStream.test';
-import './streaming/util/segment.test';
-import './streaming/loudness/LoudnessNormalizationControllerImpl.test';
-import './streaming/buffering/SourceBufferController.test';
-import './streaming/buffering/MediaSourceController.test';
-import './streaming/buffering/BufferingController.test';
-import './streaming/buffering/error/SourceBufferError.test';
-import './streaming/abr/QualitySelectorImpl.test';
-import './playback/nextEventHasMetadata.test';
-import './playback/ReadonlyPlaybackController.test';
-import './playback/PlaybackSourceImpl.test';
-import './playback/PlaybackControllerImpl.test';
-import './playback/logging/playbackStateLoggingHandler.test';
-import './playback/logging/mediaErrorToJson.test';
-import './playback/error/ReportableMediaError.test';
-import './playback/error/InvalidSeekError.test';
-import './patch/media/patchMediaElement.test';
-import './patch/media/MediaElementPatchOptions.test';
-import './patch/media/patches/createUnreliablePlaybackEventsPatch.test';
-import './patch/media/patches/createPreventStallsPatch.test';
-import './global/globalRef.test';
-import './global/environment.test';
-import './global/configureVinylGlobal.test';
-import './global/PlayerRegistry.test';
-import './event/ChangeEvent.test';
-import './drm/DrmKeySystemResolver.test';
-import './drm/DrmKeySystem.test';
-import './drm/DrmControllerImpl.test';
-import './drm/CommonEmeFactory.test';
-import './drm/CencEncryptionScheme.test';
-import './drm/util/unpackPlayReadyChallenge.test';
-import './drm/util/extractContentId.test';
-import './drm/util/createFairPlaySessionInitData.test';
-import './drm/licenseProvider/defaultLicenseProvider.test';
-import './drm/error/DrmError.test';
-import './drm/commonEme/createDrmErrorHandler.test';
-import './drm/commonEme/WebKitCommonEme.test';
-import './drm/commonEme/StandardCommonEme.test';
-import './drm/commonEme/MsCommonEme.test';
-import './drm/commonEme/CommonEme.test';
-import './client/CapabilitiesImpl.test';
-export * from './client/userAgent/userAgentExpectations';
+import './track/dash/urlDashManifestProvider.test';
+import './track/dash/util/mimeType.test';
+import './track/dash/util/mpd.test';
+import './track/dash/util/uriResolution.test';
+import './track/filters/keySystemFilter.test';
+import './track/filters/languageFilter.test';
+import './track/filters/resourceTypeFilter.test';
+import './track/filters/sampleRateFilter.test';
+import './track/hls/buildHlsMediaTimeline.test';
+import './track/hls/createDefaultHlsManifestTransformer.test';
+import './track/hls/createHlsContentStreamFactories.test';
+import './track/hls/createHlsContentTypesValue.test';
+import './track/hls/createHlsFactories.test';
+import './track/hls/createUrlHlsManifestProvider.test';
+import './track/hls/HlsManifestController.test';
+import './track/hls/HlsMediaQualityMetadataResolver.test';
+import './track/hls/HlsTrack.test';
+import './track/hls/util/hlsByteRangeToMediaRange.test';
+import './track/hls/util/hlsSegmentTime.test';
+import './track/inferLoadOptionsFromUri.test';
+import './track/mse/codec.test';
+import './track/source/FixedPlaybackQuality.test';
+import './track/source/SourceObjectTrack.test';
+import './track/source/SourceTrack.test';
+import './track/source/SourceTrackBase.test';
+import './track/TrackBase.test';
+import './track/TrackController.test';
+import './track/TrackFactory.test';
+import './util/media/codecOverrides.test';
+import './util/media/codecSupport.test';
+import './util/media/getAudioContext.test';
+import './util/media/mediaSource.test';
+import './util/media/sourceBuffer.test';
+import './vinyl/createVinylFactories.test';
+import './vinyl/playerConfigFactory.test';
+import './vinyl/VinylPlayer.test';
+import './vinyl/VinylPlayerAdBreaks.test';
+import './vinyl/VinylPlayerTextTracks.test';
+import './vinylTestUtil/util/playback/createEventSpy.test';

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

@@ -199,6 +199,31 @@ describe('PlaybackController', () => {
                     await seeked;
                     expect(media.currentTime).toBe(3);
                 });
+                it('does not let a metadata-deferred seek clobber a newer seek', async () => {
+                    // Reproduces the real race: the activate-time seek to the
+                    // track start parks waiting for the `loadedmetadata` EVENT.
+                    // Meanwhile readyState reaches HAVE_METADATA, so a
+                    // later-issued seek proceeds immediately and applies its
+                    // target. When the `loadedmetadata` event finally fires, the
+                    // parked stale seek must NOT reset the position back over the
+                    // newer target — it resolves as a no-op and the newer wins.
+                    enableSeekAutoComplete();
+                    // Stale seek parks: no metadata yet.
+                    const stale = controller.seekTo(0);
+                    // Metadata becomes available (readyState) WITHOUT the event
+                    // dispatching yet, so the next seek does not park.
+                    media.readyState = PlaybackReadyState.HAVE_METADATA;
+                    media.duration = 10;
+                    media.seekable = new MockTimeRanges([[0, 10]]);
+                    const newer = controller.seekTo(3);
+                    await expectAsync(newer).toBeResolved();
+                    expect(media.currentTime).toBe(3);
+                    // Now the deferred event fires and the stale seek resumes.
+                    media.dispatchEvent(mockEvent('loadedmetadata'));
+                    await expectAsync(stale).toBeResolved();
+                    // The stale seek did not clobber the newer target back to 0.
+                    expect(media.currentTime).toBe(3);
+                });
                 it('constrains seeks to allowable ranges within tolerance', async () => {
                     const minSeekableBuffer = controller.options.minSeekableBuffer;
                     enableSeekAutoComplete();
@@ -226,10 +251,24 @@ describe('PlaybackController', () => {
                     const unchangedTime = media.currentTime;
                     loggingRef.value.warn.calls.reset();
                     await expectAsync(controller.seekTo(29, 0.5)).toBeRejectedWithError('Could not seek to time: 29, outside of seekable ranges [[30, 50], [70, 100]] with tolerance 0.5');
-                    expect(loggingRef.value.warn).toHaveBeenCalledOnceWith(controller, 'seekTo: seek outside of seekable ranges, seek ignored');
+                    expect(loggingRef.value.warn).toHaveBeenCalledOnceWith(controller, 'seekTo: seek outside of seekable ranges, seek ignored', jasmine.anything());
                     loggingRef.value.warn.calls.reset();
                     expect(media.currentTime).toBe(unchangedTime);
                 });
+                it('does not reserve the end-of-range buffer when paused', async () => {
+                    // The buffer only matters so playback can resume near the
+                    // end; while paused a seek may land at the exact range end.
+                    const minSeekableBuffer = controller.options.minSeekableBuffer;
+                    enableSeekAutoComplete();
+                    setSeekable([[30, 100]]);
+                    media.paused = true;
+                    await controller.seekTo(100.5);
+                    expect(media.currentTime).toBe(100);
+                    // Playing again re-applies the buffer.
+                    media.paused = false;
+                    await controller.seekTo(100.5);
+                    expect(media.currentTime).toBe(100 - minSeekableBuffer);
+                });
                 describe('when there is no seekable range within tolerance after metadata', () => {
                     it('logs warning messages when necessary', async () => {
                         enableSeekAutoComplete();
@@ -238,7 +277,7 @@ describe('PlaybackController', () => {
                             [100, 120],
                         ]);
                         await expectAsync(controller.seekTo(10)).toBeRejectedWithError(`Could not seek to time: 10, outside of seekable ranges [[3, 5], [100, 120]] with tolerance 0.5`);
-                        expect(loggingRef.value.warn).toHaveBeenCalledOnceWith(controller, 'seekTo: seek outside of seekable ranges, seek ignored');
+                        expect(loggingRef.value.warn).toHaveBeenCalledOnceWith(controller, 'seekTo: seek outside of seekable ranges, seek ignored', jasmine.anything());
                     });
                 });
                 it('does not no-op if time is not within tolerance of seek time', async () => {
@@ -377,6 +416,10 @@ describe('PlaybackController', () => {
                     media.dispatchEvent(mockEvent('pause'));
                     expect(pauseSpy).toHaveBeenCalledWith({});
                     pauseSpy.calls.reset();
+                    const resizeSpy = createSpy('resize');
+                    controller.on('resize', resizeSpy);
+                    media.dispatchEvent(mockEvent('resize'));
+                    expect(resizeSpy).toHaveBeenCalledWith({});
                 });
                 describe('durationChange', () => {
                     it(`emits a change event on media's durationchange`, () => {
@@ -567,6 +610,7 @@ describe('PlaybackController', () => {
                         expect(playedSpy).not.toHaveBeenCalled();
                         clock.mockDate(new Date(60_000));
                         media.currentTime = 30;
+                        media.dispatchEvent(mockEvent('timeupdate'));
                         media.dispatchEvent(mockEvent('seeking'));
                         expect(playedSpy).toHaveBeenCalledOnceWith({
                             started: 11_000,
@@ -585,6 +629,7 @@ describe('PlaybackController', () => {
                         expect(playedSpy).not.toHaveBeenCalled();
                         clock.mockDate(new Date(17_000));
                         media.currentTime = 53;
+                        media.dispatchEvent(mockEvent('timeupdate'));
                         media.dispatchEvent(mockEvent('ended'));
                         expect(playedSpy).toHaveBeenCalledOnceWith({
                             started: 13_000,
@@ -595,6 +640,51 @@ describe('PlaybackController', () => {
                         });
                         expect(controller.playing).toBeFalse();
                     });
+                    it('measures playbackTime from the last observed timeUpdate, not currentTime at the stop', () => {
+                        // currentTime can reset (e.g. to 0) as playback stops,
+                        // before the played event fires — playbackTime must use
+                        // the last time seen during playback, not that reset.
+                        const playedSpy = createEventSpy(controller, 'played');
+                        media.currentTime = 5;
+                        media.dispatchEvent(mockEvent('playing'));
+                        media.currentTime = 45;
+                        media.dispatchEvent(mockEvent('timeupdate'));
+                        media.currentTime = 0;
+                        media.dispatchEvent(mockEvent('ended'));
+                        expect(playedSpy).toHaveBeenCalledOnceWith(objectContaining({ playbackTime: 40 }));
+                    });
+                    it('ignores a backward timeUpdate so a late negative seek does not shrink playbackTime', () => {
+                        // A timeUpdate reflecting a backward seek can land just
+                        // before the seeking event; it must not pull the observed
+                        // position below the play's forward progress.
+                        const playedSpy = createEventSpy(controller, 'played');
+                        media.currentTime = 5;
+                        media.dispatchEvent(mockEvent('playing'));
+                        media.currentTime = 45;
+                        media.dispatchEvent(mockEvent('timeupdate'));
+                        media.currentTime = 8;
+                        media.dispatchEvent(mockEvent('timeupdate'));
+                        media.dispatchEvent(mockEvent('seeking'));
+                        expect(playedSpy).toHaveBeenCalledOnceWith(objectContaining({ playbackTime: 40 }));
+                    });
+                    it('resets the observed position per play so a prior play does not inflate playbackTime', () => {
+                        // A new play after a backward seek starts at an earlier
+                        // position — the previous play's higher position must not
+                        // carry over.
+                        const playedSpy = createEventSpy(controller, 'played');
+                        media.currentTime = 0;
+                        media.dispatchEvent(mockEvent('playing'));
+                        media.currentTime = 30;
+                        media.dispatchEvent(mockEvent('timeupdate'));
+                        media.dispatchEvent(mockEvent('seeking'));
+                        playedSpy.calls.reset();
+                        media.currentTime = 5;
+                        media.dispatchEvent(mockEvent('playing'));
+                        media.currentTime = 8;
+                        media.dispatchEvent(mockEvent('timeupdate'));
+                        media.dispatchEvent(mockEvent('pause'));
+                        expect(playedSpy).toHaveBeenCalledOnceWith(objectContaining({ playbackTime: 3 }));
+                    });
                     describe('when not playing', () => {
                         it('prevents duplicate played events from being emitted', () => {
                             const playedSpy = createSpy('played');
@@ -627,7 +717,6 @@ describe('PlaybackController', () => {
                             this.type = type;
                             this.loaded = loaded;
                             this.total = total;
-                            this.type = type;
                         }
                     }
                     it(`emits updates on media's progress consistently`, () => {

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

@@ -58,6 +58,17 @@ describe('ContentStreamImpl', () => {
             bufferingController.dispatch('error', { error, target });
             expect(spy).toHaveBeenCalledWith({ error, target });
         });
+        it('redispatches hasDataChange from bufferingController', () => {
+            const spy = createEventSpy(contentStream, 'hasDataChange');
+            const event = { previous: false, current: true };
+            bufferingController.dispatch('hasDataChange', event);
+            expect(spy).toHaveBeenCalledWith(event);
+        });
+        it('exposes hasData from the bufferingController', () => {
+            expect(contentStream.hasData).toBeFalse();
+            bufferingController.hasData = true;
+            expect(contentStream.hasData).toBeTrue();
+        });
     });
     describe('preload', () => {
         it('configures segmentController with startTime and prefetchPriority', () => {

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();
+        });
+    });
+});

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

@@ -22,6 +22,8 @@ describe('getMediaPeriodAtTime', () => {
     const timeline = {
         periods: [period1, period2, period3],
         minBufferTime: 2,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(30),
     };
     it('returns the first period for time 0', () => {
         expect(getMediaPeriodAtTime(timeline, 0)).toBe(period1);
@@ -42,7 +44,12 @@ describe('getMediaPeriodAtTime', () => {
         expect(getMediaPeriodAtTime(timeline, -1)).toBeNull();
     });
     it('returns null for empty timeline', () => {
-        const empty = { periods: [], minBufferTime: 0 };
+        const empty = {
+            periods: [],
+            minBufferTime: 0,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(0),
+        };
         expect(getMediaPeriodAtTime(empty, 5)).toBeNull();
     });
 });