fixup! fix(@schematics/angular): cast createSpyObj to MockedObject for jasmine.SpyObj variables in refactor-jasmine-vitest

Address review: use explicit type argument of createSpyObj, look into
union types and keep an existing cast instead of adding a second one.

Co-authored-by: Alan Agius <alanagius@google.com>

Author: thekhegay

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

@@ -462,10 +462,20 @@ export function transformCreateSpyObj(node: ts.Node, ctx: RefactorContext): ts.N
 
   const spyObjLiteral = ts.factory.createObjectLiteralExpression(properties, true);
 
+  let parent = node.parent;
+  while (parent && ts.isParenthesizedExpression(parent)) {
+    parent = parent.parent;
+  }
+
+  // An existing cast on the call already gives the literal its type.
+  if (parent && (ts.isAsExpression(parent) || ts.isTypeAssertionExpression(parent))) {
+    return spyObjLiteral;
+  }
+
   // The literal only has the spied members, so it is not assignable to the `MockedObject<T>`
   // that a `jasmine.SpyObj<T>` annotation is transformed to. Jasmine's untyped `createSpyObj`
   // returns `any`, which is why the original assignment compiled.
-  const spyObjTypeArguments = getAssignedSpyObjTypeArguments(node);
+  const spyObjTypeArguments = node.typeArguments ?? getAssignedSpyObjTypeArguments(parent);
   if (!spyObjTypeArguments) {
     return spyObjLiteral;
   }
@@ -481,6 +491,18 @@ export function transformCreateSpyObj(node: ts.Node, ctx: RefactorContext): ts.N
 function getSpyObjTypeArguments(
   type: ts.TypeNode | undefined,
 ): ts.NodeArray<ts.TypeNode> | undefined {
+  // `jasmine.SpyObj<T> | undefined` under `strictNullChecks`.
+  if (type && ts.isUnionTypeNode(type)) {
+    for (const member of type.types) {
+      const typeArguments = getSpyObjTypeArguments(member);
+      if (typeArguments) {
+        return typeArguments;
+      }
+    }
+
+    return undefined;
+  }
+
   if (
     type &&
     ts.isTypeReferenceNode(type) &&
@@ -527,12 +549,12 @@ function findEnclosingVariableDeclaration(
 
 /**
  * Finds the `T` of a `jasmine.SpyObj<T>` annotation on the variable that a `createSpyObj` call
- * initializes (`const spy: jasmine.SpyObj<T> = ...`) or is assigned to (`spy = ...`).
+ * initializes (`const spy: jasmine.SpyObj<T> = ...`) or is assigned to (`spy = ...`), given the
+ * call's parent outside any parentheses.
  */
 function getAssignedSpyObjTypeArguments(
-  node: ts.CallExpression,
+  parent: ts.Node | undefined,
 ): ts.NodeArray<ts.TypeNode> | undefined {
-  const parent = getUnwrappedParent(node);
   if (!parent) {
     return undefined;
   }

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

@@ -214,6 +214,53 @@ describe('transformCreateSpyObj', () => {
         } as MockedObject<MyService>;
       `,
     },
+    {
+      description:
+        'should cast jasmine.createSpyObj to MockedObject when assigned to a jasmine.SpyObj union variable',
+      input: `
+        let myService: jasmine.SpyObj<MyService> | undefined;
+        myService = jasmine.createSpyObj('MyService', ['methodA']);
+      `,
+      expected: `
+        import type { MockedObject } from 'vitest';
+
+        let myService: MockedObject<MyService> | undefined;
+        myService = {
+          methodA: vi.fn().mockName('MyService.methodA'),
+        } as MockedObject<MyService>;
+      `,
+    },
+    {
+      description:
+        'should cast jasmine.createSpyObj with an explicit type argument to MockedObject',
+      input: `const myService = jasmine.createSpyObj<MyService>('MyService', ['methodA']);`,
+      expected: `
+        import type { MockedObject } from 'vitest';
+        const myService = {
+          methodA: vi.fn().mockName('MyService.methodA'),
+        } as MockedObject<MyService>;
+      `,
+    },
+    {
+      description:
+        'should not add a second cast to a jasmine.createSpyObj call that is already cast',
+      input: `
+        let myService: jasmine.SpyObj<MyService>;
+        myService = jasmine.createSpyObj('MyService', ['methodA']) as jasmine.SpyObj<MyService>;
+        const other = jasmine.createSpyObj<Other>('Other', ['methodB']) as any;
+      `,
+      expected: `
+        import type { MockedObject } from 'vitest';
+
+        let myService: MockedObject<MyService>;
+        myService = {
+          methodA: vi.fn().mockName('MyService.methodA'),
+        } as MockedObject<MyService>;
+        const other = {
+          methodB: vi.fn().mockName('Other.methodB'),
+        } as any;
+      `,
+    },
     {
       description:
         'should cast jasmine.createSpyObj to the jasmine.SpyObj type of the variable in the enclosing describe block',