vitest-auto-spy 5.47.0 → 5.49.0

package/AGENTS.md

@@ -534,7 +534,7 @@ In [`agent-docs/adapters.md`](./agent-docs/adapters.md). Read it for NestJS, Vue
 
 ## 16. ESLint plugin (flat config only)
 
-In [`agent-docs/eslint.md`](./agent-docs/eslint.md). Read it when configuring `vitest-auto-spy/eslint-plugin` or fixing one of its reports.
+In [`agent-docs/eslint.md`](./agent-docs/eslint.md). Read it when configuring `vitest-auto-spy/eslint-plugin` or fixing one of its reports. For `vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers` into `allowedFunctionCalls` rather than keeping the names by hand.
 
 <!-- agents-outline: agent-docs/eslint.md -->
 <!-- /agents-outline -->

package/CHANGELOG.md

@@ -10,6 +10,53 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.49.0] - 2026-09-28
+
+### Added
+
+- **`no-real-component-provider`** in `vitest-auto-spy/eslint-plugin`, `error` in `recommended`:
+  `fixture.debugElement.injector.get(X)` / `fixture.componentRef.injector.get(X)` for a token nothing
+  in the file replaced with a double. That read is how a spec reaches a component-level provider, and
+  when nothing swapped it the fixture hands back the production class — the component spec then
+  drives the real store through HTTP and repeats the store's own spec. The message names the repair,
+  `overrideComponentProvider(Component, X)`. Tokens from `@angular/*`, classes the file renders
+  (`createComponent`, `imports`, `declarations`, `hostDirectives`), reads wrapped in `asSpy(…)` and
+  files that call `createWithAutoSpies` are left alone; `{ ignoreTokens }` keeps an intended
+  integration test real. Only the fixture's own injector is read, never a child's. Measured on three
+  consumers, 1078 spec files: 5 reports, all of them real. The plugin now ships fifty-one rules.
+  `vitest-auto-spy/eslint-plugin` is +0.78 kB min+gzip (+1.8 %) for the rule module and its
+  messages; no module is added to the entry's graph.
+
+## [5.48.0] - 2026-09-28
+
+### Added
+
+- **`hookRegisteringHelpers` on `vitest-auto-spy/eslint-plugin`** — the frozen list of the
+  library's public helpers that register `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when
+  called (`useConsoleSpies`, `setupAutoSpy`, `setupFakeTimers`, `useCountingClock`, `mockNow`, the
+  `guard*` family, …), for `vitest/require-hook`'s `allowedFunctionCalls`:
+  `allowedFunctionCalls: [...autoSpy.hookRegisteringHelpers]`. A bare `useConsoleSpies();` in a
+  `describe` body no longer needs a hand-kept list; a spec walks the call graph of every public entry
+  and fails when a hook-registering export is missing from it. It is a property of the plugin
+  object, so `require()` and `import` both reach it. `vitest-auto-spy/eslint-plugin` is +0.42 kB
+  min+gzip (+1.0 %) for the list and the two rule changes.
+- **`prefer-to-have-signal-value`** also reports `expect(sig()).toBeNull()` and `.toBeUndefined()`
+  on a signal read, `.not` included, and fixes them to `toHaveSignalValue(null)` /
+  `toHaveSignalValue(undefined)`.
+
+### Fixed
+
+- **`prefer-to-have-signal-value`** no longer rewrites an identity check. `expect(list.items()).toBe(items)`
+  asserts the signal holds that very array, and the fix turned it into `toHaveSignalValue(items)`,
+  which compares deeply and passes for any equal copy. A `toBe` is now reported only when the
+  expected value is a primitive literal or the signal's type is primitive (`any` does not count);
+  `toEqual` and `toStrictEqual` are unchanged.
+- **Docs**: `vitest-auto-spy/console` imports `vitest` itself (the fallback adapter and the
+  `useConsoleSpies()` hooks), so on `node:test` and Rstest it loads only where the `vitest` package
+  resolves; the console page, the README and `agent-docs/adapters.md` now say so. The README API
+  table and `agent-docs/angular.md` list `registerSignalMatchers({ strict })`, and the types list of
+  `/angular/matchers` names `RegisterSignalMatchersOptions`.
+
 ## [5.47.0] - 2026-09-28
 
 ### Added
