jira-pat 1.0.0

package/backend/__tests__/projects.test.js

@@ -0,0 +1,256 @@
+const express = require('express');
+const request = require('supertest');
+const projectsRouter = require('../routes/projects');
+
+jest.mock('../service/jiraService');
+const jiraService = require('../service/jiraService');
+
+const createApp = () => {
+    const app = express();
+    app.use(express.json());
+    app.use('/api/projects', projectsRouter);
+    return app;
+};
+
+describe('projects routes', () => {
+    let app;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        app = createApp();
+    });
+
+    describe('GET /api/projects', () => {
+        it('should fetch all projects', async () => {
+            const mockProjects = [
+                { key: 'TEST', name: 'Test Project', id: '100' },
+                { key: 'PROD', name: 'Production', id: '200' }
+            ];
+            jiraService.getProjects.mockResolvedValue(mockProjects);
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual(mockProjects);
+            expect(jiraService.getProjects).toHaveBeenCalledTimes(1);
+        });
+
+        it('should return empty array when no projects', async () => {
+            jiraService.getProjects.mockResolvedValue([]);
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual([]);
+        });
+
+        it('should handle Jira API errors', async () => {
+            jiraService.getProjects.mockRejectedValue(
+                new Error('Jira API Error: 403 - Forbidden')
+            );
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch projects');
+            expect(response.body.details).toContain('403');
+        });
+
+        it('should handle network errors', async () => {
+            jiraService.getProjects.mockRejectedValue(
+                new Error('connect ECONNREFUSED')
+            );
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(500);
+            expect(response.body.details).toContain('ECONNREFUSED');
+        });
+
+        it('should handle authentication errors', async () => {
+            jiraService.getProjects.mockRejectedValue(
+                new Error('Jira API Error: 401 - Unauthorized')
+            );
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch projects');
+        });
+    });
+
+    describe('GET /api/projects/:projectKey/issuetypes', () => {
+        it('should fetch issue types for project', async () => {
+            const mockTypes = [
+                { id: '1', name: 'Bug', description: 'Bug description' },
+                { id: '2', name: 'Story', description: 'Story description' },
+                { id: '3', name: 'Task', description: 'Task description' }
+            ];
+            jiraService.getIssueTypes.mockResolvedValue(mockTypes);
+
+            const response = await request(app)
+                .get('/api/projects/TEST/issuetypes');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual(mockTypes);
+            expect(jiraService.getIssueTypes).toHaveBeenCalledWith('TEST');
+        });
+
+        it('should return issue types with all properties', async () => {
+            const mockTypes = [
+                {
+                    id: '10001',
+                    name: 'Epic',
+                    description: 'An epic',
+                    iconUrl: 'https://example.com/icon.png',
+                    subtask: false
+                }
+            ];
+            jiraService.getIssueTypes.mockResolvedValue(mockTypes);
+
+            const response = await request(app)
+                .get('/api/projects/PROJ/issuetypes');
+
+            expect(response.status).toBe(200);
+            expect(response.body[0].name).toBe('Epic');
+            expect(response.body[0].subtask).toBe(false);
+        });
+
+        it('should handle Jira API errors', async () => {
+            jiraService.getIssueTypes.mockRejectedValue(
+                new Error('Project not found')
+            );
+
+            const response = await request(app)
+                .get('/api/projects/INVALID/issuetypes');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch issue types');
+        });
+
+        it('should pass project key to service', async () => {
+            jiraService.getIssueTypes.mockResolvedValue([]);
+
+            await request(app).get('/api/projects/MYPROJ/issuetypes');
+
+            expect(jiraService.getIssueTypes).toHaveBeenCalledWith('MYPROJ');
+        });
+    });
+
+    describe('GET /api/projects/:projectKey/versions', () => {
+        it('should fetch versions for project', async () => {
+            const mockVersions = [
+                { id: '1', name: 'v1.0.0', released: true },
+                { id: '2', name: 'v2.0.0', released: false },
+                { id: '3', name: 'v2.1.0', released: false }
+            ];
+            jiraService.getProjectVersions.mockResolvedValue(mockVersions);
+
+            const response = await request(app)
+                .get('/api/projects/TEST/versions');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual(mockVersions);
+            expect(jiraService.getProjectVersions).toHaveBeenCalledWith('TEST');
+        });
+
+        it('should return empty array when no versions', async () => {
+            jiraService.getProjectVersions.mockResolvedValue([]);
+
+            const response = await request(app)
+                .get('/api/projects/EMPTY/versions');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual([]);
+        });
+
+        it('should include version details', async () => {
+            const mockVersions = [
+                {
+                    id: '10000',
+                    name: 'Sprint 1',
+                    released: false,
+                    releaseDate: '2024-01-15',
+                    description: 'First sprint'
+                }
+            ];
+            jiraService.getProjectVersions.mockResolvedValue(mockVersions);
+
+            const response = await request(app)
+                .get('/api/projects/TEST/versions');
+
+            expect(response.body[0].releaseDate).toBe('2024-01-15');
+        });
+
+        it('should handle Jira API errors', async () => {
+            jiraService.getProjectVersions.mockRejectedValue(
+                new Error('Version API unavailable')
+            );
+
+            const response = await request(app)
+                .get('/api/projects/TEST/versions');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch versions');
+        });
+
+        it('should pass project key to service', async () => {
+            jiraService.getProjectVersions.mockResolvedValue([]);
+
+            await request(app).get('/api/projects/PROJ/versions');
+
+            expect(jiraService.getProjectVersions).toHaveBeenCalledWith('PROJ');
+        });
+    });
+
+    describe('Route parameter handling', () => {
+        it('should handle special characters in project key', async () => {
+            jiraService.getIssueTypes.mockResolvedValue([]);
+
+            const response = await request(app)
+                .get('/api/projects/TEST%2DPROJ/issuetypes');
+
+            expect(response.status).toBe(200);
+        });
+
+        it('should handle numeric project keys', async () => {
+            jiraService.getProjectVersions.mockResolvedValue([]);
+
+            const response = await request(app).get('/api/projects/12345/versions');
+            expect(response.status).toBe(200);
+        });
+    });
+
+    describe('Error handling', () => {
+        it('should handle service timeout errors', async () => {
+            const timeoutError = new Error('Request timeout');
+            timeoutError.code = 'ETIMEDOUT';
+            jiraService.getProjects.mockRejectedValue(timeoutError);
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch projects');
+        });
+
+        it('should handle connection refused errors', async () => {
+            const connError = new Error('connect ECONNREFUSED');
+            connError.code = 'ECONNREFUSED';
+            jiraService.getProjects.mockRejectedValue(connError);
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.status).toBe(500);
+            expect(response.body.details).toContain('ECONNREFUSED');
+        });
+
+        it('should return proper error structure', async () => {
+            jiraService.getProjects.mockRejectedValue(new Error('Test error'));
+
+            const response = await request(app).get('/api/projects');
+
+            expect(response.body).toHaveProperty('error');
+            expect(response.body).toHaveProperty('details');
+        });
+    });
+});