chore: add vitest, migrate tests

Author: stephancill

packages/client/package.json

@@ -23,7 +23,7 @@
   "author": "Coinbase, Inc.",
   "license": "Apache-2.0",
   "scripts": {
-    "test": "jest",
+    "test": "vitest",
     "test:coverage": "yarn test:unit && open coverage/lcov-report/index.html",
     "prebuild": "rm -rf ./dist && node -p \"'export const LIB_VERSION = \\'' + require('./package.json').version + '\\';'\" > src/version.ts",
     "build": "tsc -p ./tsconfig.build.json && tsc-alias",
@@ -53,15 +53,12 @@
     "@babel/preset-typescript": "^7.22.5",
     "@peculiar/webcrypto": "^1.4.3",
     "@react-native-async-storage/async-storage": "^1.24.0",
-    "@testing-library/jest-dom": "^5.17.0",
     "@testing-library/react": "14.3.1",
-    "@types/jest": "^27.5.2",
     "@types/node": "^14.18.54",
     "@types/react": "^18.0.25",
     "@types/react-native": "^0.70.6",
     "@typescript-eslint/eslint-plugin": "^6.2.0",
     "@typescript-eslint/parser": "^6.2.0",
-    "babel-jest": "^27.5.1",
     "eslint": "^8.45.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^5.0.0",
@@ -71,12 +68,9 @@
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-unused-imports": "^3.0.0",
     "expo-web-browser": "^13.0.3",
-    "jest": "^27.5.1",
-    "jest-chrome": "^0.7.2",
-    "jest-websocket-mock": "^2.4.0",
+    "jsdom": "^26.0.0",
     "nodemon": "^3.1.0",
     "prettier": "^3.0.0",
-    "ts-jest": "^27.1.5",
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.8",
     "tslib": "^2.6.0",

packages/client/src/MWPClient.test.ts

@@ -1,3 +1,4 @@
+import { beforeEach, beforeAll, afterAll, describe, expect, it, vi } from 'vitest';
 import { postRequestToWallet } from './components/communication/postRequestToWallet';
 import { KeyManager } from './components/key/KeyManager';
 import { MWPClient } from './MWPClient';
@@ -16,30 +17,30 @@ import { ScopedAsyncStorage } from ':core/storage/ScopedAsyncStorage';
 import { fetchRPCRequest } from ':core/util/utils';
 import { Wallets } from ':core/wallet';
 
-jest.mock(':core/util/utils', () => {
-  const actual = jest.requireActual(':core/util/utils');
+vi.mock(':core/util/utils', async () => {
+  const actual = await vi.importActual(':core/util/utils');
   return {
     ...actual,
-    fetchRPCRequest: jest.fn(),
+    fetchRPCRequest: vi.fn(),
   };
 });
 
-jest.mock('./components/communication/postRequestToWallet');
+vi.mock('./components/communication/postRequestToWallet');
 
-jest.mock('expo-web-browser', () => ({
-  openAuthSessionAsync: jest.fn(),
-  dismissBrowser: jest.fn(),
+vi.mock('expo-web-browser', () => ({
+  openAuthSessionAsync: vi.fn(),
+  dismissBrowser: vi.fn(),
 }));
 
-jest.mock('./components/key/KeyManager');
-const storageStoreSpy = jest.spyOn(ScopedAsyncStorage.prototype, 'storeObject');
-const storageClearSpy = jest.spyOn(ScopedAsyncStorage.prototype, 'clear');
+vi.mock('./components/key/KeyManager');
+const storageStoreSpy = vi.spyOn(ScopedAsyncStorage.prototype, 'storeObject');
+const storageClearSpy = vi.spyOn(ScopedAsyncStorage.prototype, 'clear');
 
-jest.mock(':core/cipher/cipher', () => ({
-  decryptContent: jest.fn(),
-  encryptContent: jest.fn(),
-  exportKeyToHexString: jest.fn(),
-  importKeyFromHexString: jest.fn(),
+vi.mock(':core/cipher/cipher', () => ({
+  decryptContent: vi.fn(),
+  encryptContent: vi.fn(),
+  exportKeyToHexString: vi.fn(),
+  importKeyFromHexString: vi.fn(),
 }));
 
 const mockCryptoKey = {} as CryptoKey;
@@ -64,7 +65,7 @@ const mockWallet = Wallets.CoinbaseSmartWallet;
 describe('MWPClient', () => {
   let client: MWPClient;
   let mockMetadata: AppMetadata;
-  let mockKeyManager: jest.Mocked<KeyManager>;
+  let mockKeyManager: ReturnType<typeof vi.mocked<KeyManager>>;
 
   beforeEach(async () => {
     mockMetadata = {
@@ -73,18 +74,18 @@ describe('MWPClient', () => {
       customScheme: 'myapp://',
     };
 
-    (postRequestToWallet as jest.Mock).mockResolvedValue(mockSuccessResponse);
+    (postRequestToWallet as ReturnType<typeof vi.fn>).mockResolvedValue(mockSuccessResponse);
 
     mockKeyManager = new KeyManager({
       wallet: mockWallet,
-    }) as jest.Mocked<KeyManager>;
-    (KeyManager as jest.Mock).mockImplementation(() => mockKeyManager);
+    }) as ReturnType<typeof vi.mocked<KeyManager>>;
+    (KeyManager as ReturnType<typeof vi.fn>).mockImplementation(() => mockKeyManager);
     storageStoreSpy.mockReset();
 
-    (importKeyFromHexString as jest.Mock).mockResolvedValue(mockCryptoKey);
-    (exportKeyToHexString as jest.Mock).mockResolvedValueOnce('0xPublicKey');
+    (importKeyFromHexString as ReturnType<typeof vi.fn>).mockResolvedValue(mockCryptoKey);
+    (exportKeyToHexString as ReturnType<typeof vi.fn>).mockResolvedValueOnce('0xPublicKey');
     mockKeyManager.getSharedSecret.mockResolvedValue(mockCryptoKey);
-    (encryptContent as jest.Mock).mockResolvedValueOnce(encryptedData);
+    (encryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(encryptedData);
 
     client = await MWPClient.createInstance({
       metadata: mockMetadata,
@@ -106,8 +107,21 @@ describe('MWPClient', () => {
   });
 
   describe('handshake', () => {
+    it('should throw an error if failure in response.content', async () => {
+      const mockResponse: RPCResponseMessage = {
+        id: '1-2-3-4-5',
+        requestId: '1-2-3-4-5-6',
+        sender: '0xPublicKey',
+        content: { failure: mockError },
+        timestamp: new Date(),
+      };
+      (postRequestToWallet as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      await expect(client.handshake()).rejects.toThrowError(mockError);
+    });
+
     it('should perform a successful handshake', async () => {
-      (decryptContent as jest.Mock).mockResolvedValueOnce({
+      (decryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
         result: {
           value: ['0xAddress'],
         },
@@ -130,26 +144,13 @@ describe('MWPClient', () => {
       expect(storageStoreSpy).toHaveBeenCalledWith('walletCapabilities', mockCapabilities);
       expect(storageStoreSpy).toHaveBeenCalledWith('accounts', ['0xAddress']);
 
-      expect(client.request({ method: 'eth_requestAccounts' })).resolves.toEqual(['0xAddress']);
-    });
-
-    it('should throw an error if failure in response.content', async () => {
-      const mockResponse: RPCResponseMessage = {
-        id: '1-2-3-4-5',
-        requestId: '1-2-3-4-5',
-        sender: '0xPublicKey',
-        content: { failure: mockError },
-        timestamp: new Date(),
-      };
-      (postRequestToWallet as jest.Mock).mockResolvedValue(mockResponse);
-
-      await expect(client.handshake()).rejects.toThrowError(mockError);
+      await expect(client.request({ method: 'eth_requestAccounts' })).resolves.toEqual(['0xAddress']);
     });
   });
 
   describe('request', () => {
     beforeAll(() => {
-      jest.spyOn(ScopedAsyncStorage.prototype, 'loadObject').mockImplementation(async (key) => {
+      vi.spyOn(ScopedAsyncStorage.prototype, 'loadObject').mockImplementation(async (key) => {
         switch (key) {
           case 'accounts':
             return ['0xAddress'];
@@ -162,7 +163,7 @@ describe('MWPClient', () => {
     });
 
     afterAll(() => {
-      jest.spyOn(ScopedAsyncStorage.prototype, 'loadObject').mockRestore();
+      vi.mocked(ScopedAsyncStorage.prototype.loadObject).mockRestore();
     });
 
     it('should perform a successful request', async () => {
@@ -171,7 +172,7 @@ describe('MWPClient', () => {
         params: ['0xMessage', '0xAddress'],
       };
 
-      (decryptContent as jest.Mock).mockResolvedValueOnce({
+      (decryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
         result: {
           value: '0xSignature',
         },
@@ -212,7 +213,7 @@ describe('MWPClient', () => {
         params: [],
       };
 
-      (decryptContent as jest.Mock).mockResolvedValueOnce({
+      (decryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
         result: {
           value: '0xSignature',
         },
@@ -252,7 +253,7 @@ describe('MWPClient', () => {
         params: ['0xMessage', '0xAddress'],
       };
 
-      (decryptContent as jest.Mock).mockResolvedValueOnce({
+      (decryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
         result: {
           error: mockError,
         },
@@ -267,7 +268,7 @@ describe('MWPClient', () => {
         params: [{ chainId: '0x1' }],
       };
 
-      (decryptContent as jest.Mock).mockResolvedValueOnce({
+      (decryptContent as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
         result: {
           value: null,
         },

packages/client/src/components/communication/postRequestToWallet.test.ts

@@ -1,18 +1,19 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import * as WebBrowser from 'expo-web-browser';
 
 import { postRequestToWallet } from './postRequestToWallet';
 import { decodeResponseURLParams, encodeRequestURLParams } from './utils/encoding';
 import { RPCRequestMessage, RPCResponseMessage } from ':core/message';
 import { Wallet } from ':core/wallet';
 
-jest.mock('expo-web-browser', () => ({
-  openAuthSessionAsync: jest.fn(),
-  dismissBrowser: jest.fn(),
+vi.mock('expo-web-browser', () => ({
+  openAuthSessionAsync: vi.fn(),
+  dismissBrowser: vi.fn(),
 }));
 
-jest.mock('./utils/encoding', () => ({
-  ...jest.requireActual('./utils/encoding'),
-  decodeResponseURLParams: jest.fn(),
+vi.mock('./utils/encoding', () => ({
+  decodeResponseURLParams: vi.fn(),
+  encodeRequestURLParams: vi.fn(),
 }));
 
 const mockAppCustomScheme = 'myapp://';
@@ -48,17 +49,18 @@ describe('postRequestToWallet', () => {
 
   beforeEach(() => {
     requestUrl = new URL(mockWalletScheme);
+    (encodeRequestURLParams as ReturnType<typeof vi.fn>).mockReturnValue('mocked-search-params');
     requestUrl.search = encodeRequestURLParams(mockRequest);
-    jest.clearAllMocks();
+    vi.clearAllMocks();
   });
 
   it('should successfully post request to a web-based wallet', async () => {
     const webWallet: Wallet = { type: 'web', scheme: mockWalletScheme } as Wallet;
-    (WebBrowser.openAuthSessionAsync as jest.Mock).mockResolvedValue({
+    (WebBrowser.openAuthSessionAsync as ReturnType<typeof vi.fn>).mockResolvedValue({
       type: 'success',
       url: 'https://example.com/response',
     });
-    (decodeResponseURLParams as jest.Mock).mockResolvedValue(mockResponse);
+    (decodeResponseURLParams as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
 
     const result = await postRequestToWallet(mockRequest, mockAppCustomScheme, webWallet);
 
@@ -74,7 +76,7 @@ describe('postRequestToWallet', () => {
 
   it('should throw an error if the user cancels the request', async () => {
     const webWallet: Wallet = { type: 'web', scheme: mockWalletScheme } as Wallet;
-    (WebBrowser.openAuthSessionAsync as jest.Mock).mockResolvedValue({
+    (WebBrowser.openAuthSessionAsync as ReturnType<typeof vi.fn>).mockResolvedValue({
       type: 'cancel',
     });
 
@@ -105,7 +107,7 @@ describe('postRequestToWallet', () => {
   it('should pass through any errors from WebBrowser', async () => {
     const webWallet: Wallet = { type: 'web', scheme: mockWalletScheme } as Wallet;
     const mockError = new Error('Communication error');
-    (WebBrowser.openAuthSessionAsync as jest.Mock).mockRejectedValue(mockError);
+    (WebBrowser.openAuthSessionAsync as ReturnType<typeof vi.fn>).mockRejectedValue(mockError);
 
     await expect(postRequestToWallet(mockRequest, mockAppCustomScheme, webWallet)).rejects.toThrow(
       'User rejected the request'

packages/client/src/core/cipher/cipher.test.ts

@@ -1,3 +1,5 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+
 import { unzlibSync, zlibSync } from 'fflate';
 
 import {

packages/client/src/core/type/util.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, test } from 'vitest';
 import { HexString } from '.';
 import {
   bigIntStringFromBigInt,
@@ -190,7 +191,7 @@ describe('util', () => {
       document.head.innerHTML = `
       <link rel="shortcut icon" sizes="16x16 24x24" href="/favicon.ico">
     `;
-      expect(getFavicon()).toEqual('http://localhost/favicon.ico');
+      expect(getFavicon()).toEqual('http://localhost:3000/favicon.ico');
     });
   });
 });

packages/client/src/core/util/utils.test.ts

@@ -1,39 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
 import { LIB_VERSION } from '../../version';
 import { checkErrorForInvalidRequestArgs, fetchRPCRequest } from './utils';
 import { standardErrors } from ':core/error';
 
 // @ts-expect-error-next-line
 const invalidArgsError = (args) =>
-  standardErrors.rpc.invalidRequest({
+  standardErrors.rpc.invalidParams({
     message: 'Expected a single, non-array, object argument.',
     data: args,
   });
 // @ts-expect-error-next-line
 const invalidMethodError = (args) =>
-  standardErrors.rpc.invalidRequest({
+  standardErrors.rpc.invalidParams({
     message: "'args.method' must be a non-empty string.",
     data: args,
   });
 // @ts-expect-error-next-line
 const invalidParamsError = (args) =>
-  standardErrors.rpc.invalidRequest({
+  standardErrors.rpc.invalidParams({
     message: "'args.params' must be an object or array if provided.",
     data: args,
   });
 
 const mockUUID = '123e4567-e89b-12d3-a456-426614174000';
-jest.spyOn(crypto, 'randomUUID').mockReturnValue(mockUUID);
+vi.spyOn(crypto, 'randomUUID').mockReturnValue(mockUUID);
 
 describe('Utils', () => {
   describe('fetchRPCRequest', () => {
     function mockFetchResponse(response: unknown) {
-      global.fetch = jest.fn().mockResolvedValue({
-        json: jest.fn().mockResolvedValue(response),
+      global.fetch = vi.fn().mockResolvedValue({
+        json: vi.fn().mockResolvedValue(response),
       });
     }
 
     it('should make a POST request with correct parameters', async () => {
-      const mockResponse = { json: jest.fn().mockResolvedValue({ result: '0x1' }) };
+      const mockResponse = { json: vi.fn().mockResolvedValue({ result: '0x1' }) };
       mockFetchResponse({ id: 1, result: mockResponse, error: null });
 
       const mockRpcUrl = 'https://example.com/rpc';