tests

Author: fan-zhang-sv

packages/client/jest.config.ts

@@ -37,7 +37,6 @@ export default {
   moduleNameMapper: {
     '^src/(.*)$': '<rootDir>/src/$1',
     '^:core/(.*)$': '<rootDir>/src/core/$1',
-    '^:util/(.*)$': '<rootDir>/src/util/$1',
   },
 
   // A list of paths to directories that Jest should use to search for files in

packages/client/src/EIP1193Provider.test.ts

@@ -1,76 +1,79 @@
-import { standardErrorCodes, standardErrors } from './core/error';
+import { standardErrors } from './core/error';
 import { EIP1193Provider } from './EIP1193Provider';
 import { MWPClient } from './MWPClient';
-import { RequestArguments } from ':core/provider/interface';
-import { AddressString } from ':core/type';
-import { Wallets } from ':core/wallet';
+import { serializeError } from ':core/error/serialize';
+import { Wallet, Wallets } from ':core/wallet';
 
-function createProvider() {
-  return new EIP1193Provider({
-    metadata: {
-      appName: 'Test App',
-      appLogoUrl: undefined,
-      appChainIds: [1],
-      appDeeplinkUrl: 'https://example.com',
-    },
-    wallet: Wallets.CoinbaseSmartWallet,
-  });
-}
+jest.mock('expo-web-browser', () => ({
+  openBrowserAsync: jest.fn(),
+  WebBrowserPresentationStyle: {
+    FORM_SHEET: 'FORM_SHEET',
+  },
+  dismissBrowser: jest.fn(),
+}));
 
-const mockHandshake = jest.fn();
-const mockRequest = jest.fn();
-const mockReset = jest.fn();
+jest.mock('./MWPClient');
+jest.mock(':core/wallet');
 
-let provider: EIP1193Provider;
+describe('EIP1193Provider', () => {
+  let provider: EIP1193Provider;
+  let mockWallet: jest.Mocked<Wallet>;
+  let mockClient: jest.Mocked<MWPClient>;
 
-beforeEach(() => {
-  jest.resetAllMocks();
-  jest.spyOn(MWPClient, 'createInstance').mockImplementation(async () => {
-    return {
-      accounts: [AddressString('0x123')],
-      chainId: 1,
-      handshake: mockHandshake,
-      request: mockRequest,
-      reset: mockReset,
-    } as unknown as MWPClient;
-  });
-  provider = createProvider();
-});
+  beforeEach(() => {
+    mockWallet = Wallets.CoinbaseSmartWallet;
+    mockClient = {
+      request: jest.fn(),
+      reset: jest.fn(),
+    } as unknown as jest.Mocked<MWPClient>;
+    (MWPClient.createInstance as jest.Mock).mockResolvedValue(mockClient);
 
-describe('Event handling', () => {
-  it('emits disconnect event on user initiated disconnection', async () => {
-    const disconnectListener = jest.fn();
-    provider.on('disconnect', disconnectListener);
+    provider = new EIP1193Provider({
+      metadata: { appName: 'Test App', appDeeplinkUrl: 'test://deeplink' },
+      wallet: mockWallet,
+    });
+    console.warn = jest.fn();
+  });
 
-    await provider.disconnect();
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
 
-    expect(disconnectListener).toHaveBeenCalledWith(
-      standardErrors.provider.disconnected('User initiated disconnection')
-    );
+  test('constructor initializes correctly', () => {
+    expect(provider).toBeDefined();
+    expect(provider.isCoinbaseWallet).toBe(true);
   });
-});
 
-describe('Request Handling', () => {
-  it('returns default chain id even without signer set up', async () => {
-    expect(provider.request({ method: 'eth_chainId' })).resolves.toBe('0x1');
-    expect(provider.request({ method: 'net_version' })).resolves.toBe(1);
+  test('request method calls client.request', async () => {
+    const args = { method: 'eth_getBalance', params: ['0x123'] };
+    await provider.request(args);
+    expect(mockClient.request).toHaveBeenCalledWith(args);
   });
 
-  it('throws error when handling invalid request', async () => {
-    await expect(provider.request({} as RequestArguments)).rejects.toThrowEIPError(
-      standardErrorCodes.rpc.invalidParams,
-      "'args.method' must be a non-empty string."
+  test('request method handles errors', async () => {
+    const mockError = standardErrors.provider.unauthorized();
+    mockClient.request.mockRejectedValue(mockError);
+    await expect(provider.request({ method: 'eth_getBalance' })).rejects.toEqual(
+      serializeError(mockError)
     );
+    expect(mockClient.reset).toHaveBeenCalled();
+  });
+
+  test('enable method calls request with eth_requestAccounts', async () => {
+    const spy = jest.spyOn(provider, 'request');
+    await provider.enable();
+    expect(spy).toHaveBeenCalledWith({ method: 'eth_requestAccounts' });
   });
 
-  it('throws error for requests with unsupported or deprecated method', async () => {
-    const deprecated = ['eth_sign', 'eth_signTypedData_v2'];
-    const unsupported = ['eth_subscribe', 'eth_unsubscribe'];
+  test('disconnect method calls client.reset and emits disconnect event', async () => {
+    const spy = jest.spyOn(provider, 'emit');
+    await provider.disconnect();
+    expect(mockClient.reset).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith('disconnect', expect.any(Error));
+  });
 
-    for (const method of [...deprecated, ...unsupported]) {
-      await expect(provider.request({ method })).rejects.toThrowEIPError(
-        standardErrorCodes.provider.unsupportedMethod
-      );
-    }
+  test('ensureInitialized waits for initialization', async () => {
+    const privateEnsureInitialized = (provider as any).ensureInitialized.bind(provider);
+    await expect(privateEnsureInitialized()).resolves.not.toThrow();
   });
 });

packages/client/src/EIP1193Provider.ts

@@ -32,7 +32,7 @@ export class EIP1193Provider extends ProviderEventEmitter implements ProviderInt
     try {
       if (!this.client) throw standardErrors.rpc.internal('MWPClient not initialized');
 
-      return this.client.request(args);
+      return await this.client.request(args);
     } catch (error) {
       const { code } = error as { code?: number };
       if (code === standardErrorCodes.provider.unauthorized) this.disconnect();

packages/client/src/MWPClient.test.ts

@@ -1,25 +1,34 @@
 import { WebBasedWalletCommunicator } from 'src/components/communicator/webBased/Communicator';
 
 import { Communicator, CommunicatorInterface } from './components/communicator';
-import { KeyManager } from './components/keyManager/KeyManager';
+import { KeyManager } from './components/key/KeyManager';
 import { MWPClient } from './MWPClient';
 import {
   decryptContent,
   encryptContent,
   exportKeyToHexString,
   importKeyFromHexString,
 } from ':core/cipher/cipher';
+import { CryptoKey } from ':core/cipher/types';
 import { standardErrors } from ':core/error';
 import { EncryptedData, RPCResponseMessage } from ':core/message';
-import { AppMetadata, ProviderEventCallback, RequestArguments } from ':core/provider/interface';
+import { AppMetadata, RequestArguments } from ':core/provider/interface';
 import { ScopedAsyncStorage } from ':core/storage/ScopedAsyncStorage';
 import { Wallets } from ':core/wallet';
 
-jest.mock('./KeyManager');
+jest.mock('expo-web-browser', () => ({
+  openBrowserAsync: jest.fn(),
+  WebBrowserPresentationStyle: {
+    FORM_SHEET: 'FORM_SHEET',
+  },
+  dismissBrowser: jest.fn(),
+}));
+
+jest.mock('./components/key/KeyManager');
 const storageStoreSpy = jest.spyOn(ScopedAsyncStorage.prototype, 'storeObject');
 const storageClearSpy = jest.spyOn(ScopedAsyncStorage.prototype, 'clear');
 
-jest.mock(':util/cipher', () => ({
+jest.mock(':core/cipher/cipher', () => ({
   decryptContent: jest.fn(),
   encryptContent: jest.fn(),
   exportKeyToHexString: jest.fn(),
@@ -49,15 +58,13 @@ describe('MWPClient', () => {
   let signer: MWPClient;
   let mockMetadata: AppMetadata;
   let mockCommunicator: CommunicatorInterface;
-  let mockCallback: ProviderEventCallback;
   let mockKeyManager: jest.Mocked<KeyManager>;
 
   beforeEach(async () => {
     mockMetadata = {
       appName: 'test',
-      appLogoUrl: null,
       appChainIds: [1],
-      appDeeplinkUrl: null,
+      appDeeplinkUrl: 'https://example.com',
     };
 
     WebBasedWalletCommunicator.communicators.clear();
@@ -66,7 +73,6 @@ describe('MWPClient', () => {
       .spyOn(mockCommunicator, 'postRequestAndWaitForResponse')
       .mockResolvedValue(mockSuccessResponse);
 
-    mockCallback = jest.fn();
     mockKeyManager = new KeyManager({
       wallet: mockWallet,
     }) as jest.Mocked<KeyManager>;
@@ -110,8 +116,6 @@ describe('MWPClient', () => {
       expect(storageStoreSpy).toHaveBeenCalledWith('accounts', ['0xAddress']);
 
       expect(signer.request({ method: 'eth_requestAccounts' })).resolves.toEqual(['0xAddress']);
-      expect(mockCallback).toHaveBeenCalledWith('accountsChanged', ['0xAddress']);
-      expect(mockCallback).toHaveBeenCalledWith('connect', { chainId: '0x1' });
     });
 
     it('should throw an error if failure in response.content', async () => {
@@ -208,13 +212,12 @@ describe('MWPClient', () => {
         { id: 2, rpcUrl: 'https://eth-rpc.example.com/2' },
       ]);
       expect(storageStoreSpy).toHaveBeenCalledWith('walletCapabilities', mockCapabilities);
-      expect(mockCallback).toHaveBeenCalledWith('chainChanged', '0x1');
     });
   });
 
-  describe('disconnect', () => {
-    it('should disconnect successfully', async () => {
-      await signer.cleanup();
+  describe('reset', () => {
+    it('should reset successfully', async () => {
+      await signer.reset();
 
       expect(storageClearSpy).toHaveBeenCalled();
       expect(mockKeyManager.clear).toHaveBeenCalled();

packages/client/src/MWPClient.ts

@@ -1,4 +1,4 @@
-import { KeyManager } from './components/keyManager/KeyManager';
+import { KeyManager } from './components/key/KeyManager';
 import {
   decryptContent,
   encryptContent,

packages/client/src/components/communicator/Communicator.test.ts

@@ -0,0 +1,52 @@
+import { Communicator } from './Communicator';
+import { WebBasedWalletCommunicator } from './webBased/Communicator';
+import { Wallet } from ':core/wallet';
+
+jest.mock('expo-web-browser', () => ({
+  openBrowserAsync: jest.fn(),
+  WebBrowserPresentationStyle: {
+    FORM_SHEET: 'FORM_SHEET',
+  },
+  dismissBrowser: jest.fn(),
+}));
+
+jest.mock('./webBased/Communicator');
+
+describe('Communicator', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('getInstance returns WebBasedWalletCommunicator for web-based wallet', () => {
+    const mockWebBasedWallet: Wallet = { type: 'webBased', scheme: 'test-scheme://' } as Wallet;
+    const mockCommunicator = {
+      postRequestAndWaitForResponse: jest.fn(),
+      handleResponse: jest.fn(),
+    };
+    (WebBasedWalletCommunicator.getInstance as jest.Mock).mockReturnValue(mockCommunicator);
+
+    const result = Communicator.getInstance(mockWebBasedWallet);
+
+    expect(WebBasedWalletCommunicator.getInstance).toHaveBeenCalledWith('test-scheme://');
+    expect(result).toBe(mockCommunicator);
+  });
+
+  test('getInstance throws error for native wallet', () => {
+    const mockNativeWallet: Wallet = { type: 'native', scheme: 'native-scheme://' } as Wallet;
+
+    expect(() => Communicator.getInstance(mockNativeWallet)).toThrow(
+      'Native wallet not supported yet'
+    );
+  });
+
+  test('getInstance throws error for unsupported wallet type', () => {
+    const mockUnsupportedWallet: Wallet = {
+      type: 'unsupported' as any,
+      scheme: 'unsupported-scheme://',
+    } as Wallet;
+
+    expect(() => Communicator.getInstance(mockUnsupportedWallet)).toThrow(
+      'Unsupported wallet type'
+    );
+  });
+});

packages/client/src/components/communicator/Communicator.ts

@@ -0,0 +1,24 @@
+import { WebBasedWalletCommunicator } from './webBased/Communicator';
+import { RPCRequestMessage, RPCResponseMessage } from ':core/message';
+import { Wallet } from ':core/wallet';
+
+export interface CommunicatorInterface {
+  postRequestAndWaitForResponse: (message: RPCRequestMessage) => Promise<RPCResponseMessage>;
+  handleResponse: (responseUrl: string) => boolean;
+}
+
+export class Communicator {
+  static getInstance(wallet: Wallet): CommunicatorInterface {
+    const { type, scheme } = wallet;
+
+    if (type === 'webBased') {
+      return WebBasedWalletCommunicator.getInstance(scheme);
+    }
+
+    if (type === 'native') {
+      throw new Error('Native wallet not supported yet');
+    }
+
+    throw new Error('Unsupported wallet type');
+  }
+}

packages/client/src/components/communicator/handleResponse.test.ts

@@ -0,0 +1,65 @@
+import { handleResponse } from './handleResponse';
+import { WebBasedWalletCommunicator } from './webBased/Communicator';
+import { MWP_RESPONSE_PATH } from ':core/constants';
+import { Wallet } from ':core/wallet';
+
+jest.mock('./webBased/Communicator');
+jest.mock('expo-web-browser', () => ({
+  openBrowserAsync: jest.fn(),
+  WebBrowserPresentationStyle: {
+    FORM_SHEET: 'FORM_SHEET',
+  },
+  dismissBrowser: jest.fn(),
+}));
+
+describe('handleResponse', () => {
+  const mockWebBasedWallet = { type: 'webBased', scheme: 'https://example.com' } as Wallet;
+  const mockNativeWallet = { type: 'native' } as Wallet;
+  const mockOtherWallet = { type: 'other' as any } as Wallet;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('returns false for non-MWP response URLs', () => {
+    const url = 'https://example.com/some-path';
+    expect(handleResponse(url, mockWebBasedWallet)).toBe(false);
+  });
+
+  test('handles web-based wallet response correctly', () => {
+    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    const mockHandleResponse = jest.fn().mockReturnValue(true);
+    (WebBasedWalletCommunicator.getInstance as jest.Mock).mockReturnValue({
+      handleResponse: mockHandleResponse,
+    });
+
+    const result = handleResponse(url, mockWebBasedWallet);
+
+    expect(WebBasedWalletCommunicator.getInstance).toHaveBeenCalledWith(mockWebBasedWallet.scheme);
+    expect(mockHandleResponse).toHaveBeenCalledWith(url);
+    expect(result).toBe(true);
+  });
+
+  test('throws error for native wallet', () => {
+    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    expect(() => handleResponse(url, mockNativeWallet)).toThrow('Native wallet not supported yet');
+  });
+
+  test('returns false for unsupported wallet types', () => {
+    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    expect(handleResponse(url, mockOtherWallet)).toBe(false);
+  });
+
+  test('WebBasedWalletCommunicator.handleResponse returns false', () => {
+    const url = `https://example.com/${MWP_RESPONSE_PATH}/some-params`;
+    const mockHandleResponse = jest.fn().mockReturnValue(false);
+    (WebBasedWalletCommunicator.getInstance as jest.Mock).mockReturnValue({
+      handleResponse: mockHandleResponse,
+    });
+
+    const result = handleResponse(url, mockWebBasedWallet);
+
+    expect(mockHandleResponse).toHaveBeenCalledWith(url);
+    expect(result).toBe(false);
+  });
+});