@uarlouski/testrail-mcp-server 1.2.0 → 1.3.1

package/src/client/testrail.ts

@@ -1,161 +0,0 @@
-import { Case, Section, Priority, CaseType, CaseField, Template, Project } from "../types/testrail.js";
-
-interface PaginatedCasesResponse {
-    cases: Case[];
-    _links: { next: string | null };
-}
-
-const API_INDEX = '/index.php?';
-const API_BASE_V2 = `${API_INDEX}/api/v2`;
-
-export class TestRailClient {
-    private baseUrl: string;
-    private headers: HeadersInit;
-    private prioritiesPromise: Promise<Priority[]> | null = null;
-    private caseTypesPromise: Promise<CaseType[]> | null = null;
-    private caseFieldsPromise: Promise<CaseField[]> | null = null;
-    private projectsPromise: Promise<Project[]> | null = null;
-    private templatesPromiseMap: Map<string, Promise<Template[]>> = new Map();
-
-    constructor(baseUrl: string, email: string, apiKey: string) {
-        this.baseUrl = baseUrl.replace(/\/$/, "");
-        const auth = Buffer.from(`${email}:${apiKey}`).toString('base64');
-        this.headers = {
-            "Content-Type": "application/json",
-            "Authorization": `Basic ${auth}`,
-        };
-    }
-
-    async getCase(caseId: string): Promise<Case> {
-        return this.get<Case>(`${API_BASE_V2}/get_case/${caseId}`);
-    }
-
-    async getCases(projectId: string, sectionId?: string, filter?: Record<string, string>): Promise<Case[]> {
-        let url = `${API_BASE_V2}/get_cases/${projectId}`;
-
-        if (sectionId) {
-            url += `&section_id=${sectionId}`;
-        }
-
-        if (filter) {
-            for (const [key, value] of Object.entries(filter)) {
-                url += `&${key}=${encodeURIComponent(value)}`;
-            }
-        }
-
-        const allCases: Case[] = [];
-        let nextUrl: string | null = url;
-
-        while (nextUrl) {
-            const response: PaginatedCasesResponse = await this.get<PaginatedCasesResponse>(nextUrl);
-
-            allCases.push(...response.cases);
-
-            nextUrl = response._links?.next;
-            if (nextUrl) {
-                nextUrl = `${API_INDEX}${nextUrl}`;
-            }
-        }
-
-        return allCases;
-    }
-
-    async getSection(sectionId: string): Promise<Section> {
-        return this.get<Section>(`${API_BASE_V2}/get_section/${sectionId}`);
-    }
-
-    async getPriorities(): Promise<Priority[]> {
-        if (!this.prioritiesPromise) {
-            this.prioritiesPromise = this.get<Priority[]>(`${API_BASE_V2}/get_priorities`);
-        }
-        return this.prioritiesPromise;
-    }
-
-    async getCaseTypes(): Promise<CaseType[]> {
-        if (!this.caseTypesPromise) {
-            this.caseTypesPromise = this.get<CaseType[]>(`${API_BASE_V2}/get_case_types`);
-        }
-        return this.caseTypesPromise;
-    }
-
-    async getCaseFields(): Promise<CaseField[]> {
-        if (!this.caseFieldsPromise) {
-            this.caseFieldsPromise = this.get<CaseField[]>(`${API_BASE_V2}/get_case_fields`);
-        }
-        return this.caseFieldsPromise;
-    }
-
-    async getTemplates(projectId: string): Promise<Template[]> {
-        if (!this.templatesPromiseMap.has(projectId)) {
-            this.templatesPromiseMap.set(
-                projectId,
-                this.get<Template[]>(`${API_BASE_V2}/get_templates/${projectId}`)
-            );
-        }
-        return this.templatesPromiseMap.get(projectId)!;
-    }
-
-    async updateCase(caseId: string, fields: Record<string, any>): Promise<Case> {
-        return this.post<Case>(`${API_BASE_V2}/update_case/${caseId}`, fields);
-    }
-
-    async updateCases(caseIds: number[], fields: Record<string, any>): Promise<Case[]> {
-        // Assume the project is operating in single suite mode, get suite_id from the first case
-        const caseData = await this.getCase(String(caseIds[0]));
-
-        const response = await this.post<{ updated_cases: Case[] }>(`${API_BASE_V2}/update_cases/${caseData.suite_id}`, {
-            case_ids: caseIds,
-            ...fields,
-        });
-
-        return response.updated_cases;
-    }
-
-    async createCase(sectionId: string, fields: Record<string, any>): Promise<Case> {
-        return this.post<Case>(`${API_BASE_V2}/add_case/${sectionId}`, fields);
-    }
-
-    async getSections(projectId: string): Promise<Section[]> {
-        const response = await this.get<{ sections: Section[] }>(`${API_BASE_V2}/get_sections/${projectId}`);
-        return response.sections;
-    }
-
-    async getProjects(): Promise<Project[]> {
-        if (!this.projectsPromise) {
-            this.projectsPromise = this.get<{ projects: Project[] }>(`${API_BASE_V2}/get_projects`)
-                .then(response => response.projects);
-        }
-        return this.projectsPromise;
-    }
-
-    private async get<T>(endpoint: string): Promise<T> {
-        return this.executeRequest<T>('GET', endpoint);
-    }
-
-    private async post<T>(endpoint: string, data: Record<string, any>): Promise<T> {
-        return this.executeRequest<T>('POST', endpoint, data);
-    }
-
-    private async executeRequest<T>(method: 'GET' | 'POST', endpoint: string, data?: Record<string, any>): Promise<T> {
-        const url = `${this.baseUrl}${endpoint}`;
-        const params: RequestInit = {
-            method,
-            headers: this.headers,
-        };
-
-        if (data) {
-            params.body = JSON.stringify(data);
-        }
-
-        const response = await fetch(url, params);
-
-        if (!response.ok) {
-            let errorMessage = `TestRail: ${response.status} ${response.statusText}`;
-            const errorText = await response.text();
-            errorMessage += ` - ${errorText}`;
-            throw new Error(errorMessage);
-        }
-
-        return await response.json() as T;
-    }
-}

