@uarlouski/testrail-mcp-server 1.1.0

package/test/client/testrail.test.ts

@@ -0,0 +1,357 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { TestRailClient } from '../../src/client/testrail.js';
+import axios, { AxiosInstance, AxiosError } from 'axios';
+
+describe('TestRailClient', () => {
+    let client: TestRailClient;
+    let mockAxiosInstance: any;
+
+    beforeEach(() => {
+        // Create a simple object mock for AxiosInstance to avoid complex mocking types
+        mockAxiosInstance = {
+            get: jest.fn(),
+            post: jest.fn(),
+            defaults: { headers: { common: {} } },
+            interceptors: { request: { use: jest.fn() }, response: { use: jest.fn() } }
+        };
+
+        // Mock axios.create to return our mock instance - using type casting to bypass TS warnings
+        jest.spyOn(axios, 'create').mockReturnValue(mockAxiosInstance);
+
+        // Pass the mock instance directly to constructor
+        client = new TestRailClient('https://testrail.io/', 'user', 'apikey');
+    });
+
+    test('constructor cleans trailing slash from baseUrl', async () => {
+        const mockData = { id: 1, title: 'Test Case', template_id: 1 };
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        await client.getCase('1');
+
+        // Verify axios.create was called with cleaned URL (no trailing slash)
+        expect(axios.create).toHaveBeenCalledWith(expect.objectContaining({
+            baseURL: 'https://testrail.io'
+        }));
+    });
+
+    test('validateStatus returns true for 2xx status codes', () => {
+        // Get the config passed to axios.create
+        const createCall = (axios.create as jest.Mock).mock.calls[0][0] as { validateStatus: (status: number) => boolean };
+        const validateStatus = createCall.validateStatus;
+
+        expect(validateStatus(200)).toBe(true);
+        expect(validateStatus(201)).toBe(true);
+        expect(validateStatus(299)).toBe(true);
+    });
+
+    test('validateStatus returns false for non-2xx status codes', () => {
+        // Get the config passed to axios.create
+        const createCall = (axios.create as jest.Mock).mock.calls[0][0] as { validateStatus: (status: number) => boolean };
+        const validateStatus = createCall.validateStatus;
+
+        expect(validateStatus(199)).toBe(false);
+        expect(validateStatus(300)).toBe(false);
+        expect(validateStatus(400)).toBe(false);
+        expect(validateStatus(500)).toBe(false);
+    });
+
+    test('getCase returns data on success', async () => {
+        const mockData = { id: 1, title: 'Test Case', template_id: 1 };
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getCase('1');
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_case/1');
+    });
+
+    test('getCase throws formatted error on API error', async () => {
+        const mockError = {
+            message: 'Request failed',
+            response: {
+                status: 404,
+                statusText: 'Not Found',
+                data: { error: 'Case not found' }
+            },
+            isAxiosError: true,
+            toJSON: () => ({})
+        };
+
+        mockAxiosInstance.get.mockRejectedValue(mockError);
+
+        await expect(client.getCase('999')).rejects.toThrow(
+            'TestRail API error: 404 Not Found - {"error":"Case not found"}'
+        );
+    });
+
+    test('getCases returns cases without pagination', async () => {
+        const mockCases = [{ id: 1, title: 'Case 1' }, { id: 2, title: 'Case 2' }];
+        mockAxiosInstance.get.mockResolvedValue({
+            data: { cases: mockCases, _links: { next: null } }
+        });
+
+        const result = await client.getCases('1');
+        expect(result).toEqual(mockCases);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_cases/1');
+    });
+
+    test('getCases handles response with undefined _links', async () => {
+        const mockCases = [{ id: 1, title: 'Case 1' }];
+        mockAxiosInstance.get.mockResolvedValue({
+            data: { cases: mockCases }
+        });
+
+        const result = await client.getCases('1');
+        expect(result).toEqual(mockCases);
+    });
+
+    test('getCases handles pagination', async () => {
+        const page1Cases = [{ id: 1, title: 'Case 1' }];
+        const page2Cases = [{ id: 2, title: 'Case 2' }];
+
+        mockAxiosInstance.get
+            .mockResolvedValueOnce({
+                data: { cases: page1Cases, _links: { next: '/api/v2/get_cases/1&offset=1' } }
+            })
+            .mockResolvedValueOnce({
+                data: { cases: page2Cases, _links: { next: null } }
+            });
+
+        const result = await client.getCases('1');
+        expect(result).toEqual([...page1Cases, ...page2Cases]);
+        expect(mockAxiosInstance.get).toHaveBeenCalledTimes(2);
+    });
+
+    test('getCases with sectionId adds section filter', async () => {
+        mockAxiosInstance.get.mockResolvedValue({
+            data: { cases: [], _links: { next: null } }
+        });
+
+        await client.getCases('1', '5');
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_cases/1&section_id=5');
+    });
+
+    test('getCases with filter adds query params', async () => {
+        mockAxiosInstance.get.mockResolvedValue({
+            data: { cases: [], _links: { next: null } }
+        });
+
+        await client.getCases('1', undefined, { type_id: '1', priority_id: '2' });
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+            '/index.php?/api/v2/get_cases/1&type_id=1&priority_id=2'
+        );
+    });
+
+    test('getSection returns data on success', async () => {
+        const mockData = {
+            id: 1,
+            name: 'Section 1',
+            description: null,
+            parent_id: null,
+            depth: 0,
+            display_order: 1,
+            suite_id: 1
+        };
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getSection('1');
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_section/1');
+    });
+
+    test('getPriorities returns data on success', async () => {
+        const mockData = [{
+            id: 1,
+            is_default: true,
+            name: 'Low',
+            priority: 1,
+            short_name: 'Low'
+        }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getPriorities();
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_priorities');
+    });
+
+    test('getPriorities caches result', async () => {
+        const mockData = [{ id: 1, name: 'Low' }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        await client.getPriorities();
+        await client.getPriorities();
+
+        expect(mockAxiosInstance.get).toHaveBeenCalledTimes(1);
+    });
+
+    test('getCaseTypes returns data on success', async () => {
+        const mockData = [{
+            id: 1,
+            is_default: true,
+            name: 'Automated'
+        }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getCaseTypes();
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_case_types');
+    });
+
+    test('getCaseFields returns data on success', async () => {
+        const mockData = [{
+            id: 1,
+            name: 'custom_field',
+            system_name: 'custom_field',
+            label: 'Custom Field',
+            type_id: 1
+        }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getCaseFields();
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_case_fields');
+    });
+
+    test('getCaseFields caches result', async () => {
+        const mockData = [{ id: 1, name: 'field' }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        await client.getCaseFields();
+        await client.getCaseFields();
+
+        expect(mockAxiosInstance.get).toHaveBeenCalledTimes(1);
+    });
+
+    test('getTemplates returns data on success', async () => {
+        const mockData = [{ id: 1, name: 'Test Template', is_default: true }];
+        mockAxiosInstance.get.mockResolvedValue({ data: mockData });
+
+        const result = await client.getTemplates('1');
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_templates/1');
+    });
+
+    test('getTemplates caches result per project', async () => {
+        const mockData1 = [{ id: 1, name: 'Template 1' }];
+        const mockData2 = [{ id: 2, name: 'Template 2' }];
+        mockAxiosInstance.get
+            .mockResolvedValueOnce({ data: mockData1 })
+            .mockResolvedValueOnce({ data: mockData2 });
+
+        await client.getTemplates('1');
+        await client.getTemplates('1');
+        await client.getTemplates('2');
+
+        expect(mockAxiosInstance.get).toHaveBeenCalledTimes(2);
+    });
+
+    test('updateCase sends POST request', async () => {
+        const mockData = { id: 1, title: 'Updated Case' };
+        mockAxiosInstance.post.mockResolvedValue({ data: mockData });
+
+        const result = await client.updateCase('1', { title: 'Updated Case' });
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+            '/index.php?/api/v2/update_case/1',
+            { title: 'Updated Case' }
+        );
+    });
+
+    test('updateCases gets suite_id from first case and updates all', async () => {
+        const mockCase = { id: 1, suite_id: 10 };
+        const mockUpdated = [{ id: 1, title: 'Updated' }, { id: 2, title: 'Updated' }];
+
+        mockAxiosInstance.get.mockResolvedValue({ data: mockCase });
+        mockAxiosInstance.post.mockResolvedValue({ data: { updated_cases: mockUpdated } });
+
+        const result = await client.updateCases([1, 2], { title: 'Updated' });
+        expect(result).toEqual(mockUpdated);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_case/1');
+        expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+            '/index.php?/api/v2/update_cases/10',
+            { case_ids: [1, 2], title: 'Updated' }
+        );
+    });
+
+    test('createCase sends POST request', async () => {
+        const mockData = { id: 1, title: 'New Case' };
+        mockAxiosInstance.post.mockResolvedValue({ data: mockData });
+
+        const result = await client.createCase('5', { title: 'New Case' });
+        expect(result).toEqual(mockData);
+        expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+            '/index.php?/api/v2/add_case/5',
+            { title: 'New Case' }
+        );
+    });
+
+    test('getSections returns sections array', async () => {
+        const mockSections = [{ id: 1, name: 'Section 1' }, { id: 2, name: 'Section 2' }];
+        mockAxiosInstance.get.mockResolvedValue({ data: { sections: mockSections } });
+
+        const result = await client.getSections('1');
+        expect(result).toEqual(mockSections);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_sections/1');
+    });
+
+    test('getProjects returns projects array', async () => {
+        const mockProjects = [{ id: 1, name: 'Project 1' }];
+        mockAxiosInstance.get.mockResolvedValue({ data: { projects: mockProjects } });
+
+        const result = await client.getProjects();
+        expect(result).toEqual(mockProjects);
+        expect(mockAxiosInstance.get).toHaveBeenCalledWith('/index.php?/api/v2/get_projects');
+    });
+
+    test('getProjects caches result', async () => {
+        const mockProjects = [{ id: 1, name: 'Project 1' }];
+        mockAxiosInstance.get.mockResolvedValue({ data: { projects: mockProjects } });
+
+        await client.getProjects();
+        await client.getProjects();
+
+        expect(mockAxiosInstance.get).toHaveBeenCalledTimes(1);
+    });
+
+    test('postRequest throws formatted error on API error', async () => {
+        const mockError = {
+            message: 'Request failed',
+            response: {
+                status: 400,
+                statusText: 'Bad Request',
+                data: { error: 'Invalid field' }
+            },
+            isAxiosError: true,
+            toJSON: () => ({})
+        };
+
+        mockAxiosInstance.post.mockRejectedValue(mockError);
+
+        await expect(client.updateCase('1', {})).rejects.toThrow(
+            'TestRail API error: 400 Bad Request - {"error":"Invalid field"}'
+        );
+    });
+
+    test('handleError formats error when no response received', async () => {
+        const mockError = {
+            message: 'Network Error',
+            request: {},
+            isAxiosError: true,
+            toJSON: () => ({})
+        };
+
+        mockAxiosInstance.get.mockRejectedValue(mockError);
+
+        await expect(client.getCase('1')).rejects.toThrow(
+            'TestRail API error: No response received. Network Error'
+        );
+    });
+
+    test('handleError returns generic message for non-axios errors', async () => {
+        const mockError = new Error('Unknown error');
+        mockAxiosInstance.get.mockRejectedValue(mockError);
+
+        await expect(client.getCase('1')).rejects.toThrow(
+            'TestRail API error: Unknown error'
+        );
+    });
+});

package/test/tools/create_case.test.ts

@@ -0,0 +1,107 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createCaseTool } from '../../src/tools/create_case.js';
+import { TestRailClient } from '../../src/client/testrail.js';
+import { Case } from '../../src/types/testrail.js';
+
+describe('create_case tool', () => {
+    let mockClient: jest.Mocked<TestRailClient>;
+    let createCaseMock: jest.Mock<(sectionId: string, fields: Record<string, any>) => Promise<Case>>;
+
+    const mockCreatedCase: Case = {
+        id: 456,
+        title: 'New Test Case',
+        section_id: 1,
+        template_id: 1,
+        type_id: 1,
+        priority_id: 2,
+        milestone_id: null,
+        refs: null,
+        created_by: 1,
+        created_on: 1700000000,
+        updated_by: 1,
+        updated_on: 1700000000,
+        estimate: null,
+        estimate_forecast: null,
+        suite_id: 1,
+        display_order: 1,
+        is_deleted: 0,
+        labels: [],
+    };
+
+    beforeEach(() => {
+        createCaseMock = jest.fn<(sectionId: string, fields: Record<string, any>) => Promise<Case>>()
+            .mockResolvedValue(mockCreatedCase);
+
+        mockClient = {
+            createCase: createCaseMock
+        } as unknown as jest.Mocked<TestRailClient>;
+    });
+
+    test('exports correct tool definition', () => {
+        expect(createCaseTool.name).toBe('create_case');
+        expect(createCaseTool.description).toContain('Create');
+        expect(createCaseTool.parameters).toBeDefined();
+        expect(createCaseTool.parameters.section_id).toBeDefined();
+        expect(createCaseTool.parameters.title).toBeDefined();
+        expect(createCaseTool.parameters.fields).toBeDefined();
+    });
+
+    test('handler creates case and returns success response', async () => {
+        const result = await createCaseTool.handler(
+            { section_id: '1', title: 'New Test Case' },
+            mockClient
+        );
+
+        expect(result).toBeDefined();
+        expect(result.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.success).toBe(true);
+        expect(parsed.case_id).toBe(456);
+        expect(parsed.message).toContain('C456');
+        expect(mockClient.createCase).toHaveBeenCalledWith('1', { title: 'New Test Case' });
+    });
+
+    test('passes title and optional fields correctly', async () => {
+        const fields = {
+            priority_id: 2,
+            template_id: 1,
+            custom_automation_priority: 1,
+        };
+
+        await createCaseTool.handler(
+            { section_id: '5', title: 'My Test', fields },
+            mockClient
+        );
+
+        expect(mockClient.createCase).toHaveBeenCalledWith('5', {
+            title: 'My Test',
+            priority_id: 2,
+            template_id: 1,
+            custom_automation_priority: 1,
+        });
+    });
+
+    test('works without optional fields', async () => {
+        await createCaseTool.handler(
+            { section_id: '10', title: 'Simple Test' },
+            mockClient
+        );
+
+        expect(mockClient.createCase).toHaveBeenCalledWith('10', { title: 'Simple Test' });
+    });
+
+    test('handler returns error on failure', async () => {
+        createCaseMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await createCaseTool.handler(
+            { section_id: '1', title: 'Test' },
+            mockClient
+        );
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+});

package/test/tools/get_case.test.ts

@@ -0,0 +1,200 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { getCaseTool } from '../../src/tools/get_case.js';
+import { TestRailClient } from '../../src/client/testrail.js';
+import { Case, Section, CaseType, Priority, CaseField } from '../../src/types/testrail.js';
+
+describe('get_case tool', () => {
+    let mockClient: jest.Mocked<TestRailClient>;
+    let getCaseMock: jest.Mock<(id: string) => Promise<Case>>;
+    let getSectionMock: jest.Mock<(id: string) => Promise<Section>>;
+    let getCaseTypesMock: jest.Mock<() => Promise<CaseType[]>>;
+    let getPrioritiesMock: jest.Mock<() => Promise<Priority[]>>;
+    let getCaseFieldsMock: jest.Mock<() => Promise<CaseField[]>>;
+
+    const mockCaseFields: CaseField[] = [
+        { id: 1, name: 'is_automated', system_name: 'custom_is_automated', label: 'Is Automated', type_id: 1, template_ids: [], include_all: true, is_active: true, display_order: 1, description: null, configs: [] },
+        { id: 2, name: 'refs', system_name: 'custom_refs', label: 'Defects', type_id: 1, template_ids: [], include_all: true, is_active: true, display_order: 2, description: null, configs: [] },
+        { id: 3, name: 'case_automation_priority', system_name: 'custom_case_automation_priority', label: 'Automation Priority', type_id: 6, template_ids: [], include_all: true, is_active: true, display_order: 3, description: null, configs: [{ context: { is_global: true, project_ids: null }, options: { items: '2, P0\n3, P1\n4, P2\n5, P3\n6, P4' } }] },
+        { id: 4, name: 'preconds', system_name: 'custom_preconds', label: 'Preconditions', type_id: 1, template_ids: [], include_all: true, is_active: true, display_order: 4, description: null, configs: [] },
+        { id: 5, name: 'steps', system_name: 'custom_steps', label: 'Steps', type_id: 1, template_ids: [1], include_all: false, is_active: true, display_order: 5, description: null, configs: [] },
+        { id: 6, name: 'expected', system_name: 'custom_expected', label: 'Expected', type_id: 1, template_ids: [1], include_all: false, is_active: true, display_order: 6, description: null, configs: [] },
+        { id: 7, name: 'steps_separated', system_name: 'custom_steps_separated', label: 'Steps Separated', type_id: 1, template_ids: [2], include_all: false, is_active: true, display_order: 7, description: null, configs: [] },
+    ];
+
+    beforeEach(() => {
+        getCaseMock = jest.fn<(id: string) => Promise<Case>>();
+        getSectionMock = jest.fn<(id: string) => Promise<Section>>();
+        getCaseTypesMock = jest.fn<() => Promise<CaseType[]>>();
+        getPrioritiesMock = jest.fn<() => Promise<Priority[]>>();
+        getCaseFieldsMock = jest.fn<() => Promise<CaseField[]>>().mockResolvedValue(mockCaseFields);
+
+        mockClient = {
+            getCase: getCaseMock,
+            getSection: getSectionMock,
+            getCaseTypes: getCaseTypesMock,
+            getPriorities: getPrioritiesMock,
+            getCaseFields: getCaseFieldsMock
+        } as unknown as jest.Mocked<TestRailClient>;
+    });
+
+    test('exports correct tool definition', () => {
+        expect(getCaseTool.name).toBe('get_case');
+        expect(getCaseTool.description).toBe('Get a test case from TestRail by ID');
+        expect(getCaseTool.parameters).toBeDefined();
+    });
+
+    test('handler fetches data and returns transformed response', async () => {
+        const mockCase: Case = {
+            id: 123, title: 'My Case', template_id: 1,
+            section_id: 456,
+            type_id: 2,
+            priority_id: 3,
+            milestone_id: null,
+            refs: 'JIRA-123',
+            created_by: 1,
+            created_on: 1700000000,
+            updated_by: 1,
+            updated_on: 1700000000,
+            estimate: null,
+            estimate_forecast: null,
+            suite_id: 1,
+            display_order: 1,
+            is_deleted: 0,
+            custom_refs: null,
+            custom_case_automation_priority: null,
+            custom_is_automated: null,
+            custom_reviewer: null,
+            custom_review_status: null,
+            custom_testrail_bdd_scenario: null,
+            custom_override: null,
+            custom_preconds: null,
+            custom_steps: null,
+            custom_expected: null,
+            custom_steps_separated: null,
+            custom_mission: null,
+            custom_goals: null,
+            custom_postcondition: null,
+            custom_comments: null,
+            labels: ['tag1']
+        };
+
+        const mockSection: Section = {
+            id: 456, name: 'My Section', description: null, parent_id: null, depth: 0, display_order: 1, suite_id: 1
+        };
+
+        const mockCaseTypes: CaseType[] = [
+            { id: 1, name: 'Automated', is_default: false },
+            { id: 2, name: 'Functional', is_default: true }
+        ];
+
+        const mockPriorities: Priority[] = [
+            { id: 3, name: 'High', priority: 3, short_name: 'High', is_default: false }
+        ];
+
+        getCaseMock.mockResolvedValue(mockCase);
+        getSectionMock.mockResolvedValue(mockSection);
+        getCaseTypesMock.mockResolvedValue(mockCaseTypes);
+        getPrioritiesMock.mockResolvedValue(mockPriorities);
+
+        const result = await getCaseTool.handler({ case_id: 'C123' }, mockClient);
+
+        expect(result).toBeDefined();
+        if ('content' in result) {
+            expect(result.content[0].type).toBe('text');
+            const parsed = JSON.parse(result.content[0].text);
+
+            expect(parsed).toEqual({
+                id: 123,
+                title: 'My Case',
+                section: 'My Section',
+                type: 'Functional',
+                priority: 'High',
+                labels: ['tag1'],
+                references: 'JIRA-123',
+                updated_on: 1700000000
+            });
+        } else {
+            throw new Error('Result should have content');
+        }
+
+        expect(mockClient.getCase).toHaveBeenCalledWith('123');
+        expect(mockClient.getSection).toHaveBeenCalledWith('456');
+        expect(mockClient.getCaseTypes).toHaveBeenCalled();
+        expect(mockClient.getPriorities).toHaveBeenCalled();
+    });
+
+
+
+    test('handler returns error on failure', async () => {
+        getCaseMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+
+    test('handler returns "Unknown" when caseType is not found', async () => {
+        const mockCase: Case = {
+            id: 123, title: 'My Case', template_id: 1,
+            section_id: 456, type_id: 999, priority_id: 3,
+            milestone_id: null, refs: null, created_by: 1, created_on: 1700000000,
+            updated_by: 1, updated_on: 1700000000, estimate: null, estimate_forecast: null,
+            suite_id: 1, display_order: 1, is_deleted: 0, labels: []
+        };
+
+        getCaseMock.mockResolvedValue(mockCase);
+        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, depth: 0, display_order: 1, suite_id: 1 });
+        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
+        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', priority: 3, short_name: 'High', is_default: false }]);
+
+        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.type).toBe('Unknown');
+        expect(parsed.priority).toBe('High');
+    });
+
+    test('handler returns "Unknown" when priority is not found', async () => {
+        const mockCase: Case = {
+            id: 123, title: 'My Case', template_id: 1,
+            section_id: 456, type_id: 1, priority_id: 999,
+            milestone_id: null, refs: null, created_by: 1, created_on: 1700000000,
+            updated_by: 1, updated_on: 1700000000, estimate: null, estimate_forecast: null,
+            suite_id: 1, display_order: 1, is_deleted: 0, labels: []
+        };
+
+        getCaseMock.mockResolvedValue(mockCase);
+        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, depth: 0, display_order: 1, suite_id: 1 });
+        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
+        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', priority: 3, short_name: 'High', is_default: false }]);
+
+        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.type).toBe('Automated');
+        expect(parsed.priority).toBe('Unknown');
+    });
+
+    test('handler uses empty array when labels is undefined', async () => {
+        const mockCase: Case = {
+            id: 123, title: 'My Case', template_id: 1,
+            section_id: 456, type_id: 1, priority_id: 3,
+            milestone_id: null, refs: null, created_by: 1, created_on: 1700000000,
+            updated_by: 1, updated_on: 1700000000, estimate: null, estimate_forecast: null,
+            suite_id: 1, display_order: 1, is_deleted: 0, labels: undefined as any
+        };
+
+        getCaseMock.mockResolvedValue(mockCase);
+        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, depth: 0, display_order: 1, suite_id: 1 });
+        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
+        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', priority: 3, short_name: 'High', is_default: false }]);
+
+        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.labels).toEqual([]);
+    });
+});