@uarlouski/testrail-mcp-server 1.2.0 → 1.3.1

package/test/tools/create_case.test.ts

@@ -1,101 +0,0 @@
-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.success).toBe(true);
-        expect(result.case_id).toBe(456);
-        expect(result.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 throws error on failure', async () => {
-        createCaseMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(
-            createCaseTool.handler(
-                { section_id: '1', title: 'Test' },
-                mockClient
-            )
-        ).rejects.toThrow('API Error');
-    });
-});

package/test/tools/get_case.test.ts

@@ -1,185 +0,0 @@
-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, description: null, configs: [] },
-        { id: 2, name: 'refs', system_name: 'custom_refs', label: 'Defects', type_id: 1, template_ids: [], include_all: true, is_active: true, 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, description: null, configs: [{ 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, 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, 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, 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, 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_on: 1700000000,
-            updated_on: 1700000000,
-            estimate: null,
-            suite_id: 1,
-            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, 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', 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();
-        expect(result).toEqual({
-            id: 123,
-            title: 'My Case',
-            section: 'My Section',
-            type: 'Functional',
-            priority: 'High',
-            labels: ['tag1'],
-            references: 'JIRA-123',
-            updated_on: 1700000000
-        });
-
-        expect(mockClient.getCase).toHaveBeenCalledWith('123');
-        expect(mockClient.getSection).toHaveBeenCalledWith('456');
-        expect(mockClient.getCaseTypes).toHaveBeenCalled();
-        expect(mockClient.getPriorities).toHaveBeenCalled();
-    });
-
-
-
-    test('handler throws error on failure', async () => {
-        getCaseMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(
-            getCaseTool.handler({ case_id: '123' }, mockClient)
-        ).rejects.toThrow('API Error');
-    });
-
-    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_on: 1700000000,
-            updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: []
-        };
-
-        getCaseMock.mockResolvedValue(mockCase);
-        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, suite_id: 1 });
-        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
-        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', is_default: false }]);
-
-        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
-        // result is now a plain object
-
-        expect(result.type).toBe('Unknown');
-        expect(result.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_on: 1700000000,
-            updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: []
-        };
-
-        getCaseMock.mockResolvedValue(mockCase);
-        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, suite_id: 1 });
-        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
-        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', is_default: false }]);
-
-        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
-        // result is now a plain object
-
-        expect(result.type).toBe('Automated');
-        expect(result.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_on: 1700000000,
-            updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: undefined as any
-        };
-
-        getCaseMock.mockResolvedValue(mockCase);
-        getSectionMock.mockResolvedValue({ id: 456, name: 'Section', description: null, parent_id: null, suite_id: 1 });
-        getCaseTypesMock.mockResolvedValue([{ id: 1, name: 'Automated', is_default: false }]);
-        getPrioritiesMock.mockResolvedValue([{ id: 3, name: 'High', is_default: false }]);
-
-        const result = await getCaseTool.handler({ case_id: '123' }, mockClient);
-        // result is now a plain object
-
-        expect(result.labels).toEqual([]);
-    });
-});

package/test/tools/get_case_fields.test.ts

