vitest-auto-spy 5.60.0 → 5.62.0

package/AGENTS.md

@@ -455,6 +455,7 @@ In [`agent-docs/doubles.md`](./agent-docs/doubles.md). Read it when production c
 ## 13. Angular
 
 In [`agent-docs/angular.md`](./agent-docs/angular.md). Read it for any spec that uses `TestBed`, signals, Angular HTTP, the router or an Angular double.
+For selected void window methods, use `createWindowSpies` from `/angular/doubles`; the window recipe is in that file.
 
 <!-- agents-outline: agent-docs/angular.md -->
 

package/CHANGELOG.md

@@ -10,6 +10,21 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.62.0] - 2026-10-20
+
+### Fixed
+
+- **`prefer-settle-dynamic-import` recognises Angular provider setup in setup hooks.** A namespace
+  loaded for providers is allowed after logger or fixture preparation. Imports after application
+  actions remain checked. The English and Russian rule guides distinguish provider loading from
+  waiting for handlers, and clarify that `Promise.resolve()` does not take an event-loop turn.
+
+## [5.61.0] - 2026-10-07
+
+### Added
+
+- `createWindowSpies` in `/angular/doubles`: typed, configured no-op spies for selected void window methods, including `location.reload` and `parent.postMessage`, composable with existing window overrides.
+
 ## [5.60.0] - 2026-10-06
 
 ### Added
