jira-datacenter-mcp 0.2.0

package/build/__tests__/jira-service.test.js

@@ -0,0 +1,1527 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { initializeRuntimeConfig } from 'datacenter-mcp-core';
+import { JiraService } from '../jira-service.js';
+import { AttachmentService, BacklogService, BoardService, ComponentService, DashboardService, EpicService, FilterService, GroupService, IssueLinkService, IssueLinkTypeService, IssueService, IssuetypeService, OpenAPI, PriorityService, ProjectService, ProjectsService, ResolutionService, SearchService, SprintService, StatusService, UserService, VersionService, } from '../jira-client/index.js';
+import { request as __request } from '../jira-client/core/request.js';
+jest.mock('../jira-client/core/request.js', () => ({
+    request: jest.fn(),
+}));
+jest.mock('../jira-client/index.js', () => ({
+    IssueService: {
+        getTransitions: jest.fn(),
+        doTransition: jest.fn(),
+        getIssue: jest.fn(),
+        editIssue: jest.fn(),
+        createIssue: jest.fn(),
+        getComments: jest.fn(),
+        addComment: jest.fn(),
+        getCreateIssueMetaProjectIssueTypes: jest.fn(),
+        getCreateIssueMetaFields: jest.fn(),
+        getEditIssueMeta: jest.fn(),
+        deleteIssue: jest.fn(),
+        updateComment: jest.fn(),
+        deleteComment: jest.fn(),
+        getIssueWatchers: jest.fn(),
+        addWatcher1: jest.fn(),
+        removeWatcher1: jest.fn(),
+        getVotes: jest.fn(),
+        addVote: jest.fn(),
+        removeVote: jest.fn(),
+        getIssueWorklog: jest.fn(),
+        addWorklog: jest.fn(),
+        getWorklog: jest.fn(),
+        updateWorklog: jest.fn(),
+        deleteWorklog: jest.fn(),
+        addAttachment: jest.fn(),
+        assign: jest.fn(),
+        createIssues: jest.fn(),
+        archiveIssues: jest.fn(),
+        archiveIssue: jest.fn(),
+        rankIssues: jest.fn(),
+    },
+    AttachmentService: {
+        getAttachmentMeta: jest.fn(),
+        getAttachment: jest.fn(),
+        removeAttachment: jest.fn(),
+    },
+    IssueLinkService: {
+        linkIssues: jest.fn(),
+        getIssueLink: jest.fn(),
+        deleteIssueLink: jest.fn(),
+    },
+    IssueLinkTypeService: {
+        getIssueLinkTypes: jest.fn(),
+        createIssueLinkType: jest.fn(),
+        updateIssueLinkType: jest.fn(),
+        deleteIssueLinkType: jest.fn(),
+    },
+    BoardService: {
+        getAllBoards: jest.fn(),
+        getBoard: jest.fn(),
+        getConfiguration: jest.fn(),
+        getIssuesForBoard: jest.fn(),
+        getAllSprints: jest.fn(),
+        getAllVersions: jest.fn(),
+        getIssuesForBacklog: jest.fn(),
+        getEpics: jest.fn(),
+        getIssuesWithoutEpic: jest.fn(),
+        getIssuesForEpic: jest.fn(),
+    },
+    BacklogService: {
+        moveIssuesToBacklog: jest.fn(),
+    },
+    SprintService: {
+        createSprint: jest.fn(),
+        getSprint: jest.fn(),
+        updateSprint: jest.fn(),
+        deleteSprint: jest.fn(),
+        getIssuesForSprint1: jest.fn(),
+        moveIssuesToSprint: jest.fn(),
+    },
+    EpicService: {
+        getEpic: jest.fn(),
+        partiallyUpdateEpic: jest.fn(),
+        getIssuesForEpic1: jest.fn(),
+        moveIssuesToEpic: jest.fn(),
+        rankEpics: jest.fn(),
+    },
+    ComponentService: {
+        createComponent: jest.fn(),
+        getPaginatedComponents: jest.fn(),
+        getComponent: jest.fn(),
+        updateComponent: jest.fn(),
+        delete: jest.fn(),
+        getComponentRelatedIssues: jest.fn(),
+    },
+    FilterService: {
+        createFilter: jest.fn(),
+        getFilter: jest.fn(),
+        editFilter: jest.fn(),
+        deleteFilter: jest.fn(),
+        getFavouriteFilters: jest.fn(),
+    },
+    DashboardService: {
+        list: jest.fn(),
+        getDashboard: jest.fn(),
+    },
+    UserService: {
+        getUser1: jest.fn(),
+        findUsers: jest.fn(),
+        findAssignableUsers1: jest.fn(),
+    },
+    GroupService: {
+        createGroup: jest.fn(),
+        removeGroup: jest.fn(),
+        getUsersFromGroup: jest.fn(),
+        addUserToGroup: jest.fn(),
+        removeUserFromGroup: jest.fn(),
+    },
+    VersionService: {
+        createVersion: jest.fn(),
+        getPaginatedVersions: jest.fn(),
+        getVersion: jest.fn(),
+        updateVersion: jest.fn(),
+        delete1: jest.fn(),
+        merge: jest.fn(),
+        moveVersion: jest.fn(),
+        getVersionRelatedIssues: jest.fn(),
+        getVersionUnresolvedIssues: jest.fn(),
+    },
+    SearchService: {
+        searchUsingSearchRequest: jest.fn(),
+    },
+    ProjectService: {
+        getAllProjects: jest.fn(),
+        getProject: jest.fn(),
+        getProjectComponents: jest.fn(),
+        getProjectVersions: jest.fn(),
+        getProjectRoles: jest.fn(),
+        getProjectRole: jest.fn(),
+        setActors: jest.fn(),
+        addActorUsers: jest.fn(),
+        deleteActor: jest.fn(),
+    },
+    ProjectsService: {
+        searchForProjects: jest.fn(),
+    },
+    IssuetypeService: {
+        getIssueAllTypes: jest.fn(),
+    },
+    PriorityService: {
+        getPriorities: jest.fn(),
+    },
+    ResolutionService: {
+        getResolutions: jest.fn(),
+    },
+    StatusService: {
+        getStatuses: jest.fn(),
+    },
+    OpenAPI: {
+        BASE: '',
+        TOKEN: '',
+        VERSION: '',
+    },
+}));
+describe('JiraService', () => {
+    let jiraService;
+    const mockIssueKey = 'PROJ-123';
+    beforeEach(() => {
+        jiraService = new JiraService('test-host', 'test-token', undefined, () => 25);
+        jest.clearAllMocks();
+    });
+    describe('getTransitions', () => {
+        it('should successfully get available transitions for an issue', async () => {
+            const mockTransitionsData = {
+                transitions: [
+                    {
+                        id: '21',
+                        name: 'Start Progress',
+                        to: {
+                            id: '3',
+                            name: 'In Progress',
+                            statusCategory: { name: 'In Progress' },
+                        },
+                    },
+                    {
+                        id: '31',
+                        name: 'Done',
+                        to: {
+                            id: '4',
+                            name: 'Done',
+                            statusCategory: { name: 'Done' },
+                        },
+                    },
+                ],
+            };
+            IssueService.getTransitions.mockResolvedValue(mockTransitionsData);
+            const result = await jiraService.getTransitions(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTransitionsData);
+            expect(IssueService.getTransitions).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('should return empty transitions array when no transitions available', async () => {
+            const mockTransitionsData = {
+                transitions: [],
+            };
+            IssueService.getTransitions.mockResolvedValue(mockTransitionsData);
+            const result = await jiraService.getTransitions(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTransitionsData);
+            expect(result.data?.transitions).toHaveLength(0);
+        });
+        it('should handle API errors gracefully', async () => {
+            const mockError = new Error('Issue not found');
+            IssueService.getTransitions.mockRejectedValue(mockError);
+            const result = await jiraService.getTransitions(mockIssueKey);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Issue not found');
+        });
+        it('should handle permission errors', async () => {
+            const mockError = new Error('Insufficient permissions to view transitions');
+            IssueService.getTransitions.mockRejectedValue(mockError);
+            const result = await jiraService.getTransitions('RESTRICTED-1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Insufficient permissions to view transitions');
+        });
+    });
+    describe('token optimization paths', () => {
+        it('uses the default field profile and page size for search', async () => {
+            const mockSearchResults = { issues: [] };
+            SearchService.searchUsingSearchRequest.mockResolvedValue(mockSearchResults);
+            const result = await jiraService.searchIssues('project = TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockSearchResults);
+            expect(SearchService.searchUsingSearchRequest).toHaveBeenCalledWith({
+                jql: 'project = TEST',
+                maxResults: 25,
+                fields: ['summary', 'description', 'status', 'assignee', 'reporter', 'priority', 'issuetype', 'labels', 'updated'],
+                expand: undefined,
+                startAt: undefined,
+            });
+        });
+        it('honors explicit search fields and maxResults', async () => {
+            const mockSearchResults = { issues: [] };
+            SearchService.searchUsingSearchRequest.mockResolvedValue(mockSearchResults);
+            await jiraService.searchIssues('project = TEST', 20, ['changelog'], 5, ['summary', 'status']);
+            expect(SearchService.searchUsingSearchRequest).toHaveBeenCalledWith({
+                jql: 'project = TEST',
+                maxResults: 5,
+                fields: ['summary', 'status'],
+                expand: ['changelog'],
+                startAt: 20,
+            });
+        });
+        it('uses the richer default field profile for single issue reads', async () => {
+            const mockIssue = { key: mockIssueKey };
+            IssueService.getIssue.mockResolvedValue(mockIssue);
+            const result = await jiraService.getIssue(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssue);
+            expect(IssueService.getIssue).toHaveBeenCalledWith(mockIssueKey, undefined, [
+                'summary',
+                'description',
+                'status',
+                'assignee',
+                'reporter',
+                'priority',
+                'issuetype',
+                'labels',
+                'updated',
+                'parent',
+                'subtasks',
+            ]);
+        });
+        it('honors explicit issue fields', async () => {
+            IssueService.getIssue.mockResolvedValue({ key: mockIssueKey });
+            await jiraService.getIssue(mockIssueKey, 'renderedFields', ['summary', 'status']);
+            expect(IssueService.getIssue).toHaveBeenCalledWith(mockIssueKey, 'renderedFields', ['summary', 'status']);
+        });
+        it('uses the package default page size for issue comments', async () => {
+            const mockComments = { comments: [] };
+            IssueService.getComments.mockResolvedValue(mockComments);
+            const result = await jiraService.getIssueComments(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComments);
+            expect(IssueService.getComments).toHaveBeenCalledWith(mockIssueKey, undefined, '25', undefined, undefined);
+        });
+        it('forwards explicit issue comment pagination', async () => {
+            IssueService.getComments.mockResolvedValue({ comments: [] });
+            await jiraService.getIssueComments(mockIssueKey, 'renderedBody', 10, 20);
+            expect(IssueService.getComments).toHaveBeenCalledWith(mockIssueKey, 'renderedBody', '10', undefined, '20');
+        });
+    });
+    describe('getIssueDevelopmentInfo', () => {
+        it('resolves the numeric issue id then requests pull requests by default', async () => {
+            const mockDevInfo = { detail: [{ pullRequests: [] }] };
+            IssueService.getIssue.mockResolvedValue({ id: '1314681', key: mockIssueKey });
+            __request.mockResolvedValue(mockDevInfo);
+            const result = await jiraService.getIssueDevelopmentInfo(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockDevInfo);
+            expect(IssueService.getIssue).toHaveBeenCalledWith(mockIssueKey, undefined, ['id']);
+            expect(__request).toHaveBeenCalledWith(OpenAPI, {
+                method: 'GET',
+                url: '/dev-status/1.0/issue/detail',
+                query: { issueId: '1314681', applicationType: 'stash', dataType: 'pullrequest' },
+            });
+        });
+        it('honors explicit dataType and applicationType', async () => {
+            IssueService.getIssue.mockResolvedValue({ id: '42' });
+            __request.mockResolvedValue({});
+            await jiraService.getIssueDevelopmentInfo(mockIssueKey, 'repository', 'github');
+            expect(__request).toHaveBeenCalledWith(OpenAPI, {
+                method: 'GET',
+                url: '/dev-status/1.0/issue/detail',
+                query: { issueId: '42', applicationType: 'github', dataType: 'repository' },
+            });
+        });
+        it('fails without calling dev-status when the numeric id is missing', async () => {
+            IssueService.getIssue.mockResolvedValue({ key: mockIssueKey });
+            const result = await jiraService.getIssueDevelopmentInfo(mockIssueKey);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe(`Could not resolve numeric id for issue ${mockIssueKey}`);
+            expect(__request).not.toHaveBeenCalled();
+        });
+        it('surfaces dev-status request errors', async () => {
+            IssueService.getIssue.mockResolvedValue({ id: '1314681' });
+            __request.mockRejectedValue(new Error('View Development Tools permission required'));
+            const result = await jiraService.getIssueDevelopmentInfo(mockIssueKey);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('View Development Tools permission required');
+        });
+    });
+    describe('transitionIssue', () => {
+        it('should successfully transition an issue to a new status', async () => {
+            IssueService.doTransition.mockResolvedValue(undefined);
+            const result = await jiraService.transitionIssue({
+                issueKey: mockIssueKey,
+                transitionId: '21',
+            });
+            expect(result.success).toBe(true);
+            expect(IssueService.doTransition).toHaveBeenCalledWith(mockIssueKey, {
+                transition: { id: '21' },
+            });
+        });
+        it('should successfully transition with additional fields', async () => {
+            IssueService.doTransition.mockResolvedValue(undefined);
+            const result = await jiraService.transitionIssue({
+                issueKey: mockIssueKey,
+                transitionId: '31',
+                fields: {
+                    resolution: { name: 'Done' },
+                    comment: { body: 'Closing this issue' },
+                },
+            });
+            expect(result.success).toBe(true);
+            expect(IssueService.doTransition).toHaveBeenCalledWith(mockIssueKey, {
+                transition: { id: '31' },
+                fields: {
+                    resolution: { name: 'Done' },
+                    comment: { body: 'Closing this issue' },
+                },
+            });
+        });
+        it('should handle invalid transition ID errors', async () => {
+            const mockError = new Error('Invalid transition ID');
+            IssueService.doTransition.mockRejectedValue(mockError);
+            const result = await jiraService.transitionIssue({
+                issueKey: mockIssueKey,
+                transitionId: '999',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Invalid transition ID');
+        });
+        it('should handle missing required fields errors', async () => {
+            const mockError = new Error('Resolution field is required');
+            IssueService.doTransition.mockRejectedValue(mockError);
+            const result = await jiraService.transitionIssue({
+                issueKey: mockIssueKey,
+                transitionId: '31',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Resolution field is required');
+        });
+        it('should handle permission errors', async () => {
+            const mockError = new Error('User does not have permission to transition this issue');
+            IssueService.doTransition.mockRejectedValue(mockError);
+            const result = await jiraService.transitionIssue({
+                issueKey: 'RESTRICTED-1',
+                transitionId: '21',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('User does not have permission to transition this issue');
+        });
+        it('should handle issue not found errors', async () => {
+            const mockError = new Error('Issue does not exist');
+            IssueService.doTransition.mockRejectedValue(mockError);
+            const result = await jiraService.transitionIssue({
+                issueKey: 'NONEXISTENT-999',
+                transitionId: '21',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Issue does not exist');
+        });
+    });
+    describe('getProjects', () => {
+        it('gets all visible projects', async () => {
+            const mockProjects = [{ key: 'TEST' }];
+            ProjectService.getAllProjects.mockResolvedValue(mockProjects);
+            const result = await jiraService.getProjects();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockProjects);
+            expect(ProjectService.getAllProjects).toHaveBeenCalledWith(undefined, undefined, undefined);
+        });
+        it('forwards includeArchived, expand, and recent', async () => {
+            ProjectService.getAllProjects.mockResolvedValue([]);
+            await jiraService.getProjects(true, 'lead', 5);
+            expect(ProjectService.getAllProjects).toHaveBeenCalledWith(true, 'lead', 5);
+        });
+        it('handles API errors', async () => {
+            ProjectService.getAllProjects.mockRejectedValue(new Error('Not authenticated'));
+            const result = await jiraService.getProjects();
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Not authenticated');
+        });
+    });
+    describe('searchProjects', () => {
+        it('searches projects by query', async () => {
+            const mockResult = { total: 1 };
+            ProjectsService.searchForProjects.mockResolvedValue(mockResult);
+            const result = await jiraService.searchProjects('TES');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockResult);
+            expect(ProjectsService.searchForProjects).toHaveBeenCalledWith(undefined, 'TES', undefined);
+        });
+    });
+    describe('getProject', () => {
+        it('gets a single project by id or key', async () => {
+            const mockProject = { key: 'TEST' };
+            ProjectService.getProject.mockResolvedValue(mockProject);
+            const result = await jiraService.getProject('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockProject);
+            expect(ProjectService.getProject).toHaveBeenCalledWith('TEST', undefined);
+        });
+        it('handles project not found errors', async () => {
+            ProjectService.getProject.mockRejectedValue(new Error('Project not found'));
+            const result = await jiraService.getProject('MISSING');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Project not found');
+        });
+    });
+    describe('getProjectComponents', () => {
+        it('gets project components', async () => {
+            const mockComponents = [{ name: 'Backend' }];
+            ProjectService.getProjectComponents.mockResolvedValue(mockComponents);
+            const result = await jiraService.getProjectComponents('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComponents);
+            expect(ProjectService.getProjectComponents).toHaveBeenCalledWith('TEST');
+        });
+    });
+    describe('getProjectVersions', () => {
+        it('gets project versions', async () => {
+            const mockVersions = [{ name: '1.0' }];
+            ProjectService.getProjectVersions.mockResolvedValue(mockVersions);
+            const result = await jiraService.getProjectVersions('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVersions);
+            expect(ProjectService.getProjectVersions).toHaveBeenCalledWith('TEST', undefined);
+        });
+    });
+    describe('reference data lookups', () => {
+        it('gets issue types', async () => {
+            const mockTypes = [{ name: 'Bug' }];
+            IssuetypeService.getIssueAllTypes.mockResolvedValue(mockTypes);
+            const result = await jiraService.getIssueTypes();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTypes);
+        });
+        it('gets priorities', async () => {
+            const mockPriorities = [{ name: 'High' }];
+            PriorityService.getPriorities.mockResolvedValue(mockPriorities);
+            const result = await jiraService.getPriorities();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPriorities);
+        });
+        it('gets resolutions', async () => {
+            const mockResolutions = [{ name: 'Fixed' }];
+            ResolutionService.getResolutions.mockResolvedValue(mockResolutions);
+            const result = await jiraService.getResolutions();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockResolutions);
+        });
+        it('gets statuses', async () => {
+            const mockStatuses = [{ name: 'Open' }];
+            StatusService.getStatuses.mockResolvedValue(mockStatuses);
+            const result = await jiraService.getStatuses();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockStatuses);
+        });
+    });
+    describe('getCreateIssueMetaIssueTypes', () => {
+        it('gets issue types available for creating an issue', async () => {
+            const mockTypes = { values: [{ id: '10001', name: 'Bug' }] };
+            IssueService.getCreateIssueMetaProjectIssueTypes.mockResolvedValue(mockTypes);
+            const result = await jiraService.getCreateIssueMetaIssueTypes('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTypes);
+            expect(IssueService.getCreateIssueMetaProjectIssueTypes).toHaveBeenCalledWith('TEST', undefined, undefined);
+        });
+        it('forwards pagination as strings', async () => {
+            IssueService.getCreateIssueMetaProjectIssueTypes.mockResolvedValue({});
+            await jiraService.getCreateIssueMetaIssueTypes('TEST', 10, 5);
+            expect(IssueService.getCreateIssueMetaProjectIssueTypes).toHaveBeenCalledWith('TEST', '10', '5');
+        });
+    });
+    describe('getCreateIssueMetaFields', () => {
+        it('gets fields available for creating an issue of a given type', async () => {
+            const mockFields = { values: [{ fieldId: 'summary', required: true }] };
+            IssueService.getCreateIssueMetaFields.mockResolvedValue(mockFields);
+            const result = await jiraService.getCreateIssueMetaFields('TEST', '10001');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockFields);
+            expect(IssueService.getCreateIssueMetaFields).toHaveBeenCalledWith('10001', 'TEST', undefined, undefined);
+        });
+    });
+    describe('getEditIssueMeta', () => {
+        it('gets fields available for editing an issue', async () => {
+            const mockMeta = { fields: { summary: { required: true } } };
+            IssueService.getEditIssueMeta.mockResolvedValue(mockMeta);
+            const result = await jiraService.getEditIssueMeta(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockMeta);
+            expect(IssueService.getEditIssueMeta).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('handles permission errors', async () => {
+            IssueService.getEditIssueMeta.mockRejectedValue(new Error('Issue does not exist'));
+            const result = await jiraService.getEditIssueMeta('MISSING-1');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Issue does not exist');
+        });
+    });
+    describe('deleteIssue', () => {
+        it('deletes an issue', async () => {
+            IssueService.deleteIssue.mockResolvedValue(undefined);
+            const result = await jiraService.deleteIssue(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(IssueService.deleteIssue).toHaveBeenCalledWith(mockIssueKey, undefined);
+        });
+        it('forwards deleteSubtasks as a string', async () => {
+            IssueService.deleteIssue.mockResolvedValue(undefined);
+            await jiraService.deleteIssue(mockIssueKey, true);
+            expect(IssueService.deleteIssue).toHaveBeenCalledWith(mockIssueKey, 'true');
+        });
+        it('handles permission errors', async () => {
+            IssueService.deleteIssue.mockRejectedValue(new Error('User does not have permission to delete this issue'));
+            const result = await jiraService.deleteIssue(mockIssueKey);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('User does not have permission to delete this issue');
+        });
+    });
+    describe('updateIssueComment', () => {
+        it('updates a comment', async () => {
+            const mockComment = { id: '10000', body: 'Updated text' };
+            IssueService.updateComment.mockResolvedValue(mockComment);
+            const result = await jiraService.updateIssueComment(mockIssueKey, '10000', 'Updated text');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComment);
+            expect(IssueService.updateComment).toHaveBeenCalledWith(mockIssueKey, '10000', undefined, { body: 'Updated text' });
+        });
+        it('handles comment not found errors', async () => {
+            IssueService.updateComment.mockRejectedValue(new Error('Comment does not exist'));
+            const result = await jiraService.updateIssueComment(mockIssueKey, 'missing', 'text');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Comment does not exist');
+        });
+    });
+    describe('deleteIssueComment', () => {
+        it('deletes a comment', async () => {
+            IssueService.deleteComment.mockResolvedValue(undefined);
+            const result = await jiraService.deleteIssueComment(mockIssueKey, '10000');
+            expect(result.success).toBe(true);
+            expect(IssueService.deleteComment).toHaveBeenCalledWith(mockIssueKey, '10000');
+        });
+        it('handles permission errors', async () => {
+            IssueService.deleteComment.mockRejectedValue(new Error('User does not have permission to delete this comment'));
+            const result = await jiraService.deleteIssueComment(mockIssueKey, '10000');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('User does not have permission to delete this comment');
+        });
+    });
+    describe('watchers', () => {
+        it('gets issue watchers', async () => {
+            const mockWatchers = { watchCount: 1, watchers: [{ name: 'john.doe' }] };
+            IssueService.getIssueWatchers.mockResolvedValue(mockWatchers);
+            const result = await jiraService.getIssueWatchers(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockWatchers);
+            expect(IssueService.getIssueWatchers).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('adds a watcher', async () => {
+            IssueService.addWatcher1.mockResolvedValue(undefined);
+            const result = await jiraService.addIssueWatcher(mockIssueKey, 'john.doe');
+            expect(result.success).toBe(true);
+            expect(IssueService.addWatcher1).toHaveBeenCalledWith(mockIssueKey, undefined, 'john.doe');
+        });
+        it('removes a watcher', async () => {
+            IssueService.removeWatcher1.mockResolvedValue(undefined);
+            const result = await jiraService.removeIssueWatcher(mockIssueKey, 'john.doe');
+            expect(result.success).toBe(true);
+            expect(IssueService.removeWatcher1).toHaveBeenCalledWith(mockIssueKey, 'john.doe');
+        });
+    });
+    describe('votes', () => {
+        it('gets issue votes', async () => {
+            const mockVotes = { votes: 3, hasVoted: false };
+            IssueService.getVotes.mockResolvedValue(mockVotes);
+            const result = await jiraService.getIssueVotes(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVotes);
+        });
+        it('adds a vote', async () => {
+            IssueService.addVote.mockResolvedValue(undefined);
+            const result = await jiraService.addIssueVote(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(IssueService.addVote).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('removes a vote', async () => {
+            IssueService.removeVote.mockResolvedValue(undefined);
+            const result = await jiraService.removeIssueVote(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(IssueService.removeVote).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('handles errors when voting is disabled', async () => {
+            IssueService.addVote.mockRejectedValue(new Error('Voting is disabled'));
+            const result = await jiraService.addIssueVote(mockIssueKey);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Voting is disabled');
+        });
+    });
+    describe('worklogs', () => {
+        it('gets all worklogs for an issue', async () => {
+            const mockWorklogs = { worklogs: [{ id: '100', timeSpent: '3h' }] };
+            IssueService.getIssueWorklog.mockResolvedValue(mockWorklogs);
+            const result = await jiraService.getIssueWorklogs(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockWorklogs);
+            expect(IssueService.getIssueWorklog).toHaveBeenCalledWith(mockIssueKey);
+        });
+        it('adds a worklog entry', async () => {
+            const mockWorklog = { id: '100', timeSpent: '3h' };
+            IssueService.addWorklog.mockResolvedValue(mockWorklog);
+            const result = await jiraService.addIssueWorklog(mockIssueKey, '3h', 'Fixed the bug');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockWorklog);
+            expect(IssueService.addWorklog).toHaveBeenCalledWith(mockIssueKey, undefined, undefined, undefined, {
+                timeSpent: '3h',
+                comment: 'Fixed the bug',
+                started: undefined,
+            });
+        });
+        it('gets a single worklog entry', async () => {
+            const mockWorklog = { id: '100', timeSpent: '3h' };
+            IssueService.getWorklog.mockResolvedValue(mockWorklog);
+            const result = await jiraService.getIssueWorklog(mockIssueKey, '100');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockWorklog);
+            expect(IssueService.getWorklog).toHaveBeenCalledWith(mockIssueKey, '100');
+        });
+        it('updates a worklog entry', async () => {
+            const mockWorklog = { id: '100', timeSpent: '4h' };
+            IssueService.updateWorklog.mockResolvedValue(mockWorklog);
+            const result = await jiraService.updateIssueWorklog(mockIssueKey, '100', '4h');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockWorklog);
+            expect(IssueService.updateWorklog).toHaveBeenCalledWith(mockIssueKey, '100', undefined, undefined, {
+                timeSpent: '4h',
+                comment: undefined,
+                started: undefined,
+            });
+        });
+        it('deletes a worklog entry', async () => {
+            IssueService.deleteWorklog.mockResolvedValue(undefined);
+            const result = await jiraService.deleteIssueWorklog(mockIssueKey, '100');
+            expect(result.success).toBe(true);
+            expect(IssueService.deleteWorklog).toHaveBeenCalledWith(mockIssueKey, '100');
+        });
+        it('handles errors', async () => {
+            IssueService.addWorklog.mockRejectedValue(new Error('Time tracking is disabled'));
+            const result = await jiraService.addIssueWorklog(mockIssueKey, '3h');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Time tracking is disabled');
+        });
+    });
+    describe('attachments', () => {
+        it('adds an attachment with the file wrapped as a File', async () => {
+            const mockAttachment = [{ id: '10001', filename: 'test.txt' }];
+            IssueService.addAttachment.mockResolvedValue(mockAttachment);
+            const result = await jiraService.addIssueAttachment(mockIssueKey, 'test.txt', Buffer.from('hello').toString('base64'));
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockAttachment);
+            const [calledIssueKey, calledFormData] = IssueService.addAttachment.mock.calls[0];
+            expect(calledIssueKey).toBe(mockIssueKey);
+            expect(calledFormData.file).toBeInstanceOf(File);
+            expect(calledFormData.file.name).toBe('test.txt');
+        });
+        it('gets attachment capabilities', async () => {
+            const mockMeta = { enabled: true, uploadLimit: 10485760 };
+            AttachmentService.getAttachmentMeta.mockResolvedValue(mockMeta);
+            const result = await jiraService.getAttachmentMeta();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockMeta);
+        });
+        it('gets attachment metadata by id', async () => {
+            const mockAttachment = { id: '10001', filename: 'test.txt' };
+            AttachmentService.getAttachment.mockResolvedValue(mockAttachment);
+            const result = await jiraService.getAttachment('10001');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockAttachment);
+            expect(AttachmentService.getAttachment).toHaveBeenCalledWith('10001');
+        });
+        it('deletes an attachment', async () => {
+            AttachmentService.removeAttachment.mockResolvedValue(undefined);
+            const result = await jiraService.deleteAttachment('10001');
+            expect(result.success).toBe(true);
+            expect(AttachmentService.removeAttachment).toHaveBeenCalledWith('10001');
+        });
+        it('handles errors when attachments are disabled', async () => {
+            IssueService.addAttachment.mockRejectedValue(new Error('Attachments are disabled'));
+            const result = await jiraService.addIssueAttachment(mockIssueKey, 'test.txt', 'aGVsbG8=');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Attachments are disabled');
+        });
+    });
+    describe('issue links', () => {
+        it('links two issues', async () => {
+            IssueLinkService.linkIssues.mockResolvedValue(undefined);
+            const result = await jiraService.linkIssues('PROJ-1', 'PROJ-2', 'Blocks');
+            expect(result.success).toBe(true);
+            expect(IssueLinkService.linkIssues).toHaveBeenCalledWith({
+                inwardIssue: { key: 'PROJ-1' },
+                outwardIssue: { key: 'PROJ-2' },
+                type: { name: 'Blocks' },
+            });
+        });
+        it('includes an optional comment', async () => {
+            IssueLinkService.linkIssues.mockResolvedValue(undefined);
+            await jiraService.linkIssues('PROJ-1', 'PROJ-2', 'Blocks', 'Linked during triage');
+            expect(IssueLinkService.linkIssues).toHaveBeenCalledWith({
+                inwardIssue: { key: 'PROJ-1' },
+                outwardIssue: { key: 'PROJ-2' },
+                type: { name: 'Blocks' },
+                comment: { body: 'Linked during triage' },
+            });
+        });
+        it('gets an issue link', async () => {
+            const mockLink = { id: '1000', type: { name: 'Blocks' } };
+            IssueLinkService.getIssueLink.mockResolvedValue(mockLink);
+            const result = await jiraService.getIssueLink('1000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockLink);
+            expect(IssueLinkService.getIssueLink).toHaveBeenCalledWith('1000');
+        });
+        it('deletes an issue link', async () => {
+            IssueLinkService.deleteIssueLink.mockResolvedValue(undefined);
+            const result = await jiraService.deleteIssueLink('1000');
+            expect(result.success).toBe(true);
+            expect(IssueLinkService.deleteIssueLink).toHaveBeenCalledWith('1000');
+        });
+        it('handles errors when the link type is unknown', async () => {
+            IssueLinkService.linkIssues.mockRejectedValue(new Error('Could not find issue link type'));
+            const result = await jiraService.linkIssues('PROJ-1', 'PROJ-2', 'NoSuchType');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Could not find issue link type');
+        });
+    });
+    describe('assignIssue', () => {
+        it('assigns an issue to a user', async () => {
+            IssueService.assign.mockResolvedValue(undefined);
+            const result = await jiraService.assignIssue(mockIssueKey, 'john.doe');
+            expect(result.success).toBe(true);
+            expect(IssueService.assign).toHaveBeenCalledWith(mockIssueKey, { name: 'john.doe' });
+        });
+        it('unassigns an issue when username is null', async () => {
+            IssueService.assign.mockResolvedValue(undefined);
+            const result = await jiraService.assignIssue(mockIssueKey, null);
+            expect(result.success).toBe(true);
+            expect(IssueService.assign).toHaveBeenCalledWith(mockIssueKey, { name: null });
+        });
+        it('handles permission errors', async () => {
+            IssueService.assign.mockRejectedValue(new Error('User does not have permission to assign the issue'));
+            const result = await jiraService.assignIssue(mockIssueKey, 'john.doe');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('User does not have permission to assign the issue');
+        });
+    });
+    describe('components', () => {
+        it('creates a component', async () => {
+            const mockComponent = { id: '10000', name: 'Backend' };
+            ComponentService.createComponent.mockResolvedValue(mockComponent);
+            const result = await jiraService.createComponent('TEST', 'Backend');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComponent);
+            expect(ComponentService.createComponent).toHaveBeenCalledWith({
+                project: 'TEST',
+                name: 'Backend',
+                description: undefined,
+                leadUserName: undefined,
+            });
+        });
+        it('gets paginated components', async () => {
+            const mockPage = { values: [{ name: 'Backend' }] };
+            ComponentService.getPaginatedComponents.mockResolvedValue(mockPage);
+            const result = await jiraService.getComponents();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPage);
+            expect(ComponentService.getPaginatedComponents).toHaveBeenCalledWith(undefined, undefined, undefined);
+        });
+        it('gets a single component', async () => {
+            const mockComponent = { id: '10000', name: 'Backend' };
+            ComponentService.getComponent.mockResolvedValue(mockComponent);
+            const result = await jiraService.getComponent('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComponent);
+            expect(ComponentService.getComponent).toHaveBeenCalledWith('10000');
+        });
+        it('updates a component', async () => {
+            const mockComponent = { id: '10000', name: 'Backend v2' };
+            ComponentService.updateComponent.mockResolvedValue(mockComponent);
+            const result = await jiraService.updateComponent('10000', 'Backend v2');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockComponent);
+            expect(ComponentService.updateComponent).toHaveBeenCalledWith('10000', {
+                name: 'Backend v2',
+                description: undefined,
+                leadUserName: undefined,
+            });
+        });
+        it('deletes a component', async () => {
+            ComponentService.delete.mockResolvedValue(undefined);
+            const result = await jiraService.deleteComponent('10000');
+            expect(result.success).toBe(true);
+            expect(ComponentService.delete).toHaveBeenCalledWith('10000', undefined);
+        });
+        it('gets component related issue counts', async () => {
+            const mockCounts = { issueCount: 5 };
+            ComponentService.getComponentRelatedIssues.mockResolvedValue(mockCounts);
+            const result = await jiraService.getComponentRelatedIssues('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCounts);
+        });
+    });
+    describe('versions', () => {
+        it('creates a version', async () => {
+            const mockVersion = { id: '10000', name: '1.0' };
+            VersionService.createVersion.mockResolvedValue(mockVersion);
+            const result = await jiraService.createVersion('TEST', '1.0');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVersion);
+            expect(VersionService.createVersion).toHaveBeenCalledWith({
+                project: 'TEST',
+                name: '1.0',
+                description: undefined,
+                releaseDate: undefined,
+                startDate: undefined,
+            });
+        });
+        it('gets paginated versions with defaults', async () => {
+            const mockPage = { values: [{ name: '1.0' }] };
+            VersionService.getPaginatedVersions.mockResolvedValue(mockPage);
+            const result = await jiraService.getVersions();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockPage);
+            expect(VersionService.getPaginatedVersions).toHaveBeenCalledWith(100, '', undefined, undefined);
+        });
+        it('gets a single version', async () => {
+            const mockVersion = { id: '10000', name: '1.0' };
+            VersionService.getVersion.mockResolvedValue(mockVersion);
+            const result = await jiraService.getVersion('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVersion);
+            expect(VersionService.getVersion).toHaveBeenCalledWith('10000', undefined);
+        });
+        it('updates a version', async () => {
+            VersionService.updateVersion.mockResolvedValue({ id: '10000', released: true });
+            const result = await jiraService.updateVersion('10000', undefined, undefined, true);
+            expect(result.success).toBe(true);
+            expect(VersionService.updateVersion).toHaveBeenCalledWith('10000', {
+                name: undefined,
+                description: undefined,
+                released: true,
+                archived: undefined,
+                releaseDate: undefined,
+            });
+        });
+        it('deletes and replaces a version', async () => {
+            VersionService.delete1.mockResolvedValue(undefined);
+            const result = await jiraService.deleteAndReplaceVersion('10000', 10001, 10002);
+            expect(result.success).toBe(true);
+            expect(VersionService.delete1).toHaveBeenCalledWith('10000', {
+                moveFixIssuesTo: 10001,
+                moveAffectedIssuesTo: 10002,
+            });
+        });
+        it('merges a version into another', async () => {
+            VersionService.merge.mockResolvedValue(undefined);
+            const result = await jiraService.mergeVersion('10000', '10001');
+            expect(result.success).toBe(true);
+            expect(VersionService.merge).toHaveBeenCalledWith('10001', '10000');
+        });
+        it('moves a version', async () => {
+            const mockVersion = { id: '10000' };
+            VersionService.moveVersion.mockResolvedValue(mockVersion);
+            const result = await jiraService.moveVersion('10000', 'First');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVersion);
+            expect(VersionService.moveVersion).toHaveBeenCalledWith('10000', { position: 'First', after: undefined });
+        });
+        it('gets version related issue counts', async () => {
+            const mockCounts = { issuesFixedCount: 3 };
+            VersionService.getVersionRelatedIssues.mockResolvedValue(mockCounts);
+            const result = await jiraService.getVersionRelatedIssues('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCounts);
+        });
+        it('gets version unresolved issue counts', async () => {
+            const mockCounts = { issuesUnresolvedCount: 1 };
+            VersionService.getVersionUnresolvedIssues.mockResolvedValue(mockCounts);
+            const result = await jiraService.getVersionUnresolvedIssues('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockCounts);
+        });
+        it('handles errors', async () => {
+            VersionService.getVersion.mockRejectedValue(new Error('Version does not exist'));
+            const result = await jiraService.getVersion('missing');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Version does not exist');
+        });
+    });
+    describe('project roles', () => {
+        it('gets project roles', async () => {
+            const mockRoles = { Developers: 'https://jira/rest/api/2/project/TEST/role/10000' };
+            ProjectService.getProjectRoles.mockResolvedValue(mockRoles);
+            const result = await jiraService.getProjectRoles('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockRoles);
+            expect(ProjectService.getProjectRoles).toHaveBeenCalledWith('TEST');
+        });
+        it('gets a single project role', async () => {
+            const mockRole = { id: 10000, name: 'Developers', actors: [] };
+            ProjectService.getProjectRole.mockResolvedValue(mockRole);
+            const result = await jiraService.getProjectRole('TEST', 10000);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockRole);
+            expect(ProjectService.getProjectRole).toHaveBeenCalledWith('TEST', 10000);
+        });
+        it('replaces all actors for a role', async () => {
+            const mockRole = { id: 10000, name: 'Developers' };
+            ProjectService.setActors.mockResolvedValue(mockRole);
+            const result = await jiraService.setProjectRoleActors('TEST', 10000, { 'atlassian-user-role-actor': ['john.doe'] });
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockRole);
+            expect(ProjectService.setActors).toHaveBeenCalledWith('TEST', 10000, {
+                categorisedActors: { 'atlassian-user-role-actor': ['john.doe'] },
+                id: 10000,
+            });
+        });
+        it('adds actors to a role', async () => {
+            const mockRole = { id: 10000, name: 'Developers' };
+            ProjectService.addActorUsers.mockResolvedValue(mockRole);
+            const result = await jiraService.addProjectRoleActors('TEST', 10000, ['john.doe'], ['admins']);
+            expect(result.success).toBe(true);
+            expect(ProjectService.addActorUsers).toHaveBeenCalledWith('TEST', 10000, {
+                user: ['john.doe'],
+                group: ['admins'],
+            });
+        });
+        it('deletes an actor from a role', async () => {
+            ProjectService.deleteActor.mockResolvedValue(undefined);
+            const result = await jiraService.deleteProjectRoleActor('TEST', 10000, 'john.doe');
+            expect(result.success).toBe(true);
+            expect(ProjectService.deleteActor).toHaveBeenCalledWith('TEST', 10000, 'john.doe', undefined);
+        });
+        it('handles errors', async () => {
+            ProjectService.getProjectRole.mockRejectedValue(new Error('Project or role not found'));
+            const result = await jiraService.getProjectRole('TEST', 99999);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Project or role not found');
+        });
+    });
+    describe('users and groups', () => {
+        it('gets a user by username', async () => {
+            const mockUser = { name: 'john.doe', displayName: 'John Doe' };
+            UserService.getUser1.mockResolvedValue(mockUser);
+            const result = await jiraService.getUser('john.doe');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockUser);
+            expect(UserService.getUser1).toHaveBeenCalledWith(undefined, undefined, 'john.doe');
+        });
+        it('finds users by query', async () => {
+            const mockUsers = [{ name: 'john.doe' }];
+            UserService.findUsers.mockResolvedValue(mockUsers);
+            const result = await jiraService.findUsers('john');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockUsers);
+            expect(UserService.findUsers).toHaveBeenCalledWith(undefined, undefined, undefined, undefined, 'john');
+        });
+        it('finds assignable users for a project', async () => {
+            const mockUsers = [{ name: 'john.doe' }];
+            UserService.findAssignableUsers1.mockResolvedValue(mockUsers);
+            const result = await jiraService.findAssignableUsers('TEST');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockUsers);
+            expect(UserService.findAssignableUsers1).toHaveBeenCalledWith(undefined, 50, 'TEST', undefined, undefined);
+        });
+        it('creates a group', async () => {
+            const mockGroup = { name: 'developers' };
+            GroupService.createGroup.mockResolvedValue(mockGroup);
+            const result = await jiraService.createGroup('developers');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockGroup);
+            expect(GroupService.createGroup).toHaveBeenCalledWith({ name: 'developers' });
+        });
+        it('deletes a group', async () => {
+            GroupService.removeGroup.mockResolvedValue(undefined);
+            const result = await jiraService.deleteGroup('developers');
+            expect(result.success).toBe(true);
+            expect(GroupService.removeGroup).toHaveBeenCalledWith('developers', undefined);
+        });
+        it('gets group members', async () => {
+            const mockMembers = { values: [{ name: 'john.doe' }] };
+            GroupService.getUsersFromGroup.mockResolvedValue(mockMembers);
+            const result = await jiraService.getGroupUsers('developers');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockMembers);
+        });
+        it('adds a user to a group', async () => {
+            const mockGroup = { name: 'developers' };
+            GroupService.addUserToGroup.mockResolvedValue(mockGroup);
+            const result = await jiraService.addUserToGroup('developers', 'john.doe');
+            expect(result.success).toBe(true);
+            expect(GroupService.addUserToGroup).toHaveBeenCalledWith('developers', { name: 'john.doe' });
+        });
+        it('removes a user from a group', async () => {
+            GroupService.removeUserFromGroup.mockResolvedValue(undefined);
+            const result = await jiraService.removeUserFromGroup('developers', 'john.doe');
+            expect(result.success).toBe(true);
+            expect(GroupService.removeUserFromGroup).toHaveBeenCalledWith('developers', 'john.doe');
+        });
+        it('handles errors', async () => {
+            UserService.getUser1.mockRejectedValue(new Error('The requested user is not found'));
+            const result = await jiraService.getUser('missing');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The requested user is not found');
+        });
+    });
+    describe('filters', () => {
+        it('creates a filter', async () => {
+            const mockFilter = { id: '10000', name: 'My open issues' };
+            FilterService.createFilter.mockResolvedValue(mockFilter);
+            const result = await jiraService.createFilter('My open issues', 'assignee = currentUser() AND resolution = Unresolved');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockFilter);
+            expect(FilterService.createFilter).toHaveBeenCalledWith(undefined, {
+                name: 'My open issues',
+                jql: 'assignee = currentUser() AND resolution = Unresolved',
+                description: undefined,
+                favourite: undefined,
+            });
+        });
+        it('gets a filter', async () => {
+            const mockFilter = { id: '10000', name: 'My open issues' };
+            FilterService.getFilter.mockResolvedValue(mockFilter);
+            const result = await jiraService.getFilter('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockFilter);
+            expect(FilterService.getFilter).toHaveBeenCalledWith('10000', undefined);
+        });
+        it('updates a filter', async () => {
+            const mockFilter = { id: '10000', name: 'Renamed' };
+            FilterService.editFilter.mockResolvedValue(mockFilter);
+            const result = await jiraService.updateFilter('10000', 'Renamed');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockFilter);
+            expect(FilterService.editFilter).toHaveBeenCalledWith('10000', undefined, {
+                name: 'Renamed',
+                jql: undefined,
+                description: undefined,
+                favourite: undefined,
+            });
+        });
+        it('deletes a filter', async () => {
+            FilterService.deleteFilter.mockResolvedValue(undefined);
+            const result = await jiraService.deleteFilter('10000');
+            expect(result.success).toBe(true);
+            expect(FilterService.deleteFilter).toHaveBeenCalledWith('10000');
+        });
+        it('gets favourite filters', async () => {
+            const mockFilters = [{ id: '10000', name: 'My open issues' }];
+            FilterService.getFavouriteFilters.mockResolvedValue(mockFilters);
+            const result = await jiraService.getFavouriteFilters();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockFilters);
+        });
+        it('handles errors', async () => {
+            FilterService.createFilter.mockRejectedValue(new Error('Filter name was not provided'));
+            const result = await jiraService.createFilter('', '');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Filter name was not provided');
+        });
+    });
+    describe('dashboards', () => {
+        it('gets a list of dashboards', async () => {
+            const mockDashboards = { dashboards: [{ id: '10000', name: 'My Dashboard' }] };
+            DashboardService.list.mockResolvedValue(mockDashboards);
+            const result = await jiraService.getDashboards();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockDashboards);
+            expect(DashboardService.list).toHaveBeenCalledWith(undefined, undefined, undefined);
+        });
+        it('gets a single dashboard', async () => {
+            const mockDashboard = { id: '10000', name: 'My Dashboard' };
+            DashboardService.getDashboard.mockResolvedValue(mockDashboard);
+            const result = await jiraService.getDashboard('10000');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockDashboard);
+            expect(DashboardService.getDashboard).toHaveBeenCalledWith('10000');
+        });
+        it('handles errors', async () => {
+            DashboardService.getDashboard.mockRejectedValue(new Error('No dashboard with the specified id'));
+            const result = await jiraService.getDashboard('missing');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('No dashboard with the specified id');
+        });
+    });
+    describe('issue link types', () => {
+        it('gets issue link types', async () => {
+            const mockTypes = { issueLinkTypes: [{ id: '10000', name: 'Blocks' }] };
+            IssueLinkTypeService.getIssueLinkTypes.mockResolvedValue(mockTypes);
+            const result = await jiraService.getIssueLinkTypes();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockTypes);
+        });
+        it('creates an issue link type', async () => {
+            const mockType = { id: '10000', name: 'Blocks' };
+            IssueLinkTypeService.createIssueLinkType.mockResolvedValue(mockType);
+            const result = await jiraService.createIssueLinkType('Blocks', 'is blocked by', 'blocks');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockType);
+            expect(IssueLinkTypeService.createIssueLinkType).toHaveBeenCalledWith({
+                name: 'Blocks',
+                inward: 'is blocked by',
+                outward: 'blocks',
+            });
+        });
+        it('updates an issue link type', async () => {
+            const mockType = { id: '10000', name: 'Blocks v2' };
+            IssueLinkTypeService.updateIssueLinkType.mockResolvedValue(mockType);
+            const result = await jiraService.updateIssueLinkType('10000', 'Blocks v2');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockType);
+            expect(IssueLinkTypeService.updateIssueLinkType).toHaveBeenCalledWith('10000', {
+                name: 'Blocks v2',
+                inward: undefined,
+                outward: undefined,
+            });
+        });
+        it('deletes an issue link type', async () => {
+            IssueLinkTypeService.deleteIssueLinkType.mockResolvedValue(undefined);
+            const result = await jiraService.deleteIssueLinkType('10000');
+            expect(result.success).toBe(true);
+            expect(IssueLinkTypeService.deleteIssueLinkType).toHaveBeenCalledWith('10000');
+        });
+        it('handles errors', async () => {
+            IssueLinkTypeService.deleteIssueLinkType.mockRejectedValue(new Error('No issue link type with the given id exists'));
+            const result = await jiraService.deleteIssueLinkType('missing');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('No issue link type with the given id exists');
+        });
+    });
+    describe('bulk and rank operations', () => {
+        it('bulk creates issues', async () => {
+            const mockResponse = { issues: [{ id: '10001', key: 'PROJ-1' }] };
+            IssueService.createIssues.mockResolvedValue(mockResponse);
+            const result = await jiraService.createIssues([
+                { projectId: 'TEST', summary: 'First', description: 'desc', issueTypeId: '10001' },
+            ]);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockResponse);
+            expect(IssueService.createIssues).toHaveBeenCalledWith({
+                issueUpdates: [
+                    {
+                        fields: {
+                            project: { key: 'TEST' },
+                            summary: 'First',
+                            description: 'desc',
+                            issuetype: { id: '10001' },
+                        },
+                    },
+                ],
+            });
+        });
+        it('bulk archives issues by JQL', async () => {
+            IssueService.archiveIssues.mockResolvedValue({ numberOfIssuesUpdated: 3 });
+            const result = await jiraService.archiveIssues('project = TEST AND resolution = Fixed');
+            expect(result.success).toBe(true);
+            expect(IssueService.archiveIssues).toHaveBeenCalledWith(undefined, 'project = TEST AND resolution = Fixed');
+        });
+        it('archives a single issue', async () => {
+            IssueService.archiveIssue.mockResolvedValue(undefined);
+            const result = await jiraService.archiveIssue(mockIssueKey);
+            expect(result.success).toBe(true);
+            expect(IssueService.archiveIssue).toHaveBeenCalledWith(mockIssueKey, undefined);
+        });
+        it('ranks issues', async () => {
+            IssueService.rankIssues.mockResolvedValue({ success: true });
+            const result = await jiraService.rankIssues(['PROJ-1', 'PROJ-2'], 'PROJ-3');
+            expect(result.success).toBe(true);
+            expect(IssueService.rankIssues).toHaveBeenCalledWith({
+                issues: ['PROJ-1', 'PROJ-2'],
+                rankBeforeIssue: 'PROJ-3',
+                rankAfterIssue: undefined,
+                rankCustomFieldId: undefined,
+            });
+        });
+        it('handles errors', async () => {
+            IssueService.rankIssues.mockRejectedValue(new Error('User does not have permission to rank'));
+            const result = await jiraService.rankIssues(['PROJ-1']);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('User does not have permission to rank');
+        });
+    });
+    describe('agile boards', () => {
+        it('gets boards', async () => {
+            const mockBoards = { values: [{ id: 1, name: 'Scrum Board' }] };
+            BoardService.getAllBoards.mockResolvedValue(mockBoards);
+            const result = await jiraService.getBoards();
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBoards);
+            expect(BoardService.getAllBoards).toHaveBeenCalledWith(undefined, undefined, undefined, undefined, undefined);
+        });
+        it('gets a single board', async () => {
+            const mockBoard = { id: 1, name: 'Scrum Board' };
+            BoardService.getBoard.mockResolvedValue(mockBoard);
+            const result = await jiraService.getBoard(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockBoard);
+            expect(BoardService.getBoard).toHaveBeenCalledWith(1);
+        });
+        it('gets board configuration', async () => {
+            const mockConfig = { id: 1, columnConfig: {} };
+            BoardService.getConfiguration.mockResolvedValue(mockConfig);
+            const result = await jiraService.getBoardConfiguration(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockConfig);
+        });
+        it('gets board issues', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-1' }] };
+            BoardService.getIssuesForBoard.mockResolvedValue(mockIssues);
+            const result = await jiraService.getBoardIssues(1, 'status = Open');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+            expect(BoardService.getIssuesForBoard).toHaveBeenCalledWith(1, undefined, 'status = Open', undefined, undefined, undefined, undefined);
+        });
+        it('gets board sprints', async () => {
+            const mockSprints = { values: [{ id: 1, name: 'Sprint 1' }] };
+            BoardService.getAllSprints.mockResolvedValue(mockSprints);
+            const result = await jiraService.getBoardSprints(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockSprints);
+            expect(BoardService.getAllSprints).toHaveBeenCalledWith(1, undefined, undefined, undefined);
+        });
+        it('gets board versions', async () => {
+            const mockVersions = { values: [{ id: 1, name: '1.0' }] };
+            BoardService.getAllVersions.mockResolvedValue(mockVersions);
+            const result = await jiraService.getBoardVersions(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockVersions);
+        });
+        it('handles errors', async () => {
+            BoardService.getBoard.mockRejectedValue(new Error('The board does not exist'));
+            const result = await jiraService.getBoard(999);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The board does not exist');
+        });
+    });
+    describe('backlog and epics', () => {
+        it('gets board backlog issues', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-1' }] };
+            BoardService.getIssuesForBacklog.mockResolvedValue(mockIssues);
+            const result = await jiraService.getBoardBacklogIssues(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+            expect(BoardService.getIssuesForBacklog).toHaveBeenCalledWith(1, undefined, undefined, undefined, undefined, undefined, undefined);
+        });
+        it('gets board epics', async () => {
+            const mockEpics = { values: [{ id: 1, name: 'Epic 1' }] };
+            BoardService.getEpics.mockResolvedValue(mockEpics);
+            const result = await jiraService.getBoardEpics(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockEpics);
+            expect(BoardService.getEpics).toHaveBeenCalledWith(1, undefined, undefined, undefined);
+        });
+        it('gets board issues without an epic', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-2' }] };
+            BoardService.getIssuesWithoutEpic.mockResolvedValue(mockIssues);
+            const result = await jiraService.getBoardIssuesWithoutEpic(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+        });
+        it('gets board epic issues', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-3' }] };
+            BoardService.getIssuesForEpic.mockResolvedValue(mockIssues);
+            const result = await jiraService.getBoardEpicIssues(1, 10);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+            expect(BoardService.getIssuesForEpic).toHaveBeenCalledWith(10, 1, undefined, undefined, undefined, undefined, undefined, undefined);
+        });
+        it('moves issues to backlog', async () => {
+            BacklogService.moveIssuesToBacklog.mockResolvedValue(undefined);
+            const result = await jiraService.moveIssuesToBacklog(['PROJ-1', 'PROJ-2']);
+            expect(result.success).toBe(true);
+            expect(BacklogService.moveIssuesToBacklog).toHaveBeenCalledWith({ issues: ['PROJ-1', 'PROJ-2'] });
+        });
+        it('handles errors', async () => {
+            BacklogService.moveIssuesToBacklog.mockRejectedValue(new Error('Sprint does not exist'));
+            const result = await jiraService.moveIssuesToBacklog(['PROJ-1']);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Sprint does not exist');
+        });
+    });
+    describe('sprints', () => {
+        it('creates a sprint', async () => {
+            const mockSprint = { id: 1, name: 'Sprint 1' };
+            SprintService.createSprint.mockResolvedValue(mockSprint);
+            const result = await jiraService.createSprint('Sprint 1', 1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockSprint);
+            expect(SprintService.createSprint).toHaveBeenCalledWith({
+                name: 'Sprint 1',
+                originBoardId: 1,
+                startDate: undefined,
+                endDate: undefined,
+                goal: undefined,
+            });
+        });
+        it('gets a sprint', async () => {
+            const mockSprint = { id: 1, name: 'Sprint 1' };
+            SprintService.getSprint.mockResolvedValue(mockSprint);
+            const result = await jiraService.getSprint(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockSprint);
+            expect(SprintService.getSprint).toHaveBeenCalledWith(1);
+        });
+        it('updates a sprint to start it', async () => {
+            const mockSprint = { id: 1, state: 'active' };
+            SprintService.updateSprint.mockResolvedValue(mockSprint);
+            const result = await jiraService.updateSprint(1, undefined, undefined, undefined, undefined, 'active');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockSprint);
+            expect(SprintService.updateSprint).toHaveBeenCalledWith(1, {
+                name: undefined,
+                startDate: undefined,
+                endDate: undefined,
+                goal: undefined,
+                state: 'active',
+            });
+        });
+        it('deletes a sprint', async () => {
+            SprintService.deleteSprint.mockResolvedValue(undefined);
+            const result = await jiraService.deleteSprint(1);
+            expect(result.success).toBe(true);
+            expect(SprintService.deleteSprint).toHaveBeenCalledWith(1);
+        });
+        it('gets sprint issues', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-1' }] };
+            SprintService.getIssuesForSprint1.mockResolvedValue(mockIssues);
+            const result = await jiraService.getSprintIssues(1);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+            expect(SprintService.getIssuesForSprint1).toHaveBeenCalledWith(1, undefined, undefined, undefined, undefined, undefined, undefined);
+        });
+        it('moves issues into a sprint', async () => {
+            SprintService.moveIssuesToSprint.mockResolvedValue(undefined);
+            const result = await jiraService.moveIssuesToSprint(1, ['PROJ-1', 'PROJ-2']);
+            expect(result.success).toBe(true);
+            expect(SprintService.moveIssuesToSprint).toHaveBeenCalledWith(1, { issues: ['PROJ-1', 'PROJ-2'] });
+        });
+        it('handles errors', async () => {
+            SprintService.deleteSprint.mockRejectedValue(new Error('The sprint is active or completed'));
+            const result = await jiraService.deleteSprint(1);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The sprint is active or completed');
+        });
+    });
+    describe('epics', () => {
+        it('gets an epic', async () => {
+            const mockEpic = { id: 1, key: 'PROJ-1', name: 'Epic 1' };
+            EpicService.getEpic.mockResolvedValue(mockEpic);
+            const result = await jiraService.getEpic('PROJ-1');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockEpic);
+            expect(EpicService.getEpic).toHaveBeenCalledWith('PROJ-1');
+        });
+        it('updates an epic', async () => {
+            const mockEpic = { id: 1, done: true };
+            EpicService.partiallyUpdateEpic.mockResolvedValue(mockEpic);
+            const result = await jiraService.updateEpic('PROJ-1', undefined, undefined, true);
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockEpic);
+            expect(EpicService.partiallyUpdateEpic).toHaveBeenCalledWith('PROJ-1', {
+                name: undefined,
+                summary: undefined,
+                done: true,
+            });
+        });
+        it('gets epic issues', async () => {
+            const mockIssues = { issues: [{ key: 'PROJ-2' }] };
+            EpicService.getIssuesForEpic1.mockResolvedValue(mockIssues);
+            const result = await jiraService.getEpicIssues('PROJ-1');
+            expect(result.success).toBe(true);
+            expect(result.data).toBe(mockIssues);
+            expect(EpicService.getIssuesForEpic1).toHaveBeenCalledWith('PROJ-1', undefined, undefined, undefined, undefined, undefined, undefined);
+        });
+        it('moves issues into an epic', async () => {
+            EpicService.moveIssuesToEpic.mockResolvedValue(undefined);
+            const result = await jiraService.moveIssuesToEpic('PROJ-1', ['PROJ-2', 'PROJ-3']);
+            expect(result.success).toBe(true);
+            expect(EpicService.moveIssuesToEpic).toHaveBeenCalledWith('PROJ-1', { issues: ['PROJ-2', 'PROJ-3'] });
+        });
+        it('ranks an epic', async () => {
+            EpicService.rankEpics.mockResolvedValue(undefined);
+            const result = await jiraService.rankEpic('PROJ-1', 'PROJ-4');
+            expect(result.success).toBe(true);
+            expect(EpicService.rankEpics).toHaveBeenCalledWith('PROJ-1', {
+                rankBeforeEpic: 'PROJ-4',
+                rankAfterEpic: undefined,
+                rankCustomFieldId: undefined,
+            });
+        });
+        it('handles errors', async () => {
+            EpicService.getEpic.mockRejectedValue(new Error('The epic does not exist'));
+            const result = await jiraService.getEpic('missing');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('The epic does not exist');
+        });
+    });
+    describe('constructor base URL resolution', () => {
+        it('builds BASE from host + default /rest when apiBasePath is missing', () => {
+            new JiraService('jira.example.com', 'test-token');
+            expect(OpenAPI.BASE).toBe('https://jira.example.com/rest');
+        });
+        it('strips accidentally-included /api/2 suffix from saved apiBasePath', () => {
+            new JiraService('jira.example.com', 'test-token', '/rest/api/2');
+            expect(OpenAPI.BASE).toBe('https://jira.example.com/rest');
+        });
+        it('accepts a fully-qualified apiBasePath as an override', () => {
+            new JiraService('ignored.example.com', 'test-token', 'https://real.example.com/rest');
+            expect(OpenAPI.BASE).toBe('https://real.example.com/rest');
+        });
+    });
+    describe('validateConfig', () => {
+        const originalEnv = process.env;
+        const originalPlatform = process.platform;
+        let tempDir;
+        let tempHome;
+        let homedirSpy;
+        beforeEach(() => {
+            process.env = { ...originalEnv };
+            delete process.env.ATLASSIAN_DC_MCP_CONFIG_FILE;
+            delete process.env.JIRA_API_TOKEN;
+            delete process.env.JIRA_HOST;
+            delete process.env.JIRA_API_BASE_PATH;
+            delete process.env.JIRA_DEFAULT_PAGE_SIZE;
+            tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'jira-validate-config-home-'));
+            homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tempHome);
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jira-validate-config-'));
+            initializeRuntimeConfig({ cwd: tempDir });
+        });
+        afterEach(() => {
+            homedirSpy.mockRestore();
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+            fs.rmSync(tempHome, { recursive: true, force: true });
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        });
+        afterAll(() => {
+            process.env = originalEnv;
+        });
+        it('should return empty array when all required env vars are present', () => {
+            process.env.JIRA_API_TOKEN = 'test-token';
+            process.env.JIRA_HOST = 'test-host';
+            const missingVars = JiraService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should allow anonymous access when JIRA_API_TOKEN is missing', () => {
+            delete process.env.JIRA_API_TOKEN;
+            process.env.JIRA_HOST = 'test-host';
+            const missingVars = JiraService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should return missing vars when both host options are missing', () => {
+            process.env.JIRA_API_TOKEN = 'test-token';
+            delete process.env.JIRA_HOST;
+            delete process.env.JIRA_API_BASE_PATH;
+            const missingVars = JiraService.validateConfig();
+            expect(missingVars).toContain('JIRA_HOST or JIRA_API_BASE_PATH');
+        });
+        it('should accept JIRA_API_BASE_PATH as alternative to JIRA_HOST', () => {
+            process.env.JIRA_API_TOKEN = 'test-token';
+            delete process.env.JIRA_HOST;
+            process.env.JIRA_API_BASE_PATH = 'https://test-host/rest';
+            const missingVars = JiraService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+        it('should accept required config from the shared config file', () => {
+            const sharedConfigPath = path.join(tempDir, 'shared.env');
+            fs.writeFileSync(sharedConfigPath, 'JIRA_HOST=file-host\nJIRA_API_TOKEN=file-token\n');
+            process.env.ATLASSIAN_DC_MCP_CONFIG_FILE = sharedConfigPath;
+            const missingVars = JiraService.validateConfig();
+            expect(missingVars).toEqual([]);
+        });
+    });
+});
+//# sourceMappingURL=jira-service.test.js.map