package/src/tools/create_case.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-
-const parameters = {
-    section_id: z.string().describe("The ID of the section where the case should be created"),
-    title: z.string().describe("The title of the test case (required)"),
-    fields: z.record(z.string(), z.any()).optional().describe("Optional object containing additional fields. Use get_case_fields to see available fields. Example: {\"priority_id\": 2, \"template_id\": 1, \"custom_automation_priority\": 1}"),
-};
-
-export const createCaseTool: ToolDefinition<typeof parameters, TestRailClient> = {
-    name: "create_case",
-    description: "Create a new test case in TestRail. IMPORTANT: Before creating a case, first call get_templates to discover available templates for the project, then use get_case_fields to see which fields are available for the chosen template. Requires section_id and title.",
-    parameters,
-    handler: async ({ section_id, title, fields }, client) => {
-        const caseData = {
-            title,
-            ...fields,
-        };
-
-        const createdCase = await client.createCase(section_id, caseData);
-
-        return {
-            success: true,
-            case_id: createdCase.id,
-            message: `Test case C${createdCase.id} created successfully`,
-        };
-    }
-};

package/src/tools/get_templates.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import { TestRailClient } from "../client/testrail.js";
-import { ToolDefinition } from "../types/custom.js";
-import { TemplateSchema } from "../types/testrail.js";
-
-const parameters = {
-    project_id: z.string().describe("The ID of the project"),
-};
-
-export const getTemplatesTool: ToolDefinition<typeof parameters, TestRailClient> = {
-    name: "get_templates",
-    description: "Get available test case templates for a project. Returns template IDs and names. Use template IDs with get_case_fields to understand which fields apply to each template.",
-    parameters,
-    handler: async ({ project_id }, client) => {
-        const templates = await client.getTemplates(project_id);
-
-        const response = {
-            templates: templates.map(t => TemplateSchema.parse(t)),
-        };
-
-        return response;
-    }
-};

package/src/types/custom.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-
-export interface TestCaseResponse {
-    id: number;
-    title: string;
-    section: string;
-    type: string;
-    priority: string;
-    labels: string[];
-    references: string | null;
-    [key: string]: any;
-}
-
-export interface ToolDefinition<T extends z.ZodRawShape, Context = any> {
-    name: string;
-    description: string;
-    parameters: T;
-    handler: (args: z.infer<z.ZodObject<T>>, context: Context) => Promise<Record<string, any>>;
-}

package/test/client/testrail.test.ts

