canary-test-cli 7.1.0 → 8.0.0

package/agents/skills/claude-code/canary-edge-case-discovery/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: canary-edge-case-discovery
+description: >
+  Given a feature description, function signature, or existing test suite,
+  surfaces edge cases worth testing across six categories. Explanation depth
+  scales to user skill level. Optionally focuses on critical areas when
+  critical-areas.json is present.
+---
+
+# Canary: Edge Case Discovery
+
+Surfaces the edge cases that tests typically miss: the inputs and conditions
+that work in demos but break in production.
+
+## When to Use
+
+- After writing happy-path tests: "what else should I test?"
+
+- When reviewing a feature for robustness
+
+- As Phase 2 of `/canary-test-pipeline`
+
+- When asked "what edge cases should I cover?"
+
+## Input
+
+Provide one of:
+
+- A feature description: `"points accrual on tier upgrade"`
+
+- A function signature:
+  `accruePoints(memberId: string, amount: number): Promise<Result>`
+
+- A test file path: `tests/loyalty/points.spec.ts`
+
+- Or nothing — Canary will infer from open files and recent context
+
+If `.canary/critical-areas.json` is present, focus edge case discovery on the
+highest-risk areas first (rank_score ≥ 0.6).
+
+## The Six Categories
+
+For each category, generate specific, actionable cases — not generic advice.
+
+### 1. Boundary values
+
+Zero, negative, max integer, empty string, null, undefined, one-off-by-one. For
+amounts: 0, 1, MAX_SAFE_INTEGER, -1, 0.001 (floating point). For strings: empty
+string, whitespace-only, max-length + 1 character.
+
+### 2. Race conditions
+
+Concurrent writes to the same resource. Double-submit (user clicks twice). Stale
+reads after an update. Lock contention. Out-of-order async responses.
+
+### 3. Locale and timezone
+
+DST transition times. Dates at midnight UTC vs local time. Non-ASCII characters
+in names and addresses. RTL text in string fields. Locale-specific number
+formats (1.000,00 vs 1,000.00). Emoji in text fields.
+
+### 4. Partial network
+
+Request timeout mid-flight. Dropped connection after partial response. Retry
+storms (client retries while server is still processing). Response truncation.
+
+### 5. Unexpected input shapes
+
+Extra fields the schema doesn't expect. Missing required fields. Wrong types
+(string where number expected). SQL or script injection strings. Deeply nested
+objects. Arrays where scalars expected.
+
+### 6. Accessibility
+
+Keyboard-only navigation paths. Missing ARIA labels. Focus trap conditions.
+Screen reader text for dynamic content. Colour contrast for status indicators.
+_(Only include if the input is a UI feature or test.)_
+
+## Output Depth
+
+**Consult the resolved persona; do not infer one here.** The engine owns that
+decision (issue #462) so every skill adapts the same way and a downstream
+overlay has one place to override.
+
+Resolve it in this order:
+
+1. `--level <id>` if the caller passed one. It is the explicit override and
+   always wins.
+2. The `persona` block on a `canary__analyze_file` response. It carries `id`,
+   `depth`, `formats`, `reasoning`, plus `source`, `reason`, and `signals` — the
+   evidence behind the choice.
+3. Neither available → use `junior`, the engine's fallback. Erring explanatory
+   is deliberate: over-explaining is a mild annoyance, under-explaining silently
+   fails a manual tester.
+
+Render from the persona's `depth`, not from its `id` — an overlay may add
+personas this table never listed:
+
+| `depth`  | Output style                        |
+| -------- | ----------------------------------- |
+| `terse`  | Bullet list of cases only           |
+| `brief`  | Cases + one-line _why this matters_ |
+| `guided` | Cases + numbered reproduction steps |
+
+When `reasoning` is true, say which persona shaped the output and why —
+`persona.reason` is written to be quoted.
+
+Read `source` before trusting the persona, and treat the three values
+differently:
+
+- `explicit` — the reader chose this. Do not second-guess it.
+- `detected` — inferred from at least two independent signals about the project.
+  Reliable enough to act on, still a guess; mention it is overridable with
+  `CANARY_PERSONA` or `--level` if the depth seems wrong for them.
+- `fallback` — the engine **declined** to guess, which is the common case. That
+  is not a failure and not a reason to go hunting for signals of your own: it
+  means the evidence did not clear the floor, and re-deriving an audience here
+  is exactly the hand-rolling this section replaced. Use the persona as given.
+
+**Never infer `terse` on your own.** Stripping explanation from a reader who
+turns out to be a manual tester is the expensive direction of this mistake;
+`fallback` is deliberately explanatory for that reason. Note that `manual` is
+not inferable from a file analysis at all — it is reached by an explicit choice
+— so a `fallback` persona may well be a manual tester.
+
+The shipped personas are `sdet` (terse), `junior` (brief), and `manual`
+(guided); the definitions live in `ts/src/data/personas/registry.json`.
+
+## Output Format (`sdet` example)
+
+```text
+Edge cases — points accrual on tier upgrade
+
+  Boundary values
+  · amount = 0
+  · amount = MAX_SAFE_INTEGER
+  · memberId empty string
+  · memberId with special characters
+
+  Race conditions
+  · concurrent accrual calls for the same memberId
+  · double-submit within 100ms
+
+  ...
+
+  Suggested next: /canary-write-test "add edge case tests for accruePoints boundary values"
+```
+
+## Flags
+
+- `--level sdet|junior|manual` — output depth. Overrides the resolved persona;
+  the default is the persona the engine resolved (see **Output Depth**).
+
+## Related skills
+
+- `/canary-critical-areas` — produces `critical-areas.json` used for focus
+
+- `/canary-write-test` — generates tests for the surfaced cases
+
+- `/canary-test-pipeline` — Phase 2

package/agents/skills/claude-code/canary-edge-case-discovery/skill.yaml

@@ -0,0 +1,16 @@
+name: canary-edge-case-discovery
+version: '1.0.0'
+description:
+  Surface edge cases worth testing across six categories from a feature
+  description, function signature, or existing suite; explanation depth scales
+  to user skill level.
+stability: static
+triggers:
+  - manual
+platforms:
+  - claude-code
+type: rigid
+tools: []
+tier: 1
+depends_on:
+  - canary-ci-ready

package/agents/skills/claude-code/canary-fail-fast/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: canary-fail-fast
+description:
+  Surface test failures fast and loud — audit a Playwright config for fail-fast
+  knobs (maxFailures/forbidOnly/retries) and print a loud, categorized failure
+  digest to the CI log + ::error annotations at run end, failing the step so the
+  signal can't be missed. Self-contained (bundles its own Playwright JSON parser
+  and failure categorizer).
+cli: scripts/cli.mjs
+requires: [node>=20]
+---
+
+# Canary Fail-Fast
+
+Make test failures **fast** (abort a broken run early) and **loud** (surface in
+the CI log + Checks, not a file). Two halves:
+
+1. **Fail-fast config audit** — flags the absence of `maxFailures`,
+   `forbidOnly`, and `retries` in a `playwright.config.*`.
+2. **Loud run-end digest** — a terse, categorized failure summary to stdout +
+   `::error` annotations, with a non-zero exit.
+
+Self-contained: it bundles a minimal Playwright JSON parser and the failure
+categorizer, so it has no dependency on any other skill.
+
+## Fail-fast config (paste into `playwright.config.ts`)
+
+```ts
+export default defineConfig({
+  // Fail fast in CI: abort once enough has clearly broken, never on local runs.
+  forbidOnly: !!process.env.CI, // a stray test.only fails the build
+  maxFailures: process.env.CI ? 10 : 0, // stop the run after 10 failures in CI
+  retries: process.env.CI ? 2 : 0, // absorb flakes in CI; surface them locally
+  // ...your existing config
+});
+```
+
+## Invocation
+
+```bash
+# Loud failure digest from a Playwright JSON run (exits non-zero on failures):
+canary skills run canary-fail-fast -- --results test-results/results.json
+
+# Audit the fail-fast config:
+canary skills run canary-fail-fast -- --config playwright.config.ts
+
+# Both at once:
+canary skills run canary-fail-fast -- \
+  --results test-results/results.json \
+  --config playwright.config.ts
+
+# Usage and the full flag list (exits 0):
+canary skills run canary-fail-fast -- --help
+```
+
+At least one of `--results` / `--config` is required. The digest exits `1` when
+any test failed (so the CI step fails); the config audit alone never fails the
+build.
+
+## CI wiring (GitHub Actions)
+
+Run after the Playwright step with `if: always()` so the digest surfaces even
+when the test step already failed:
+
+```yaml
+- name: Run Playwright
+  run:
+    npx playwright test --reporter=json --output-file=test-results/results.json
+
+- name: Fail-fast digest
+  if: always()
+  run: |
+    canary skills run canary-fail-fast -- \
+      --results test-results/results.json
+```