@@ -6841,7 +6856,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.60.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.62.0...HEAD
+[5.62.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.61.0...v5.62.0
+[5.61.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.60.0...v5.61.0
 [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

package/README.md

@@ -3125,6 +3125,7 @@ only the ones you need. Every helper, with its signature: [API](https://asdalexe
 | `provideLocationDouble()` / `injectLocationDouble()` / `createLocationDouble()`                             | `/angular-router`             | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` / `simulateHashChange()` for the browser's half of the contract; `Location` is `providedIn: 'root'`, so a spec that forgets the provider silently drives the platform's real one                                                                        |
 | `createForm(model, schema?)` / `registerFormMatchers()`                                                     | `/signal-forms`               | A signal form built where `form()` can inject, and `expect(field).toHaveFieldErrors(['required'])` over what it produced                                                                                                                                                                                                                                                                  |
 | `provideWindowDouble(TOKEN, over?)` / `provideDocumentDouble(over?)`                                        | `/angular/doubles`            | A `window` / `document` merged **over** the real jsdom one, so members the spec never named still answer; the globals stay untouched                                                                                                                                                                                                                                                      |
+| `createWindowSpies(selection)`                                                                              | `/angular/doubles`            | Typed no-op spies for selected void window methods: `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })`; pass them as window overrides.                                                                                                                                                                                                                                |
 | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(Ref, init?)`                                     | `/angular/doubles`            | The Material dialog trio without `@angular/material` as a dependency — the token and the ref class are arguments, `afterClosed()` still answers after the close                                                                                                                                                                                                                           |
 | `providePlatform(platform, flags?)`                                                                         | `/angular/doubles`            | `PLATFORM_ID` plus the app's own `isBrowser` / `isServer` tokens, always agreeing                                                                                                                                                                                                                                                                                                         |
 | `provideDomSanitizerDouble()` / `provideChangeDetectorRefDouble()`                                          | `/angular/doubles`            | A `DomSanitizer` whose bypass spies return Angular's real safe values; a `ChangeDetectorRef` of four spies answering `undefined` (`create…Double()` for the bare double)                                                                                                                                                                                                                  |

package/agent-docs/angular.md

@@ -862,6 +862,32 @@ Five things to know:
   `win.Promise.resolve()`, `win.Object.keys(x)` and `new win.Event('x')` work, and
   `win.Event === window.Event` holds — which is what `instanceof` in production code needs.
 
+`createWindowSpies` creates typed spies for selected `void` methods, including nested window members.
+The spies return `undefined` without invoking browser methods.
+
+```ts
+import { InjectionToken } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { expect } from 'vitest';
+import { createWindowSpies, provideWindowDouble } from 'vitest-auto-spy/angular/doubles';
+
+const WINDOW = new InjectionToken<Window>('WINDOW');
+const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+TestBed.configureTestingModule({
+  providers: [provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } })],
+});
+const win = TestBed.inject(WINDOW);
+win.location.reload();
+win.parent.postMessage('ready', '*');
+expect(spies.location.reload).toHaveBeenCalledOnce();
+expect(spies.parent.postMessage).toHaveBeenCalledWith('ready', '*');
+```
+
+Pass an array for root methods: `createWindowSpies(['close', 'focus'])`. Each call builds fresh spies.
+The object returned by `createWindowSpies` contains only the selected methods. Their parameter types and spy helpers are preserved.
+For methods that return a value, use `createFunctionSpy` and configure that value explicitly.
+When adding location values, spread `spies.location` too; replacing it would discard the reload spy.
+
 ### The Material dialog trio — `provideMatDialogData` / `provideMatDialogRef`
 
 ```ts

package/agent-docs/waiting.md

@@ -22,6 +22,17 @@ fixture.debugElement.query(By.css('.open')).nativeElement.click(); // production
 await settleDynamicImport(() => import('./profile-select.modal'));
 ```
 
+**Loading provider classes is setup, not a wait for application work.** Keep
+`const { PremiumService } = await import('./premium.service')` when its exports configure Angular
+providers before creating the service under test. `settleDynamicImport` is useful after an action
+starts a lazy import; it adds no needed wait merely to read provider classes. Preserve dynamic
+imports when module evaluation order matters, including `vi.resetModules()` / `vi.doMock()` setup.
+The ESLint rule recognises provider setup in `beforeEach` / `beforeAll`. Earlier fixture factories
+must be imported functions whose bound results also supply providers. Member calls and other
+actions prevent this exemption, except recognised module-registry resets.
+
+`await Promise.resolve()` yields to microtasks; it is not equivalent to `flushEventLoop(1)`.
+
 Three rules worth stating outright, because each of them cost a day somewhere:
 
 - **`afterNextRender` does not run on `detectChanges()`.** A component that fills a form there is
@@ -30,9 +41,8 @@ Three rules worth stating outright, because each of them cost a day somewhere:
 - **`fixture.whenRenderingDone()` is not a stronger `whenStable()`.** With an animation renderer
   installed it degrades to `Promise.resolve()`. Use `stable(fixture)`.
 - **`fakeAsync` / `tick()` / `flushMicrotasks()` never reach the module loader.** Spinning
-  `await Promise.resolve()` ten times looks like it works and instead lands the continuation after
-  teardown — a green run with `NG0205: Injector has already been destroyed` in "Unhandled Errors"
-  and a non-zero exit code.
+  `await Promise.resolve()` ten times may leave a continuation until after teardown, causing
+  `NG0205: Injector has already been destroyed` in "Unhandled Errors" and a non-zero exit code.
 
 **`stable()` and `flushEffects()` are not zoneless-only, and their tick runs inside the `NgZone` so
 that they are not.** `TestBed.createComponent` builds the component inside `ngZone.run(…)`, so an

package/dist/angular-doubles.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken, ChangeDetectorRef } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-BdYUK_Zv.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func, p as FunctionSpy } from './types-BdYUK_Zv.js';
 import { DomSanitizer } from '@angular/platform-browser';
 import 'vitest';
 
