@jmruthers/pace-core 0.5.74 → 0.5.76

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

@@ -1,634 +0,0 @@
-/**
- * @file ActionManager Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/ActionManager
- * @since 0.3.0
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { ActionManagerImpl } from '../ActionManager';
-import type { DataTableAction } from '../../types';
-import type { DataRecord } from '../../types';
-
-// Test data types
-interface TestDataRecord extends DataRecord {
-  id: string;
-  name: string;
-  email: string;
-  role: string;
-  isActive: boolean;
-}
-
-// Test data fixtures
-const createTestData = (overrides: Partial<TestDataRecord> = {}): TestDataRecord => ({
-  id: 'test-id-1',
-  name: 'Test User',
-  email: 'test@example.com',
-  role: 'user',
-  isActive: true,
-  ...overrides,
-});
-
-const createTestAction = (overrides: Partial<DataTableAction<TestDataRecord>> = {}): DataTableAction<TestDataRecord> => ({
-  label: 'Test Action',
-  onClick: vi.fn(),
-  variant: 'default',
-  testId: 'test-action',
-  ...overrides,
-});
-
-const createTestActions = (count: number): DataTableAction<TestDataRecord>[] => 
-  Array.from({ length: count }, (_, i) => createTestAction({
-    label: `Action ${i + 1}`,
-    testId: `action-${i + 1}`,
-    onClick: vi.fn(),
-  }));
-
-describe('[unit] ActionManager', () => {
-  let actionManager: ActionManagerImpl<TestDataRecord>;
-  let testActions: DataTableAction<TestDataRecord>[];
-
-  beforeEach(() => {
-    testActions = createTestActions(3);
-    actionManager = new ActionManagerImpl(testActions);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Initialization', () => {
-    it('should initialize with empty actions array', () => {
-      const emptyManager = new ActionManagerImpl();
-      expect(emptyManager.getActions()).toEqual([]);
-      expect(emptyManager.getActionCount()).toBe(0);
-    });
-
-    it('should initialize with provided actions', () => {
-      expect(actionManager.getActions()).toHaveLength(3);
-      expect(actionManager.getActionCount()).toBe(3);
-    });
-
-    it('should create action map from initial actions', () => {
-      expect(actionManager.hasAction('action-1')).toBe(true);
-      expect(actionManager.hasAction('action-2')).toBe(true);
-      expect(actionManager.hasAction('action-3')).toBe(true);
-    });
-  });
-
-  describe('Action Retrieval', () => {
-    it('should get all actions', () => {
-      const actions = actionManager.getActions();
-      expect(actions).toHaveLength(3);
-      expect(actions[0].label).toBe('Action 1');
-    });
-
-    it('should return copy of actions array', () => {
-      const actions1 = actionManager.getActions();
-      const actions2 = actionManager.getActions();
-      expect(actions1).not.toBe(actions2); // Different array instances
-      expect(actions1).toEqual(actions2); // Same content
-    });
-
-    it('should get action by ID', () => {
-      const action = actionManager.getAction('action-1');
-      expect(action).toBeDefined();
-      expect(action?.label).toBe('Action 1');
-    });
-
-    it('should return undefined for non-existent action', () => {
-      const action = actionManager.getAction('non-existent');
-      expect(action).toBeUndefined();
-    });
-
-    it('should get action by index', () => {
-      const action = actionManager.getActionByIndex(0);
-      expect(action).toBeDefined();
-      expect(action?.label).toBe('Action 1');
-    });
-
-    it('should return undefined for invalid index', () => {
-      const action = actionManager.getActionByIndex(999);
-      expect(action).toBeUndefined();
-    });
-
-    it('should get action index by ID', () => {
-      const index = actionManager.getActionIndex('action-2');
-      expect(index).toBe(1);
-    });
-
-    it('should return -1 for non-existent action index', () => {
-      const index = actionManager.getActionIndex('non-existent');
-      expect(index).toBe(-1);
-    });
-  });
-
-  describe('Action Management', () => {
-    describe('Add Action', () => {
-      it('should add new action', () => {
-        const newAction = createTestAction({
-          label: 'New Action',
-          testId: 'new-action',
-        });
-
-        actionManager.addAction(newAction);
-
-        expect(actionManager.getActionCount()).toBe(4);
-        expect(actionManager.hasAction('new-action')).toBe(true);
-        expect(actionManager.getAction('new-action')).toEqual(newAction);
-      });
-
-      it('should replace existing action with same ID', () => {
-        const originalAction = actionManager.getAction('action-1');
-        const updatedAction = createTestAction({
-          label: 'Updated Action 1',
-          testId: 'action-1',
-        });
-
-        actionManager.addAction(updatedAction);
-
-        expect(actionManager.getActionCount()).toBe(3); // Count should remain same
-        expect(actionManager.getAction('action-1')).toEqual(updatedAction);
-        expect(actionManager.getAction('action-1')).not.toEqual(originalAction);
-      });
-
-      it('should generate ID from label when testId is not provided', () => {
-        const actionWithoutId = createTestAction({
-          label: 'Action Without ID',
-          testId: undefined,
-        });
-
-        actionManager.addAction(actionWithoutId);
-
-        const generatedId = 'action-without-id';
-        expect(actionManager.hasAction(generatedId)).toBe(true);
-      });
-
-    it('should generate random ID when neither testId nor label provided', () => {
-      const actionWithoutId = createTestAction({
-        label: '',
-        testId: undefined,
-      });
-
-      actionManager.addAction(actionWithoutId);
-
-      // The action should be stored with a generated testId
-      const actions = actionManager.getActions();
-      const addedAction = actions.find(a => a.label === '');
-      expect(addedAction).toBeDefined();
-      
-      // Check that the action has a generated testId
-      const generatedId = (actionManager as any).getActionId(addedAction);
-      expect(generatedId).toMatch(/^action-[a-z0-9]{9}$/);
-    });
-    });
-
-    describe('Remove Action', () => {
-      it('should remove existing action', () => {
-        actionManager.removeAction('action-1');
-
-        expect(actionManager.getActionCount()).toBe(2);
-        expect(actionManager.hasAction('action-1')).toBe(false);
-        expect(actionManager.getAction('action-1')).toBeUndefined();
-      });
-
-      it('should not affect other actions when removing', () => {
-        actionManager.removeAction('action-2');
-
-        expect(actionManager.hasAction('action-1')).toBe(true);
-        expect(actionManager.hasAction('action-3')).toBe(true);
-        expect(actionManager.getActionCount()).toBe(2);
-      });
-
-      it('should handle removal of non-existent action gracefully', () => {
-        const initialCount = actionManager.getActionCount();
-        actionManager.removeAction('non-existent');
-        expect(actionManager.getActionCount()).toBe(initialCount);
-      });
-    });
-
-    describe('Update Action', () => {
-      it('should update existing action', () => {
-        const updates = { label: 'Updated Action 1', variant: 'destructive' as const };
-
-        actionManager.updateAction('action-1', updates);
-
-        const updatedAction = actionManager.getAction('action-1');
-        expect(updatedAction?.label).toBe('Updated Action 1');
-        expect(updatedAction?.variant).toBe('destructive');
-        expect(updatedAction?.testId).toBe('action-1'); // Should preserve original testId
-      });
-
-      it('should throw error when updating non-existent action', () => {
-        expect(() => {
-          actionManager.updateAction('non-existent', { label: 'Updated' });
-        }).toThrow('Action with ID "non-existent" not found');
-      });
-
-      it('should update action in both array and map', () => {
-        const updates = { label: 'Updated Action 1' };
-
-        actionManager.updateAction('action-1', updates);
-
-        const actionFromMap = actionManager.getAction('action-1');
-        const actionFromArray = actionManager.getActionByIndex(0);
-
-        expect(actionFromMap?.label).toBe('Updated Action 1');
-        expect(actionFromArray?.label).toBe('Updated Action 1');
-        expect(actionFromMap).toBe(actionFromArray); // Same reference
-      });
-    });
-
-    describe('Set Actions', () => {
-      it('should replace all actions', () => {
-        const newActions = createTestActions(2);
-        newActions[0].testId = 'new-action-1';
-        newActions[1].testId = 'new-action-2';
-
-        actionManager.setActions(newActions);
-
-        expect(actionManager.getActionCount()).toBe(2);
-        expect(actionManager.hasAction('action-1')).toBe(false);
-        expect(actionManager.hasAction('new-action-1')).toBe(true);
-        expect(actionManager.hasAction('new-action-2')).toBe(true);
-      });
-
-      it('should clear action map when setting new actions', () => {
-        const newActions = createTestActions(1);
-        newActions[0].testId = 'replacement-action';
-
-        actionManager.setActions(newActions);
-
-        expect(actionManager.getActionCount()).toBe(1);
-        expect(actionManager.hasAction('action-1')).toBe(false);
-        expect(actionManager.hasAction('replacement-action')).toBe(true);
-      });
-
-      it('should handle empty actions array', () => {
-        actionManager.setActions([]);
-
-        expect(actionManager.getActionCount()).toBe(0);
-        expect(actionManager.getActions()).toEqual([]);
-      });
-    });
-
-    describe('Clear Actions', () => {
-      it('should clear all actions', () => {
-        actionManager.clearActions();
-
-        expect(actionManager.getActionCount()).toBe(0);
-        expect(actionManager.getActions()).toEqual([]);
-        expect(actionManager.hasAction('action-1')).toBe(false);
-      });
-    });
-  });
-
-  describe('Action Filtering', () => {
-    beforeEach(() => {
-      const actions = [
-        createTestAction({ label: 'Enabled Action', testId: 'enabled', disabled: false }),
-        createTestAction({ label: 'Disabled Action', testId: 'disabled', disabled: true }),
-        createTestAction({ 
-          label: 'Conditional Action', 
-          testId: 'conditional', 
-          disabled: (row: TestDataRecord) => !row.isActive 
-        }),
-        createTestAction({ label: 'Another Enabled', testId: 'enabled2', disabled: false }),
-      ];
-      actionManager.setActions(actions);
-    });
-
-    it('should get enabled actions', () => {
-      const enabledActions = actionManager.getEnabledActions();
-      expect(enabledActions).toHaveLength(2); // 2 explicitly enabled (conditional is disabled with mock row)
-      expect(enabledActions.map(a => a.testId)).toContain('enabled');
-      expect(enabledActions.map(a => a.testId)).toContain('enabled2');
-    });
-
-    it('should get actions by variant', () => {
-      const actions = [
-        createTestAction({ label: 'Default Action', testId: 'default', variant: 'default' }),
-        createTestAction({ label: 'Destructive Action', testId: 'destructive', variant: 'destructive' }),
-        createTestAction({ label: 'Secondary Action', testId: 'secondary', variant: 'secondary' }),
-        createTestAction({ label: 'Another Default', testId: 'default2', variant: 'default' }),
-      ];
-      actionManager.setActions(actions);
-
-      const defaultActions = actionManager.getActionsByVariant('default');
-      expect(defaultActions).toHaveLength(2);
-      expect(defaultActions.map(a => a.testId)).toContain('default');
-      expect(defaultActions.map(a => a.testId)).toContain('default2');
-
-      const destructiveActions = actionManager.getActionsByVariant('destructive');
-      expect(destructiveActions).toHaveLength(1);
-      expect(destructiveActions[0].testId).toBe('destructive');
-    });
-
-    it('should get destructive actions', () => {
-      const actions = [
-        createTestAction({ label: 'Delete', testId: 'delete', variant: 'destructive' }),
-        createTestAction({ label: 'Edit', testId: 'edit', variant: 'default' }),
-        createTestAction({ label: 'Remove', testId: 'remove', variant: 'destructive' }),
-      ];
-      actionManager.setActions(actions);
-
-      const destructiveActions = actionManager.getDestructiveActions();
-      expect(destructiveActions).toHaveLength(2);
-      expect(destructiveActions.map(a => a.testId)).toContain('delete');
-      expect(destructiveActions.map(a => a.testId)).toContain('remove');
-    });
-
-    it('should get primary actions', () => {
-      const actions = [
-        createTestAction({ label: 'Primary', testId: 'primary', variant: 'default' }),
-        createTestAction({ label: 'Secondary', testId: 'secondary', variant: 'secondary' }),
-        createTestAction({ label: 'Another Primary', testId: 'primary2', variant: 'default' }),
-      ];
-      actionManager.setActions(actions);
-
-      const primaryActions = actionManager.getPrimaryActions();
-      expect(primaryActions).toHaveLength(2);
-      expect(primaryActions.map(a => a.testId)).toContain('primary');
-      expect(primaryActions.map(a => a.testId)).toContain('primary2');
-    });
-
-    it('should get secondary actions', () => {
-      const actions = [
-        createTestAction({ label: 'Primary', testId: 'primary', variant: 'default' }),
-        createTestAction({ label: 'Secondary', testId: 'secondary', variant: 'secondary' }),
-        createTestAction({ label: 'Another Secondary', testId: 'secondary2', variant: 'secondary' }),
-      ];
-      actionManager.setActions(actions);
-
-      const secondaryActions = actionManager.getSecondaryActions();
-      expect(secondaryActions).toHaveLength(2);
-      expect(secondaryActions.map(a => a.testId)).toContain('secondary');
-      expect(secondaryActions.map(a => a.testId)).toContain('secondary2');
-    });
-  });
-
-  describe('Action Execution', () => {
-    it('should execute action successfully', () => {
-      const mockOnClick = vi.fn();
-      const action = createTestAction({
-        label: 'Test Action',
-        testId: 'test-action',
-        onClick: mockOnClick,
-      });
-      actionManager.addAction(action);
-
-      const testRow = createTestData();
-      actionManager.executeAction('test-action', testRow);
-
-      expect(mockOnClick).toHaveBeenCalledWith(testRow);
-      expect(mockOnClick).toHaveBeenCalledTimes(1);
-    });
-
-    it('should throw error when executing non-existent action', () => {
-      const testRow = createTestData();
-
-      expect(() => {
-        actionManager.executeAction('non-existent', testRow);
-      }).toThrow('Action with ID "non-existent" not found');
-    });
-
-    it('should throw error when executing disabled action', () => {
-      const mockOnClick = vi.fn();
-      const action = createTestAction({
-        label: 'Disabled Action',
-        testId: 'disabled-action',
-        onClick: mockOnClick,
-        disabled: (row: TestDataRecord) => !row.isActive,
-      });
-      actionManager.addAction(action);
-
-      const inactiveRow = createTestData({ isActive: false });
-
-      expect(() => {
-        actionManager.executeAction('disabled-action', inactiveRow);
-      }).toThrow('Action "disabled-action" is disabled for this row');
-
-      expect(mockOnClick).not.toHaveBeenCalled();
-    });
-
-    it('should execute action when disabled function returns false', () => {
-      const mockOnClick = vi.fn();
-      const action = createTestAction({
-        label: 'Conditional Action',
-        testId: 'conditional-action',
-        onClick: mockOnClick,
-        disabled: (row: TestDataRecord) => !row.isActive,
-      });
-      actionManager.addAction(action);
-
-      const activeRow = createTestData({ isActive: true });
-      actionManager.executeAction('conditional-action', activeRow);
-
-      expect(mockOnClick).toHaveBeenCalledWith(activeRow);
-    });
-
-    it('should execute action when disabled is false', () => {
-      const mockOnClick = vi.fn();
-      const action = createTestAction({
-        label: 'Enabled Action',
-        testId: 'enabled-action',
-        onClick: mockOnClick,
-        disabled: false,
-      });
-      actionManager.addAction(action);
-
-      const testRow = createTestData();
-      actionManager.executeAction('enabled-action', testRow);
-
-      expect(mockOnClick).toHaveBeenCalledWith(testRow);
-    });
-  });
-
-  describe('Action State Checking', () => {
-    beforeEach(() => {
-      const actions = [
-        createTestAction({ 
-          label: 'Always Disabled', 
-          testId: 'always-disabled', 
-          disabled: true 
-        }),
-        createTestAction({ 
-          label: 'Always Enabled', 
-          testId: 'always-enabled', 
-          disabled: false 
-        }),
-        createTestAction({ 
-          label: 'Conditional', 
-          testId: 'conditional', 
-          disabled: (row: TestDataRecord) => !row.isActive 
-        }),
-      ];
-      actionManager.setActions(actions);
-    });
-
-    it('should check if action is disabled for specific row', () => {
-      const activeRow = createTestData({ isActive: true });
-      const inactiveRow = createTestData({ isActive: false });
-
-      expect(actionManager.isActionDisabled('always-disabled', activeRow)).toBe(true);
-      expect(actionManager.isActionDisabled('always-enabled', activeRow)).toBe(false);
-      expect(actionManager.isActionDisabled('conditional', activeRow)).toBe(false);
-      expect(actionManager.isActionDisabled('conditional', inactiveRow)).toBe(true);
-    });
-
-    it('should return true for non-existent action', () => {
-      const testRow = createTestData();
-      expect(actionManager.isActionDisabled('non-existent', testRow)).toBe(true);
-    });
-
-    it('should handle function-based disabled state', () => {
-      const testRow = createTestData({ isActive: true });
-      expect(actionManager.isActionDisabled('conditional', testRow)).toBe(false);
-
-      const inactiveRow = createTestData({ isActive: false });
-      expect(actionManager.isActionDisabled('conditional', inactiveRow)).toBe(true);
-    });
-  });
-
-  describe('Action Movement', () => {
-    beforeEach(() => {
-      const actions = createTestActions(5);
-      actionManager.setActions(actions);
-    });
-
-    it('should move action to new position', () => {
-      actionManager.moveAction('action-2', 0);
-
-      const actions = actionManager.getActions();
-      expect(actions[0].testId).toBe('action-2');
-      expect(actions[1].testId).toBe('action-1');
-      expect(actions[2].testId).toBe('action-3');
-    });
-
-    it('should move action to last position', () => {
-      actionManager.moveAction('action-1', 4);
-
-      const actions = actionManager.getActions();
-      expect(actions[4].testId).toBe('action-1');
-      expect(actions[0].testId).toBe('action-2');
-    });
-
-    it('should throw error when moving non-existent action', () => {
-      expect(() => {
-        actionManager.moveAction('non-existent', 0);
-      }).toThrow('Action with ID "non-existent" not found');
-    });
-
-    it('should throw error for invalid index', () => {
-      expect(() => {
-        actionManager.moveAction('action-1', -1);
-      }).toThrow('Invalid index: -1');
-
-      expect(() => {
-        actionManager.moveAction('action-1', 10);
-      }).toThrow('Invalid index: 10');
-    });
-
-    it('should handle moving to same position', () => {
-      const originalActions = actionManager.getActions();
-      actionManager.moveAction('action-3', 2);
-
-      const newActions = actionManager.getActions();
-      expect(newActions).toEqual(originalActions);
-    });
-  });
-
-  describe('Action ID Generation', () => {
-    it('should generate ID from testId when available', () => {
-      const action = createTestAction({ testId: 'custom-id', label: 'Test' });
-      const id = (actionManager as any).getActionId(action);
-      expect(id).toBe('custom-id');
-    });
-
-    it('should generate ID from label when testId not available', () => {
-      const action = createTestAction({ testId: undefined, label: 'Test Action' });
-      const id = (actionManager as any).getActionId(action);
-      expect(id).toBe('test-action');
-    });
-
-    it('should handle special characters in label', () => {
-      const action = createTestAction({ testId: undefined, label: 'Test Action with Spaces!' });
-      const id = (actionManager as any).getActionId(action);
-      expect(id).toBe('test-action-with-spaces!');
-    });
-
-    it('should generate random ID when neither testId nor label available', () => {
-      const action = createTestAction({ testId: undefined, label: '' });
-      const id = (actionManager as any).getActionId(action);
-      expect(id).toMatch(/^action-[a-z0-9]{9}$/);
-    });
-  });
-
-  describe('Performance and Memory', () => {
-    it('should handle large number of actions efficiently', () => {
-      const largeActionSet = createTestActions(1000);
-      actionManager.setActions(largeActionSet);
-
-      expect(actionManager.getActionCount()).toBe(1000);
-      expect(actionManager.hasAction('action-500')).toBe(true);
-      expect(actionManager.getAction('action-500')).toBeDefined();
-    });
-
-    it('should not leak memory with repeated operations', () => {
-      // Perform many add/remove operations
-      for (let i = 0; i < 100; i++) {
-        const action = createTestAction({ testId: `temp-action-${i}` });
-        actionManager.addAction(action);
-        actionManager.removeAction(`temp-action-${i}`);
-      }
-
-      expect(actionManager.getActionCount()).toBe(3); // Original actions
-      expect(actionManager.hasAction('temp-action-99')).toBe(false);
-    });
-
-    it('should handle concurrent operations', () => {
-      const actions = createTestActions(10);
-      
-      // Add multiple actions concurrently with unique testIds
-      actions.forEach((action, index) => {
-        actionManager.addAction({ ...action, testId: `concurrent-action-${index}` });
-      });
-
-      expect(actionManager.getActionCount()).toBe(13); // 3 original + 10 new
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle actions with undefined properties', () => {
-      const action = {
-        label: 'Test Action',
-        onClick: vi.fn(),
-      } as any;
-
-      actionManager.addAction(action);
-
-      expect(actionManager.getActionCount()).toBe(4);
-      expect(actionManager.hasAction('test-action')).toBe(true);
-    });
-
-    it('should handle empty string labels', () => {
-      const action = createTestAction({ label: '', testId: 'empty-label' });
-      actionManager.addAction(action);
-
-      expect(actionManager.hasAction('empty-label')).toBe(true);
-      expect(actionManager.getAction('empty-label')?.label).toBe('');
-    });
-
-    it('should handle actions with same label but different testId', () => {
-      const action1 = createTestAction({ label: 'Same Label', testId: 'same-label-1' });
-      const action2 = createTestAction({ label: 'Same Label', testId: 'same-label-2' });
-
-      actionManager.addAction(action1);
-      actionManager.addAction(action2);
-
-      expect(actionManager.getActionCount()).toBe(5); // 3 original + 2 new
-      expect(actionManager.hasAction('same-label-1')).toBe(true);
-      expect(actionManager.hasAction('same-label-2')).toBe(true);
-    });
-  });
-});