qa-test-review
Test code reviewers for test files only — production code is out of scope. 5 skills (object-model-patterns, test-code-conventions, test-framework-blueprint, test-isolation-patterns, test-step-design-patterns) and 6 agents (assertion-quality-reviewer, e2e-selector-quality-critic, framework-architecture-auditor, mocking-anti-pattern-detector, test-code-critic, test-suite-health-auditor).
Install this plugin
/plugin install qa-test-review@testland-qaPart of role bundles: qa-starter, qa-role-automation-engineer, qa-role-sdet
qa-test-review
Test code quality reviewers - agents specialized for test files only, not production code. Production-code reviewers are well-served by the broader ecosystem; test-code hygiene (AAA structure, assertion specificity, mocking anti-patterns, E2E selector quality) is its own discipline and gets its own reviewers here.
Components
| Type | Name | Description |
|---|---|---|
| Skill | test-code-conventions | Pure-reference catalog (§1-§10): AAA structure, single-responsibility, naming, assertion specificity, mocking, fixture coupling, magic numbers, E2E selectors, web-first assertions, slow setup. The agents in this plugin cite back to it. |
| Skill | object-model-patterns | Architecture-tier catalog: Page Object Model (Fowler), Screenplay (Marcano/Palmer), Component Object, App Actions (Cypress), Service Object, Repository - canonical citations, when-to-use, anti-patterns per pattern. |
| Skill | test-isolation-patterns | Architecture-tier catalog: fixture scope, Meszaros four-phase pattern, Fresh-vs-Shared-Fixture (Fowler), DB isolation strategies (transaction-rollback / DB-per-worker / template-db / Testcontainers), parallel safety, cleanup discipline. |
| Skill | test-step-design-patterns | Architecture-tier catalog: FIRST principles (Martin), step granularity, abstraction layers (mechanical → page → business), step-extraction rule of three (Fowler), AAA / Given-When-Then mapping, declarative-vs-imperative phrasing. |
| Skill | test-framework-blueprint | Build-an-X workflow: seven steps from no test suite to a written framework blueprint (SUT inventory, runner choice, layout + fixture architecture, object-model decision, data + mocking wiring, CI matrix, conventions doc) plus an implementation order. Defers pattern detail to the sister catalogs; hands the blueprint to qa-roles/automation-harness-bootstrapper for scaffolding. |
| Agent | test-code-critic | Walks structure / naming / single-responsibility / magic-number / slow-setup violations (§1-§3, §6, §7, §10). Refuses to review production code. |
| Agent | assertion-quality-reviewer | Rates each assertion as specific / narrow-vague / wide-vague / match-vague (§4). Recommends specific replacements. |
| Agent | mocking-anti-pattern-detector | Flags over-mocking, behavior-verification leakage, mock chains, mocking-what-you-don't-own, and fake-candidate situations (§5). |
| Agent | e2e-selector-quality-critic | Flags brittle CSS class / nth-child / XPath selectors and non-web-first assertions; recommends getByRole / accessibility-first equivalents (§8, §9). |
| Agent | framework-architecture-auditor | Cross-file framework audit: POM consistency, base-class hierarchy depth, fixture coupling, helper sprawl, naming-convention drift, retry / wait consistency, documented-vs-actual convention drift, CI integration health. Sister-tier above the per-file critics. |
| Agent | test-suite-health-auditor | Whole-suite cross-tool audit: file inventory, tier classification (unit / integration / E2E), pyramid ratio vs canonical 70/20/10, per-layer flake rate, ROI per tier, selector quality, assertion quality. Emits categorical verdict (Healthy / Needs pruning / Needs refactor / Cannot assess) with top-3 prune/expand/refactor recommendations. Distinct from framework-architecture-auditor (single-framework, narrow) and qa-roles/test-architect (A2, prescribes strategy). |
| Skill | test-design-scorecard | Scores test files 1 to 5 on six design axes with explicit per-level anchors, then turns the scores into growth-framed feedback and a per-author trend. Produces a score, not a merge verdict. |
| Skill | test-suite-health-audit | Measures a suite on tier mix, pyramid distance, per-layer flake rate and ROI per tier, then reduces to one verdict. Reports against a target without prescribing one. |
| Skill | test-framework-architecture-audit | Audits the framework itself across eight axes (page objects, base-class depth, fixtures, helpers, naming, waits, convention drift, CI) and labels which numeric cuts are conventions rather than standards. |
Install
/plugin marketplace add testland/qa
/plugin install qa-test-review@testland-qaSkills
object-model-patterns
Pure reference catalog of the canonical object-model architecture patterns for test automation frameworks - Page Object Model (Fowler), Screenplay (Marcano/Palmer/Hill), Component Object, App Actions (Cypress idiom), Service Object, Repository, and Screen Object (the desktop/mobile sibling of Page Object covering Windows UIA, macOS XCTest, Linux AT-SPI, Appium / Espresso) - each with its canonical citation, when-to-use rules, refuse-to-mix anti-patterns, and a worked example. This is the architecture-tier reference - what each pattern *is* - not file-level style rules and not tool-specific configuration. Use when designing, reviewing, or migrating a test framework's object-model architecture.
test-code-conventions
Pure-reference catalog of test-code conventions: AAA structure (Arrange / Act / Assert), per-test single-responsibility, descriptive naming (`{sut}_{scenario}_{expected}`), assertion specificity, mocking rationale (state vs behavior, fake vs mock), fixture-coupling rules, and the magic-number / hard-coded-string anti-patterns; the E2E selector-priority and web-first-assertion conventions live in references/. Use as the shared rule book a test-code review cites back to, or as onboarding for what makes a test code-reviewable; to score a test's quality on weighted axes use test-design-scorecard, and for setup/teardown isolation specifically use test-isolation-patterns.
test-design-scorecard
Scores test files 1 to 5 on six design axes (AAA phase separation, single-responsibility, naming, fixture coupling, magic literals, setup time) using explicit per-level anchors that settle what separates a 2 from a 4, then turns the scores into growth-framed feedback and a per-author trend report; the per-PR and per-author rollup examples and trend-reporting conventions live in references/. Owns the scoring and the write-up only: the conventions being scored live in a separate conventions catalog such as `test-code-conventions`, and block-or-approve gating belongs to an adversarial review. Use when a test diff needs a graded coaching read rather than a merge verdict: onboarding a new engineer, a team deliberately ramping up test discipline, or a quarterly per-author trend where the output is a conversation, not a gate.
test-framework-architecture-audit
Audits an existing test automation framework across eight architecture-tier axes and bands each one PASS, WARN, or FAIL: page-object coverage and purity, base-class inheritance depth, fixture scope and coupling, helper sprawl, naming-convention drift, retry and wait consistency, documented-versus-actual convention drift, and CI integration health. Carries the numeric cut behind every band and labels which cuts are practitioner conventions rather than published standards. Measures the framework's own structure (page objects, base classes, fixtures, helpers, conventions), not the suite's tier mix or flake rate, and not the design of a framework that does not exist yet. Use when a test framework has grown for a release or more without structural review, before a major refactor, or when a team suspects its written test conventions no longer match what the code actually does.
test-framework-blueprint
Build-an-X workflow that takes an SDET from no test suite to a complete framework design in seven steps - inventory the SUT, choose runner + language, directory layout + fixture architecture, object-model decision, test data + mocking wiring, reporting + CI integration, conventions doc + review gates - producing a written framework blueprint (directory tree, fixture list, chosen patterns, CI matrix) plus an implementation order. This is the whole-framework design workflow - not the Step 2 runner-choice decision on its own, not the Step 4 object-model pattern catalog it defers to, and not the scaffolder that generates the harness skeleton once the blueprint exists. Use when designing a test automation framework from scratch or re-architecting one that grew organically.
test-isolation-patterns
Pure reference catalog of test-isolation and fixture-lifecycle patterns - the four-phase test pattern (Meszaros), fixture scope (per-test / per-describe / shared / global), the Fresh-Fixture vs Shared-Fixture trade-off (Fowler), parallel-safety patterns, and cleanup discipline (afterEach / afterAll / tagged-cleanup), plus a pattern-selection guide and a worked leaking-state diagnosis. The database-isolation strategies (transaction-rollback / database-per-worker / template-database) and network / external-service stubbing live in references/. This is the architecture-tier reference, not a file-level fixture-coupling style rule. Use when designing fixture scope and isolation strategy, auditing fixture coupling or retry/wait policy, or moving a suite to parallel execution.
test-step-design-patterns
Pure reference catalog of test-step design patterns at the architecture tier - step granularity (one logical action per step), abstraction layers (mechanical → page → business), step extraction rules (when to inline / when to extract to a helper / when to extract to a Page Object method), the declarative-vs-imperative phrasing rule, FIRST principles (Fast / Independent / Repeatable / Self-validating / Timely), and the AAA / Given-When-Then mapping. This is the cross-framework architecture-tier reference for what a step IS, when it should exist, and where it should live - not file-level AAA style rules and not Gherkin-specific translation. Use when designing or reviewing the step layer of a test framework - for example when writing or reviewing E2E or integration tests, when the step count per test is high, or when refactoring recorded or codegen test output into readable steps.
test-suite-health-audit
Measures an existing test suite's current state on four axes: per-file tier classification (unit / integration / E2E, first match wins), pyramid ratio against whatever target the team already committed to, per-layer flake rate, and defects-caught-per-run-minute ROI per tier, then reduces them to one categorical verdict (Healthy, Needs pruning, Needs refactor, Cannot assess). Reports severity against a target ratio but never prescribes one: choosing the target unit:integration:E2E mix and the rebalancing plan belongs to a pyramid-balancing capability such as `test-pyramid-balancer`. Use when a suite has grown for a year or more without review and someone needs a defensible read on whether it is healthy, over-grown, or structurally inverted before deciding what to delete or rewrite.
Agents
assertion-quality-reviewer
Adversarial reviewer specialized for assertion quality - flags weak / vague matchers (`expect(x).toBeTruthy()` / `.toBeDefined()` / `.toContain('error')` style) and recommends specific replacements (`.toEqual({...})` / `.toBe(expected)` / `.toMatch(regex)`). Walks per-§4 of `test-code-conventions`. Use during PR review against test files; complements `test-code-critic` (which handles structure / naming) and `mocking-anti-pattern-detector` (which handles mocking specificity).
e2e-selector-quality-critic
Adversarial reviewer specialized for E2E test selector fragility only - flags brittle CSS class selectors / nth-child / XPath / position-based selectors and recommends `getByRole` / `getByLabelText` / accessibility-first equivalents per Testing Library's priority order. Per Playwright best practices: "automated tests should verify that the application code works for the end users, and avoid relying on implementation details." For non-web-first assertion style (`.isVisible()` checked synchronously vs the `await expect(...).toBeVisible()` form) and matcher specificity, see `assertion-quality-reviewer`. Use against any E2E test files (Playwright / Cypress / Selenium / WebdriverIO) when the concern is selector fragility.
framework-architecture-auditor
Adversarial reviewer that audits the test framework codebase at the **architecture tier** - POM consistency across pages, base-class hierarchy depth, fixture coupling and scope, helper sprawl, naming-convention drift between modules, retry / wait convention consistency, documented-vs-actual convention drift, CI integration health, and dead helpers. Operates on the whole test directory, not individual test files. Distinct from `test-code-critic`, `assertion-quality-reviewer`, `e2e-selector-quality-critic`, and `mocking-anti-pattern-detector` (sibling critics in this plugin, each reviewing individual test files); this agent reviews **patterns across files** that per-file critics structurally cannot see. Use as a quarterly / per-release framework-health audit, or before a major refactor.
mocking-anti-pattern-detector
Adversarial reviewer scoped to mocking patterns only - flags over-mocking (mocking what the team owns when state verification would do), mock chains (`when(a.method()).thenReturn(when(b.x).thenReturn(...))` style coupling), behavior-verification leakage (asserting which methods were called instead of asserting on the SUT's resulting state), and mocking third-party boundaries the team doesn't own (libraries / framework internals). Per Fowler's classical (Detroit) school: prefer state verification; fakes over mocks for stateful collaborators. Scope is mocking patterns only, not general test-code conventions (see `test-code-critic` for those). Does not cover test-double reset or teardown lifecycle between tests (see `test-isolation-patterns`). Use during PR review against test files when the concern is mocking technique.
test-code-critic
Adversarial reviewer specialized for **test files only** - flags violations of the conventions in `test-code-conventions` (AAA structure, single-responsibility per test, descriptive naming, magic numbers, slow setup) with file:line evidence and the convention-section reference. Refuses to review non-test files (production code is the job of saturated production-reviewer agents elsewhere). Use as a PR-time check that runs only against `*.spec.*` / `*.test.*` / `tests/**` paths.
test-suite-health-auditor
Adversarial cross-tool auditor that evaluates an existing test suite's current state across seven axes: file inventory, tier classification (unit/integration/E2E), pyramid ratio vs canonical 70/20/10, per-layer flake rate, ROI per tier, selector quality, and assertion quality. Emits a categorical verdict (Healthy / Needs pruning / Needs refactor / Cannot assess) with per-axis findings and top-3 recommendations. Distinct from qa-roles/test-architect (prescribes strategy) and qa-test-review/framework-architecture-auditor (single-framework, narrow scope). Use when a team wants an outside read on overall suite health rather than per-test or per-framework review.