@amazon/vinyl 1.0.0

package/dist/unit/types/current/track/source/FixedPlaybackQuality.test.js

@@ -0,0 +1,365 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEmptyMediaQualityMetadata, FixedPlaybackQuality, PlaybackReadyState, } from '@amazon/vinyl';
+import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
+import { createEventSpy } from '@amazon/vinyl-util/testUtil';
+describe('FixedPlaybackQuality', () => {
+    let fixedPlaybackQuality;
+    let playbackController;
+    const fixedQuality = {
+        ...createEmptyMediaQualityMetadata(),
+        contentType: 'audio',
+    };
+    let playbackQualityChange;
+    let bufferingQualityChange;
+    let streamingQualityChange;
+    beforeEach(() => {
+        playbackController = new MockPlaybackController();
+        fixedPlaybackQuality = new FixedPlaybackQuality(fixedQuality, {
+            playbackController,
+        });
+        playbackQualityChange = createEventSpy(fixedPlaybackQuality, 'playbackQualityChange');
+        bufferingQualityChange = createEventSpy(fixedPlaybackQuality, 'bufferingQualityChange');
+        streamingQualityChange = createEventSpy(fixedPlaybackQuality, 'streamingQualityChange');
+    });
+    describe('contentTypes', () => {
+        it('returns content type from fixed quality', () => {
+            expect(fixedPlaybackQuality.contentTypes).toEqual(new Set(['audio']));
+        });
+        it('updates when fixed quality changes', () => {
+            fixedPlaybackQuality.fixedQuality = {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: 'video',
+            };
+            expect(fixedPlaybackQuality.contentTypes).toEqual(new Set(['video']));
+        });
+        it('returns empty set when content type is null', () => {
+            fixedPlaybackQuality.fixedQuality = {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: null,
+            };
+            expect(fixedPlaybackQuality.contentTypes).toEqual(new Set());
+        });
+    });
+    describe('getStreamingQuality', () => {
+        it('returns fixed quality for matching content type', () => {
+            expect(fixedPlaybackQuality.getStreamingQuality('audio')).toBe(fixedQuality);
+        });
+        it('returns null for non-matching content type', () => {
+            expect(fixedPlaybackQuality.getStreamingQuality('video')).toBeNull();
+        });
+        it('updates when fixed quality changes', () => {
+            const fixedQuality2 = {
+                ...createEmptyMediaQualityMetadata(),
+                mimeType: 'audio/mp4',
+                contentType: 'audio',
+            };
+            fixedPlaybackQuality.fixedQuality = fixedQuality2;
+            expect(fixedPlaybackQuality.getStreamingQuality('audio')).toBe(fixedQuality2);
+        });
+        it('returns null when content type is null', () => {
+            fixedPlaybackQuality.fixedQuality = {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: null,
+            };
+            expect(fixedPlaybackQuality.getStreamingQuality('audio')).toBeNull();
+        });
+    });
+    describe('when activated', () => {
+        beforeEach(() => {
+            fixedPlaybackQuality.activate();
+        });
+        it('getBufferingQuality returns fixedQuality for matching content type', () => {
+            expect(fixedPlaybackQuality.getBufferingQuality('audio')).toEqual(fixedQuality);
+        });
+        it('getBufferingQuality returns null for non-matching content type', () => {
+            expect(fixedPlaybackQuality.getBufferingQuality('video')).toBeNull();
+        });
+        it('emits bufferingQualityChange event', () => {
+            expect(bufferingQualityChange).toHaveBeenCalledOnceWith({
+                previous: null,
+                current: fixedQuality,
+            });
+        });
+        it('no-ops when setting same buffering quality again', () => {
+            bufferingQualityChange.calls.reset();
+            // Change the fixed quality to the same value, which should trigger the setter with the same value
+            fixedPlaybackQuality.fixedQuality = fixedQuality;
+            expect(bufferingQualityChange).not.toHaveBeenCalled();
+        });
+    });
+    describe('when deactivated', () => {
+        it('getBufferingQuality returns null', () => {
+            expect(fixedPlaybackQuality.getBufferingQuality('audio')).toEqual(null);
+            fixedPlaybackQuality.activate();
+            expect(fixedPlaybackQuality.getBufferingQuality('audio')).toEqual(fixedQuality);
+            fixedPlaybackQuality.deactivate();
+            expect(fixedPlaybackQuality.getBufferingQuality('audio')).toEqual(null);
+        });
+        it('emits bufferingQualityChange event', () => {
+            fixedPlaybackQuality.activate();
+            bufferingQualityChange.calls.reset();
+            fixedPlaybackQuality.deactivate();
+            expect(bufferingQualityChange).toHaveBeenCalledOnceWith({
+                previous: fixedQuality,
+                current: null,
+            });
+        });
+    });
+    describe('when readyState is at least HAVE_CURRENT_DATA', () => {
+        beforeEach(() => {
+            playbackController.readyState = PlaybackReadyState.HAVE_CURRENT_DATA;
+        });
+        describe('then activated', () => {
+            beforeEach(() => {
+                fixedPlaybackQuality.activate();
+            });
+            describe('getPlaybackQuality', () => {
+                it('returns fixedQuality for matching content type', () => {
+                    expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toEqual(fixedQuality);
+                });
+                it('returns null for non-matching content type', () => {
+                    expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+                });
+            });
+            describe('playbackQualityChange', () => {
+                it('is emitted', () => {
+                    expect(playbackQualityChange).toHaveBeenCalledOnceWith({
+                        previous: null,
+                        current: fixedQuality,
+                    });
+                });
+                it('no-ops when setting same playback quality again', () => {
+                    playbackQualityChange.calls.reset();
+                    // Trigger the same ready state change again
+                    playbackController.dispatch('readyStateChange', {
+                        previous: PlaybackReadyState.HAVE_CURRENT_DATA,
+                        current: PlaybackReadyState.HAVE_CURRENT_DATA,
+                    });
+                    expect(playbackQualityChange).not.toHaveBeenCalled();
+                });
+            });
+            describe('then deactivated', () => {
+                beforeEach(() => {
+                    playbackQualityChange.calls.reset();
+                    fixedPlaybackQuality.deactivate();
+                });
+                describe('playbackQualityChange', () => {
+                    it('is emitted', () => {
+                        expect(playbackQualityChange).toHaveBeenCalledOnceWith({
+                            previous: fixedQuality,
+                            current: null,
+                        });
+                    });
+                });
+                describe('getPlaybackQuality', () => {
+                    it('returns null', () => {
+                        expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+                    });
+                });
+            });
+        });
+    });
+    describe('when readyState is not at least HAVE_CURRENT_DATA', () => {
+        beforeEach(() => {
+            playbackController.readyState = PlaybackReadyState.HAVE_METADATA;
+        });
+        describe('and readyState changes to at least HAVE_CURRENT_DATA', () => {
+            beforeEach(() => {
+                playbackController.readyState =
+                    PlaybackReadyState.HAVE_CURRENT_DATA;
+                playbackController.dispatch('readyStateChange', {
+                    previous: PlaybackReadyState.HAVE_METADATA,
+                    current: PlaybackReadyState.HAVE_CURRENT_DATA,
+                });
+            });
+            it('getPlaybackQuality returns null for all content types', () => {
+                expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+                expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+            });
+        });
+        describe('then activated', () => {
+            beforeEach(() => {
+                fixedPlaybackQuality.activate();
+            });
+            it('getPlaybackQuality returns null for all content types', () => {
+                expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+                expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+            });
+            describe('and readyState changes to at least HAVE_CURRENT_DATA', () => {
+                beforeEach(() => {
+                    playbackController.readyState =
+                        PlaybackReadyState.HAVE_CURRENT_DATA;
+                    playbackController.dispatch('readyStateChange', {
+                        previous: PlaybackReadyState.HAVE_METADATA,
+                        current: PlaybackReadyState.HAVE_CURRENT_DATA,
+                    });
+                });
+                it('getPlaybackQuality returns fixedQuality for matching content type', () => {
+                    expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBe(fixedQuality);
+                    expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+                });
+                it('emits playbackQualityChange', () => {
+                    expect(playbackQualityChange).toHaveBeenCalledOnceWith({
+                        previous: null,
+                        current: fixedQuality,
+                    });
+                });
+                describe('and readyState changes to HAVE_NOTHING', () => {
+                    beforeEach(() => {
+                        playbackController.readyState =
+                            PlaybackReadyState.HAVE_NOTHING;
+                        playbackController.dispatch('readyStateChange', {
+                            previous: PlaybackReadyState.HAVE_CURRENT_DATA,
+                            current: PlaybackReadyState.HAVE_NOTHING,
+                        });
+                    });
+                    describe('getPlaybackQuality', () => {
+                        it('returns null for all content types', () => {
+                            expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+                            expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+                        });
+                    });
+                });
+                describe('then deactivated', () => {
+                    beforeEach(() => {
+                        playbackQualityChange.calls.reset();
+                        fixedPlaybackQuality.deactivate();
+                    });
+                    it('emits playbackQualityChange', () => {
+                        expect(playbackQualityChange).toHaveBeenCalledOnceWith({
+                            previous: fixedQuality,
+                            current: null,
+                        });
+                    });
+                    describe('then deactivated again', () => {
+                        beforeEach(() => {
+                            playbackQualityChange.calls.reset();
+                            fixedPlaybackQuality.deactivate();
+                        });
+                        it('does nothing', () => {
+                            expect(playbackQualityChange).not.toHaveBeenCalled();
+                        });
+                    });
+                });
+                describe('and readyState changes to still at least HAVE_CURRENT_DATA', () => {
+                    beforeEach(() => {
+                        playbackQualityChange.calls.reset();
+                        playbackController.readyState =
+                            PlaybackReadyState.HAVE_FUTURE_DATA;
+                        playbackController.dispatch('readyStateChange', {
+                            previous: PlaybackReadyState.HAVE_CURRENT_DATA,
+                            current: PlaybackReadyState.HAVE_FUTURE_DATA,
+                        });
+                    });
+                    it('does not emit playbackQualityChange', () => {
+                        expect(playbackQualityChange).not.toHaveBeenCalled();
+                        expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toEqual(fixedQuality);
+                    });
+                });
+            });
+        });
+    });
+    describe('when not activated', () => {
+        it('getPlaybackQuality returns null for all content types', () => {
+            expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+            expect(fixedPlaybackQuality.getPlaybackQuality('video')).toBeNull();
+        });
+    });
+    describe('isActive', () => {
+        it('returns true if active', () => {
+            expect(fixedPlaybackQuality.active).toBeFalse();
+            fixedPlaybackQuality.activate();
+            expect(fixedPlaybackQuality.active).toBeTrue();
+            fixedPlaybackQuality.activate();
+            expect(fixedPlaybackQuality.active).toBeTrue();
+            fixedPlaybackQuality.deactivate();
+            expect(fixedPlaybackQuality.active).toBeFalse();
+            fixedPlaybackQuality.deactivate();
+            expect(fixedPlaybackQuality.active).toBeFalse();
+        });
+    });
+    describe('fixedQuality', () => {
+        describe('when set', () => {
+            it('emits streamingQualityChange event', () => {
+                const newQuality = {
+                    ...createEmptyMediaQualityMetadata(),
+                    decoderId: '2',
+                    contentType: 'video',
+                };
+                streamingQualityChange.calls.reset();
+                fixedPlaybackQuality.fixedQuality = newQuality;
+                expect(streamingQualityChange).toHaveBeenCalledOnceWith({
+                    previous: fixedQuality,
+                    current: newQuality,
+                });
+            });
+            it('no-ops if set to same value', () => {
+                streamingQualityChange.calls.reset();
+                fixedPlaybackQuality.fixedQuality = fixedQuality;
+                expect(streamingQualityChange).toHaveBeenCalledOnceWith({
+                    previous: fixedQuality,
+                    current: fixedQuality,
+                });
+            });
+            describe('and activated', () => {
+                beforeEach(() => {
+                    fixedPlaybackQuality.activate();
+                });
+                it('changes bufferingQuality', () => {
+                    const newQuality = {
+                        ...createEmptyMediaQualityMetadata(),
+                        decoderId: '2',
+                        contentType: 'audio',
+                    };
+                    bufferingQualityChange.calls.reset();
+                    fixedPlaybackQuality.fixedQuality = newQuality;
+                    expect(fixedPlaybackQuality.getBufferingQuality('audio')).toBe(newQuality);
+                    expect(bufferingQualityChange).toHaveBeenCalledOnceWith({
+                        previous: fixedQuality,
+                        current: newQuality,
+                    });
+                    expect(playbackQualityChange).not.toHaveBeenCalled();
+                });
+                describe('and readyState is at least HAVE_CURRENT_DATA', () => {
+                    beforeEach(() => {
+                        playbackController.readyState =
+                            PlaybackReadyState.HAVE_CURRENT_DATA;
+                        playbackController.dispatch('readyStateChange', {
+                            previous: null,
+                            current: PlaybackReadyState.HAVE_CURRENT_DATA,
+                        });
+                    });
+                    it('sets playbackQuality', () => {
+                        const newQuality = {
+                            ...createEmptyMediaQualityMetadata(),
+                            decoderId: '2',
+                            contentType: 'audio',
+                        };
+                        playbackQualityChange.calls.reset();
+                        fixedPlaybackQuality.fixedQuality = newQuality;
+                        expect(fixedPlaybackQuality.fixedQuality).toBe(newQuality);
+                        expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBe(newQuality);
+                        expect(playbackQualityChange).toHaveBeenCalledOnceWith({
+                            previous: fixedQuality,
+                            current: newQuality,
+                        });
+                    });
+                });
+            });
+            describe('and not activated', () => {
+                it('does not change buffering or playback quality', () => {
+                    fixedPlaybackQuality.fixedQuality = {
+                        ...createEmptyMediaQualityMetadata(),
+                        decoderId: '2',
+                        contentType: 'audio',
+                    };
+                    expect(fixedPlaybackQuality.getBufferingQuality('audio')).toBeNull();
+                    expect(fixedPlaybackQuality.getPlaybackQuality('audio')).toBeNull();
+                });
+            });
+        });
+    });
+});

