Skip to content
Skills Library
Programming · Testing

backend-testing

/backend-testing

Turn backend test ambiguity into one practical backend test packet. Use when the user needs API/service/repository/auth-flow coverage design, fixture or seed/reset strategy, container-vs-mock dependency choices, contract/API compatibility checks, or flaky backend-suite stabilization across local and CI.

Repository
jeo-skills ↗
Licence
MIT
Last repository change
13.11.2026

Assessment and security

95/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene10 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
5
Deprecation

No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Turn backend test ambiguity into one practical backend test packet. Use when the user needs API/service/repository/auth-flow coverage design, fixture or seed/reset strategy, container-vs-mock dependency choices, contract/API compatibility checks, or flaky backend-suite stabilization across local and CI.

Original author description

Turn backend test ambiguity into one practical backend test packet. Use when the user needs API/service/repository/auth-flow coverage design, fixture or seed/reset strategy, container-vs-mock dependency choices, contract/API compatibility checks, or flaky backend-suite stabilization across local and CI.

How it works

  1. When to use this skill
  2. When not to use this skill
  3. Instructions
  4. Output format
  5. Examples
  6. Best practices
  7. References
Original SKILL.md headings · 251 lines, 1,662 words
SKILL.md preview
---
name: backend-testing
description: >-
  Turn backend test ambiguity into one practical backend test packet. Use when the user needs
  API/service/repository/auth-flow coverage design, fixture or seed/reset strategy,
  container-vs-mock dependency choices, contract/API compatibility checks, or flaky backend-suite
  stabilization across local and CI.
allowed-tools: Bash Read Write Edit Glob Grep
metadata:
  tags: testing, backend, api-test, integration-test, contract-test, testcontainers, ci
  platforms: Claude, ChatGPT, Gemini
  version: 1.2.0
---









# Backend Testing

Use this skill as a **packet-first backend testing router**.

The job is not to dump boilerplate for every framework. The job is to:
1. classify the request into the right backend test packet,
2. pick the smallest credible mix of test layers,
3. make dependency realism and data control explicit,
4. split local vs PR vs slower lanes honestly,
5. route policy, contract-shape, and auth-implementation work away when they are the real task.

Read these when needed:
- references/intake-packets-and-route-outs.md
- references/test-layer-matrix.md
- references/stability-checklist.md

## When to use this skill
- Add or repair backend coverage for APIs, services, repositories, workers, integrations, or auth flows
- Decide whether a backend change needs unit, integration, contract/API, or narrow smoke coverage
- Design fixture, factory, seed/reset, auth bootstrap, or environment-control strategy
- Decide when to use mocks, fakes, containers, or real dependencies
- Stabilize flaky backend suites, especially CI-only failures and local-vs-CI drift
- Review whether a backend suite is too broad, too slow, too mock-heavy, or missing a key layer

## When not to use this skill
- The main task is org-wide test policy, gate design, release evidence, or company-wide QA philosophy → use `testing-strategies`
- The main task is API contract shape, versioning, or schema design before tests can be scoped honestly → use `api-design`
- The main task is implementing auth/session/provider behavior rather than testing it → use `authentication-setup`
- The main task is frontend/browser testing or UI workflow coverage
- There is no concrete backend behavior or regression target yet; in that case define the missing behavior packet first instead of pretending the test plan is settled

## Instructions

### Step 1: Classify the request into one packet
Choose the single best entry packet before giving advice.

**Packets**
- `coverage-plan` — which layers to add for a concrete backend change
- `fixture-and-reset-plan` — how to seed, isolate, reset, or bootstrap data/auth state
- `contract-and-api-checks` — how to protect response/event/schema compatibility once the interface already exists
- `flake-stabilization` — how to stabilize CI-only or intermittent backend failures
- `execution-lane-split` — how to divide local-fast, PR, nightly, and release-only backend checks

If the request mixes several concerns, name the **primary packet** and one secondary concern.

### Step 2: Frame the backend surface and risk
Capture the smallest useful context:
- surface: endpoint, service, repository, worker, queue consumer, auth flow, integration, or migration
- highest-risk behaviors: validation, permissions, persistence, retries, idempotency, ordering, serialization, side effects, compatibility
- existing coverage already present
- external dependencies involved: DB, cache, queue, email, payment, third-party API, identity provider, filesystem
- runtime/language stack
- where the evidence must hold: local loop, PR CI, scheduled CI, release smoke

If the request is vague, choose the smallest regression slice worth protecting first.

### Step 3: Choose the right test layers
Use the packet and risk to select the lightest credible layer mix.

#### Unit / service
Prefer when the main risk is branching logic, validation, orchestration, or pure-ish business rules.