package/agents/skills/claude-code/canary-fail-fast/scripts/cli.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// canary-fail-fast -- surface test failures fast and loud. Ported behavior-for-
+// behavior from the Python original.
+//
+// Two halves:
+//   --config <playwright.config.*>  audit fail-fast knobs (maxFailures/forbidOnly/
+//                                   retries); print recommendations (read-only).
+//   --results <playwright.json>     print a loud, categorized failure digest to
+//                                   the CI log + ::error annotations; exit non-
+//                                   zero on any failure so the step fails.
+//
+// At least one of --config / --results is required. Self-contained -- no
+// external skill dependency.
+//
+// Invoked via `canary skills run canary-fail-fast -- --results <json> [--config <path>]`.
+
+import fs from 'node:fs';
+
+import {
+  createParser,
+  formatUsageError,
+  EXIT_USAGE,
+} from '../../../lib/parse-args.mjs';
+import { parseFailures } from './parse.mjs';
+import { buildDigest } from './digest.mjs';
+import { checkConfig } from './fastfail_check.mjs';
+
+const PREFIX = 'canary-fail-fast:';
+const DASH = '\u2014'; // em dash (see digest.mjs)
+
+const USAGE =
+  'usage: canary-fail-fast [-h] [--results PATH] [--config PATH]\n' +
+  '\n' +
+  'Fail-fast config audit + loud run-end failure digest.';
+
+/**
+ * Both value flags are optional here -- main enforces "at least one of
+ * --results / --config" itself, because argparse has no vocabulary for that.
+ * The four shared invariants live in the shared parser (#479).
+ */
+export const CLI_SPEC = {
+  prog: 'canary-fail-fast',
+  values: {
+    '--results': { key: 'results' },
+    '--config': { key: 'config' },
+  },
+};
+
+const parseArgs = createParser(CLI_SPEC);
+
+export function main(argv = []) {
+  const { opts: args, help, error } = parseArgs(argv);
+
+  if (help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (error) {
+    console.error(formatUsageError(CLI_SPEC.prog, error));
+    return EXIT_USAGE;
+  }
+
+  if (!args.results && !args.config) {
+    console.error(
+      `${PREFIX} nothing to do ${DASH} pass --results and/or --config.`,
+    );
+    return 1;
+  }
+
+  // ---- config audit -----------------------------------------------------
+  if (args.config) {
+    let text;
+    try {
+      text = fs.readFileSync(args.config, 'utf8');
+    } catch (exc) {
+      console.error(`${PREFIX} cannot read config: ${exc.message}`);
+      return 1;
+    }
+    const recs = checkConfig(text);
+    if (recs.length) {
+      console.log('Fail-fast config recommendations:');
+      for (const r of recs) console.log(`  - ${r}`);
+    } else {
+      console.log('Fail-fast config OK.');
+    }
+  }
+
+  // ---- failure digest ---------------------------------------------------
+  let exitCode = 0;
+  if (args.results) {
+    if (!fs.existsSync(args.results)) {
+      console.error(`${PREFIX} results file not found: ${args.results}`);
+      return 1;
+    }
+    let failures;
+    try {
+      failures = parseFailures(args.results);
+    } catch (exc) {
+      console.error(`${PREFIX} ${exc.message}`);
+      return 1;
+    }
+    const d = buildDigest(failures);
+    console.log(d.text);
+    for (const ann of d.annotations) console.log(ann);
+    exitCode = d.exitCode;
+  }
+
+  return exitCode;
+}
+
+// Direct execution (the skill runner execs this file via its shebang).
+//
+// `process.exitCode`, not `process.exit()`: a large `--json` payload exceeds
+// the pipe buffer, and `process.exit` tears the process down mid-write, leaving
+// truncated JSON that still exits 0 (#791).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  process.exitCode = main(process.argv.slice(2));
+}

