Merged 1.4.2 changes for testing. Successful

Author: DDtMM

projects/signal-generators/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddtmm/angular-signal-generators",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "license": "MIT",
   "description": "Specialized Angular signals to help with frequently encountered situations.",
   "peerDependencies": {

projects/signal-generators/src/lib/internal/signal-input-utilities.ts

@@ -1,3 +1,4 @@
+import { isSignal } from '@angular/core';
 import { SignalInput, ToSignalInput } from '../signal-input';
 
 export function isSignalInput<T>(obj: SignalInput<T> | T): obj is SignalInput<T>
@@ -8,7 +9,14 @@ export function isSignalInput(obj: unknown): obj is SignalInput<unknown>
  * @param obj Any type of a value can be checked.
  */
 export function isSignalInput(obj: unknown): obj is SignalInput<unknown> {
-  return (obj != null) && (typeof obj === 'function' && obj.length === 0 || isToSignalInput(obj));
+  return (obj != null) && (isSignal(obj) || isSignalInputFunction(obj) || isToSignalInput(obj));
+}
+
+export function isSignalInputFunction<T>(obj: SignalInput<T>): obj is () => T
+export function isSignalInputFunction(obj: unknown): obj is () => unknown
+/** Is true if obj is a function and it has no arguments. */
+export function isSignalInputFunction(obj: unknown): obj is () => unknown {
+  return typeof obj === 'function' && obj.length === 0 && !isSignal(obj);
 }
 
 export function isToSignalInput<T>(obj: SignalInput<T>): obj is ToSignalInput<T>

projects/signal-generators/src/lib/internal/timer-internal.spec.ts

@@ -1,5 +1,5 @@
 import { fakeAsync, tick } from '@angular/core/testing';
-import { tickAndAssertValue } from '../../testing/testing-utilities';
+import { tickAndAssertValues } from '../../testing/testing-utilities';
 import { TimerInternal, TimerInternalOptions, TimerStatus } from './timer-internal';
 
 describe('timerInternal', () => {
@@ -117,7 +117,7 @@ describe('timerInternal', () => {
 
   /** It is a pretty common pattern in these tests to tick, and then expect a value */
   function tickAndAssertTimerValue(timer: TimerInternal, pattern: [elapsedMs: number, expectedTicks: number][]): void {
-    tickAndAssertValue(() => timer.ticks, pattern);
+    tickAndAssertValues(() => timer.ticks, pattern);
   }
 });
 

projects/signal-generators/src/lib/internal/value-source-utilities.ts

@@ -1,17 +1,16 @@
 import { CreateSignalOptions, Signal, WritableSignal, signal } from '@angular/core';
+import { SignalInput } from '../signal-input';
 import { ValueSource } from '../value-source';
 import { CoerceSignalOptions, coerceSignal } from './signal-coercion';
 import { isSignalInput } from './signal-input-utilities';
-import { SignalInput } from '../signal-input';
 
-/** The signal that is the result of a value created by */
+
 export type ValueSourceSignal<V extends ValueSource<unknown>> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   V extends Signal<any> ? V // if value source was already a signal then it is just itself.
     : V extends SignalInput<infer T> ? Signal<T> // a plain signal is created from an observable or function returning a value.
       : WritableSignal<V>; // if a value was used as a ValueSource then the signal created is a writable signal.
 
-
 export function valueSourceToSignal<T, V extends ValueSource<T>>(
   valueSource: V, options?: CoerceSignalOptions<T> & CreateSignalOptions<T>): ValueSourceSignal<V> {
 

projects/signal-generators/src/lib/signals/async-signal.spec.ts

@@ -0,0 +1,174 @@
+import { Component, Injector, signal } from '@angular/core';
+import { fakeAsync, tick } from '@angular/core/testing';
+import { MockBuilder, MockRender, MockedComponentFixture } from 'ng-mocks';
+import { BehaviorSubject, startWith, tap, timer } from 'rxjs';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
+import { autoDetectChangesSignal } from '../../testing/signal-testing-utilities';
+import { asyncSignal } from './async-signal';
+
+describe('asyncSignal', () => {
+  let fixture: MockedComponentFixture<void, void>;
+  let injector: Injector;
+
+  beforeEach(() => {
+    fixture = MockRender();
+    injector = fixture.componentRef.injector;
+  });
+
+  setupTypeGuardTests(() => asyncSignal(Promise.resolve(1), { injector }));
+
+  describe('for computed and effects', () => {
+    setupComputedAndEffectTests(
+      () => {
+        const sut = asyncSignal(Promise.resolve(1), { injector });
+        return [sut, () => sut.set(Promise.resolve(2))];
+      },
+      null,
+      'from a value'
+    );
+    setupComputedAndEffectTests(
+      () => {
+        const source = signal(Promise.resolve(1));
+        const sut = asyncSignal(source, { injector });
+        return [sut, () => source.set(Promise.resolve(2))];
+      },
+      null,
+      'from a signal'
+    );
+  });
+
+  describe('from a value', () => {
+    it('returns a signal that can be set', fakeAsync(() => {
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(Promise.resolve(1), { injector }));
+      sut.set(Promise.resolve(2));
+      tick();
+      expect(sut()).toBe(2);
+    }));
+    it('returns a signal with readonly method', fakeAsync(() => {
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(Promise.resolve(1), { injector }));
+      sut.set(Promise.resolve(2));
+      tick();
+      expect(sut.asReadonly()()).toBe(2);
+    }));
+    it('returns a signal that can be updated', fakeAsync(() => {
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(Promise.resolve(1), { injector }));
+      sut.update((x) => (x instanceof Promise ? Promise.resolve(2) : Promise.resolve(0)));
+      tick();
+      expect(sut()).toBe(2);
+    }));
+  });
+
+  describe('from a signalInput', () => {
+    it('updates output from a signal', fakeAsync(() => {
+      const source = autoDetectChangesSignal(fixture, signal(Promise.resolve(1)));
+      const sut = asyncSignal(source, { injector });
+      source.set(Promise.resolve(2));
+      tick();
+      expect(sut()).toBe(2);
+    }));
+
+    it('updates output from a value that needs coercing', fakeAsync(() => {
+      const source = autoDetectChangesSignal(fixture, signal(Promise.resolve(1)));
+      const sut = asyncSignal(() => source(), { injector });
+      source.set(Promise.resolve(2));
+      tick();
+      expect(sut()).toBe(2);
+    }));
+  });
+
+  describe('execution', () => {
+    it('creates a signal that initially returns defaultValue if provided in options', fakeAsync(() => {
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(Promise.resolve(1), { defaultValue: -1, injector }));
+      expect(sut()).toBe(-1);
+      tick();
+      expect(sut()).toBe(1);
+    }));
+
+    it('ignores output from a prior async source value when another one is active', fakeAsync(() => {
+      const subjectOne = new BehaviorSubject(1);
+      const subjectTwo = new BehaviorSubject(6);
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(subjectOne, { injector }));
+      tick();
+      expect(sut()).toBe(1);
+      sut.set(subjectTwo);
+      expect(sut()).toBe(6);
+      subjectOne.next(2);
+      expect(sut()).toBe(6);
+      subjectTwo.next(7);
+      expect(sut()).toBe(7);
+    }));
+
+    it('updates if a signal is used inside of the "auto-computed" overload.', fakeAsync(() => {
+      function fakeFetch(idValue: number): Promise<number> {
+        return Promise.resolve(idValue + 1);
+      }
+      const $id = autoDetectChangesSignal(fixture, signal(1), { tickAfter: true });
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(() => fakeFetch($id()), { injector }), { tickAfter: true });
+      expect(sut()).toBe(2);
+      $id.set(5);
+      expect(sut()).toBe(6);
+    }));
+  });
+
+  describe('errors', () => {
+    it('throws when subscribable async source throws', fakeAsync(() => {
+      const obs$ = timer(1000).pipe(
+        tap(() => {
+          throw new Error();
+        }),
+        startWith(6)
+      );
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(obs$, { injector }), { tickAfter: true });
+      expect(sut()).toBe(6);
+      tick(1000); // get observable to throw error.
+      expect(() => sut()).toThrowError();
+    }));
+
+    it('throws when PromiseLike async source is rejected', fakeAsync(() => {
+      let reject: () => void = () => {};
+      const asyncSource = new Promise<number>((_, r) => {
+        reject = r;
+      });
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(asyncSource, { injector }), { tickAfter: true });
+      expect(sut()).toBe(undefined);
+      reject();
+      tick(); // need to process the reject.
+      expect(() => sut()).toThrowError();
+    }));
+
+    it('will not update after an error has been thrown', fakeAsync(() => {
+      let reject: () => void = () => {};
+      const asyncSource = new Promise<number>((_, r) => {
+        reject = r;
+      });
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(asyncSource, { injector }), { tickAfter: true });
+      reject(); // this will go undetected.
+      sut.set(Promise.resolve(5));
+      expect(() => sut()).toThrowError();
+    }));
+
+    it('will not create a new error after an error has been thrown', fakeAsync(() => {
+      let reject: (reason: unknown) => void = () => {};
+      const asyncSource = new Promise<number>((_, r) => (reject = r));
+      const sut = autoDetectChangesSignal(fixture, asyncSignal(asyncSource, { injector }), { tickAfter: true });
+      reject('error1'); // there is intentionally no tick after.  Use cause to identify
+      sut.set(Promise.reject('error2'));
+      expect(() => sut()).toThrowMatching((x) => (x as Error).cause === 'error1');
+    }));
+  });
+});
+
+/** This needed to be outside the other asyncSignal tests since the only way to test without options was to be in an injection context. */
+describe('asyncSignal without options', () => {
+  it('can be created without options', fakeAsync(() => {
+    @Component({ standalone: true })
+    class TestComponent {
+      sut = asyncSignal(Promise.resolve(1));
+    }
+    MockBuilder(TestComponent);
+    const fixture = MockRender(TestComponent);
+    expect(fixture.point.componentInstance.sut()).toBe(undefined);
+    tick();
+    expect(fixture.point.componentInstance.sut()).toBe(1);
+  }));
+});