#### Integration
Prefer when database behavior, framework wiring, middleware, transactions, queues, caches, or serialization matter.

#### Contract / API
Prefer when clients depend on response shapes, status codes, schemas, or events and the interface already exists.

#### Smoke / selective end-to-end
Prefer only when a narrow release-critical journey crosses several backend boundaries and lower layers would miss the core risk.

State what is **in scope**, what is **out of scope**, and why.

### Step 4: Decide dependency realism on purpose
For each dependency, choose one of:
- **mock / stub** — expensive, unstable, or irrelevant to the behavior under test
- **fake / simulator** — behavior matters, but a lightweight substitute is enough
- **containerized real dependency** — queries, migrations, message semantics, or wire behavior matter enough that drift would hurt
- **shared external environment** — only when unavoidable; call out the fragility cost explicitly

Good defaults:
- prefer real DB behavior when repository, migration, transaction, or serialization behavior is central
- prefer mocks for outbound third-party APIs unless the integration contract itself is under test
- prefer a narrow containerized slice over a giant all-dependencies-in-PR setup
- do not claim fake and real dependencies are equivalent when production parity is the whole risk

### Step 5: Define fixture, data, auth, and environment control
A backend suite becomes untrustworthy when state is vague.

Specify:
- fixture/factory strategy
- seed/reset/rollback plan
- auth/bootstrap helpers for users, roles, tenants, tokens, or sessions
- time/randomness/idempotency control where needed
- isolation rule: per test, per file, per suite, or per environment
- debugging signals to capture when failures happen

If the suite relies on ordering, leftovers, or sleeps, call that fragility out directly.

### Step 6: Split the execution lanes
Treat local, PR, and slower lanes as different jobs.

Define:
- **local-fast path** — what developers should run repeatedly
- **PR path** — what must gate merges
- **scheduled / nightly path** — heavier breadth or expensive realism
- **release / incident path** — narrow confidence checks or regression ratchets when needed

If the suite is slow, split it. Do not pretend one giant authoritative path is practical everywhere.

### Step 7: Produce one backend test packet
Return one concise packet, not a general essay.

Recommended packet shapes:
- `coverage-plan` → coverage table + dependency strategy + exclusions
- `fixture-and-reset-plan` → fixture/reset memo + auth/bootstrap notes
- `contract-and-api-checks` → compatibility packet + consumer/provider scope + route-outs
- `flake-stabilization` → flake memo with likely causes, isolation fixes, readiness checks, and debug signals
- `execution-lane-split` → lane matrix with local/PR/scheduled/release responsibilities

Minimum packet contents:
- change surface and primary risk
- chosen packet and any secondary concern
- selected layers and why
- dependency realism decisions
- fixture/data/auth/environment control
- execution-lane split
- explicit route-outs when the request is partly owned elsewhere

### Step 8: Verify scope boundaries before finalizing
Check:
- does the packet protect the real backend regression risk rather than generic coverage vanity?
- did you keep org-wide validation policy in `testing-strategies`?
- did you route contract *shape* decisions to `api-design` while keeping contract *protection* here only when the interface already exists?
- did you route auth implementation work to `authentication-setup`?
- will a maintainer understand why a dependency is mocked, faked, containerized, or real?

## Output format

```markdown
## Backend Test Packet: [Surface or Change]

### Packet choice
- Primary packet: coverage-plan | fixture-and-reset-plan | contract-and-api-checks | flake-stabilization | execution-lane-split
- Secondary concern: optional
- Confidence: high | medium | low

### Change framing
- Surface: ...
- Main risks: ...
- Runtime: ...
- Existing coverage: ...

### Layer decisions
| Layer | In scope? | What it protects | Notes |
|------|-----------|------------------|-------|
| Unit / service | yes/no | ... | ... |
| Integration | yes/no | ... | ... |
| Contract / API | yes/no | ... | ... |
| Smoke / selective E2E | yes/no | ... | ... |

### Dependency realism
| Dependency | Strategy | Why |
|------------|----------|-----|
| Database / queue / cache | ... | ... |
| External API | ... | ... |
| Auth provider | ... | ... |

### Data and environment control
- Fixtures / factories: ...
- Seed / reset: ...
- Auth bootstrap: ...
- Isolation rule: ...
- Debug signals: ...

### Execution lanes
- Local-fast: ...
- PR CI: ...
- Scheduled / nightly: ...
- Release / incident: ...

### Route-outs
- `testing-strategies`: ...
- `api-design`: ...
- `authentication-setup`: ...
```

## Examples

### Example 1: auth-heavy API change
**Input:** “We added refresh-token rotation and new admin-only endpoints to our Express API. I need backend tests that catch auth failures, token replay issues, and DB persistence bugs without turning CI into a giant end-to-end suite.”

