post-dev-test
/post-dev-test
Uzupełnia testy po rozwoju funkcji: sprawdza pokrycie testami i pisze brakujące testy integracyjne i e2e, z plikami testów i raportem pokrycia.
- Autor
- sd0xdev ↗
- Repozytorium
- sd0x-harness ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 08.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 08.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Uzupełnia testy po rozwoju funkcji: sprawdza pokrycie testami i pisze brakujące testy integracyjne i e2e, z plikami testów i raportem pokrycia.
Oryginalny opis (EN)
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.
Jak działa
- Trigger
- When to Use
- Key Rule: Must Execute on Changes
- When NOT to Use
- Workflow
- Test File Conventions
- Test Template
- Output
- Verification
- Execute Tests
Podgląd SKILL.md
---
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
Pliki w paczce (2)
- SKILL.md 9 KB
- references/test-patterns.md 5 KB
Wersje
W bazie nie ma innych skilli o nazwie post-dev-test.
Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.
Migawka bazy z 13.11.2026 · wersja paczki d01e1aa3f055 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100test-review
Przegląda pokrycie testami przez Codex exec, ocenia wystarczalność testów, wskazuje luki i zwraca analizę pokrycia z raportem luk. - 90dev-test-strategy
Projektuje plan testów i zakres regresji: pokrycie jednostkowe, integracyjne i e2e, automatyzację oraz kontrole CI. - 100test-deep
Orkiestruje testy z uwzględnieniem kontekstu: dobiera testy, segreguje awarie, prowadzi drabinkę testów i zwraca wyniki z raportem triage oraz akcjami naprawczymi. - 100test-generation-patterns
Podpowiada wzorce generowania testów z pomocą AI: testy jednostkowe, integracyjne i zwiększanie pokrycia istniejącego kodu. - 100test-unit
Pisze testy jednostkowe i integracyjne dla wskazanego modułu lub zmiany, na przykład dla pojedynczej funkcji. - 100tdd
Prowadzi przepływ pracy TDD: testy najpierw, pokrycie testami i testy funkcji przed implementacją.