feat(@schematics/angular): do not transform flush & tick if used outside fakeAsync

Author: yjaaidi

packages/schematics/angular/refactor/fake-async/index_spec.ts

@@ -68,6 +68,30 @@ it("should work", fakeAsync(() => {
 
     expect(newContent).toContain(`await vi.runAllTimersAsync();`);
   });
+
+  it('should not transform `tick` if not inside `fakeAsync`', async () => {
+    const { transformContent } = await setUp();
+
+    const newContent = await transformContent(`
+it("should work", () => {
+  tick(100);
+}));
+`);
+
+    expect(newContent).toContain(`tick(100);`);
+  });
+
+  it('should not transform `flush` if not inside `fakeAsync`', async () => {
+    const { transformContent } = await setUp();
+
+    const newContent = await transformContent(`
+it("should work", () => {
+  flush();
+}));
+`);
+
+    expect(newContent).toContain(`flush();`);
+  });
 });
 
 async function setUp() {

packages/schematics/angular/refactor/fake-async/refactor-context.ts

@@ -8,10 +8,12 @@
 
 export interface RefactorContext {
   importedVitestIdentifiers: Set<string>;
+  isInsideFakeAsync: boolean;
 }
 
 export function createRefactorContext(): RefactorContext {
   return {
     importedVitestIdentifiers: new Set(),
+    isInsideFakeAsync: false,
   };
 }

packages/schematics/angular/refactor/fake-async/transform-fake-async.ts

@@ -9,7 +9,10 @@
 import ts from '../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
 import { createRefactorContext } from './refactor-context';
 import { transformFlush } from './transformers/flush';
-import { transformSetupFakeTimers } from './transformers/setup-fake-timers';
+import {
+  isFakeAsyncCallExpression,
+  transformSetupFakeTimers,
+} from './transformers/setup-fake-timers';
 import { transformTick } from './transformers/tick';
 
 /**
@@ -31,9 +34,15 @@ export function transformFakeAsync(filePath: string, content: string): string {
   const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
     const visit = (node: ts.Node): ts.Node => {
       if (ts.isCallExpression(node)) {
+        const isFakeAsync = isFakeAsyncCallExpression(node);
+
         for (const transformer of callExpressionTransformers) {
           node = transformer(node, refactorContext);
         }
+
+        if (isFakeAsync) {
+          refactorContext.isInsideFakeAsync = true;
+        }
       }
 
       return ts.visitEachChild(node, visit, context);

packages/schematics/angular/refactor/fake-async/transformers/flush.ts

@@ -1,7 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
 import ts from '../../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { RefactorContext } from '../refactor-context';
 
-export function transformFlush(node: ts.Node): ts.Node {
+export function transformFlush(node: ts.Node, ctx: RefactorContext): ts.Node {
   if (
+    ctx.isInsideFakeAsync &&
     ts.isCallExpression(node) &&
     ts.isIdentifier(node.expression) &&
     node.expression.text === 'flush'

packages/schematics/angular/refactor/fake-async/transformers/setup-fake-timers.ts

@@ -1,27 +1,30 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
 import ts from '../../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
 import { RefactorContext } from '../refactor-context';
 
 export function transformSetupFakeTimers(node: ts.Node, ctx: RefactorContext): ts.Node {
-  if (
-    ts.isCallExpression(node) &&
-    ts.isIdentifier(node.expression) &&
-    node.expression.text === 'fakeAsync' &&
-    node.arguments.length >= 1 &&
-    (ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]))
-  ) {
+  if (isFakeAsyncCallExpression(node)) {
     ctx.importedVitestIdentifiers.add('onTestFinished');
     ctx.importedVitestIdentifiers.add('vi');
+    ctx.isInsideFakeAsync = true;
 
     const callback = node.arguments[0];
     const callbackBody = ts.isBlock(callback.body)
       ? callback.body
       : ts.factory.createBlock([ts.factory.createExpressionStatement(callback.body)]);
 
     // Generate the following code:
-    // vi.useFakeTimers();
-    // onTestFinished(() => {
-    //   vi.useRealTimers();
-    // });
+    // > vi.useFakeTimers();
+    // > onTestFinished(() => {
+    // >  vi.useRealTimers();
+    // > });
     const setupStatements: ts.Statement[] = [
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
@@ -71,3 +74,16 @@ export function transformSetupFakeTimers(node: ts.Node, ctx: RefactorContext): t
 
   return node;
 }
+
+export function isFakeAsyncCallExpression(node: ts.Node): node is ts.CallExpression & {
+  expression: ts.Identifier;
+  arguments: [ts.ArrowFunction | ts.FunctionExpression];
+} {
+  return (
+    ts.isCallExpression(node) &&
+    ts.isIdentifier(node.expression) &&
+    node.expression.text === 'fakeAsync' &&
+    node.arguments.length >= 1 &&
+    (ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]))
+  );
+}

packages/schematics/angular/refactor/fake-async/transformers/tick.ts

@@ -1,8 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
 import ts from '../../../third_party/github.com/Microsoft/TypeScript/lib/typescript';
 import { RefactorContext } from '../refactor-context';
 
-export function transformTick(node: ts.Node): ts.Node {
+export function transformTick(node: ts.Node, ctx: RefactorContext): ts.Node {
   if (
+    ctx.isInsideFakeAsync &&
     ts.isCallExpression(node) &&
     ts.isIdentifier(node.expression) &&
     node.expression.text === 'tick'