@@ -6046,7 +6093,9 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.47.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.49.0...HEAD
+[5.49.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.48.0...v5.49.0
+[5.48.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.47.0...v5.48.0
 [5.47.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.46.0...v5.47.0
 [5.46.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.45.0...v5.46.0
 [5.45.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.44.0...v5.45.0

package/README.md

@@ -81,7 +81,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored; `moduleNamespace(await importOriginal(), { passthrough: true })` is Vitest's `{ spy: true }` with `calledWith` on top, on any runner
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`, and `outOfType()` for the fixture that is outside its type on purpose
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — fifty rules in `vitest-auto-spy/eslint-plugin` (eight `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
+- 📏 Lint rules and one-line test-run hygiene — fifty-one rules in `vitest-auto-spy/eslint-plugin` (eight `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-init-and-ng-test) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
@@ -890,7 +890,9 @@ it('reports a failed load', () => {
 `useConsoleSpies()` registers `beforeEach(installConsoleSpies)` and `afterEach(restoreConsole)` in
 the enclosing `describe` (or the file) and returns the spies, which are the same objects in every
 test. It registers Vitest hooks, which Bun resolves to its own; on `node:test` and Rstest write that
-pair in the runner's hooks yourself. Do not
+pair in the runner's hooks yourself — the entry imports `vitest` itself, so there it loads only where
+the `vitest` package resolves. Under `vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers`
+from `vitest-auto-spy/eslint-plugin` into its `allowedFunctionCalls`. Do not
 rely on the **import** to install them: it does so once per worker, so under `isolate: false` the
 spies go on in whichever file imported them first and silence every later file of the worker — on a
 1759-file Angular consumer, 32 of the 39 files importing the entry relied on that, and three files
@@ -2953,7 +2955,8 @@ expect(component.draft).toHaveSignalValue({}, { strict: false });
 ```
 
 The `prefer-to-have-signal-value` lint rule rewrites the inline spellings — `expect(component.total()).toBe(3)`
-— into the matcher with a `--fix`.
+— into the matcher with a `--fix`. A `toBe` against an object-typed signal checks identity, which the
+deep matcher cannot keep, so the rule leaves it alone.
 
 #### Where a spec spends its time
 
@@ -4016,8 +4019,9 @@ export can never be.
 | `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `no-real-component-provider`      |   `error`   | —                 | `fixture.debugElement.injector.get(X)` for a component-level provider nothing in the file replaced → the real store under a component spec; `overrideComponentProvider(Cmp, X)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `prefer-to-have-signal-value`     |   `warn`    | `--fix`           | `expect(signal()).toBe(…)` → `expect(signal).toHaveSignalValue(…)`; the matcher names the signal in the failure and refuses a non-signal. `toStrictEqual` keeps `{ strict: true }`. **Type-aware** — the callee must be callable and carry Angular's signal brand — and silent without `parserOptions.project`; safe to autofix since 5.46.0 fixed the `Set`/`Map` comparison                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `prefer-to-have-signal-value`     |   `warn`    | `--fix`           | `expect(signal()).toBe(…)` → `expect(signal).toHaveSignalValue(…)`; the matcher names the signal in the failure and refuses a non-signal. `toStrictEqual` keeps `{ strict: true }`, `toBeNull()` / `toBeUndefined()` become `toHaveSignalValue(null)` / `(undefined)`. **Type-aware** — the callee must be callable and carry Angular's signal brand — and silent without `parserOptions.project`; safe to autofix since 5.46.0 fixed the `Set`/`Map` comparison. A `toBe` against an object-typed signal is an identity check and is left alone                                                                                                                                                                                                                                                                                                                  |
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer that with `NG0101`                                                                                                                                                                                                                                                                                                                                                  |
 | `prefer-spy-on-own-method`        |   `warn`    | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double                                                                                                                                                                                                                                                                        |
 | `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
@@ -4051,7 +4055,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Eight of the fifty fix on their own, nineteen offer suggestions**, and the split is not about how hard
+**Eight of the fifty-one fix on their own, nineteen offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -4128,6 +4132,16 @@ a spread, an unknown provider factory, `createWithAutoSpies`, `renderShallow` or
 `TestBed.overrideProvider` silences the file. A token handed a plain `useValue` is left to
 `prefer-provide-auto-spy` — two rules on one line only teach people to disable both.
 
+`no-real-component-provider` catches `fixture.debugElement.injector.get(X)` — or
+`fixture.componentRef.injector.get(X)` — for a token nothing in the file replaced with a double.
+`injectSpy` cannot reach a provider the component declares itself, so a spec that wants that store
+reads it through the fixture, and when nothing swapped it the fixture hands back the production
+class: the component spec drives the real store through HTTP and repeats the store's own spec. The
+message names the repair, [`overrideComponentProvider(Cmp, X)`](#a-provider-the-component-declares-for-itself). Tokens
+from `@angular/*`, classes the file renders, reads wrapped in `asSpy(…)` and files that call
+`createWithAutoSpies` are left alone, and `{ ignoreTokens }` keeps an intended integration test real.
+On three consumers, 1078 spec files, it reports 5, every one of them real.
+
 `no-ts-expect-error-on-double` reports `@ts-expect-error` / `@ts-ignore` above a double's
 configuration whatever reason follows the directive. On one 1759-file suite it reports 34, every one
 with a reason: four on overloaded clients ([the recipe](#how-to-mock-an-overloaded-method)), twenty-six
@@ -4222,7 +4236,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the fifty rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the fifty-one rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -4239,7 +4253,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of fifty rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of fifty-one rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -4360,7 +4374,7 @@ another, and the next one is in that same file.
 | `collectRouterEvents(events)` _(`/angular-router`)_                                                                                         | The double's router events as one comparable value — `expect([[NavigationStart, '/checkout'], …])`, a class-and-URL pair per event                                                                                                                                                                                       |
 | `provideLocationDouble()` / `injectLocationDouble(injector?)` / `createLocationDouble()` _(`/angular-router`)_                              | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` for the popstate no method call can cause                                                                                                                                              |
 | `createForm(model, schema?, options?)` / `registerFormMatchers()` _(`/signal-forms`)_                                                       | Angular's own signal `form()`, built in the `TestBed`'s injection context, and the `toHaveFieldErrors` matcher over its `errors()`                                                                                                                                                                                       |
-| `registerSignalMatchers()` _(Angular)_                                                                                                      | Adds `expect(sig).toHaveSignalValue(value)`                                                                                                                                                                                                                                                                              |
+| `registerSignalMatchers(opts?)` _(Angular)_                                                                                                 | Adds `expect(sig).toHaveSignalValue(value)`; `{ strict: true }` compares every assertion like `toStrictEqual`                                                                                                                                                                                                            |
 | `trackRecomputations(signal)` / `trackEffectRuns(effectRef)` _(Angular)_                                                                    | Count what the reactive graph re-ran — `{ count, stop() }`, undone by `restoreMockedProps()`                                                                                                                                                                                                                             |
 | `provideWindowDouble(token, overrides?)` / `provideDocumentDouble(overrides?)` _(Angular)_                                                  | A `window` / `document` merged over the real jsdom one; `createWindowDouble` / `createDocumentDouble` outside DI                                                                                                                                                                                                         |
 | `provideMatDialogData(token, data)` / `provideMatDialogRef(Ref, init?)` / `injectMatDialogRef(Ref)` _(Angular)_                             | The Material dialog trio — the token and the ref class are arguments; `createMatDialogRef` builds the ref outside DI                                                                                                                                                                                                     |

package/agent-docs/adapters.md

@@ -39,7 +39,9 @@ expect(consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced,
 ```
 
 It registers Vitest hooks (Bun resolves them to its own); on `node:test` and Rstest write
-`installConsoleSpies()` in a `beforeEach` and `restoreConsole()` in an `afterEach` yourself.
+`installConsoleSpies()` in a `beforeEach` and `restoreConsole()` in an `afterEach` yourself. The entry
+imports `vitest` itself, so there it loads only where the `vitest` package resolves. Under
+`vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers` into `allowedFunctionCalls` (§16).
 
 The exported `consoleInfoSpy` & co. are the same objects; `restoreConsole()` keeps them and clears
 their calls. **Do not rely on the import to install them**: it does so once per worker, so under

package/agent-docs/angular.md

@@ -1063,8 +1063,8 @@ service.products.set([edited]); // the component's own optimistic write — stat
 expect(products.reload).toHaveBeenCalled(); // reload is spied, answers true, and re-issues nothing
 
 // signal assertions
-registerSignalMatchers(); // once, in the setup file — /angular/matchers
-expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's
+registerSignalMatchers(); // once, in the setup file — /angular/matchers; ({ strict: true }) makes the whole suite strict
+expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's, { strict: false } opts out
 
 // resource assertions — value AND status, which is the whole point
 registerResourceMatchers(); // once, in the setup file — /angular/matchers

package/agent-docs/eslint.md

@@ -32,6 +32,25 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 `autoSpy.configs.strict` is `recommended` with every rule at `error`, instead of mapping
 `Object.keys(autoSpy.rules)` by hand.
 
+`@vitest/eslint-plugin`'s `vitest/require-hook` reports a bare `useConsoleSpies();` or
+`setupFakeTimers();` in a `describe` body, since it cannot know the call registers hooks.
+`autoSpy.hookRegisteringHelpers` is the library's list of such helpers — every public function that
+calls `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when it runs, kept in step with the
+source by a spec — so spread it instead of maintaining the names by hand. Calls that register no
+hook (`registerSignalMatchers()`, `trackStrayTimers()`) are not in it; add them yourself where a
+linted file calls them at the top level.
+
+```js
+export default [
+  {
+    files: ['**/*.spec.ts'],
+    rules: {
+      'vitest/require-hook': ['error', { allowedFunctionCalls: [...autoSpy.hookRegisteringHelpers] }],
+    },
+  },
+];
+```
+
 | Rule | Level | Fix | Flags |
 | --- | --- | --- | --- |
 | `no-expect-in-subscribe` | `error` | suggest | `expect()` inside `subscribe()` → `expectEmission` / `firstValueFrom` |
@@ -54,9 +73,10 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-dead-schemas` | `error` | — | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it |
 | `no-import-time-spread` | `error` | suggest | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads |
 | `no-unregistered-inject-spy` | `error` | — | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler |
+| `no-real-component-provider` | `error` | — | `fixture.debugElement.injector.get(X)` for a component-level provider nothing in the file replaced → the real store under a component spec; `overrideComponentProvider(Cmp, X)`; `{ ignoreTokens }` for an intended integration test |
 | `prefer-render-shallow` | `warn` | suggest | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children |
 | `prefer-set-inputs` | `warn` | suggest | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101` |
-| `prefer-to-have-signal-value` | `warn` | `--fix` | `expect(component.total()).toBe(3)` / `toEqual(…)` → `expect(component.total).toHaveSignalValue(3)`, `toStrictEqual` → `{ strict: true }`; the matcher names the signal in the failure and refuses a value that is not one. **Type-aware**: the signal is recognised by Angular's brand on its type, so methods, functions and getters are never reported, and without `parserOptions.project` it reports nothing |
+| `prefer-to-have-signal-value` | `warn` | `--fix` | `expect(component.total()).toBe(3)` / `toEqual(…)` → `expect(component.total).toHaveSignalValue(3)`, `toStrictEqual` → `{ strict: true }`, `toBeNull()` / `toBeUndefined()` → `toHaveSignalValue(null)` / `(undefined)`; the matcher names the signal in the failure and refuses a value that is not one. **Type-aware**: the signal is recognised by Angular's brand on its type, so methods, functions and getters are never reported, and without `parserOptions.project` it reports nothing. A `toBe` against an object-typed signal (`expect(list.items()).toBe(items)`) is an identity check the deep matcher would lose, so it is reported only when the expected value is a primitive literal or the signal's type is primitive |
 | `prefer-spy-on-own-method` | `warn` | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double |
 | `prefer-observer-stub` | `error` | — | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo |
 | `no-hand-assigned-global` | `error` | `--fix` | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages, `stubWorker({ respond })` for `Worker`; the three observers stay with `prefer-observer-stub`; any value written into an imported object (`environment.production = true`) → `mockValueProp(environment, 'production', true)`, fixed in a test or `beforeEach` |
@@ -85,9 +105,9 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-save-arguments-by-value` | `error` | — | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state |
 | `prefer-native-spy-api` | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim |
 
-Fifty rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+Fifty-one rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
-`prefer-set-inputs`, `no-unasserted-argument`, `prefer-spy-on-own-method` and `prefer-to-have-signal-value`**; eight fix on their own, nineteen offer suggestions. Forty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
+`prefer-set-inputs`, `no-unasserted-argument`, `prefer-spy-on-own-method` and `prefer-to-have-signal-value`**; eight fix on their own, nineteen offer suggestions. Forty-seven are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
 `no-unknown-use-value-key` and `prefer-to-have-signal-value` read types, and all four report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the

package/dist/cli.js

@@ -3865,7 +3865,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.46.0";
+var EXPORT_MAP_VERSION = "5.48.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",

package/dist/eslint-plugin.cjs

@@ -3,6 +3,25 @@
 var node_fs = require('node:fs');
 var node_path = require('node:path');
 
+// src/lib/eslint/hook-registering-helpers.ts
+var hookRegisteringHelpers = Object.freeze([
+  "enableAngularDiagnostics",
+  "enableTestBedDiagnostics",
+  "guardDocumentPollution",
+  "guardGlobalPatches",
+  "guardPrototypePollution",
+  "guardStrayConsole",
+  "installPerTest",
+  "mockNow",
+  "setupAngularTestEnv",
+  "setupAutoSpy",
+  "setupFakeTimers",
+  "trackMockRegistry",
+  "trackNodeMocks",
+  "useConsoleSpies",
+  "useCountingClock"
+]);
+
 // src/lib/eslint/rule-types.ts
 function isCast(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
@@ -4138,11 +4157,15 @@ var preferRenderShallow = defineRule({
 
 // src/lib/eslint/prefer-to-have-signal-value.ts
 var MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var VALUE_MATCHERS = /* @__PURE__ */ new Map([
+  ["toBeNull", "null"],
+  ["toBeUndefined", "undefined"]
+]);
 var SIGNAL_BRAND = "\u0275SIGNAL";
 var SIGNAL_BRAND_PROPERTY = /^__@(?:SIGNAL|ɵSIGNAL|ɵWRITABLE_SIGNAL)@\d+$/;
 function signalAssertionOf(node) {
   const callee = node.callee;
-  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !MATCHERS.has(callee.property.name)) {
+  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !(MATCHERS.has(callee.property.name) || VALUE_MATCHERS.has(callee.property.name))) {
     return void 0;
   }
   let expected = callee.object;
@@ -4164,9 +4187,37 @@ function readsSignal(context, node) {
   const signatures = type.getCallSignatures();
   return type.getProperties().some((property) => property.getName() === SIGNAL_BRAND || SIGNAL_BRAND_PROPERTY.test(property.getName())) && signatures.length > 0;
 }
+function isPrimitiveLiteral(node) {
+  if (node === void 0) {
+    return false;
+  }
+  switch (node.type) {
+    case "Literal":
+      return Reflect.get(node, "regex") === void 0;
+    case "Identifier":
+      return isIdentifier(node) && node.name === "undefined";
+    case "UnaryExpression":
+      return isPrimitiveLiteral(Reflect.get(node, "argument"));
+    case "TemplateLiteral":
+      return Reflect.get(node, "expressions")?.length === 0;
+    default:
+      return false;
+  }
+}
+function primitiveValue({ checker, toTs }, received) {
+  const value = checker.getTypeAtLocation(toTs.get(received));
+  return checker.typeToString(value) !== "any" && isPrimitiveLike(checker, value);
+}
+function identityIsMoot(context, node, shape) {
+  if (shape.matcher.name !== "toBe" || isPrimitiveLiteral(node.arguments.at(0))) {
+    return true;
+  }
+  const services = checkerServices(context, PRIMITIVE_CHECKER_METHODS);
+  return services !== void 0 && askChecker(() => primitiveValue(services, shape.received)) === true;
+}
 var preferToHaveSignalValue = defineRule({
   name: "prefer-to-have-signal-value",
-  description: "Assert a signal with toHaveSignalValue instead of reading it inline into toBe/toEqual",
+  description: "Assert a signal with toHaveSignalValue instead of reading it inline into toBe/toEqual/toBeNull",
   messages: {
     preferToHaveSignalValue: "Assert the signal, not the value it happens to hold: `expect({{signal}}).toHaveSignalValue(\u2026)` keeps the signal's name in the failure output and refuses a value that is not a signal."
   },
@@ -4174,7 +4225,7 @@ var preferToHaveSignalValue = defineRule({
   create: (context) => ({
     CallExpression: (node) => {
       const shape = signalAssertionOf(node);
-      if (!shape || !readsSignal(context, shape.received.callee)) {
+      if (!shape || !readsSignal(context, shape.received.callee) || !identityIsMoot(context, node, shape)) {
         return;
       }
       context.report({
@@ -4183,9 +4234,10 @@ var preferToHaveSignalValue = defineRule({
         data: { signal: excerpt(context, shape.received.callee, 40) },
         ...shape.received.typeArguments === void 0 && {
           fix: (fixer) => {
+            const value = VALUE_MATCHERS.get(shape.matcher.name);
             const fixes = [
               fixer.replaceText(shape.received, context.sourceCode.getText(shape.received.callee)),
-              fixer.replaceText(shape.matcher, "toHaveSignalValue")
+              value === void 0 ? fixer.replaceText(shape.matcher, "toHaveSignalValue") : fixer.replaceTextRange([shape.matcher.range[0], node.range[1]], `toHaveSignalValue(${value})`)
             ];
             const last = node.arguments.at(-1);
             if (shape.strict && last !== void 0) {
@@ -4577,6 +4629,120 @@ var preferProvideAutoSpy = defineRule({
   }
 });
 
+// src/lib/eslint/real-component-provider.ts
+var REPLACING_CALLS = /* @__PURE__ */ new Set([
+  "createSpyFromClass",
+  "overrideAutoSpy",
+  "overrideComponent",
+  "overrideComponentProvider",
+  "overrideProvider",
+  "provideAutoSpy"
+]);
+var OPAQUE_HELPERS2 = /* @__PURE__ */ new Set(["createWithAutoSpies"]);
+var OWN_INJECTOR_HOLDERS = /* @__PURE__ */ new Set(["componentRef", "debugElement"]);
+var FRAMEWORK_SCOPE = "@angular/";
+var REAL_COMPONENT_PROVIDER_SCHEMA = [
+  {
+    type: "object",
+    properties: { ignoreTokens: { type: "array", items: { type: "string" }, uniqueItems: true } },
+    additionalProperties: false
+  }
+];
+function calleeName2(node) {
+  return isIdentifier(node.callee) ? node.callee.name : memberName(node.callee);
+}
+var RENDERED_KEYS = /* @__PURE__ */ new Set(["declarations", "hostDirectives", "imports"]);
+function isRenderedList(node) {
+  const name = propertyName(node.parent);
+  return name !== void 0 && RENDERED_KEYS.has(name) && Reflect.get(node.parent, "value") === node;
+}
+function isReplacingArgument(node) {
+  const call = node.parent;
+  if (!isCallExpression(call) || !call.arguments.includes(node)) {
+    return false;
+  }
+  const name = calleeName2(call);
+  return name !== void 0 && REPLACING_CALLS.has(name);
+}
+function ownInjectorToken(node) {
+  const [token] = node.arguments;
+  if (!isMemberExpression(node.callee) || memberName(node.callee) !== "get" || !token || !isIdentifier(token)) {
+    return void 0;
+  }
+  const injector = node.callee.object;
+  if (!isMemberExpression(injector) || memberName(injector) !== "injector") {
+    return void 0;
+  }
+  const holder = memberName(injector.object);
+  return holder !== void 0 && OWN_INJECTOR_HOLDERS.has(holder) ? token : void 0;
+}
+function isClaimedSpy(node) {
+  return isCallExpression(node.parent) && calleeName2(node.parent) === "asSpy";
+}
+function ignoredTokens(options) {
+  const configured = Reflect.get(Object(options[0]), "ignoreTokens");
+  return new Set(Array.isArray(configured) ? configured.filter((entry) => typeof entry === "string") : []);
+}
+function isFrameworkImport(node) {
+  return node.type === "ImportDeclaration" && String(Reflect.get(Reflect.get(node, "source"), "value")).startsWith(FRAMEWORK_SCOPE);
+}
+function readCall2(node, scan) {
+  const name = calleeName2(node);
+  if (name !== void 0 && OPAQUE_HELPERS2.has(name)) {
+    scan.opaque = true;
+  }
+  if (name === "createComponent") {
+    node.arguments.filter(isIdentifier).forEach((argument) => scan.rendered.add(argument.name));
+  }
+  const token = ownInjectorToken(node);
+  if (token && !isClaimedSpy(node)) {
+    scan.reads.push(token);
+  }
+}
+var noRealComponentProvider = defineRule({
+  name: "no-real-component-provider",
+  description: "Do not read a component's own provider from the fixture unless the file replaced it with a spy",
+  schema: REAL_COMPONENT_PROVIDER_SCHEMA,
+  messages: {
+    noRealComponentProvider: "Nothing in this file replaces `{{token}}`, so the fixture hands back the real instance the component provides, and the spec tests it through the component. Install the spy where the component looks: `const {{variable}} = overrideComponentProvider(Component, {{token}});`, before the fixture is created. If the real one is meant, list `{{token}}` in `{ ignoreTokens }`."
+  },
+  create: (context) => {
+    const scan = { reads: [], replaced: /* @__PURE__ */ new Set(), rendered: /* @__PURE__ */ new Set(), framework: /* @__PURE__ */ new Set(), opaque: false };
+    const ignored = ignoredTokens(context.options);
+    return {
+      Property: (node) => {
+        if (propertyName(node) === "provide" && isIdentifier(node.value)) {
+          scan.replaced.add(node.value.name);
+        }
+      },
+      Identifier: (node) => {
+        if (hasAncestor(node, isReplacingArgument)) {
+          scan.replaced.add(node.name);
+        }
+        if (hasAncestor(node, isRenderedList)) {
+          scan.rendered.add(node.name);
+        }
+        if (hasAncestor(node, isFrameworkImport)) {
+          scan.framework.add(node.name);
+        }
+      },
+      CallExpression: (node) => {
+        readCall2(node, scan);
+      },
+      "Program:exit": () => {
+        if (scan.opaque) {
+          return;
+        }
+        const skipped = [scan.replaced, scan.rendered, scan.framework, ignored];
+        scan.reads.filter(({ name }) => !skipped.some((names) => names.has(name))).forEach((token) => {
+          const variable = `${token.name.charAt(0).toLowerCase()}${token.name.slice(1)}`;
+          context.report({ node: token, messageId: "noRealComponentProvider", data: { token: token.name, variable } });
+        });
+      }
+    };
+  }
+});
+
 // src/lib/eslint/reflect-access.ts
 var HELPER3 = "mockValueProp";
 var REFLECT = /* @__PURE__ */ new Set(["Reflect"]);
@@ -5500,7 +5666,7 @@ function readCast(context, node) {
     context.report({ node, messageId: "castResponse", data: { cast: excerpt(context, node, 50) } });
   }
 }
-function readCall2(context, node) {
+function readCall3(context, node) {
   const helper = isIdentifier(node.callee) ? node.callee.name : void 0;
   const argument = node.typeArguments?.params[0];
   if (helper === void 0 || !TYPE_ARGUMENT_DOUBLES.has(helper) || argument === void 0) {
@@ -5522,7 +5688,7 @@ var preferStubResponse = defineRule({
   },
   create: (context) => ({
     CallExpression: (node) => {
-      readCall2(context, node);
+      readCall3(context, node);
     },
     [CAST_SELECTORS.join(", ")]: (node) => {
       readCast(context, node);
@@ -5758,6 +5924,7 @@ var rules = {
   "no-dead-schemas": noDeadSchemas,
   "no-import-time-spread": noImportTimeSpread,
   "no-unregistered-inject-spy": noUnregisteredInjectSpy,
+  "no-real-component-provider": noRealComponentProvider,
   "prefer-render-shallow": preferRenderShallow,
   "prefer-to-have-signal-value": preferToHaveSignalValue,
   "prefer-observer-stub": preferObserverStub,
@@ -5810,6 +5977,7 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-dead-schemas`]: "error",
   [`${PLUGIN_NAME}/no-import-time-spread`]: "error",
   [`${PLUGIN_NAME}/no-unregistered-inject-spy`]: "error",
+  [`${PLUGIN_NAME}/no-real-component-provider`]: "error",
   [`${PLUGIN_NAME}/prefer-render-shallow`]: "warn",
   [`${PLUGIN_NAME}/prefer-to-have-signal-value`]: "warn",
   [`${PLUGIN_NAME}/no-stub-class-double`]: "warn",
@@ -5853,7 +6021,8 @@ var plugin = {
     recommended: { plugins: {}, rules: recommendedRules },
     strict: { plugins: {}, rules: strictRules },
     typeErrors: { plugins: {}, rules: typeErrorRules }
-  }
+  },
+  hookRegisteringHelpers
 };
 plugin.configs.recommended.plugins[PLUGIN_NAME] = plugin;
 plugin.configs.strict.plugins[PLUGIN_NAME] = plugin;

package/dist/eslint-plugin.d.ts

@@ -227,29 +227,6 @@ interface RuleModule {
     create(context: RuleContext): RuleListener;
 }
 
-/**
- * `vitest-auto-spy/eslint-plugin` — the lint rules that keep a suite on the library's API.
- *
- * ```js
- * // eslint.config.js (flat config)
- * import autoSpy from 'vitest-auto-spy/eslint-plugin';
- *
- * export default [
- *   { files: ['**\/*.spec.ts'], ...autoSpy.configs.recommended },
- * ];
- * ```
- *
- * Scope the config to spec files yourself: every rule here is about test code, and `Object.
- * defineProperty` or an object of `vi.fn()`s is perfectly reasonable in application code.
- *
- * `configs.strict` is `recommended` with every rule at `error`. `configs.typeErrors` is the subset whose
- * findings are compile errors — already `error` in `recommended` — to spread back over a blanket
- * downgrade while a large suite is being adopted.
- *
- * Flat config only. The legacy `.eslintrc` `plugins: ['…']` form resolves plugin names to
- * `eslint-plugin-*` packages, which a subpath export of this package can never be.
- */
-
 /** Severity map shared by the shipped configs. */
 type RuleSeverity = 'error' | 'off' | 'warn';
 /** A flat-config object: the plugin under its name, plus the rules it turns on. */
@@ -277,6 +254,11 @@ interface AutoSpyEslintPlugin {
         strict: FlatConfig;
         typeErrors: FlatConfig;
     };
+    /**
+     * The library's helpers that register `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when
+     * called, for `vitest/require-hook`'s `allowedFunctionCalls`.
+     */
+    hookRegisteringHelpers: readonly string[];
 }
 declare const plugin: AutoSpyEslintPlugin;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.47.0",
+  "version": "5.49.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -384,7 +384,9 @@ it('loads', async () => {
   `toHaveSignalValue(v)` after `registerSignalMatchers()` from `vitest-auto-spy/angular/matchers`
   (`toEqual` semantics; `toHaveSignalValue(v, { strict: true })` for `toStrictEqual`'s, or
   `registerSignalMatchers({ strict: true })` for the whole suite). The type-aware
-  `prefer-to-have-signal-value` lint rule rewrites `expect(sig()).toBe(v)` into the matcher.
+  `prefer-to-have-signal-value` lint rule rewrites `expect(sig()).toBe(v)`, `.toBeNull()` and
+  `.toBeUndefined()` into the matcher, except a `toBe` that checks an object's identity, which the
+  deep matcher cannot keep.
 - **Never assert a resource with `expect(r.value()).toEqual(...)` alone** — an unresolved resource
   still holds its _default_, so that passes while proving nothing. `toHaveResourceValue(v)` after
   `registerResourceMatchers()`, from the same `/angular/matchers` entry, fails unless the resource
@@ -408,7 +410,9 @@ it('loads', async () => {
   To control an `effect()`, set the signals it reads and assert what it produced.
 - **`injectSpy(X)` only reaches the global TestBed.** For a component-level provider use
   `asSpy(fixture.debugElement.injector.get(X))` to read it, or `overrideComponentProvider(Cmp, X)` to
-  replace it — `provideAutoSpy` loses to a provider the component declares, silently.
+  replace it — `provideAutoSpy` loses to a provider the component declares, silently. Reading it
+  bare, with nothing in the file replacing it, hands back the real store and makes the component spec
+  re-test it; `no-real-component-provider` reports that.
 - **Declare `Spy<T>`, never Vitest's `Mocked<T>`** — `Mocked<T>` keeps the private members, so the
   assignment fails with a list of private field names that says nothing about the declaration being
   the problem.
@@ -485,13 +489,18 @@ npx vitest-auto-spy codemod --verify  # after a migration: anything the transfor
 Most of this library's guarantees are type-level, so a green run that does not type-check is not
 done. Report failures with their output rather than describing them as passing.
 
-**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The fifty rules in
+**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The fifty-one rules in
 `vitest-auto-spy/eslint-plugin` are lint, not typecheck: `no-mocked-for-spy` rewrites a declaration
 to `Spy<T>` and cannot see what the name is assigned two lines below, so a clean lint pass is not
 evidence that the types still hold. Where it cannot prove the rename it downgrades to a suggestion —
 accept those together with the repair at the creation site, usually `createAutoMock<T>()` in place of
 an object literal.
 
+**`vitest/require-hook` reports a bare `useConsoleSpies();` or `setupFakeTimers();`** in a
+`describe` body. Do not wrap it in a hook or disable the line: spread
+`autoSpy.hookRegisteringHelpers` from `vitest-auto-spy/eslint-plugin` into the rule's
+`allowedFunctionCalls`.
+
 **`no-private-member-access`, `no-mistyped-use-value` and `no-unknown-use-value-key` are the three
 rules here that need type information.** The first reports
 `instance['privateMember']` (bracket access, which TypeScript does not visibility-check),