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

Stabilize `refactor-jasmine-vitest` schematic by covering the known remaining test patterns and cases.

Author: hawkgs

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');
         });
       });

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,

packages/schematics/angular/refactor/jasmine-vitest/transformers/jasmine-spy.ts

@@ -183,35 +183,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 +447,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;
   }

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',
@@ -258,6 +258,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();`,