eslint-plugin-test-governance 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -6,6 +6,26 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.6.2] - 2026-10-14
+
+### Fixed
+
+- A test or describe whose function a condition picks, as in
+  `(process.env.CI ? describe.skip : describe)('order book', fn)`, is now read as a conditional skip in
+  Playwright, Jest and Vitest. Before, it wasn't seen at all: a `// SKIP:` marker above it was reported
+  as orphaned, tags in its title didn't reach its tests, and `requireTicketForConditional` didn't
+  require a ticket for it. In code without semicolons, a marker above the `;` that starts the line
+  belongs to it.
+
+## [0.6.1] - 2026-10-14
+
+### Fixed
+
+- In Playwright, `test.slow('title', body)` is no longer read as a slow test declared with a title.
+  Playwright has no such form: `slow` only marks a running test, and a string before the description
+  is its condition, so the call is checked like `test.slow(condition, description)`. Before, with the
+  `slow` state on, it needed a `// SLOW:` marker even without `requireTicketForConditional`.
+
 ## [0.6.0] - 2026-10-14
 
 This release renames the `unstable` state to `quarantined`.
@@ -285,7 +305,9 @@ First release.
 - Support for ESLint 9 and 10 flat config, JavaScript and TypeScript test files, `.extend()`
   fixtures, describe blocks, runtime skips and tags in titles or the `tag` option.
 
