Test changes with Angular 16

Author: DDtMM

projects/signal-generators/package.json

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

projects/signal-generators/src/lib/generators/debounce-signal.spec.ts

@@ -4,7 +4,7 @@ import { debounceSignal } from './debounce-signal';
 import { fakeAsync } from '@angular/core/testing';
 import { tickAndAssertValue } from '../../testing/testing-utilities';
 import { autoDetectChangesSignal } from '../../testing/signal-testing-utilities';
-import { setupGeneralSignalTests } from '../../testing/general-signal-tests.spec';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
 
 
 describe('debounceSignal', () => {
@@ -16,37 +16,50 @@ describe('debounceSignal', () => {
     injector = fixture.componentRef.injector;
   });
 
-  setupGeneralSignalTests(() => debounceSignal(1, 500, { injector }));
+  setupTypeGuardTests(() => debounceSignal(1, 500, { injector }));
 
-  it('initially shows the source value', fakeAsync(() => {
-    const source = signal(1);
-    const debounced = debounceSignal(source, 500, { injector });
-    expect(debounced()).toBe(source());
-  }));
+  describe('when created with a signal', () => {
+    setupComputedAndEffectTests(() => {
+      const source = signal(1);
+      return [debounceSignal(source, 500, { injector }), () => source.set(2)];
+    }, () => fixture);
+
+    it('initially shows the source value', fakeAsync(() => {
+      const source = signal(1);
+      const debounced = debounceSignal(source, 500, { injector });
+      expect(debounced()).toBe(source());
+    }));
+
+    it('should not change value until time of last source change equals debounce time', fakeAsync(() => {
+      const originalValue = 1;
+      const source = autoDetectChangesSignal(fixture, signal(originalValue));
+      const debounced = debounceSignal(source, 500, { injector });
+      tickAndAssertValue(debounced, [[100, originalValue]]);
+      source.set(2);
+      tickAndAssertValue(debounced, [[499, originalValue], [1, source()]]);
+      source.set(3);
+      tickAndAssertValue(debounced, [[500, source()]]);
+    }));
+
+    it('should adjust debounce time when time from a signal changes', fakeAsync(() => {
+      const originalValue = 1;
+      const debounceTime = autoDetectChangesSignal(fixture, signal(500));
+      const source = autoDetectChangesSignal(fixture, signal(originalValue));
+      const debounced = autoDetectChangesSignal(fixture, debounceSignal(source, debounceTime, { injector }));
+      tickAndAssertValue(debounced, [[100, originalValue]]);
+      source.set(2);
+      debounceTime.set(5000);
+      tickAndAssertValue(debounced, [[500, originalValue], [4500, source()]]);
+    }));
+  });
 
-  it('should not change value until time of last source change equals debounce time', fakeAsync(() => {
-    const originalValue = 1;
-    const source = autoDetectChangesSignal(fixture, signal(originalValue));
-    const debounced = debounceSignal(source, 500, { injector });
-    tickAndAssertValue(debounced, [[100, originalValue]]);
-    source.set(2);
-    tickAndAssertValue(debounced, [[499, originalValue], [1, source()]]);
-    source.set(3);
-    tickAndAssertValue(debounced, [[500, source()]]);
-  }));
 
-  it('should adjust debounce time when time from a signal changes', fakeAsync(() => {
-    const originalValue = 1;
-    const debounceTime = autoDetectChangesSignal(fixture, signal(500));
-    const source = autoDetectChangesSignal(fixture, signal(originalValue));
-    const debounced = autoDetectChangesSignal(fixture, debounceSignal(source, debounceTime, { injector }));
-    tickAndAssertValue(debounced, [[100, originalValue]]);
-    source.set(2);
-    debounceTime.set(5000);
-    tickAndAssertValue(debounced, [[500, originalValue], [4500, source()]]);
-  }));
+  describe('when created from a value', () => {
+    setupComputedAndEffectTests(() => {
+      const sut = debounceSignal(1, 500, { injector });
+      return [sut, () => sut.set(2)];
+    }, () => fixture);
 
-  describe('when created from writable overload', () => {
     it('#set should be debounced', fakeAsync(() => {
       const debounced = autoDetectChangesSignal(fixture, debounceSignal('x', 500, { injector }));
       tickAndAssertValue(debounced, [[100, 'x']]);

projects/signal-generators/src/lib/generators/extend-signal.spec.ts

@@ -1,9 +1,21 @@
 import { computed, signal } from '@angular/core';
 import { extendSignal } from './extend-signal';
-import { setupGeneralSignalTests } from '../../testing/general-signal-tests.spec';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
 
 describe('extendSignal', () => {
-  setupGeneralSignalTests(() => extendSignal(1, { dummy: () => undefined}));
+  setupTypeGuardTests(() => extendSignal(1, { dummy: () => undefined}));
+
+  describe('for computed and effects', () => {
+    setupComputedAndEffectTests(() => {
+      const sut = extendSignal(1, { andOne: (proxy) => proxy.update(y => y + 1) });
+      return [sut, () => { sut.andOne(); }];
+    }, null, 'from a value');
+    setupComputedAndEffectTests(() => {
+      const source = signal(1);
+      const sut = extendSignal(source, { andOne: () => source.update(y => y + 1) });
+      return [sut, () => { sut.andOne(); }];
+    }, null, 'from a signal');
+  })
 
   it('initially returns initial value from a value', () => {
     const source = extendSignal(1, { dummy: () => undefined});

projects/signal-generators/src/lib/generators/filter-signal.spec.ts

@@ -1,5 +1,5 @@
 import { MockedComponentFixture, MockRender } from 'ng-mocks';
-import { setupGeneralSignalTests } from '../../testing/general-signal-tests.spec';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
 import { filterSignal } from './filter-signal';
 import { autoDetectChangesSignal } from '../../testing/signal-testing-utilities';
 import { signal } from '@angular/core';
@@ -11,10 +11,16 @@ describe('filterSignal', () => {
     fixture = MockRender();
   });
 
-  setupGeneralSignalTests(() => filterSignal<number>(1, x => x < 5));
+  setupTypeGuardTests(() => filterSignal<number>(1, x => x < 5));
 
 
   describe('from value', () => {
+    setupComputedAndEffectTests(() => {
+      const sut = filterSignal<number>(1, x => x < 5);
+      return [sut, () => sut.set(2)];
+    }, () => fixture);
+
+
     it('filters values based on a boolean condition', () => {
       const sut = filterSignal<number>(1, x => x < 5);
       expect(sut()).toBe(1);
@@ -46,6 +52,12 @@ describe('filterSignal', () => {
   });
 
   describe('from signal', () => {
+    setupComputedAndEffectTests(() => {
+      const source = signal(1);
+      const sut = filterSignal<number>(source, x => x < 5);
+      return [sut, () => source.set(2)];
+    }, () => fixture);
+
     it('filters values based on a boolean condition', () => {
       const source = autoDetectChangesSignal(fixture, signal(1));
       const sut = filterSignal<number>(source, x => x < 5);

projects/signal-generators/src/lib/generators/lift-signal.spec.ts

@@ -1,33 +1,100 @@
 import { signal } from '@angular/core';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
 import { liftSignal } from './lift-signal';
-import { setupGeneralSignalTests } from '../../testing/general-signal-tests.spec';
+
+class DummyClass {
+  constructor(public value: number) { }
+
+  /** for testing mutations */
+  double(): void {
+    this.value *= 2;
+  }
+  triple(): void {
+    this.value *= 3;
+  }
+  /** for testing updated */
+  getQuad(): DummyClass {
+    return new DummyClass(this.value * 4);
+  }
+}
 
 describe('liftSignal', () => {
-  setupGeneralSignalTests(() => liftSignal([1, 2, 3], []));
+  setupTypeGuardTests(() => liftSignal([1, 2, 3], []));
 
   it('initially returns the initial value', () => {
     const src = liftSignal([1, 2, 3], []);
     expect(src()).toEqual([1, 2, 3]);
   });
 
   [
-    { factory: () => [1, 2, 3], label: 'object' },
-    { factory: () => signal([1, 2, 3]), label: 'signal' }
+    { factory: () => new DummyClass(5), label: 'object' },
+    { factory: () => signal(new DummyClass(5)), label: 'object signal' }
   ].forEach(({ factory, label }) => {
-    it(`adds methods from a passed ${label} that mutate the value when called`, () => {
-      const src = liftSignal(factory(), ['push', 'pop', 'shift']);
-      src.push(4);
-      expect(src()).toEqual([1, 2, 3, 4]);
-      src.pop();
-      expect(src()).toEqual([1, 2, 3]);
-      src.shift();
-      expect(src()).toEqual([2, 3]);
+    describe('mutators', () => {
+      setupComputedAndEffectTests(() => {
+        const sut = liftSignal(factory(), null, ['double']);
+        return [sut, () => { sut.double(); }];
+      });
+
+      it(`adds methods from a passed ${label} that mutate the value when called`, () => {
+        const src = liftSignal(factory(), null, ['double', 'triple']);
+        src.double()
+        expect(src()).toEqual(new DummyClass(10));
+        src.triple()
+        expect(src()).toEqual(new DummyClass(30));
+      });
     });
-    it(`adds methods from a passed ${label} that update the value when called`, () => {
-      const src = liftSignal(factory(), null, ['filter']);
-      src.filter(x => x === 2);
-      expect(src()).toEqual([2]);
+    describe('updaters', () => {
+
+      setupComputedAndEffectTests(() => {
+        const sut = liftSignal(factory(), ['getQuad']);
+        return [sut, () => { sut.getQuad(); }];
+      });
+
+      it(`adds methods from a passed ${label} that update the value when called`, () => {
+        const src = liftSignal(factory(), ['getQuad']);
+        src.getQuad();
+        expect(src()).toEqual(new DummyClass(20));
+      });
     });
+
+  });
+
+  [
+    { factory: () => [1, 2, 3], label: 'array' },
+    { factory: () => signal([1, 2, 3]), label: 'array signal' }
+  ].forEach(({ factory, label }) => {
+    describe('mutators', () => {
+      setupComputedAndEffectTests(() => {
+        const sut = liftSignal(factory(), null, ['push']);
+        return [sut, () => { sut.push(5); }];
+      });
+
+      it(`adds methods from a passed ${label} that mutate the value when called`, () => {
+        const src = liftSignal(factory(), ['concat'], ['push', 'pop', 'shift']);
+        src.push(4);
+        expect(src()).toEqual([1, 2, 3, 4]);
+        src.pop();
+        expect(src()).toEqual([1, 2, 3]);
+        src.shift();
+        expect(src()).toEqual([2, 3]);
+        src.concat([4, 5]);
+        expect(src()).toEqual([2, 3, 4, 5]);
+      });
+    });
+    describe('updaters', () => {
+      setupComputedAndEffectTests(() => {
+        const sut = liftSignal(factory(), ['concat']);
+        return [sut, () => { sut.concat([5]); }];
+      });
+
+      it(`adds methods from a passed ${label} that update the value when called`, () => {
+        const src = liftSignal(factory(), ['filter']);
+        src.filter(x => x === 2);
+        expect(src()).toEqual([2]);
+      });
+    });
+
   });
 
 });

projects/signal-generators/src/lib/generators/lift-signal.ts

@@ -1,7 +1,6 @@
 
 import { Signal, WritableSignal, signal } from '@angular/core';
-import { coerceSignal } from '../internal/signal-coercion';
-import { isSignalInput } from '../internal/signal-input-utilities';
+import { SIGNAL } from '@angular/core/primitives/signals';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type MethodKey<T> = keyof { [K in keyof T as T[K] extends (...args: any[]) => unknown ? K : never] : K } & keyof T;
@@ -18,7 +17,7 @@ export type BoundMethods<T, K extends readonly (MethodKey<T> | UpdaterKey<T>)[]
  * Lifts methods from the signal's value to the signal itself.
  * @example
  * ```ts
- * const awesomeArray = liftSignal([1, 2, 3, 4], ['push', 'pop'], ['filter']);
+ * const awesomeArray = liftSignal([1, 2, 3, 4], ['filter'], ['push', 'pop']);
  * awesomeArray.push(5);
  * console.log(awesomeArray()); //[1, 2, 3, 4, 5];
  * awesomeArray.pop();
@@ -27,36 +26,44 @@ export type BoundMethods<T, K extends readonly (MethodKey<T> | UpdaterKey<T>)[]
  * console.log(awesomeArray()); //[2, 4];
  * ```
  * @param valueSource Either a value or a Writable signal.
+ * @param updaters A tuple that contains the names that will return a new value.
  * @param mutators A tuple that contains the names that will modify the signal's value directly.
- * @param updaters A tuple that contains the names that will return T.
+ * To guarantee this will return a new value, structuredClone or object.assign is used to create a brand new object, so used with caution.
  * @typeParam T the type of the signal's value as well as the type where the functions are lifted from.
- * @typeParam M A tuple that contains the names of methods appropriate for mutating.
  * @typeParam U A tuple that contains the names of methods appropriate for updating.
+ * @typeParam M A tuple that contains the names of methods appropriate for mutating.
  */
 export function liftSignal<T extends NonNullable<unknown>,
-    const M extends readonly MethodKey<T>[] | null | undefined,
-    const U extends readonly UpdaterKey<T>[] | null | undefined = null>(
+    const U extends readonly UpdaterKey<T>[] | null | undefined,
+    const M extends readonly MethodKey<T>[] | null | undefined = null>(
   valueSource: Exclude<T, Signal<unknown>> | WritableSignal<T>,
-  mutators: M,
-  updaters?: U):
+  updaters: U,
+  mutators?: M
+  ):
   WritableSignal<T> & BoundMethods<T, M> & BoundMethods<T, U> {
 
-  const output = isSignalInput(valueSource)
-    ? coerceSignal(valueSource as WritableSignal<T>)
+  const output = SIGNAL in valueSource
+    ? valueSource
     : signal(valueSource);
 
   const boundMethods: Partial<BoundMethodsStrict<T, NonNullable<M>> & BoundMethodsStrict<T, NonNullable<U>>> = {};
 
-  mutators?.forEach((cur) => {
-    boundMethods[cur] = (...args) => output.update(x => {
-      (x[cur] as MethodKeyFn<typeof x, typeof cur>)(...args);
-      return x;
-    });
-  });
-
   updaters?.forEach((cur) => {
     boundMethods[cur] = (...args) => output.update(x => (x[cur] as UpdaterKeyFn<typeof x, typeof cur>)(...args));
   });
 
+  if (mutators) {
+    const cloneFn = Array.isArray(output())
+      ? (x: T) => structuredClone(x)
+      : (x: T) => Object.assign(Object.create(Object.getPrototypeOf(x)), x);
+    mutators?.forEach((cur) => {
+      boundMethods[cur] = (...args) => output.update(x => {
+        const cloned = cloneFn(x);
+        (cloned[cur] as MethodKeyFn<typeof x, typeof cur>)(...args);
+        return cloned;
+      });
+    });
+  }
+
   return Object.assign(output, boundMethods as BoundMethods<T, M> & BoundMethods<T, U>);
 }

projects/signal-generators/src/lib/generators/map-signal.spec.ts

@@ -2,7 +2,7 @@ import { MockRender, MockedComponentFixture } from 'ng-mocks';
 import { autoDetectChangesSignal } from '../../testing/signal-testing-utilities';
 import { mapSignal } from './map-signal';
 import { WritableSignal, signal } from '@angular/core';
-import { setupGeneralSignalTests } from '../../testing/general-signal-tests.spec';
+import { setupComputedAndEffectTests, setupTypeGuardTests } from '../../testing/common-signal-tests.spec';
 
 describe('mapSignal', () => {
   let fixture: MockedComponentFixture<void, void>;
@@ -11,7 +11,7 @@ describe('mapSignal', () => {
     fixture = MockRender();
   });
 
-  setupGeneralSignalTests(() => mapSignal(1, (x) => x + 1));
+  setupTypeGuardTests(() => mapSignal(1, (x) => x + 1));
 
   it('throws if not enough parameters are passed', () => {
     expect(() => (mapSignal as unknown as (x: number) => void)(1)).toThrow();
@@ -24,6 +24,11 @@ describe('mapSignal', () => {
       signal1 = autoDetectChangesSignal(fixture, signal(3));
       signal2 = autoDetectChangesSignal(fixture, signal(5));
     });
+    setupComputedAndEffectTests(() => {
+      const source = signal(1);
+      const sut = mapSignal(source, x => x + 1);
+      return [sut, () => { source.set(2) }];
+    }, () => fixture);
     it('the typings are correct for a single signal', () => {
       const source = mapSignal(signal1, (a) => a + 1);
       expect(source()).toBe(4);
@@ -53,6 +58,10 @@ describe('mapSignal', () => {
     });
   });
   describe('when passed a value', () => {
+    setupComputedAndEffectTests(() => {
+      const sut = mapSignal(1, x => x + 1);
+      return [sut, () => { sut.set(2) }];
+    }, () => fixture);
     it('initially returns mapped value', () => {
       const source = autoDetectChangesSignal(fixture, mapSignal(1, (x) => x * 3));
       expect(source()).toBe(3);