**Good response shape:**
- chooses `coverage-plan` as the primary packet
- combines unit/service plus integration/API coverage instead of one giant E2E suite
- keeps real DB or containerized persistence where token/session behavior matters
- defines auth bootstrap helpers and reset strategy
- limits smoke coverage to a narrow release-critical path

### Example 2: CI-only flake in a service suite
**Input:** “Our FastAPI tests pass locally but fail in CI around seeded Postgres state and background jobs. Give me a stabilization plan.”

**Good response shape:**
- chooses `flake-stabilization` as the primary packet
- identifies seed/reset drift, readiness, async timing, or leftover state as likely causes
- recommends stronger isolation, readiness checks, and debugging signals instead of just retries
- separates local-fast and CI-authoritative behavior clearly

### Example 3: contract protection after an API already exists
**Input:** “Our payment service and webhook consumers keep drifting on response fields. I do not need API redesign, I need backend tests that catch compatibility regressions.”

**Good response shape:**
- chooses `contract-and-api-checks` as the primary packet
- keeps contract protection here because the interface already exists
- routes any schema redesign or versioning debate to `api-design`
- recommends consumer/provider or schema-compatibility coverage rather than broader smoke inflation

### Example 4: too-broad policy request
**Input:** “Design our overall engineering org testing strategy for frontend, backend, mobile, and QA.”

**Good response shape:**
- recognizes that the primary task belongs to `testing-strategies`
- keeps any backend-specific advice scoped as a handoff only
- refuses to turn `backend-testing` into a universal QA-governance skill

## Best practices
1. Start from the packet, not from the framework.
2. Protect the real backend regression risk before chasing coverage percentages.
3. Prefer layered backend coverage over giant brittle end-to-end suites.
4. Make fixture, seed, and auth bootstrap strategy explicit; hidden state is where trust dies.
5. Split local-fast, PR, scheduled, and release lanes intentionally.
6. Use real dependencies when wire behavior matters, but keep expensive realism bounded.
7. Treat flaky tests as a trust problem, not just an annoyance.
8. Route policy, contract-shape, and auth-implementation ownership away instead of absorbing them.

## References
- [The Practical Test Pyramid](https://martinfowler.com/articles/practical-test-pyramid.html)
- [pytest: Good Integration Practices](https://docs.pytest.org/en/stable/explanation/goodpractices.html)
- [Testcontainers](https://testcontainers.com/)
- [Pact Docs](https://docs.pact.io/)
- [GitHub Actions: Building and testing Python](https://docs.github.com/en/actions/use-cases-and-examples/building-and-testing/building-and-testing-python)
Files in this package (6)
  • SKILL.md 12 KB
  • SKILL.toon 2 KB
  • evals/evals.json 3 KB
  • references/intake-packets-and-route-outs.md 2 KB
  • references/stability-checklist.md 2 KB
  • references/test-layer-matrix.md 2 KB

Versions

RepositoryScoreLicence
This page · akillness/jeo-skills95MIT
albkue/my-skill100MIT
rhesis-ai/rhesis95MIT
autohandai/community-skills95Apache-2.0

Database snapshot: 13.11.2026 · package version fafa06e8fb5c (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

  • 85backend-testing-strategy-review
    Use when reviewing test code for strategy quality — pyramid balance, mock boundaries, fixture/setup correctness, flaky patterns, behavior-vs-implementation tests, missing assertions. Triggers when test files (`*Test.java`, `test_*.py`, `*.test.ts`, `*_test.go`) are in scope.
  • 85proof
    QA and testing engineer — test strategy, E2E suites, API tests, flaky test triage, coverage. Use when asked to "write E2E tests", "design a test strategy", "triage flaky tests", or "check test coverage".
  • 100backend-code-review
    Review backend code like a senior engineer. Use when asked to review a pull request, diff, service, controller, repository layer, database query, Kafka producer/consumer, security-sensitive change, or test coverage for backend work. Do NOT use for implementation help…
  • 95testing-strategies
    Turn test-policy ambiguity into one packet-first validation brief. Use when the main job is deciding which gate is actually being shaped (merge, release, or scheduled), what evidence a change needs, how flaky or expensive suites should be handled, and whether the next owner is…
  • 100backend-test
    Generate backend tests (unit, integration, mocks) for existing code. Auto-invoke when user says "write test for", "add test", "test this", or "create test".
  • 100typescript-testing-backend
    Use when writing or reviewing TypeScript backend tests — Jest unit tests for services/controllers (mocked Prisma) or Supertest integration tests against a real isolated PostgreSQL test database. Triggers on edits to `*.service.test.ts`, `*.controller.test.ts`,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.