@@ -1,132 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getCaseFieldsTool } from '../../src/tools/get_case_fields.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { CaseField } from '../../src/types/testrail.js';
-
-describe('get_case_fields tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getCaseFieldsMock: jest.Mock<() => Promise<CaseField[]>>;
-
-    const mockCaseFields: CaseField[] = [
-        {
-            id: 1,
-            name: 'is_automated',
-            system_name: 'custom_is_automated',
-            label: 'Is Automated',
-            type_id: 5,
-            template_ids: [],
-            include_all: true,
-            is_active: true,
-            description: 'Whether test is automated',
-            configs: [{ options: { is_required: false } }]
-        },
-        {
-            id: 2,
-            name: 'automation_priority',
-            system_name: 'custom_automation_priority',
-            label: 'Automation Priority',
-            type_id: 6,
-            template_ids: [],
-            include_all: true,
-            is_active: true,
-            description: 'Priority for automation',
-            configs: [{ options: { items: '1, P0\n2, P1\n3, P2', is_required: true } }]
-        },
-        {
-            id: 3,
-            name: 'inactive_field',
-            system_name: 'custom_inactive_field',
-            label: 'Inactive Field',
-            type_id: 1,
-            template_ids: [],
-            include_all: true,
-            is_active: false,
-            description: null,
-            configs: []
-        },
-        {
-            id: 4,
-            name: 'components',
-            system_name: 'custom_components',
-            label: 'Components',
-            type_id: 12,
-            template_ids: [],
-            include_all: true,
-            is_active: true,
-            description: 'Test components',
-            configs: [{ options: { items: '1, UI\n2, API\n3, Database' } }]
-        }
-    ];
-
-    beforeEach(() => {
-        getCaseFieldsMock = jest.fn<() => Promise<CaseField[]>>().mockResolvedValue(mockCaseFields);
-
-        mockClient = {
-            getCaseFields: getCaseFieldsMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getCaseFieldsTool.name).toBe('get_case_fields');
-        expect(getCaseFieldsTool.description).toContain('field schema');
-        expect(getCaseFieldsTool.parameters).toBeDefined();
-    });
-
-    test('handler fetches and returns field schema', async () => {
-        const result = await getCaseFieldsTool.handler({}, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.fields).toBeDefined();
-        expect(result.fields.length).toBeGreaterThan(0);
-        expect(mockClient.getCaseFields).toHaveBeenCalled();
-    });
-
-    test('includes template_ids for template-specific fields', async () => {
-        const templateSpecificFields: CaseField[] = [
-            {
-                id: 5,
-                name: 'steps',
-                system_name: 'custom_steps',
-                label: 'Steps',
-                type_id: 3,
-                template_ids: [1, 2],
-                include_all: false,
-                is_active: true,
-                description: 'Test steps',
-                configs: []
-            }
-        ];
-
-        getCaseFieldsMock.mockResolvedValue(templateSpecificFields);
-
-        const result = await getCaseFieldsTool.handler({}, mockClient);
-
-        const stepsField = result.fields.find((f: any) => f.system_name === 'custom_steps');
-        expect(stepsField.template_ids).toEqual([1, 2]);
-    });
-
-    test('handles unknown field type gracefully', async () => {
-        const unknownTypeFields: CaseField[] = [
-            {
-                id: 6,
-                name: 'unknown_type',
-                system_name: 'custom_unknown_type',
-                label: 'Unknown Type Field',
-                type_id: 999,
-                template_ids: [],
-                include_all: true,
-                is_active: true,
-                description: null,
-                configs: []
-            }
-        ];
-
-        getCaseFieldsMock.mockResolvedValue(unknownTypeFields);
-
-        const result = await getCaseFieldsTool.handler({}, mockClient);
-
-        const unknownField = result.fields.find((f: any) => f.system_name === 'custom_unknown_type');
-        expect(unknownField.type).toBe('Unknown (999)');
-    });
-});
-

package/test/tools/get_cases.test.ts

@@ -1,104 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getCasesTool } from '../../src/tools/get_cases.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Case } from '../../src/types/testrail.js';
-
-describe('get_cases tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getCasesMock: jest.Mock<(projectId: string, sectionId?: string, filter?: Record<string, string>) => Promise<Case[]>>;
-
-    const mockCases: Case[] = [
-        {
-            id: 1, title: 'Login test', section_id: 1, template_id: 1, type_id: 1,
-            priority_id: 2, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: [], custom_automation_status: 1
-        },
-        {
-            id: 2, title: 'Logout test', section_id: 1, template_id: 1, type_id: 1,
-            priority_id: 3, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: [], custom_automation_status: 2
-        },
-        {
-            id: 3, title: 'Registration test', section_id: 2, template_id: 1, type_id: 1,
-            priority_id: 1, milestone_id: null, refs: null, created_on: 1700000000,
-            updated_by: 1, updated_on: 1700000000, estimate: null,
-            suite_id: 1, labels: [], custom_automation_status: 0
-        },
-    ];
-
-    beforeEach(() => {
-        getCasesMock = jest.fn<(projectId: string, sectionId?: string, filter?: Record<string, string>) => Promise<Case[]>>()
-            .mockResolvedValue(mockCases);
-
-        mockClient = {
-            getCases: getCasesMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getCasesTool.name).toBe('get_cases');
-        expect(getCasesTool.description).toContain('cases');
-        expect(getCasesTool.parameters).toBeDefined();
-        expect(getCasesTool.parameters.project_id).toBeDefined();
-        expect(getCasesTool.parameters.section_id).toBeDefined();
-        expect(getCasesTool.parameters.filter).toBeDefined();
-        expect(getCasesTool.parameters.fields).toBeDefined();
-    });
-
-    test('handler fetches and returns cases', async () => {
-        const result = await getCasesTool.handler({ project_id: '1' }, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.cases).toHaveLength(3);
-        expect(mockClient.getCases).toHaveBeenCalledWith('1', undefined, undefined);
-    });
-
-    test('filters cases using where clause with single condition', async () => {
-        const result = await getCasesTool.handler(
-            { project_id: '1', where: { custom_automation_status: 1 } },
-            mockClient
-        );
-
-        expect(result.cases).toHaveLength(1);
-        expect(result.cases[0].id).toBe(1);
-        expect(result.cases[0].title).toBe('Login test');
-    });
-
-    test('filters cases using where clause with multiple conditions', async () => {
-        const result = await getCasesTool.handler(
-            { project_id: '1', where: { custom_automation_status: 2, priority_id: 3 } },
-            mockClient
-        );
-
-        expect(result.cases).toHaveLength(1);
-        expect(result.cases[0].id).toBe(2);
-        expect(result.cases[0].title).toBe('Logout test');
-    });
-
-    test('returns empty array when where clause matches no cases', async () => {
-        const result = await getCasesTool.handler(
-            { project_id: '1', where: { custom_automation_status: 999 } },
-            mockClient
-        );
-
-        expect(result.cases).toHaveLength(0);
-    });
-
-    test('combines where clause with fields parameter', async () => {
-        const result = await getCasesTool.handler(
-            { project_id: '1', where: { priority_id: 2 }, fields: ['priority_id', 'custom_automation_status'] },
-            mockClient
-        );
-
-        expect(result.cases).toHaveLength(1);
-        expect(result.cases[0]).toEqual({
-            id: 1,
-            title: 'Login test',
-            suite_id: 1,
-            priority_id: 2,
-            custom_automation_status: 1
-        });
-    });
-});

