vitest-auto-spy 4.4.0 → 4.5.0

package/AGENTS.md

@@ -2328,6 +2328,7 @@ export default [
 | `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                     |
 | `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` 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                  |
+| `prefer-render-shallow`           | `error` | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children          |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`       |
 | `no-jasmine-globals`              | `error` | —                 | `jasmine.*`, bare `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(`                              |
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                    |

package/README.md

@@ -76,7 +76,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
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 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 — nineteen rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, seven suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
+- 📏 Lint rules and one-line test-run hygiene — twenty rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
 - 🩺 [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-and-init) — 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
@@ -2961,6 +2961,7 @@ export can never be.
 | `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                      |
 | `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` 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                   |
+| `prefer-render-shallow`           |   `error`   | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children           |
 | `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                   |
 | `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest  |
 | `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                     |
@@ -2970,7 +2971,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.
 
-**Three of the nineteen fix on their own, seven offer suggestions**, and the split is not about how hard
+**Three of the twenty fix on their own, eight 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
@@ -3074,7 +3075,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 nineteen rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the twenty rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3091,7 +3092,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 nineteen rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of twenty rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 

package/dist/cli.js

@@ -2356,7 +2356,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "4.3.0";
+var EXPORT_MAP_VERSION = "4.4.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node 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-http 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";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 11 14 15 16",

package/dist/eslint-plugin.cjs

@@ -316,6 +316,48 @@ function defineRule(options) {
   };
 }
 
+// src/lib/eslint/dom-reads.ts
+var TEMPLATE_READS = [
+  "nativeElement",
+  "debugElement",
+  "elementRef",
+  "querySelector",
+  "getComputedStyle",
+  "triggerEventHandler",
+  "innerHTML",
+  "innerText",
+  "textContent",
+  "getAttribute",
+  "classList",
+  "shadowRoot",
+  "By.css",
+  "By.directive"
+];
+function templatePolicy(context) {
+  return Reflect.get(Object(context.options[0]), "templates") === "never" ? "never" : "as-needed";
+}
+function readsRenderedTemplate(source) {
+  return TEMPLATE_READS.some((member) => source.includes(member));
+}
+function renderShallowSuggestion(context, node) {
+  const [component, ...extra] = node.arguments;
+  const state = bindingState(context.sourceCode.getScope(node), "renderShallow");
+  if (!component || extra.length > 0 || state === "taken") {
+    return void 0;
+  }
+  const replacement = `renderShallow(${context.sourceCode.getText(component)}).fixture`;
+  return {
+    desc: `Render without the children and the template: ${replacement}`,
+    fix: (fixer) => {
+      const edits = [fixer.replaceText(node, replacement)];
+      if (state === "free") {
+        edits.push(insertImport(fixer, `import { renderShallow } from '${PACKAGE}/angular';`));
+      }
+      return edits;
+    }
+  };
+}
+
 // src/lib/eslint/floating-assertion.ts
 var PROMISE_CALLBACK_METHODS = /* @__PURE__ */ new Set(["catch", "finally", "then"]);
 function isPromiseCallback(fn) {
@@ -1609,6 +1651,32 @@ var noUnregisteredInjectSpy = defineRule({
     };
   }
 });
+var preferRenderShallow = defineRule({
+  anchor: "-a-components-children",
+  description: "Render through renderShallow() when the spec never reads the rendered template",
+  hasSuggestions: true,
+  schema: [{ type: "object", properties: { templates: { enum: ["as-needed", "never"] } }, additionalProperties: false }],
+  messages: {
+    keepTemplate: '`keepTemplate: true` puts the real template back, and this project set `{ templates: "never" }`. Drop it \u2014 or, when the component genuinely reads its own template through `viewChild` or content projection, silence this line, because the alternative is a spec that cannot reach the component at all.',
+    preferRenderShallow: "`TestBed.createComponent` pays for compiling the template and instantiating the whole child subtree, and nothing in this file reads either \u2014 no `nativeElement`, no `debugElement`, no `By.css`, no `querySelector`. `renderShallow(X)` brings the same component up through the same `TestBed` with the children dropped and the template blank, and leaves inputs, signals, lifecycle hooks and DI exactly where they were; `fixture` is still a real `ComponentFixture`. What it buys is measured in `bench-angular/`: **0.24\xD7** the per-test cycle at 100 children and **0.05\xD7** at 400 \u2014 but at **zero** children the two are level (measurements straddle 1.0, and it is the noisiest row in the benchmark), so a leaf component gains nothing and this report is worth ignoring there. Reach for `{ keepTemplate: true }` when the component reads its own template through `viewChild` or content projection, which this rule cannot see from the spec."
+  },
+  create: (context) => ({
+    'CallExpression[callee.object.name="TestBed"][callee.property.name="createComponent"]': (node) => {
+      if (templatePolicy(context) === "as-needed" && readsRenderedTemplate(context.sourceCode.getText())) {
+        return;
+      }
+      const suggestion = renderShallowSuggestion(context, node);
+      context.report(
+        suggestion ? { node, messageId: "preferRenderShallow", suggest: [suggestion] } : { node, messageId: "preferRenderShallow" }
+      );
+    },
+    'Property[key.name="keepTemplate"][value.value=true]': (node) => {
+      if (templatePolicy(context) === "never") {
+        context.report({ node, messageId: "keepTemplate" });
+      }
+    }
+  })
+});
 var rules = {
   "prefer-provide-auto-spy": preferProvideAutoSpy,
   "prefer-create-spy-from-class": preferCreateSpyFromClass,
@@ -1625,6 +1693,7 @@ var rules = {
   "no-inject-before-override": noInjectBeforeOverride,
   "no-import-time-spread": noImportTimeSpread,
   "no-unregistered-inject-spy": noUnregisteredInjectSpy,
+  "prefer-render-shallow": preferRenderShallow,
   ...jasmineRules
 };
 
@@ -1646,6 +1715,7 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-inject-before-override`]: "error",
   [`${PLUGIN_NAME}/no-import-time-spread`]: "error",
   [`${PLUGIN_NAME}/no-unregistered-inject-spy`]: "error",
+  [`${PLUGIN_NAME}/prefer-render-shallow`]: "error",
   [`${PLUGIN_NAME}/jasmine-namespace-without-entry`]: "error",
   [`${PLUGIN_NAME}/no-jasmine-globals`]: "error",
   [`${PLUGIN_NAME}/no-save-arguments-by-value`]: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun and node:test, 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

@@ -323,7 +323,7 @@ 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 nineteen rules in
+**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The twenty 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 —