@@ -183,7 +183,7 @@ declare function injectMatDialogRef<Ref extends DialogRefLike>(RefClass: Abstrac
  */
 
 /** How many levels of slicing the type follows. Beyond it a member takes its whole type. */
-type Levels = [never, 0, 1, 2, 3];
+type Levels$1 = [never, 0, 1, 2, 3];
 /**
  * One member's override: the member's own type, or a slice of it wherever it is a plain-ish object.
  *
@@ -192,7 +192,7 @@ type Levels = [never, 0, 1, 2, 3];
  * array is matched whole too: slicing one by index describes nothing a spec means.
  */
 type PlatformOverride<V, Depth extends number> = V extends (...args: never[]) => unknown ? V : V extends readonly unknown[] ? V : V extends object ? Depth extends 0 ? V : V | {
-    [K in keyof V]?: PlatformOverride<V[K], Levels[Depth]>;
+    [K in keyof V]?: PlatformOverride<V[K], Levels$1[Depth]>;
 } : V;
 /**
  * What a spec says about a platform object: a value per member, and a **slice** wherever the member
@@ -470,4 +470,35 @@ declare function provideOverlayDouble<O extends OverlayLike>(OverlayClass: Abstr
  */
 declare function injectOverlayDouble<O extends OverlayLike>(OverlayClass: AbstractType<O>, injector?: Injector): OverlayDouble<O>;
 
-export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+type Levels = [never, 0, 1, 2, 3];
+type VoidMethodKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: never[]) => infer R ? (R extends void ? K : never) : never;
+}[keyof T];
+/** Select void methods at each object level; only named methods become spies. */
+type WindowSpySelection<T = Window, Depth extends number = 3> = readonly VoidMethodKeys<T>[] | (Depth extends 0 ? never : {
+    [K in keyof T as T[K] extends object ? (T[K] extends (...args: never[]) => unknown ? never : K) : never]?: WindowSpySelection<NonNullable<T[K]>, Levels[Depth]>;
+});
+/** The selected methods, with their original call signatures and the auto-spy helpers. */
+type WindowSpies<T, Selection> = Selection extends readonly (infer K)[] ? {
+    [P in Extract<K, keyof T>]: T[P] extends (...args: never[]) => unknown ? FunctionSpy<T[P]> : never;
+} : {
+    [P in keyof Selection & keyof T]: WindowSpies<NonNullable<T[P]>, Selection[P]>;
+};
+type ValidSelection<T, Selection> = Selection extends readonly unknown[] ? readonly VoidMethodKeys<T>[] : {
+    [K in keyof Selection]: K extends keyof T ? T[K] extends (...args: never[]) => unknown ? never : ValidSelection<NonNullable<T[K]>, Selection[K]> : never;
+};
+/**
+ * Build typed, already configured no-op spies for selected void window methods.
+ *
+ * ```ts
+ * const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+ * provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } });
+ * expect(spies.location.reload).toHaveBeenCalledOnce();
+ * ```
+ *
+ * No global is read or patched. Pass the result to `createWindowDouble` or `provideWindowDouble`;
+ * unnamed members still use the real window. Use `createFunctionSpy` for methods returning values.
+ */
+declare function createWindowSpies<const Selection extends WindowSpySelection>(selection: Selection & ValidSelection<Window, Selection>): WindowSpies<Window, Selection>;
+
+export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, type WindowSpies, type WindowSpySelection, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/angular-doubles.js

@@ -464,7 +464,35 @@ function injectOverlayDouble(OverlayClass, injector) {
   return double;
 }
 
