feat(openapi-resource-mocks/testing): add response sequence mocking

mockResource now accepts { sequence: [entry1, entry2, ...] } as second arg.
Each factory call consumes the next entry (ProviderInitialBehavior<T>); reload()
also advances the sequence when in resolved/local state via its internal
_notifyRequest. Last entry repeats when the sequence is exhausted.
Enables pagination, retry, and error-then-success patterns without manual
ref manipulation mid-test.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: constantant

tools/openapi-resource-mocks/src/testing.spec.ts

@@ -166,4 +166,100 @@ describe('mockResource', () => {
       expect(handle.ref.status()).toBe('error');
     });
   });
+
+  describe('response sequence', () => {
+    it('applies first entry on initial factory call', () => {
+      const handle = mockResource<string[]>(TOKEN as never, {
+        sequence: [{ value: ['a'] }, { value: ['b'] }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn();
+      expect(handle.ref.status()).toBe('resolved');
+      expect(handle.ref.value()).toEqual(['a']);
+    });
+
+    it('advances to the next entry on each factory call', () => {
+      const handle = mockResource<string[]>(TOKEN as never, {
+        sequence: [{ value: ['first'] }, { value: ['second'] }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn();
+      expect(handle.ref.value()).toEqual(['first']);
+      fn();
+      expect(handle.ref.value()).toEqual(['second']);
+    });
+
+    it('also advances on reload() when in resolved state', () => {
+      const handle = mockResource<string[]>(TOKEN as never, {
+        sequence: [{ value: ['v1'] }, { value: ['v2'] }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn();
+      expect(handle.ref.value()).toEqual(['v1']);
+      handle.ref.reload(); // reload() calls _notifyRequest internally → advances sequence
+      expect(handle.ref.value()).toEqual(['v2']);
+    });
+
+    it('error-then-success pattern', () => {
+      const err = new Error('timeout');
+      const handle = mockResource<number>(TOKEN as never, {
+        sequence: [{ error: err }, { value: 42 }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn(); // call 1 → error
+      expect(handle.ref.status()).toBe('error');
+      expect(handle.ref.error()).toBe(err);
+      fn(); // call 2 → success (simulates param change / retry)
+      expect(handle.ref.status()).toBe('resolved');
+      expect(handle.ref.value()).toBe(42);
+    });
+
+    it('loading → resolved pattern', () => {
+      const handle = mockResource<string>(TOKEN as never, {
+        sequence: [{ loading: true }, { value: 'done' }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn(); // call 1 → loading
+      expect(handle.ref.isLoading()).toBe(true);
+      fn(); // call 2 → resolved
+      expect(handle.ref.value()).toBe('done');
+    });
+
+    it('repeats last entry when sequence is exhausted', () => {
+      const handle = mockResource<number>(TOKEN as never, {
+        sequence: [{ value: 1 }, { value: 2 }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn();
+      expect(handle.ref.value()).toBe(1);
+      fn();
+      expect(handle.ref.value()).toBe(2);
+      fn(); // beyond sequence — last entry repeats
+      expect(handle.ref.value()).toBe(2);
+    });
+
+    it('still tracks calls in sequence mode', () => {
+      const handle = mockResource<string>(TOKEN as never, {
+        sequence: [{ value: 'x' }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn({ param: 1 });
+      expect(handle.calls).toHaveLength(1);
+      expect(handle.calls[0]).toEqual([{ param: 1 }]);
+    });
+
+    it('delay in sequence entry: loading immediately then resolves after delay', () => {
+      vi.useFakeTimers();
+      const handle = mockResource<string>(TOKEN as never, {
+        sequence: [{ value: 'slow', delay: 300 }],
+      });
+      const fn = handle.useFactory!() as FakeFn;
+      fn();
+      expect(handle.ref.isLoading()).toBe(true);
+      vi.advanceTimersByTime(300);
+      expect(handle.ref.status()).toBe('resolved');
+      expect(handle.ref.value()).toBe('slow');
+      vi.useRealTimers();
+    });
+  });
 });

tools/openapi-resource-mocks/src/testing.ts

@@ -1,9 +1,12 @@
 import { InjectionToken, FactoryProvider } from '@angular/core';
 import { httpResource } from '@angular/common/http';
 import { createMockResourceRef } from './lib/mock-resource-ref';
-import type { MockResourceRef } from './lib/mock-resource-ref';
+import type { MockResourceRef, MockResourceRefInternal } from './lib/mock-resource-ref';
 import type { ProviderInitialBehavior } from './lib/provide-mock-resource';
 
+/** One step in a response sequence — same shape as the single initialBehavior. */
+export type MockSequenceEntry<T> = ProviderInitialBehavior<T>;
+
 /** A FactoryProvider that also exposes the underlying ref and call history for assertions. */
 export interface MockResourceHandle<T> extends FactoryProvider {
   /** The underlying MockResourceRef — use to change state mid-test. */
@@ -55,29 +58,52 @@ function deepEqual(a: unknown, b: unknown): boolean {
  * Creates a lightweight mock provider for an httpResource token — no MockResourceBus,
  * no DOM events. Drop the handle directly into TestBed `providers: []`.
  *
+ * **Single behavior:**
  * ```ts
  * const petsMock = mockResource(FIND_PETS_BY_STATUS, { value: [] });
  * TestBed.configureTestingModule({ providers: [petsMock] });
- * // after rendering:
  * petsMock.expectCalled();
  * petsMock.expectCalledWith({ status: 'active' });
- * petsMock.ref.resolve(newPets);
+ * petsMock.ref.resolve(newPets); // change mid-test
+ * ```
+ *
+ * **Response sequence** (each call / reload consumes the next entry; last repeats):
+ * ```ts
+ * const petsMock = mockResource(FIND_PETS_BY_STATUS, {
+ *   sequence: [{ loading: true }, { error: new Error('timeout') }, { value: pets }],
+ * });
  * ```
  */
 export function mockResource<T>(
   token: InjectionToken<(...args: unknown[]) => ReturnType<typeof httpResource<T>>>,
-  initialBehavior?: ProviderInitialBehavior<T>,
+  behaviorOrOptions?: ProviderInitialBehavior<T> | { sequence: MockSequenceEntry<T>[] },
 ): MockResourceHandle<T> {
   const ref = createMockResourceRef<T>();
+  const internal = ref as MockResourceRefInternal<T>;
   const calls: unknown[][] = [];
 
-  if (initialBehavior) applyBehavior(ref, initialBehavior);
+  let notifyOnCall = false;
+
+  if (!behaviorOrOptions) {
+    // no-op: ref stays idle
+  } else if ('sequence' in behaviorOrOptions) {
+    const sequence = behaviorOrOptions.sequence;
+    let idx = 0;
+    ref.onRequest(() => {
+      const entry = idx < sequence.length ? sequence[idx++] : sequence[sequence.length - 1];
+      applyBehavior(ref, entry);
+    });
+    notifyOnCall = true;
+  } else {
+    applyBehavior(ref, behaviorOrOptions);
+  }
 
   const handle: MockResourceHandle<T> = {
     provide: token,
     useFactory: () =>
       (...args: unknown[]) => {
         calls.push(args);
+        if (notifyOnCall) internal._notifyRequest(args);
         return ref as unknown as ReturnType<typeof httpResource<T>>;
       },
     get ref() {