jira-pat 1.0.0

package/backend/__tests__/jiraService.test.js

@@ -0,0 +1,1127 @@
+const axios = require('axios');
+const NodeCache = require('node-cache');
+
+jest.mock('axios');
+jest.mock('dotenv', () => ({ config: jest.fn() }));
+jest.mock('node-cache');
+
+const mockCacheInstance = {
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn(),
+    flushAll: jest.fn(),
+    keys: jest.fn(() => [])
+};
+
+NodeCache.mockImplementation(() => mockCacheInstance);
+
+process.env.JIRA_BASE_URL = 'https://test.atlassian.net';
+process.env.JIRA_PAT = 'test-pat';
+process.env.JIRA_EMAIL = 'test@example.com';
+process.env.BACKEND_BASE_URL = 'http://localhost:5000';
+
+const jiraService = require('../service/jiraService');
+
+describe('jiraService', () => {
+    let mockAxiosInstance;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockCacheInstance.get.mockReset();
+        mockCacheInstance.set.mockReset();
+        mockCacheInstance.del.mockReset();
+        mockCacheInstance.flushAll.mockReset();
+        mockCacheInstance.keys.mockReturnValue([]);
+        
+        mockAxiosInstance = {
+            get: jest.fn(),
+            post: jest.fn(),
+            put: jest.fn(),
+            defaults: { baseURL: 'https://test.atlassian.net' }
+        };
+        axios.create.mockReturnValue(mockAxiosInstance);
+    });
+
+    describe('adfToText', () => {
+        it('should convert ADF text node to plain text', () => {
+            const node = { type: 'text', text: 'Hello World' };
+            expect(jiraService.adfToText(node)).toBe('Hello World');
+        });
+
+        it('should return empty string for null node', () => {
+            expect(jiraService.adfToText(null)).toBe('');
+        });
+
+        it('should handle paragraph with multiple text nodes', () => {
+            const node = {
+                type: 'paragraph',
+                content: [
+                    { type: 'text', text: 'Hello' },
+                    { type: 'text', text: 'World' }
+                ]
+            };
+            const result = jiraService.adfToText(node);
+            expect(result).toContain('Hello');
+            expect(result).toContain('World');
+        });
+
+        it('should handle nested content', () => {
+            const node = {
+                type: 'doc',
+                content: [
+                    {
+                        type: 'paragraph',
+                        content: [{ type: 'text', text: 'First line' }]
+                    },
+                    {
+                        type: 'paragraph',
+                        content: [{ type: 'text', text: 'Second line' }]
+                    }
+                ]
+            };
+            const result = jiraService.adfToText(node);
+            expect(result).toContain('First line');
+            expect(result).toContain('Second line');
+        });
+    });
+
+    describe('searchIssues', () => {
+        it('should search issues with project filter', async () => {
+            const mockResponse = {
+                data: {
+                    issues: [{ key: 'TEST-1', fields: { summary: 'Test Issue' } }],
+                    total: 1
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            const result = await jiraService.searchIssues({ project: 'TEST' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('project = "TEST"')
+                    })
+                })
+            );
+            expect(result.issues).toHaveLength(1);
+        });
+
+        it('should handle status filter with exclude syntax', async () => {
+            const mockResponse = { data: { issues: [], total: 0 } };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            await jiraService.searchIssues({ status: 'exclude:Done,In Progress' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('status != "Done"')
+                    })
+                })
+            );
+        });
+
+        it('should throw error on Jira API failure', async () => {
+            mockCacheInstance.get.mockReturnValue(undefined);
+            const error = {
+                response: {
+                    status: 400,
+                    data: { errorMessages: ['Invalid JQL'] }
+                },
+                message: 'Request failed'
+            };
+            mockAxiosInstance.get.mockRejectedValue(error);
+
+            await expect(jiraService.searchIssues({ project: 'TEST' }))
+                .rejects.toThrow();
+        });
+
+        it('should search by issue key when format is PROJECT-NUMBER', async () => {
+            const mockResponse = { data: { issues: [], total: 0 } };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            await jiraService.searchIssues({ search: 'TEST-123', project: 'TEST' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('issueKey = "TEST-123"')
+                    })
+                })
+            );
+        });
+
+        it('should search by number when format is just a number', async () => {
+            const mockResponse = { data: { issues: [], total: 0 } };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            await jiraService.searchIssues({ search: '123', project: 'TEST' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('issueKey = "TEST-123"')
+                    })
+                })
+            );
+        });
+
+        it('should use text search when search is not a number or key', async () => {
+            const mockResponse = { data: { issues: [], total: 0 } };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            await jiraService.searchIssues({ search: 'some text', project: 'TEST' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('text ~ "some text"')
+                    })
+                })
+            );
+        });
+
+        it('should return from cache when cache hit', async () => {
+            const cachedData = { issues: [{ key: 'TEST-1' }], total: 1 };
+            mockCacheInstance.get.mockReturnValue(cachedData);
+
+            const result = await jiraService.searchIssues({ project: 'TEST' });
+
+            expect(result).toEqual(cachedData);
+            expect(mockAxiosInstance.get).not.toHaveBeenCalled();
+        });
+
+        it('should throw error on non-response API failure', async () => {
+            mockCacheInstance.get.mockReturnValue(undefined);
+            mockAxiosInstance.get.mockRejectedValue(new Error('Network timeout'));
+
+            await expect(jiraService.searchIssues({ project: 'TEST' }))
+                .rejects.toThrow('Network timeout');
+        });
+
+        it('should handle regular status filter', async () => {
+            const mockResponse = { data: { issues: [], total: 0 } };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            await jiraService.searchIssues({ status: 'Done' });
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/search/jql',
+                expect.objectContaining({
+                    params: expect.objectContaining({
+                        jql: expect.stringContaining('status = "Done"')
+                    })
+                })
+            );
+        });
+
+        it('should return newline for empty paragraph', () => {
+            const node = { type: 'paragraph', content: [] };
+            expect(jiraService.adfToText(node)).toBe('\n');
+        });
+
+        it('should return empty string for unknown node type', () => {
+            const node = { type: 'unknown', content: [] };
+            expect(jiraService.adfToText(node)).toBe('');
+        });
+
+        it('should return empty string for node with undefined text property', () => {
+            const node = { type: 'text' };
+            expect(jiraService.adfToText(node)).toBe('');
+        });
+
+        it('should return empty string for node without content array', () => {
+            const node = { type: 'other' };
+            expect(jiraService.adfToText(node)).toBe('');
+        });
+    });
+
+    describe('getIssueDetail', () => {
+        it('should fetch issue details and transform data', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    summary: 'Test Issue',
+                    description: {
+                        type: 'doc',
+                        version: 1,
+                        content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Description' }] }]
+                    },
+                    subtasks: [{ key: 'TEST-2', fields: { summary: 'Subtask', status: { name: 'Done' } } }],
+                    issuelinks: []
+                },
+                renderedFields: {
+                    description: '<p>Description HTML</p>'
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.summary).toBe('Test Issue');
+            expect(result.fields.subtasksMapped).toHaveLength(1);
+            expect(result.fields.issuelinksMapped).toEqual([]);
+        });
+
+        it('should handle inward issue links', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    issuelinks: [{
+                        type: { name: 'Blocks', inward: 'is blocked by' },
+                        inwardIssue: {
+                            key: 'TEST-2',
+                            fields: { summary: 'Blocker', status: { name: 'In Progress' } }
+                        }
+                    }]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.issuelinksMapped[0]).toMatchObject({
+                direction: 'inward',
+                label: 'is blocked by',
+                key: 'TEST-2'
+            });
+        });
+
+        it('should handle outward issue links', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    issuelinks: [{
+                        type: { name: 'Blocks', outward: 'blocks' },
+                        outwardIssue: {
+                            key: 'TEST-3',
+                            fields: { summary: 'Blocked', status: { name: 'To Do' } }
+                        }
+                    }]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.issuelinksMapped[0]).toMatchObject({
+                direction: 'outward',
+                label: 'blocks',
+                key: 'TEST-3'
+            });
+        });
+
+        it('should proxy images from Atlassian domain', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    description: '<img src="https://test.atlassian.net/attachment.png" />'
+                },
+                renderedFields: {
+                    description: '<img src="https://test.atlassian.net/attachment.png" />'
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionHtml).toContain('/api/issues/image/proxy?url=');
+        });
+
+        it('should not proxy images from external domains', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    description: '<img src="https://external.com/image.png" />'
+                },
+                renderedFields: {
+                    description: '<img src="https://external.com/image.png" />'
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionHtml).toContain('https://external.com/image.png');
+        });
+
+        it('should handle empty fields', async () => {
+            const mockIssue = { key: 'TEST-1' };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionText).toBe('');
+            expect(result.fields.subtasksMapped).toEqual([]);
+            expect(result.fields.issuelinksMapped).toEqual([]);
+        });
+
+        it('should handle null subtasks', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    summary: 'Test',
+                    subtasks: null,
+                    issuelinks: null
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.subtasksMapped).toEqual([]);
+            expect(result.fields.issuelinksMapped).toEqual([]);
+        });
+
+        it('should handle subtasks with missing fields summary and status', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    subtasks: [
+                        { key: 'TEST-2', fields: {} },
+                        { key: 'TEST-3', fields: { summary: 'Has summary' } }
+                    ],
+                    issuelinks: []
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.subtasksMapped[0].summary).toBe('');
+            expect(result.fields.subtasksMapped[0].status).toBe('Unknown');
+            expect(result.fields.subtasksMapped[1].summary).toBe('Has summary');
+        });
+
+        it('should handle inward issue links with missing fields', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    issuelinks: [{
+                        type: { name: 'Blocks', inward: 'is blocked by' },
+                        inwardIssue: {
+                            key: 'TEST-2',
+                            fields: {}
+                        }
+                    }]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.issuelinksMapped[0].summary).toBe('');
+            expect(result.fields.issuelinksMapped[0].status).toBe('Unknown');
+        });
+
+        it('should handle outward issue links with missing fields', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    issuelinks: [{
+                        type: { name: 'Blocks', outward: 'blocks' },
+                        outwardIssue: {
+                            key: 'TEST-3',
+                            fields: {}
+                        }
+                    }]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.issuelinksMapped[0].summary).toBe('');
+            expect(result.fields.issuelinksMapped[0].status).toBe('Unknown');
+        });
+
+        it('should use ADF description text when no renderedFields', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    summary: 'Test Issue',
+                    description: {
+                        type: 'doc',
+                        version: 1,
+                        content: [{ type: 'paragraph', content: [{ type: 'text', text: 'ADF Description' }] }]
+                    }
+                },
+                renderedFields: null
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionText).toContain('ADF Description');
+        });
+
+        it('should filter out null issue links (neither inward nor outward)', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    issuelinks: [{
+                        type: { name: 'Relates', inward: 'relates to', outward: 'relates to' },
+                        inwardIssue: null,
+                        outwardIssue: null
+                    }]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.issuelinksMapped).toEqual([]);
+        });
+
+        it('should proxy images from .atlassian.net domain', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {},
+                renderedFields: {
+                    description: '<img src="https://myteam.atlassian.net/attachment.png" />'
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionHtml).toContain('/api/issues/image/proxy?url=');
+        });
+
+        it('should not proxy images from non-Atlassian domains in description', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {},
+                renderedFields: {
+                    description: '<img src="https://external.com/image.png" />'
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionHtml).toBe('<img src="https://external.com/image.png" />');
+        });
+
+        it('should handle empty description html', async () => {
+            const mockIssue = {
+                key: 'TEST-1',
+                fields: {
+                    summary: 'Test'
+                },
+                renderedFields: {
+                    description: ''
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue({ data: mockIssue });
+
+            const result = await jiraService.getIssueDetail('TEST-1');
+
+            expect(result.fields.descriptionText).toBe('');
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('Network Error'));
+
+            await expect(jiraService.getIssueDetail('TEST-1'))
+                .rejects.toThrow('Network Error');
+        });
+
+        it('should throw error without response on network error', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('Network timeout'));
+
+            await expect(jiraService.getIssueDetail('TEST-1'))
+                .rejects.toThrow('Network timeout');
+        });
+    });
+
+    describe('getComments', () => {
+        it('should fetch and transform comments', async () => {
+            const mockComments = [{
+                id: '1',
+                renderedBody: '<img src="https://test.atlassian.net/img.png" />',
+                body: { type: 'doc', content: [] }
+            }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result).toHaveLength(1);
+            expect(result[0].renderedHtml).toContain('/api/issues/image/proxy?url=');
+        });
+
+        it('should return empty array when no comments', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should use ADF body text when no rendered body', async () => {
+            const mockComments = [{
+                id: '1',
+                body: {
+                    type: 'doc',
+                    content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Plain text' }] }]
+                }
+            }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result[0].bodyText).toContain('Plain text');
+        });
+
+        it('should handle comment with null body', async () => {
+            const mockComments = [{ id: '1', body: null }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result[0].bodyText).toBe('');
+        });
+
+        it('should not proxy images from non-Atlassian domains in comments', async () => {
+            const mockComments = [{
+                id: '1',
+                renderedBody: '<img src="https://external.com/img.png" />'
+            }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result[0].renderedHtml).toBe('<img src="https://external.com/img.png" />');
+        });
+
+        it('should handle comments with empty renderedBody and no body', async () => {
+            const mockComments = [{ id: '1', renderedBody: '', body: null }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result[0].bodyText).toBe('');
+        });
+
+        it('should handle comments with falsy renderedBody and no body', async () => {
+            const mockComments = [{ id: '1', body: null }];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { comments: mockComments }
+            });
+
+            const result = await jiraService.getComments('TEST-1');
+
+            expect(result[0].bodyText).toBe('');
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getComments('TEST-1')).rejects.toThrow('API Error');
+        });
+    });
+
+    describe('addComment', () => {
+        it('should add comment with ADF format', async () => {
+            const mockResponse = {
+                data: {
+                    id: '100',
+                    body: {
+                        type: 'doc',
+                        content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Test comment' }] }]
+                    }
+                }
+            };
+            mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+            const result = await jiraService.addComment('TEST-1', 'Test comment');
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1/comment',
+                expect.objectContaining({
+                    body: expect.objectContaining({
+                        type: 'doc',
+                        content: expect.arrayContaining([
+                            expect.objectContaining({
+                                type: 'paragraph'
+                            })
+                        ])
+                    })
+                })
+            );
+            expect(result.bodyText).toBe('Test comment');
+        });
+
+        it('should handle addComment response without body', async () => {
+            const mockResponse = {
+                data: {
+                    id: '100'
+                }
+            };
+            mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+            const result = await jiraService.addComment('TEST-1', 'Test comment');
+
+            expect(result.bodyText).toBeUndefined();
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.post.mockRejectedValue(new Error('Failed to add comment'));
+
+            await expect(jiraService.addComment('TEST-1', 'Test'))
+                .rejects.toThrow('Failed to add comment');
+        });
+    });
+
+    describe('getTransitions', () => {
+        it('should fetch available transitions', async () => {
+            const mockTransitions = [
+                { id: '1', name: 'To Do' },
+                { id: '2', name: 'In Progress' }
+            ];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { transitions: mockTransitions }
+            });
+
+            const result = await jiraService.getTransitions('TEST-1');
+
+            expect(result).toEqual(mockTransitions);
+        });
+
+        it('should return empty array when no transitions', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.getTransitions('TEST-1');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getTransitions('TEST-1')).rejects.toThrow();
+        });
+    });
+
+    describe('transitionIssue', () => {
+        it('should transition issue with given transitionId', async () => {
+            mockAxiosInstance.post.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.transitionIssue('TEST-1', '3');
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1/transitions',
+                { transition: { id: '3' } }
+            );
+            expect(result.success).toBe(true);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.post.mockRejectedValue(new Error('Transition failed'));
+
+            await expect(jiraService.transitionIssue('TEST-1', '3'))
+                .rejects.toThrow();
+        });
+    });
+
+    describe('getAssignableUsers', () => {
+        it('should fetch assignable users', async () => {
+            const mockUsers = [{ accountId: '1', displayName: 'John' }];
+            mockAxiosInstance.get.mockResolvedValue({ data: mockUsers });
+
+            const result = await jiraService.getAssignableUsers('TEST-1');
+
+            expect(result).toEqual(mockUsers);
+        });
+
+        it('should filter by query when provided', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: [] });
+
+            await jiraService.getAssignableUsers('TEST-1', 'john');
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                '/rest/api/3/user/assignable/search',
+                { params: { issueKey: 'TEST-1', query: 'john' } }
+            );
+        });
+
+        it('should return from cache when cache hit', async () => {
+            const cachedUsers = [{ accountId: '1', displayName: 'Cached User' }];
+            mockCacheInstance.get.mockReturnValue(cachedUsers);
+
+            const result = await jiraService.getAssignableUsers('TEST-1');
+
+            expect(result).toEqual(cachedUsers);
+            expect(mockAxiosInstance.get).not.toHaveBeenCalled();
+        });
+
+        it('should return from cache when cache hit with query', async () => {
+            const cachedUsers = [{ accountId: '1', displayName: 'Cached User' }];
+            mockCacheInstance.get.mockReturnValue(cachedUsers);
+
+            const result = await jiraService.getAssignableUsers('TEST-1', 'john');
+
+            expect(result).toEqual(cachedUsers);
+            expect(mockAxiosInstance.get).not.toHaveBeenCalled();
+        });
+
+        it('should handle empty response data', async () => {
+            mockCacheInstance.get.mockReturnValue(undefined);
+            mockAxiosInstance.get.mockResolvedValue({ data: null });
+
+            const result = await jiraService.getAssignableUsers('TEST-1');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockCacheInstance.get.mockReturnValue(undefined);
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getAssignableUsers('TEST-1')).rejects.toThrow();
+        });
+    });
+
+    describe('assignIssue', () => {
+        it('should assign issue to user', async () => {
+            mockAxiosInstance.put.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.assignIssue('TEST-1', 'account123');
+
+            expect(mockAxiosInstance.put).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1/assignee',
+                { accountId: 'account123' }
+            );
+            expect(result.success).toBe(true);
+        });
+
+        it('should unassign issue when accountId is null', async () => {
+            mockAxiosInstance.put.mockResolvedValue({ data: {} });
+
+            await jiraService.assignIssue('TEST-1', null);
+
+            expect(mockAxiosInstance.put).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1/assignee',
+                { accountId: null }
+            );
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.put.mockRejectedValue(new Error('Assignment failed'));
+
+            await expect(jiraService.assignIssue('TEST-1', 'user1'))
+                .rejects.toThrow();
+        });
+    });
+
+    describe('attachFile', () => {
+        it('should attach file with FormData', async () => {
+            mockAxiosInstance.post.mockResolvedValue({ data: [{ filename: 'test.pdf' }] });
+
+            await jiraService.attachFile(
+                'TEST-1',
+                Buffer.from('test'),
+                'test.pdf',
+                'application/pdf'
+            );
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1/attachments',
+                expect.any(Object),
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        'X-Atlassian-Token': 'no-check'
+                    })
+                })
+            );
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.post.mockRejectedValue(new Error('Upload failed'));
+
+            await expect(jiraService.attachFile('TEST-1', Buffer.from('test'), 'test.pdf', 'application/pdf'))
+                .rejects.toThrow();
+        });
+    });
+
+    describe('getProjects', () => {
+        it('should fetch all projects', async () => {
+            const mockProjects = [
+                { key: 'TEST', name: 'Test Project' },
+                { key: 'PROD', name: 'Production' }
+            ];
+            mockAxiosInstance.get.mockResolvedValue({ data: mockProjects });
+
+            const result = await jiraService.getProjects();
+
+            expect(result).toEqual(mockProjects);
+        });
+
+        it('should return empty array when response data is null', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: null });
+
+            const result = await jiraService.getProjects();
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getProjects()).rejects.toThrow();
+        });
+    });
+
+    describe('getIssueTypes', () => {
+        it('should fetch issue types for project', async () => {
+            const mockTypes = [
+                { id: '1', name: 'Bug' },
+                { id: '2', name: 'Story' }
+            ];
+            mockAxiosInstance.get.mockResolvedValue({
+                data: { issueTypes: mockTypes }
+            });
+
+            const result = await jiraService.getIssueTypes('TEST');
+
+            expect(result).toEqual(mockTypes);
+        });
+
+        it('should return empty array when issueTypes is missing', async () => {
+            mockAxiosInstance.get.mockResolvedValue({
+                data: {}
+            });
+
+            const result = await jiraService.getIssueTypes('TEST');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getIssueTypes('TEST')).rejects.toThrow();
+        });
+    });
+
+    describe('getProjectVersions', () => {
+        it('should fetch versions for project', async () => {
+            const mockVersions = [
+                { id: '1', name: 'v1.0' },
+                { id: '2', name: 'v2.0' }
+            ];
+            mockAxiosInstance.get.mockResolvedValue({ data: mockVersions });
+
+            const result = await jiraService.getProjectVersions('TEST');
+
+            expect(result).toEqual(mockVersions);
+        });
+
+        it('should return empty array when response data is null', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: null });
+
+            const result = await jiraService.getProjectVersions('TEST');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('API Error'));
+
+            await expect(jiraService.getProjectVersions('TEST')).rejects.toThrow();
+        });
+    });
+
+    describe('createIssue', () => {
+        it('should create issue with required fields', async () => {
+            const mockResponse = { data: { key: 'TEST-100', id: '100' } };
+            mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+            const result = await jiraService.createIssue({
+                projectKey: 'TEST',
+                summary: 'New Issue',
+                issueType: '1'
+            });
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue',
+                expect.objectContaining({
+                    fields: expect.objectContaining({
+                        project: { key: 'TEST' },
+                        summary: 'New Issue',
+                        issuetype: { id: '1' }
+                    })
+                })
+            );
+            expect(result.key).toBe('TEST-100');
+        });
+
+        it('should include description in ADF format', async () => {
+            const mockResponse = { data: { key: 'TEST-100' } };
+            mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+            await jiraService.createIssue({
+                projectKey: 'TEST',
+                summary: 'New Issue',
+                issueType: '1',
+                description: 'This is a description'
+            });
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue',
+                expect.objectContaining({
+                    fields: expect.objectContaining({
+                        description: expect.objectContaining({
+                            type: 'doc',
+                            content: expect.arrayContaining([
+                                expect.objectContaining({
+                                    type: 'paragraph'
+                                })
+                            ])
+                        })
+                    })
+                })
+            );
+        });
+
+        it('should include priority when provided', async () => {
+            const mockResponse = { data: { key: 'TEST-100' } };
+            mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+            await jiraService.createIssue({
+                projectKey: 'TEST',
+                summary: 'New Issue',
+                issueType: '1',
+                priority: '3'
+            });
+
+            expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+                '/rest/api/3/issue',
+                expect.objectContaining({
+                    fields: expect.objectContaining({
+                        priority: { id: '3' }
+                    })
+                })
+            );
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.post.mockRejectedValue(new Error('Create failed'));
+
+            await expect(jiraService.createIssue({
+                projectKey: 'TEST',
+                summary: 'Test',
+                issueType: '1'
+            })).rejects.toThrow();
+        });
+    });
+
+    describe('updateIssue', () => {
+        it('should update issue fields', async () => {
+            mockAxiosInstance.put.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.updateIssue('TEST-1', { summary: 'Updated' });
+
+            expect(mockAxiosInstance.put).toHaveBeenCalledWith(
+                '/rest/api/3/issue/TEST-1',
+                { fields: { summary: 'Updated' } }
+            );
+            expect(result.success).toBe(true);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.put.mockRejectedValue(new Error('Update failed'));
+
+            await expect(jiraService.updateIssue('TEST-1', { summary: 'Test' }))
+                .rejects.toThrow();
+        });
+    });
+
+    describe('searchLabels', () => {
+        it('should search labels', async () => {
+            const mockResponse = {
+                data: {
+                    results: [
+                        { displayName: 'bug', value: 'bug' },
+                        { displayName: 'bug-fix', value: 'bug-fix' }
+                    ]
+                }
+            };
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+            const result = await jiraService.searchLabels('bug');
+
+            expect(result).toEqual(['bug', 'bug-fix']);
+        });
+
+        it('should handle empty query', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: { results: [] } });
+
+            const result = await jiraService.searchLabels('');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should return empty array when results is missing', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: {} });
+
+            const result = await jiraService.searchLabels('bug');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('Search failed'));
+
+            await expect(jiraService.searchLabels('bug')).rejects.toThrow();
+        });
+    });
+
+    describe('downloadAttachment', () => {
+        it('should download attachment with stream', async () => {
+            const mockStream = { pipe: jest.fn() };
+            mockAxiosInstance.get.mockResolvedValue({
+                data: mockStream,
+                headers: { 'content-type': 'image/png' }
+            });
+
+            const result = await jiraService.downloadAttachment('https://example.com/file.png');
+
+            expect(result.data).toBe(mockStream);
+        });
+
+        it('should handle relative URLs', async () => {
+            mockAxiosInstance.get.mockResolvedValue({ data: {} });
+
+            await jiraService.downloadAttachment('/rest/api/file.png');
+
+            expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+                expect.stringContaining('/rest/api/file.png'),
+                { responseType: 'stream' }
+            );
+        });
+
+        it('should throw error on API failure', async () => {
+            mockAxiosInstance.get.mockRejectedValue(new Error('Download failed'));
+
+            await expect(jiraService.downloadAttachment('https://example.com/file.png'))
+                .rejects.toThrow();
+        });
+    });
+});