// docs

Running a pass

The loop you'll live in: pick a deck, step through cases, mark by eye, and handle fails with evidence attached. Keyboard shortcuts and resume behaviour included.

Teasynaer is a manual QA runner: you look at a case, do what it says, and record what actually happened. This page is the reference for the loop you'll live in — Home → Packages → Runner → Run Summary — plus what happens the moment something fails.

Home — resume a run in progress, or start a new one.
Packages — pick which deck (test package) to run.
Runner — one case-card at a time; mark Pass, Fail, or Skip.
Run Summary — see what happened, and optionally re-run just the fails.

Nothing in this loop is automatic. A human looks at every card and makes the call — that's the entire point of the product.

Start a run

From Home: if you've got a run already open, a resume banner is waiting —

Resume "Auth"
paused at card 4 of 18 · started 20 minutes ago

Click ▶ Resume and you're straight back in, on the same card. No banner means nothing's in progress for you right now.

From Packages (/packages, or ⌘K → Open decks): pick a deck from the list — each row shows its case count and status — then click Start run · [deck name] →. You land in the Runner on card 1.

No deck to pick from? Someone with admin access needs to create or import one first (the in-product Case Editor, a Gherkin .feature upload, a TestRail CSV, or the machine-import API all produce a runnable deck). That's a separate job from running the pass — this page picks up once a deck already exists.

Mark a verdict

Every case-card shows the same two things regardless of how the deck was authored: a Steps list and an Expected result. Do the steps, check whether reality matches Expected, then record it:

Verdict	Key	Swipe	Button
Pass	`p`	right	Pass ▶
Fail	`f`	left	◀ Fail
Skip	`s`	down	Skip

A few things worth knowing before you rely on either input method:

Keys are case-insensitive, and ignored while a text field has focus, while ⌘/Ctrl/Alt is held, or on OS key-repeat — so a stuck p key can't rip through the rest of the deck.
A swipe has to clear a real distance to register; a tap or a small jiggle is ignored (it's read as a click, not a gesture). Swiping up does nothing — there's no verdict assigned to it.
Escape takes you back to Home. Nothing you've already recorded is affected either way.
There's no confirmation dialog on any verdict, and no reason field on Skip — the whole design is optimised for speed. Fail is the one exception: it opens something extra. See When a case fails.

The Runner's own footer is the cheat-sheet, if you forget: swipe ← fail · → pass · ↓ skip · ⌘K jump.

Undo a verdict

Fat-fingered a Pass that should've been a Fail? ↶ Undo last verdict appears as soon as you've recorded at least one verdict on this run. It steps back exactly one card and clears that card's verdict — there's no multi-level undo, so treat anything more than one card back as final.

Get anywhere with ⌘K

There's no sidebar. Press ⌘K (or Ctrl-K) from any signed-in screen to open the command palette:

Command	Goes to	Who sees it
Go home	`/`	everyone
Open decks	`/packages`	everyone
New deck	`/packages`	everyone
Connect setup	`/connect`	everyone
Configure tracker	`/settings/integrations/tracker`	admin only
Manage users	`/settings/users`	admin only
View audit log	`/settings/audit`	admin only

The current screen's own command is dropped from its own list (Packages doesn't offer "Open decks" from Packages). Mid-run, the Runner adds View run summary for the run you're on. Once the palette's open, each row also has a one-letter accelerator (shown next to its hint) — press it (or hold Alt and press it, if you're still typing in the search box) to jump straight there.

Leave and come back

Close the tab, lose your connection, restart the laptop — it doesn't matter. There is no client-side "current card" for the Runner to lose: your resume position is simply how many verdicts already exist for this run, read fresh from Postgres every time the page loads. Reopen the run (or click ▶ Resume on Home) and you land on the exact card you left, no further state to reconstruct.

When a case fails

Marking Fail doesn't just record a verdict — it opens the On-Fail panel for that result immediately, in the same tab, before you can move on:

Notes — a free-text "What went wrong?" field, capped at 4,000 characters with a live counter. It autosaves as you type, so leaving via Back to deck without filing doesn't lose it.
Assign to — optional, defaults to Unassigned; pick anyone in the workspace.
Needs re-test — off by default; toggle it on to flag the fail as something that'll need checking again later. It shows up as a needs re-test tag on the Run Summary.
Evidence — whatever this run captured for the case: screenshots (Shot N), a screen-recording clip (Clip m:ss) scrubbable to your step markers, the request log, and the console log. What's actually in that bundle, and how redaction works before any of it uploads, is covered in Evidence & redaction — worth reading before your first real fail.
Then either File issue + bundle → — which needs an issue tracker configured (GitHub, GitLab, Jira, webhook, or Forgejo); if none is set up yet, filing is blocked and you're pointed at Export packet instead — or Export packet, the always-available, tracker-independent fallback that lets you file by hand.

Back to deck returns you to the Runner without losing your draft notes; you can come back and file later from the fail's card on the Run Summary.

Run Summary

Once every card in the run has a verdict, you land on its summary: a Pass / Fail / Skip tally, plus one line that reflects the actual numbers rather than a generic "done" —

Situation	Sign-off reads
Completed run, nothing exercised	"Nothing was actually tested."
Completed run, no fails	"Nothing failed. Clean run."
Fails, none filed	"N didn't. None filed."
Fails, some filed	"N didn't. Filed M."
Fails, all filed	"N didn't. I filed it/them."

Below that:

Fail and Skip cases get their own cards — case key, title, your notes, and tags for needs re-test, a link to the filed issue, and a link to the evidence (or an evidence expired tag, if retention garbage-collection has since cleared it).
Passes collapse into a disclosure — "N passes · show them" — so a clean run doesn't bury the cards worth reading.
If this run was itself re-run from another, or has since been re-run, lineage links appear: ↖ re-run of [run] and/or fails re-run as [run] ↺.

Re-run just the fails

If anything failed, ↺ Re-run the N fails sits on the summary. Clicking it:

seeds a brand-new run scoped to exactly the cases that came back Fail (Skips aren't carried over),
keeps them in their original fail order,
silently drops any case since deleted or archived,
and drops you straight into the Runner for that new run — no intermediate screen.

The two runs stay cross-linked via those lineage links, so anyone reviewing later can trace a retest back to what it was retesting. For the view across many runs — trend lines, run-vs-run comparison, milestones, and CI export — see Reporting.

Good to know

This is a manual runner end to end — a human records every verdict, always. There's no unattended "run this deck against the target" mode. The nearest thing that exists is a deterministic dry-run plan preview in the Case Editor — a coverage estimate over your ⌖ target chips, not an execution engine that presses buttons for you.
File issue is greyed out until a tracker is configured for your workspace; Export packet always works regardless, and is the honest fallback.
Undo reaches back exactly one card — once you've moved two cards on, the earlier verdict is final.