Testing

What this skill can do:

• ✅ Generate unit tests
• ✅ Generate integration tests
• ✅ Create test fixtures and mocks
• ✅ Set up test data factories
• ✅ Analyze coverage gaps
• ✅ Follow project's existing test patterns

Dependencies

• context.md - For project context
• .github/copilot/docs/testing.md - For test strategy
• coding.skill - Chains from after implementation
• Existing tests - For pattern matching
• .github/skills/index.yaml - To verify specialized test skill coverage

Coverage Boundary (MANDATORY)

This core testing skill covers generic unit/integration/component/e2e workflows.

Before executing, run a specialization check:

1. Extract requested test subtype from the user prompt
2. Check if subtype is explicitly covered in this skill
3. Check if a dedicated skill already exists in .github/skills/index.yaml
4. If subtype is specialized and uncovered:
  - STOP direct test generation
  - Trigger missing-skill generation via setup workflow
  - Create/register dedicated skill (example: test-contract/SKILL.md)
  - Re-route execution to that new skill

Specialized subtypes that require dedicated skills when not already covered:

• contract testing
• mutation testing
• load or stress testing
• chaos testing
• fuzz testing
• security penetration testing
• advanced snapshot governance

Workflow

Step 1: Understand Test Requirements

1. Read .github/copilot/docs/testing.md for:
   - Test framework (Jest, Vitest, pytest, etc.)
   - Coverage requirements
   - Test structure conventions
   
2. Read existing tests to match patterns

Step 2: Identify Test Scope

Step 3: Generate Tests with Mocking

┌─────────────────────────────────────────────────────────────────────────┐
│  MANDATORY: USE MOCKING DATA                                            │
│                                                                         │
│  ALL tests MUST use mocked data:                                        │
│  • Mock external API calls                                              │
│  • Mock database operations                                             │
│  • Mock file system operations                                          │
│  • Mock time-dependent functions                                        │
│                                                                         │
│  NEVER make real external calls in tests                                │
└─────────────────────────────────────────────────────────────────────────┘

Step 4: Test Structure Template

Unit Test Template

// [language: TypeScript/Jest example]
describe('[ModuleName]', () => {
  // Setup
  beforeEach(() => {
    // Reset mocks
  });

  describe('[functionName]', () => {
    it('should [expected behavior] when [condition]', () => {
      // Arrange
      const mockData = { /* mocked input */ };
      
      // Act
      const result = functionName(mockData);
      
      // Assert
      expect(result).toEqual(expected);
    });

    it('should handle [edge case]', () => {
      // Test edge case
    });

    it('should throw when [error condition]', () => {
      // Test error handling
    });
  });
});

Integration Test Template

describe('[API Endpoint]', () => {
  // Mocked dependencies
  let mockDb: MockDatabase;
  let mockAuth: MockAuthService;

  beforeAll(() => {
    mockDb = createMockDatabase();
    mockAuth = createMockAuth();
  });

  afterEach(() => {
    mockDb.reset();
  });

  describe('GET /api/[resource]', () => {
    it('should return [expected] when authenticated', async () => {
      // Arrange
      mockAuth.setUser({ id: 'test-user' });
      mockDb.seed([{ /* test data */ }]);

      // Act
      const response = await request(app).get('/api/resource');

      // Assert
      expect(response.status).toBe(200);
      expect(response.body).toMatchObject({ /* expected */ });
    });

    it('should return 401 when not authenticated', async () => {
      mockAuth.setUser(null);
      const response = await request(app).get('/api/resource');
      expect(response.status).toBe(401);
    });
  });
});

Step 5: Mock Data Factories

Create reusable mock data:

// tests/factories/user.factory.ts
export const createMockUser = (overrides = {}) => ({
  id: 'test-user-id',
  email: '[email protected]',
  name: 'Test User',
  createdAt: new Date('2024-01-01'),
  ...overrides
});

// tests/mocks/database.mock.ts
export const createMockDatabase = () => ({
  users: [],
  seed: function(data) { this.users = data; },
  reset: function() { this.users = []; },
  findUser: function(id) { return this.users.find(u => u.id === id); }
});

Step 6: Coverage Requirements

┌─────────────────────────────────────────────────────────────────────────┐
│  TEST COVERAGE TARGETS                                                  │
│                                                                         │
│  Minimum coverage (unless project specifies otherwise):                 │
│  • Statements: 80%                                                      │
│  • Branches: 70%                                                        │
│  • Functions: 80%                                                       │
│  • Lines: 80%                                                           │
│                                                                         │
│  Critical paths (auth, payments, etc.): 90%+                            │
└─────────────────────────────────────────────────────────────────────────┘

Step 7: Test File Naming

Step 8: Run and Verify

After creating tests:

1. Run test suite
2. Verify all tests pass
3. Check coverage meets requirements
4. Report results

Test Checklist

Before completing:

• Tests created for new/modified code
• Mocking used for all external dependencies
• Edge cases covered
• Error conditions tested
• Tests follow project patterns
• All tests pass
• Coverage maintained or improved

Output Format

Return to orchestrator: