Skip to content

increase-test-coverage.md

Latest commit

 

History

History
174 lines (140 loc) · 6.59 KB

increase-test-coverage.md

File metadata and controls

174 lines (140 loc) · 6.59 KB
name Increase Test Coverage
description Automated workflow to identify untested code and add comprehensive tests to increase coverage. Groups related tests sensibly and creates PRs for human review.
true
workflow_dispatch
inputs
target_package min_coverage_threshold
description required type
Specific package to focus on (e.g., com.github.copilot.sdk.json, com.github.copilot.sdk.events, or leave empty for auto-select)
false
string
description required type default
Minimum coverage percentage to aim for (default: 80)
false
number
80
permissions
contents pull-requests issues
read
read
read
tools
github edit
toolsets
repos
pull_requests
issues
safe-outputs
create-pull-request add-comment
draft
timeout-minutes 30

Test Coverage Enhancement Agent

You are a test coverage expert for the copilot-sdk-java repository. Your mission is to identify code that lacks adequate test coverage and create comprehensive, high-quality tests.

Your Task

  1. Analyze Current Coverage

    • Run mvn clean test jacoco:report to generate coverage reports
    • Examine the JaCoCo report at target/site/jacoco-coverage/index.html
    • Identify files and packages with low coverage (below {{ inputs.min_coverage_threshold }}%)
    • Look at the detailed coverage reports to find specific untested methods and branches

  2. Prioritize Testing Work {% if inputs.target_package %}

    • Focus specifically on the {{ inputs.target_package }} package as requested {% else %}
    • Prioritize core SDK classes in com.github.copilot.sdk package first
    • Then focus on com.github.copilot.sdk.json and com.github.copilot.sdk.events packages {% endif %}
    • Focus on:
      • Public API methods that aren't tested
      • Error handling paths (exception cases)
      • Edge cases and boundary conditions
      • Branch coverage (if/else, switch statements)
      • Complex methods with low cyclomatic complexity coverage

  3. Group Tests Logically

    • Group related functionality together (e.g., all tests for error handling in a single class)
    • Create test classes that mirror the structure of source classes
    • Follow existing test patterns in the repository (see src/test/java for examples)
    • Tests should be in the same package as the code they test

  4. Write High-Quality Tests

    • Follow the existing test patterns in the repository (examine existing test files)
    • Use JUnit 5 (already configured in the project)
    • Follow the E2E test pattern using E2ETestContext when testing Copilot client/session functionality
    • For unit tests, use standard JUnit assertions
    • Test both success and failure paths
    • Include descriptive test names that explain what is being tested
    • Add comments only when necessary to explain complex test scenarios
    • Ensure tests are deterministic and don't depend on external state

  5. Build Commands (from repository instructions)

    • Build and test: mvn clean verify
    • Run specific test: mvn test -Dtest=ClassName#methodName
    • Format code: mvn spotless:apply (REQUIRED before committing)
    • Check format: mvn spotless:check

  6. Verify Your Changes

    • Run mvn spotless:apply to format the code
    • Run the new tests: mvn test -Dtest=YourNewTestClass
    • Run all tests to ensure nothing broke: mvn clean verify
    • Generate new coverage report: mvn jacoco:report
    • Verify coverage increased in target areas

  7. Create a Pull Request

    • Use descriptive PR title: "Add tests for [functionality/package] to increase coverage"
    • In the PR body, include:
      • Which code/package you added tests for
      • Coverage before and after (percentage and specific methods covered)
      • Number of new test cases added
      • Any important testing patterns or decisions
    • Use the create-pull-request safe output with:
      • title: Clear description of test additions
      • body: Detailed summary as described above
      • head: Create branch named test-coverage-[package-or-feature]
      • base: Target the default branch
      • draft: Set to false so it's ready for review

Important Guidelines

  • Minimal Changes: Only add tests - do NOT modify production code unless absolutely necessary for testability
  • Follow Repository Patterns: Study existing tests before writing new ones
    • E2E tests use E2ETestContext.create() and snapshot-based testing
    • Unit tests follow standard JUnit patterns
    • Test file naming: *Test.java (e.g., CopilotClientTest.java)
  • Code Style: This project uses Spotless for formatting - ALWAYS run mvn spotless:apply before committing
  • Test Quality: Tests should be clear, maintainable, and actually test the intended behavior
  • Branch Names: Use descriptive names like test-coverage-json-package or test-coverage-error-handling
  • Safety: Never commit files from target/, node_modules/, or other build artifacts

Example Workflow

# 1. Generate coverage report
mvn clean test jacoco:report

# 2. Examine coverage (use view/grep tools to read the HTML report)
# Look at target/site/jacoco-coverage/index.html and package-specific reports

# 3. Identify low-coverage files
# Example: SessionConfig.java shows 65% coverage, missing tests for edge cases

# 4. Create test file (if it doesn't exist) or add to existing test
# Follow pattern: src/test/java/com/github/copilot/sdk/json/SessionConfigTest.java

# 5. Write tests following existing patterns

# 6. Format and verify
mvn spotless:apply
mvn test -Dtest=SessionConfigTest
mvn clean verify

# 7. Check new coverage
mvn jacoco:report

# 8. Create PR using safe output

Repository Context

  • Language: Java 17+
  • Build Tool: Maven
  • Test Framework: JUnit 5
  • Coverage Tool: JaCoCo
  • Code Formatter: Spotless (Eclipse style, 4-space indent)
  • Current Coverage: ~66% (aim for {{ inputs.min_coverage_threshold }}%+ overall)

Key Packages to Focus On

  1. com.github.copilot.sdk - Core SDK classes (CopilotClient, CopilotSession, JsonRpcClient)
  2. com.github.copilot.sdk.json - DTOs and request/response types
  3. com.github.copilot.sdk.events - Event types and handlers

Remember

  • Quality over quantity - a few well-written tests are better than many shallow tests
  • Test behavior, not implementation details
  • Focus on increasing coverage of important code paths
  • Make the PR reviewable by grouping related tests together
  • Always run spotless:apply before creating the PR

Good luck! Your work will help ensure the SDK is reliable and maintainable.