Update tests

Author: tommasoberlose

src/updatedAtHelper.ts

@@ -82,3 +82,27 @@ export default class UpdatedAtHelper {
     cache[name] = { ...cache[name], localUpdatedAt: new Date().getTime() };
   }
 }
+
+/**
+ * A testing-specific extension of UpdatedAtHelper that provides methods
+ * to control its internal state for predictable test outcomes.
+ * @internal
+ */
+export class TestUpdatedAtHelper extends UpdatedAtHelper {
+  /**
+   * Resets the internal cache to its default empty state.
+   */
+  static _clearCache() {
+    cache = {};
+  }
+
+  /**
+   * Manually sets the stored timestamp for a slice.
+   * This is useful for simulating scenarios where storage was updated externally.
+   * @param name - The name of the slice.
+   * @param timestamp - The timestamp to set.
+   */
+  static _setStoredUpdatedAtForTest(name: string, timestamp: number) {
+    cache[name] = { ...(cache[name] || { localUpdatedAt: 0 }), storedUpdatedAt: timestamp };
+  }
+}

test/mocks.ts

@@ -1,22 +1,66 @@
+/**
+ * @file This file contains shared mocks and utilities used across the test suite
+ * for the rtk-persist library.
+ */
+
 import { PayloadAction } from "@reduxjs/toolkit";
-import { StorageHandler } from "../src/types";
 import { createPersistedSlice } from "../src/slice";
+import { StorageHandler } from "../src/types";
 
-let data: Record<string, string> = {};
-export const mockStorageHandler: StorageHandler = {
-  getItem: (key: string) => {
-    if (key in data) return data[key];
-    throw new Error();
-  },
-  setItem: (key: string, value: string) => {
-    data[key] = value;
-  },
-  removeItem: (key: string) => {
-    delete data[key];
-  },
-};
+/**
+ * A simple in-memory storage mock that implements the `StorageHandler` interface.
+ * Each instance has its own isolated data store, making it ideal for ensuring
+ * tests do not interfere with one another.
+ * @public
+ */
+export class StorageMock implements StorageHandler {
+  private data: Record<string, string> = {};
+
+  /**
+   * Retrieves an item from the in-memory store.
+   * @param key - The key of the item to retrieve.
+   * @returns The stored value, or `null` if the key does not exist.
+   */
+  getItem(key: string): Promise<string | null> | (string | null) {
+    return key in this.data ? this.data[key] : null;
+  }
 
+  /**
+   * Saves an item to the in-memory store.
+   * @param key - The key to associate with the value.
+   * @param value - The string value to store.
+   */
+  setItem(key: string, value: string): Promise<void> | void {
+    this.data[key] = value;
+  }
+
+  /**
+   * Removes an item from the in-memory store.
+   * @param key - The key of the item to remove.
+   */
+  removeItem(key: string): Promise<void> | void {
+    delete this.data[key];
+  }
+
+  /**
+   * Clears all data from the in-memory store.
+   */
+  clear(): void {
+    this.data = {};
+  }
+}
+
+/**
+ * The default initial state for the mock counter slice.
+ * @public
+ */
 export const sliceInitialState = { counter: 0 };
+
+/**
+ * A pre-configured persisted slice for use in tests.
+ * It includes common reducers and selectors for a counter.
+ * @public
+ */
 export const mockPersistedSlice = createPersistedSlice({
   name: 'test-counter',
   initialState: sliceInitialState,

test/reducer.test.ts

@@ -1,24 +1,98 @@
 import { configurePersistedStore } from "../src";
 import { TestSettings as Settings } from '../src/settings';
-import { mockPersistedSlice, mockStorageHandler } from "./mocks";
+import { StorageHandler } from "../src/types";
+import { mockPersistedSlice, StorageMock } from "./mocks";
 
-describe('Global settings', () => {
+describe('Settings', () => {
+  let storage: StorageHandler;
+
+  // Before each test, create a new storage mock and clear all global settings
+  // to ensure tests are isolated.
   beforeEach(() => {
+    storage = new StorageMock();
     Settings._clearSettings();
   });
-  it('should allow to get and set static variables', () => {
-    Settings.storageHandler = mockStorageHandler;
-    expect(Settings.storageHandler).toEqual(mockStorageHandler);
+
+  describe('storageHandler', () => {
+    it('should allow setting and getting the storage handler', () => {
+      Settings.storageHandler = storage;
+      expect(Settings.storageHandler).toBe(storage);
+    });
+
+    it('should be initialized by configurePersistedStore', async () => {
+      await configurePersistedStore({
+        reducer: ({ [mockPersistedSlice.name]: mockPersistedSlice.reducer }),
+      }, 'mockApp', storage);
+      expect(Settings.storageHandler).toBe(storage);
+    });
+
+    it('should throw a TypeError if accessed before being set', () => {
+      expect(() => Settings.storageHandler).toThrow(TypeError);
+    });
   });
 
-  it('should be initiated when configuring a store', async () => {
-    await configurePersistedStore({
-      reducer: ({ [mockPersistedSlice.name]: mockPersistedSlice.reducer }),
-    }, 'mock', mockStorageHandler);
-    expect(Settings.storageHandler).toEqual(mockStorageHandler);
+  describe('applicationId', () => {
+    it('should allow setting and getting the application ID', () => {
+      Settings.applicationId = 'my-app';
+      expect(Settings.applicationId).toBe('my-app');
+    });
+
+    it('should be initialized by configurePersistedStore', async () => {
+      await configurePersistedStore({
+        reducer: ({ [mockPersistedSlice.name]: mockPersistedSlice.reducer }),
+      }, 'mockApp', storage);
+      expect(Settings.applicationId).toBe('mockApp');
+    });
+
+    it('should throw a TypeError if accessed before being set', () => {
+      expect(() => Settings.applicationId).toThrow(TypeError);
+    });
   });
 
-  it('should throw an exception when requesting variables not set', () => {
-    expect(() => Settings.storageHandler).toThrow(TypeError);
+  describe('slice subscription', () => {
+    it('should allow subscribing slices and retrieving the list', () => {
+      Settings.subscribeSlice('user');
+      Settings.subscribeSlice('posts');
+      expect(Settings.subscribedSliceIds).toEqual(['user', 'posts']);
+    });
+
+    it('should not allow duplicate slice subscriptions', () => {
+      Settings.subscribeSlice('user');
+      Settings.subscribeSlice('user');
+      Settings.subscribeSlice('posts');
+      expect(Settings.subscribedSliceIds).toEqual(['user', 'posts']);
+    });
+
+    it('should be cleared by _clearSettings', () => {
+      Settings.subscribeSlice('user');
+      expect(Settings.subscribedSliceIds).toEqual(['user']);
+      Settings._clearSettings();
+      expect(Settings.subscribedSliceIds).toEqual([]);
+    });
+  });
+
+  describe('persistence pause and resume', () => {
+    it('should be enabled by default', () => {
+      expect(Settings.isPersistenceEnabled).toBe(true);
+    });
+
+    it('should allow pausing persistence', () => {
+      Settings.pause();
+      expect(Settings.isPersistenceEnabled).toBe(false);
+    });
+
+    it('should allow resuming persistence after being paused', () => {
+      Settings.pause();
+      expect(Settings.isPersistenceEnabled).toBe(false);
+      Settings.resume();
+      expect(Settings.isPersistenceEnabled).toBe(true);
+    });
+
+    it('should be reset to enabled when settings are cleared', () => {
+      Settings.pause();
+      expect(Settings.isPersistenceEnabled).toBe(false);
+      Settings._clearSettings();
+      expect(Settings.isPersistenceEnabled).toBe(true);
+    });
   });
-});
+});