jira-pat 1.0.0

package/backend/__tests__/issues.test.js

@@ -0,0 +1,565 @@
+const express = require('express');
+const request = require('supertest');
+
+jest.mock('../service/jiraService');
+jest.mock('express-rate-limit', () => {
+    return () => (req, res, next) => next();
+});
+const jiraService = require('../service/jiraService');
+
+const createApp = () => {
+    const app = express();
+    app.use(express.json());
+    app.use('/api/issues', require('../routes/issues'));
+    return app;
+};
+
+describe('issues routes', () => {
+    let app;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        app = createApp();
+    });
+
+    describe('GET /api/issues', () => {
+        it('should return issues list', async () => {
+            const mockData = {
+                issues: [{ key: 'TEST-1', fields: { summary: 'Test Issue' } }],
+                total: 1
+            };
+            jiraService.searchIssues.mockResolvedValue(mockData);
+
+            const response = await request(app)
+                .get('/api/issues')
+                .query({ project: 'TEST' });
+
+            expect(response.status).toBe(200);
+            expect(response.body.issues).toHaveLength(1);
+            expect(jiraService.searchIssues).toHaveBeenCalledWith(
+                expect.objectContaining({ project: 'TEST' })
+            );
+        });
+
+        it('should return empty array when no issues found', async () => {
+            jiraService.searchIssues.mockResolvedValue({ issues: [], total: 0 });
+
+            const response = await request(app).get('/api/issues');
+
+            expect(response.status).toBe(200);
+            expect(response.body.issues).toEqual([]);
+        });
+
+        it('should pass search parameter to service', async () => {
+            jiraService.searchIssues.mockResolvedValue({ issues: [], total: 0 });
+
+            await request(app).get('/api/issues').query({ search: 'test' });
+
+            expect(jiraService.searchIssues).toHaveBeenCalledWith(
+                expect.objectContaining({ search: 'test' })
+            );
+        });
+
+        it('should handle Jira API errors', async () => {
+            jiraService.searchIssues.mockRejectedValue(new Error('Jira API Error'));
+
+            const response = await request(app).get('/api/issues');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch issues');
+        });
+
+        it('should handle pagination parameters', async () => {
+            jiraService.searchIssues.mockResolvedValue({ issues: [], total: 0 });
+
+            await request(app)
+                .get('/api/issues')
+                .query({ startAt: '10', maxResults: '25' });
+
+            expect(jiraService.searchIssues).toHaveBeenCalledWith(
+                expect.objectContaining({ startAt: '10', maxResults: '25' })
+            );
+        });
+    });
+
+    describe('POST /api/issues', () => {
+        it('should create issue with valid data', async () => {
+            const mockIssue = { key: 'TEST-100', id: '100' };
+            jiraService.createIssue.mockResolvedValue(mockIssue);
+
+            const response = await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST', summary: 'New Issue', issueType: '1' });
+
+            expect(response.status).toBe(201);
+            expect(response.body.key).toBe('TEST-100');
+        });
+
+        it('should reject missing summary', async () => {
+            const response = await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST' });
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('Summary is required');
+        });
+
+        it('should reject empty summary', async () => {
+            const response = await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST', summary: '   ' });
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('Summary cannot be empty');
+        });
+
+        it('should reject summary over 255 characters', async () => {
+            const response = await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST', summary: 'a'.repeat(256) });
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('Summary must be under 255 characters');
+        });
+
+        it('should trim summary whitespace', async () => {
+            jiraService.createIssue.mockResolvedValue({ key: 'TEST-1' });
+
+            await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST', summary: '  Trimmed Summary  ' });
+
+            expect(jiraService.createIssue).toHaveBeenCalledWith(
+                expect.objectContaining({ summary: 'Trimmed Summary' })
+            );
+        });
+
+        it('should handle API errors when creating issue', async () => {
+            jiraService.createIssue.mockRejectedValue(new Error('Create failed'));
+
+            const response = await request(app)
+                .post('/api/issues')
+                .send({ projectKey: 'TEST', summary: 'New Issue', issueType: '1' });
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to create issue');
+        });
+    });
+
+    describe('GET /api/issues/labels/search', () => {
+        it('should search labels', async () => {
+            jiraService.searchLabels.mockResolvedValue(['bug', 'feature']);
+
+            const response = await request(app)
+                .get('/api/issues/labels/search')
+                .query({ query: 'bug' });
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual(['bug', 'feature']);
+        });
+
+        it('should handle errors', async () => {
+            jiraService.searchLabels.mockRejectedValue(new Error('Search failed'));
+
+            const response = await request(app).get('/api/issues/labels/search');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('GET /api/issues/image/proxy', () => {
+        it('should reject missing url', async () => {
+            const response = await request(app).get('/api/issues/image/proxy');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle missing content-type header', async () => {
+            const mockStream = {
+                pipe: jest.fn((res) => {
+                    res.end();
+                    return mockStream;
+                })
+            };
+            jiraService.downloadAttachment.mockResolvedValue({
+                data: mockStream,
+                headers: {}
+            });
+
+            const response = await request(app)
+                .get('/api/issues/image/proxy')
+                .query({ url: 'https://example.com/image.png' });
+
+            expect(response.status).toBe(200);
+        });
+
+        it('should relay content-type header when present', async () => {
+            const mockStream = {
+                pipe: jest.fn((res) => {
+                    res.end();
+                    return mockStream;
+                })
+            };
+            jiraService.downloadAttachment.mockResolvedValue({
+                data: mockStream,
+                headers: { 'content-type': 'image/png' }
+            });
+
+            const response = await request(app)
+                .get('/api/issues/image/proxy')
+                .query({ url: 'https://example.com/image.png' });
+
+            expect(response.status).toBe(200);
+            expect(response.headers['content-type']).toContain('image/png');
+        });
+
+        it('should handle errors', async () => {
+            jiraService.downloadAttachment.mockRejectedValue(new Error('Download failed'));
+
+            const response = await request(app)
+                .get('/api/issues/image/proxy')
+                .query({ url: 'https://example.com/image.png' });
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('GET /api/issues/:issueKey', () => {
+        it('should fetch issue details', async () => {
+            const mockIssue = { key: 'TEST-1', fields: { summary: 'Test' } };
+            jiraService.getIssueDetail.mockResolvedValue(mockIssue);
+
+            const response = await request(app).get('/api/issues/TEST-1');
+
+            expect(response.status).toBe(200);
+            expect(response.body.key).toBe('TEST-1');
+        });
+
+        it('should reject invalid issue key format', async () => {
+            const response = await request(app).get('/api/issues/invalid');
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toContain('Invalid issue key');
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.getIssueDetail.mockRejectedValue(new Error('Not found'));
+
+            const response = await request(app).get('/api/issues/TEST-1');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('GET /api/issues/:issueKey/comments', () => {
+        it('should fetch comments', async () => {
+            jiraService.getComments.mockResolvedValue([
+                { id: '1', body: { text: 'Comment' } }
+            ]);
+
+            const response = await request(app).get('/api/issues/TEST-1/comments');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveLength(1);
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app).get('/api/issues/invalid/comments');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.getComments.mockRejectedValue(new Error('API Error'));
+
+            const response = await request(app).get('/api/issues/TEST-1/comments');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('POST /api/issues/:issueKey/comments', () => {
+        it('should add comment', async () => {
+            jiraService.addComment.mockResolvedValue({ id: '100', body: {} });
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/comments')
+                .send({ body: 'New comment' });
+
+            expect(response.status).toBe(201);
+            expect(jiraService.addComment).toHaveBeenCalledWith('TEST-1', 'New comment');
+        });
+
+        it('should reject empty comment body', async () => {
+            const response = await request(app)
+                .post('/api/issues/TEST-1/comments')
+                .send({ body: '   ' });
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('Comment body cannot be empty');
+        });
+
+        it('should reject missing comment body', async () => {
+            const response = await request(app)
+                .post('/api/issues/TEST-1/comments')
+                .send({});
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app)
+                .post('/api/issues/invalid/comments')
+                .send({ body: 'Test' });
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.addComment.mockRejectedValue(new Error('Post failed'));
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/comments')
+                .send({ body: 'Comment' });
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('GET /api/issues/:issueKey/transitions', () => {
+        it('should fetch transitions', async () => {
+            jiraService.getTransitions.mockResolvedValue([
+                { id: '1', name: 'To Do' },
+                { id: '2', name: 'In Progress' }
+            ]);
+
+            const response = await request(app).get('/api/issues/TEST-1/transitions');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveLength(2);
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app).get('/api/issues/invalid/transitions');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.getTransitions.mockRejectedValue(new Error('API Error'));
+
+            const response = await request(app).get('/api/issues/TEST-1/transitions');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('POST /api/issues/:issueKey/transitions', () => {
+        it('should transition issue', async () => {
+            jiraService.transitionIssue.mockResolvedValue({ success: true });
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/transitions')
+                .send({ transitionId: '3' });
+
+            expect(response.status).toBe(200);
+            expect(response.body.success).toBe(true);
+        });
+
+        it('should reject missing transitionId', async () => {
+            const response = await request(app)
+                .post('/api/issues/TEST-1/transitions')
+                .send({});
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('transitionId is required');
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app)
+                .post('/api/issues/invalid/transitions')
+                .send({ transitionId: '1' });
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.transitionIssue.mockRejectedValue(new Error('Transition failed'));
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/transitions')
+                .send({ transitionId: '3' });
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('GET /api/issues/:issueKey/assignable', () => {
+        it('should fetch assignable users', async () => {
+            jiraService.getAssignableUsers.mockResolvedValue([
+                { accountId: '1', displayName: 'John' }
+            ]);
+
+            const response = await request(app).get('/api/issues/TEST-1/assignable');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toHaveLength(1);
+        });
+
+        it('should pass query parameter', async () => {
+            jiraService.getAssignableUsers.mockResolvedValue([]);
+
+            await request(app)
+                .get('/api/issues/TEST-1/assignable')
+                .query({ query: 'john' });
+
+            expect(jiraService.getAssignableUsers).toHaveBeenCalledWith('TEST-1', 'john');
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app).get('/api/issues/invalid/assignable');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.getAssignableUsers.mockRejectedValue(new Error('API Error'));
+
+            const response = await request(app).get('/api/issues/TEST-1/assignable');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('PUT /api/issues/:issueKey/assignee', () => {
+        it('should assign issue', async () => {
+            jiraService.assignIssue.mockResolvedValue({ success: true });
+
+            const response = await request(app)
+                .put('/api/issues/TEST-1/assignee')
+                .send({ accountId: 'user123' });
+
+            expect(response.status).toBe(200);
+            expect(jiraService.assignIssue).toHaveBeenCalledWith('TEST-1', 'user123');
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app)
+                .put('/api/issues/invalid/assignee')
+                .send({ accountId: 'user123' });
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.assignIssue.mockRejectedValue(new Error('Assign failed'));
+
+            const response = await request(app)
+                .put('/api/issues/TEST-1/assignee')
+                .send({ accountId: 'user123' });
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('POST /api/issues/:issueKey/attachments', () => {
+        it('should upload attachment', async () => {
+            jiraService.attachFile.mockResolvedValue([{ filename: 'test.pdf' }]);
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/attachments')
+                .attach('file', Buffer.from('test'), 'test.pdf');
+
+            expect(response.status).toBe(201);
+        });
+
+        it('should reject missing file', async () => {
+            const response = await request(app)
+                .post('/api/issues/TEST-1/attachments')
+                .field('other', 'data');
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('No file uploaded');
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app)
+                .post('/api/issues/invalid/attachments')
+                .attach('file', Buffer.from('test'), 'test.pdf');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.attachFile.mockRejectedValue(new Error('Upload failed'));
+
+            const response = await request(app)
+                .post('/api/issues/TEST-1/attachments')
+                .attach('file', Buffer.from('test'), 'test.pdf');
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('PUT /api/issues/:issueKey', () => {
+        it('should update issue fields', async () => {
+            jiraService.updateIssue.mockResolvedValue({ success: true });
+
+            const response = await request(app)
+                .put('/api/issues/TEST-1')
+                .send({ fields: { summary: 'Updated' } });
+
+            expect(response.status).toBe(200);
+            expect(response.body.success).toBe(true);
+        });
+
+        it('should reject missing fields', async () => {
+            const response = await request(app)
+                .put('/api/issues/TEST-1')
+                .send({});
+
+            expect(response.status).toBe(400);
+            expect(response.body.error).toBe('fields are required');
+        });
+
+        it('should validate issue key', async () => {
+            const response = await request(app)
+                .put('/api/issues/invalid')
+                .send({ fields: {} });
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should handle API errors', async () => {
+            jiraService.updateIssue.mockRejectedValue(new Error('Update failed'));
+
+            const response = await request(app)
+                .put('/api/issues/TEST-1')
+                .send({ fields: { summary: 'Test' } });
+
+            expect(response.status).toBe(500);
+        });
+    });
+
+    describe('Input Validation', () => {
+        it('should validate issue key with numbers', async () => {
+            const response = await request(app).get('/api/issues/TEST123');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should validate issue key with special chars', async () => {
+            const response = await request(app).get('/api/issues/TEST-1;DROP');
+
+            expect(response.status).toBe(400);
+        });
+
+        it('should accept valid issue keys', async () => {
+            jiraService.getIssueDetail.mockResolvedValue({ key: 'TEST-123' });
+
+            const response = await request(app).get('/api/issues/TEST-123');
+
+            expect(response.status).toBe(200);
+        });
+    });
+});