package/dist/unit/types/current/track/source/SourceObjectTrack.test.d.ts

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

package/dist/unit/types/current/track/source/SourceObjectTrack.test.d.ts.map

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

package/dist/unit/types/current/track/source/SourceObjectTrack.test.js

@@ -0,0 +1,103 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSourceObjectTrackFactory, SourceObjectTrack, } from '@amazon/vinyl';
+import { Deferred } from '@amazon/vinyl-util';
+import { flushPromises, MockMediaStream, } from '@amazon/vinyl-util/browserTestUtil';
+import { MockDrmController, MockPlaybackController, MockPlaybackSource, } from '@amazon/vinyl/vinylTestUtil';
+import { useMockLogger } from '@amazon/vinyl-util/testUtil';
+describe('SourceObjectTrack', () => {
+    useMockLogger();
+    let mediaStream;
+    let playbackController;
+    let playbackSource;
+    let drmController;
+    let promise;
+    let track;
+    function createSourceObjectTrack(uri = 'uri', type = 'srcObject') {
+        return new SourceObjectTrack(uri, type, promise, {
+            playbackController,
+            playbackSource,
+            drmController,
+        });
+    }
+    beforeEach(() => {
+        mediaStream = new MockMediaStream();
+        playbackController = new MockPlaybackController();
+        playbackController.seekTo.and.resolveTo(void 0);
+        playbackSource = new MockPlaybackSource();
+        drmController = new MockDrmController();
+        promise = new Deferred();
+        track = createSourceObjectTrack();
+    });
+    describe('activate', () => {
+        describe('when promise is resolved', () => {
+            beforeEach(async () => {
+                promise.resolve(mediaStream);
+                await promise;
+            });
+            it('sets srcObject on PlaybackSource', async () => {
+                expect(playbackSource.srcObject).toBeNull();
+                track.activate({});
+                await flushPromises();
+                expect(playbackSource.srcObject).toBe(mediaStream);
+            });
+        });
+    });
+    describe('deactivate', () => {
+        describe('when promise is resolved', () => {
+            beforeEach(async () => {
+                promise.resolve(mediaStream);
+                await promise;
+            });
+            it('sets src to null on PlaybackSource and calls load', () => {
+                track.activate({});
+                track.deactivate();
+                expect(playbackSource.srcObject).toBe(null);
+                expect(playbackSource.load).toHaveBeenCalledOnceWith();
+            });
+        });
+    });
+    describe('toString', () => {
+        it('contains the uri', () => {
+            expect(track.toString()).toContain(track.uri);
+            expect(track.toString()).toContain('SourceObjectTrack');
+        });
+    });
+});
+describe('createSourceTrackFactory', () => {
+    let trackFactory;
+    beforeEach(() => {
+        trackFactory = createSourceObjectTrackFactory({
+            playbackController: new MockPlaybackController(),
+            playbackSource: new MockPlaybackSource(),
+            drmController: new MockDrmController(),
+        });
+    });
+    it('creates a track factory for SourceTrack', () => {
+        const track = trackFactory.createTrack({
+            type: 'srcObject',
+            uri: 'test',
+            srcObjectProvider: () => new MockMediaStream(),
+        });
+        expect(track).toBeInstanceOf(SourceObjectTrack);
+    });
+    it('validates the track options', () => {
+        expect(() => trackFactory.validate(
+        // @ts-expect-error Expected validation error
+        {
+            type: 'srcObject',
+            uri: 'test',
+        })).toThrowError(`property 'srcObjectProvider' is required`);
+        expect(() => trackFactory.validate({
+            type: 'srcObject',
+            uri: 'test',
+            srcObjectProvider: () => new MockMediaStream(),
+            config: {
+                // @ts-expect-error Expected number
+                startTime: '42',
+            },
+        })).toThrowError(`Expected: (type number | nullish), but was: "42". At: config.startTime`);
+    });
+});

