fix(@schematics/angular): add mock names to createSpyObj transformation

This commit enhances the jasmine-vitest schematic by adding mock names to `vi.fn()` instances created from `jasmine.createSpyObj`. This improves debugging in Vitest by providing meaningful names for mock functions, making test failures easier to understand and trace.

Author: clydin

packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer.integration_spec.ts

@@ -255,14 +255,15 @@ describe('Jasmine to Vitest Transformer - Integration Tests', () => {
       });
     `;
 
+    /* eslint-disable max-len */
     const vitestCode = `
       describe('Complex Scenarios', () => {
         let serviceMock;
 
         beforeEach(() => {
           serviceMock = {
-            getData: vi.fn().mockReturnValue(expect.any(String)),
-            process: vi.fn().mockReturnValue(undefined),
+            getData: vi.fn().mockName("MyService.getData").mockReturnValue(expect.any(String)),
+            process: vi.fn().mockName("MyService.process").mockReturnValue(undefined),
           };
         });
 
@@ -299,6 +300,7 @@ describe('Jasmine to Vitest Transformer - Integration Tests', () => {
         });
       });
     `;
+    /* eslint-enable max-len */
 
     await expectTransformation(jasmineCode, vitestCode);
   });

packages/schematics/angular/refactor/jasmine-vitest/test-file-transformer_spec.ts

@@ -78,7 +78,7 @@ describe('Jasmine to Vitest Transformer', () => {
         input: `const spy = jasmine.createSpyObj('MyService', { getPromise: Promise.resolve(jasmine.any(String)) });`,
         expected: `
           const spy = {
-            getPromise: vi.fn().mockReturnValue(Promise.resolve(expect.any(String))),
+            getPromise: vi.fn().mockName("MyService.getPromise").mockReturnValue(Promise.resolve(expect.any(String))),
           };
         `,
       },
@@ -105,8 +105,8 @@ describe('Jasmine to Vitest Transformer', () => {
         `,
         expected: `
           const myService = {
-            methodA: vi.fn(),
-            propA: 'valueA'
+            methodA: vi.fn().mockName("MyService.methodA"),
+            propA: 'valueA',
           };
           vi.spyOn(myService, 'methodA').mockReturnValue('mocked value');
           myService.methodA('test');

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

@@ -227,6 +227,12 @@ export function transformCreateSpyObj(
     'Transformed `jasmine.createSpyObj()` to an object literal with `vi.fn()`.',
   );
 
+  const baseNameArg = node.arguments[0];
+  const baseName = ts.isStringLiteral(baseNameArg) ? baseNameArg.text : undefined;
+  const methods = node.arguments[1];
+  const propertiesArg = node.arguments[2];
+  let properties: ts.PropertyAssignment[] = [];
+
   if (node.arguments.length < 2) {
     const category = 'createSpyObj-single-argument';
     reporter.recordTodo(category);
@@ -235,14 +241,10 @@ export function transformCreateSpyObj(
     return node;
   }
 
-  const methods = node.arguments[1];
-  const propertiesArg = node.arguments[2];
-  let properties: ts.PropertyAssignment[] = [];
-
   if (ts.isArrayLiteralExpression(methods)) {
-    properties = createSpyObjWithArray(methods);
+    properties = createSpyObjWithArray(methods, baseName);
   } else if (ts.isObjectLiteralExpression(methods)) {
-    properties = createSpyObjWithObject(methods);
+    properties = createSpyObjWithObject(methods, baseName);
   } else {
     const category = 'createSpyObj-dynamic-variable';
     reporter.recordTodo(category);
@@ -264,13 +266,28 @@ export function transformCreateSpyObj(
   return ts.factory.createObjectLiteralExpression(properties, true);
 }
 
-function createSpyObjWithArray(methods: ts.ArrayLiteralExpression): ts.PropertyAssignment[] {
+function createSpyObjWithArray(
+  methods: ts.ArrayLiteralExpression,
+  baseName: string | undefined,
+): ts.PropertyAssignment[] {
   return methods.elements
     .map((element) => {
       if (ts.isStringLiteral(element)) {
+        const mockFn = createViCallExpression('fn');
+        const methodName = element.text;
+        let finalExpression: ts.Expression = mockFn;
+
+        if (baseName) {
+          finalExpression = ts.factory.createCallExpression(
+            createPropertyAccess(finalExpression, 'mockName'),
+            undefined,
+            [ts.factory.createStringLiteral(`${baseName}.${methodName}`)],
+          );
+        }
+
         return ts.factory.createPropertyAssignment(
-          ts.factory.createIdentifier(element.text),
-          createViCallExpression('fn'),
+          ts.factory.createIdentifier(methodName),
+          finalExpression,
         );
       }
 
@@ -279,13 +296,25 @@ function createSpyObjWithArray(methods: ts.ArrayLiteralExpression): ts.PropertyA
     .filter((p): p is ts.PropertyAssignment => !!p);
 }
 
-function createSpyObjWithObject(methods: ts.ObjectLiteralExpression): ts.PropertyAssignment[] {
+function createSpyObjWithObject(
+  methods: ts.ObjectLiteralExpression,
+  baseName: string | undefined,
+): ts.PropertyAssignment[] {
   return methods.properties
     .map((prop) => {
       if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
         const methodName = prop.name.text;
         const returnValue = prop.initializer;
-        const mockFn = createViCallExpression('fn');
+        let mockFn = createViCallExpression('fn');
+
+        if (baseName) {
+          mockFn = ts.factory.createCallExpression(
+            createPropertyAccess(mockFn, 'mockName'),
+            undefined,
+            [ts.factory.createStringLiteral(`${baseName}.${methodName}`)],
+          );
+        }
+
         const mockReturnValue = createPropertyAccess(mockFn, 'mockReturnValue');
 
         return ts.factory.createPropertyAssignment(

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

@@ -118,8 +118,8 @@ vi.spyOn(service, 'myMethod').and.unknownStrategy();`,
         description: 'should transform jasmine.createSpyObj with an array of methods',
         input: `const myService = jasmine.createSpyObj('MyService', ['methodA', 'methodB']);`,
         expected: `const myService = {
-          methodA: vi.fn(),
-          methodB: vi.fn()
+          methodA: vi.fn().mockName("MyService.methodA"),
+          methodB: vi.fn().mockName("MyService.methodB"),
         };`,
       },
       {
@@ -134,16 +134,16 @@ vi.spyOn(service, 'myMethod').and.unknownStrategy();`,
         description: 'should transform jasmine.createSpyObj with an object of return values',
         input: `const myService = jasmine.createSpyObj('MyService', { methodA: 'foo', methodB: 42 });`,
         expected: `const myService = {
-          methodA: vi.fn().mockReturnValue('foo'),
-          methodB: vi.fn().mockReturnValue(42)
+          methodA: vi.fn().mockName("MyService.methodA").mockReturnValue('foo'),
+          methodB: vi.fn().mockName("MyService.methodB").mockReturnValue(42),
         };`,
       },
       {
         description:
           'should transform jasmine.createSpyObj with an object of return values containing an asymmetric matcher',
         input: `const myService = jasmine.createSpyObj('MyService', { methodA: jasmine.any(String) });`,
         expected: `const myService = {
-          methodA: vi.fn().mockReturnValue(expect.any(String))
+          methodA: vi.fn().mockName("MyService.methodA").mockReturnValue(expect.any(String)),
         };`,
       },
       {
@@ -158,23 +158,23 @@ vi.spyOn(service, 'myMethod').and.unknownStrategy();`,
         description: 'should transform jasmine.createSpyObj with a property map',
         input: `const myService = jasmine.createSpyObj('MyService', ['methodA'], { propA: 'valueA' });`,
         expected: `const myService = {
-          methodA: vi.fn(),
-          propA: 'valueA'
+          methodA: vi.fn().mockName("MyService.methodA"),
+          propA: 'valueA',
         };`,
       },
       {
         description: 'should transform jasmine.createSpyObj with a method map and a property map',
         input: `const myService = jasmine.createSpyObj('MyService', { methodA: 'foo' }, { propA: 'valueA' });`,
         expected: `const myService = {
-          methodA: vi.fn().mockReturnValue('foo'),
-          propA: 'valueA'
+          methodA: vi.fn().mockName("MyService.methodA").mockReturnValue('foo'),
+          propA: 'valueA',
         };`,
       },
       {
         description: 'should ignore non-string literals in the method array',
         input: `const myService = jasmine.createSpyObj('MyService', ['methodA', 123, someVar]);`,
         expected: `const myService = {
-          methodA: vi.fn()
+          methodA: vi.fn().mockName("MyService.methodA"),
         };`,
       },
     ];