@amazon/vinyl 1.1.1 → 2.0.0

package/dist/unit/types/current/track/AutoResetController.test.js

@@ -3,10 +3,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AutoResetControllerImpl, } from '@amazon/vinyl';
-import { ErrorOrigin, ReportableError, networkState, DisposedError, } from '@amazon/vinyl-util';
+import { networkState, DisposedError, RequestError } from '@amazon/vinyl-util';
 import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
-import { createEventSpy, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
+import { createEventSpy, emptyInternalError, emptyResponseError, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
 import { mockEvent, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+/**
+ * Creates a RequestError representing a transient network failure (no response received).
+ * These are the only errors that AutoResetController watches for retry opportunities.
+ */
+function createNetworkRequestError() {
+    return new RequestError(null, emptyInternalError);
+}
+/**
+ * Creates a RequestError that received an HTTP response. These should be ignored by
+ * the AutoResetController, since a service that responded is unlikely to recover
+ * on its own.
+ */
+function createResponseRequestError() {
+    return new RequestError(new Response(null, { status: 500 }), emptyResponseError);
+}
 describe('AutoResetControllerImpl', () => {
     let deps;
     let controller;
@@ -47,32 +62,35 @@ describe('AutoResetControllerImpl', () => {
             expect(playbackController.on).toHaveBeenCalledWith('seeking', jasmine.any(Function));
             expect(playbackController.on).toHaveBeenCalledWith('playing', jasmine.any(Function));
         });
+        it('starts with resetPending false', () => {
+            controller = new AutoResetControllerImpl(deps);
+            expect(controller.resetPending).toBeFalse();
+        });
     });
     describe('setError', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
         });
-        it('ignores non-ReportableError', () => {
+        it('ignores non-RequestError', () => {
             const error = new Error('test error');
             controller.setError(error);
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('ignores ReportableError with non-SERVICE_INTERNAL origin', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_EXTERNAL);
-            controller.setError(error);
+        it('ignores RequestError with a response (HTTP failure)', () => {
+            controller.setError(createResponseRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('sets error and starts watching for SERVICE_INTERNAL ReportableError', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+        it('sets error and starts watching for transient network RequestError', () => {
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).toHaveBeenCalledWith('online', jasmine.any(Function));
+            expect(controller.resetPending).toBeTrue();
         });
         it('ignores subsequent errors when already in error state', () => {
-            const error1 = new ReportableError('test1', ErrorOrigin.SERVICE_INTERNAL);
-            const error2 = new ReportableError('test2', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error1);
+            controller.setError(createNetworkRequestError());
             mockNetworkState.on.calls.reset();
-            controller.setError(error2);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
     });
@@ -82,7 +100,7 @@ describe('AutoResetControllerImpl', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
             resetSpy = createEventSpy(controller, 'reset');
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('emits reset event when network comes online', () => {
             controller.setError(error);
@@ -160,7 +178,7 @@ describe('AutoResetControllerImpl', () => {
         let resetSpy;
         let error;
         beforeEach(() => {
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('retries at specified interval when online', async () => {
             controller = new AutoResetControllerImpl(deps, { retryInterval: 5 });
@@ -197,12 +215,109 @@ describe('AutoResetControllerImpl', () => {
                 expect(resetSpy).toHaveBeenCalledTimes(3);
             }
         });
+        it('clears resetPending when max retries are exhausted', async () => {
+            controller = new AutoResetControllerImpl(deps, {
+                retryInterval: 1,
+                maxRetries: 1,
+            });
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // First retry succeeds (resets) and re-arms on next setError
+            await clock.tick(1);
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // Second retry exhausts the budget — interval fires but no reset emitted,
+            // and resetPending should transition to false.
+            await clock.tick(1);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPending', () => {
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            error = createNetworkRequestError();
+        });
+        it('is false initially', () => {
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes true when an eligible error is set', () => {
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+        });
+        it('remains false when a non-eligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false after a reset is emitted', () => {
+            controller.setError(error);
+            playbackController.dispatch('play', {});
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false when cleared', () => {
+            controller.setError(error);
+            controller.clear();
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('is false when the controller is disabled', () => {
+            controller = new AutoResetControllerImpl(deps, { enabled: false });
+            controller.setError(error);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPendingChange event', () => {
+        let resetPendingChangeSpy;
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            resetPendingChangeSpy = createEventSpy(controller, 'resetPendingChange');
+            error = createNetworkRequestError();
+        });
+        it('dispatches when resetPending becomes true', () => {
+            controller.setError(error);
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: false,
+                current: true,
+            });
+        });
+        it('dispatches when resetPending becomes false via reset', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            playbackController.dispatch('play', {});
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('dispatches when resetPending becomes false via clear', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.clear();
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('does not dispatch when setError is called with an in-progress error', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.setError(error);
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when clear is called with no error', () => {
+            controller.clear();
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when an ineligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
     });
     describe('clear', () => {
         let error;
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('clears error state and stops watching', () => {
             controller.setError(error);
@@ -229,8 +344,7 @@ describe('AutoResetControllerImpl', () => {
     describe('dispose', () => {
         it('clears error state and disposes resources', () => {
             controller = new AutoResetControllerImpl(deps);
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             controller.dispose();
             // Should not emit reset after disposing
             const resetSpy = createEventSpy(controller, 'reset');
@@ -250,15 +364,13 @@ describe('AutoResetControllerImpl', () => {
     describe('disabled behavior', () => {
         it('does not watch for errors when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
         it('does not emit reset events when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
             const resetSpy = createEventSpy(controller, 'reset');
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             playbackController.dispatch('play', {});
             expect(resetSpy).not.toHaveBeenCalled();
         });

package/dist/unit/types/current/track/TrackBase.test.js

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { TrackBase, trackBaseOptionsValidator, } from '@amazon/vinyl';
+import { TrackBase, trackConfigOptionsValidator, } from '@amazon/vinyl';
 import { Abort, createShortUid, DisposedError, } from '@amazon/vinyl-util';
 import { MockDrmController, MockPlaybackController, } from '@amazon/vinyl/vinylTestUtil';
 import { createEventSpy } from '@amazon/vinyl-util/testUtil';
@@ -29,6 +29,9 @@ describe('TrackBase', () => {
         simulateError(error) {
             this.errorHandler(error);
         }
+        simulateSetSeekRange(value) {
+            this.setSeekRange(value);
+        }
     }
     let track;
     let playbackController;
@@ -151,13 +154,13 @@ describe('TrackBase', () => {
             });
         });
     });
-    describe('trackBaseOptionsValidator', () => {
-        it('validates the track layout options config shape', () => {
-            expect(trackBaseOptionsValidator.isValid({
+    describe('trackConfigOptionsValidator', () => {
+        it('validates the track config options shape', () => {
+            expect(trackConfigOptionsValidator.isValid({
                 startTime: 44,
                 extra: {},
             })).toBeTrue();
-            expect(trackBaseOptionsValidator.isValid({
+            expect(trackConfigOptionsValidator.isValid({
                 startTime: '44',
                 extra: {},
             })).toBeFalse();
@@ -184,6 +187,14 @@ describe('TrackBase', () => {
             });
         });
     });
+    describe('setSeekRange', () => {
+        it('does not re-emit seekRangeChange when the range is unchanged', () => {
+            track.simulateSetSeekRange({ start: 0, end: 60 });
+            const seekRangeSpy = createEventSpy(track, 'seekRangeChange');
+            track.simulateSetSeekRange({ start: 0, end: 60 });
+            expect(seekRangeSpy).not.toHaveBeenCalled();
+        });
+    });
     describe('reset', () => {
         let resetSpy;
         beforeEach(() => {
@@ -201,5 +212,39 @@ describe('TrackBase', () => {
             expect(track.error).toBeNull();
             expect(resetSpy).toHaveBeenCalledOnceWith({});
         });
+        describe('hard reset of an active track', () => {
+            beforeEach(() => {
+                playbackController.play.and.resolveTo(void 0);
+                track.activate({ startTime: 5 });
+                // Clear calls captured during activate so assertions only
+                // observe the reset behavior.
+                track.onActivated.calls.reset();
+                track.onDeactivated.calls.reset();
+                track.clearPrefetch.calls.reset();
+                playbackController.seekTo.calls.reset();
+            });
+            it('deactivates, activates, and restores the playback time', () => {
+                playbackController.currentTime = 42;
+                track.reset(true);
+                expect(track.onDeactivated).toHaveBeenCalledOnceWith();
+                expect(track.clearPrefetch).toHaveBeenCalledOnceWith();
+                expect(track.onActivated).toHaveBeenCalledOnceWith({
+                    startTime: 5,
+                });
+                expect(playbackController.seekTo).toHaveBeenCalledOnceWith(42);
+                expect(resetSpy).toHaveBeenCalledOnceWith({});
+            });
+            it('resumes playback when it was not paused', () => {
+                playbackController.paused = false;
+                playbackController.ended = false;
+                track.reset(true);
+                expect(playbackController.play).toHaveBeenCalledOnceWith();
+            });
+            it('does not resume playback when it was paused', () => {
+                playbackController.paused = true;
+                track.reset(true);
+                expect(playbackController.play).not.toHaveBeenCalled();
+            });
+        });
     });
 });