vitest-auto-spy 5.10.0 → 5.10.1

package/AGENTS.md

@@ -2369,11 +2369,17 @@ Five things to know:
   `provideRouter()` is what tests a navigation.
 - **`emitNavigation()` takes what you have** — nothing, a URL string, or an event you built. A
   `NavigationEnd` moves the URL with it; any other event does not.
-- **The navigation in flight follows the events.** `setCurrentNavigation({ extras: { state } })`
-  puts one up and `setCurrentNavigation(null)` ends it; a `NavigationStart` pushed through
-  `emitNavigation()` starts one with that event's id, URL and trigger, and a `NavigationEnd`,
-  `NavigationCancel`, `NavigationError` or `NavigationSkipped` drops it back to `null` — which is
-  what the real router answers to a component reading it while handling a `NavigationEnd`.
+- **The navigation in flight follows the events, and a terminal event ends it _after_ delivering
+  it.** `setCurrentNavigation({ extras: { state } })` puts one up and `setCurrentNavigation(null)`
+  ends it; a `NavigationStart` pushed through `emitNavigation()` starts one with that event's id,
+  URL and trigger, and a `NavigationEnd`, `NavigationCancel`, `NavigationError` or
+  `NavigationSkipped` drops it back to `null` once its subscribers have run. Angular's doc comment
+  — "the current navigation becomes to null after the NavigationEnd event is emitted" — means
+  _after_ literally: the router emits the terminal event from a `tap` with the navigation still in
+  flight and clears it in the `finalize` below, and `events` is a Subject, so a synchronous
+  subscriber runs between the two. **A component that reads `currentNavigation()` while handling a
+  `NavigationEnd` gets the navigation that just finished**, here and in production; it reads `null`
+  only once `navigate()` has resolved. Probed against a real `provideRouter()` on Angular 22.
 - **Ordering does not matter here.** `Router` is `providedIn: 'root'` and `provideRouter()` does not
   re-provide the token, so the double wins in either order — and a `TestBed` without it hands out a
   real router, which is what `injectRouterDouble()` says by name.

package/dist/angular-router.js

@@ -246,22 +246,22 @@ function createUrlState(initial) {
     }
   };
 }
