refactor(operators): migrate unit tests to Vitest (#5031)

Closes #5021

Author: JulienMichelFr

modules/operators/eslint.config.mjs

@@ -47,4 +47,11 @@ export default [
         ...config.rules,
       },
     })),
+  {
+    ignores: [
+      'schematics-core',
+      '**/vite.config.*.timestamp*',
+      '**/vitest.config.*.timestamp*',
+    ],
+  },
 ];

modules/operators/jest.config.ts

@@ -6,7 +6,10 @@ import {
 import { createWorkspace } from '@ngrx/schematics-core/testing';
 
 describe('migrate tapResponse', () => {
-  const collectionPath = path.join(__dirname, '../migration.json');
+  const collectionPath = path.join(
+    process.cwd(),
+    'dist/modules/operators/migrations/migration.json'
+  );
   const schematicRunner = new SchematicTestRunner('schematics', collectionPath);
   let appTree: UnitTestTree;
 

modules/operators/migrations/20_0_0-rc_0-tap-response/index.spec.ts

@@ -25,12 +25,24 @@
           {
             "command": "pnpm exec tsc -p modules/operators/tsconfig.schematics.json"
           },
+          {
+            "command": "pnpm exec rimraf node_modules/@ngrx/operators"
+          },
+          {
+            "command": "pnpm exec mkdirp node_modules/@ngrx/operators"
+          },
+          {
+            "command": "ncp dist/modules/operators node_modules/@ngrx/operators"
+          },
           {
             "command": "cpy LICENSE dist/modules/operators"
           }
         ]
       },
-      "outputs": ["{workspaceRoot}/dist/modules/operators"]
+      "outputs": [
+        "{workspaceRoot}/dist/modules/operators",
+        "{workspaceRoot}/node_modules/@ngrx/operators"
+      ]
     },
     "lint": {
       "executor": "@nx/eslint:lint",
@@ -43,12 +55,8 @@
       "outputs": ["{options.outputFile}"]
     },
     "test": {
-      "executor": "@nx/jest:jest",
-      "options": {
-        "jestConfig": "modules/operators/jest.config.ts",
-        "runInBand": true,
-        "passWithNoTests": false
-      },
+      "executor": "@analogjs/vitest-angular:test",
+      "dependsOn": ["build"],
       "outputs": ["{workspaceRoot}/coverage/modules/operators"]
     }
   }

modules/operators/project.json

