@jmruthers/pace-core 0.5.68 → 0.5.70

package/src/__tests__/helpers/__tests__/test-utils.test.tsx

@@ -0,0 +1,436 @@
+/**
+ * @file Test Utilities Tests
+ * @package @jmruthers/pace-core
+ * @module TestHelpers/__tests__
+ * @since 1.0.0
+ */
+
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { QueryClient } from '@tanstack/react-query';
+import {
+  renderWithProviders,
+  mockData,
+  testDataGenerators,
+  createMockSupabaseClient,
+  TestWrapper,
+  testHelpers,
+  setupTest,
+  createComponentTestStructure,
+  createHookTestStructure
+} from '../test-utils';
+
+// Mock the fixtures
+vi.mock('../fixtures/test-data', () => ({
+  TEST_FIXTURES: {
+    users: {
+      basic: {
+        id: 'test-user-id',
+        email: 'test@example.com',
+        name: 'Test User'
+      }
+    },
+    mockFunctions: {
+      onClick: vi.fn(),
+      onSubmit: vi.fn()
+    }
+  },
+  createFixture: vi.fn((base, overrides) => ({ ...base, ...overrides }))
+}));
+
+describe('[helpers] renderWithProviders', () => {
+    it('renders component with QueryClient provider by default', () => {
+    const TestComponent = () => <div data-testid="test-component">Test</div>;
+    
+    renderWithProviders(<TestComponent />);
+    
+    expect(screen.getByTestId('test-component')).toBeInTheDocument();
+  });
+
+  it('renders component without QueryClient when withQueryClient is false', () => {
+    const TestComponent = () => <div data-testid="test-component">Test</div>;
+    
+    renderWithProviders(<TestComponent />, { withQueryClient: false });
+    
+    expect(screen.getByTestId('test-component')).toBeInTheDocument();
+  });
+
+  it('uses custom QueryClient when provided', () => {
+    const customQueryClient = new QueryClient();
+    const TestComponent = () => <div data-testid="test-component">Test</div>;
+    
+    renderWithProviders(<TestComponent />, { queryClient: customQueryClient });
+    
+    expect(screen.getByTestId('test-component')).toBeInTheDocument();
+  });
+
+  it('forwards additional render options', () => {
+    const TestComponent = () => <div data-testid="test-component">Test</div>;
+    
+    const { container } = renderWithProviders(<TestComponent />, {
+      container: document.body
+    });
+    
+    expect(container).toBe(document.body);
+  });
+});
+
+describe('[helpers] mockData', () => {
+    it('generates user data with defaults', () => {
+    const user = mockData.user();
+    
+    expect(user).toHaveProperty('id');
+    expect(user).toHaveProperty('email');
+    expect(user).toHaveProperty('name');
+  });
+
+  it('generates user data with overrides', () => {
+    const user = mockData.user({ name: 'Custom User' });
+    
+    expect(user.name).toBe('Custom User');
+  });
+
+  it('generates button data with defaults', () => {
+    const button = mockData.button();
+    
+    expect(button).toHaveProperty('children', 'Click me');
+    expect(button).toHaveProperty('onClick');
+  });
+
+  it('generates button data with overrides', () => {
+    const button = mockData.button({ children: 'Custom Button' });
+    
+    expect(button.children).toBe('Custom Button');
+  });
+
+  it('generates form data with defaults', () => {
+    const form = mockData.form();
+    
+    expect(form).toHaveProperty('onSubmit');
+  });
+
+  it('generates form data with overrides', () => {
+    const customOnSubmit = vi.fn();
+    const form = mockData.form({ onSubmit: customOnSubmit });
+    
+    expect(form.onSubmit).toBe(customOnSubmit);
+  });
+});
+
+describe('[helpers] testDataGenerators', () => {
+    describe('user generator', () => {
+    it('generates single user with defaults', () => {
+      const user = testDataGenerators.user();
+      
+      expect(user).toHaveProperty('id', 'test-user-id');
+      expect(user).toHaveProperty('email', 'test@example.com');
+      expect(user).toHaveProperty('name', 'Test User');
+      expect(user).toHaveProperty('created_at');
+    });
+
+    it('generates single user with overrides', () => {
+      const user = testDataGenerators.user({ name: 'Custom User' });
+      
+      expect(user.name).toBe('Custom User');
+      expect(user.id).toBe('test-user-id');
+    });
+  });
+
+  describe('createUser generator', () => {
+    it('generates single user when count is 1', () => {
+      const user = testDataGenerators.createUser(1);
+      
+      expect(user).toHaveProperty('id', 'test-user-id');
+      expect(user).toHaveProperty('email', 'test@example.com');
+      expect(user).toHaveProperty('name', 'Test User');
+    });
+
+    it('generates multiple users when count > 1', () => {
+      const users = testDataGenerators.createUser(3);
+      
+      expect(users).toHaveLength(3);
+      expect(users[0].id).toBe('test-user-1');
+      expect(users[1].id).toBe('test-user-2');
+      expect(users[2].id).toBe('test-user-3');
+    });
+
+    it('generates users with overrides', () => {
+      const users = testDataGenerators.createUser(2, { name: 'Custom User' });
+      
+      expect(users).toHaveLength(2);
+      expect(users[0].name).toBe('Custom User');
+      expect(users[1].name).toBe('Custom User');
+    });
+  });
+
+  describe('createUsers generator', () => {
+    it('generates multiple users', () => {
+      const users = testDataGenerators.createUsers(3);
+      
+      expect(users).toHaveLength(3);
+      expect(users[0].id).toBe('test-user-1');
+      expect(users[1].id).toBe('test-user-2');
+      expect(users[2].id).toBe('test-user-3');
+    });
+  });
+
+  describe('organisation generator', () => {
+    it('generates organisation with defaults', () => {
+      const org = testDataGenerators.organisation();
+      
+      expect(org).toHaveProperty('id', 'test-org-id');
+      expect(org).toHaveProperty('name', 'Test Organisation');
+      expect(org).toHaveProperty('created_at');
+    });
+
+    it('generates organisation with overrides', () => {
+      const org = testDataGenerators.organisation({ name: 'Custom Org' });
+      
+      expect(org.name).toBe('Custom Org');
+    });
+  });
+
+  describe('event generator', () => {
+    it('generates event with defaults', () => {
+      const event = testDataGenerators.event();
+      
+      expect(event).toHaveProperty('id', 'test-event-id');
+      expect(event).toHaveProperty('name', 'Test Event');
+      expect(event).toHaveProperty('organisation_id', 'test-org-id');
+      expect(event).toHaveProperty('created_at');
+    });
+
+    it('generates event with overrides', () => {
+      const event = testDataGenerators.event({ name: 'Custom Event' });
+      
+      expect(event.name).toBe('Custom Event');
+    });
+  });
+
+  describe('permission generator', () => {
+    it('generates permission with defaults', () => {
+      const permission = testDataGenerators.permission();
+      
+      expect(permission).toHaveProperty('id', 'test-permission-id');
+      expect(permission).toHaveProperty('name', 'test:permission');
+      expect(permission).toHaveProperty('resource', 'test-resource');
+      expect(permission).toHaveProperty('operation', 'read');
+    });
+
+    it('generates permission with overrides', () => {
+      const permission = testDataGenerators.permission({ operation: 'write' });
+      
+      expect(permission.operation).toBe('write');
+    });
+  });
+
+  describe('session generator', () => {
+    it('generates session with defaults', () => {
+      const session = testDataGenerators.session();
+      
+      expect(session).toHaveProperty('access_token', 'test-access-token');
+      expect(session).toHaveProperty('refresh_token', 'test-refresh-token');
+      expect(session).toHaveProperty('expires_in', 3600);
+      expect(session).toHaveProperty('token_type', 'bearer');
+      expect(session).toHaveProperty('user');
+    });
+
+    it('generates session with overrides', () => {
+      const session = testDataGenerators.session({ expires_in: 7200 });
+      
+      expect(session.expires_in).toBe(7200);
+    });
+  });
+
+  describe('createSession generator', () => {
+    it('generates single session when count is 1', () => {
+      const session = testDataGenerators.createSession(1);
+      
+      expect(session).toHaveProperty('access_token', 'test-access-token');
+      expect(session).toHaveProperty('user');
+    });
+
+    it('generates multiple sessions when count > 1', () => {
+      const sessions = testDataGenerators.createSession(3);
+      
+      expect(sessions).toHaveLength(3);
+      expect(sessions[0].access_token).toBe('test-access-token-1');
+      expect(sessions[1].access_token).toBe('test-access-token-2');
+      expect(sessions[2].access_token).toBe('test-access-token-3');
+    });
+  });
+});
+
+describe('[helpers] createMockSupabaseClient', () => {
+    it('creates mock Supabase client with default methods', () => {
+    const mockClient = createMockSupabaseClient();
+    
+    expect(mockClient).toHaveProperty('from');
+    expect(mockClient).toHaveProperty('rpc');
+    expect(mockClient).toHaveProperty('auth');
+  });
+
+  it('creates mock query builder with chaining methods', () => {
+    const mockClient = createMockSupabaseClient();
+    const queryBuilder = mockClient.from('test_table');
+    
+    expect(queryBuilder).toHaveProperty('select');
+    expect(queryBuilder).toHaveProperty('insert');
+    expect(queryBuilder).toHaveProperty('update');
+    expect(queryBuilder).toHaveProperty('delete');
+    expect(queryBuilder).toHaveProperty('eq');
+    expect(queryBuilder).toHaveProperty('order');
+  });
+
+  it('creates mock auth methods', () => {
+    const mockClient = createMockSupabaseClient();
+    
+    expect(mockClient.auth).toHaveProperty('getUser');
+    expect(mockClient.auth).toHaveProperty('getSession');
+    expect(mockClient.auth).toHaveProperty('signIn');
+    expect(mockClient.auth).toHaveProperty('signOut');
+  });
+
+  it('creates mock RPC method', () => {
+    const mockClient = createMockSupabaseClient();
+    
+    expect(mockClient.rpc).toBeDefined();
+    expect(typeof mockClient.rpc).toBe('function');
+  });
+});
+
+describe('[helpers] TestWrapper', () => {
+    it('renders children with QueryClient provider', () => {
+    const TestComponent = () => <div data-testid="test-component">Test</div>;
+    
+    render(
+      <TestWrapper>
+        <TestComponent />
+      </TestWrapper>
+    );
+    
+    expect(screen.getByTestId('test-component')).toBeInTheDocument();
+  });
+});
+
+describe('[helpers] testHelpers', () => {
+    describe('waitFor', () => {
+    it('resolves when callback succeeds', async () => {
+      let called = false;
+      const callback = () => {
+        called = true;
+      };
+      
+      await testHelpers.waitFor(callback);
+      
+      expect(called).toBe(true);
+    });
+
+    it('rejects when callback fails and timeout is reached', async () => {
+      const callback = () => {
+        throw new Error('Test error');
+      };
+      
+      await expect(testHelpers.waitFor(callback, 100)).rejects.toThrow('Test error');
+    });
+
+    it('retries callback until it succeeds', async () => {
+      let attempts = 0;
+      const callback = () => {
+        attempts++;
+        if (attempts < 3) {
+          throw new Error('Not ready yet');
+        }
+      };
+      
+      await testHelpers.waitFor(callback, 1000);
+      
+      expect(attempts).toBe(3);
+    });
+  });
+
+  describe('createMockFn', () => {
+    it('creates mock function with implementation', () => {
+      const implementation = (x: number) => x * 2;
+      const mockFn = testHelpers.createMockFn(implementation);
+      
+      expect(mockFn(5)).toBe(10);
+    });
+
+    it('creates mock function without implementation', () => {
+      const mockFn = testHelpers.createMockFn();
+      
+      expect(mockFn).toBeDefined();
+      expect(typeof mockFn).toBe('function');
+    });
+  });
+
+  describe('createTestProps', () => {
+    it('creates props factory with defaults', () => {
+      const defaults = { name: 'Test', age: 25 };
+      const createProps = testHelpers.createTestProps(defaults);
+      
+      const props = createProps();
+      expect(props).toEqual(defaults);
+    });
+
+    it('creates props factory with overrides', () => {
+      const defaults = { name: 'Test', age: 25 };
+      const createProps = testHelpers.createTestProps(defaults);
+      
+      const props = createProps({ age: 30 });
+      expect(props).toEqual({ name: 'Test', age: 30 });
+    });
+  });
+});
+
+describe('[helpers] setupTest', () => {
+    it('sets up test environment', () => {
+    const mockClearAllMocks = vi.spyOn(vi, 'clearAllMocks');
+    const mockRestoreAllMocks = vi.spyOn(vi, 'restoreAllMocks');
+    
+    setupTest();
+    
+    // The setupTest function should be callable
+    expect(typeof setupTest).toBe('function');
+  });
+});
+
+describe('[helpers] createComponentTestStructure', () => {
+    it('creates component test structure', () => {
+    const structure = createComponentTestStructure('TestComponent');
+    
+    expect(structure).toHaveProperty('describe');
+    expect(typeof structure.describe).toBe('function');
+  });
+
+  it('executes test function within describe block', () => {
+    const testFn = vi.fn();
+    const structure = createComponentTestStructure('TestComponent');
+    
+    structure.describe(testFn);
+    
+    // The test function should be callable
+    expect(typeof testFn).toBe('function');
+  });
+});
+
+describe('[helpers] createHookTestStructure', () => {
+    it('creates hook test structure', () => {
+    const structure = createHookTestStructure('useTestHook');
+    
+    expect(structure).toHaveProperty('describe');
+    expect(typeof structure.describe).toBe('function');
+  });
+
+  it('executes test function within describe block', () => {
+    const testFn = vi.fn();
+    const structure = createHookTestStructure('useTestHook');
+    
+    structure.describe(testFn);
+    
+    // The test function should be callable
+    expect(typeof testFn).toBe('function');
+  });
+});