package/agents/skills/claude-code/canary-fail-fast/scripts/digest.mjs

@@ -0,0 +1,69 @@
+// digest -- loud, categorized failure digest (pure). Ported behavior-for-
+// behavior from the Python original.
+//
+// Turns a list of failures into a terse CI-log digest + `::error` workflow
+// annotations + a non-zero exit code, so an engineer triages from the run log
+// without opening the HTML report.
+
+import { FAILURE_CATEGORIES, categorizeFailure } from './failures.mjs';
+
+// Output glyphs kept as \u escapes so the source stays ASCII while the emitted
+// text is byte-identical to the Python original.
+const CHECK = '\u2705'; // white heavy check mark
+const CROSS = '\u274c'; // cross mark
+const DASH = '\u2014'; // em dash
+
+/**
+ * @typedef {{text: string, annotations: string[], exitCode: number}} Digest
+ */
+
+function firstLine(error, limit = 160) {
+  if (!error) return '(no error message)';
+  for (const raw of error.split(/\r\n|\r|\n/)) {
+    const line = raw.trim();
+    if (line) return line.slice(0, limit);
+  }
+  return '(no error message)';
+}
+
+/** Build the digest text, `::error` annotations, and exit code from failures. */
+export function buildDigest(failures) {
+  if (!failures.length) {
+    return { text: `${CHECK} 0 failing tests.`, annotations: [], exitCode: 0 };
+  }
+
+  const n = failures.length;
+  const byCat = new Map();
+  for (const f of failures) {
+    const cat = categorizeFailure(f.error);
+    if (!byCat.has(cat)) byCat.set(cat, []);
+    byCat.get(cat).push(f);
+  }
+
+  const lines = [
+    `${CROSS} ${n} failing test${n !== 1 ? 's' : ''} ${DASH} triage by category:`,
+    '',
+  ];
+  for (const cat of FAILURE_CATEGORIES) {
+    const bucket = byCat.get(cat);
+    if (!bucket || !bucket.length) continue;
+    lines.push(`  ${cat} (${bucket.length}):`);
+    for (const f of bucket) {
+      lines.push(`    - ${f.title} ${DASH} ${firstLine(f.error)}`);
+    }
+  }
+  const text = lines.join('\n');
+
+  const annotations = [];
+  for (const f of failures) {
+    const cat = categorizeFailure(f.error);
+    let loc = '';
+    if (f.file) loc += `file=${f.file},`;
+    if (f.line !== null && f.line !== undefined) loc += `line=${f.line},`;
+    annotations.push(
+      `::error ${loc}title=Test failure::${f.title} ${DASH} ${cat}: ${firstLine(f.error)}`,
+    );
+  }
+
+  return { text, annotations, exitCode: 1 };
+}

