post-dev-test
/post-dev-test
Post-development test completion. Use when: checking test coverage after feature-dev, writing missing integration/e2e tests. Not for: unit test generation (use codex-test-gen), test review (use test-review). Output: test files + coverage report.
- Author
- sd0xdev ↗
- Repository
- sd0x-harness ↗
- Licence
- MIT
- Last repository change
- 08.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 08.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Post-development test completion. Use when: checking test coverage after feature-dev, writing missing integration/e2e tests. Not for: unit test generation (use codex-test-gen), test review (use test-review). Output: test files + coverage report.
Original author description
Post-development test completion. Use when: checking test coverage after feature-dev, writing missing integration/e2e tests. Not for: unit test generation (use codex-test-gen), test review (use test-review). Output: test files + coverage report.
How it works
- Trigger
- When to Use
- Key Rule: Must Execute on Changes
- When NOT to Use
- Workflow
- Test File Conventions
- Test Template
- Output
- Verification
- Execute Tests
SKILL.md preview
---
name: post-dev-test
description: "Post-development test completion. Use when: checking test coverage after feature-dev, writing missing integration/e2e tests. Not for: unit test generation (use codex-test-gen), test review (use test-review). Output: test files + coverage report."
allowed-tools: Read, Grep, Glob, Write, Bash
---
# Post-Dev Test Skill
## Trigger
- Keywords: add tests, integration test, e2e test, test coverage, post dev test
## When to Use
- After completing feature development, before /precommit
- Want to ensure new features have sufficient integration/e2e coverage
- Unit tests exist, but higher-level tests are missing
## Key Rule: Must Execute on Changes
**Even if test coverage looks complete, tests must be executed whenever there are code changes.**
| Scenario | Action |
| ---------------------------- | ------------------------------------ |
| Code changes exist | Must execute related integration/e2e |
| Tests exist and are complete | Still execute to confirm no regression |
| Tests missing or insufficient| Write then execute |
| Pure doc/comment changes | Can skip |
**Reason**: Test coverage does not equal tests passing. Existing tests may fail due to code changes.
## When NOT to Use
- Only need unit tests (use `/codex-test-gen`)
- Review existing tests (use `/codex-test-review`)
- Still in development (complete `/feature-dev` flow first)
## Workflow
```
┌─────────────────────────────────────────────────────────────────┐
│ Phase 1: Analyze Context │
├─────────────────────────────────────────────────────────────────┤
│ 1. From conversation history: what feature was developed? │
│ 2. Identify involved Service / Provider / Controller │
│ 3. List core flows and API endpoints │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 2: Check Existing Test Coverage │
├─────────────────────────────────────────────────────────────────┤
│ 1. Search test/integration/ for related tests │
│ 2. Search test/e2e/ for related tests │
│ 3. Assess coverage gaps │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 3: Determine Test Strategy │
├─────────────────────────────────────────────────────────────────┤
│ ┌──────────────┬────────────────────────────────────────────┐ │
│ │ Change Type │ Test Requirement │ │
│ ├──────────────┼────────────────────────────────────────────┤ │
│ │ New API │ Integration test (Controller + Service) │ │
│ │ New Service │ Integration test (Service layer) │ │
│ │ Cross-svc │ E2E test (complete flow) │ │
│ │ DB operation │ Integration test (actual DB) │ │
│ │ External API │ Integration test (mock external) │ │
│ └──────────────┴────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 4: Write Tests │
├─────────────────────────────────────────────────────────────────┤
│ 1. Reference existing test patterns │
│ 2. Use {FRAMEWORK_MOCK_LIB} createApp / createRequester │
│ 3. Follow TEST_ENV environment variable conventions │
│ 4. Write to corresponding directory │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 5: Execute Verification │
├─────────────────────────────────────────────────────────────────┤
│ 1. Execute newly added tests │
│ 2. Confirm passing │
│ 3. Report results │
└─────────────────────────────────────────────────────────────────┘
```
## Test File Conventions
| Type | Directory | Naming | Env Variable |
| ----------- | ------------------- | -------------------------------------- | ---------------------- |
| Integration | `test/integration/` | `*.integration.test.ts` or `*.test.ts` | `TEST_ENV=integration` |
| E2E | `test/e2e/` | `*.e2e.test.ts` or `*.test.ts` | `TEST_ENV=e2e` |
## Test Template
```typescript
import { Application, Framework } from '{FRAMEWORK_WEB}';
import { close, createApp } from '{FRAMEWORK_MOCK_LIB}';
import { ITestRequester, createRequester } from '../../createRequester';
import { TestEnvironment, onlyIf } from '../../helper/test-env';
const describeIntegration = onlyIf([
TestEnvironment.INTEGRATION,
TestEnvironment.E2E,
]);
describeIntegration('Feature Integration Tests', () => {
let app: Application;
let request: ITestRequester;
beforeAll(async () => {
app = await createApp<Framework>();
request = await createRequester(app);
});
afterAll(async () => {
await close(app);
});
describe('Scenario: ...', () => {
it('should ...', async () => {
// Arrange
// Act
// Assert
});
});
});
```
## Output
- Test files (integration/e2e) in correct directories
- Coverage delta report
- Gate: ✅ Coverage sufficient / ⛔ Gaps remaining
## Verification
- [ ] Test files in correct directory
- [ ] Using correct TEST_ENV condition
- [ ] Tests can run independently
- [ ] Covers main flow + error scenarios
## Execute Tests
```bash
# Execute single integration test
TEST_ENV=integration yarn jest test/integration/path/to/test.ts
# Execute single e2e test
TEST_ENV=e2e yarn jest test/e2e/path/to/test.ts
```
## Examples
```
Input: (User Authentication feature developed in conversation)
Phase 1: Identify ActiveAssetsWeeklyService, ActiveAssetsCacheService involved
Phase 2: Search test/e2e/auth/ -> found missing login test
Phase 3: Decide to write E2E test (cross-service flow)
Phase 4: Write active-assets-weekly.e2e.test.ts
Phase 5: Execute test and verify passing
```
```
Input: (New API endpoint developed in conversation)
Phase 1: Identify Controller + Service
Phase 2: Search test/integration/controller/ -> no corresponding test
Phase 3: Decide to write Integration test
Phase 4: Write new-feature.integration.test.ts
Phase 5: Execute test and verify passing
```
## References
- `references/test-patterns.md` - Existing test pattern reference
Files in this package (2)
- SKILL.md 9 KB
- references/test-patterns.md 5 KB
Versions
The database has no other skills named post-dev-test.
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version d01e1aa3f055 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100test-review
Test coverage review via Codex exec. Use when: reviewing test sufficiency, identifying coverage gaps, test quality audit. Not for: generating tests (use codex-test-gen), code review (use codex-code-review). Output: coverage analysis + gap report. - 90dev-test-strategy
Use to design or validate test plans, unit/integration/e2e coverage, automation, CI checks, fixtures, and regression scope. - 100test-deep
Context-aware test orchestration. Use when: smart test selection, failure triage, progressive test ladder, test failure analysis. Not for: writing tests (use post-dev-test), reviewing tests (use codex-test-review), generating tests (use codex-test-gen), full manual run (use… - 100test-generation-patterns
Use this skill when generating tests with AI assistance. Activate when the user wants to create unit tests, integration tests, generate test cases, improve test coverage, write tests for existing code, or set up testing patterns for their project. - 100test-unit
Write unit and integration tests for a named module or change. Use when "write unit tests" or "add tests for this function". Coverage plan → plan-test-coverage. Mutation score → test-mutation. Browser check → test-playwright. - 100tdd
Test-driven development workflow. Use when the user asks to "write tests first", "TDD", "add test coverage", "test this function", or wants to develop a feature test-first.