vitest-auto-spy 5.14.0 → 5.15.1

package/AGENTS.md

@@ -201,6 +201,23 @@ asSpy<AppLogger>(logger.channel('app')).info.mockReturnValue(undefined); // →
 `asInstance` did not take a deep mock before 3.5.0, which left it with nowhere to go: this tree
 sends you to `mockDeep` when the calls chain, and the result then fitted nothing that expected `T`.
 
+**`selfReturning: true` chains a factory, not a `return this` builder**, and the difference decides
+where the calls are recorded. A called node answers _itself_, not the object the method was read
+off, so every hop moves one level deeper: `editor.chain().focus().insertContent('text')` records
+`insertContent` on `chain.focus`, while the `chain` handle the spec is holding still has none — and
+`expect(chain.insertContent).toHaveBeenCalled()` reports nothing although the chain ran. Either walk
+the same path in the assertion, or, for an API where every command answers the **same** object
+(tiptap's `ChainedCommands`, a query builder, a `mockReturnThis()` chain), build that object with
+`createAutoMock` instead, where `selfReturning` names methods that answer one double:
+
+```ts
+const chain = createAutoMock<ChainedCommands>(undefined, { selfReturning: ['focus', 'insertContent'] });
+const editor = createAutoMock<Editor>(undefined, { returns: { chain: asInstance(chain) } });
+
+editor.chain().focus().insertContent('text').run();
+expect(chain.insertContent).toHaveBeenCalledWith('text'); // one double, so the assertion is the obvious one
+```
+
 **An `abstract class` is a class.** `abstract class LocalStorage extends AbstractStorage {}`,
 provided in production as `{ provide: LocalStorage, useClass: BrowserLocalStorage }`, is the
 standard Angular DI-token idiom, and `provideAutoSpy(LocalStorage)` / `createSpyFromClass(LocalStorage)`
@@ -231,6 +248,19 @@ createAutoMock<NavigationService>({ currentFocus: undefined, navRoot: undefined,
 This is the way to say "the member exists and is empty", and it is worth writing even when it looks
 redundant.
 
+**A getter in `overrides` stays a getter.** The seed is kept as a descriptor rather than read once
+while the double is assembled, so it runs at every read, with the double as `this` — and a seed
+written to **throw** ("this global is missing on this platform") fails where the code under test
+reads the member, not where the provider literal is evaluated. A `{ set }` seed is kept the same way
+and takes the write. Both used to be flattened as the double was built, which turned a throwing
+seed into a failure during `TestBed.configureTestingModule`, three frames from the branch under test.
+
+A **registration** is no exception, and it was the half that stayed broken one release longer: the
+merge that puts `registerAutoSpyDefaults` under a call site copied both sides with a spread, so a
+seeded getter was flattened on any class or token the registry knows — whether or not the
+registration names that key — while the same seed stayed live on one it does not. The merge copies
+descriptors now, and the seed behaves the same either way.
+
 ### What a Proxy-backed double cannot do
 
 `createAutoMock` and `mockDeep` build a Proxy, not an object, and there is one place where the
@@ -3148,7 +3178,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-create-spy-from-class`    | `error` | —                 | an object literal of 2+ `vi.fn()`s → `createSpyFromClass` (a factory's own seed is exempt)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `no-stub-class-double`            | `warn`  | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy` and delete the stub; a decorated, `implements`-ing, `extends`-ing or unnamed class is exempt — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `no-structural-double`            | `warn`  | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`; a bare `let fn: Mock` is a callback and never reported — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`; `ApplicationRef`, `DestroyRef`, `EnvironmentInjector`, `HttpClient` and `Injector` keep their real instance — option: `{ ignoreTokens }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `no-shared-module-level-mock`     | `error` | —                 | an **exported** value holding `vi.fn()`s → export a factory instead                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `no-mocked-for-spy`               | `error` | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the assigned value is not from a factory of this library                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `prefer-as-spy`                   | `error` | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
@@ -3311,6 +3341,15 @@ The variable is resolved through the scope manager, so it has to be a `const`/`l
 from `TestBed.inject(...)` and never assigned again — a name bound by an import, a parameter, or a
 `let` that is reassigned is left alone.
 
+Five tokens are left alone whatever is spied on them: `ApplicationRef`, `DestroyRef`,
+`EnvironmentInjector`, `HttpClient`, `Injector`. Each is a case where this rule's advice is
+impossible or self-defeating — `{ provide: DestroyRef, useValue }` is silently ignored, because
+`R3Injector.get()` short-circuits on `__NG_ENV_ID__` before it reads its providers; a spied
+`ApplicationRef` has no `injector` to build a component with; `HttpClient` under
+`provideHttpClientTesting()` is supposed to be real. A project adds its own with
+`['error', { ignoreTokens: ['MapRendererService'] }]`, compared as source text, which extends the
+five rather than replacing them.
+
 `no-inject-before-override` catches the trap this plugin's own advice sets. `TestBed.inject()` in a
 `beforeEach` — the line you write once `provideAutoSpy(X)` has taken away the literal you used to
 configure — instantiates the module, and every `TestBed.override*` afterwards throws, including one

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-17.5%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-17.6%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -2027,6 +2027,26 @@ expect(svc.apiUrl).toBe('https://api.test'); // or assign: svc.apiUrl = '...'
 > access — an un-seeded property read returns a spy. Seed real property values via `overrides`
 > (or assignment) to get them back verbatim.
 
+**A getter in `overrides` stays a getter.** The seed keeps its descriptor, so an accessor is
+installed as one and runs at the read — once per read, with the double as `this` — and a `{ set }`
+seed takes the write. That is what a seed written to _throw_ needs: "this global is missing on this
+platform" fails where the code under test reads the member, not while the provider literal is being
+evaluated.
+
+```ts
+const platform = createAutoMock<PlatformSupport>({
+  get transceiver(): never {
+    throw new TypeError('RTCRtpTransceiver is not defined');
+  },
+});
+
+expect(() => platform.transceiver).toThrow(); // at the read, not at `TestBed.configureTestingModule`
+```
+
+A class or token registered with `registerAutoSpyDefaults` behaves the same: the merge that puts a
+registration under the call site copies descriptors rather than spreading them, so a seeded getter
+is not flattened by the mere existence of a registration.
+
 For a double the code under test only **reads** — a DTO, a route snapshot, a config object — that
 caveat is the wrong trade, and [`createMock<T>()`](#utilities) is the other half of the pair: it
 returns a plain `T` built from the fields you seed, with no spies anywhere.
@@ -3427,7 +3447,7 @@ export can never be.
 | `prefer-create-spy-from-class`    |   `error`   | —                 | an object literal of two or more `vi.fn()`s → `createSpyFromClass` / `createAutoMock`, unless it is a factory's own seed                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-stub-class-double`            |   `warn`    | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy`, the stub class deleted                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no-structural-double`            |   `warn`    | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`; `ApplicationRef`, `DestroyRef`, `EnvironmentInjector`, `HttpClient` and `Injector` keep their real instance — option: `{ ignoreTokens }`                                                                                                                                                                                                                                                                                              |
 | `no-object-define-property`       |   `error`   | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-expect-in-subscribe`          |   `error`   | suggest           | `expect()` inside a `subscribe()` callback → `expectEmission` / `firstValueFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-shared-module-level-mock`     |   `error`   | —                 | an **exported** value holding `vi.fn()`s → export a factory that returns it                                                                                                                                                                                                                                                                                                                                                                                                                                      |

package/dist/angular.js

@@ -729,6 +729,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -749,7 +755,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }
@@ -1521,7 +1527,12 @@ function exposeAsSpy(spy) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }

package/dist/bun-angular.js

@@ -1,12 +1,12 @@
 import { stable, flushEffects } from './chunk-M5BULP7X.js';
 export { flushEffects, stable } from './chunk-M5BULP7X.js';
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 import { currentSpecFile, mockValueProp } from './chunk-N3T7KWWA.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-import { createSpyForToken } from './chunk-RPEYIZPL.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+import { createSpyForToken } from './chunk-DUFMKOKF.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/bun.d.ts

@@ -248,6 +248,13 @@ interface MockDeepOptions {
      * ```ts
      * asSpy<QueryBuilder>(query.where('id')).limit.mockReturnValue(query);
      * ```
+     *
+     * **A called node answers itself, not its receiver**, which is the difference between a factory
+     * and a `return this` builder. `editor.chain().focus().insertContent('x')` therefore records
+     * `insertContent` on `chain.focus`, while the `chain` handle the spec holds has no calls at all —
+     * the obvious assertion reports nothing although the chain ran. Assert down the path the chain
+     * walked, or build the object with `createAutoMock<T>(undefined, { selfReturning: ['focus', …] })`,
+     * where the named methods answer one double, which is what an API of this shape does.
      */
     selfReturning?: boolean;
 }

package/dist/bun.js

@@ -1,7 +1,7 @@
 import './chunk-M6VMOOZ2.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/{chunk-ADBB2HQG.js → chunk-5XLI5JYC.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-N3T7KWWA.js';
-import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-BWT7U4V4.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyConfiguredReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-WAMFS3UI.js';
 import { resolveReadGuard, createTrackedPropSpy } from './chunk-OS4PTU6D.js';
 import { redefineFailure } from './chunk-DTZCPCMA.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';

package/dist/{chunk-RPEYIZPL.js → chunk-DUFMKOKF.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass, createAutoMock } from './chunk-WAMFS3UI.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 
 // src/lib/track-injections.ts

package/dist/{chunk-BWT7U4V4.js → chunk-WAMFS3UI.js}

@@ -72,7 +72,12 @@ function attachDispose(spy) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }
@@ -296,6 +301,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -312,7 +323,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }

package/dist/cli.js

@@ -2455,7 +2455,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.14.0";
+var EXPORT_MAP_VERSION = "5.15.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-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";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 17 18 19",

package/dist/eslint-plugin.cjs

@@ -952,6 +952,23 @@ function injectedFromVariable(context, target) {
   const initializer = initializerOf(context.sourceCode.getScope(target), target);
   return initializer && isTestBedInject(initializer) ? initializer : void 0;
 }
+var KEPT_REAL_TOKENS = ["ApplicationRef", "DestroyRef", "EnvironmentInjector", "HttpClient", "Injector"];
+var INJECTED_SPY_SCHEMA = [
+  {
+    type: "object",
+    properties: { ignoreTokens: { type: "array", items: { type: "string" }, uniqueItems: true } },
+    additionalProperties: false
+  }
+];
+function keepsTheRealInstance(context, injectCall) {
+  const [token] = injectCall.arguments;
+  if (!token) {
+    return false;
+  }
+  const text = context.sourceCode.getText(token);
+  const configured = Reflect.get(Object(context.options[0]), "ignoreTokens");
+  return KEPT_REAL_TOKENS.includes(text) || Array.isArray(configured) && configured.includes(text);
+}
 function memberName2(node) {
   const value = node?.type === "Literal" ? Reflect.get(node, "value") : void 0;
   return typeof value === "string" && /^[$A-Z_a-z][\w$]*$/.test(value) ? value : void 0;
@@ -3007,8 +3024,9 @@ var preferInjectSpy = defineRule({
   anchor: "-reading-a-spy-back-from-di",
   description: "Read an already-spied dependency with injectSpy() instead of re-spying a TestBed.inject() result",
   hasSuggestions: true,
+  schema: INJECTED_SPY_SCHEMA,
   messages: {
-    preferInjectSpy: "Spying the instance DI just handed you replaces one method and leaves the rest real. Provide it with `provideAutoSpy(X)` and read it back with `injectSpy(X)`."
+    preferInjectSpy: "Spying the instance DI just handed you replaces one method and leaves the rest real. Provide it with `provideAutoSpy(X)` and read it back with `injectSpy(X)`. When the real instance is what the spec came for \u2014 the spy holds one method of an object whose other half has to keep working, or the token cannot be substituted at all, as `DestroyRef` cannot (it carries `__NG_ENV_ID__`, so `R3Injector.get()` answers before it reads its own providers and `{ provide: DestroyRef, useValue }` is silently ignored) \u2014 that token belongs in `{ ignoreTokens: [...] }`, which is a statement about the token and survives the next edit, rather than behind a per-line disable."
   },
   create: (context) => ({
     'CallExpression[callee.object.name="vi"][callee.property.name="spyOn"]': (node) => {
@@ -3017,7 +3035,7 @@ var preferInjectSpy = defineRule({
         return;
       }
       const injectCall = isTestBedInject(target) ? target : injectedFromVariable(context, target);
-      if (!injectCall) {
+      if (!injectCall || keepsTheRealInstance(context, injectCall)) {
         return;
       }
       const suggestion = injectSpySuggestion(context, node, injectCall);

package/dist/index.js

@@ -1502,7 +1502,12 @@ function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn, reads) {
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }
@@ -1887,6 +1892,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -1903,7 +1914,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }

package/dist/jasmine.js

@@ -1,7 +1,7 @@
 import { useVitestAdapter } from './chunk-PA4ZNLNZ.js';
 import { enableJasmineCompat } from './chunk-MAKQSO2R.js';
 export { enableJasmineCompat } from './chunk-MAKQSO2R.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/nestjs.js

@@ -1,6 +1,6 @@
-import { createSpyForToken } from './chunk-RPEYIZPL.js';
-export { trackInjections } from './chunk-RPEYIZPL.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
+import { createSpyForToken } from './chunk-DUFMKOKF.js';
+export { trackInjections } from './chunk-DUFMKOKF.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/node.cjs

@@ -1222,7 +1222,12 @@ var DISPOSE = installDisposeSymbol(Symbol);
 function createProxyPropStore(seed) {
   const store = { values: /* @__PURE__ */ new Map(), accessors: /* @__PURE__ */ new Map(), deleted: /* @__PURE__ */ new Set() };
   for (const key of Reflect.ownKeys(seed)) {
-    store.values.set(key, Reflect.get(seed, key));
+    const descriptor = { ...Reflect.getOwnPropertyDescriptor(seed, key) };
+    if ((descriptor.get ?? descriptor.set) !== void 0) {
+      store.accessors.set(key, descriptor);
+      continue;
+    }
+    store.values.set(key, descriptor.value);
   }
   return store;
 }
@@ -1609,6 +1614,12 @@ function baseList(base) {
 function baseObject(base) {
   return isMergeable(base) ? base : {};
 }
+function mergeObjects(base, written) {
+  const merged = {};
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(base));
+  Object.defineProperties(merged, Object.getOwnPropertyDescriptors(written));
+  return merged;
+}
 function mergeAutoSpyDefaults(ObjectClass, local) {
   const defaults = registry().get(ObjectClass);
   if (!defaults) {
@@ -1625,7 +1636,7 @@ function mergeInto(defaults, written) {
     if (Array.isArray(value)) {
       merged[key] = [.../* @__PURE__ */ new Set([...baseList(base), ...value])];
     } else if (isMergeable(value)) {
-      merged[key] = { ...baseObject(base), ...value };
+      merged[key] = mergeObjects(baseObject(base), value);
     } else {
       merged[key] = value;
     }

package/dist/node.js

@@ -1,6 +1,6 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { guardAccessorSpies, createRedefineMockAdapter } from './chunk-DTZCPCMA.js';
 import './chunk-PC3FAZT3.js';

package/dist/react.js

@@ -1,6 +1,6 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/rstest.js

@@ -1,6 +1,6 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-33NJHIS2.js';
 import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-DTZCPCMA.js';

package/dist/svelte.js

@@ -1,6 +1,6 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/dist/vue.js

@@ -1,7 +1,7 @@
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-ADBB2HQG.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5XLI5JYC.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-N3T7KWWA.js';
-import { createSpyFromClass } from './chunk-BWT7U4V4.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BWT7U4V4.js';
+import { createSpyFromClass } from './chunk-WAMFS3UI.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-WAMFS3UI.js';
 import './chunk-OS4PTU6D.js';
 import { vitestMockAdapter } from './chunk-ZU55UY2M.js';
 import './chunk-33NJHIS2.js';

package/package.json

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