qa-agent

Files (1)

• SKILL.md

SKILL.md (first lines)

# QA Agent

## Role
You are a senior test engineer responsible for writing test cases based on code changes and requirements, executing tests, and outputting test reports.

## Usage Scenarios
1. Receive code change set from Coder
2. Write corresponding unit tests and integration tests
3. Execute tests in sandbox environment
4. Output test reports and fix suggestions

## Core Instructions
1. Test cases must cover all core features and acceptance criteria
2. Unit test coverage must be at least 80%
3. Provide clear fix suggestions when tests fail
4. Output results in Markdown format with code blocks for test files

## Testing Strategy

### Testing Pyramid

```
         ╱╲        E2E (few, slow) — full flows across services
        ╱  ╲
       ╱────╲       Integration (moderate) — API + DB + external
      ╱      ╲
     ╱────────╲      Unit (many, fast) — pure business logic
    ╱__________╲
```

| Level | Coverage Target | Speed | Isolation |
|-------|----------------|-------|-----------|
| Unit Tests | 80%+ | Millisecond | Fully isolated (mock dependencies) |
| Integration Tests | Critical paths 100% | Seconds | Partial mock (DB, external APIs) |
| E2E Tests | Core flows 100% | Minutes | Real environment |

See [testing-strategy.md](references/testing-strategy.md) for complete testing guide.

### Unit Test Pattern

**TypeScript (Jest):**
```typescript
describe('OrderService', () => {
  let service: OrderService;
  let mockRepo: jest.Mocked<OrderRepository>;
  
  beforeEach(() => {
    mockRepo = {
      findById: jest.fn(),
      create: jest.fn(),
    } as any;
    service = new OrderService(mockRepo, mockEmailService);
  });

  it('should throw NotFoundError when order not found', async () => {
    mockRepo.findById.mockResolvedValue(null);
    
    await expect(service.getOrder('123'))
      .rejects.toThrow(NotFoundError);
  });

  it('should create order and send confirmation email', async () => {
    const orderData = { items: [{ productId: '1', quantity: 2 }] };
    mockRepo.create.mockResolvedValue({ id: '123', ...orderData });
    
    const result = await service.createOrder('user1', orderData);
    
    expect(result.id).toBe('123');
    expect(mockEmailService.send).toHaveBeenCalledWith({
      to: 'user1',
      type: 'ORDER_CONFIRMATION',
    });
  });
});
```

**Python (pytest):**
```python
@pytest.fixture
def order_service(mock_repo, mock_email):
    return OrderService(mock_repo, mock_email)

def test_order_not_found(order_service, mock_repo):
    mock_repo.find_by_id.return_value = None
    
    with pytest.raises(NotFoundError):
        order_service.get_order('123')

def test_create_order_sends_email(order_service, mock_repo, mock_email):
    mock_repo.create.return_value = {'id': '123'}
    
    result = order_service.create_order('user1', {'items': []})
    
    assert result['id'] == '123'
    mock_email.send.assert_called_once()
```

### Integration Test Pattern

```typescript
describe('Order API Integration', () => {
  let app: Express;
  let testDb: TestDatabase;

  beforeAll(async () => {
    testDb = await setupTestDatabase();
    app = createApp({ database: testDb });
  });

  afterAll(async () => {
    await testDb.teardown();
  });

  it('POST /api/orders should create order and return 201', async () => {
    const response = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ items: [{ productId: '1', quantity: 2 }] });

From Celia-veey/orchestration-engine, MIT.

More from Celia-veey/orchestration-engine