@jmruthers/pace-core 0.5.67 → 0.5.69

package/src/components/DataTable/core/__tests__/DataManager.test.ts

@@ -0,0 +1,519 @@
+/**
+ * @file DataManager Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Core/DataManager
+ * @since 0.3.0
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { DataManager } from '../DataManager';
+import type { DataAdapter, FetchOptions } from '../interfaces';
+import type { DataRecord } from '../../types';
+
+// Test data types
+interface TestDataRecord extends DataRecord {
+  id: string;
+  name: string;
+  email: string;
+  created_at: string;
+}
+
+// Mock data adapter
+const createMockAdapter = (): DataAdapter<TestDataRecord> => ({
+  name: 'test-adapter',
+  fetchData: vi.fn(),
+  updateData: vi.fn(),
+  deleteData: vi.fn(),
+  createData: vi.fn(),
+  exportData: vi.fn(),
+  importData: vi.fn(),
+  isConnected: vi.fn(() => true),
+  getError: vi.fn(() => null),
+});
+
+// Test data fixtures
+const createTestData = (overrides: Partial<TestDataRecord> = {}): TestDataRecord => ({
+  id: 'test-id-1',
+  name: 'Test User',
+  email: 'test@example.com',
+  created_at: '2023-01-01T00:00:00Z',
+  ...overrides,
+});
+
+const createTestDataArray = (count: number): TestDataRecord[] => 
+  Array.from({ length: count }, (_, i) => createTestData({
+    id: `test-id-${i + 1}`,
+    name: `Test User ${i + 1}`,
+    email: `test${i + 1}@example.com`,
+  }));
+
+describe('[unit] DataManager', () => {
+  let dataManager: DataManager<TestDataRecord>;
+  let mockAdapter: DataAdapter<TestDataRecord>;
+
+  beforeEach(() => {
+    mockAdapter = createMockAdapter();
+    dataManager = new DataManager(mockAdapter, 5000); // 5 second cache timeout
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Initialization', () => {
+    it('should initialize with empty data and default state', () => {
+      expect(dataManager.getData()).toEqual([]);
+      expect(dataManager.isLoading()).toBe(false);
+      expect(dataManager.getError()).toBe(null);
+    });
+
+    it('should initialize with custom cache timeout', () => {
+      const customTimeout = 10000;
+      const manager = new DataManager(mockAdapter, customTimeout);
+      expect(manager).toBeDefined();
+    });
+
+    it('should set adapter correctly', () => {
+      expect(dataManager.getAdapter()).toBe(mockAdapter);
+    });
+  });
+
+  describe('Data Retrieval', () => {
+    it('should return current data', () => {
+      const testData = createTestDataArray(3);
+      // Manually set data for testing (simulating internal state)
+      (dataManager as any).data = testData;
+      
+      expect(dataManager.getData()).toEqual(testData);
+    });
+
+    it('should return empty array when no data', () => {
+      expect(dataManager.getData()).toEqual([]);
+    });
+  });
+
+  describe('CRUD Operations', () => {
+    describe('Create Data', () => {
+      it('should create new data item successfully', async () => {
+        const newData = { name: 'New User', email: 'new@example.com' };
+        const createdItem = createTestData(newData);
+        
+        vi.mocked(mockAdapter.createData).mockResolvedValue(createdItem);
+
+        const result = await dataManager.createData(newData);
+
+        expect(mockAdapter.createData).toHaveBeenCalledWith(newData);
+        expect(result).toEqual(createdItem);
+        expect(dataManager.getData()).toContain(createdItem);
+        expect(dataManager.isLoading()).toBe(false);
+        expect(dataManager.getError()).toBe(null);
+      });
+
+      it('should handle create data errors', async () => {
+        const newData = { name: 'New User', email: 'new@example.com' };
+        const error = new Error('Create failed');
+        
+        vi.mocked(mockAdapter.createData).mockRejectedValue(error);
+
+        await expect(dataManager.createData(newData)).rejects.toThrow('Create failed');
+        
+        expect(dataManager.getError()).toBe(error);
+        expect(dataManager.isLoading()).toBe(false);
+        expect(dataManager.getData()).toEqual([]);
+      });
+
+      it('should set loading state during create operation', async () => {
+        const newData = { name: 'New User', email: 'new@example.com' };
+        const createdItem = createTestData(newData);
+        
+        let resolveCreate: (value: TestDataRecord) => void;
+        const createPromise = new Promise<TestDataRecord>((resolve) => {
+          resolveCreate = resolve;
+        });
+        
+        vi.mocked(mockAdapter.createData).mockReturnValue(createPromise);
+
+        const createPromise2 = dataManager.createData(newData);
+        
+        // Check loading state during operation
+        expect(dataManager.isLoading()).toBe(true);
+        
+        resolveCreate!(createdItem);
+        await createPromise2;
+        
+        expect(dataManager.isLoading()).toBe(false);
+      });
+    });
+
+    describe('Update Data', () => {
+      beforeEach(() => {
+        // Set up initial data
+        const testData = createTestDataArray(3);
+        (dataManager as any).data = testData;
+      });
+
+      it('should update existing data item successfully', async () => {
+        const id = 'test-id-1';
+        const updates = { name: 'Updated User' };
+        
+        vi.mocked(mockAdapter.updateData).mockResolvedValue(undefined);
+
+        await dataManager.updateData(id, updates);
+
+        expect(mockAdapter.updateData).toHaveBeenCalledWith(id, updates);
+        
+        const updatedItem = dataManager.getData().find(item => item.id === id);
+        expect(updatedItem).toMatchObject(updates);
+        expect(dataManager.isLoading()).toBe(false);
+        expect(dataManager.getError()).toBe(null);
+      });
+
+      it('should handle update data errors', async () => {
+        const id = 'test-id-1';
+        const updates = { name: 'Updated User' };
+        const error = new Error('Update failed');
+        
+        vi.mocked(mockAdapter.updateData).mockRejectedValue(error);
+
+        await expect(dataManager.updateData(id, updates)).rejects.toThrow('Update failed');
+        
+        expect(dataManager.getError()).toBe(error);
+        expect(dataManager.isLoading()).toBe(false);
+      });
+
+      it('should not update local data if item not found', async () => {
+        const id = 'non-existent-id';
+        const updates = { name: 'Updated User' };
+        
+        vi.mocked(mockAdapter.updateData).mockResolvedValue(undefined);
+
+        await dataManager.updateData(id, updates);
+
+        expect(mockAdapter.updateData).toHaveBeenCalledWith(id, updates);
+        // Local data should remain unchanged
+        expect(dataManager.getData()).toEqual(createTestDataArray(3));
+      });
+
+      it('should set loading state during update operation', async () => {
+        const id = 'test-id-1';
+        const updates = { name: 'Updated User' };
+        
+        let resolveUpdate: () => void;
+        const updatePromise = new Promise<void>((resolve) => {
+          resolveUpdate = resolve;
+        });
+        
+        vi.mocked(mockAdapter.updateData).mockReturnValue(updatePromise);
+
+        const updatePromise2 = dataManager.updateData(id, updates);
+        
+        // Check loading state during operation
+        expect(dataManager.isLoading()).toBe(true);
+        
+        resolveUpdate!();
+        await updatePromise2;
+        
+        expect(dataManager.isLoading()).toBe(false);
+      });
+    });
+
+    describe('Delete Data', () => {
+      beforeEach(() => {
+        // Set up initial data
+        const testData = createTestDataArray(3);
+        (dataManager as any).data = testData;
+      });
+
+      it('should delete data item successfully', async () => {
+        const id = 'test-id-1';
+        
+        vi.mocked(mockAdapter.deleteData).mockResolvedValue(undefined);
+
+        await dataManager.deleteData(id);
+
+        expect(mockAdapter.deleteData).toHaveBeenCalledWith(id);
+        expect(dataManager.getData()).toHaveLength(2);
+        expect(dataManager.getData().find(item => item.id === id)).toBeUndefined();
+        expect(dataManager.isLoading()).toBe(false);
+        expect(dataManager.getError()).toBe(null);
+      });
+
+      it('should handle delete data errors', async () => {
+        const id = 'test-id-1';
+        const error = new Error('Delete failed');
+        
+        vi.mocked(mockAdapter.deleteData).mockRejectedValue(error);
+
+        await expect(dataManager.deleteData(id)).rejects.toThrow('Delete failed');
+        
+        expect(dataManager.getError()).toBe(error);
+        expect(dataManager.isLoading()).toBe(false);
+        // Data should remain unchanged on error
+        expect(dataManager.getData()).toHaveLength(3);
+      });
+
+      it('should not remove item if not found locally', async () => {
+        const id = 'non-existent-id';
+        
+        vi.mocked(mockAdapter.deleteData).mockResolvedValue(undefined);
+
+        await dataManager.deleteData(id);
+
+        expect(mockAdapter.deleteData).toHaveBeenCalledWith(id);
+        // Local data should remain unchanged
+        expect(dataManager.getData()).toHaveLength(3);
+      });
+
+      it('should set loading state during delete operation', async () => {
+        const id = 'test-id-1';
+        
+        let resolveDelete: () => void;
+        const deletePromise = new Promise<void>((resolve) => {
+          resolveDelete = resolve;
+        });
+        
+        vi.mocked(mockAdapter.deleteData).mockReturnValue(deletePromise);
+
+        const deletePromise2 = dataManager.deleteData(id);
+        
+        // Check loading state during operation
+        expect(dataManager.isLoading()).toBe(true);
+        
+        resolveDelete!();
+        await deletePromise2;
+        
+        expect(dataManager.isLoading()).toBe(false);
+      });
+    });
+  });
+
+  describe('Caching', () => {
+    it('should cache data with timestamp', async () => {
+      const cacheKey = 'test-cache-key';
+      const testData = createTestDataArray(3);
+      
+      dataManager.setCachedData(cacheKey, testData);
+      
+      const cachedData = await dataManager.getCachedData(cacheKey);
+      expect(cachedData).toEqual(testData);
+    });
+
+    it('should return null for non-existent cache key', async () => {
+      const cacheKey = 'non-existent-key';
+      
+      const cachedData = await dataManager.getCachedData(cacheKey);
+      expect(cachedData).toBeNull();
+    });
+
+    it('should return null for expired cache', async () => {
+      const cacheKey = 'expired-cache-key';
+      const testData = createTestDataArray(3);
+      
+      // Set cache with old timestamp
+      (dataManager as any).cache.set(cacheKey, {
+        data: testData,
+        timestamp: Date.now() - 10000, // 10 seconds ago
+      });
+      
+      const cachedData = await dataManager.getCachedData(cacheKey);
+      expect(cachedData).toBeNull();
+    });
+
+    it('should clear cache after CRUD operations', async () => {
+      const cacheKey = 'test-cache-key';
+      const testData = createTestDataArray(3);
+      
+      dataManager.setCachedData(cacheKey, testData);
+      expect(await dataManager.getCachedData(cacheKey)).toEqual(testData);
+      
+      // Perform CRUD operation
+      const newData = { name: 'New User', email: 'new@example.com' };
+      const createdItem = createTestData(newData);
+      vi.mocked(mockAdapter.createData).mockResolvedValue(createdItem);
+      
+      await dataManager.createData(newData);
+      
+      // Cache should be cleared
+      expect(await dataManager.getCachedData(cacheKey)).toBeNull();
+    });
+
+    it('should clear all cache', () => {
+      const testData = createTestDataArray(3);
+      
+      dataManager.setCachedData('key1', testData);
+      dataManager.setCachedData('key2', testData);
+      
+      expect((dataManager as any).cache.size).toBe(2);
+      
+      dataManager.clearCache();
+      
+      expect((dataManager as any).cache.size).toBe(0);
+    });
+
+    it('should handle cache timeout configuration', async () => {
+      const shortTimeoutManager = new DataManager(mockAdapter, 1000); // 1 second timeout
+      const cacheKey = 'test-cache-key';
+      const testData = createTestDataArray(3);
+      
+      shortTimeoutManager.setCachedData(cacheKey, testData);
+      
+      // Should be available immediately
+      expect(await shortTimeoutManager.getCachedData(cacheKey)).toEqual(testData);
+      
+      // Wait for timeout
+      await new Promise(resolve => setTimeout(resolve, 1100));
+      
+      // Should be expired now
+      expect(await shortTimeoutManager.getCachedData(cacheKey)).toBeNull();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should set error state on create failure', async () => {
+      const error = new Error('Create failed');
+      vi.mocked(mockAdapter.createData).mockRejectedValue(error);
+      
+      await expect(dataManager.createData({})).rejects.toThrow();
+      expect(dataManager.getError()).toBe(error);
+    });
+
+    it('should set error state on update failure', async () => {
+      const error = new Error('Update failed');
+      vi.mocked(mockAdapter.updateData).mockRejectedValue(error);
+      
+      await expect(dataManager.updateData('id', {})).rejects.toThrow();
+      expect(dataManager.getError()).toBe(error);
+    });
+
+    it('should set error state on delete failure', async () => {
+      const error = new Error('Delete failed');
+      vi.mocked(mockAdapter.deleteData).mockRejectedValue(error);
+      
+      await expect(dataManager.deleteData('id')).rejects.toThrow();
+      expect(dataManager.getError()).toBe(error);
+    });
+
+    it('should clear error state on successful operation', async () => {
+      // First, set an error
+      const error = new Error('Previous error');
+      (dataManager as any).error = error;
+      expect(dataManager.getError()).toBe(error);
+      
+      // Then perform successful operation
+      const newData = { name: 'New User', email: 'new@example.com' };
+      const createdItem = createTestData(newData);
+      vi.mocked(mockAdapter.createData).mockResolvedValue(createdItem);
+      
+      await dataManager.createData(newData);
+      
+      expect(dataManager.getError()).toBe(null);
+    });
+  });
+
+  describe('Adapter Management', () => {
+    it('should set new adapter', () => {
+      const newAdapter = createMockAdapter();
+      
+      dataManager.setAdapter(newAdapter);
+      
+      expect(dataManager.getAdapter()).toBe(newAdapter);
+    });
+
+    it('should clear cache when setting new adapter', () => {
+      const testData = createTestDataArray(3);
+      dataManager.setCachedData('test-key', testData);
+      
+      expect((dataManager as any).cache.size).toBe(1);
+      
+      const newAdapter = createMockAdapter();
+      dataManager.setAdapter(newAdapter);
+      
+      expect((dataManager as any).cache.size).toBe(0);
+    });
+  });
+
+  describe('Row ID Generation', () => {
+    it('should use id field for row identification', () => {
+      const item = createTestData({ id: 'test-id' });
+      const rowId = (dataManager as any).getRowId(item);
+      expect(rowId).toBe('test-id');
+    });
+
+    it('should use key field when id is not available', () => {
+      const item = { key: 'test-key', name: 'Test' } as any;
+      const rowId = (dataManager as any).getRowId(item);
+      expect(rowId).toBe('test-key');
+    });
+
+    it('should use JSON string when neither id nor key is available', () => {
+      const item = { name: 'Test', email: 'test@example.com' } as any;
+      const rowId = (dataManager as any).getRowId(item);
+      expect(rowId).toBe(JSON.stringify(item));
+    });
+  });
+
+  describe('Concurrent Operations', () => {
+    it('should handle concurrent create operations', async () => {
+      const data1 = { name: 'User 1', email: 'user1@example.com' };
+      const data2 = { name: 'User 2', email: 'user2@example.com' };
+      const created1 = createTestData({ ...data1, id: 'id-1' });
+      const created2 = createTestData({ ...data2, id: 'id-2' });
+      
+      vi.mocked(mockAdapter.createData)
+        .mockResolvedValueOnce(created1)
+        .mockResolvedValueOnce(created2);
+
+      const [result1, result2] = await Promise.all([
+        dataManager.createData(data1),
+        dataManager.createData(data2),
+      ]);
+
+      expect(result1).toEqual(created1);
+      expect(result2).toEqual(created2);
+      expect(dataManager.getData()).toHaveLength(2);
+    });
+
+    it('should handle concurrent update operations', async () => {
+      const testData = createTestDataArray(2);
+      (dataManager as any).data = testData;
+      
+      vi.mocked(mockAdapter.updateData).mockResolvedValue(undefined);
+
+      await Promise.all([
+        dataManager.updateData('test-id-1', { name: 'Updated 1' }),
+        dataManager.updateData('test-id-2', { name: 'Updated 2' }),
+      ]);
+
+      expect(mockAdapter.updateData).toHaveBeenCalledTimes(2);
+      expect(dataManager.getData()).toHaveLength(2);
+    });
+  });
+
+  describe('Performance and Memory', () => {
+    it('should handle large datasets efficiently', async () => {
+      const largeDataset = createTestDataArray(1000);
+      (dataManager as any).data = largeDataset;
+      
+      expect(dataManager.getData()).toHaveLength(1000);
+      expect(dataManager.getData()[0]).toEqual(expect.objectContaining({
+        id: 'test-id-1',
+        name: 'Test User 1',
+      }));
+    });
+
+    it('should not leak memory with repeated operations', async () => {
+      const testData = { name: 'Test User', email: 'test@example.com' };
+      const createdItem = createTestData(testData);
+      
+      vi.mocked(mockAdapter.createData).mockResolvedValue(createdItem);
+
+      // Perform multiple operations
+      for (let i = 0; i < 100; i++) {
+        await dataManager.createData({ ...testData, name: `User ${i}` });
+      }
+
+      expect(dataManager.getData()).toHaveLength(100);
+      expect((dataManager as any).cache.size).toBe(0); // Cache should be cleared after each operation
+    });
+  });
+});