test(undo-redo): ensure no undo after clearing the undo-redo stacks

Author: GregOnNet

libs/ngrx-toolkit/src/lib/with-undo-redo.spec.ts

@@ -1,9 +1,16 @@
-import { patchState, signalStore, type, withComputed, withMethods, withState } from '@ngrx/signals';
+import { computed, inject } from '@angular/core';
 import { fakeAsync, TestBed, tick } from '@angular/core/testing';
-import { withUndoRedo } from './with-undo-redo';
+import {
+  patchState,
+  signalStore,
+  type,
+  withComputed,
+  withMethods,
+  withState,
+} from '@ngrx/signals';
 import { addEntity, withEntities } from '@ngrx/signals/entities';
-import { computed, inject } from '@angular/core';
 import { withCallState } from './with-call-state';
+import { withUndoRedo } from './with-undo-redo';
 
 const testState = { test: '' };
 const testKeys = ['test' as const];
@@ -13,7 +20,10 @@ const newerValue = 'newer value';
 describe('withUndoRedo', () => {
   it('adds methods for undo, redo, canUndo, canRedo', () => {
     TestBed.runInInjectionContext(() => {
-      const Store = signalStore(withState(testState), withUndoRedo({ keys: testKeys }));
+      const Store = signalStore(
+        withState(testState),
+        withUndoRedo({ keys: testKeys })
+      );
       const store = new Store();
 
       expect(Object.keys(store)).toEqual([
@@ -22,39 +32,55 @@ describe('withUndoRedo', () => {
         'canRedo',
         'undo',
         'redo',
-        'clearStack'
+        'clearStack',
       ]);
     });
   });
 
   it('should check keys and collection types', () => {
-    signalStore(withState(testState),
+    signalStore(
+      withState(testState),
       // @ts-expect-error - should not allow invalid keys
-      withUndoRedo({ keys: ['tes'] }));
-    signalStore(withState(testState),
+      withUndoRedo({ keys: ['tes'] })
+    );
+    signalStore(
+      withState(testState),
       withEntities({ entity: type(), collection: 'flight' }),
       // @ts-expect-error - should not allow invalid keys when entities are present
-      withUndoRedo({ keys: ['flightIdsTest'] }));
-    signalStore(withState(testState),
+      withUndoRedo({ keys: ['flightIdsTest'] })
+    );
+    signalStore(
+      withState(testState),
       // @ts-expect-error - should not allow collections without named entities
-      withUndoRedo({ collections: ['tee'] }));
-    signalStore(withState(testState), withComputed(store => ({ testComputed: computed(() => store.test()) })),
+      withUndoRedo({ collections: ['tee'] })
+    );
+    signalStore(
+      withState(testState),
+      withComputed((store) => ({ testComputed: computed(() => store.test()) })),
       // @ts-expect-error - should not allow collections without named entities with other computed
-      withUndoRedo({ collections: ['tested'] }));
-    signalStore(withEntities({ entity: type() }),
+      withUndoRedo({ collections: ['tested'] })
+    );
+    signalStore(
+      withEntities({ entity: type() }),
       // @ts-expect-error - should not allow collections without named entities
-      withUndoRedo({ collections: ['test'] }));
-    signalStore(withEntities({ entity: type(), collection: 'flight' }),
+      withUndoRedo({ collections: ['test'] })
+    );
+    signalStore(
+      withEntities({ entity: type(), collection: 'flight' }),
       // @ts-expect-error - should not allow invalid collections
-      withUndoRedo({ collections: ['test'] }));
+      withUndoRedo({ collections: ['test'] })
+    );
   });
 
   describe('undo and redo', () => {
     it('restores previous state for regular store key', fakeAsync(() => {
       TestBed.runInInjectionContext(() => {
         const Store = signalStore(
           withState(testState),
-          withMethods(store => ({ updateTest: (newTest: string) => patchState(store, { test: newTest }) })),
+          withMethods((store) => ({
+            updateTest: (newTest: string) =>
+              patchState(store, { test: newTest }),
+          })),
           withUndoRedo({ keys: testKeys })
         );
 
@@ -80,7 +106,10 @@ describe('withUndoRedo', () => {
       TestBed.runInInjectionContext(() => {
         const Store = signalStore(
           withState(testState),
-          withMethods(store => ({ updateTest: (newTest: string) => patchState(store, { test: newTest }) })),
+          withMethods((store) => ({
+            updateTest: (newTest: string) =>
+              patchState(store, { test: newTest }),
+          })),
           withUndoRedo({ keys: testKeys, skip: 1 })
         );
 
@@ -111,8 +140,9 @@ describe('withUndoRedo', () => {
     it('undoes and redoes previous state for entity', fakeAsync(() => {
       const Store = signalStore(
         withEntities({ entity: type<{ id: string }>() }),
-        withMethods(store => ({
-          addEntity: (newTest: string) => patchState(store, addEntity({ id: newTest }))
+        withMethods((store) => ({
+          addEntity: (newTest: string) =>
+            patchState(store, addEntity({ id: newTest })),
         })),
         withUndoRedo()
       );
@@ -132,7 +162,10 @@ describe('withUndoRedo', () => {
 
         store.addEntity(newerValue);
         tick(1);
-        expect(store.entities()).toEqual([{ id: newValue }, { id: newerValue }]);
+        expect(store.entities()).toEqual([
+          { id: newValue },
+          { id: newerValue },
+        ]);
         expect(store.canUndo()).toBe(true);
         expect(store.canRedo()).toBe(false);
 
@@ -166,9 +199,16 @@ describe('withUndoRedo', () => {
     it('restores previous state for named entity', fakeAsync(() => {
       TestBed.runInInjectionContext(() => {
         const Store = signalStore(
-          withEntities({ entity: type<{ id: string }>(), collection: 'flight' }),
-          withMethods(store => ({
-            addEntity: (newTest: string) => patchState(store, addEntity({ id: newTest }, { collection: 'flight' }))
+          withEntities({
+            entity: type<{ id: string }>(),
+            collection: 'flight',
+          }),
+          withMethods((store) => ({
+            addEntity: (newTest: string) =>
+              patchState(
+                store,
+                addEntity({ id: newTest }, { collection: 'flight' })
+              ),
           })),
           withCallState({ collection: 'flight' }),
           withUndoRedo({ collections: ['flight'] })
@@ -196,7 +236,9 @@ describe('withUndoRedo', () => {
       const Store = signalStore(
         { providedIn: 'root' },
         withState(testState),
-        withMethods(store => ({ update: (value: string) => patchState(store, { test: value }) })),
+        withMethods((store) => ({
+          update: (value: string) => patchState(store, { test: value }),
+        })),
         withUndoRedo({ keys: testKeys })
       );
 
@@ -209,6 +251,38 @@ describe('withUndoRedo', () => {
 
       expect(store.canUndo()).toBe(false);
       expect(store.canRedo()).toBe(false);
-    })
+    });
+
+    it('can undo after clearing and setting the same value again', fakeAsync(() => {
+      const recordState = { customer: { firstname: 'Santa' } };
+
+      const Store = signalStore(
+        { providedIn: 'root' },
+        withState(recordState),
+        withMethods((store) => ({
+          update: (value: typeof recordState) => patchState(store, value),
+        })),
+        withUndoRedo({ keys: ['customer'] })
+      );
+
+      const store = TestBed.inject(Store);
+
+      store.update({ customer: { firstname: 'Alan' } });
+      tick(1);
+
+      store.update({ customer: { firstname: 'Gordon' } });
+      tick(1);
+
+      store.clearStack();
+      tick(1);
+
+      // After clearing the undo/redo stack, there is no previous item any more
+      // The following update is the very first value.
+      store.update({ customer: { firstname: 'Hugh' } });
+      tick(1);
+
+      expect(store.canUndo()).toBe(false);
+      expect(store.canRedo()).toBe(false);
+    }));
   });
 });