vitest-auto-spy 5.59.0 → 5.60.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.60.0] - 2026-10-06
+
+### Added
+
+- **`no-redundant-as-instance`** in `vitest-auto-spy/eslint-plugin`, `warn` in `recommended`:
+  `expect(service.open()).toBe(asInstance(ref))`. The three comparing matchers take their argument as
+  a free type parameter, so the unwrap buys nothing there — it keeps an import alive and reads as if
+  the types needed it. `--fix` drops the wrapper and, when that was the import's last use, the import
+  too. Slots typed against the real class are untouched: `toHaveBeenCalledWith(asInstance(cart))`
+  can be load-bearing, and so can a wrapper that is part of the argument (`[asInstance(x)]`,
+  `asInstance(x).id`). Three such call sites in two consumer suites (5.59.1). The plugin now ships
+  fifty-eight rules. `/eslint-plugin` is 53.45 → 53.84 kB (+0.39 kB, +0.7 %): the rule, minus the
+  matcher set that `no-constant-expect`, `prefer-to-have-signal-value` and
+  `no-vacuous-absence-assertion` each carried a copy of, and the `matcherOf` walk `no-constant-expect`
+  duplicated — both now shared out of `absence-assertion.ts`.
+
+## [5.59.1] - 2026-09-30
+
 ## [5.59.0] - 2026-09-30
 
 ### Added
@@ -27,6 +45,10 @@ The latest released version here must always match the one published on
 
 ### Fixed
 
+- **A repeated list flag adds up instead of keeping only the last value.** `doctor --ignore a
+  --ignore b` used to ignore only `b`, so a wrapper passing one `--ignore` per check silently
+  reported the first one again. `--ignore`, `--only`, `--gate-only` and `--related` now join every
+  occurrence; a comma-separated value still works.
 - **`no-inline-test-data` asks for a spec-local `const` when the part of a long expected value it
   names is written only once.** It used to send that part to a `*.mock.ts` file, a file of its own
   for a value one test uses. A part the file writes again still goes to the mock file.
