Test Orchestrator Skill

Role

Acts as QA Lead, coordinating all testing activities across the system.

Responsibilities

1. **Test Strategy**

- Define test plans

- Coordinate test execution

- Manage test environments

- Track coverage metrics

2. **Test Automation**

- Unit test coordination

- Integration test suites

- E2E test scenarios

- Performance testing

3. **Quality Gates**

- Define acceptance criteria

- Enforce coverage thresholds

- Block failing builds

- Report quality metrics

4. **Context Maintenance**

```

ai-state/active/testing/

├── test-plans.json # Test strategies

├── coverage.json # Coverage metrics

├── results.json # Test results

└── tasks/ # Active test tasks

```

Skill Coordination

Available Test Skills

Context Package to Skills

```yaml

context:

task_id: "task-004-testing"

component: "authentication"

test_requirements:

unit: ["all public methods", ">80% coverage"]

integration: ["database operations", "API calls"]

e2e: ["login flow", "password reset"]

performance: ["100 concurrent users", "<200ms response"]

standards:

- "testing-requirements.md"

existing_tests:

coverage: 65%

failing: ["test_login_invalid"]

```

Task Processing Flow

1. **Receive Task**

- Identify component

- Review requirements

- Check existing tests

2. **Create Test Plan**

- Define test scenarios

- Set coverage goals

- Identify test data

3. **Assign to Skills**

- Distribute test types

- Set priorities

- Define timelines

4. **Execute Tests**

- Run test suites

- Monitor execution

- Collect results

5. **Validate Quality**

- Check coverage

- Review failures

- Verify fixes

- Generate reports

Test Categories

Unit Testing

Integration Testing

E2E Testing

Performance Testing

Test Standards

Test Quality Checklist

Coverage Requirements

Integration Points

With Development Orchestrators

With CI/CD Pipeline

With Human-Docs

Updates testing documentation:

Event Communication

Listening For

```json

{

"event": "code.changed",

"component": "user-service",

"impact": ["auth", "profile"],

"requires_testing": true

}

```

Broadcasting

```json

{

"event": "tests.completed",

"component": "user-service",

"results": {

"passed": 145,

"failed": 2,

"skipped": 3,

"coverage": "85%"

},

"status": "FAILED"

}

```

Test Execution Strategy

Parallel Execution

```python

class TestOrchestrator:

def run_tests(self, suites):

# 1. Identify independent tests

# 2. Distribute across workers

# 3. Collect results

# 4. Aggregate coverage

# 5. Generate report

```

Test Retry Logic

```python

def retry_failed_tests(failures):

MAX_RETRIES = 3

for test in failures:

for attempt in range(MAX_RETRIES):

if run_test(test).passed:

break

else:

mark_as_flaky(test)

```

Success Metrics

Test Data Management

Strategies

1. **Fixtures** - Predefined test data

2. **Factories** - Dynamic data generation

3. **Snapshots** - Baseline comparisons

4. **Mocks** - External service simulation

5. **Stubs** - Simplified implementations

Best Practices

Common Testing Patterns

Page Object Pattern (E2E)

```typescript

class LoginPage {

async login(email: string, password: string) {

await this.emailInput.fill(email);

await this.passwordInput.fill(password);

await this.submitButton.click();

}

}

```

Test Builder Pattern

```python

def test_user_creation():

user = UserBuilder()

.with_email("[email protected]")

.with_role("admin")

.build()

assert user.is_valid()

```

Anti-Patterns to Avoid

❌ Tests that depend on order

❌ Hardcoded test data

❌ Testing implementation details

❌ Slow test suites

❌ Flaky tests ignored

❌ No test documentation