package/agents/skills/claude-code/canary-fail-fast/scripts/failures.mjs

@@ -0,0 +1,60 @@
+// failures -- heuristic failure categorization (self-contained, pure). Ported
+// behavior-for-behavior from the Python original.
+//
+// Order matters -- the most distinctive signals are checked first so 4xx/5xx
+// status-code patterns don't swallow schema errors that happen to mention a
+// status code in a response preview.
+
+export const FAILURE_CATEGORIES = [
+  'schema',
+  'auth',
+  'server',
+  'client',
+  'timeout',
+  'network',
+  'other',
+];
+
+// [category, pattern] pairs in match-priority order (distinct from the display
+// order in FAILURE_CATEGORIES). Patterns are case-insensitive and stateless
+// (no `g` flag), mirroring Python's re.search with re.IGNORECASE.
+//
+// Intentional deviation (exotic input only): the `\b` word boundaries use
+// JavaScript's ASCII-only word-character definition, whereas Python's `re` is
+// Unicode-aware by default. An accented/non-ASCII letter glued directly to a
+// status code (a "u"-with-umlaut immediately before `401`, say) can therefore
+// categorize differently than the Python original. This is negligible for real
+// Playwright error messages, which are
+// ASCII around status codes; documented so the behavior reads as deliberate.
+const RULES = [
+  [
+    'schema',
+    /ZodError|invalid[_ ]type|unrecognized key|expected .+ received|at path "|\bzod\b/i,
+  ],
+  [
+    'auth',
+    /\b401\b|unauthorized|\b403\b|forbidden|invalid(?: auth)? token|token expired/i,
+  ],
+  ['timeout', /timeout|timed out|etimedout|deadline exceeded/i],
+  [
+    'network',
+    /econnrefused|enotfound|econnreset|socket hang up|getaddrinfo|network request failed/i,
+  ],
+  [
+    'server',
+    /\b5\d{2}\b|internal server error|bad gateway|service unavailable|gateway timeout/i,
+  ],
+  [
+    'client',
+    /\b4(?:0[045-9]|1\d|2\d)\b|bad request|not found|unprocessable|conflict/i,
+  ],
+];
+
+/** Return the category of a failure error message ('other' when unknown). */
+export function categorizeFailure(error) {
+  if (!error) return 'other';
+  for (const [category, pattern] of RULES) {
+    if (pattern.test(error)) return category;
+  }
+  return 'other';
+}

