test: add test codes (#8)

packages/sdk/src/core/__mocks__/mock-connection-manager.ts

@@ -0,0 +1,21 @@
+import { ConnectionState } from '../connection';
+import { WalletProvider } from '../providers';
+import { WalletConnectionEvent } from '../types';
+
+export const defineMockConnectionManager = () => {
+  jest.mock('../connection', () => ({
+    ConnectionManager: jest.fn(() => mockConnectionManager),
+  }));
+};
+
+export const mockConnectionManager = {
+  connectWallet: jest.fn<Promise<void>, []>(),
+  disconnectWallet: jest.fn<void, []>(),
+  getConnectionState: jest.fn<ConnectionState, []>(),
+  getWalletProvider: jest.fn<WalletProvider, []>(),
+  on: jest.fn<void, [(event: WalletConnectionEvent) => void]>(),
+  off: jest.fn<void, [(event: WalletConnectionEvent) => void]>(),
+  connectAdenaWallet: jest.fn<Promise<void>, []>(),
+  connectTM2Wallet: jest.fn<Promise<void>, []>(),
+  triggerConnectionEvent: jest.fn<void, [WalletConnectionEvent]>(),
+};

packages/sdk/src/core/__mocks__/mock-global.ts

@@ -4,8 +4,20 @@ export const defineGlobalMock = () => {
   Object.defineProperty(global, 'sessionStorage', {
     value: mockSessionStorage,
   });
+  Object.defineProperty(global, 'open', {
+    value: jest.fn(),
+    configurable: true,
+  });
+  Object.defineProperty(global, 'console', {
+    value: {
+      ...console,
+      error() {},
+    },
+  });
 };
 
 export const clearGlobalMock = () => {
   Object.defineProperty(global, 'sessionStorage', {});
+  Object.defineProperty(global, 'open', {});
+  Object.defineProperty(global, 'console', {});
 };

packages/sdk/src/core/__mocks__/mock-wallet-provider.ts

@@ -1,164 +1,64 @@
 import { WalletProvider } from '../providers';
-import { WalletResponseFailureType, WalletResponseStatus, WalletResponseSuccessType } from '../types';
+import {
+  TransactionResultSync,
+  WalletResponseFailureType,
+  WalletResponseRejectType,
+  WalletResponseSuccessType,
+} from '../types';
+import { makeResponseMessage } from '../utils';
+
+export const defineMockWalletProvider = () => {
+  jest.mock('../providers', () => ({
+    WalletProvider: jest.fn(() => mockWalletProvider),
+  }));
+};
 
 export const mockWalletProvider: jest.Mocked<WalletProvider> = {
-  isConnected: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-    message: 'Wallet is connected',
-    data: null,
-  }),
-  addEstablish: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-    message: 'Connection established',
-    data: null,
-  }),
-  getAccount: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.GET_ACCOUNT_SUCCESS,
-    message: 'Account retrieved',
-    data: { address: 'mock-address', connected: true },
-  }),
-  switchNetwork: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-    message: 'Network switched',
-    data: null,
-  }),
-  addNetwork: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.ADD_NETWORK_SUCCESS,
-    message: 'Network added',
-    data: null,
-  }),
-  signTransaction: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.SIGN_SUCCESS,
-    message: 'Transaction signed',
-    data: 'mock-signed-transaction',
-  }),
-  broadcastTransaction: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.TRANSACTION_SUCCESS,
-    message: 'Transaction broadcasted',
-    data: { result: 'mock-result' },
-  }),
+  isConnected: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS)),
+  addEstablish: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS)),
+  getAccount: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.GET_ACCOUNT_SUCCESS)),
+  switchNetwork: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS)),
+  addNetwork: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.ADD_NETWORK_SUCCESS)),
+  signTransaction: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.SIGN_SUCCESS)),
+  broadcastTransaction: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.TRANSACTION_SUCCESS)),
   onChangeAccount: jest.fn().mockImplementation(() => {
-    return {
-      code: 0,
-      status: WalletResponseStatus.SUCCESS,
-      type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-      message: 'Account change listener added',
-      data: null,
-    };
+    return;
   }),
   onChangeNetwork: jest.fn().mockImplementation(() => {
-    return {
-      code: 0,
-      status: WalletResponseStatus.SUCCESS,
-      type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-      message: 'Network change listener added',
-      data: null,
-    };
+    return;
   }),
 };
 
-jest.mock('../providers', () => ({
-  WalletProvider: jest.fn(() => mockWalletProvider),
-}));
+export const isConnectedSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS, true);
 
-export const isConnectedSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: true,
-};
+export const isConnectedFailureMock = makeResponseMessage(WalletResponseFailureType.ALREADY_CONNECTED, false);
 
