jira-pat 1.0.0

package/frontend/src/__tests__/services/api.test.js

@@ -0,0 +1,568 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import axios from 'axios';
+import { 
+  withRetry, 
+  getIssues, 
+  fetchIssueDetail, 
+  fetchComments, 
+  postComment,
+  fetchTransitions,
+  transitionIssue,
+  fetchAssignableUsers,
+  assignIssue,
+  uploadAttachment,
+  fetchProjects,
+  fetchIssueTypes,
+  createIssue,
+  fetchProjectVersions,
+  updateIssue,
+  searchLabels
+} from '../../services/api';
+
+vi.mock('axios');
+
+describe('API Service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(axios, 'isCancel').mockImplementation(() => false);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('withRetry', () => {
+    it('should return result on first success', async () => {
+      const fn = vi.fn().mockResolvedValue('success');
+      const result = await withRetry(fn);
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry on failure and succeed', async () => {
+      const fn = vi.fn()
+        .mockRejectedValueOnce(new Error('Temporary error'))
+        .mockResolvedValueOnce('success');
+      
+      const result = await withRetry(fn, 3, 10);
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should retry multiple times before success', async () => {
+      const fn = vi.fn()
+        .mockRejectedValueOnce(new Error('Error 1'))
+        .mockRejectedValueOnce(new Error('Error 2'))
+        .mockResolvedValueOnce('success');
+      
+      const result = await withRetry(fn, 3, 10);
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+
+    it('should not retry on client errors (4xx)', async () => {
+      const error = new Error('Bad Request');
+      error.response = { status: 400 };
+      const fn = vi.fn().mockRejectedValue(error);
+      
+      await expect(withRetry(fn, 3, 10)).rejects.toThrow('Bad Request');
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw after max attempts', async () => {
+      const fn = vi.fn().mockRejectedValue(new Error('Server error'));
+      fn.mockImplementation(() => Promise.reject(new Error('Server error')));
+      
+      await expect(withRetry(fn, 3, 10)).rejects.toThrow('Server error');
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+
+    it('should respect custom maxAttempts', async () => {
+      const fn = vi.fn().mockRejectedValue(new Error('Error'));
+      
+      await expect(withRetry(fn, 5, 10)).rejects.toThrow('Error');
+      expect(fn).toHaveBeenCalledTimes(5);
+    });
+
+    it('should throw lastError when all retries fail with 5xx errors', async () => {
+      const error = new Error('Server error 500');
+      error.response = { status: 500 };
+      const fn = vi.fn()
+        .mockRejectedValueOnce(error)
+        .mockRejectedValueOnce(error)
+        .mockRejectedValueOnce(error);
+      
+      await expect(withRetry(fn, 3, 10)).rejects.toThrow('Server error 500');
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+
+    it('should throw lastError after exhausting all attempts', async () => {
+      const fn = vi.fn()
+        .mockRejectedValueOnce(new Error('Error 1'))
+        .mockRejectedValueOnce(new Error('Error 2'))
+        .mockRejectedValueOnce(new Error('Error 3'));
+      
+      await expect(withRetry(fn, 3, 10)).rejects.toThrow('Error 3');
+    });
+  });
+
+  describe('getIssues', () => {
+    it('should fetch issues with params', async () => {
+      const mockData = { issues: [{ key: 'TEST-1' }] };
+      axios.mockResolvedValue({ data: mockData });
+      
+      const result = await getIssues({ project: 'TEST', status: 'Open' });
+      
+      expect(axios).toHaveBeenCalled();
+      expect(result).toEqual(mockData);
+    });
+
+    it('should filter out empty params', async () => {
+      axios.mockResolvedValue({ data: { issues: [] } });
+      
+      await getIssues({ project: 'TEST', status: undefined, empty: '' });
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.params).toEqual({ project: 'TEST' });
+    });
+
+    it('should handle empty response', async () => {
+      axios.mockResolvedValue({ data: {} });
+      
+      const result = await getIssues({ project: 'TEST' });
+      
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('fetchIssueDetail', () => {
+    it('should fetch issue by key', async () => {
+      const mockData = { key: 'TEST-123', fields: { summary: 'Test' } };
+      axios.mockResolvedValue({ data: mockData });
+      
+      const result = await fetchIssueDetail('TEST-123');
+      
+      expect(axios).toHaveBeenCalled();
+      expect(result).toEqual(mockData);
+    });
+
+    it('should include retry logic', async () => {
+      const mockData = { key: 'TEST-123' };
+      axios
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({ data: mockData });
+      
+      const result = await fetchIssueDetail('TEST-123');
+      
+      expect(result).toEqual(mockData);
+      expect(axios).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('fetchComments', () => {
+    it('should fetch comments for issue', async () => {
+      const mockComments = [{ id: 1, body: 'Comment' }];
+      axios.mockResolvedValue({ data: mockComments });
+      
+      const result = await fetchComments('TEST-123');
+      
+      expect(result).toEqual(mockComments);
+    });
+  });
+
+  describe('postComment', () => {
+    it('should post comment without retry (no withRetry)', async () => {
+      const mockComment = { id: 1, body: 'New comment' };
+      axios.mockResolvedValue({ data: mockComment });
+      
+      const result = await postComment('TEST-123', 'New comment');
+      
+      expect(result).toEqual(mockComment);
+    });
+
+    it('should include comment body in request', async () => {
+      axios.mockResolvedValue({ data: {} });
+      
+      await postComment('TEST-123', 'Test body');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual({ body: 'Test body' });
+    });
+  });
+
+  describe('fetchTransitions', () => {
+    it('should fetch transitions with retry', async () => {
+      const mockTransitions = [{ id: '1', name: 'To Do' }];
+      axios
+        .mockRejectedValueOnce(new Error('Retry'))
+        .mockResolvedValueOnce({ data: mockTransitions });
+      
+      const result = await fetchTransitions('TEST-123');
+      
+      expect(result).toEqual(mockTransitions);
+    });
+  });
+
+  describe('transitionIssue', () => {
+    it('should transition issue without retry', async () => {
+      axios.mockResolvedValue({ data: { success: true } });
+      
+      const result = await transitionIssue('TEST-123', '2');
+      
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should send transitionId in request body', async () => {
+      axios.mockResolvedValue({ data: {} });
+      
+      await transitionIssue('TEST-123', 'transition-5');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual({ transitionId: 'transition-5' });
+    });
+  });
+
+  describe('fetchAssignableUsers', () => {
+    it('should fetch assignable users with query', async () => {
+      const mockUsers = [{ accountId: '1', displayName: 'User' }];
+      axios.mockResolvedValue({ data: mockUsers });
+      
+      const result = await fetchAssignableUsers('TEST-123', 'john');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.params).toEqual({ query: 'john' });
+      expect(result).toEqual(mockUsers);
+    });
+
+    it('should fetch all users when no query provided', async () => {
+      axios.mockResolvedValue({ data: [] });
+      
+      await fetchAssignableUsers('TEST-123');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.params).toEqual({ query: undefined });
+    });
+  });
+
+  describe('assignIssue', () => {
+    it('should assign issue without retry', async () => {
+      axios.mockResolvedValue({ data: { success: true } });
+      
+      const result = await assignIssue('TEST-123', 'user-456');
+      
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should send accountId in request body', async () => {
+      axios.mockResolvedValue({ data: {} });
+      
+      await assignIssue('TEST-123', 'user-789');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual({ accountId: 'user-789' });
+    });
+  });
+
+  describe('uploadAttachment', () => {
+    it('should upload file with FormData', async () => {
+      axios.post = vi.fn().mockResolvedValue({ data: { success: true } });
+      const file = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      
+      const result = await uploadAttachment('TEST-123', file);
+      
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should throw timeout error for aborted requests', async () => {
+      const error = new Error('timeout');
+      error.name = 'AbortError';
+      axios.post = vi.fn().mockRejectedValue(error);
+      const file = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      
+      await expect(uploadAttachment('TEST-123', file)).rejects.toThrow(
+        'Request timed out. Please check your connection.'
+      );
+    });
+
+    it('should set correct content-type header', async () => {
+      axios.post = vi.fn().mockResolvedValue({ data: {} });
+      const file = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      
+      await uploadAttachment('TEST-123', file);
+      
+      const call = axios.post.mock.calls[0];
+      expect(call[2]?.headers?.['Content-Type']).toBe('multipart/form-data');
+    });
+
+    it('should rethrow non-timeout errors', async () => {
+      const error = new Error('Server error');
+      axios.post = vi.fn().mockRejectedValue(error);
+      const file = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      
+      await expect(uploadAttachment('TEST-123', file)).rejects.toThrow('Server error');
+    });
+
+    it('should handle ERR_CANCELED error code for non-timeout cancellations', async () => {
+      const error = new Error('Network error');
+      error.code = 'ERR_CANCELED';
+      axios.post = vi.fn().mockRejectedValue(error);
+      const file = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      
+      await expect(uploadAttachment('TEST-123', file)).rejects.toThrow(
+        'Request timed out. Please check your connection.'
+      );
+    });
+  });
+
+  describe('fetchProjectVersions', () => {
+    it('should fetch project versions', async () => {
+      const mockVersions = [{ id: '1', name: 'v1.0' }];
+      axios.mockResolvedValue({ data: mockVersions });
+      
+      const result = await fetchProjectVersions('TEST');
+      
+      expect(result).toEqual(mockVersions);
+    });
+  });
+
+  describe('fetchProjects', () => {
+    it('should fetch all projects', async () => {
+      const mockProjects = [
+        { id: '1', key: 'PROJ', name: 'Project 1' },
+        { id: '2', key: 'TEST', name: 'Test Project' }
+      ];
+      axios.mockResolvedValue({ data: mockProjects });
+      
+      const result = await fetchProjects();
+      
+      expect(result).toEqual(mockProjects);
+    });
+
+    it('should include retry logic', async () => {
+      const mockProjects = [{ id: '1', key: 'PROJ', name: 'Project' }];
+      axios
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({ data: mockProjects });
+      
+      const result = await fetchProjects();
+      
+      expect(result).toEqual(mockProjects);
+      expect(axios).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle empty projects list', async () => {
+      axios.mockResolvedValue({ data: [] });
+      
+      const result = await fetchProjects();
+      
+      expect(result).toEqual([]);
+    });
+
+    it('should handle server error with retry', async () => {
+      const error = new Error('Internal Server Error');
+      error.response = { status: 500 };
+      axios
+        .mockRejectedValueOnce(error)
+        .mockRejectedValueOnce(error)
+        .mockResolvedValueOnce({ data: [{ key: 'PROJ' }] });
+      
+      const result = await fetchProjects();
+      
+      expect(result).toEqual([{ key: 'PROJ' }]);
+    });
+  });
+
+  describe('fetchIssueTypes', () => {
+    it('should fetch issue types for project', async () => {
+      const mockIssueTypes = [
+        { id: '1', name: 'Bug' },
+        { id: '2', name: 'Story' }
+      ];
+      axios.mockResolvedValue({ data: mockIssueTypes });
+      
+      const result = await fetchIssueTypes('TEST');
+      
+      expect(result).toEqual(mockIssueTypes);
+    });
+
+    it('should include project key in URL', async () => {
+      axios.mockResolvedValue({ data: [] });
+      
+      await fetchIssueTypes('MYPROJ');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.url).toContain('/projects/MYPROJ/issuetypes');
+    });
+
+    it('should include retry logic', async () => {
+      const mockIssueTypes = [{ id: '1', name: 'Task' }];
+      axios
+        .mockRejectedValueOnce(new Error('Timeout'))
+        .mockResolvedValueOnce({ data: mockIssueTypes });
+      
+      const result = await fetchIssueTypes('TEST');
+      
+      expect(result).toEqual(mockIssueTypes);
+    });
+
+    it('should throw on client error without retry', async () => {
+      const error = new Error('Not Found');
+      error.response = { status: 404 };
+      axios.mockRejectedValue(error);
+      
+      await expect(fetchIssueTypes('INVALID')).rejects.toThrow('Not Found');
+      expect(axios).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle null response data', async () => {
+      axios.mockResolvedValue({ data: null });
+      
+      const result = await fetchIssueTypes('TEST');
+      
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('createIssue', () => {
+    it('should create issue with provided data', async () => {
+      const issueData = {
+        project: { key: 'TEST' },
+        summary: 'New Issue',
+        issuetype: { name: 'Task' }
+      };
+      const mockResponse = { id: '12345', key: 'TEST-100', ...issueData };
+      axios.mockResolvedValue({ data: mockResponse });
+      
+      const result = await createIssue(issueData);
+      
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should send issue data in request body', async () => {
+      const issueData = {
+        project: { key: 'PROJ' },
+        summary: 'Test Summary',
+        description: 'Test Description',
+        issuetype: { name: 'Bug' }
+      };
+      axios.mockResolvedValue({ data: {} });
+      
+      await createIssue(issueData);
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual(issueData);
+    });
+
+    it('should handle validation error response', async () => {
+      const error = new Error('Validation Failed');
+      error.response = { status: 400, data: { errorMessages: ['Summary is required'] } };
+      axios.mockRejectedValue(error);
+      
+      await expect(createIssue({})).rejects.toThrow('Validation Failed');
+    });
+
+    it('should handle empty issue data', async () => {
+      axios.mockResolvedValue({ data: { id: '1' } });
+      
+      const result = await createIssue({});
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual({});
+      expect(result).toEqual({ id: '1' });
+    });
+
+    it('should handle unauthorized error', async () => {
+      const error = new Error('Unauthorized');
+      error.response = { status: 401 };
+      axios.mockRejectedValue(error);
+      
+      await expect(createIssue({ project: { key: 'TEST' } })).rejects.toThrow('Unauthorized');
+    });
+
+    it('should handle server error', async () => {
+      const error = new Error('Internal Server Error');
+      error.response = { status: 500 };
+      axios.mockRejectedValue(error);
+      
+      await expect(createIssue({ project: { key: 'TEST' } })).rejects.toThrow('Internal Server Error');
+    });
+  });
+
+  describe('updateIssue', () => {
+    it('should update issue fields', async () => {
+      axios.mockResolvedValue({ data: { success: true } });
+      
+      const result = await updateIssue('TEST-123', { summary: 'New summary' });
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data).toEqual({ fields: { summary: 'New summary' } });
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should send multiple fields', async () => {
+      axios.mockResolvedValue({ data: {} });
+      
+      await updateIssue('TEST-123', { 
+        summary: 'Summary', 
+        description: 'Description',
+        labels: ['bug']
+      });
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.data.fields).toEqual({
+        summary: 'Summary',
+        description: 'Description',
+        labels: ['bug']
+      });
+    });
+  });
+
+  describe('searchLabels', () => {
+    it('should search labels with query', async () => {
+      const mockLabels = ['bug', 'feature', 'urgent'];
+      axios.mockResolvedValue({ data: mockLabels });
+      
+      const result = await searchLabels('bu');
+      
+      const call = axios.mock.calls[0][0];
+      expect(call.params).toEqual({ query: 'bu' });
+      expect(result).toEqual(mockLabels);
+    });
+
+    it('should include retry logic', async () => {
+      const mockLabels = ['test'];
+      axios
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({ data: mockLabels });
+      
+      const result = await searchLabels('test');
+      
+      expect(result).toEqual(mockLabels);
+    });
+  });
+
+  describe('timeout handling', () => {
+    it('should handle timeout error for regular requests', async () => {
+      const error = new Error('Request timeout');
+      error.name = 'AbortError';
+      axios.mockRejectedValue(error);
+      
+      await expect(getIssues({ project: 'TEST' })).rejects.toThrow(
+        'Request timed out. Please check your connection.'
+      );
+    });
+
+    it('should handle ERR_CANCELED error code', async () => {
+      const error = new Error('Canceled');
+      error.code = 'ERR_CANCELED';
+      axios.mockRejectedValue(error);
+      
+      await expect(fetchIssueDetail('TEST-123')).rejects.toThrow(
+        'Request timed out. Please check your connection.'
+      );
+    });
+  });
+});

package/frontend/src/__tests__/setup.js

@@ -0,0 +1,54 @@
+import '@testing-library/jest-dom';
+import { vi } from 'vitest';
+import React from 'react';
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation(query => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});
+
+vi.mock('lucide-react', () => {
+  const createIconMock = (testId) => {
+    return (props) => React.createElement('div', { 
+      'data-testid': testId,
+      className: props?.className,
+      ...props 
+    });
+  };
+  
+  const icons = {
+    Inbox: createIconMock('inbox-icon'),
+    Bug: createIconMock('bug-icon'),
+    FileText: createIconMock('filetext-icon'),
+    Layers: createIconMock('layers-icon'),
+    ClipboardList: createIconMock('clipboard-icon'),
+    ChevronUp: createIconMock('chevron-up-icon'),
+    ChevronDown: createIconMock('chevron-down-icon'),
+    Minus: createIconMock('minus-icon'),
+    AlertCircle: createIconMock('alert-icon'),
+    Info: createIconMock('info-icon'),
+    X: () => React.createElement('button', { 'aria-label': 'Close' }),
+    Link2: createIconMock('link-icon'),
+    ExternalLink: createIconMock('external-link-icon'),
+    CheckCircle: createIconMock('check-icon'),
+    Loader2: createIconMock('loader-icon'),
+    Paperclip: createIconMock('paperclip-icon'),
+    Calendar: createIconMock('calendar-icon'),
+    Package: createIconMock('package-icon'),
+    PlusCircle: createIconMock('plus-icon'),
+  };
+  
+  return {
+    ...icons,
+    default: ({ children, ...props }) => React.createElement('div', props, children),
+  };
+});