Test
Write and run tests for codeFrom its SKILL.md
npx -y skills add jmylchreest/aide --skill testAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 19 stars19 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
6.2 KB, as published. Nobody here has run it
Test Mode
Recommended model tier: balanced (sonnet) - this skill performs straightforward operations
Write comprehensive tests and run test suites.
Prerequisites
Before starting:
- Identify the code to be tested (function, module, feature)
- Understand the testing framework used in the project
Workflow
Step 1: Check Project Testing Decisions
Use the mcp__plugin_aide_aide__decision_get tool with topic testing to check for testing framework decisions.
Common frameworks by language:
- TypeScript/JavaScript: Vitest, Jest, Mocha
- Go: built-in
go test - Python: pytest, unittest
Step 2: Discover Existing Test Patterns
Use Glob to find test files:
- Pattern:
**/*.test.ts,**/*.spec.ts(TypeScript) - Pattern:
**/*_test.go(Go) - Pattern:
**/test_*.py,**/*_test.py(Python)
Use Grep to find test patterns in existing test files:
Grep pattern="describe\(" include="*.test.*"— find test suitesGrep pattern="it\(|test\(" include="*.test.*"— find test cases
Read an existing test file to understand:
- Import patterns
- Setup/teardown patterns
- Mocking approach
- Assertion style
Step 3: Analyze Target Code
Use mcp__plugin_aide_aide__code_symbols with the target file path to get function signatures.
Use mcp__plugin_aide_aide__code_search to find related types.
Identify:
- Input parameters and types
- Return type
- Side effects
- Dependencies to mock
- Edge cases
Step 4: Write Tests
Follow the project's testing conventions. Cover these scenarios:
Test Categories:
- Happy path - Normal, expected inputs
- Edge cases - Empty, null, boundary values
- Error cases - Invalid inputs, expected failures
- Async behavior - If applicable
Naming convention:
- Descriptive names that explain what is being tested
- Format: "should [expected behavior] when [condition]"
Step 5: Run Tests
# TypeScript/JavaScript
npm test # Run all tests
npm test -- --grep "name" # Run specific test
npm run test:coverage # Run with coverage
# Go
go test ./... # Run all tests
go test -v ./pkg/... # Verbose output
go test -cover ./... # With coverage
# Python
pytest # Run all tests
pytest -v # Verbose
pytest --cov # With coverage
Step 6: Verify Coverage
# Check coverage report
npm run test:coverage
# Go
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out
Coverage targets:
- New code: aim for >80%
- Critical paths: aim for >90%
- Focus on meaningful tests, not just coverage numbers
Failure Handling
| Failure | Action |
|---|---|
| Test imports fail | Check path aliases, ensure test config matches main |
| Mock not working | Verify mock setup, check dependency injection |
| Async test timeout | Add proper await, increase timeout if needed |
| Flaky test | Check for shared state, timing issues, or external deps |
| Coverage too low | Add edge case tests, error path tests |
Test Structure Templates
TypeScript/JavaScript (Vitest/Jest)
import { describe, it, expect, beforeEach, vi } from "vitest";
import { functionToTest } from "./module";
describe("functionToTest", () => {
beforeEach(() => {
// Reset state before each test
vi.clearAllMocks();
});
it("should return expected result for valid input", () => {
const result = functionToTest("valid input");
expect(result).toBe("expected output");
});
it("should handle empty input", () => {
const result = functionToTest("");
expect(result).toBe("");
});
it("should throw error for null input", () => {
expect(() => functionToTest(null)).toThrow("Input required");
});
it("should handle async operation", async () => {
const result = await functionToTest("async input");
expect(result).resolves.toBe("async output");
});
});
Go
func TestFunctionName(t *testing.T) {
tests := []struct {
name string
input string
want string
wantErr bool
}{
{"valid input", "input", "expected", false},
{"empty input", "", "", false},
{"invalid input", "bad", "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := FunctionName(tt.input)
if (err != nil) != tt.wantErr {
t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("got = %v, want %v", got, tt.want)
}
})
}
}
Python
import pytest
from module import function_to_test
class TestFunctionToTest:
def test_valid_input(self):
assert function_to_test("input") == "expected"
def test_empty_input(self):
assert function_to_test("") == ""
def test_invalid_input_raises(self):
with pytest.raises(ValueError):
function_to_test(None)
@pytest.fixture
def mock_dependency(self, mocker):
return mocker.patch("module.dependency")
MCP Tools
mcp__plugin_aide_aide__code_search- Find existing tests, patterns, typesmcp__plugin_aide_aide__code_symbols- Understand function signatures to testmcp__plugin_aide_aide__decision_get- Check testing framework decisions
Verification Criteria
Before completing:
- All new tests pass
- Existing tests still pass
- Coverage meets project standards
- Tests are deterministic (not flaky)
- Tests follow project conventions
Output Format
## Tests Added
### Files
- `path/to/file.test.ts` - 5 tests for UserService
### Test Cases
1. should create user with valid data
2. should reject duplicate email
3. should hash password before saving
4. should handle empty name
5. should validate email format
### Coverage
- New code: 92%
- Total project: 84%
### Verification
- All tests: PASS
- No flaky tests observed