jira-pat 1.0.0

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

@@ -0,0 +1,1053 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useIssueDrawer } from '../../hooks/useIssueDrawer';
+import * as api from '../../services/api';
+
+vi.mock('../../services/api', () => ({
+  fetchIssueDetail: vi.fn(),
+  fetchComments: vi.fn(),
+  fetchTransitions: vi.fn(),
+  fetchAssignableUsers: vi.fn(),
+  postComment: vi.fn(),
+  transitionIssue: vi.fn(),
+  assignIssue: vi.fn(),
+  uploadAttachment: vi.fn(),
+  fetchProjectVersions: vi.fn(),
+  updateIssue: vi.fn(),
+  searchLabels: vi.fn()
+}));
+
+const mockIssueDetail = {
+  key: 'TEST-123',
+  fields: {
+    summary: 'Test Issue',
+    status: { name: 'To Do' },
+    project: { key: 'TEST' },
+    labels: ['bug', 'urgent'],
+    assignee: null
+  }
+};
+
+const mockComments = [
+  { id: 1, body: 'Comment 1' },
+  { id: 2, body: 'Comment 2' }
+];
+
+const mockTransitions = [
+  { id: '1', name: 'To Do' },
+  { id: '2', name: 'In Progress' }
+];
+
+const mockUsers = [
+  { accountId: 'user1', displayName: 'User One' },
+  { accountId: 'user2', displayName: 'User Two' }
+];
+
+describe('useIssueDrawer', () => {
+  const mockAddToast = vi.fn();
+  const mockRefetch = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+    api.fetchComments.mockResolvedValue(mockComments);
+    api.fetchTransitions.mockResolvedValue(mockTransitions);
+    api.fetchAssignableUsers.mockResolvedValue(mockUsers);
+    api.fetchProjectVersions.mockResolvedValue([]);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should initialize with null issueDetail and empty arrays', () => {
+    const { result } = renderHook(() => useIssueDrawer(null, mockAddToast, mockRefetch));
+    
+    expect(result.current.issueDetail).toBe(null);
+    expect(result.current.comments).toEqual([]);
+    expect(result.current.transitions).toEqual([]);
+    expect(result.current.assignableUsers).toEqual([]);
+    expect(result.current.drawerLoading).toBe(false);
+    expect(result.current.drawerError).toBe(null);
+  });
+
+  it('should not fetch data when issueKey is null', () => {
+    renderHook(() => useIssueDrawer(null, mockAddToast, mockRefetch));
+    
+    expect(api.fetchIssueDetail).not.toHaveBeenCalled();
+  });
+
+  it('should fetch issue data when issueKey is provided', async () => {
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+    
+    expect(api.fetchIssueDetail).toHaveBeenCalledWith('TEST-123');
+    expect(api.fetchComments).toHaveBeenCalledWith('TEST-123');
+    expect(api.fetchTransitions).toHaveBeenCalledWith('TEST-123');
+    expect(api.fetchAssignableUsers).toHaveBeenCalledWith('TEST-123');
+  });
+
+  it('should set issue detail and related data on successful fetch', async () => {
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.issueDetail).toEqual(mockIssueDetail);
+    });
+    
+    expect(result.current.comments).toEqual(mockComments);
+    expect(result.current.transitions).toEqual(mockTransitions);
+    expect(result.current.assignableUsers).toEqual(mockUsers);
+  });
+
+  it('should handle fetch errors gracefully', async () => {
+    api.fetchIssueDetail.mockRejectedValue(new Error('Network error'));
+    
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+    
+    expect(result.current.drawerError).toBe('Network error');
+  });
+
+  it('should use fallback error message when error has no message', async () => {
+    api.fetchIssueDetail.mockRejectedValue(new Error());
+    
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+    
+    expect(result.current.drawerError).toBe('Failed to load issue details');
+  });
+
+  it('should continue if transitions fetch fails', async () => {
+    api.fetchTransitions.mockRejectedValue(new Error('Transitions error'));
+    
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+    
+    expect(result.current.drawerError).toBe(null);
+    expect(result.current.issueDetail).toEqual(mockIssueDetail);
+  });
+
+  it('should not post empty comment', async () => {
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+
+    await result.current.handlePostComment();
+
+    expect(api.postComment).not.toHaveBeenCalled();
+  });
+
+  it('should not assign without accountId', async () => {
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+
+    await result.current.handleAssignUser(null, 'User One');
+
+    expect(api.assignIssue).not.toHaveBeenCalled();
+  });
+
+  it('should not update status without transitionId', async () => {
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+
+    await result.current.handleUpdateStatus(null, 'In Progress');
+
+    expect(api.transitionIssue).not.toHaveBeenCalled();
+  });
+
+  it('should not update version without issueKey', async () => {
+    const { result } = renderHook(() => useIssueDrawer(null, mockAddToast, mockRefetch));
+
+    await result.current.handleUpdateVersion('1');
+
+    expect(api.updateIssue).not.toHaveBeenCalled();
+  });
+
+  it('should reject disallowed file types', async () => {
+    const disallowedFile = new File(['content'], 'test.exe', { type: 'application/x-executable' });
+    
+    const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+    
+    await waitFor(() => {
+      expect(result.current.drawerLoading).toBe(false);
+    });
+
+    const mockEvent = {
+      target: {
+        files: [disallowedFile],
+        value: ''
+      }
+    };
+
+    await result.current.handleFileUpload(mockEvent);
+
+    expect(mockAddToast).toHaveBeenCalledWith('File type not allowed', 'error');
+    expect(api.uploadAttachment).not.toHaveBeenCalled();
+  });
+
+  describe('handlePostComment', () => {
+    it('should successfully post a comment', async () => {
+      const postedComment = { id: 3, body: 'New comment' };
+      api.postComment.mockResolvedValue(postedComment);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await waitFor(() => {
+        result.current.setNewCommentText('New comment');
+      });
+      await waitFor(() => {
+        expect(result.current.newCommentText).toBe('New comment');
+      });
+      await result.current.handlePostComment();
+
+      await waitFor(() => {
+        expect(result.current.comments).toHaveLength(3);
+        expect(result.current.comments[2]).toEqual(postedComment);
+      });
+      expect(result.current.newCommentText).toBe('');
+      expect(mockAddToast).toHaveBeenCalledWith('Comment posted', 'success');
+    });
+
+    it('should handle comment post error', async () => {
+      api.postComment.mockRejectedValue(new Error('Comment failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await waitFor(() => {
+        result.current.setNewCommentText('New comment');
+      });
+      await waitFor(() => {
+        expect(result.current.newCommentText).toBe('New comment');
+      });
+      await result.current.handlePostComment();
+
+      await waitFor(() => {
+        expect(mockAddToast).toHaveBeenCalledWith('Error posting comment: Comment failed', 'error');
+      });
+    });
+
+    it('should set isPostingComment while posting', async () => {
+      let resolveComment;
+      api.postComment.mockImplementation(() => new Promise(r => resolveComment = r));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await waitFor(() => {
+        result.current.setNewCommentText('New comment');
+      });
+      await waitFor(() => {
+        expect(result.current.newCommentText).toBe('New comment');
+      });
+      const postPromise = result.current.handlePostComment();
+      await waitFor(() => {
+        expect(result.current.isPostingComment).toBe(true);
+      });
+      resolveComment({ id: 3, body: 'New comment' });
+      await postPromise;
+      await waitFor(() => {
+        expect(result.current.isPostingComment).toBe(false);
+      });
+    });
+  });
+
+  describe('handleAssignUser', () => {
+    it('should successfully assign a user', async () => {
+      api.assignIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, assignee: { displayName: 'User One' } } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await result.current.handleAssignUser('user1', 'User One');
+
+      expect(api.assignIssue).toHaveBeenCalledWith('TEST-123', 'user1');
+      expect(mockAddToast).toHaveBeenCalledWith('Issue assigned successfully', 'success');
+      expect(mockRefetch).toHaveBeenCalled();
+    });
+
+    it('should handle assign error', async () => {
+      api.assignIssue.mockRejectedValue(new Error('Assign failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await result.current.handleAssignUser('user1', 'User One');
+
+      expect(result.current.optimisticAssignee).toBe(null);
+      expect(mockAddToast).toHaveBeenCalledWith('Failed to assign: Assign failed', 'error');
+    });
+
+    it('should clear assigneeSearch and targetAccountId on assign', async () => {
+      api.assignIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setAssigneeSearch('search');
+      result.current.setTargetAccountId('user1');
+      await result.current.handleAssignUser('user1', 'User One');
+
+      expect(result.current.assigneeSearch).toBe('');
+      expect(result.current.targetAccountId).toBe('');
+    });
+
+    it('should set isAssigningOptimistic during assignment', async () => {
+      let resolveAssign;
+      api.assignIssue.mockImplementation(() => new Promise(r => resolveAssign = r));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const assignPromise = result.current.handleAssignUser('user1', 'User One');
+      await waitFor(() => {
+        expect(result.current.isAssigningOptimistic).toBe(true);
+      });
+      resolveAssign(undefined);
+      await assignPromise;
+      await waitFor(() => {
+        expect(result.current.isAssigningOptimistic).toBe(false);
+      });
+    });
+  });
+
+  describe('handleUpdateStatus', () => {
+    it('should successfully update status', async () => {
+      api.transitionIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, status: { name: 'In Progress' } } });
+      api.fetchTransitions.mockResolvedValue([]);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await result.current.handleUpdateStatus('2', 'In Progress');
+
+      await waitFor(() => {
+        expect(api.transitionIssue).toHaveBeenCalledWith('TEST-123', '2');
+      });
+      expect(result.current.optimisticStatus).toBe('In Progress');
+      expect(mockAddToast).toHaveBeenCalledWith('Status updated successfully', 'success');
+      expect(mockRefetch).toHaveBeenCalled();
+    });
+
+    it('should handle status update error', async () => {
+      api.transitionIssue.mockRejectedValue(new Error('Transition failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await result.current.handleUpdateStatus('2', 'In Progress');
+
+      expect(result.current.optimisticStatus).toBe(null);
+      expect(mockAddToast).toHaveBeenCalledWith('Failed to update status: Transition failed', 'error');
+    });
+
+    it('should set targetTransitionId to empty after update', async () => {
+      api.transitionIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+      api.fetchTransitions.mockResolvedValue([]);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setTargetTransitionId('2');
+      await result.current.handleUpdateStatus('2', 'In Progress');
+      expect(result.current.targetTransitionId).toBe('');
+    });
+
+    it('should set isTransitioningOptimistic during transition', async () => {
+      let resolveTransition;
+      api.transitionIssue.mockImplementation(() => new Promise(r => resolveTransition = r));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const transitionPromise = result.current.handleUpdateStatus('2', 'In Progress');
+      await waitFor(() => {
+        expect(result.current.isTransitioningOptimistic).toBe(true);
+      });
+      resolveTransition(undefined);
+      await transitionPromise;
+      await waitFor(() => {
+        expect(result.current.isTransitioningOptimistic).toBe(false);
+      });
+    });
+  });
+
+  describe('handleFileUpload', () => {
+    it('should reject files larger than 10MB', async () => {
+      const largeFile = new File(['x'.repeat(11 * 1024 * 1024)], 'large.pdf', { type: 'application/pdf' });
+      
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [largeFile],
+          value: 'file-input-value'
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+
+      await waitFor(() => {
+        expect(result.current.uploadMessage).toBe('Error: File size exceeds 10MB limit');
+      });
+      expect(api.uploadAttachment).not.toHaveBeenCalled();
+    });
+
+    it('should successfully upload a file', async () => {
+      const validFile = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      api.uploadAttachment.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [validFile],
+          value: 'file-input-value'
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+
+      await waitFor(() => {
+        expect(api.uploadAttachment).toHaveBeenCalledWith('TEST-123', validFile);
+      });
+      await waitFor(() => {
+        expect(result.current.uploadMessage).toBe('File uploaded successfully');
+      });
+      expect(mockAddToast).toHaveBeenCalledWith('File attached successfully', 'success');
+    });
+
+    it('should handle upload error', async () => {
+      const validFile = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      api.uploadAttachment.mockRejectedValue(new Error('Upload failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [validFile],
+          value: 'file-input-value'
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+
+      await waitFor(() => {
+        expect(result.current.uploadMessage).toBe('Error uploading file: Upload failed');
+      });
+      expect(mockAddToast).toHaveBeenCalledWith('Error attaching file: Upload failed', 'error');
+    });
+
+    it('should clear file input after upload', async () => {
+      const validFile = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      api.uploadAttachment.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [validFile],
+          value: 'file-input-value'
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+
+      expect(mockEvent.target.value).toBe('');
+    });
+
+    it('should accept valid file types', async () => {
+      const validFile = new File(['content'], 'test.pdf', { type: 'application/pdf' });
+      api.uploadAttachment.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue(mockIssueDetail);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [validFile],
+          value: ''
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+      expect(api.uploadAttachment).toHaveBeenCalled();
+    });
+  });
+
+  describe('handleUpdateVersion', () => {
+    it('should successfully update version', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, fixVersions: [{ id: '1', name: 'v1.0' }] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleUpdateVersion('1');
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { fixVersions: [{ id: '1' }] });
+      expect(mockAddToast).toHaveBeenCalledWith('Fix version updated', 'success');
+    });
+
+    it('should handle version update error', async () => {
+      api.updateIssue.mockRejectedValue(new Error('Update failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleUpdateVersion('1');
+
+      expect(mockAddToast).toHaveBeenCalledWith('Error updating version: Update failed', 'error');
+    });
+
+    it('should clear version when null versionId provided', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, fixVersions: [] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleUpdateVersion(null);
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { fixVersions: [] });
+    });
+
+    it('should set isUpdatingVersions during update', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, fixVersions: [{ id: '1' }] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleUpdateVersion('1');
+
+      await waitFor(() => {
+        expect(result.current.isUpdatingVersions).toBe(false);
+      });
+    });
+  });
+
+  describe('handleAddLabel', () => {
+    it('should successfully add a label', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: ['bug', 'urgent'] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleAddLabel('new-label');
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { labels: ['bug', 'urgent', 'new-label'] });
+      expect(mockAddToast).toHaveBeenCalledWith('Label added', 'success');
+      expect(result.current.newLabelText).toBe('');
+      expect(result.current.showLabelSuggestions).toBe(false);
+    });
+
+    it('should handle add label error', async () => {
+      api.updateIssue.mockRejectedValue(new Error('Label update failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleAddLabel('new-label');
+
+      expect(mockAddToast).toHaveBeenCalledWith('Error adding label: Label update failed', 'error');
+    });
+
+    it('should not add duplicate label', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleAddLabel('bug');
+
+      expect(api.updateIssue).not.toHaveBeenCalled();
+    });
+
+    it('should not add empty label', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleAddLabel('');
+
+      expect(api.updateIssue).not.toHaveBeenCalled();
+    });
+
+    it('should use newLabelText when labelToAdd is not string', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: ['bug', 'urgent'] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      result.current.setNewLabelText('typed-label');
+      await waitFor(() => {
+        expect(result.current.newLabelText).toBe('typed-label');
+      });
+
+      await result.current.handleAddLabel(null);
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { labels: ['bug', 'urgent', 'typed-label'] });
+    });
+
+    it('should set isUpdatingLabels during update', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: ['bug', 'urgent'] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleAddLabel('new-label');
+
+      await waitFor(() => {
+        expect(result.current.isUpdatingLabels).toBe(false);
+      });
+    });
+  });
+
+  describe('handleRemoveLabel', () => {
+    it('should successfully remove a label', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: ['bug'] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleRemoveLabel('urgent');
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { labels: ['bug'] });
+      expect(mockAddToast).toHaveBeenCalledWith('Label removed', 'success');
+    });
+
+    it('should handle remove label error', async () => {
+      api.updateIssue.mockRejectedValue(new Error('Remove label failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleRemoveLabel('urgent');
+
+      expect(mockAddToast).toHaveBeenCalledWith('Error removing label: Remove label failed', 'error');
+    });
+
+    it('should set isUpdatingLabels during removal', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: ['bug'] } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleRemoveLabel('urgent');
+
+      await waitFor(() => {
+        expect(result.current.isUpdatingLabels).toBe(false);
+      });
+    });
+
+    it('should not remove label without issueKey', async () => {
+      const { result } = renderHook(() => useIssueDrawer(null, mockAddToast, mockRefetch));
+
+      await result.current.handleRemoveLabel('urgent');
+
+      expect(api.updateIssue).not.toHaveBeenCalled();
+    });
+
+    it('should use empty array when no labels remain after removal', async () => {
+      api.updateIssue.mockResolvedValue(undefined);
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, fields: { ...mockIssueDetail.fields, labels: null } });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.issueDetail).toBeDefined();
+      });
+
+      await result.current.handleRemoveLabel('urgent');
+
+      expect(api.updateIssue).toHaveBeenCalledWith('TEST-123', { labels: [] });
+    });
+  });
+
+  describe('label search debounce', () => {
+    it('should clear suggestions when label text is empty', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setNewLabelText('test');
+      await waitFor(() => {
+        expect(result.current.labelSuggestions.length).toBeGreaterThanOrEqual(0);
+      });
+
+      result.current.setNewLabelText('');
+      expect(result.current.labelSuggestions).toEqual([]);
+      expect(result.current.showLabelSuggestions).toBe(false);
+    });
+
+    it('should filter out existing labels from suggestions', async () => {
+      api.searchLabels.mockResolvedValue(['bug', 'new-label', 'urgent']);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setNewLabelText('b');
+      await waitFor(() => {
+        expect(result.current.labelSuggestions).toEqual([]);
+      });
+    });
+
+    it('should handle label search error gracefully', async () => {
+      api.searchLabels.mockRejectedValue(new Error('Search failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setNewLabelText('test');
+      await waitFor(() => {
+        expect(result.current.labelSuggestions).toEqual([]);
+      });
+    });
+
+    it('should show suggestions when labels are available', async () => {
+      api.searchLabels.mockResolvedValue(['backend', 'frontend']);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setNewLabelText('b');
+      await waitFor(() => {
+        expect(result.current.showLabelSuggestions).toBe(true);
+      });
+    });
+
+    it('should trigger error catch when label search fails after debounce', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      api.searchLabels.mockRejectedValue(new Error('Label search failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setNewLabelText('test');
+      await waitFor(() => {
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Label search error:', expect.any(Error));
+      }, { timeout: 1000 });
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('assignee search debounce', () => {
+    it('should clear users when search is empty', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setAssigneeSearch('');
+      expect(result.current.assignableUsers).toEqual(mockUsers);
+    });
+
+    it('should handle assignee search error gracefully', async () => {
+      api.fetchAssignableUsers.mockRejectedValue(new Error('Search failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setAssigneeSearch('test');
+      await waitFor(() => {
+        expect(result.current.assignableUsers).toEqual([]);
+      });
+    });
+
+    it('should update assignable users after search', async () => {
+      api.fetchAssignableUsers.mockResolvedValue([{ accountId: 'user3', displayName: 'User Three' }]);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setAssigneeSearch('three');
+      await waitFor(() => {
+        expect(result.current.assignableUsers).toHaveLength(1);
+        expect(result.current.assignableUsers[0].accountId).toBe('user3');
+      });
+    });
+
+    it('should not search when assignee search length is less than 1', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      api.fetchAssignableUsers.mockClear();
+      result.current.setAssigneeSearch('');
+      expect(api.fetchAssignableUsers).not.toHaveBeenCalled();
+    });
+
+    it('should trigger error catch when assignee search fails after debounce', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      api.fetchAssignableUsers.mockRejectedValue(new Error('Assignee search failed'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      result.current.setAssigneeSearch('test');
+      await waitFor(() => {
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Assignee search error:', expect.any(Error));
+      }, { timeout: 1000 });
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle missing project key in issue detail', async () => {
+      api.fetchIssueDetail.mockResolvedValue({
+        ...mockIssueDetail,
+        fields: { ...mockIssueDetail.fields, project: null }
+      });
+
+      renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(api.fetchIssueDetail).toHaveBeenCalled();
+      });
+
+      expect(api.fetchProjectVersions).not.toHaveBeenCalled();
+    });
+
+    it('should handle null issueDetail fields', async () => {
+      api.fetchIssueDetail.mockResolvedValue({
+        key: 'TEST-123',
+        fields: {
+          summary: 'Test',
+          status: null,
+          project: null,
+          labels: null,
+          assignee: null
+        }
+      });
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      expect(result.current.issueDetail).toBeDefined();
+    });
+
+    it('should handle fetchProjectVersions error gracefully', async () => {
+      api.fetchProjectVersions.mockRejectedValue(new Error('Versions error'));
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      expect(result.current.projectVersions).toEqual([]);
+    });
+
+    it('should load project versions when project key exists', async () => {
+      const versions = [{ id: '1', name: 'v1.0' }, { id: '2', name: 'v2.0' }];
+      api.fetchProjectVersions.mockResolvedValue(versions);
+
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      await waitFor(() => {
+        expect(result.current.projectVersions).toEqual(versions);
+      });
+    });
+
+    it('should not upload when no file is selected', async () => {
+      const { result } = renderHook(() => useIssueDrawer('TEST-123', mockAddToast, mockRefetch));
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      const mockEvent = {
+        target: {
+          files: [],
+          value: ''
+        }
+      };
+
+      await result.current.handleFileUpload(mockEvent);
+      expect(api.uploadAttachment).not.toHaveBeenCalled();
+    });
+
+    it('should reset state when issueKey changes', async () => {
+      const { result, rerender } = renderHook(
+        ({ issueKey }) => useIssueDrawer(issueKey, mockAddToast, mockRefetch),
+        { initialProps: { issueKey: 'TEST-123' } }
+      );
+      
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+      });
+
+      expect(result.current.issueDetail).toEqual(mockIssueDetail);
+
+      api.fetchIssueDetail.mockResolvedValue({ ...mockIssueDetail, key: 'TEST-456' });
+      rerender({ issueKey: 'TEST-456' });
+
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(true);
+      });
+
+      await waitFor(() => {
+        expect(result.current.drawerLoading).toBe(false);
+        expect(result.current.issueDetail.key).toBe('TEST-456');
+      });
+    });
+  });
+});