@@ -1,430 +0,0 @@
-import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
-import { TestRailClient } from '../../src/client/testrail.js';
-
-describe('TestRailClient', () => {
-    let client: TestRailClient;
-    let fetchMock: any;
-
-    beforeEach(() => {
-        fetchMock = jest.spyOn(global, 'fetch');
-        client = new TestRailClient('https://testrail.io/', 'user', 'apikey');
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    test('constructor cleans trailing slash from baseUrl', async () => {
-        const mockData = { id: 1, title: 'Test Case', template_id: 1 };
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        await client.getCase('1');
-
-        expect(fetchMock).toHaveBeenCalledWith('https://testrail.io/index.php?/api/v2/get_case/1', expect.any(Object));
-    });
-
-    test('getCase returns data on success', async () => {
-        const mockData = { id: 1, title: 'Test Case', template_id: 1 };
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getCase('1');
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith('https://testrail.io/index.php?/api/v2/get_case/1', expect.objectContaining({
-            method: 'GET',
-            headers: expect.objectContaining({
-                'Authorization': expect.stringContaining('Basic'),
-                'Content-Type': 'application/json'
-            })
-        }));
-    });
-
-    test('getCase throws formatted error on API error', async () => {
-        const errorResponse = { error: 'Case not found' };
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 404,
-            statusText: 'Not Found',
-            text: async () => JSON.stringify(errorResponse),
-            json: async () => errorResponse
-        });
-
-        await expect(client.getCase('999')).rejects.toThrow(
-            'TestRail: 404 Not Found - {"error":"Case not found"}'
-        );
-    });
-
-    test('getCase throws error containing raw text when response is not JSON', async () => {
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 500,
-            statusText: 'Internal Server Error',
-            text: async () => 'Not JSON Content',
-            json: async () => { throw new Error('Not JSON'); }
-        });
-
-        await expect(client.getCase('1')).rejects.toThrow(
-            'TestRail: 500 Internal Server Error - Not JSON Content'
-        );
-    });
-
-    test('getCases returns cases without pagination', async () => {
-        const mockCases = [{ id: 1, title: 'Case 1' }, { id: 2, title: 'Case 2' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ cases: mockCases, _links: { next: null } })
-        });
-
-        const result = await client.getCases('1');
-        expect(result).toEqual(mockCases);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_cases/1',
-            expect.objectContaining({ method: 'GET' })
-        );
-    });
-
-    test('getCases handles response with undefined _links', async () => {
-        const mockCases = [{ id: 1, title: 'Case 1' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ 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' }];
-
-        fetchMock
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => ({ cases: page1Cases, _links: { next: '/api/v2/get_cases/1&offset=1' } })
-            })
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => ({ cases: page2Cases, _links: { next: null } })
-            });
-
-        const result = await client.getCases('1');
-        expect(result).toEqual([...page1Cases, ...page2Cases]);
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_cases/1',
-            expect.any(Object)
-        );
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_cases/1&offset=1',
-            expect.any(Object)
-        );
-    });
-
-    test('getCases with sectionId adds section filter', async () => {
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ cases: [], _links: { next: null } })
-        });
-
-        await client.getCases('1', '5');
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_cases/1&section_id=5',
-            expect.any(Object)
-        );
-    });
-
-    test('getCases with filter adds query params', async () => {
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ cases: [], _links: { next: null } })
-        });
-
-        await client.getCases('1', undefined, { type_id: '1', priority_id: '2' });
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_cases/1&type_id=1&priority_id=2',
-            expect.any(Object)
-        );
-    });
-
-    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
-        };
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getSection('1');
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_section/1',
-            expect.any(Object)
-        );
-    });
-
-    test('getPriorities returns data on success', async () => {
-        const mockData = [{
-            id: 1,
-            is_default: true,
-            name: 'Low',
-            priority: 1,
-            short_name: 'Low'
-        }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getPriorities();
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_priorities',
-            expect.any(Object)
-        );
-    });
-
-    test('getPriorities caches result', async () => {
-        const mockData = [{ id: 1, name: 'Low' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        await client.getPriorities();
-        await client.getPriorities();
-
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-
-    test('getCaseTypes returns data on success', async () => {
-        const mockData = [{
-            id: 1,
-            is_default: true,
-            name: 'Automated'
-        }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getCaseTypes();
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_case_types',
-            expect.any(Object)
-        );
-    });
-
-    test('getCaseFields returns data on success', async () => {
-        const mockData = [{
-            id: 1,
-            name: 'custom_field',
-            system_name: 'custom_field',
-            label: 'Custom Field',
-            type_id: 1
-        }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getCaseFields();
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_case_fields',
-            expect.any(Object)
-        );
-    });
-
-    test('getCaseFields caches result', async () => {
-        const mockData = [{ id: 1, name: 'field' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        await client.getCaseFields();
-        await client.getCaseFields();
-
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-
-    test('getTemplates returns data on success', async () => {
-        const mockData = [{ id: 1, name: 'Test Template', is_default: true }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.getTemplates('1');
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_templates/1',
-            expect.any(Object)
-        );
-    });
-
-    test('getTemplates caches result per project', async () => {
-        const mockData1 = [{ id: 1, name: 'Template 1' }];
-        const mockData2 = [{ id: 2, name: 'Template 2' }];
-        fetchMock
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => mockData1
-            })
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => mockData2
-            });
-
-        await client.getTemplates('1');
-        await client.getTemplates('1');
-        await client.getTemplates('2');
-
-        expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-
-    test('updateCase sends POST request', async () => {
-        const mockData = { id: 1, title: 'Updated Case' };
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.updateCase('1', { title: 'Updated Case' });
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/update_case/1',
-            expect.objectContaining({
-                method: 'POST',
-                body: JSON.stringify({ 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' }];
-
-        fetchMock
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => mockCase
-            })
-            .mockResolvedValueOnce({
-                ok: true,
-                json: async () => ({ updated_cases: mockUpdated })
-            });
-
-        const result = await client.updateCases([1, 2], { title: 'Updated' });
-        expect(result).toEqual(mockUpdated);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_case/1',
-            expect.any(Object)
-        );
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/update_cases/10',
-            expect.objectContaining({
-                method: 'POST',
-                body: JSON.stringify({ case_ids: [1, 2], title: 'Updated' })
-            })
-        );
-    });
-
-    test('createCase sends POST request', async () => {
-        const mockData = { id: 1, title: 'New Case' };
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => mockData
-        });
-
-        const result = await client.createCase('5', { title: 'New Case' });
-        expect(result).toEqual(mockData);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/add_case/5',
-            expect.objectContaining({
-                method: 'POST',
-                body: JSON.stringify({ title: 'New Case' })
-            })
-        );
-    });
-
-    test('getSections returns sections array', async () => {
-        const mockSections = [{ id: 1, name: 'Section 1' }, { id: 2, name: 'Section 2' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ sections: mockSections })
-        });
-
-        const result = await client.getSections('1');
-        expect(result).toEqual(mockSections);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_sections/1',
-            expect.any(Object)
-        );
-    });
-
-    test('getProjects returns projects array', async () => {
-        const mockProjects = [{ id: 1, name: 'Project 1' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ projects: mockProjects })
-        });
-
-        const result = await client.getProjects();
-        expect(result).toEqual(mockProjects);
-        expect(fetchMock).toHaveBeenCalledWith(
-            'https://testrail.io/index.php?/api/v2/get_projects',
-            expect.any(Object)
-        );
-    });
-
-    test('getProjects caches result', async () => {
-        const mockProjects = [{ id: 1, name: 'Project 1' }];
-        fetchMock.mockResolvedValue({
-            ok: true,
-            json: async () => ({ projects: mockProjects })
-        });
-
-        await client.getProjects();
-        await client.getProjects();
-
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-    });
-
-    test('postRequest throws formatted error on API error', async () => {
-        const errorResponse = { error: 'Invalid field' };
-        fetchMock.mockResolvedValue({
-            ok: false,
-            status: 400,
-            statusText: 'Bad Request',
-            text: async () => JSON.stringify(errorResponse),
-            json: async () => errorResponse
-        });
-
-        await expect(client.updateCase('1', {})).rejects.toThrow(
-            'TestRail: 400 Bad Request - {"error":"Invalid field"}'
-        );
-    });
-
-    test('handleError formats error when network fails', async () => {
-        fetchMock.mockRejectedValue(new Error('Network Error'));
-
-        await expect(client.getCase('1')).rejects.toThrow(
-            'Network Error'
-        );
-    });
-});