package/test/tools/get_projects.test.ts

@@ -1,38 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getProjectsTool } from '../../src/tools/get_projects.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Project } from '../../src/types/testrail.js';
-
-describe('get_projects tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getProjectsMock: jest.Mock<() => Promise<Project[]>>;
-
-    const mockProjects: Project[] = [
-        { id: 1, name: 'Project Alpha', is_completed: false, suite_mode: 1 },
-        { id: 2, name: 'Project Beta', is_completed: false, suite_mode: 3 },
-        { id: 3, name: 'Old Project', is_completed: true, suite_mode: 1 },
-    ];
-
-    beforeEach(() => {
-        getProjectsMock = jest.fn<() => Promise<Project[]>>()
-            .mockResolvedValue(mockProjects);
-
-        mockClient = {
-            getProjects: getProjectsMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getProjectsTool.name).toBe('get_projects');
-        expect(getProjectsTool.description).toContain('project');
-        expect(getProjectsTool.parameters).toBeDefined();
-    });
-
-    test('handler fetches and returns projects', async () => {
-        const result = await getProjectsTool.handler({}, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.projects).toHaveLength(2);
-        expect(mockClient.getProjects).toHaveBeenCalled();
-    });
-});

package/test/tools/get_sections.test.ts

@@ -1,39 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getSectionsTool } from '../../src/tools/get_sections.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Section } from '../../src/types/testrail.js';
-
-describe('get_sections tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getSectionsMock: jest.Mock<(projectId: string) => Promise<Section[]>>;
-
-    const mockSections: Section[] = [
-        { id: 1, name: 'Login', description: null, parent_id: null, suite_id: 1 },
-        { id: 2, name: 'Authentication', description: 'Auth tests', parent_id: 1, suite_id: 1 },
-        { id: 3, name: 'Registration', description: null, parent_id: null, suite_id: 1 },
-    ];
-
-    beforeEach(() => {
-        getSectionsMock = jest.fn<(projectId: string) => Promise<Section[]>>()
-            .mockResolvedValue(mockSections);
-
-        mockClient = {
-            getSections: getSectionsMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getSectionsTool.name).toBe('get_sections');
-        expect(getSectionsTool.description).toContain('section');
-        expect(getSectionsTool.parameters).toBeDefined();
-        expect(getSectionsTool.parameters.project_id).toBeDefined();
-    });
-
-    test('handler throws error on failure', async () => {
-        getSectionsMock.mockRejectedValue(new Error('API Error'));
-
-        await expect(
-            getSectionsTool.handler({ project_id: '1' }, mockClient)
-        ).rejects.toThrow('API Error');
-    });
-});

package/test/tools/get_templates.test.ts

@@ -1,38 +0,0 @@
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { getTemplatesTool } from '../../src/tools/get_templates.js';
-import { TestRailClient } from '../../src/client/testrail.js';
-import { Template } from '../../src/types/testrail.js';
-
-describe('get_templates tool', () => {
-    let mockClient: jest.Mocked<TestRailClient>;
-    let getTemplatesMock: jest.Mock<(projectId: string) => Promise<Template[]>>;
-
-    const mockTemplates: Template[] = [
-        { id: 1, name: 'Test Case (Text)', is_default: false },
-        { id: 2, name: 'Test Case (Steps)', is_default: true },
-        { id: 3, name: 'Exploratory Session', is_default: false },
-    ];
-
-    beforeEach(() => {
-        getTemplatesMock = jest.fn<(projectId: string) => Promise<Template[]>>().mockResolvedValue(mockTemplates);
-
-        mockClient = {
-            getTemplates: getTemplatesMock
-        } as unknown as jest.Mocked<TestRailClient>;
-    });
-
-    test('exports correct tool definition', () => {
-        expect(getTemplatesTool.name).toBe('get_templates');
-        expect(getTemplatesTool.description).toContain('template');
-        expect(getTemplatesTool.parameters).toBeDefined();
-        expect(getTemplatesTool.parameters.project_id).toBeDefined();
-    });
-
-    test('handler fetches and returns templates', async () => {
-        const result = await getTemplatesTool.handler({ project_id: '1' }, mockClient);
-
-        expect(result).toBeDefined();
-        expect(result.templates).toHaveLength(3);
-        expect(mockClient.getTemplates).toHaveBeenCalledWith('1');
-    });
-});