+// src/lib/window-spies.ts
+function buildSpies(selection, path) {
+  const result = {};
+  if (Array.isArray(selection)) {
+    for (const key of selection) {
+      Object.defineProperty(result, key, {
+        value: createFunctionSpy(`${path}.${String(key)}`).mockReturnValue(void 0),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  } else {
+    for (const key of Reflect.ownKeys(selection)) {
+      Object.defineProperty(result, key, {
+        value: buildSpies(Reflect.get(selection, key), `${path}.${String(key)}`),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  return result;
+}
+function createWindowSpies(selection) {
+  return buildSpies(selection, "window");
+}
+
 // src/angular-doubles.ts
 useVitestAdapter();
 
-export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/cli.js

@@ -1667,7 +1667,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.59.1";
+var EXPORT_MAP_VERSION = "5.61.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",
@@ -1800,6 +1800,7 @@ var EXPORTED_BY = {
   createSpyFromInstance: "0 1 2 3 4 20 21 22",
   createSpyObj: "9",
   createWindowDouble: "14",
+  createWindowSpies: "14",
   createWithAutoSpies: "2 12",
   CreateWithAutoSpiesOptions: "2 12",
   DeepMockProxy: "0 1 2 3 4 20 21 22",
@@ -2158,6 +2159,8 @@ var EXPORTED_BY = {
   WebStorageKey: "7",
   WebStorageStub: "7",
   WebStorageStubOptions: "7",
+  WindowSpies: "14",
+  WindowSpySelection: "14",
   withFakeTimers: "23",
   WithMockReturnValue: "0 1 2 3 4 20 21 22",
   withoutStrayTimerTracking: "23",

package/dist/eslint-plugin.cjs

@@ -480,13 +480,13 @@ function runnerBehind(callee) {
   }
   return isCallExpression(callee) ? runnerBehind(callee.callee) : void 0;
 }
-function insideRunnerCallback(node) {
+function enclosingRunner(node) {
   const callback = enclosingFunction(node);
   if (!callback) {
-    return false;
+    return void 0;
   }
   const call = callback.parent;
-  return isCallExpression(call) && call.arguments.includes(callback) && runnerBehind(call.callee) !== void 0;
+  return isCallExpression(call) && call.arguments.includes(callback) ? runnerBehind(call.callee) : void 0;
 }
 function consumptionOf(node) {
   const { parent } = node;
@@ -518,6 +518,74 @@ function takesTheNamespaceFirst(node, bound) {
   const before2 = siblings2.slice(0, siblings2.indexOf(statement)).reverse().find((sibling) => !bound.has(sibling));
   return before2 === void 0 ? statement.parent === callback.body : resetsRegistry(before2);
 }
+function providerReference(context, reference, callback) {
+  if (enclosingFunction(reference) !== callback) {
+    return false;
+  }
+  let current = reference;
+  while (current !== callback) {
+    if (propertyName(current) === "providers") {
+      const configuration = current.parent;
+      const call = configuration.parent;
+      if (!isCallExpression(call) || !call.arguments.includes(configuration)) {
+        return false;
+      }
+      if (!isMemberExpression(call.callee) || memberName(call.callee) !== "configureTestingModule" || !isIdentifier(call.callee.object)) {
+        return false;
+      }
+      const receiver = call.callee.object;
+      const binding = findBinding(context.sourceCode.getScope(receiver), receiver.name);
+      const specifier = binding && importSpecifierOf(binding);
+      return specifier ? isIdentifier(specifier.imported) && specifier.imported.name === "TestBed" && specifier.parent.source.value === "@angular/core/testing" : binding === void 0 && receiver.name === "TestBed";
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function suppliesProvider(context, awaited, callback) {
+  const holder = awaited.parent;
+  const pattern = isVariableDeclarator(holder) ? holder.id : isAssignmentExpression(holder) ? holder.left : void 0;
+  return pattern !== void 0 && anyInSubtree(
+    context,
+    pattern,
+    (candidate) => {
+      if (!isIdentifier(candidate)) {
+        return false;
+      }
+      const binding = findBinding(context.sourceCode.getScope(candidate), candidate.name);
+      const writes = binding?.references.filter((reference) => reference.writeExpr) ?? [];
+      return writes.length === 1 && writes[0]?.writeExpr === awaited && binding?.references.some(
+        (reference) => reference.identifier.range[0] > awaited.range[1] && providerReference(context, reference.identifier, callback)
+      ) === true;
+    },
+    false
+  );
+}
+function preparesProvider(context, call, callback) {
+  if (!isCallExpression(call) || !isIdentifier(call.callee)) {
+    return false;
+  }
+  const binding = findBinding(context.sourceCode.getScope(call), call.callee.name);
+  return binding?.defs.some((definition) => definition.type === "ImportBinding") === true && suppliesProvider(context, call, callback);
+}
+function loadsProviderForSetup(context, node, runner) {
+  const callback = enclosingFunction(node);
+  const statement = bindingStatement(node.parent);
+  if (!callback || statement?.parent !== callback.body || !isBlockStatement(callback.body)) {
+    return false;
+  }
+  if (runner !== "beforeAll" && runner !== "beforeEach" || !suppliesProvider(context, node.parent, callback)) {
+    return false;
+  }
+  return callback.body.body.slice(0, callback.body.body.indexOf(statement)).every(
+    (before2) => (before2.type === "VariableDeclaration" || isExpressionStatement(before2)) && !anyInSubtree(
+      context,
+      before2,
+      (candidate) => isAssignmentExpression(candidate) && !isIdentifier(candidate.left) || candidate.type === "UnaryExpression" && Reflect.get(candidate, "operator") === "delete" || (isCallExpression(candidate) || candidate.type === "NewExpression" || candidate.type === "AwaitExpression" || candidate.type === "UpdateExpression") && !preparesProvider(context, candidate, callback) && !(candidate.type === "AwaitExpression" && suppliesProvider(context, candidate, callback) && anyInSubtree(context, candidate, (child) => child.type === "ImportExpression" && child.parent === candidate, false)) && !isRunnerCall(candidate, REGISTRY_RESETS),
+      false
+    )
+  );
+}
 function wrap(context, node) {
   const state = bindingState(context.sourceCode.getScope(node), HELPER);
   if (state === "taken") {
@@ -540,7 +608,7 @@ var preferSettleDynamicImport = defineRule({
   description: "Load a module the code under test lazy-loads with settleDynamicImport(), not a bare await import()",
   hasSuggestions: true,
   messages: {
-    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` has not run yet, so the assertions below read the state one turn early. ${REPAIR}`,
+    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` may still be pending, so the assertions below may read state too early. ${REPAIR}`,
     thenedDynamicImport: `\`{{load}}.then(\u2026)\` waits for the module, not for the code under test that was loading it, and its callback runs later still, after the test ends if nothing awaits it. ${REPAIR}`
   },
   create: (context) => {
@@ -548,7 +616,8 @@ var preferSettleDynamicImport = defineRule({
     return {
       ImportExpression: (node) => {
         const consumption = consumptionOf(node);
-        if (consumption === void 0 || !insideRunnerCallback(node) || consumption === "await" && takesTheNamespaceFirst(node, bound)) {
+        const runner = enclosingRunner(node);
+        if (consumption === void 0 || runner === void 0 || consumption === "await" && (takesTheNamespaceFirst(node, bound) || loadsProviderForSetup(context, node, runner))) {
           return;
         }
         const messageId = consumption === "await" ? "awaitedDynamicImport" : "thenedDynamicImport";

package/package.json

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

@@ -1,6 +1,6 @@
 ---
 name: vitest-auto-spy
-description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy or a subpath (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
+description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, createWindowSpies, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
 ---
 
 # vitest-auto-spy
@@ -329,11 +329,17 @@ it('loads', async () => {
 | a component that reads `location.back()`, or asserts where a redirect landed                               | `provideLocationDouble()` + `injectLocationDouble()` — Angular's own `SpyLocation`; without the provider, `Location` is `providedIn: 'root'` and the real one answers                                                                                                                                                                                     |
 | "did A run before B?" across three collaborators                                                           | `createLog<'drop-cache' \| 'flush'>()` — hand `log.fn('drop-cache')` to each, assert `log.result()` once                                                                                                                                                                                                                                                  |
 | a `window` or `document` behind a DI token                                                                 | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })` — `/angular/doubles`                                                                                                                                                                                                                                                           |
+| selected void window methods, such as `location.reload` or `parent.postMessage`                            | `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })` from `/angular/doubles` — pass the result to `provideWindowDouble(WINDOW, spies)`; each spy returns `undefined` without calling the browser. For root methods, use `createWindowSpies(['close', 'focus'])`.                                                                        |
 | `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                                      | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)` — `/angular/doubles`                                                                                                                                                                                                                                |
 | asserting a `computed()` did **not** recompute                                                             | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                                                                                                                                                                                                                                                 |
 | `form()` in a spec, or `errors()` read by hand                                                             | `createForm(model, schema)` + `registerFormMatchers()` — then `toHaveFieldErrors([…])` (`/signal-forms`)                                                                                                                                                                                                                                                  |
 | any of those doubles without a `TestBed`                                                                   | `createRouterDouble` (`/angular-router`) / `createWindowDouble` / `createDocumentDouble` / `createMatDialogRef` (`/angular/doubles`)                                                                                                                                                                                                                      |
 
+When composing window spies with data overrides, keep the nested spies too:
+`provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'example.test' } })`.
+Assert calls on `spies.location.reload` or `spies.parent.postMessage`. For methods returning a value,
+use `createFunctionSpy` from the core and configure that value explicitly.
+
 ## Rules that prevent most of the mistakes
 
 - Declare the variable as **`Spy<T>`, never as `T`** — `Spy<T>` is a mapped type and drops private