-export const isConnectedFailureMock = {
-  code: 4000,
-  status: WalletResponseStatus.FAILURE,
-  type: WalletResponseFailureType.ALREADY_CONNECTED,
-  message: '',
-  data: false,
-};
+export const addEstablishSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS, true);
 
-export const addEstablishSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: null,
-};
+export const addEstablishFailureMock = makeResponseMessage(WalletResponseFailureType.ALREADY_CONNECTED, false);
 
-export const addEstablishFailureMock = {
-  code: 4000,
-  status: WalletResponseStatus.FAILURE,
-  type: WalletResponseFailureType.ALREADY_CONNECTED,
-  message: '',
-  data: null,
-};
+export const addEstablishRejectMock = makeResponseMessage(WalletResponseRejectType.CONNECTION_REJECTED, false);
 
-export const getAccountSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.GET_ACCOUNT_SUCCESS,
-  message: '',
-  data: { address: '' },
-};
+export const getAccountSuccessMock = makeResponseMessage(WalletResponseSuccessType.GET_ACCOUNT_SUCCESS);
 
-export const switchNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const switchNetworkSuccessMock = makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS);
 
-export const addNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.ADD_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const addNetworkSuccessMock = makeResponseMessage<void>(WalletResponseSuccessType.ADD_NETWORK_SUCCESS);
 
-export const signTransactionSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SIGN_SUCCESS,
-  message: '',
-  data: '',
-};
+export const addNetworkFailureMock = makeResponseMessage<void>(WalletResponseFailureType.UNADDED_NETWORK);
 
-export const broadcastTransactionSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.TRANSACTION_SUCCESS,
-  message: '',
-  data: { result: '' },
-};
+export const addNetworkRejectMock = makeResponseMessage<void>(WalletResponseRejectType.SWITCH_NETWORK_REJECTED);
 
-export const onChangeAccountSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: null,
-};
+export const signTransactionSuccessMock = makeResponseMessage(WalletResponseSuccessType.SIGN_SUCCESS);
 
-export const onChangeNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const broadcastTransactionSuccessMock = makeResponseMessage<TransactionResultSync>(
+  WalletResponseSuccessType.TRANSACTION_SUCCESS
+);
+
+export const broadcastTransactionFailureMock = makeResponseMessage<TransactionResultSync>(
+  WalletResponseFailureType.TRANSACTION_FAILED
+);
+
+export const onChangeAccountSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS);
+
+export const onChangeNetworkSuccessMock = makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS);

packages/sdk/src/core/__tests__/methods/add-establish.test.ts

@@ -0,0 +1,54 @@
+import {
+  addEstablishFailureMock,
+  addEstablishRejectMock,
+  addEstablishSuccessMock,
+  mockWalletProvider,
+} from '../../__mocks__/mock-wallet-provider';
+import { addEstablish } from '../../methods';
+import { AddEstablishOptions, AddEstablishResponse } from '../../types/methods';
+
+describe('addEstablish', () => {
+  const options: AddEstablishOptions = {
+    siteName: 'Test Site',
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call addEstablish with correct options and return the response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishSuccessMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(mockWalletProvider.addEstablish).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishFailureMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle reject response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishRejectMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should throw an error if addEstablish fails', async () => {
+    const mockError = new Error('Failed to establish connection');
+
+    mockWalletProvider.addEstablish.mockRejectedValue(mockError);
+
+    await expect(addEstablish(mockWalletProvider, options)).rejects.toThrow('Failed to establish connection');
+  });
+});

packages/sdk/src/core/__tests__/methods/add-network.test.ts

@@ -0,0 +1,43 @@
+import { addNetworkFailureMock, addNetworkSuccessMock, mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { addNetwork } from '../../methods';
+import { AddNetworkOptions, AddNetworkResponse } from '../../types/methods';
+
+describe('addNetwork', () => {
+  const options: AddNetworkOptions = {
+    chainId: 'test-chain-id',
+    chainName: 'Test Chain',
+    rpcUrl: 'https://test-rpc-url.com',
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call addNetwork with correct options and return the response', async () => {
+    const mockResponse: AddNetworkResponse = addNetworkSuccessMock;
+
+    mockWalletProvider.addNetwork.mockResolvedValue(mockResponse);
+
+    const response = await addNetwork(mockWalletProvider, options);
+
+    expect(mockWalletProvider.addNetwork).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const mockResponse: AddNetworkResponse = addNetworkFailureMock;
+
+    mockWalletProvider.addNetwork.mockResolvedValue(mockResponse);
+
+    const response = await addNetwork(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should throw an error if addNetwork fails', async () => {
+    const mockError = new Error('Failed to add network');
+    mockWalletProvider.addNetwork.mockRejectedValue(mockError);
+
+    await expect(addNetwork(mockWalletProvider, options)).rejects.toThrow('Failed to add network');
+  });
+});