package/agents/skills/claude-code/canary-fail-fast/scripts/fastfail_check.mjs

@@ -0,0 +1,43 @@
+// fastfail_check -- fail-fast config audit for a Playwright config (pure, read-
+// only). Ported behavior-for-behavior from the Python original.
+//
+// Scans a `playwright.config.*` for the fail-fast knobs a suite should set so a
+// broken CI run aborts early instead of burning the whole matrix. Never edits
+// the config -- it recommends, and CANONICAL is the block to paste in.
+
+const DASH = '\u2014'; // em dash (see digest.mjs)
+
+// The block to paste into playwright.config.ts. Exported for reference; the CLI
+// does not emit it.
+export const CANONICAL = `export default defineConfig({
+  // Fail fast in CI: abort once enough has clearly broken, never on local runs.
+  forbidOnly: !!process.env.CI,             // a stray test.only fails the build
+  maxFailures: process.env.CI ? 10 : 0,     // stop the run after 10 failures in CI
+  retries: process.env.CI ? 2 : 0,          // absorb flakes in CI; surface them locally
+  // ...your existing config
+});
+`;
+
+// knob name -> why it matters, in the Python dict's insertion order.
+const KNOBS = [
+  ['forbidOnly', 'a stray `test.only` silently skips the rest of the suite'],
+  [
+    'maxFailures',
+    'a broken run keeps burning the matrix instead of aborting early',
+  ],
+  [
+    'retries',
+    'flakes either fail the build or hide locally without a CI retry policy',
+  ],
+];
+
+/**
+ * Return one recommendation per fail-fast knob missing from the config text.
+ * Empty array means all knobs are present. Substring scan -- good enough to flag
+ * absence; it does not validate the knob's value.
+ */
+export function checkConfig(text) {
+  return KNOBS.filter(([knob]) => !text.includes(knob)).map(
+    ([knob, why]) => `Add \`${knob}\` ${DASH} without it, ${why}.`,
+  );
+}

package/agents/skills/claude-code/canary-fail-fast/scripts/parse.mjs

