QA-MCP: Test Standardization & Orchestration Server

Instructions

Implementation Reference

• src/qa_mcp/tools/compose.py:19-106 (handler)

  Main handler function that implements the core logic of the suite.compose tool, including test case selection, coverage analysis, and suite composition.

  def compose_suite(
      testcases: list[dict],
      target: str,
      sprint: str | None = None,
      max_duration_minutes: int | None = None,
      custom_criteria: dict[str, Any] | None = None,
  ) -> dict:
      """
      Compose a test suite from a collection of test cases.
  
      Args:
          testcases: List of test cases in QA-MCP standard format
          target: Suite type - 'smoke', 'sanity', 'regression', 'e2e'
          sprint: Sprint name/number for context
          max_duration_minutes: Maximum suite duration (overrides default)
          custom_criteria: Custom selection criteria
  
      Returns:
          Dictionary containing:
          - suite: Composed suite with selected test cases
          - selection_rationale: Why each test was included/excluded
          - coverage_summary: What's covered and what's not
          - recommendations: Suggestions for improving coverage
      """
      # Parse test cases
      parsed_cases = []
      parse_errors = []
  
      for idx, tc_dict in enumerate(testcases):
          try:
              tc = TestCase(**tc_dict)
              parsed_cases.append(tc)
          except Exception as e:
              parse_errors.append(f"Test case {idx}: {str(e)}")
  
      if parse_errors:
          return {
              "suite": None,
              "selection_rationale": [],
              "coverage_summary": {},
              "recommendations": [],
              "errors": parse_errors,
          }
  
      # Get suite rules
      suite_type = SuiteType(target.lower())
      rules = SUITE_RULES.get(target.lower(), SUITE_RULES["regression"])
  
      # Override max duration if provided
      if max_duration_minutes:
          rules = {**rules, "max_duration_minutes": max_duration_minutes}
  
      # Select test cases
      selected, excluded, rationale = _select_testcases(parsed_cases, suite_type, rules)
  
      # Build coverage summary
      coverage_summary = _build_coverage_summary(parsed_cases, selected, suite_type)
  
      # Generate recommendations
      recommendations = _generate_recommendations(parsed_cases, selected, excluded, suite_type)
  
      # Calculate total duration
      total_duration = sum(
          tc.estimated_duration_minutes or 5  # Default 5 min per test
          for tc in selected
      )
  
      # Build suite composition
      suite = SuiteComposition(
          suite_type=suite_type,
          name=f"{target.upper()} Suite" + (f" - {sprint}" if sprint else ""),
          description=rules.get("description", f"{target} test suite"),
          testcases=[tc.id or f"TC-{idx}" for idx, tc in enumerate(selected)],
          total_duration_minutes=total_duration,
          coverage_summary=coverage_summary,
          rationale=f"{len(selected)} test case seçildi, toplam {total_duration} dakika",
      )
  
      return {
          "suite": suite.model_dump(),
          "selected_testcases": [tc.model_dump() for tc in selected],
          "excluded_count": len(excluded),
          "selection_rationale": rationale,
          "coverage_summary": coverage_summary,
          "recommendations": recommendations,
          "duration_warning": total_duration > rules.get("max_duration_minutes", 999),
      }

• src/qa_mcp/server.py:238-265 (registration)

  Registration of the suite.compose tool in the MCP server, including name, description, and input schema.

  Tool(
      name="suite.compose",
      description="Test case listesinden Smoke/Regression/E2E suite oluşturur",
      inputSchema={
          "type": "object",
          "properties": {
              "testcases": {
                  "type": "array",
                  "items": {"type": "object"},
                  "description": "Test case listesi",
              },
              "target": {
                  "type": "string",
                  "enum": ["smoke", "sanity", "regression", "e2e"],
                  "description": "Suite tipi",
              },
              "sprint": {
                  "type": "string",
                  "description": "Sprint adı/numarası (opsiyonel)",
              },
              "max_duration_minutes": {
                  "type": "integer",
                  "description": "Maksimum suite süresi (dakika)",
              },
          },
          "required": ["testcases", "target"],
      },
  ),

• src/qa_mcp/server.py:376-384 (handler)

  Tool dispatcher in call_tool() that invokes the compose_suite handler for suite.compose calls.

  elif name == "suite.compose":
      result = compose_suite(
          testcases=arguments["testcases"],
          target=arguments["target"],
          sprint=arguments.get("sprint"),
          max_duration_minutes=arguments.get("max_duration_minutes"),
      )
      audit_log(name, arguments, f"Composed {arguments['target']} suite")