@@ -6819,7 +6841,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.59.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.60.0...HEAD
+[5.60.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.1...v5.60.0
+[5.59.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.0...v5.59.1
 [5.59.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...v5.59.0
 [5.58.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.57.0...v5.58.0
 [5.57.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.56.0...v5.57.0

package/README.md

@@ -3596,6 +3596,7 @@ Rolling it out on a large suite, and the options each rule takes:
 | [`no-instance-lifecycle-spy`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-instance-lifecycle-spy)               |   `warn`    | —                 | Spy on an Angular lifecycle hook through the class prototype — Angular never calls the one on an instance                             |
 | [`no-ts-expect-error-on-double`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-ts-expect-error-on-double)         |   `error`   | —                 | Do not suppress a type error on a double's configuration — name the overload, or fix the fixture                                      |
 | [`no-constant-expect`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-constant-expect)                             |   `error`   | —                 | Assert on a value the code under test produced, not on one the spec spelled out                                                       |
+| [`no-redundant-as-instance`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-redundant-as-instance)                 |   `warn`    | `--fix`           | Drop asInstance() around a comparing matcher's argument — the unwrap buys nothing there and keeps an import alive                     |
 | [`no-redundant-smoke-test`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-redundant-smoke-test)                   |   `error`   | suggest           | Delete a test whose whole body asserts that the subject exists, where the block already has tests that use it                         |
 | [`no-self-called-spy`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-self-called-spy)                             |   `error`   | —                 | Do not assert a call the test made itself — drive the production path that should make it                                             |
 | [`no-vacuous-absence-assertion`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-vacuous-absence-assertion)         |   `error`   | —                 | Do not let a whole test rest on assertions that a stream which never emits already satisfies                                          |

package/agent-docs/eslint.md

@@ -91,6 +91,7 @@ export default [
 | `no-instance-lifecycle-spy` | `warn` | — | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance |
 | `no-ts-expect-error-on-double` | `error` | — | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `returnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature → an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`; otherwise the fixture is the wrong shape, checked against `ReturnType<X['m']>`. A reason after the directive does not silence it; a deliberate out-of-type value keeps it under `eslint-disable-next-line … -- <why>` |
 | `no-constant-expect` | `error` | — | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer it already fixes (`toBe` / `toEqual` / `toStrictEqual` against a literal; `toBeTruthy`, `toBeDefined`, `toBeNull`… for any literal) → assert on what the code produced, or `expect.fail(…)` for an unreachable branch |
+| `no-redundant-as-instance` | `warn` | `--fix` | `expect(x).toBe(asInstance(ref))` → `.toBe(ref)`: the comparing matchers take their argument as a free type parameter, so the bridge buys nothing there; `--fix` drops the wrapper and the import once it is unused. `toHaveBeenCalledWith(asInstance(cart))` is left alone — that slot is typed against the real class and the unwrap can be load-bearing; so is a wrapper that is part of the argument (`[asInstance(x)]`, `asInstance(x).id`) |
 | `no-redundant-smoke-test` | `error` | suggest | `it('should create', () => expect(pipe).toBeTruthy())` — every statement of the body an `expect(x)` under `toBeTruthy` / `toBeDefined` / `toBeInstanceOf` (or their negated twins), weighed against the tests that run the same setup: the rest of the block, and everything the blocks nested in it declare → delete it; the suggestion removes the test and the blank line above it. Silent where that test is the block's only running one, and a skipped sibling does not count as proof |
 | `no-self-called-spy` | `error` | — | `vi.spyOn(obj, 'm')`, then `obj.m(…)` written by the test itself, then a positive `toHaveBeenCalled*` — the assertion is satisfied by the test's own line, so the test survives the deletion of the behaviour its title names. Order decides it: a call written **before** the spy is arrangement, and a `mockClear` between the call and the assertion, a negated matcher or arguments the call did not pass all silence it |
 | `no-vacuous-absence-assertion` | `error` | — | a test **all** of whose assertions are satisfied by the stream never emitting. The carrier is a `const` / `let` declared in the test whose every write outside the declaration sits in a `subscribe` callback of that test (the assignment and the `push` forms both count), or a `vi.fn()` the test hands to `subscribe` and never calls itself. Silence satisfies an equality matcher repeating the initialiser's source text, `toBeUndefined` / `not.toBeDefined` on a `let` holding `undefined`, `toBeNull` on one holding `null`, `toBeFalsy` / `not.toBeTruthy` on any falsy literal, `toHaveLength(0)` on `[]` or `''`, and `not.toHaveBeenCalled` / `not.toHaveBeenCalledWith` / `toHaveBeenCalledTimes(0)` on any subject — read literally, so `toBeNull()` on a `let` with no initialiser is **not** reported. One `expect()` a silent source could fail silences the rule, which is what exempts the "nothing yet, trigger, now the value" shape; a test asserting through a local helper is skipped entirely → `await expectNoEmission(source$)`, or `expect(await expectEmission(source$))` |
@@ -111,22 +112,24 @@ export default [
 | `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. The fix renames only the member (`and.returnValue` → `mockReturnValue`, `withArgs` → `calledWith`), so comments stay; a rewrite that would drop one is a suggestion |
 
-Fifty-seven rules, **every one an `error` except `prefer-render-shallow`,
+Fifty-eight rules, **every one an `error` 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`, `prefer-to-have-signal-value`,
-`no-unasserted-console-spy`, `no-real-wait-in-test` and `no-inline-test-data`**; eight fix on their own, nineteen offer suggestions. Fifty-three are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
+`no-unasserted-console-spy`, `no-real-wait-in-test`, `no-inline-test-data` and
+`no-redundant-as-instance`**; nine fix on their own, nineteen offer suggestions. Fifty-four 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;
 `no-relative-mock-under-builder` waits for a builder target serving the file, or `{ builder: 'unit-test' }`.
 
-The twelve `warn`s do not rank findings by importance. Each names something other than a defect: a
+The thirteen `warn`s do not rank findings by importance. Each names something other than a defect: a
 cheaper render (`prefer-render-shallow`), a heuristic reading with no `provide:` to settle it
 (`no-stub-class-double`, `no-structural-double`, `no-instance-lifecycle-spy`), a repair that turns
 many files red at once (`prefer-create-mock`), a question only the author can answer
 (`no-unasserted-argument`, `no-unasserted-console-spy`, `no-real-wait-in-test`), a place data should
 live rather than a defect (`no-inline-test-data`), or a preferred spelling
-of working code (`prefer-spy-on-own-method`, `prefer-set-inputs`, `prefer-to-have-signal-value`). Set
+of working code (`prefer-spy-on-own-method`, `prefer-set-inputs`, `prefer-to-have-signal-value`,
+`no-redundant-as-instance`). Set
 any of the `warn`s to `'error'` once the batch is done.
 
 Three rules can report on a _correct_ project, and only one has an option:

package/dist/cli.js

@@ -37,6 +37,7 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "target",
   "top"
 ]);
+var LIST_FLAGS = /* @__PURE__ */ new Set(["gate-only", "ignore", "only", "related"]);
 var OPTIONAL_VALUE_FLAGS = /* @__PURE__ */ new Set(["changed"]);
 var ALIASES = { h: "help", v: "version" };
 function normalizeName(raw) {
@@ -45,6 +46,10 @@ function normalizeName(raw) {
 }
 function parseArgs(argv) {
   const flags = {};
+  const setValue = (name2, value) => {
+    const previous = flags[name2];
+    flags[name2] = LIST_FLAGS.has(name2) && typeof previous === "string" ? `${previous},${value}` : value;
+  };
   const positionals = [];
   let command;
   let consumed = false;
@@ -67,12 +72,12 @@ function parseArgs(argv) {
     const [rawName, inlineValue] = splitInline(token);
     const name2 = normalizeName(rawName);
     if (inlineValue !== void 0) {
-      flags[name2] = inlineValue;
+      setValue(name2, inlineValue);
       continue;
     }
     const next = own[index + 1];
     if (VALUE_FLAGS.has(name2) && next !== void 0 && (!next.startsWith("-") || /^-\d/.test(next))) {
-      flags[name2] = next;
+      setValue(name2, next);
       consumed = true;
       continue;
     }
@@ -1662,7 +1667,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.58.0";
+var EXPORT_MAP_VERSION = "5.59.1";
 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

@@ -632,7 +632,7 @@ function repairFor(node, subscribeCall) {
 var TESTS = /* @__PURE__ */ new Set(["it", "test"]);
 var NEVER_CALLED = /* @__PURE__ */ new Set(["toHaveBeenCalled", "toHaveBeenCalledWith"]);
 var UNDEFINED_MATCHERS = /* @__PURE__ */ new Set(["toBeDefined", "toBeUndefined"]);
-var EQUALITY = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var FALSY = /* @__PURE__ */ new Set(["0", "''", '""', "``", "NaN", "false", "null", "undefined"]);
 var EMPTY = /* @__PURE__ */ new Set(["[]", "''", '""', "``"]);
 function testCallOf(fn) {
@@ -697,7 +697,7 @@ function satisfiedByHeldValue(context, held, matcher) {
   if (matcher.negated) {
     return UNDEFINED_MATCHERS.has(matcher.name) ? held === "undefined" : matcher.name === "toBeTruthy" && FALSY.has(held);
   }
-  if (EQUALITY.has(matcher.name)) {
+  if (EQUALITY_MATCHERS.has(matcher.name)) {
     return matcher.args.length === 1 && argument !== void 0 && tight(context.sourceCode.getText(argument)) === tight(held);
   }
   if (matcher.name === "toHaveLength") {
@@ -1724,7 +1724,6 @@ var noUnassertedConsoleSpy = defineRule({
 });
 
 // src/lib/eslint/constant-expect.ts
-var COMPARES = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var CLASSIFIES = /* @__PURE__ */ new Set(["toBeDefined", "toBeFalsy", "toBeNaN", "toBeNull", "toBeTruthy", "toBeUndefined"]);
 var OBJECT_LITERALS = /* @__PURE__ */ new Set([
   "ArrayExpression",
@@ -1758,17 +1757,8 @@ function isConstant(node) {
       return LITERALS.has(value.type);
   }
 }
-function matcherOf2(expectCall) {
-  let member = expectCall.parent;
-  while (memberName(member) === "not") {
-    member = member.parent;
-  }
-  const name = memberName(member);
-  const call = member.parent;
-  return name && isCallExpression(call) && call.callee === member ? { name, args: call.arguments } : void 0;
-}
 function isDecided(actual, matcher) {
-  if (COMPARES.has(matcher.name)) {
+  if (EQUALITY_MATCHERS.has(matcher.name)) {
     return isConstant(actual) && matcher.args.every(isConstant);
   }
   return CLASSIFIES.has(matcher.name) && (OBJECT_LITERALS.has(unwrapped(actual).type) || isConstant(actual));
@@ -1782,7 +1772,7 @@ var noConstantExpect = defineRule({
   create: (context) => ({
     'CallExpression[callee.name="expect"]': (node) => {
       const [actual] = node.arguments;
-      const matcher = matcherOf2(node);
+      const matcher = matcherOf(node);
       if (actual && matcher && isDecided(actual, matcher)) {
         context.report({ node, messageId: "noConstantExpect", data: { actual: excerpt(context, actual, 40), matcher: matcher.name } });
       }
@@ -3443,6 +3433,55 @@ var noInstanceLifecycleSpy = defineRule({
   })
 });
 
+// src/lib/eslint/matcher-as-instance.ts
+var AS_INSTANCE = "asInstance";
+function importedAsInstance(context, callee) {
+  const binding = findBinding(context.sourceCode.getScope(callee), callee.name);
+  return binding?.defs.some((definition) => definition.type === "ImportBinding") ? binding : void 0;
+}
+function unwrap2(context, fixer, wrapper, value, binding) {
+  const edits = [fixer.replaceText(wrapper, context.sourceCode.getText(value))];
+  const orphaned = binding.references.length === 1 ? dropNamedImport(context.sourceCode, fixer, binding) : void 0;
+  if (orphaned) {
+    edits.push(orphaned);
+  }
+  return edits;
+}
+var noRedundantAsInstance = defineRule({
+  name: "no-redundant-as-instance",
+  description: "Pass the value itself to a comparing matcher; asInstance() bridges slots typed as the real class",
+  fixable: true,
+  messages: {
+    noRedundantAsInstance: "`asInstance({{value}})` buys nothing under `.{{matcher}}()`: the matcher takes its argument as a free type parameter, so the value compiles as it is. Pass `{{value}}` directly."
+  },
+  create: (context) => ({
+    'CallExpression[callee.name="expect"]': (node) => {
+      const matcher = matcherOf(node);
+      if (!matcher || !EQUALITY_MATCHERS.has(matcher.name)) {
+        return;
+      }
+      for (const argument of matcher.args) {
+        if (!isCallExpression(argument) || !isIdentifier(argument.callee) || argument.callee.name !== AS_INSTANCE) {
+          continue;
+        }
+        const [value, ...extra] = argument.arguments;
+        if (value === void 0 || extra.length > 0) {
+          continue;
+        }
+        const binding = importedAsInstance(context, argument.callee);
+        if (binding) {
+          context.report({
+            node: argument,
+            messageId: "noRedundantAsInstance",
+            data: { matcher: matcher.name, value: excerpt(context, value, 40) },
+            fix: (fixer) => unwrap2(context, fixer, argument, value, binding)
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/lib/eslint/use-value-types.ts
 var PRIMITIVE_CHECKER_METHODS = [
   "getTypeAtLocation",
@@ -5101,7 +5140,6 @@ 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"]
@@ -5110,7 +5148,7 @@ 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) || VALUE_MATCHERS.has(callee.property.name))) {
+  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !(EQUALITY_MATCHERS.has(callee.property.name) || VALUE_MATCHERS.has(callee.property.name))) {
     return void 0;
   }
   let expected = callee.object;
@@ -6537,7 +6575,7 @@ function isObjectPattern(node) {
 function isUnwrapped(node) {
   return isCast(node) || node.type === "TSNonNullExpression";
 }
-function unwrap2(node) {
+function unwrap3(node) {
   return isUnwrapped(node) ? node.expression : node;
 }
 function methodString(node) {
@@ -6545,7 +6583,7 @@ function methodString(node) {
   return typeof value === "string" && METHOD_NAME.test(value) ? value : void 0;
 }
 function listedMethod(value) {
-  const list = unwrap2(value);
+  const list = unwrap3(value);
   const elements = isArrayExpression(list) ? list.elements : [];
   const names = elements.filter((element) => element !== null).map(methodString);
   return elements.length === 1 ? names[0] : void 0;
@@ -6586,7 +6624,7 @@ function readsMethod(member, method) {
   return named === method && !(isAssignmentExpression(parent) && parent.left === member);
 }
 function isRealObject(scope, node, follow) {
-  const value = unwrap2(node);
+  const value = unwrap3(node);
   if (isIdentifier(value)) {
     const bound = follow ? boundValueOf(scope, value) : void 0;
     return bound ? isRealObject(scope, bound, false) : DOM_GLOBALS.has(value.name) && bindingState(scope, value.name) === "free";
@@ -7049,6 +7087,7 @@ var rules = {
   "no-mistyped-use-value": noMistypedUseValue,
   "no-unknown-use-value-key": noUnknownUseValueKey,
   "no-instance-lifecycle-spy": noInstanceLifecycleSpy,
+  "no-redundant-as-instance": noRedundantAsInstance,
   "no-ts-expect-error-on-double": noTsExpectErrorOnDouble,
   "no-constant-expect": noConstantExpect,
   "no-compile-components": noCompileComponents,
@@ -7127,7 +7166,8 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-relative-mock-under-builder`]: "error",
   [`${PLUGIN_NAME}/no-real-wait-in-test`]: "warn",
   [`${PLUGIN_NAME}/no-disabled-testbed-teardown`]: "error",
-  [`${PLUGIN_NAME}/no-inline-test-data`]: "warn"
+  [`${PLUGIN_NAME}/no-inline-test-data`]: "warn",
+  [`${PLUGIN_NAME}/no-redundant-as-instance`]: "warn"
 };
 var typeErrorRules = {
   [`${PLUGIN_NAME}/prefer-as-spy`]: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.59.0",
+  "version": "5.60.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",