eslint-plugin-test-governance 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -6,6 +6,18 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-10-27
+
+### Added
+
+- Jasmine support. `configs.jasmine`, or `configure({ framework: 'jasmine' })`, checks tests run by
+  Jasmine on its own, on Karma with karma-jasmine (as Angular's karma builder sets up) or by WebdriverIO's
+  Jasmine framework: the globals `it`, `xit`, `fit`, `describe`, `xdescribe` and `fdescribe`, or the same
+  names from `jasmine-core`. `xit` and `xdescribe` skip a test, and `it('title')` with no function is a
+  todo. `pending()` and Jasmine 7's `notApplicable()` skip the running test in a test, `beforeEach` or
+  `afterEach`; like `t.skip('reason')`, `pending('reason')` needs a ticket unless a condition guards it.
+  `testFunctions` defaults to `['it']`, since Jasmine has no `test`.
+
 ## [0.8.1] - 2026-10-22
 
 ### Fixed
@@ -357,7 +369,8 @@ 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.8.1...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.1...v0.9.0
 [0.8.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.2...v0.7.0

package/README.md

@@ -4,7 +4,7 @@
 [![CI](https://github.com/Huldoser/eslint-plugin-test-governance/actions/workflows/ci.yml/badge.svg)](https://github.com/Huldoser/eslint-plugin-test-governance/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/npm/l/eslint-plugin-test-governance)](LICENSE)
 
-ESLint rules that keep a Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO or `node:test` suite honest. Every skipped, fixme, todo, `@new`
+ESLint rules that keep a Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, `node:test` or Jasmine suite honest. Every skipped, fixme, todo, `@new`
 or `@quarantined` test must point at the ticket that tracks it:
 
 <!-- example: valid -->
@@ -35,8 +35,8 @@ Requires ESLint 9 or 10 with flat config, and Node.js 22.12 or later. For TypeSc
 ## Usage
 
 Pick the config for the framework your tests use, `configs.playwright`, `configs.jest`,
-`configs.vitest`, `configs.mocha`, `configs.cypress`, `configs.webdriverio` or `configs['node-test']` for
-Node's built-in runner, and point it at those test files with `files`:
+`configs.vitest`, `configs.mocha`, `configs.cypress`, `configs.webdriverio`, `configs['node-test']` for
+Node's built-in runner or `configs.jasmine`, and point it at those test files with `files`:
 
 ```js
 // eslint.config.js
@@ -53,16 +53,17 @@ export default [
 ```
 
 There is no default config. Each framework declares, skips and tags tests its own way, so the rules
-need to know which one a file uses. In a Jest, Vitest or Mocha config, `test`, `it` and `describe` belong
-to that framework, whether they are globals or imported from `@jest/globals`, `vitest` or `mocha`, the
-way the Jest, Vitest and Mocha ESLint plugins are set up. `node:test` has no globals, so in its config
+need to know which one a file uses. In a Jest, Vitest, Mocha or Jasmine config, the framework's functions,
+such as `it` and `describe`, belong to it, whether they are globals or imported from `@jest/globals`,
+`vitest`, `mocha` or `jasmine-core`, the way the Jest, Vitest and Mocha ESLint plugins are set up. `node:test` has no globals, so in its config
 they are the names imported or required from `node:test`, and `test` and `it` from `testFunctions`.
 
 Cypress and WebdriverIO run their tests on Mocha, so `configs.cypress` and `configs.webdriverio` read the
-same calls as `configs.mocha`. `webdriverio` means WebdriverIO's Mocha framework; its Jasmine framework
-isn't supported yet. Puppeteer has no test functions of its own, so use the config of the runner its
-tests run on: `configs.jest` for jest-puppeteer, or `configs.vitest`, `configs.mocha` or
-`configs['node-test']`.
+same calls as `configs.mocha`. `webdriverio` means WebdriverIO's Mocha framework; for its Jasmine
+framework, use `configs.jasmine`. Karma runs Jasmine or Mocha tests, so use `configs.jasmine` with
+karma-jasmine, which Angular's karma builder sets up, and `configs.mocha` with karma-mocha. Puppeteer has
+no test functions of its own, so use the config of the runner its tests run on: `configs.jest` for
+jest-puppeteer, or `configs.vitest`, `configs.mocha`, `configs['node-test']` or `configs.jasmine`.
 
 With ESLint's `defineConfig()` (ESLint 9.22 or later), put the config in `extends`:
 
@@ -133,26 +134,30 @@ export default [
 ];
 ```
 
+This matters most for Jasmine next to Jest or Mocha, whose `it`, `xit` and `describe` look the same:
+only the `files` of each config tell them apart.
+
 Each framework's config, such as `configs.playwright`, sets only the framework, so one listed after a
 `configure()` for the same files keeps that config's options and changes only the framework. They all
 turn on the same rules. What puts a test in a state in each framework:
 
-| State (marker)                         | Playwright                                                                                                          | Jest                                                                 | Vitest                                                                                                                                                                                     | Mocha                                                                                                                                                                     | Cypress                                  | WebdriverIO | node-test                                                                                                                                                                                         |
-| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `skip` (`// SKIP:`)                    | `test.skip(...)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` | `test.skip`, `it.skip`, `describe.skip`, `xit`, `xtest`, `xdescribe` | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skipIf(true)`, `runIf(false)`, `{ skip: true }`, `context.skip()`, `context.skip('note')` or `skip()` in a body or in `beforeEach` | `it.skip`, `specify.skip`, `describe.skip`, `context.skip`, `xit`, `xspecify`, `xdescribe`, `xcontext`, TDD `test.skip` and `suite.skip`, `this.skip()` in a test or hook | as Mocha                                 | as Mocha    | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skip()`, `{ skip: true }` or `{ skip: 'reason' }`, `t.skip()`, `t.skip('reason')` or `this.skip()` in a test, `beforeEach` or `afterEach` |
-| `todo` (`// TODO:`)                    |                                                                                                                     | `test.todo`, `it.todo`                                               | `test.todo`, `describe.todo`, `{ todo: true }`                                                                                                                                             | a test with only a title, `it('title')`, which Mocha runs as pending                                                                                                      | as Mocha                                 | as Mocha    | `test.todo`, `it.todo`, `describe.todo`, `suite.todo`, `todo()`, `{ todo: true }` or `{ todo: 'reason' }`, `t.todo()`, `this.todo()`                                                              |
-| `fixme` (`// FIXME:`)                  | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                        |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |
-| `fail` (`// FAIL:`), off by default    | `test.fail(...)`, `testInfo.fail()`                                                                                 | `test.failing`                                                       | `test.fails`, `{ fails: true }`                                                                                                                                                            |                                                                                                                                                                           |                                          |             | `test.expectFailure`, `expectFailure()`, `{ expectFailure }`                                                                                                                                      |
-| `slow` (`// SLOW:`), off by default    | `test.slow()`, `testInfo.slow()`                                                                                    |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |
-| 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)(...)`                                    | `if (...) this.skip()`, `(condition ? it.skip : it)(...)`                                                                                                                 | as Mocha, and `{ browser: '!webkit' }`   | as Mocha    | `{ skip: condition }`, `{ todo: condition }`, `if (...) t.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`                                                                                                                         | the title                                                                                                                                                                 | the title, `{ tags }` from @cypress/grep | the title   | the title                                                                                                                                                                                         |
+| State (marker)                         | Playwright                                                                                                          | Jest                                                                 | Vitest                                                                                                                                                                                     | Mocha                                                                                                                                                                     | Cypress                                  | WebdriverIO | node-test                                                                                                                                                                                         | Jasmine                                                                                                                  |
+| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `skip` (`// SKIP:`)                    | `test.skip(...)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` | `test.skip`, `it.skip`, `describe.skip`, `xit`, `xtest`, `xdescribe` | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skipIf(true)`, `runIf(false)`, `{ skip: true }`, `context.skip()`, `context.skip('note')` or `skip()` in a body or in `beforeEach` | `it.skip`, `specify.skip`, `describe.skip`, `context.skip`, `xit`, `xspecify`, `xdescribe`, `xcontext`, TDD `test.skip` and `suite.skip`, `this.skip()` in a test or hook | as Mocha                                 | as Mocha    | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skip()`, `{ skip: true }` or `{ skip: 'reason' }`, `t.skip()`, `t.skip('reason')` or `this.skip()` in a test, `beforeEach` or `afterEach` | `xit`, `xdescribe`, `pending()`, `pending('reason')` or `notApplicable('reason')` in a test, `beforeEach` or `afterEach` |
+| `todo` (`// TODO:`)                    |                                                                                                                     | `test.todo`, `it.todo`                                               | `test.todo`, `describe.todo`, `{ todo: true }`                                                                                                                                             | a test with only a title, `it('title')`, which Mocha runs as pending                                                                                                      | as Mocha                                 | as Mocha    | `test.todo`, `it.todo`, `describe.todo`, `suite.todo`, `todo()`, `{ todo: true }` or `{ todo: 'reason' }`, `t.todo()`, `this.todo()`                                                              | a test with only a title, `it('title')`, which Jasmine reports as pending                                                |
+| `fixme` (`// FIXME:`)                  | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                        |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |                                                                                                                          |
+| `fail` (`// FAIL:`), off by default    | `test.fail(...)`, `testInfo.fail()`                                                                                 | `test.failing`                                                       | `test.fails`, `{ fails: true }`                                                                                                                                                            |                                                                                                                                                                           |                                          |             | `test.expectFailure`, `expectFailure()`, `{ expectFailure }`                                                                                                                                      |                                                                                                                          |
+| `slow` (`// SLOW:`), off by default    | `test.slow()`, `testInfo.slow()`                                                                                    |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |                                                                                                                          |
+| 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)(...)`                                    | `if (...) this.skip()`, `(condition ? it.skip : it)(...)`                                                                                                                 | as Mocha, and `{ browser: '!webkit' }`   | as Mocha    | `{ skip: condition }`, `{ todo: condition }`, `if (...) t.skip()`, `(condition ? it.skip : it)(...)`                                                                                              | `if (...) pending()`, `(condition ? xit : it)(...)`                                                                      |
+| tags such as `@new` (`// NEW:`)        | the title, `{ tag }`                                                                                                | the title                                                            | the title, `{ tags }`, where `'new'` and `'@new'` both mean `@new`                                                                                                                         | the title                                                                                                                                                                 | the title, `{ tags }` from @cypress/grep | the title   | the title                                                                                                                                                                                         | the title                                                                                                                |
 
 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, Mocha and `node:test`, `test.skip('title')` and `describe.skip('title')` with no body are skipped too.
+In Vitest, Mocha and `node:test`, `test.skip('title')` and `describe.skip('title')` with no body are skipped too,
+as is `xit('title')` in Jasmine.
 In Mocha, `this.skip()` counts in a test or hook written as a `function`; an arrow function gets no
 Mocha context, so its `this` is not the test's. `this.slow(ms)` only sets Mocha's speed threshold, so
 it isn't the `slow` state.
@@ -167,6 +172,10 @@ A test with no function, `test('title')`, passes in Node, so it isn't a todo. A
 `before` and `after` inside it, get the suite's context, which can't skip. Node reports a test in one
 state only, skip before todo before `expectFailure`, so `describe.skip('title', { todo: 'why' }, fn)`
 needs only a `// SKIP:` marker.
+In Jasmine, `pending()` and Jasmine 7's `notApplicable()` stop the running test, so they count in a test,
+`beforeEach` or `afterEach`; in `beforeAll`, `afterAll` or a describe's body Jasmine fails the suite
+instead, so they are left alone there. Like `t.skip('reason')`, `pending('reason')` takes a reason, not a
+condition. A function or variable of your own called `pending` is not Jasmine's.
 
 ## Rules
 
@@ -175,6 +184,7 @@ needs only a `// SKIP:` marker.
 💼 [Configurations](https://github.com/Huldoser/eslint-plugin-test-governance#usage) enabled in.\
 ⚠️ [Configurations](https://github.com/Huldoser/eslint-plugin-test-governance#usage) set to warn in.\
 🌲 Set in the `cypress` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
+🌼 Set in the `jasmine` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🃏 Set in the `jest` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 ☕ Set in the `mocha` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🟢 Set in the `node-test` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
@@ -184,13 +194,13 @@ needs only a `// SKIP:` marker.
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
-| Name                                                                   | Description                                                                       | 💼                   | ⚠️                   | 🔧  | 💡  |
-| :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------- | :------------------- | :------------------- | :-- | :-- |
-| [marker-matches-state](docs/rules/marker-matches-state.md)             | Require the marker keyword to match the test's state                              | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
-| [no-conflicting-states](docs/rules/no-conflicting-states.md)           | Disallow state tags that contradict each other, differ in case or look like typos |                      | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 | 🔧  |     |
-| [no-orphaned-marker](docs/rules/no-orphaned-marker.md)                 | Disallow marker comments that no longer match a test state                        | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
-| [require-ticket](docs/rules/require-ticket.md)                         | Require a ticket marker comment above skipped, fixme and tagged tests             | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
-| [require-ticket-in-comments](docs/rules/require-ticket-in-comments.md) | Require FIXME and TODO comments in test files to start with a ticket              | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
+| Name                                                                   | Description                                                                       | 💼                      | ⚠️                      | 🔧  | 💡  |
+| :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------- | :---------------------- | :---------------------- | :-- | :-- |
+| [marker-matches-state](docs/rules/marker-matches-state.md)             | Require the marker keyword to match the test's state                              | 🌲 🌼 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                         |     | 💡  |
+| [no-conflicting-states](docs/rules/no-conflicting-states.md)           | Disallow state tags that contradict each other, differ in case or look like typos |                         | 🌲 🌼 🃏 ☕ 🟢 🎭 ⚡ 🤖 | 🔧  |     |
+| [no-orphaned-marker](docs/rules/no-orphaned-marker.md)                 | Disallow marker comments that no longer match a test state                        | 🌲 🌼 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                         |     | 💡  |
+| [require-ticket](docs/rules/require-ticket.md)                         | Require a ticket marker comment above skipped, fixme and tagged tests             | 🌲 🌼 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                         |     | 💡  |
+| [require-ticket-in-comments](docs/rules/require-ticket-in-comments.md) | Require FIXME and TODO comments in test files to start with a ticket              | 🌲 🌼 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                         |     | 💡  |
 
 <!-- end auto-generated rules list -->
 
@@ -232,7 +242,7 @@ and markers. To turn a rule off, set it to `'off'` as usual.
 | `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.                                                                                                                                                                                                                                                                                                                                                                |
-| `testFunctions`               | `string[]`                                                                    | `['test']`                        | Names treated as the framework's `test`. Jest and Vitest default to `['test', 'it']`, and Mocha, Cypress and WebdriverIO to `['it', 'specify', 'test']`. Your list replaces the default one, so include those names if you still need them. See below.                                                                                                                                                                                                                                                                                       |
+| `testFunctions`               | `string[]`                                                                    | `['test']`                        | Names treated as the framework's `test`. Jest and Vitest default to `['test', 'it']`, Mocha, Cypress and WebdriverIO to `['it', 'specify', 'test']`, and Jasmine to `['it']`. Your list replaces the default one, so include those names if you still need them. See below.                                                                                                                                                                                                                                                                  |
 | `reportUnreadableTags`        | `boolean`                                                                     | `false`                           | When a tag state is on, report titles that aren't static text, and tags or details that can't be read in the file, such as ones imported from another module, since their tags can't be checked.                                                                                                                                                                                                                                                                                                                                             |
 
 ### Tag names
@@ -337,8 +347,17 @@ In `node:test` files:
 - Subtests: `t.test(...)` on the context a test's body receives.
 - Any name in `testFunctions`, which defaults to `['test', 'it']`. `node:test` has no globals.
 
+In Jasmine files:
+
+- The globals `it`, `xit`, `fit`, `describe`, `xdescribe`, `fdescribe`, and the hooks `beforeEach`,
+  `afterEach`, `beforeAll` and `afterAll`. With the runner's `globals: false`, Jasmine 7 takes the same
+  names from `jasmine-core`, so names imported or required from it count too, including aliases and
+  the whole module, as `core.xit` after `const core = require('jasmine-core')`.
+- `pending()` and `notApplicable()`, as globals or imported by name.
+- Any name in `testFunctions`, which defaults to `['it']`. Jasmine has no `test`.
+
 A name imported or required from another test runner (Playwright, `vitest`, `@jest/globals`,
-`node:test`, `bun:test`, `mocha`, `ava`, `tap`, `uvu`), or a variable set from one such as
+`node:test`, `jasmine-core`, `bun:test`, `mocha`, `ava`, `tap`, `uvu`), or a variable set from one such as
 `const test = require('ava')`, is never treated as the framework's `test`, and neither is a local
 variable or function declared inside a function that happens to be called `test`.
 
@@ -366,8 +385,9 @@ Not covered in this version: tests generated in loops with dynamic titles, and t
 from other modules (see `reportUnreadableTags`), fixtures imported from other modules under a name not in
 `testFunctions`, a Vitest test with only a title, which Vitest runs as a todo but which looks the same as a
 helper called `test`, Playwright annotations as markers, Cypress tests skipped with @cypress/skip-test's
-`skipOn()` and `onlyOn()`, `node:test`'s experimental `tags` option and `getTestContext()`, and other
-runners such as Jasmine and Bun.
+`skipOn()` and `onlyOn()`, `node:test`'s experimental `tags` option and `getTestContext()`, Jasmine's
+`pending()` in a helper function that tests call, Jasmine 5 and 6's `require('jasmine-core').noGlobals()`,
+and other runners such as Bun.
 
 ## TypeScript
 

package/dist/index.d.ts

@@ -33,5 +33,5 @@ declare const plugin: TestGovernancePlugin;
  * so all rules read the same ticket formats and states.
  */
 export declare function configure(options: GovernanceOptions): FlatConfig;
-export declare const configs: Record<"playwright" | "jest" | "vitest" | "mocha" | "cypress" | "webdriverio" | "node-test", FlatConfig>;
+export declare const configs: Record<"playwright" | "jest" | "vitest" | "mocha" | "cypress" | "webdriverio" | "node-test" | "jasmine", FlatConfig>;
 export default plugin;

package/dist/index.js

@@ -52,7 +52,7 @@ for (const framework of FRAMEWORK_NAMES) {
 // tools that list the configs don't see it.
 Object.defineProperty(plugin.configs, 'recommended', {
     get() {
-        throw new ConfigError("configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md");
+        throw new ConfigError("configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio, configs['node-test'] or configs.jasmine. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md");
     },
 });
 export const configs = plugin.configs;

package/dist/utils/analyze.d.ts

@@ -73,6 +73,8 @@ export interface Subject {
     ownSkip: boolean;
     markers: Marker[];
     dynamicTitle: boolean;
+    /** For a runtime function such as Jasmine's `pending()`, its name; messages call the others by their state. */
+    functionName?: string;
 }
 export interface Analysis {
     subjects: Subject[];

package/dist/utils/analyze.js

@@ -82,6 +82,7 @@ function collectTestNames(program, framework, configured) {
     const roots = new Map(framework.globals);
     for (const name of configured)
         roots.set(name, TEST);
+    const runtime = new Map();
     const modules = new Set();
     const mergeTests = new Set();
     /** Names bound to another test runner, such as `ava` in `import ava from 'ava'`. */
@@ -123,6 +124,12 @@ function collectTestNames(program, framework, configured) {
         roots.delete(name);
         others.add(name);
     };
+    /** Takes `name` for the runtime function `imported`, as in `const { pending: pend } = require('jasmine-core')`. */
+    const bindRuntime = (name, imported) => {
+        const modifier = imported === undefined ? undefined : framework.runtimeFunctions.get(imported);
+        if (imported !== undefined && modifier !== undefined)
+            runtime.set(name, { name: imported, modifier });
+    };
     for (const statement of program.body) {
         if (statement.type === 'ImportDeclaration') {
             const source = statement.source.value;
@@ -144,6 +151,7 @@ function collectTestNames(program, framework, configured) {
                     }
                     else {
                         const root = framework.exports.get(importedName(spec));
+                        bindRuntime(local, importedName(spec));
                         if (root)
                             roots.set(local, root);
                         else if (importedName(spec) === 'mergeTests')
@@ -200,6 +208,7 @@ function collectTestNames(program, framework, configured) {
                         setOther(prop.value.name);
                     else if (framework.ownsModule(source)) {
                         const root = framework.exports.get(propertyName(prop) ?? '');
+                        bindRuntime(prop.value.name, propertyName(prop));
                         if (root)
                             roots.set(prop.value.name, root);
                     }
@@ -207,7 +216,7 @@ function collectTestNames(program, framework, configured) {
             }
         }
     }
-    return { roots, modules };
+    return { roots, modules, runtime };
 }
 /** The name a property key spells out: `test` in `{ test }`, `{ 'test': t }` or `{ ['test']: t }`. */
 function propertyName(prop) {
@@ -225,6 +234,21 @@ function requireSource(node) {
     const first = node.arguments.at(0);
     return first?.type === 'Literal' && typeof first.value === 'string' ? first.value : undefined;
 }
+/**
+ * Where the file declares what `id` refers to: `inside` a function or block, a parameter included, at the
+ * `top` level, or nowhere, for a `global`.
+ */
+function declaredWhere(sourceCode, id) {
+    for (let scope = sourceCode.getScope(id); scope; scope = scope.upper) {
+        const variable = scope.set.get(id.name);
+        if (!variable)
+            continue;
+        if (scope.block.type !== 'Program')
+            return 'inside';
+        return variable.defs.length > 0 ? 'top' : 'global';
+    }
+    return 'global';
+}
 /**
  * Whether `id` refers to a variable or function declared inside a function or block, such as a local
  * helper that happens to be called `test`. Top-level variables, imports, parameters and globals still count.
@@ -816,14 +840,31 @@ function runAnalysis(sourceCode, options) {
         if (body?.type === 'FunctionExpression')
             thisBodies.add(body);
     };
-    /** What a body can change the test's state with: Playwright's `testInfo` or Vitest's test context. */
+    /**
+     * What a body can change the test's state with: Playwright's `testInfo`, Vitest's test context, or
+     * Jasmine's `pending()`.
+     */
     const bodyInfos = (args, path) => {
         const body = args.findLast(isFunction);
-        // `test.each(table)` passes the row to the body, and `test.for(cases)` passes it before the context.
-        if (!framework.info || !body || path.includes('each()'))
+        if (!body)
             return [];
+        const functions = [
+            ...[...framework.runtimeFunctions].map(([name, modifier]) => ({
+                name,
+                method: modifier,
+                runtimeFunction: { name, imported: false },
+            })),
+            ...[...testNames.runtime].map(([local, fn]) => ({
+                name: local,
+                method: fn.modifier,
+                runtimeFunction: { name: fn.name, imported: true },
+            })),
+        ];
+        // `test.each(table)` passes the row to the body, and `test.for(cases)` passes it before the context.
+        if (!framework.info || path.includes('each()'))
+            return functions;
         const param = body.params.at(framework.info.param + (path.includes('for()') ? 1 : 0));
-        return infoNames(param, framework.info.methods);
+        return [...functions, ...infoNames(param, framework.info.methods)];
     };
     /**
      * What a callee declares and with which members: `describe` and `['skip']` for `test.describe.skip`.
@@ -834,12 +875,16 @@ function runAnalysis(sourceCode, options) {
             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 };
+        const written = playwrightDescribe ? path.slice(1) : path;
+        return { kind, members: [...root.modifiers, ...written], written, args };
     };
-    /** Whether a call with these members and arguments declares a test or describe of this kind. */
-    const declares = ({ kind, members }, args) => {
+    /**
+     * Whether a call with these members and arguments declares a test or describe of this kind. Only the
+     * members written after the name must exist: Jasmine's `xit` skips, but it has no `it.skip`.
+     */
+    const declares = ({ kind, members, written }, args) => {
         const allowed = kind === 'test' ? framework.testMembers : framework.describeMembers;
-        return members.every((m) => allowed.has(m)) && isDeclaration(sourceCode, framework, kind, args, members);
+        return written.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
@@ -893,7 +938,7 @@ function runAnalysis(sourceCode, options) {
         const { object } = callee;
         if (object.type !== 'Identifier' || !infos.findLast((info) => info.name === object.name)?.methods)
             return undefined;
-        const declaration = { kind: 'test', members: [], args: new Map() };
+        const declaration = { kind: 'test', members: [], written: [], args: new Map() };
         return declares(declaration, call.arguments)
             ? declare(call, declaration, bodyInfos(call.arguments, []))
             : undefined;
@@ -938,7 +983,7 @@ function runAnalysis(sourceCode, options) {
     };
     /**
      * `testInfo.skip()`, `step.skip()`, `test.info().skip()`, Vitest's `context.skip()` or `skip()`,
-     * Mocha's `this.skip()`, and node:test's `t.skip()` and `t.todo()`.
+     * Mocha's `this.skip()`, node:test's `t.skip()` and `t.todo()`, and Jasmine's `pending()`.
      */
     const runtimeCall = (call) => {
         const { callee } = call;
@@ -946,7 +991,17 @@ function runAnalysis(sourceCode, options) {
         const innermost = (name) => infos.findLast((info) => info.name === name);
         if (callee.type === 'Identifier') {
             const info = innermost(callee.name);
-            return info?.method !== undefined ? runtimeSubject(call, info.method, info.step) : undefined;
+            if (info?.method === undefined)
+                return undefined;
+            // A global such as Jasmine's `pending` counts unless the file declares the name itself; an import of
+            // one counts unless a function or block declares the name again.
+            const fn = info.runtimeFunction;
+            if (fn && declaredWhere(sourceCode, callee) !== (fn.imported ? 'top' : 'global'))
+                return undefined;
+            const subject = runtimeSubject(call, info.method, info.step);
+            if (subject)
+                subject.functionName = fn?.name;
+            return subject;
         }
         if (callee.type !== 'MemberExpression')
             return undefined;
@@ -1105,6 +1160,6 @@ export function describeSubject(subject) {
     if (subject.kind === 'step')
         return 'This step';
     if (subject.kind === 'runtime')
-        return `This ${subject.states[0].state.modifier} call`;
+        return `This ${subject.functionName ?? subject.states[0].state.modifier} call`;
     return 'This test';
 }

package/dist/utils/constants.d.ts

@@ -8,7 +8,7 @@ export type BuiltinStateName = (typeof BUILTIN_STATE_NAMES)[number];
 export declare const TAG_STATE_NAMES: readonly ["new", "quarantined"];
 export type TagStateName = (typeof TAG_STATE_NAMES)[number];
 /** The test frameworks the rules understand. */
-export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test"];
+export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test", "jasmine"];
 export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];
 export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "numeric", "pattern"];
 /** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */

package/dist/utils/constants.js

@@ -14,6 +14,7 @@ export const FRAMEWORK_NAMES = [
     'cypress',
     'webdriverio',
     'node-test',
+    'jasmine',
 ];
 export const TICKET_PRESETS = [
     'any',

package/dist/utils/frameworks.d.ts

@@ -93,6 +93,11 @@ export interface Framework {
     thisMethods: ReadonlySet<string>;
     /** Whether a test with only a title written out is a todo, as Mocha's pending `it('title')`. */
     todoWithoutBody: boolean;
+    /**
+     * Functions, global or imported by name, that change the state of the test whose body calls them, or
+     * whose `beforeEach` or `afterEach` does, as Jasmine's `pending()`, with the state each puts it in.
+     */
+    runtimeFunctions: ReadonlyMap<string, Modifier>;
     /** Built-in states a test can be put in with this framework. */
     states: ReadonlySet<BuiltinStateName>;
     /** Playwright's own API on `test`: `test.describe`, `test.step`, `test.info()` and runtime `test.skip()`. */

package/dist/utils/frameworks.js

@@ -3,7 +3,17 @@ const DESCRIBE = { kind: 'describe', modifiers: [] };
 const HOOK = { kind: 'hook', modifiers: [] };
 const PLAYWRIGHT_MODULES = new Set(['@playwright/test', 'playwright/test']);
 /** Test runners besides Playwright. A name imported from one of them belongs to that runner. */
-const OTHER_RUNNERS = new Set(['vitest', '@jest/globals', 'node:test', 'bun:test', 'mocha', 'ava', 'tap', 'uvu']);
+const OTHER_RUNNERS = new Set([
+    'vitest',
+    '@jest/globals',
+    'node:test',
+    'jasmine-core',
+    'bun:test',
+    'mocha',
+    'ava',
+    'tap',
+    'uvu',
+]);
 /** `@playwright/test` and the component-testing packages such as `@playwright/experimental-ct-react`. */
 function isPlaywrightModule(source) {
     return PLAYWRIGHT_MODULES.has(source) || source.startsWith('@playwright/experimental-ct-');
@@ -39,6 +49,7 @@ const playwright = {
     skipNotes: false,
     thisMethods: new Set(),
     todoWithoutBody: false,
+    runtimeFunctions: new Map(),
     states: new Set(['skip', 'fixme', 'fail', 'slow', 'new', 'quarantined']),
     playwright: true,
 };
@@ -77,6 +88,7 @@ const jest = {
     skipNotes: false,
     thisMethods: new Set(),
     todoWithoutBody: false,
+    runtimeFunctions: new Map(),
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
 };
@@ -124,6 +136,7 @@ const vitest = {
     skipNotes: true,
     thisMethods: new Set(),
     todoWithoutBody: false,
+    runtimeFunctions: new Map(),
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
 };
@@ -168,6 +181,7 @@ const mocha = {
     skipNotes: false,
     thisMethods: new Set(['skip']),
     todoWithoutBody: true,
+    runtimeFunctions: new Map(),
     states: new Set(['skip', 'todo', 'new', 'quarantined']),
     playwright: false,
 };
@@ -222,9 +236,57 @@ const nodeTest = {
     skipNotes: true,
     thisMethods: NODE_TEST_CONTEXT,
     todoWithoutBody: false,
+    runtimeFunctions: new Map(),
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
 };
+const JASMINE_FUNCTIONS = new Map([
+    ['it', TEST],
+    ['xit', SKIPPED_TEST],
+    ['fit', { kind: 'test', modifiers: ['only'] }],
+    ['describe', DESCRIBE],
+    ['xdescribe', SKIPPED_DESCRIBE],
+    ['fdescribe', { kind: 'describe', modifiers: ['only'] }],
+    ['beforeEach', HOOK],
+    ['afterEach', HOOK],
+    // A `pending()` in `beforeAll` or `afterAll` fails the suite instead of skipping its tests.
+    ['beforeAll', { kind: 'hook', modifiers: [], noContext: true }],
+    ['afterAll', { kind: 'hook', modifiers: [], noContext: true }],
+]);
+/**
+ * Jasmine, run on its own, on Karma or by WebdriverIO's Jasmine framework. Its functions are globals, or
+ * with `globals: false` in Jasmine 7 exports of `jasmine-core`, and have no members: the `x` and `f` forms
+ * are functions of their own. `pending()` and Jasmine 7's `notApplicable()` skip the running test.
+ */
+const jasmine = {
+    name: 'jasmine',
+    ownsModule: (source) => source === 'jasmine-core',
+    exports: JASMINE_FUNCTIONS,
+    moduleIsDefault: true,
+    globals: new Map([...JASMINE_FUNCTIONS].filter(([name]) => name !== 'it')),
+    testFunctions: ['it'],
+    testMembers: new Set(),
+    describeMembers: new Set(),
+    factories: new Set(),
+    effects: effects([['skip', 'skip']]),
+    optionEffects: new Map(),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
+    plainTags: false,
+    subtests: false,
+    skipWithoutBody: true,
+    // `pending('why')` takes a reason, not a condition.
+    skipNotes: true,
+    thisMethods: new Set(),
+    todoWithoutBody: true,
+    runtimeFunctions: new Map([
+        ['pending', 'skip'],
+        ['notApplicable', 'skip'],
+    ]),
+    states: new Set(['skip', 'todo', 'new', 'quarantined']),
+    playwright: false,
+};
 export const FRAMEWORKS = {
     playwright,
     jest,
@@ -233,6 +295,7 @@ export const FRAMEWORKS = {
     cypress: { name: 'cypress', ...mocha },
     webdriverio: { name: 'webdriverio', ...mocha },
     'node-test': nodeTest,
+    jasmine,
 };
 /** Whether `source` belongs to a test runner other than `framework`, so its names are never tests here. */
 export function isOtherRunner(framework, source) {

package/dist/utils/options.d.ts

@@ -21,7 +21,7 @@ export interface CustomState {
 export interface GovernanceOptions {
     /**
      * The test framework of the files the config applies to: `'playwright'`, `'jest'`, `'vitest'`, `'mocha'`,
-     * `'cypress'`, `'webdriverio'` or `'node-test'`. Required; each framework's config, such as `configs.mocha`, sets it.
+     * `'cypress'`, `'webdriverio'`, `'node-test'` or `'jasmine'`. Required; each framework's config, such as `configs.mocha`, sets it.
      */
     framework: FrameworkName;
     /**

package/docs/rules/marker-matches-state.md

@@ -2,7 +2,7 @@
 
 📝 Require the marker keyword to match the test's state.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🌼 `jasmine`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 

package/docs/rules/no-conflicting-states.md

@@ -2,7 +2,7 @@
 
 📝 Disallow state tags that contradict each other, differ in case or look like typos.
 
-⚠️ This rule _warns_ in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+⚠️ This rule _warns_ in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🌼 `jasmine`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
 

package/docs/rules/no-orphaned-marker.md

@@ -2,7 +2,7 @@
 
 📝 Disallow marker comments that no longer match a test state.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🌼 `jasmine`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 

package/docs/rules/require-ticket-in-comments.md

@@ -2,7 +2,7 @@
 
 📝 Require FIXME and TODO comments in test files to start with a ticket.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🌼 `jasmine`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 

package/docs/rules/require-ticket.md

@@ -2,7 +2,7 @@
 
 📝 Require a ticket marker comment above skipped, fixme and tagged tests.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🌼 `jasmine`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
@@ -17,7 +17,7 @@ A test is in a state when it is:
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | -------------------------- |
 | `skip`         | `test.skip('title', fn)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` in a step | `// SKIP:`             | yes                        |
 | `fixme`        | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                                          | `// FIXME:`            | yes                        |
-| `todo`         | Jest's, Vitest's and `node:test`'s `test.todo`, and a Mocha test with only a title, `it('title')`                                     | `// TODO:`             | yes, except in Playwright  |
+| `todo`         | Jest's, Vitest's and `node:test`'s `test.todo`, and a Mocha or Jasmine test with only a title, `it('title')`                          | `// TODO:`             | yes, except in Playwright  |
 | `new`          | the `@new` tag                                                                                                                        | `// NEW:`              | with `lifecycleTags: true` |
 | `quarantined`  | the `@quarantined` tag                                                                                                                | `// QUARANTINED:`      | with `lifecycleTags: true` |
 | `fail`, `slow` | `test.fail(...)`, `test.slow()`, `testInfo.fail()`, `testInfo.slow()`                                                                 | `// FAIL:`, `// SLOW:` | no                         |
@@ -27,7 +27,8 @@ In Jest and Vitest, `xit`, `xdescribe`, Vitest's `{ skip: true }`, `skipIf(true)
 `context.skip('note')`, in a test or in `beforeEach`, skip a test too, and `test.failing` and `test.fails` put it in the `fail` state. In Mocha, Cypress and WebdriverIO, `xit`, `xdescribe` and
 `this.skip()` in a test or hook skip a test too, and Cypress's `{ browser: '!webkit' }` skips it in other
 browsers, which counts as a conditional skip. In `node:test`, `{ skip: 'reason' }`, `t.skip()` and `this.skip()` skip a test, `{ todo: true }`,
-`t.todo()` and `this.todo()` make it a todo, `t.test()` subtests count as tests, and `test.expectFailure` puts it in the `fail` state. The
+`t.todo()` and `this.todo()` make it a todo, `t.test()` subtests count as tests, and `test.expectFailure` puts it in the `fail` state. In
+Jasmine, `xit`, `xdescribe`, and `pending()` or `notApplicable()` in a test, `beforeEach` or `afterEach` skip a test. The
 [README](../../README.md#frameworks) lists every form.
 
 Tags are read from the title (`'places a limit order @new'`) and from `{ tag: '@new' }` or `{ tag: ['@new', '@smoke'] }`,
@@ -213,6 +214,14 @@ import { test } from 'node:test';
 test('liquidates below maintenance', { skip: 'broker sandbox is down' }, () => {});
 ```
 
+<!-- example: invalid settings={"framework":"jasmine"} -->
+
+```js
+it('streams level 2 quotes', () => {
+  pending('needs the market data feed');
+});
+```
+
 <!-- example: invalid settings={"framework":"cypress","lifecycleTags":true} -->
 
 ```js
@@ -299,6 +308,19 @@ test('nets margin across accounts', (t) => {
 });
 ```
 
+<!-- example: valid settings={"framework":"jasmine"} -->
+
+```js
+describe('order entry', () => {
+  // SKIP: TRADE-93
+  xit('routes an order to the dark pool', () => {});
+
+  it('prints the trade confirmation', () => {
+    if (isNode) pending('needs a browser');
+  });
+});
+```
+
 ## Options
 
 This rule has no options of its own. It reads the shared options described in the

package/docs/upgrading.md

@@ -90,7 +90,7 @@ becomes `extends: ['test-governance/playwright']`.
 A config that still reads `configs.recommended` fails when it loads:
 
 ```text
-eslint-plugin-test-governance: configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md
+eslint-plugin-test-governance: configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio, configs['node-test'] or configs.jasmine. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md
 ```
 
 ### The framework option
@@ -121,7 +121,7 @@ Without it, the config fails when it loads:
 
 ```text
 eslint-plugin-test-governance: invalid options:
-  - framework is required: set it to "playwright", "jest", "vitest", "mocha", "cypress", "webdriverio" or "node-test", or use configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']
+  - framework is required: set it to "playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test" or "jasmine", or use configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio, configs['node-test'] or configs.jasmine
 ```
 
 If you write `settings['test-governance']` yourself instead of calling `configure()`, add `framework`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.8.1",
-  "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO and node:test tests.",
+  "version": "0.9.0",
+  "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, node:test and Jasmine tests.",
   "keywords": [
     "eslint",
     "eslintplugin",
@@ -13,6 +13,7 @@
     "cypress",
     "webdriverio",
     "node-test",
+    "jasmine",
     "testing"
   ],
   "homepage": "https://github.com/Huldoser/eslint-plugin-test-governance#readme",