npx skills use modu-ai/moai-adk@moai-ref-testing-pyramid
指定 Agent (Claude Code)
npx skills add modu-ai/moai-adk --skill moai-ref-testing-pyramid -a claude-code -g -y
安装 repo 全部 skill
npx skills add modu-ai/moai-adk --all -g -y
预览 repo 内 skill
npx skills add modu-ai/moai-adk --list
SKILL.md
Frontmatter
{
"name": "moai-ref-testing-pyramid",
"metadata": {
"tags": "testing, pyramid, coverage, tdd, patterns, reference",
"status": "active",
"updated": "2026-03-30",
"version": "1.0.0",
"category": "domain"
},
"description": "Test pyramid strategy, coverage targets, test patterns, and quality metrics reference. Agent-extending skill that amplifies manager-develop test-creation and quality-validation work with production-grade testing patterns. NOT for: production code implementation, architecture design, DevOps, security audits.\n",
"when_to_use": "Use for test-pyramid strategy reference: coverage targets, unit\/integration\/e2e test patterns, and quality metrics. Amplifies manager-develop test-creation and quality-validation work with production-grade testing patterns.\n",
"user-invocable": false,
"progressive_disclosure": {
"enabled": true,
"level1_tokens": 100,
"level2_tokens": 3000
}
}
Testing Pyramid Reference
Target Agents
manager-develop - Primary: applies patterns during test creation and coverage analysis
manager-develop - Secondary: applies during RED-GREEN-REFACTOR cycles
Test Pyramid Ratios
/ E2E \ 10% — Critical user journeys only
/----------\
/ Integration \ 20% — API endpoints, DB queries, service boundaries
/----------------\
/ Unit Tests \ 70% — Functions, hooks, utilities, pure logic
/--------------------\
Level
Speed
Reliability
Maintenance
Coverage Target
Unit
Fast (<100ms)
High
Low
70% of tests
Integration
Medium (1-5s)
Medium
Medium
20% of tests
E2E
Slow (10-60s)
Lower
High
10% of tests
Coverage Targets by Context
Context
Target
Rationale
Critical business logic
95%+
Revenue/security impact
API endpoints
90%+
Contract compliance
Utility functions
85%+
Reuse reliability
UI components
80%+
Rendering correctness
Configuration/glue code
60%+
Low complexity
Generated code
0%
Don't test generated code
Test Pattern: AAA (Arrange-Act-Assert)
// Arrange: Set up test data and preconditions
input := CreateTestUser("test@example.com")
// Act: Execute the function under test
result, err := service.CreateUser(ctx, input)
// Assert: Verify the outcome
assert.NoError(t, err)
assert.Equal(t, "test@example.com", result.Email)
CSS styling and layout (use visual regression tools instead)
Test Quality Metrics
Metric
Target
Tool
Line Coverage
85%+
go test -cover, istanbul, coverage.py
Branch Coverage
75%+
go test -covermode=count
Mutation Score
70%+
go-mutesting, Stryker
Test Execution Time
<2 min (unit), <10 min (all)
CI timer
Flaky Test Rate
<1%
CI history analysis
Test File Conventions
Language
Test File
Location
Go
*_test.go
Same package
TypeScript
*.test.ts / *.spec.ts
__tests__/ or co-located
Python
test_*.py
tests/ directory
Java
*Test.java
src/test/ mirror
Rust
#[cfg(test)] mod tests
Same file or tests/
TDD RED-GREEN-REFACTOR Quick Reference
RED: Write a failing test that defines expected behavior
GREEN: Write minimal code to make the test pass
REFACTOR: Clean up while keeping tests green
Rules:
Never write production code without a failing test
Write the smallest test that fails
Write the simplest code that passes
Refactor only when all tests are green
One assertion per test (when practical)
Common Rationalizations
Rationalization
Reality
"E2E tests cover everything, unit tests are redundant"
E2E tests are slow and flaky. Unit tests provide fast, precise feedback. The pyramid exists because each level serves a different purpose.
"Integration tests are more realistic than unit tests"
Realism comes at the cost of speed and isolation. A balanced pyramid gives both fast feedback and realistic validation.
"100% code coverage means the code is well tested"
Coverage measures execution, not correctness. A test that executes code without meaningful assertions provides zero value.
"Mocking is bad, I prefer real dependencies"
Real dependencies make tests slow and non-deterministic. Mock at boundaries, test business logic in isolation.
"This test is flaky, but it catches real bugs sometimes"
Flaky tests erode trust in the entire suite. Fix the flakiness or quarantine the test with a tracking issue.
DAMP over DRY: Test code should be descriptive and self-contained. A reader should understand the test without reading shared fixtures or helper methods.
Red Flags
Test pyramid inverted: more E2E tests than unit tests
Unit tests depend on external services (databases, APIs, file systems)
Test assertions check implementation details instead of behavior
No integration tests between unit and E2E layers
Flaky test present without a quarantine label or tracking issue
Verification
Test distribution follows the pyramid: unit > integration > E2E (show test counts per category)
Unit tests run in under 30 seconds total
Integration tests mock external dependencies at the boundary
No flaky tests in the active suite (run 3x to verify stability)
Test names describe behavior, not implementation (review naming convention)
Coverage report shows meaningful assertions, not just line execution
