@uarlouski/testrail-mcp-server 1.1.0

package/test/tools/get_case_fields.test.ts

@@ -0,0 +1,205 @@
+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,
+            display_order: 1,
+            description: 'Whether test is automated',
+            configs: [{ context: { is_global: true, project_ids: null }, 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,
+            display_order: 2,
+            description: 'Priority for automation',
+            configs: [{ context: { is_global: true, project_ids: null }, 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,
+            display_order: 3,
+            description: null,
+            configs: []
+        },
+        {
+            id: 4,
+            name: 'components',
+            system_name: 'custom_components',
+            label: 'Components',
+            type_id: 12,
+            template_ids: [],
+            include_all: true,
+            is_active: true,
+            display_order: 4,
+            description: 'Test components',
+            configs: [{ context: { is_global: true, project_ids: null }, 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.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.fields).toHaveLength(11); // 8 system fields + 3 active custom fields
+        expect(mockClient.getCaseFields).toHaveBeenCalled();
+    });
+
+    test('returns only essential schema fields', async () => {
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const field = parsed.fields[0];
+        expect(Object.keys(field).sort()).toEqual(['is_required', 'label', 'system_name', 'type']);
+    });
+
+    test('returns correct field types', async () => {
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const checkboxField = parsed.fields.find((f: any) => f.system_name === 'custom_is_automated');
+        expect(checkboxField.type).toBe('Checkbox');
+
+        const dropdownField = parsed.fields.find((f: any) => f.system_name === 'custom_automation_priority');
+        expect(dropdownField.type).toBe('Dropdown');
+
+        const multiSelectField = parsed.fields.find((f: any) => f.system_name === 'custom_components');
+        expect(multiSelectField.type).toBe('Multi-select');
+    });
+
+    test('parses dropdown options correctly', async () => {
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const dropdownField = parsed.fields.find((f: any) => f.system_name === 'custom_automation_priority');
+        expect(dropdownField.options).toEqual(['P0', 'P1', 'P2']);
+
+        const multiSelectField = parsed.fields.find((f: any) => f.system_name === 'custom_components');
+        expect(multiSelectField.options).toEqual(['UI', 'API', 'Database']);
+    });
+
+    test('identifies required fields', async () => {
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const optionalField = parsed.fields.find((f: any) => f.system_name === 'custom_is_automated');
+        expect(optionalField.is_required).toBe(false);
+
+        const requiredField = parsed.fields.find((f: any) => f.system_name === 'custom_automation_priority');
+        expect(requiredField.is_required).toBe(true);
+    });
+
+    test('filters out inactive fields', async () => {
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const inactiveField = parsed.fields.find((f: any) => f.system_name === 'custom_inactive_field');
+        expect(inactiveField).toBeUndefined();
+    });
+
+    test('handler returns error on failure', async () => {
+        getCaseFieldsMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+
+    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,
+                display_order: 5,
+                description: 'Test steps',
+                configs: []
+            }
+        ];
+
+        getCaseFieldsMock.mockResolvedValue(templateSpecificFields);
+
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const stepsField = parsed.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,
+                display_order: 6,
+                description: null,
+                configs: []
+            }
+        ];
+
+        getCaseFieldsMock.mockResolvedValue(unknownTypeFields);
+
+        const result = await getCaseFieldsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const unknownField = parsed.fields.find((f: any) => f.system_name === 'custom_unknown_type');
+        expect(unknownField.type).toBe('Unknown (999)');
+    });
+});
+

package/test/tools/get_cases.test.ts

