feat(@schematics/angular): stabilize refactor-jasmine-vitest schematic

hawkgs · hawkgs · commit 5e3676ab2777 · 2026-03-24T12:58:40.000+02:00
Stabilize `refactor-jasmine-vitest` schematic by covering the known remaining test patterns and cases.
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.integration_spec.ts b/packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.integration_spec.ts
@@ -288,8 +288,8 @@ describe('Jasmine to Vitest Transformer - Integration Tests', () => {
         });
 
         it('should handle spy call order', () => {
-          const spyA = vi.fn();
-          const spyB = vi.fn();
+          const spyA = vi.fn().mockName('spyA');
+          const spyB = vi.fn().mockName('spyB');
           spyA();
           spyB();
           expect(Math.min(...vi.mocked(spyA).mock.invocationCallOrder)).toBeLessThan(Math.min(...vi.mocked(spyB).mock.invocationCallOrder));
@@ -387,7 +387,7 @@ describe('Jasmine to Vitest Transformer - Integration Tests', () => {
         });
 
         it('should handle spies throwing errors', () => {
-          const spy = vi.fn().mockImplementation(() => { throw new Error('Test Error') });
+          const spy = vi.fn().mockName('mySpy').mockImplementation(() => { throw new Error('Test Error') });
           expect(() => spy()).toThrowError('Test Error');
         });
       });
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.ts b/packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.ts
@@ -40,6 +40,7 @@ import {
   transformUnsupportedJasmineCalls,
 } from './transformers/jasmine-misc';
 import {
+  transformCreateSpy,
   transformCreateSpyObj,
   transformSpies,
   transformSpyCallInspection,
@@ -116,6 +117,7 @@ const callExpressionTransformers = [
   transformSyntacticSugarMatchers,
   transformComplexMatchers,
   transformSpies,
+  transformCreateSpy,
   transformCreateSpyObj,
   transformSpyReset,
   transformSpyCallInspection,
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-misc.ts b/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-misc.ts
@@ -52,6 +52,20 @@ export function transformTimerMocks(
     case 'mockDate':
       newMethodName = 'setSystemTime';
       break;
+    case 'autoTick': {
+      const category = 'clockAutoTick';
+      reporter.recordTodo(category, sourceFile, node);
+      addTodoComment(node, category);
+
+      return node;
+    }
+    case 'withMock': {
+      const category = 'clockWithMock';
+      reporter.recordTodo(category, sourceFile, node);
+      addTodoComment(node, category);
+
+      return node;
+    }
   }
 
   if (newMethodName) {
@@ -85,15 +99,21 @@ export function transformFail(node: ts.Node, { sourceFile, reporter }: RefactorC
     node.expression.expression.text === 'fail'
   ) {
     reporter.reportTransformation(sourceFile, node, 'Transformed `fail()` to `throw new Error()`.');
-    const reason = node.expression.arguments[0];
 
-    const replacement = ts.factory.createThrowStatement(
-      ts.factory.createNewExpression(
+    const arg = node.expression.arguments[0];
+    let throwExpression: ts.Expression;
+
+    if (arg && ts.isNewExpression(arg)) {
+      throwExpression = arg;
+    } else {
+      throwExpression = ts.factory.createNewExpression(
         ts.factory.createIdentifier('Error'),
         undefined,
-        reason ? [reason] : [],
-      ),
-    );
+        arg ? [arg] : [],
+      );
+    }
+
+    const replacement = ts.factory.createThrowStatement(throwExpression);
 
     return ts.setOriginalNode(ts.setTextRange(replacement, node), node);
   }
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-misc_spec.ts b/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-misc_spec.ts
@@ -35,6 +35,18 @@ describe('Jasmine to Vitest Transformer - transformTimerMocks', () => {
       input: `jasmine.clock().mockDate();`,
       expected: `vi.setSystemTime(new Date());`,
     },
+    {
+      description: 'should add a TODO for jasmine.clock().autoTick()',
+      input: 'jasmine.clock().autoTick();',
+      expected: `// TODO: vitest-migration: Vitest does not have a direct equivalent for jasmine.clock().autoTick(). Please migrate this manually. See: https://vitest.dev/api/vi.html#fake-timers
+jasmine.clock().autoTick();`,
+    },
+    {
+      description: 'should add a TODO for jasmine.clock().withMock()',
+      input: 'jasmine.clock().withMock(noop);',
+      expected: `// TODO: vitest-migration: Vitest does not have a direct equivalent for jasmine.clock().withMock(). Please migrate this manually via vi.useFakeTimers() and vi.useRealTimers(). See: https://vitest.dev/api/vi.html#vi-usefaketimers
+jasmine.clock().withMock(noop);`,
+    },
   ];
 
   testCases.forEach(({ description, input, expected }) => {
@@ -56,6 +68,11 @@ describe('transformFail', () => {
       input: `fail();`,
       expected: `throw new Error();`,
     },
+    {
+      description: 'should transform fail() with an Error object',
+      input: `fail(new TypeError('Invalid input'));`,
+      expected: `throw new TypeError('Invalid input');`,
+    },
   ];
 
   testCases.forEach(({ description, input, expected }) => {
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-spy.ts b/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-spy.ts
@@ -151,6 +151,16 @@ export function transformSpies(node: ts.Node, refactorCtx: RefactorContext): ts.
 
             return ts.factory.createCallExpression(newExpression, undefined, [arrowFunction]);
           }
+          case 'identity': {
+            reporter.reportTransformation(
+              sourceFile,
+              node,
+              'Transformed `.and.identity()` to `.getMockName()`.',
+            );
+            const newExpression = createPropertyAccess(spyCall, 'getMockName');
+
+            return ts.factory.createCallExpression(newExpression, undefined, undefined);
+          }
           default: {
             const category = 'unsupported-spy-strategy';
             reporter.recordTodo(category, sourceFile, node);
@@ -183,35 +193,54 @@ export function transformSpies(node: ts.Node, refactorCtx: RefactorContext): ts.
     }
   }
 
-  const jasmineMethodName = getJasmineMethodName(node);
-  switch (jasmineMethodName) {
-    case 'createSpy':
-      addVitestValueImport(pendingVitestValueImports, 'vi');
-      reporter.reportTransformation(
-        sourceFile,
-        node,
-        'Transformed `jasmine.createSpy()` to `vi.fn()`.',
-      );
-
-      // jasmine.createSpy(name, originalFn) -> vi.fn(originalFn)
-      return createViCallExpression('fn', node.arguments.length > 1 ? [node.arguments[1]] : []);
-    case 'spyOnAllFunctions': {
-      reporter.reportTransformation(
-        sourceFile,
-        node,
-        'Found unsupported `jasmine.spyOnAllFunctions()`.',
-      );
-      const category = 'spyOnAllFunctions';
-      reporter.recordTodo(category, sourceFile, node);
-      addTodoComment(node, category);
+  if (getJasmineMethodName(node) === 'spyOnAllFunctions') {
+    reporter.reportTransformation(
+      sourceFile,
+      node,
+      'Found unsupported `jasmine.spyOnAllFunctions()`.',
+    );
+    const category = 'spyOnAllFunctions';
+    reporter.recordTodo(category, sourceFile, node);
+    addTodoComment(node, category);
 
-      return node;
-    }
+    return node;
   }
 
   return node;
 }
 
+export function transformCreateSpy(
+  node: ts.Node,
+  { reporter, sourceFile, pendingVitestValueImports }: RefactorContext,
+): ts.Node {
+  if (!isJasmineCallExpression(node, 'createSpy')) {
+    return node;
+  }
+
+  addVitestValueImport(pendingVitestValueImports, 'vi');
+  reporter.reportTransformation(
+    sourceFile,
+    node,
+    'Transformed `jasmine.createSpy()` to `vi.fn()`.',
+  );
+
+  const spyName = node.arguments[0];
+  const viFnCallExpression = createViCallExpression(
+    'fn',
+    node.arguments.length > 1 ? [node.arguments[1]] : [],
+  );
+
+  // jasmine.createSpy() -> vi.fn()
+  // jasmine.createSpy(name, originalFn) -> vi.fn(originalFn).mockName(name)
+  return !spyName
+    ? viFnCallExpression
+    : ts.factory.createCallExpression(
+        createPropertyAccess(viFnCallExpression, 'mockName'),
+        undefined,
+        [node.arguments[0]],
+      );
+}
+
 export function transformCreateSpyObj(
   node: ts.Node,
   { sourceFile, reporter, pendingVitestValueImports }: RefactorContext,
@@ -428,12 +457,56 @@ function transformMostRecentArgs(
   return createPropertyAccess(mockProperty, 'lastCall');
 }
 
+function transformThisFor(
+  node: ts.Node,
+  { sourceFile, reporter, pendingVitestValueImports }: RefactorContext,
+): ts.Node {
+  // Check 1: Is the node is a call expression?
+  if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
+    return node;
+  }
+
+  // Check 2: Is it a call to `.thisFor`?
+  const thisForPae = node.expression;
+  if (
+    !ts.isIdentifier(thisForPae.name) ||
+    thisForPae.name.text !== 'thisFor' ||
+    !ts.isPropertyAccessExpression(thisForPae.expression)
+  ) {
+    return node;
+  }
+
+  // Check 3: Can we get the spy identifier from `spy.calls`?
+  const spyIdentifier = getSpyIdentifierFromCalls(thisForPae.expression);
+  if (!spyIdentifier) {
+    return node;
+  }
+
+  // If all checks pass, perform the transformation.
+  reporter.reportTransformation(
+    sourceFile,
+    node,
+    'Transformed `spy.calls.thisFor(index)` to `vi.mocked(spy).mock.contexts[index]`.',
+  );
+  const mockProperty = createMockedSpyMockProperty(spyIdentifier, pendingVitestValueImports);
+
+  return ts.factory.createElementAccessExpression(
+    createPropertyAccess(mockProperty, 'contexts'),
+    node.arguments[0] ?? 0,
+  );
+}
+
 export function transformSpyCallInspection(node: ts.Node, refactorCtx: RefactorContext): ts.Node {
   const mostRecentArgsTransformed = transformMostRecentArgs(node, refactorCtx);
   if (mostRecentArgsTransformed !== node) {
     return mostRecentArgsTransformed;
   }
 
+  const thisForTransformed = transformThisFor(node, refactorCtx);
+  if (thisForTransformed !== node) {
+    return thisForTransformed;
+  }
+
   if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
     return node;
   }
@@ -479,6 +552,13 @@ export function transformSpyCallInspection(node: ts.Node, refactorCtx: RefactorC
         message = 'Transformed `spy.calls.argsFor()` to `mock.calls[i]`.';
         newExpression = ts.factory.createElementAccessExpression(callsProperty, node.arguments[0]);
         break;
+      case 'saveArgumentsByValue':
+        {
+          const category = 'saveArgumentsByValue';
+          reporter.recordTodo(category, sourceFile, node);
+          addTodoComment(node, category);
+        }
+        break;
       case 'mostRecent':
         if (
           !ts.isPropertyAccessExpression(node.parent) ||
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-spy_spec.ts b/packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-spy_spec.ts
@@ -36,14 +36,14 @@ describe('Jasmine to Vitest Transformer - transformSpies', () => {
       expected: `vi.spyOn(service, 'myMethod');`,
     },
     {
-      description: 'should transform jasmine.createSpy("name") to vi.fn()',
+      description: 'should transform jasmine.createSpy("name") to vi.fn().mockName("name")',
       input: `const mySpy = jasmine.createSpy('mySpy');`,
-      expected: `const mySpy = vi.fn();`,
+      expected: `const mySpy = vi.fn().mockName('mySpy');`,
     },
     {
-      description: 'should transform jasmine.createSpy("name", fn) to vi.fn(fn)',
+      description: 'should transform jasmine.createSpy("name", fn) to vi.fn(fn).mockName("name")',
       input: `const mySpy = jasmine.createSpy('mySpy', () => 'foo');`,
-      expected: `const mySpy = vi.fn(() => 'foo');`,
+      expected: `const mySpy = vi.fn(() => 'foo').mockName('mySpy');`,
     },
     {
       description: 'should transform spyOnProperty(object, "prop") to vi.spyOn(object, "prop")',
@@ -65,7 +65,7 @@ describe('Jasmine to Vitest Transformer - transformSpies', () => {
     {
       description: 'should handle chained calls on jasmine.createSpy()',
       input: `const mySpy = jasmine.createSpy('mySpy').and.returnValue(true);`,
-      expected: `const mySpy = vi.fn().mockReturnValue(true);`,
+      expected: `const mySpy = vi.fn().mockName('mySpy').mockReturnValue(true);`,
     },
     {
       description: 'should handle .and.returnValues() with no arguments',
@@ -94,6 +94,11 @@ describe('Jasmine to Vitest Transformer - transformSpies', () => {
       input: `spyOn(service, 'myMethod').and.rejectWith('some error');`,
       expected: `vi.spyOn(service, 'myMethod').mockRejectedValue('some error');`,
     },
+    {
+      description: 'should transform .and.identity() to .getMockName()',
+      input: `spyOn(service, 'myMethod').and.identity();`,
+      expected: `vi.spyOn(service, 'myMethod').getMockName();`,
+    },
     {
       description: 'should add a TODO for an unsupported spy strategy',
       input: `spyOn(service, 'myMethod').and.unknownStrategy();`,
@@ -258,6 +263,11 @@ describe('transformSpyCallInspection', () => {
       input: `const recentArgs = mySpy.calls.mostRecent().args;`,
       expected: `const recentArgs = vi.mocked(mySpy).mock.lastCall;`,
     },
+    {
+      description: 'should transform spy.calls.thisFor(index)',
+      input: `const context = mySpy.calls.thisFor(1337);`,
+      expected: `const context = vi.mocked(mySpy).mock.contexts[1337];`,
+    },
     {
       description: 'should transform spy.calls.first()',
       input: `const firstCall = mySpy.calls.first();`,
@@ -269,6 +279,14 @@ describe('transformSpyCallInspection', () => {
       expected: `// TODO: vitest-migration: Direct usage of mostRecent() is not supported. Please refactor to access .args directly or use vi.mocked(spy).mock.lastCall. See: https://vitest.dev/api/mocked.html#mock-lastcall
 const mostRecent = mySpy.calls.mostRecent();`,
     },
+    {
+      description: 'should add a TODO for spy.calls.saveArgumentsByValue()',
+      input: `const saveArgs = mySpy.calls.saveArgumentsByValue();`,
+      expected:
+        '// TODO: vitest-migration: Vitest does not have a direct equivalent for spy.calls.saveArgumentsByValue().' +
+        ' Please migrate this manually by cloning and storing the arguments in a local variable.' +
+        '\nconst saveArgs = mySpy.calls.saveArgumentsByValue();',
+    },
   ];
 
   testCases.forEach(({ description, input, expected }) => {
diff --git a/packages/schematics/angular/refactor/jasmine-vitest/utils/todo-notes.ts b/packages/schematics/angular/refactor/jasmine-vitest/utils/todo-notes.ts
@@ -124,6 +124,23 @@ export const TODO_NOTES = {
       ' Please refactor to access .args directly or use vi.mocked(spy).mock.lastCall.',
     url: 'https://vitest.dev/api/mocked.html#mock-lastcall',
   },
+  'saveArgumentsByValue': {
+    message:
+      'Vitest does not have a direct equivalent for spy.calls.saveArgumentsByValue().' +
+      ' Please migrate this manually by cloning and storing the arguments in a local variable.',
+  },
+  'clockAutoTick': {
+    message:
+      'Vitest does not have a direct equivalent for jasmine.clock().autoTick(). Please migrate this manually.',
+    url: 'https://vitest.dev/api/vi.html#fake-timers',
+  },
+  'clockWithMock': {
+    message:
+      'Vitest does not have a direct equivalent for jasmine.clock().withMock().' +
+      ' Please migrate this manually via vi.useFakeTimers() and vi.useRealTimers().',
+    url: 'https://vitest.dev/api/vi.html#vi-usefaketimers',
+  },
+
   'unhandled-done-usage': {
     message: "The 'done' callback was used in an unhandled way. Please migrate manually.",
   },