package/dist/unit/types/current/track/source/SourceTrack.test.d.ts

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

package/dist/unit/types/current/track/source/SourceTrack.test.d.ts.map

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

package/dist/unit/types/current/track/source/SourceTrack.test.js

@@ -0,0 +1,116 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSourceTrackFactory, SourceTrack, } from '@amazon/vinyl';
+import { Deferred } from '@amazon/vinyl-util';
+import { flushPromises } from '@amazon/vinyl-util/browserTestUtil';
+import { MockDrmController, MockPlaybackController, MockPlaybackSource, } from '@amazon/vinyl/vinylTestUtil';
+import { useMockLogger } from '@amazon/vinyl-util/testUtil';
+describe('SourceTrack', () => {
+    useMockLogger();
+    let playbackController;
+    let playbackSource;
+    let drmController;
+    let promise;
+    let track;
+    function createSourceTrack(uri = 'uri', type = 'src') {
+        return new SourceTrack(uri, type, promise, {
+            playbackController,
+            playbackSource,
+            drmController,
+        });
+    }
+    beforeEach(() => {
+        playbackController = new MockPlaybackController();
+        playbackController.seekTo.and.resolveTo(void 0);
+        playbackSource = new MockPlaybackSource();
+        drmController = new MockDrmController();
+        promise = new Deferred();
+        track = createSourceTrack();
+    });
+    describe('activate', () => {
+        describe('when promise is resolved', () => {
+            beforeEach(async () => {
+                promise.resolve('test');
+                await promise;
+            });
+            it('sets src on PlaybackSource', async () => {
+                expect(playbackSource.src).toBeNull();
+                track.activate({});
+                await flushPromises();
+                expect(playbackSource.src).toBe('test');
+            });
+        });
+    });
+    describe('deactivate', () => {
+        describe('when promise is resolved', () => {
+            beforeEach(async () => {
+                promise.resolve('test');
+                await promise;
+            });
+            it('sets src to null on PlaybackSource and calls load', () => {
+                track.activate({});
+                track.deactivate();
+                expect(playbackSource.src).toBe(null);
+                expect(playbackSource.load).toHaveBeenCalledOnceWith();
+            });
+        });
+    });
+    describe('toString', () => {
+        it('contains the uri', () => {
+            expect(track.toString()).toContain(track.uri);
+            expect(track.toString()).toContain('SourceTrack');
+        });
+    });
+});
+describe('createSourceTrackFactory', () => {
+    let trackFactory;
+    beforeEach(() => {
+        trackFactory = createSourceTrackFactory({
+            playbackController: new MockPlaybackController(),
+            playbackSource: new MockPlaybackSource(),
+            drmController: new MockDrmController(),
+        });
+    });
+    it('creates a track factory for SourceTrack', () => {
+        const track = trackFactory.createTrack({
+            type: 'src',
+            uri: 'test',
+        });
+        expect(track).toBeInstanceOf(SourceTrack);
+    });
+    describe('when srcProvider is set', () => {
+        it('uses the provider to get the uri', async () => {
+            const track = trackFactory.createTrack({
+                type: 'src',
+                uri: 'a',
+                srcProvider: () => 'expected',
+            });
+            expect(track).toBeInstanceOf(SourceTrack);
+            await expectAsync(track.src).toBeResolvedTo('expected');
+        });
+    });
+    it('validates the track options', () => {
+        trackFactory.validate({
+            type: 'src',
+            uri: 'test',
+        });
+        expect(() => trackFactory.validate(
+        // @ts-expect-error Expected validation error
+        {
+            type: 'src',
+        })).toThrowError(`property 'uri' is required`);
+        expect(() => trackFactory.validate({
+            type: 'src',
+            uri: 'test',
+            srcProvider: () => '',
+            config: {
+                qualityMetadata: {
+                    // @ts-expect-error Expected string
+                    decoderId: 42,
+                },
+            },
+        })).toThrowError(`Expected: type string, but was: 42. At: config.qualityMetadata.decoderId`);
+    });
+});

package/dist/unit/types/current/track/source/SourceTrackBase.test.d.ts

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

package/dist/unit/types/current/track/source/SourceTrackBase.test.d.ts.map

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