@@ -0,0 +1,193 @@
+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_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: [], 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_by: 1, created_on: 1700000000,
+            updated_by: 1, updated_on: 1700000000, estimate: null, estimate_forecast: null,
+            suite_id: 1, display_order: 2, is_deleted: 0, 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_by: 1, created_on: 1700000000,
+            updated_by: 1, updated_on: 1700000000, estimate: null, estimate_forecast: null,
+            suite_id: 1, display_order: 3, is_deleted: 0, 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.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.cases).toHaveLength(3);
+        expect(mockClient.getCases).toHaveBeenCalledWith('1', undefined, undefined);
+    });
+
+    test('passes section_id when provided', async () => {
+        await getCasesTool.handler({ project_id: '1', section_id: '2' }, mockClient);
+
+        expect(mockClient.getCases).toHaveBeenCalledWith('1', '2', undefined);
+    });
+
+    test('passes filter when provided', async () => {
+        const filter = { priority_id: '1,2', type_id: '3' };
+        await getCasesTool.handler({ project_id: '1', filter }, mockClient);
+
+        expect(mockClient.getCases).toHaveBeenCalledWith('1', undefined, filter);
+    });
+
+    test('returns correct case structure', async () => {
+        const result = await getCasesTool.handler({ project_id: '1' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases[0]).toEqual({
+            id: 1,
+            title: 'Login test',
+            suite_id: 1,
+        });
+
+        expect(parsed.cases[2]).toEqual({
+            id: 3,
+            title: 'Registration test',
+            suite_id: 1,
+        });
+    });
+
+    test('includes additional fields when specified', async () => {
+        const result = await getCasesTool.handler(
+            { project_id: '1', fields: ['priority_id', 'type_id', 'custom_automation_status'] },
+            mockClient
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases[0]).toEqual({
+            id: 1,
+            title: 'Login test',
+            suite_id: 1,
+            priority_id: 2,
+            type_id: 1,
+            custom_automation_status: 1,
+        });
+
+        expect(parsed.cases[1]).toEqual({
+            id: 2,
+            title: 'Logout test',
+            suite_id: 1,
+            priority_id: 3,
+            type_id: 1,
+            custom_automation_status: 2,
+        });
+    });
+
+    test('ignores non-existent fields', async () => {
+        const result = await getCasesTool.handler(
+            { project_id: '1', fields: ['priority_id', 'nonexistent_field'] },
+            mockClient
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases[0]).toEqual({
+            id: 1,
+            title: 'Login test',
+            suite_id: 1,
+            priority_id: 2,
+        });
+    });
+
+    test('handler returns error on failure', async () => {
+        getCasesMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getCasesTool.handler({ project_id: '1' }, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+
+    test('filters cases using where clause with single condition', async () => {
+        const result = await getCasesTool.handler(
+            { project_id: '1', where: { custom_automation_status: 1 } },
+            mockClient
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases).toHaveLength(1);
+        expect(parsed.cases[0].id).toBe(1);
+        expect(parsed.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
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases).toHaveLength(1);
+        expect(parsed.cases[0].id).toBe(2);
+        expect(parsed.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
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.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
+        );
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.cases).toHaveLength(1);
+        expect(parsed.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

@@ -0,0 +1,75 @@
+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', announcement: null, is_completed: false, suite_mode: 1 },
+        { id: 2, name: 'Project Beta', announcement: 'Active project', is_completed: false, suite_mode: 3 },
+        { id: 3, name: 'Old Project', announcement: null, 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.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.projects).toHaveLength(2); // Only active projects
+        expect(mockClient.getProjects).toHaveBeenCalled();
+    });
+
+    test('filters out completed projects', async () => {
+        const result = await getProjectsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        const completedProject = parsed.projects.find((p: any) => p.name === 'Old Project');
+        expect(completedProject).toBeUndefined();
+    });
+
+    test('returns correct project structure', async () => {
+        const result = await getProjectsTool.handler({}, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.projects[0]).toEqual({
+            id: 1,
+            name: 'Project Alpha',
+        });
+
+        expect(parsed.projects[1]).toEqual({
+            id: 2,
+            name: 'Project Beta',
+        });
+    });
+
+    test('handler returns error on failure', async () => {
+        getProjectsMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getProjectsTool.handler({}, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+});

package/test/tools/get_sections.test.ts

@@ -0,0 +1,68 @@
+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, depth: 0, display_order: 1, suite_id: 1 },
+        { id: 2, name: 'Authentication', description: 'Auth tests', parent_id: 1, depth: 1, display_order: 2, suite_id: 1 },
+        { id: 3, name: 'Registration', description: null, parent_id: null, depth: 0, display_order: 3, 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 fetches and returns sections', async () => {
+        const result = await getSectionsTool.handler({ project_id: '1' }, mockClient);
+
+        expect(result).toBeDefined();
+        expect(result.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.sections).toHaveLength(3);
+        expect(mockClient.getSections).toHaveBeenCalledWith('1');
+    });
+
+    test('returns correct section structure', async () => {
+        const result = await getSectionsTool.handler({ project_id: '1' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.sections[0]).toEqual({
+            id: 1,
+            name: 'Login',
+        });
+
+        expect(parsed.sections[1]).toEqual({
+            id: 2,
+            name: 'Authentication',
+        });
+    });
+
+    test('handler returns error on failure', async () => {
+        getSectionsMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getSectionsTool.handler({ project_id: '1' }, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+});

package/test/tools/get_templates.test.ts

@@ -0,0 +1,67 @@
+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.content[0].type).toBe('text');
+
+        const parsed = JSON.parse(result.content[0].text);
+        expect(parsed.templates).toHaveLength(3);
+        expect(mockClient.getTemplates).toHaveBeenCalledWith('1');
+    });
+
+    test('returns correct template structure', async () => {
+        const result = await getTemplatesTool.handler({ project_id: '1' }, mockClient);
+        const parsed = JSON.parse(result.content[0].text);
+
+        expect(parsed.templates[0]).toEqual({
+            id: 1,
+            name: 'Test Case (Text)',
+        });
+
+        expect(parsed.templates[1]).toEqual({
+            id: 2,
+            name: 'Test Case (Steps)',
+        });
+    });
+
+    test('handler returns error on failure', async () => {
+        getTemplatesMock.mockRejectedValue(new Error('API Error'));
+
+        const result = await getTemplatesTool.handler({ project_id: '1' }, mockClient);
+
+        expect(result).toEqual({
+            content: [{ type: 'text', text: 'Error: API Error' }],
+            isError: true
+        });
+    });
+});