jira-pat 1.0.0

package/frontend/src/__tests__/hooks/useIssuesList.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useIssuesList } from '../../hooks/useIssuesList';
+import * as api from '../../services/api';
+
+vi.mock('../../services/api', () => ({
+  getIssues: vi.fn()
+}));
+
+describe('useIssuesList', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should initialize with empty issues, loading true, and null error', () => {
+    api.getIssues.mockImplementation(() => new Promise(() => {}));
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    expect(result.current.issues).toEqual([]);
+    expect(result.current.loading).toBe(true);
+    expect(result.current.error).toBe(null);
+  });
+
+  it('should fetch issues on mount', async () => {
+    const mockIssues = [
+      { key: 'TEST-1', fields: { summary: 'Issue 1' } },
+      { key: 'TEST-2', fields: { summary: 'Issue 2' } }
+    ];
+    api.getIssues.mockResolvedValue({ issues: mockIssues });
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+    
+    expect(result.current.issues).toEqual(mockIssues);
+    expect(api.getIssues).toHaveBeenCalledWith({
+      project: 'TEST',
+      status: 'exclude:Done,Cancelled,Closed'
+    });
+  });
+
+  it('should apply status filter when provided', async () => {
+    api.getIssues.mockResolvedValue({ issues: [] });
+    
+    renderHook(() => useIssuesList('TEST', 'In Progress'));
+    
+    await waitFor(() => {
+      expect(api.getIssues).toHaveBeenCalledWith({
+        project: 'TEST',
+        status: 'In Progress'
+      });
+    });
+  });
+
+  it('should handle API errors', async () => {
+    const errorMessage = 'Failed to fetch issues';
+    api.getIssues.mockRejectedValue(new Error(errorMessage));
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+    
+    expect(result.current.error).toBe(errorMessage);
+    expect(result.current.issues).toEqual([]);
+  });
+
+  it('should use fallback error message when error has no message', async () => {
+    api.getIssues.mockRejectedValue(new Error());
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+    
+    expect(result.current.error).toBe('Failed to fetch issues');
+  });
+
+  it('should refetch when projectKey changes', async () => {
+    api.getIssues.mockResolvedValue({ issues: [{ key: 'TEST-1' }] });
+    
+    const { rerender } = renderHook(
+      ({ project }) => useIssuesList(project, null),
+      { initialProps: { project: 'PROJ1' } }
+    );
+    
+    await waitFor(() => {
+      expect(api.getIssues).toHaveBeenCalled();
+    });
+
+    api.getIssues.mockClear();
+    api.getIssues.mockResolvedValue({ issues: [{ key: 'PROJ2-1' }] });
+    
+    rerender({ project: 'PROJ2' });
+    
+    await waitFor(() => {
+      expect(api.getIssues).toHaveBeenCalledWith({
+        project: 'PROJ2',
+        status: 'exclude:Done,Cancelled,Closed'
+      });
+    });
+  });
+
+  it('should refetch when statusFilter changes', async () => {
+    api.getIssues.mockResolvedValue({ issues: [] });
+    
+    const { rerender } = renderHook(
+      ({ project, status }) => useIssuesList(project, status),
+      { initialProps: { project: 'TEST', status: null } }
+    );
+    
+    await waitFor(() => {
+      expect(result => result.current.loading === false);
+    });
+
+    api.getIssues.mockClear();
+    
+    rerender({ project: 'TEST', status: 'In Review' });
+    
+    await waitFor(() => {
+      expect(api.getIssues).toHaveBeenCalledWith({
+        project: 'TEST',
+        status: 'In Review'
+      });
+    });
+  });
+
+  it('should provide refetch function', async () => {
+    api.getIssues
+      .mockResolvedValueOnce({ issues: [{ key: 'TEST-1' }] })
+      .mockResolvedValueOnce({ issues: [{ key: 'TEST-2' }] });
+    
+    const { result, rerender } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.issues[0].key).toBe('TEST-1');
+
+    await result.current.refetch();
+    rerender();
+    
+    expect(result.current.issues[0].key).toBe('TEST-2');
+  });
+
+  it('should handle empty issues response', async () => {
+    api.getIssues.mockResolvedValue({ issues: [] });
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+    
+    expect(result.current.issues).toEqual([]);
+  });
+
+  it('should handle undefined issues in response', async () => {
+    api.getIssues.mockResolvedValue({});
+    
+    const { result } = renderHook(() => useIssuesList('TEST', null));
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+    
+    expect(result.current.issues).toEqual([]);
+  });
+});

package/frontend/src/__tests__/hooks/useToasts.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useToasts } from '../../hooks/useToasts';
+
+describe('useToasts', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it('should initialize with empty toasts array', () => {
+    const { result } = renderHook(() => useToasts());
+    expect(result.current.toasts).toEqual([]);
+  });
+
+  it('should add a toast with default type info', () => {
+    const { result } = renderHook(() => useToasts());
+    
+    act(() => {
+      result.current.addToast('Test message');
+    });
+
+    expect(result.current.toasts).toHaveLength(1);
+    expect(result.current.toasts[0]).toMatchObject({
+      message: 'Test message',
+      type: 'info'
+    });
+  });
+
+  it('should add a toast with custom type', () => {
+    const { result } = renderHook(() => useToasts());
+    
+    act(() => {
+      result.current.addToast('Success message', 'success');
+    });
+
+    expect(result.current.toasts[0]).toMatchObject({
+      message: 'Success message',
+      type: 'success'
+    });
+  });
+
+  it('should add multiple toasts', () => {
+    const { result } = renderHook(() => useToasts());
+    
+    act(() => {
+      result.current.addToast('First message', 'info');
+      result.current.addToast('Second message', 'error');
+      result.current.addToast('Third message', 'success');
+    });
+
+    expect(result.current.toasts).toHaveLength(3);
+  });
+
+  it('should auto-remove toast after 4000ms', async () => {
+    vi.useRealTimers();
+    const { result } = renderHook(() => useToasts());
+    
+    act(() => {
+      result.current.addToast('Auto-remove toast');
+    });
+
+    expect(result.current.toasts).toHaveLength(1);
+
+    await act(async () => {
+      await new Promise(resolve => setTimeout(resolve, 4001));
+    });
+
+    expect(result.current.toasts).toHaveLength(0);
+  });
+
+  it('should manually remove a toast', async () => {
+    vi.useRealTimers();
+    const { result } = renderHook(() => useToasts());
+    
+    act(() => {
+      result.current.addToast('Test toast');
+    });
+
+    expect(result.current.toasts).toHaveLength(1);
+    
+    const toastId = result.current.toasts[0].id;
+    
+    act(() => {
+      result.current.removeToast(toastId);
+    });
+
+    expect(result.current.toasts).toHaveLength(0);
+  });
+
+  it('should handle all toast types', () => {
+    const types = ['info', 'success', 'warning', 'error'];
+    const { result } = renderHook(() => useToasts());
+
+    types.forEach((type, index) => {
+      act(() => {
+        result.current.addToast(`Message ${index}`, type);
+      });
+    });
+
+    expect(result.current.toasts).toHaveLength(4);
+    types.forEach((type, index) => {
+      expect(result.current.toasts[index].type).toBe(type);
+    });
+  });
+});