@@ -0,0 +1,149 @@
+// parse -- minimal Playwright JSON parser (failing tests only, self-contained).
+// Ported behavior-for-behavior from the Python original.
+//
+// Walks the Playwright JSON reporter's nested suites/specs/tests and returns the
+// real failures. A failed/unexpected test with a passing retry is flaky and
+// excluded; without one it is a failure. Leading non-JSON banners are stripped
+// before parsing (matches the reporter's defensive indexOf('{')).
+
+import fs from 'node:fs';
+
+/**
+ * @typedef {{title: string, status: string, file: (string|null),
+ *            line: (number|null), error: (string|null)}} Failure
+ */
+
+/** Build a Failure with the Python dataclass defaults (absent -> null). */
+export function Failure(fields) {
+  return {
+    title: fields.title,
+    status: fields.status,
+    file: fields.file ?? null,
+    line: fields.line ?? null,
+    error: fields.error ?? null,
+  };
+}
+
+function isObject(x) {
+  return x !== null && typeof x === 'object' && !Array.isArray(x);
+}
+
+// Mirror Python dict.get: `.get` on a non-dict (str/list/number/None) raises
+// AttributeError, which parseFailures converts into a structured error. Here a
+// non-object access throws TypeError, caught by the same conversion.
+function dget(obj, key, dflt) {
+  if (!isObject(obj)) throw new TypeError('value is not an object');
+  return key in obj ? obj[key] : dflt;
+}
+
+// Mirror Python's `container or []` for a for-loop target. Python truthiness
+// differs from JS: an empty object `{}` and empty string `""` are FALSY in
+// Python but TRUTHY in JS. A naive `x || []` would turn `{"suites": {}}` into a
+// thrown "unexpected structure" (JS iterates the truthy `{}`) where Python
+// quietly iterates nothing -- flipping a CI pass into a fail. So:
+//   - any Python-falsy value (null/undefined/false/0/""/[]/{})  -> [] (iterate nothing)
+//   - an Array                                                  -> the array
+//   - any other truthy value (non-empty object/string/number)   -> returned as-is,
+//     so `for...of` reproduces Python's iterate-then-`.get`-fails path (a string
+//     iterates its chars; a non-empty object/number is non-iterable and throws),
+//     which surfaces as the same "unexpected structure" error.
+function asItems(v) {
+  if (Array.isArray(v)) return v;
+  if (v && typeof v === 'object') return Object.keys(v).length ? v : [];
+  if (v && typeof v !== 'object') return v; // non-empty string / truthy number
+  return []; // null/undefined/false/0/""
+}
+
+/** Parse a Playwright JSON results file, returning only the real failures. */
+export function parseFailures(resultsPath) {
+  if (!fs.existsSync(resultsPath)) return [];
+
+  let text = fs.readFileSync(resultsPath, 'utf8');
+  const braceAt = text.indexOf('{');
+  if (braceAt > 0) text = text.slice(braceAt);
+
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (exc) {
+    throw new Error(`results file is not valid JSON: ${exc.message}`);
+  }
+
+  if (!isObject(data)) {
+    throw new Error("results file's top-level value must be an object");
+  }
+
+  const failures = [];
+  try {
+    for (const suite of asItems(data.suites)) {
+      processSuite(suite, failures, '', '');
+    }
+  } catch (exc) {
+    if (exc instanceof TypeError) {
+      throw new Error(
+        `results file has an unexpected structure: ${exc.message}`,
+      );
+    }
+    throw exc;
+  }
+  return failures;
+}
+
+function processSuite(suite, failures, parentPath, suiteFile) {
+  const suiteTitle = dget(suite, 'title', '');
+  const suitePath = parentPath ? `${parentPath} > ${suiteTitle}` : suiteTitle;
+  const currentFile = dget(suite, 'file', undefined) || suiteFile;
+
+  for (const child of asItems(dget(suite, 'suites', []))) {
+    processSuite(child, failures, suitePath, currentFile);
+  }
+
+  for (const spec of asItems(dget(suite, 'specs', []))) {
+    const specPath = `${suitePath} > ${dget(spec, 'title', '')}`;
+    const specLocation = dget(spec, 'location', undefined) || {};
+    for (const test of asItems(dget(spec, 'tests', []))) {
+      const testTitle =
+        dget(test, 'title', undefined) || dget(spec, 'title', '');
+      const testLocation = dget(test, 'location', undefined) || {};
+      const results = asItems(dget(test, 'results', undefined));
+
+      const status = dget(test, 'status', 'unknown');
+      if (status !== 'unexpected' && status !== 'failed') continue;
+
+      const hasPassingRetry = results.some((r) => {
+        const s = dget(r, 'status', undefined);
+        return s === 'passed' || s === 'expected';
+      });
+      if (hasPassingRetry) continue; // flaky -- excluded from the failure count
+
+      let error = null;
+      if (results.length) {
+        const last = results[results.length - 1];
+        const err = dget(last, 'error', undefined) || {};
+        error = dget(err, 'message', undefined);
+        if (error === undefined || error === null) {
+          const errs = dget(last, 'errors', undefined) || [];
+          if (errs.length) {
+            error = dget(errs[0], 'message', undefined);
+          }
+        }
+      }
+
+      failures.push(
+        Failure({
+          title: `${specPath} > ${testTitle}`,
+          status,
+          file:
+            dget(testLocation, 'file', undefined) ||
+            dget(specLocation, 'file', undefined) ||
+            currentFile,
+          line:
+            dget(testLocation, 'line', undefined) ||
+            dget(specLocation, 'line', undefined) ||
+            null,
+          error,
+        }),
+      );
+    }
+  }
+}