@@ -9,7 +9,10 @@ import { createWorkspace } from '@ngrx/schematics-core/testing';
 describe('Operators ng-add Schematic', () => {
   const schematicRunner = new SchematicTestRunner(
     '@ngrx/operators',
-    path.join(__dirname, '../collection.json')
+    path.join(
+      process.cwd(),
+      'dist/modules/operators/schematics/collection.json'
+    )
   );
   const defaultOptions: SchemaOptions = {
     skipPackageJson: false,

modules/operators/schematics-core/jest.config.js

@@ -1,6 +1,7 @@
 import { noop, Observable, of, throwError } from 'rxjs';
 import { mapResponse } from '..';
 import { concatMap, finalize } from 'rxjs/operators';
+import { vi } from 'vitest';
 
 describe('mapResponse', () => {
   it('should map the emitted value using the next callback', () => {
@@ -20,41 +21,43 @@ describe('mapResponse', () => {
     expect(results).toEqual([2, 3, 4]);
   });
 
-  it('should map the thrown error using the error callback', (done) => {
-    throwError(() => 'error')
-      .pipe(
-        mapResponse({
-          next: noop,
-          error: (error) => `mapped ${error}`,
-        })
-      )
-      .subscribe((result) => {
-        expect(result).toBe('mapped error');
-        done();
-      });
-  });
+  it('should map the thrown error using the error callback', () =>
+    new Promise((done) => {
+      throwError(() => 'error')
+        .pipe(
+          mapResponse({
+            next: noop,
+            error: (error) => `mapped ${error}`,
+          })
+        )
+        .subscribe((result) => {
+          expect(result).toBe('mapped error');
+          done(void 0);
+        });
+    }));
 
-  it('should map the error thrown in next callback using error callback', (done) => {
-    function producesError() {
-      throw 'error';
-    }
+  it('should map the error thrown in next callback using error callback', () =>
+    new Promise((done) => {
+      function producesError() {
+        throw 'error';
+      }
 
-    of(1)
-      .pipe(
-        mapResponse({
-          next: producesError,
-          error: (error) => `mapped ${error}`,
-        })
-      )
-      .subscribe((result) => {
-        expect(result).toBe('mapped error');
-        done();
-      });
-  });
+      of(1)
+        .pipe(
+          mapResponse({
+            next: producesError,
+            error: (error) => `mapped ${error}`,
+          })
+        )
+        .subscribe((result) => {
+          expect(result).toBe('mapped error');
+          done(void 0);
+        });
+    }));
 
   it('should not unsubscribe from outer observable on inner observable error', () => {
-    const innerCompleteCallback = jest.fn<void, []>();
-    const outerCompleteCallback = jest.fn<void, []>();
+    const innerCompleteCallback = vi.fn<() => void>();
+    const outerCompleteCallback = vi.fn<() => void>();
 
     new Observable((subscriber) => subscriber.next(1))
       .pipe(

modules/operators/schematics-core/jest.config.ts

@@ -1,18 +1,19 @@
 import { EMPTY, noop, Observable, of, throwError } from 'rxjs';
 import { tapResponse } from '..';
 import { concatMap, finalize } from 'rxjs/operators';
+import { vi } from 'vitest';
 
 describe('tapResponse', () => {
   it('should invoke next callback on next', () => {
-    const nextCallback = jest.fn<void, [number]>();
+    const nextCallback = vi.fn<(value: [number]) => void>();
 
     of(1, 2, 3).pipe(tapResponse(nextCallback, noop)).subscribe();
 
     expect(nextCallback.mock.calls).toEqual([[1], [2], [3]]);
   });
 
   it('should invoke error callback on error', () => {
-    const errorCallback = jest.fn<void, [{ message: string }]>();
+    const errorCallback = vi.fn<() => [{ message: string }]>();
     const error = { message: 'error' };
 
     throwError(() => error)
@@ -23,7 +24,7 @@ describe('tapResponse', () => {
   });
 
   it('should invoke error callback on the exception thrown in next', () => {
-    const errorCallback = jest.fn<void, [{ message: string }]>();
+    const errorCallback = vi.fn<() => [{ message: string }]>();
     const error = { message: 'error' };
 
     function producesError() {
@@ -36,7 +37,7 @@ describe('tapResponse', () => {
   });
 
   it('should invoke complete callback on complete', () => {
-    const completeCallback = jest.fn<void, []>();
+    const completeCallback = vi.fn<() => void>();
 
     EMPTY.pipe(tapResponse(noop, noop, completeCallback)).subscribe();
 
@@ -97,8 +98,8 @@ describe('tapResponse', () => {
   });
 
   it('should not unsubscribe from outer observable on inner observable error', () => {
-    const innerCompleteCallback = jest.fn<void, []>();
-    const outerCompleteCallback = jest.fn<void, []>();
+    const innerCompleteCallback = vi.fn<() => void>();
+    const outerCompleteCallback = vi.fn<() => void>();
 
     new Observable((subscriber) => subscriber.next(1))
       .pipe(

modules/operators/schematics/ng-add/index.spec.ts

@@ -1,5 +1,33 @@
-import 'zone.js/plugins/zone-legacy';
-import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/zone';
+import {
+  TextEncoder as NodeTextEncoder,
+  TextDecoder as NodeTextDecoder,
+} from 'util';
 
-setupZoneTestEnv();
-Object.assign(global, { TextDecoder, TextEncoder });
+// Only assign if not already defined, using type assertion to satisfy TypeScript
+if (typeof globalThis.TextEncoder === 'undefined') {
+  globalThis.TextEncoder = NodeTextEncoder as unknown as {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+  };
+}
+
+if (typeof globalThis.TextDecoder === 'undefined') {
+  globalThis.TextDecoder = NodeTextDecoder as unknown as {
+    new (): TextDecoder;
+    prototype: TextDecoder;
+  };
+}
+
+import '@angular/compiler';
+import '@analogjs/vitest-angular/setup-zone';
+
+import {
+  BrowserTestingModule,
+  platformBrowserTesting,
+} from '@angular/platform-browser/testing';
+import { getTestBed } from '@angular/core/testing';
+
+getTestBed().initTestEnvironment(
+  BrowserTestingModule,
+  platformBrowserTesting()
+);