-[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.2...HEAD
+[0.6.2]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.1...v0.6.2
+[0.6.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.4.0...v0.5.0

package/README.md

@@ -136,10 +136,12 @@ turn on the same rules. What puts a test in a state in each framework:
 | `fixme` (`// FIXME:`)                  | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                        |                                                                      |                                                                                                                                                                                            |
 | `fail` (`// FAIL:`), off by default    | `test.fail(...)`, `testInfo.fail()`                                                                                 | `test.failing`                                                       | `test.fails`, `{ fails: true }`                                                                                                                                                            |
 | `slow` (`// SLOW:`), off by default    | `test.slow()`, `testInfo.slow()`                                                                                    |                                                                      |                                                                                                                                                                                            |
-| conditional skip, no ticket by default | `test.skip(condition)`, `if (...) test.skip()`                                                                      |                                                                      | `skipIf(condition)`, `runIf(condition)`, `{ skip: condition }`, `context.skip(condition)`, `if (...) context.skip()`                                                                       |
+| conditional skip, no ticket by default | `test.skip(condition)`, `if (...) test.skip()`, `(condition ? test.skip : test)(...)`                               | `(condition ? it.skip : it)(...)`                                    | `skipIf(condition)`, `runIf(condition)`, `{ skip: condition }`, `context.skip(condition)`, `if (...) context.skip()`, `(condition ? it.skip : it)(...)`                                    |
 | tags such as `@new` (`// NEW:`)        | the title, `{ tag }`                                                                                                | the title                                                            | the title, `{ tags }`, where `'new'` and `'@new'` both mean `@new`                                                                                                                         |
 
 Table-driven tests count too: `test.skip.each(table)(...)`, `describe.skip.each` and Vitest's `.for`.
+A test or describe whose function a condition picks, as in `(isMobile ? test.skip : test)('title', fn)`,
+is a conditional skip in every framework.
 A literal condition decides on its own: `skipIf(true)` and `runIf(false)` always skip, and `skipIf(false)`,
 `runIf(true)` and `{ skip: false }` never do.
 In Vitest, `test.skip('title')` and `describe.skip('title')` with no body are skipped too.
@@ -202,7 +204,7 @@ and markers. To turn a rule off, set it to `'off'` as usual.
 | `lifecycleTags`               | `boolean`                                                      | `false`                           | Turns on the `new` (`@new`) and `quarantined` (`@quarantined`) states.                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `states`                      | `{ [state]: boolean \| { enabled?, tag?, marker?, ticket? } }` | `skip`, `fixme` and `todo` on     | Turns built-in states (`skip`, `fixme`, `fail`, `slow`, `todo`, `new`, `quarantined`) on or off, renames their tag or marker, or gives them their own ticket format. `fail` and `slow` are off by default; a setting for `new` or `quarantined` here wins over `lifecycleTags`. Only `new` and `quarantined` have a tag to rename; see [Tag names](#tag-names). `fixme` and `slow` exist only in Playwright and `todo` only in Jest and Vitest, so turning one on elsewhere has no effect. |
 | `customStates`                | `{ [name]: { when, marker, ticket? } }`                        | `{}`                              | Adds a state for a tag, e.g. `{ 'needs-data': { when: '@needs-data', marker: 'NEEDS-DATA' } }`. `when` is a tag and `marker` an uppercase keyword; neither can be shared with another state.                                                                                                                                                                                                                                                                                               |
-| `requireTicketForConditional` | `boolean`                                                      | `false`                           | Require a ticket for conditional skips too: `test.skip(condition, ...)`, `if (...) test.skip()`, a skip in a `catch` block or after an early `return` or `throw`.                                                                                                                                                                                                                                                                                                                          |
+| `requireTicketForConditional` | `boolean`                                                      | `false`                           | Require a ticket for conditional skips too: `test.skip(condition, ...)`, `if (...) test.skip()`, `(condition ? test.skip : test)(...)`, a skip in a `catch` block or after an early `return` or `throw`.                                                                                                                                                                                                                                                                                   |
 | `allowBlankLine`              | `boolean`                                                      | `false`                           | Let blank lines separate a marker from its test.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `allowNotes`                  | `boolean`                                                      | `false`                           | Allow free text after the tickets, e.g. `// SKIP: TRADE-123 flaky on CI`. Applies to markers and to `FIXME` / `TODO` comments.                                                                                                                                                                                                                                                                                                                                                             |
 | `comments`                    | `false \| { keywords?: string[] }`                             | `{ keywords: ['FIXME', 'TODO'] }` | Comment keywords that must start with a ticket anywhere in a test file, e.g. `// TODO: TRADE-123`. Your keywords replace the default ones. `false` allows free-form comments.                                                                                                                                                                                                                                                                                                              |

package/dist/utils/analyze.js

@@ -247,7 +247,12 @@ function anchorOf(call) {
 }
 /** The contiguous comment block directly above `anchor`. */
 function commentBlock(sourceCode, anchor, allowBlankLine) {
-    const comments = sourceCode.getCommentsBefore(anchor);
+    // Code without semicolons starts a line that opens with `(` with one: `;(isCI ? describe.skip : describe)(...)`.
+    const semicolon = sourceCode.getTokenBefore(anchor);
+    const leading = semicolon?.value === ';' &&
+        semicolon.loc.start.line === anchor.loc.start.line &&
+        sourceCode.getTokenBefore(semicolon)?.loc.end.line !== semicolon.loc.start.line;
+    const comments = sourceCode.getCommentsBefore(leading ? semicolon : anchor);
     const block = [];
     let nextLine = anchor.loc.start.line;
     for (let i = comments.length - 1; i >= 0; i--) {
@@ -726,16 +731,59 @@ function runAnalysis(sourceCode, options) {
         const param = body.params.at(framework.info.param + (path.includes('for()') ? 1 : 0));
         return infoNames(param, framework.info.methods);
     };
+    /**
+     * What a callee declares and with which members: `describe` and `['skip']` for `test.describe.skip`.
+     * Undefined for a hook.
+     */
+    const declarationOf = ({ root, path, args }) => {
+        if (root.kind === 'hook')
+            return undefined;
+        const playwrightDescribe = framework.playwright && path[0] === 'describe';
+        const kind = playwrightDescribe ? 'describe' : root.kind;
+        return { kind, members: [...root.modifiers, ...(playwrightDescribe ? path.slice(1) : path)], args };
+    };
+    /** Whether a call with these members and arguments declares a test or describe of this kind. */
+    const declares = ({ kind, members }, args) => {
+        const allowed = kind === 'test' ? framework.testMembers : framework.describeMembers;
+        return members.every((m) => allowed.has(m)) && isDeclaration(sourceCode, framework, kind, args, members);
+    };
+    /**
+     * `(isCI ? describe.skip : describe)('order entry', ...)`: a test or describe whose function is picked by
+     * a condition. A state that only one side has depends on the condition, like `test.skip(isCI)`.
+     */
+    const pickedDeclaration = (call) => {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'ConditionalExpression')
+            return undefined;
+        const [yes, no] = [callee.consequent, callee.alternate].map((side) => {
+            const picked = target(chainOf(unwrap(side), framework.factories));
+            return picked && declarationOf(picked);
+        });
+        const args = call.arguments;
+        if (yes === undefined || no === undefined)
+            return undefined;
+        if (yes.kind !== no.kind || !declares(yes, args) || !declares(no, args))
+            return undefined;
+        usesTest = true;
+        const details = detailsOf(sourceCode, call);
+        const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
+        const [ifYes, ifNo] = [yes, no].map(({ members, args: conditions }) => modifiersOf(members, details.entries, conditions));
+        const modifiers = new Map();
+        for (const modifier of new Set([...ifYes.keys(), ...ifNo.keys()])) {
+            modifiers.set(modifier, ifYes.get(modifier) === true && ifNo.get(modifier) === true);
+        }
+        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos: bodyInfos(args, yes.members) };
+    };
     const visitCall = (call) => {
         const callee = target(chainOf(call.callee, framework.factories));
         if (callee === undefined)
-            return { subject: runtimeCall(call) };
+            return pickedDeclaration(call) ?? { subject: runtimeCall(call) };
         usesTest = true;
         const args = call.arguments;
-        const { root } = callee;
-        let { path } = callee;
+        const { path } = callee;
+        const declaration = declarationOf(callee);
         // Vitest's `beforeEach((context) => context.skip())` skips the tests it runs before.
-        if (root.kind === 'hook')
+        if (declaration === undefined)
             return { infos: bodyInfos(args, path) };
         if (framework.playwright) {
             // `test.step('fills the order', async (step) => {...})` or `test.step.skip(...)`. The step's body
@@ -749,14 +797,8 @@ function runAnalysis(sourceCode, options) {
             }
         }
         const bodyInfo = bodyInfos(args, path);
-        let { kind } = root;
-        if (framework.playwright && path[0] === 'describe') {
-            kind = 'describe';
-            path = path.slice(1);
-        }
-        const members = [...root.modifiers, ...path];
-        const allowed = kind === 'test' ? framework.testMembers : framework.describeMembers;
-        if (members.every((m) => allowed.has(m)) && isDeclaration(sourceCode, framework, kind, args, members)) {
+        const { kind, members } = declaration;
+        if (declares(declaration, args)) {
             // A declaration always has a first argument: its title, or the body of a describe without one.
             const details = detailsOf(sourceCode, call);
             const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
@@ -766,8 +808,8 @@ function runAnalysis(sourceCode, options) {
             };
         }
         // test.skip(), test.fixme(), test.fail() and test.slow() in a test, a describe or a hook.
-        if (framework.playwright && path.length === 1 && RUNTIME_MODIFIERS.has(path[0])) {
-            return { subject: runtimeSubject(call, path[0]), infos: bodyInfo };
+        if (framework.playwright && members.length === 1 && RUNTIME_MODIFIERS.has(members[0])) {
+            return { subject: runtimeSubject(call, members[0]), infos: bodyInfo };
         }
         return { infos: bodyInfo };
     };

package/dist/utils/frameworks.js

@@ -18,14 +18,13 @@ const playwright = {
     defaultExport: TEST,
     globals: new Map(),
     testFunctions: ['test'],
-    testMembers: new Set(['only', 'skip', 'fixme', 'fail', 'slow']),
+    testMembers: new Set(['only', 'skip', 'fixme', 'fail']),
     describeMembers: new Set(['only', 'skip', 'fixme', 'serial', 'parallel']),
     factories: new Set(),
     effects: effects([
         ['skip', 'skip'],
         ['fixme', 'fixme'],
         ['fail', 'fail'],
-        ['slow', 'slow'],
     ]),
     optionEffects: new Map(),
     tagKey: 'tag',

package/docs/rules/require-ticket.md

@@ -80,6 +80,24 @@ A runtime skip under an `if`, a `switch` case, a ternary or `&&` counts as condi
 such as `catch { test.skip(true, 'Market data feed is down') }`, and a skip after an early exit such as
 `if (ready) return;` or `if (!ok) throw error;` earlier in the same function.
 
+A test or describe whose function a condition picks is a conditional skip too, in every framework. Its
+title and tags count as usual, and a marker goes above it, or in code without semicolons above the
+`;` that starts the line.
+
+<!-- example: valid -->
+
+```js
+(isMobile ? test.skip : test)('places an order', async ({ page }) => {});
+```
+
+<!-- example: invalid settings={"framework":"jest","requireTicketForConditional":true} -->
+
+```js
+(process.env.CI ? describe.skip : describe)('order book', () => {
+  it('shows the best bid', () => {});
+});
+```
+
 If one test or describe has several markers for the same state, each must be valid: in
 `// SKIP: TRADE-1` followed by `// SKIP: nope`, the second line is reported.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest and Vitest tests.",
   "keywords": [
     "eslint",