Create Test Suite

Instructions

Implementation Reference

• handlers/createTestSuiteHandler.ts:14-38 (handler)

  Main handler function for the 'create_test_suite' tool. Validates input, resolves project UUID (by UUID or name via resolveProject), calls DebuggAIServerClient.createTestSuite API, and returns the created suite JSON.

  export async function createTestSuiteHandler(
    input: CreateTestSuiteInput,
    _context: ToolContext,
  ): Promise<ToolResponse> {
    const start = Date.now();
    logger.toolStart('create_test_suite', input);
    try {
      const client = new DebuggAIServerClient(config.api.key);
      await client.init();
  
      let projectUuid = input.projectUuid;
      if (!projectUuid) {
        const resolved = await resolveProject(client, input.projectName!);
        if ('error' in resolved) return errorResp(resolved.error, resolved.message, { candidates: resolved.candidates });
        projectUuid = resolved.uuid;
      }
  
      const suite = await client.createTestSuite({ name: input.name, description: input.description, projectUuid });
      logger.toolComplete('create_test_suite', Date.now() - start);
      return { content: [{ type: 'text', text: JSON.stringify(suite, null, 2) }] };
    } catch (error) {
      logger.toolError('create_test_suite', error as Error, Date.now() - start);
      throw handleExternalServiceError(error, 'DebuggAI', 'create_test_suite');
    }
  }

• types/index.ts:359-365 (schema)

  Zod schema and TypeScript type for create_test_suite input validation. Requires name, description, and optionally projectUuid or projectName.

  export const CreateTestSuiteInputSchema = z.object({
    name: z.string().min(1),
    description: z.string().min(1),
    ...projectIdentifier,
  }).strict();
  
  export type CreateTestSuiteInput = z.infer<typeof CreateTestSuiteInputSchema>;

• tools/testSuiteTools.ts:34-54 (registration)

  Tool definition builder: registers the tool with name 'create_test_suite', title, description, and inputSchema. Also exports buildValidatedCreateTestSuiteTool which pairs the schema with the handler.

  export function buildCreateTestSuiteTool(): Tool {
    return {
      name: 'create_test_suite',
      title: 'Create Test Suite',
      description: 'Create a named test suite for a project. A test suite is a collection of test cases that can be run together. Requires name, description, and a project identifier (projectUuid or projectName). Returns {uuid, name, description, runStatus, testsCount}.',
      inputSchema: {
        type: 'object',
        properties: {
          name: { type: 'string', description: 'Suite name. Required.', minLength: 1 },
          description: { type: 'string', description: 'Suite description. Required.', minLength: 1 },
          ...PROJECT_PROPS,
        },
        required: ['name', 'description'],
        additionalProperties: false,
      },
    };
  }
  
  export function buildValidatedCreateTestSuiteTool(): ValidatedTool {
    return { ...buildCreateTestSuiteTool(), inputSchema: CreateTestSuiteInputSchema, handler: createTestSuiteHandler };
  }

• tools/index.ts:48-85 (registration)

  Registration of create_test_suite in the global tool registry via initTools (line 48 for Tool, line 70 for ValidatedTool).

      buildCreateTestSuiteTool(),
      buildSearchTestSuitesTool(),
      buildDeleteTestSuiteTool(),
      buildCreateTestCaseTool(),
      buildUpdateTestCaseTool(),
      buildDeleteTestCaseTool(),
      buildRunTestSuiteTool(),
      buildGetTestSuiteResultsTool(),
    ];
    const validated: ValidatedTool[] = [
      buildValidatedTestPageChangesTool(ctx),
      buildValidatedTriggerCrawlTool(ctx),
      buildValidatedProbePageTool(),
      buildValidatedSearchProjectsTool(),
      buildValidatedSearchEnvironmentsTool(),
      buildValidatedCreateEnvironmentTool(),
      buildValidatedUpdateEnvironmentTool(),
      buildValidatedDeleteEnvironmentTool(),
      buildValidatedUpdateProjectTool(),
      buildValidatedDeleteProjectTool(),
      buildValidatedSearchExecutionsTool(),
      buildValidatedCreateProjectTool(),
      buildValidatedCreateTestSuiteTool(),
      buildValidatedSearchTestSuitesTool(),
      buildValidatedDeleteTestSuiteTool(),
      buildValidatedCreateTestCaseTool(),
      buildValidatedUpdateTestCaseTool(),
      buildValidatedDeleteTestCaseTool(),
      buildValidatedRunTestSuiteTool(),
      buildValidatedGetTestSuiteResultsTool(),
    ];
  
    _tools = tools;
    _validatedTools = validated;
  
    toolRegistry.clear();
    for (const v of validated) toolRegistry.set(v.name, v);
  }

• services/index.ts:525-537 (helper)

  DebuggAIServerClient.createTestSuite method: makes the actual HTTP POST to 'api/v1/test-suites/' API endpoint to create the test suite.

  public async createTestSuite(input: {
    name: string;
    description: string;
    projectUuid: string;
  }): Promise<{ uuid: string; name: string; description: string | null; runStatus: string; testsCount: number }> {
    if (!this.tx) throw new Error('Client not initialized — call init() first');
    const s = await this.tx.post<any>('api/v1/test-suites/', {
      name: input.name,
      description: input.description,
      project: input.projectUuid,
    });
    return this.mapTestSuite(s);
  }