opsmill-dev-test-driving-bugs
/opsmill-dev-test-driving-bugs
Pisze jeden nieprzechodzący test reprodukujący błąd po zakończonej analizie przyczyn źródłowych, zanim powstanie poprawka.
- Autor
- opsmill ↗
- Repozytorium
- infrahub ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 1
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
Co robi i kiedy
Pisze jeden nieprzechodzący test reprodukujący błąd po zakończonej analizie przyczyn źródłowych, zanim powstanie poprawka.
Argumenty
/opsmill-dev-test-driving-bugs <issue number or URL, or bug description> [pr]
Oryginalny opis (EN)
Writes a single failing test that reproduces a bug after its root-cause analysis is complete, before any fix is written. TRIGGER when: a bug has a completed root-cause analysis and you need the failing reproduction test, writing a test that proves a bug exists, the second step of the bug-fixing pipeline. DO NOT TRIGGER when: still triaging or diagnosing the bug → opsmill-dev-analyzing-bugs; implementing the fix once the test exists → opsmill-dev-fixing-bugs; general feature test-first work → superpowers test-driven-development.
Jak działa
- User Input
- Your role
- Tool usage
- Input and setup
- Write the test
- Escalation
- Quality gates
- Common mistakes
Podgląd SKILL.md
---
name: opsmill-dev-test-driving-bugs
description: >-
Writes a single failing test that reproduces a bug after its root-cause analysis is complete,
before any fix is written. TRIGGER when: a bug has a completed root-cause analysis and you need
the failing reproduction test, writing a test that proves a bug exists, the second step of the
bug-fixing pipeline. DO NOT TRIGGER when: still triaging or diagnosing the bug → opsmill-dev-analyzing-bugs;
implementing the fix once the test exists → opsmill-dev-fixing-bugs; general feature test-first work →
superpowers test-driven-development.
argument-hint: <issue number or URL, or bug description> [pr]
compatibility: >-
Works in any git repo with a test suite; discovers testing conventions from the OpsMill `dev/`
layout with auto-detection fallback. The draft-PR step needs `gh` and a GitHub remote.
metadata:
pipeline: bug-fixing (2 of 3 — analyze → test-drive → fix)
version: 0.1.0
author: OpsMill
user-invocable: true
disable-model-invocation: true
---
# Bug test-writer
## User Input
```text
$ARGUMENTS
```
## Your role
You are a senior QA engineer writing a targeted failing test that reproduces a confirmed bug.
`/opsmill-dev-analyzing-bugs` has already identified the root cause. Your job is to write **ONE** test that
fails on the current code, proving the bug exists.
## Tool usage
- Use the `Read` tool to read files -- do NOT use `cat` or `head`/`tail` in Bash.
- Use the `Glob` tool to find files -- do NOT use `find` or `ls -R` in Bash.
- Use the `Grep` tool to search file contents -- do NOT use `grep` or `rg` in Bash.
- Reserve Bash for git commands, `gh` CLI, and commands that require shell execution.
- *Shell* state (variables, `cd`) does **not** persist across separate Bash calls -- re-derive
any shell value you reuse rather than relying on one set in an earlier step. The pipeline's
logical flags like `OPEN_PR` are decisions you carry in your own reasoning, not shell variables,
so they do persist across steps.
## Input and setup
Parse `$ARGUMENTS` for an optional **`pr`** flag: if the word `pr` appears anywhere in the
arguments (case-insensitive), set `OPEN_PR=true`. Otherwise `OPEN_PR=false`. The rest of
`$ARGUMENTS` (issue number / URL / description) is only used to disambiguate when more than one
analysis exists -- do **not** re-derive the slug from it.
Discover the handoff file `/opsmill-dev-analyzing-bugs` wrote, using `Glob` for `.bug-analysis-*.md` in the repo
root:
- **No match:** inform the developer "Run `/opsmill-dev-analyzing-bugs <issue>` first." and **STOP**.
- **Exactly one match:** use it.
- **Multiple matches:** pick the one whose `<key>` best matches `$ARGUMENTS` (issue number, then
slug words). If still ambiguous, list them and ask the developer which to use.
Read the full analysis. Take the canonical `<key>` and branch from its **`Key:`** and
**`Branch:`** header fields rather than re-deriving a slug -- this keeps the branch/PR names
consistent across steps. (If those fields are absent -- an older analysis -- fall back to the
key embedded in the filename, `.bug-analysis-<key>.md`, and `ai-bug-pipeline-<key>`.)
If the analysis file is missing required fields (Root cause, Affected files), inform the
developer and **STOP**.
## Write the test
Follow steps 0--9 below. **Step 10 (draft PR) runs only when `OPEN_PR=true`.** If
`OPEN_PR=false`, the run stays **fully local**: stop after step 9 with the test committed on the
local branch `<branch>` -- do NOT push and do NOT open a PR. Display the test results and the
branch name, and tell the developer that `/opsmill-dev-fixing-bugs` will pick it up from that local branch.
### Step 0: Create working branch
Detect the default branch and create a working branch from it:
```bash
DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')
# Fallback when origin/HEAD is unset (shallow/CI clones, manually-added remotes):
[ -z "$DEFAULT_BRANCH" ] && DEFAULT_BRANCH=$(git remote show origin 2>/dev/null | sed -n 's/.*HEAD branch: //p')
[ "$DEFAULT_BRANCH" = "(unknown)" ] && DEFAULT_BRANCH="" # git prints "(unknown)" when remote HEAD is indeterminate
DEFAULT_BRANCH=${DEFAULT_BRANCH:-main}
git fetch origin "$DEFAULT_BRANCH" || { echo "Cannot fetch origin/$DEFAULT_BRANCH -- set the default branch manually and retry."; exit 1; }
# Fetch the working branch into a tracking ref with an explicit refspec, so origin/<branch> is
# created even on single-branch/shallow clones (a bare `git fetch origin <branch>` only updates
# FETCH_HEAD there). Silently a no-op when the branch doesn't exist on the remote yet.
git fetch origin "+refs/heads/<branch>:refs/remotes/origin/<branch>" 2>/dev/null
# Resume the branch reconciled to the pushed tip if it exists on the remote; else a local-only
# branch (a no-pr run not yet pushed); else create it fresh from the default branch:
if git rev-parse --verify -q "origin/<branch>" >/dev/null; then
git checkout -B "<branch>" "origin/<branch>" # remote tip wins -> never reuse a stale local copy
elif git rev-parse --verify -q "<branch>" >/dev/null; then
git checkout "<branch>" # local-only branch (no-pr run, never pushed)
else
git checkout -b "<branch>" "origin/$DEFAULT_BRANCH"
fi
```
- `<branch>` is the `Branch:` value from the analysis (`ai-bug-pipeline-<key>`) -- use it verbatim
so `/opsmill-dev-fixing-bugs` finds the same branch.
- Re-runs are deterministic -- see the inline comments for how each branch state (pushed,
local-only, absent) is handled and why the remote tip wins.
- If the **default-branch** `git fetch` fails, **STOP** and report it -- do not continue to write a
test with no working branch (the `exit 1` only fails that one shell call). The working-branch
fetch is best-effort (a missing remote branch is normal); a network failure there only means the
branch can't be resumed from the remote, in which case STOP rather than recreating from default.
### Step 1: Read testing documentation
Determine which area the bug lives in (backend, frontend, etc.) and read the project's testing
conventions. Anchor on the `dev/` layout, falling back to detection:
- Read root `AGENTS.md` and `dev/documentation-architecture.md` (if present) to map the bug to a
code package.
- Backend testing docs, if present: `dev/knowledge/**/testing.md` and `dev/guidelines/**/testing.md`.
- Frontend testing docs, if present: `dev/guides/frontend/writing-unit-tests.md`,
`writing-component-tests.md`, `writing-e2e-tests.md`.
- **Fallback** (no `dev/` testing docs): detect the test runner and layout from the project
itself -- `pyproject.toml` / `tox.ini` / `pytest.ini` (pytest), `package.json` scripts
(vitest / jest / playwright), or a `Makefile` / `AGENTS.md` documenting the test command.
### Step 2: Discover existing test setup
Read the test setup local to the target test directory and its parents (e.g. `conftest.py`
files up the tree for pytest, shared setup/`setup.ts` for JS suites). Understand the available
fixtures, their scopes, and setup/teardown patterns. Do NOT reinvent setup logic that already
exists.
### Step 3: Check reusable utilities
Look for the project's reusable test helpers, base classes, factories, and fakes/adapters
(commonly under `tests/helpers/`, `tests/adapters/`, `tests/fake/`, or similar). Use these
instead of writing your own test infrastructure.
### Step 4: Read existing tests
Read 2--3 existing tests in the target test directory to learn the naming conventions, class
structure, and import patterns before writing your own.
### Step 5: Choose the test type
Pick the right test level using whatever guidance you found in step 1. Examples of common
levels:
- **Python / pytest:** unit, component, functional, integration. Reuse existing schema fixtures
and helpers when available.
- **Frontend:** unit/component (e.g. Vitest, colocated `.test.ts`), E2E (e.g. Playwright). Use
a GIVEN/WHEN/THEN structure and existing factories when the project does.
### Step 6: Write the test
Write a single targeted test that reproduces the bug:
- **Assert the CORRECT/EXPECTED behavior.** The test fails because the bug prevents the expected
behavior. Do NOT assert that the buggy behavior succeeds. For example: if the bug is
"duplicate records can be created," assert that the second creation raises an error or that
only one record exists -- this FAILS on buggy code and PASSES once fixed.
- The test MUST exercise the **actual production code path**, not a reimplementation. Call the
real functions/classes from the source. Do NOT copy production logic into the test.
- Test **observable behavior**, not internal implementation details (test that an API returns
wrong data or that a constraint is violated -- not that a constructor received specific
kwargs).
- **Test the affected code path** identified in the analysis "Affected files" section, not a
lower-level abstraction it calls internally. A test that can pass without changing the
affected code path is testing the wrong thing.
- Place it in the correct test folder following project conventions (test files usually mirror
source structure). If adding to an existing test file is more appropriate than creating a new
one, do that.
### Step 7: Verify the test FAILS
**CRITICAL: verify the test FAILS on the current code.** Run just this test using the project's
detected runner (e.g. `uv run pytest path::Test::test -x -v`, `npm run test -- <path>`,
`npx playwright test path`). Note the `--` for `npm run`: without it npm swallows the path
instead of forwarding it to the test runner.
- If a test run takes more than ~5 minutes, kill it and investigate why.
- The failure must be an **assertion error that directly relates to the root cause** (e.g.
`AssertionError: Expected ValidationError but none was raised`, or `assert 2 == 1` when
duplicates were found).
- If the test **PASSES**, your assertions are wrong -- you are likely asserting buggy behavior.
Flip them to assert what SHOULD happen.
- If it fails for the **wrong reason** (import error, missing fixture, syntax error), fix those
and re-run until it fails for the reason in the root cause.
> **Gate (T2-verify · P1):** paste the actual failing test run proving it fails for the documented reason (not an import/collection error). See `../quality-gates/gates/primitives/evidence-before-done.md`.
### Step 8: Format and lint
Run the project's formatter and linter on the test file(s) and fix any issues before committing.
Use whatever the project defines (e.g. `uv run invoke format` / `uv run invoke lint`,
`npx biome check --write .`, `ruff format`, `prettier`/`eslint`). Detect these from
`AGENTS.md` / `Makefile` / `pyproject.toml` / `package.json`.
### Step 9: Commit test files
Commit ONLY the test file(s). Do NOT touch production code. Stage files **by name**
(`git add path/to/test_file`) -- never `git add .` or `git add -A`, as unrelated working-tree
files would be committed by mistake. Commit message: `test: add failing test for <key>`.
### Step 10: Open draft PR (only if `OPEN_PR=true`)
> **Ship gate (T2 · P2 + P3) — before opening the draft PR or stamping `AGENT_TEST_COMPLETE`.** Run the ship gate per `../quality-gates/gates/primitives/independent-judge.md` (judge → on-FAIL STOP → R2 degrade → write receipt on PASS, all defined there). R1 criteria: the `.bug-analysis-<key>.md` verbatim (the root cause the test must prove — NOT your summary). Artifact: the test diff. Forbidden evasions: the test-gate evasions from `../quality-gates/gates/primitives/anti-gaming.md`. The judge confirms the test genuinely exercises the bug (not trivially-passing, not always-failing).
Push the branch and open a **draft** Pull Request against the repo's default branch:
```bash
git push -u origin "<branch>" || { echo "Push rejected (non-fast-forward / protected / network). STOP and resolve before retrying -- do not open or edit a PR."; exit 1; }
# Idempotent: on a resumed run a draft PR may already exist for this branch -- edit it
# instead of creating a duplicate (gh pr create errors if one already exists). Default to
# CREATE when the count is empty/non-numeric (a gh error), since create reports a real
# duplicate clearly, whereas edit on a missing PR would just fail.
PR_COUNT=$(gh pr list --head "<branch>" --state open --json number --jq 'length' 2>/dev/null)
if [ "${PR_COUNT:-0}" -gt 0 ] 2>/dev/null; then
gh pr edit "<branch>" --title "<title>" --body-file <tmp-body-file>
else
# No --base: gh pr create defaults the base to the repo's default branch, so the
# default-branch detection from Step 0 (which doesn't persist across Bash calls) isn't needed here.
gh pr create --draft --title "<title>" --body-file <tmp-body-file>
fi
```
Write the PR body to a temp file first (use the `Write` tool, e.g. under the system temp dir),
then pass it via `--body-file`.
- Title: `test: failing test for <key> -- <short description>`
- PR body with this exact structure:
````markdown
## Analyst's findings (summary)
> **Root cause:** <copied from analysis>
> **Affected files:**
> <copied from analysis>
## Replication test
**Test file:** `path/to/test_file.ext`
**Test name:** `test_name_here`
**What it tests:** <one sentence explaining the observable behavior being asserted>
**Verification:** Test confirmed FAILING on current code.
**Failure reason:** <one sentence explaining HOW the test fails and why that proves the bug>
<details><summary>Failure output (last 20 lines)</summary>
```text
<paste the relevant failure output>
```
</details>
## Test expectations
<what the test asserts and any edge cases it covers -- NOT how to fix the bug>
<!-- AGENT_TEST_COMPLETE -->
````
If the analysis was triggered by a GitHub issue, post a short comment on the issue linking to
the draft PR.
## Escalation
If the test cannot be made to fail for the right reason after 3 attempts, inform the developer
explaining what was tried and **STOP**. Do NOT open a PR or include the `AGENT_TEST_COMPLETE`
marker.
## Quality gates
Gates for this skill follow `../quality-gates/gates/gate-model.md`. `test-driving-bugs` is **Tier 2 — it writes a failing reproduction test and stamps `AGENT_TEST_COMPLETE` unconditionally** (in PR mode it also opens a draft PR; both paths require the full ship gate).
| Gate | Step / trigger | Tier | Primitives | Pass criteria | On-fail |
|---|---|---|---|---|---|
| Test-fails-right | after writing the test | T2-verify | P1 | The new test FAILS for the documented reason. Paste the failing run. | STOP; fix the test |
| Test-catches-bug | before opening the draft PR / stamping `AGENT_TEST_COMPLETE` | T2-ship | P2 + P3 | A fresh judge, given the `.bug-analysis-<key>.md` verbatim and the test diff, confirms the test actually exercises the bug (not trivially-passing, not always-failing). | STOP; do not stamp; fix and re-judge |
## Common mistakes
| 🚩 Red flag | Do instead |
| --- | --- |
| Test passes on the current (buggy) code | You're asserting the buggy behavior — flip the assertions to the expected behavior so it FAILS now |
| Copying production logic into the test | Call the real functions/classes from the source; test the actual code path |
| Test passes without touching the affected files | Exercise the affected code path from the analysis, not a lower-level abstraction it calls |
| Editing production code "to help the test" | This step writes tests only — production code is `/opsmill-dev-fixing-bugs`'s job |
| `git add .` / `git add -A` | Stage the test file(s) by name |
| Opening the PR / writing `AGENT_TEST_COMPLETE` after a failed attempt | The marker is the "test ready" signal — only emit it once the test fails for the right reason |
Wersje
W bazie nie ma innych skilli o nazwie opsmill-dev-test-driving-bugs.
Migawka bazy z 13.11.2026 · wersja paczki 4fce92bd8e4d (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
- 100opsmill-dev-fixing-bugs
Implementuje i weryfikuje poprawkę błędu, gdy istnieje już nieprzechodzący test reprodukujący, jako ostatni krok potoku naprawy błędów. - 100opsmill-dev-analyzing-bugs
Przeprowadza analizę przyczyn źródłowych błędu ze zgłoszenia GitHub, jego adresu lub opisu, zanim powstanie jakakolwiek reprodukcja czy poprawka. - 100hatch3r-bug-fix
Prowadzi naprawę błędu krok po kroku: diagnoza przyczyny źródłowej, minimalna poprawka i test regresji. - 100quick-fix
Prowadzi błąd lub podzadanie Jira od zgłoszenia do merge requesta: test reprodukujący, przyczyna, poprawka i sprawdzenia. - 96fix-bug
Naprawia usterkę: odtwarza ją, pisze nieprzechodzący test, znajduje przyczynę, poprawia kod i zapisuje wniosek. - 100dev-bug
Odtwarza błąd, znajduje przyczynę na podstawie dowodów, a potem naprawia go wraz z testem regresji.