Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

test-case-analysis

Use when a TMS test case needs manual execution, selector discovery, or defect investigation before automation — "analyse SCRUM-T101", "run this case and emit an AFS", any pre-automation case exploration. Produces an Automation-Friendly Spec (AFS); does not write test code.

arozumenko · Static checks on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add arozumenko/sdlc-skills --skill test-case-analysis

About this skill


name: test-case-analysis description: Use when a TMS test case needs manual execution, selector discovery, or defect investigation before automation — "analyse SCRUM-T101", "run this case and emit an AFS", any pre-automation case exploration. Produces an Automation-Friendly Spec (AFS); does not write test code. license: Apache-2.0 metadata: authors: - Alexander Bychinskiy alexander_bychinskiy@epam.com - Artem Rozumenko artem_rozumenko@epam.com version: "0.1.0"

Test Case Analysis

Execute a TMS test case against the live app, observe what actually happens, and emit an Automation-Friendly Spec (AFS) a downstream engineer can implement without re-exploring.

Core philosophy: a written test case is a hypothesis. The app is the only source of truth. This skill never trusts the case as authored — it runs it step by step, captures stable selectors, flags defects, and only then produces a spec.

Absolute boundaries

  • No automation code. No .spec.ts, no test_*.py, no step definitions. The output is a markdown AFS file. Automation is implemented downstream — your agent knows which role / workflow picks the AFS up.
  • No automating un-automatable cases. Physical device, visual judgment that can't be asserted, flows that genuinely can't be scripted — mark the AFS un-automatable and stop.
  • No skipping exploration. Even if the TMS case looks complete, execute it. The case describes intent; only execution reveals truth.

Analyst slot contract

This skill IS the analyst slot in the test-automation pipeline. When dispatched — by an orchestrator like test-automation-lead, or standalone for "analyse SCRUM-T101" — role, context, parameters, and return shape are fixed here so dispatch prompts don't have to inline them.

Role. Execute one TMS test case end-to-end against the live app, capture stable selectors, classify the finding, emit an AFS. No automation code (see § Absolute boundaries).

Session context — read once at session start. Typically auto-imported via @-blocks in your agent's AGENT.md; if your agent doesn't auto-import, read them now:

  • .agents/profile.md — project systems, base URL, credentials matrix, sample users, bug filing target
  • .agents/workflow.md — branch/PR rules, EPIC pattern
  • .agents/testing.md — framework, locator strategy, TMS case-gate exclusion list
  • .agents/memory/<your-agent>/project_briefing.md — accumulated project gotchas from prior sessions
  • .agents/architecture.md — the surfaces you'll touch (also referenced in Phase 2)

Missing context → flag the gap; don't fabricate defaults.

Per-case parameters (caller provides at dispatch time):

  • TMS case ID (e.g. SCRUM-T101)
  • User set — a key into .agents/profile.md § Roles & sample users (e.g. ${TEST_USER} / ${TRIAL_USER})
  • Base URL — usually from .agents/profile.md, but caller may override
  • EPIC parent key — for defect filing under story-subtask style

Return contract:

  • Status — one of ready-for-automation / already-covered / extend-existing / blocked / defect-found / out-of-scope-by-author / un-automatable. Full semantics in Phase 0 (out-of-scope) and § 5 Classify findings (the rest).
  • AFS path — test-specs/<feature>/l<pri>_<slug>_<tms-id>.md for fresh-implementation, lcovered_* for already-covered, lextend_* for extend-existing. Omitted for un-automatable and out-of-scope-by-author (no AFS emitted).
  • Filed bug IDs — if defect-found, the tracker IDs created per § 5's bug-filing routing.

Phase 0 — Case-gate (preflight, runs BEFORE Phase 1)

Before fetching the case body, probe its TMS author metadata. Skip cases the author has marked as not actionable — there's no analyst value in executing them, and downstream the implementer / orchestrator will reject them.

What to probe (project-defined in .agents/testing.md § TMS case-gate; if absent, default to fetching all and flag the gap):

Metadata fieldTypical exclusionsWhy
StatusOut of Scope, Untested, Draft, DeprecatedAuthor has signalled the case isn't currently a target — don't burn cycles
Folder / parent membershipMismatch vs requested folderCatches raw-key-ASC iteration drift across folders (e.g. KEY-NNN is in folder A, KEY-NNN+1 jumped to folder B) — drift recurs when iterating by key
Version / last-modifiedStale per the project's freshness thresholdStale cases often contradict the live product (case-text drift) — see test-automation-workflow § Reverse-masking guard

How to probe. Probe the single-case status field directly via your adapter (get_field_value / fetch_case(id, fields=[status]) / equivalent). Don't query-set — JQL-style status in (...) queries on TMS custom fields are unreliable across adapters; verify the field on each case directly.

Outcomes:

  • All probes clear → continue to Phase 1.
  • Status excluded → don't fetch the body; return out-of-scope-by-author with the field value as evidence; close the case in the tracker (or mark per project convention).
  • Folder/membership mismatch → don't dispatch; return to the orchestrator with the discrepancy. Iteration drift is an orchestrator-side routing issue, not an analyst-side execution issue.
  • TMS unreachable for the probe → fall back to fetching the body (Phase 1 will surface it); flag the gap for scout to fill in .agents/testing.md.

The six-phase loop (one case at a time, runs AFTER Phase 0)

1. Fetch the case         → TMS adapter (pluggable; see test-automation.yaml)
2. Read app context       → .agents/architecture.md + previous AFS files
3. Execute                → browser-driving capability (your agent's wired MCP), step-by-step
4. Capture selectors      → stable, accessible, fallback-ready
5. Classify findings      → ready / already-covered / extend-existing / bloc
Read the complete source ↗