-function followEvent(event, inFlight, navigationOf) {
-  if (event instanceof NavigationStart) {
-    inFlight.set(
-      navigationOf({
-        id: event.id,
-        initialUrl: serializer.parse(event.url),
-        extractedUrl: serializer.parse(event.url),
-        trigger: event.navigationTrigger ?? "imperative"
-      })
-    );
-    return event.id;
-  }
-  if (event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError || event instanceof NavigationSkipped) {
-    inFlight.set(null);
+function startEvent(event, inFlight, navigationOf) {
+  if (!(event instanceof NavigationStart)) {
+    return void 0;
   }
-  return void 0;
+  inFlight.set(
+    navigationOf({
+      id: event.id,
+      initialUrl: serializer.parse(event.url),
+      extractedUrl: serializer.parse(event.url),
+      trigger: event.navigationTrigger ?? "imperative"
+    })
+  );
+  return event.id;
+}
+function endsNavigation(event) {
+  return event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError || event instanceof NavigationSkipped;
 }
 function buildNavigation(state, id, named) {
   return {
@@ -334,8 +334,11 @@ function createRouterDouble(init = {}) {
       if (next instanceof NavigationEnd) {
         state.set(next.urlAfterRedirects);
       }
-      navigationId = followEvent(next, inFlight, navigationOf) ?? navigationId;
+      navigationId = startEvent(next, inFlight, navigationOf) ?? navigationId;
       events.next(next);
+      if (endsNavigation(next)) {
+        inFlight.set(null);
+      }
     }
   };
   doubles2.set(router, double);

package/dist/cli.js

@@ -2453,7 +2453,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.10.0";
+var EXPORT_MAP_VERSION = "5.10.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

@@ -757,14 +757,22 @@ function factoryBody(context, value) {
 }
 var SPY_FACTORIES = /* @__PURE__ */ new Set([
   "autoMocked",
+  "createActivatedRoute",
   "createAutoMock",
+  "createDocumentDouble",
   "createMock",
+  "createRouterDouble",
   "createSpyClass",
   "createSpyFromClass",
+  "createWindowDouble",
   "mockConstructor",
   "mockDeep",
+  "provideActivatedRoute",
   "provideAutoSpy",
-  "provideAutoSpyForToken"
+  "provideAutoSpyForToken",
+  "provideDocumentDouble",
+  "provideRouterDouble",
+  "provideWindowDouble"
 ]);
 function isFactoryCall(node) {
   return isCallExpression(node) && isIdentifier(node.callee) && SPY_FACTORIES.has(node.callee.name);
@@ -2104,6 +2112,46 @@ function testCall(node) {
   }
   return { skipped: SKIPPED_TESTS.has(chain.root) || chain.members.some((member) => SKIPPED_MEMBERS.has(member)) };
 }
+var SUBJECT_BUILDERS = /* @__PURE__ */ new Set(["get", "inject"]);
+function containsCall(node) {
+  let current = node;
+  while (isMemberExpression(current)) {
+    if (isCallExpression(current.object)) {
+      return true;
+    }
+    current = current.object;
+  }
+  return isCallExpression(current);
+}
+function namesSubject(subject, matcher) {
+  if (isIdentifier(subject)) {
+    return true;
+  }
+  if (isMemberExpression(subject)) {
+    return !containsCall(subject);
+  }
+  if (!isCallExpression(subject)) {
+    return false;
+  }
+  if (matcher === "toBeInstanceOf") {
+    return false;
+  }
+  if (isIdentifier(subject.callee)) {
+    return subject.arguments.length === 0;
+  }
+  const [token, ...rest] = subject.arguments;
+  return isMemberExpression(subject.callee) && SUBJECT_BUILDERS.has(memberName(subject.callee) ?? "") && !containsCall(subject.callee.object) && rest.length === 0 && token !== void 0 && (isIdentifier(token) || isMemberExpression(token) && !containsCall(token));
+}
+function subjectReference(subject, context) {
+  if (isIdentifier(subject) || isMemberExpression(subject)) {
+    return context.sourceCode.getText(subject);
+  }
+  let current = subject;
+  while (isCallExpression(current) || isMemberExpression(current)) {
+    current = isCallExpression(current) ? current.callee : current.object;
+  }
+  return isIdentifier(current) ? current.name : void 0;
+}
 function existenceSubject(expression) {
   if (!isCallExpression(expression) || !isMemberExpression(expression.callee)) {
     return void 0;
@@ -2119,7 +2167,10 @@ function existenceSubject(expression) {
     return void 0;
   }
   const [subject] = target.arguments;
-  return subject && (negated ? MISSING.has(matcher) : EXISTS.has(matcher)) ? subject : void 0;
+  if (!subject || !(negated ? MISSING.has(matcher) : EXISTS.has(matcher))) {
+    return void 0;
+  }
+  return namesSubject(subject, matcher) ? subject : void 0;
 }
 function existenceOnly(callback) {
   const body = callback.body;
@@ -2139,6 +2190,14 @@ function removal2(context, statement) {
     return fixer.replaceTextRange([start, statement.range[1]], "");
   };
 }
+function recordName(names, node, context) {
+  const text = context.sourceCode.getText(node);
+  for (let scope = enclosingFunction(node); scope; scope = enclosingFunction(scope.parent)) {
+    const seen = names.get(scope) ?? /* @__PURE__ */ new Set();
+    seen.add(text);
+    names.set(scope, seen);
+  }
+}
 function countNested(blocks) {
   blocks.forEach((block, scope) => {
     let current = scope;
@@ -2146,6 +2205,7 @@ function countNested(blocks) {
       const above = blocks.get(current);
       if (above) {
         above.below += block.proving;
+        above.running.push(...block.running);
       }
       if (current === void 0) {
         return;
@@ -2154,6 +2214,27 @@ function countNested(blocks) {
     }
   });
 }
+function reportBlock(context, block, names) {
+  if (block.below === 0) {
+    return;
+  }
+  const referenced = new Set(block.running.flatMap((callback) => [...names.get(callback) ?? []]));
+  block.smoke.forEach(({ node, subject }) => {
+    const reference = subjectReference(subject, context);
+    if (reference !== void 0 && !referenced.has(reference)) {
+      return;
+    }
+    const data = {
+      siblings: block.below === 1 ? "another test under the same setup already runs against it" : `${block.below} other tests under the same setup already run against it`,
+      subject: context.sourceCode.getText(subject)
+    };
+    const statement = node.parent;
+    const report = { data, messageId: "noRedundantSmokeTest", node };
+    context.report(
+      isExpressionStatement(statement) ? { ...report, suggest: [{ desc: "Remove this test", fix: removal2(context, statement) }] } : report
+    );
+  });
+}
 var noRedundantSmokeTest = defineRule({
   anchor: "-a-promise-a-test-forgets-to-await",
   description: "Delete a test whose whole body asserts that the subject exists, where the block already has tests that use it",
@@ -2163,41 +2244,32 @@ var noRedundantSmokeTest = defineRule({
   },
   create: (context) => {
     const blocks = /* @__PURE__ */ new Map();
+    const names = /* @__PURE__ */ new Map();
     return {
+      Identifier: (node) => recordName(names, node, context),
+      MemberExpression: (node) => recordName(names, node, context),
       CallExpression: (node) => {
         const test = testCall(node);
         if (!test) {
           return;
         }
         const scope = enclosingFunction(node);
-        const block = blocks.get(scope) ?? { below: 0, proving: 0, smoke: [] };
+        const block = blocks.get(scope) ?? { below: 0, proving: 0, running: [], smoke: [] };
         const callback = node.arguments.find(isFunctionNode);
         const subject = callback && existenceOnly(callback);
         if (subject) {
           block.smoke.push({ node, subject });
         } else if (!test.skipped) {
           block.proving += 1;
+          if (callback) {
+            block.running.push(callback);
+          }
         }
         blocks.set(scope, block);
       },
       "Program:exit": () => {
         countNested(blocks);
-        blocks.forEach((block) => {
-          if (block.below === 0) {
-            return;
-          }
-          block.smoke.forEach(({ node, subject }) => {
-            const data = {
-              siblings: block.below === 1 ? "another test under the same setup already runs against it" : `${block.below} other tests under the same setup already run against it`,
-              subject: context.sourceCode.getText(subject)
-            };
-            const statement = node.parent;
-            const report = { data, messageId: "noRedundantSmokeTest", node };
-            context.report(
-              isExpressionStatement(statement) ? { ...report, suggest: [{ desc: "Remove this test", fix: removal2(context, statement) }] } : report
-            );
-          });
-        });
+        blocks.forEach((block) => reportBlock(context, block, names));
       }
     };
   }

package/package.json

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