test: update types in the unit tests

Author: jamaljsr

app/src/__tests__/components/loop/LoopPage.spec.tsx

@@ -3,6 +3,7 @@ import { runInAction } from 'mobx';
 import { SwapStatus } from 'types/generated/loop_pb';
 import { grpc } from '@improbable-eng/grpc-web';
 import { fireEvent, waitFor } from '@testing-library/react';
+import Big from 'big.js';
 import { saveAs } from 'file-saver';
 import { formatSats } from 'util/formatters';
 import { renderWithProviders } from 'util/tests';
@@ -70,9 +71,9 @@ describe('LoopPage component', () => {
     const { findByText } = render();
     // convert from numeric timestamp to string (1586390353623905000 -> '4/15/2020')
     const formatDate = (s: SwapStatus.AsObject) =>
-      new Date(s.initiationTime / 1000 / 1000).toLocaleDateString();
+      new Date(+Big(s.initiationTime).div(1000).div(1000)).toLocaleDateString();
     const [swap1, swap2] = loopListSwaps.swapsList.sort(
-      (a, b) => b.initiationTime - a.initiationTime,
+      (a, b) => +Big(b.initiationTime).sub(a.initiationTime),
     );
 
     expect(await findByText(formatDate(swap1))).toBeInTheDocument();

app/src/__tests__/components/loop/ProcessingSwaps.spec.tsx

@@ -2,6 +2,7 @@ import React from 'react';
 import { runInAction } from 'mobx';
 import * as LOOP from 'types/generated/loop_pb';
 import { fireEvent } from '@testing-library/react';
+import Big from 'big.js';
 import { renderWithProviders } from 'util/tests';
 import { loopListSwaps } from 'util/tests/sampleData';
 import { createStore, Store } from 'store';
@@ -27,7 +28,7 @@ describe('ProcessingSwaps component', () => {
     swap.id = `${id || ''}${swap.id}`;
     swap.type = type;
     swap.state = state;
-    swap.lastUpdateTime = Date.now() * 1000 * 1000;
+    swap.lastUpdateTime = Big(Date.now() * 1000 * 1000);
     runInAction(() => {
       store.swapStore.swaps.set(swap.id, swap);
     });

app/src/__tests__/components/pool/AccountSection.spec.tsx

@@ -117,7 +117,7 @@ describe('AccountSection', () => {
     });
 
     expect(store.accountStore.activeTraderKey).toBe(hex(poolInitAccount.traderKey));
-    expect(store.fundNewAccountView.amount).toBe(0);
+    expect(+store.fundNewAccountView.amount).toBe(0);
     expect(store.fundNewAccountView.confTarget).toBe(DEFAULT_CONF_TARGET);
     expect(store.fundNewAccountView.expireBlocks).toBe(DEFAULT_EXPIRE_BLOCKS);
   });
@@ -206,7 +206,7 @@ describe('AccountSection', () => {
       expect(getByText('Account')).toBeInTheDocument();
     });
 
-    expect(+store.accountStore.activeAccount.totalBalance).toBe(
+    expect(store.accountStore.activeAccount.totalBalance.toString()).toBe(
       poolDepositAccount.account.value,
     );
     expect(store.fundAccountView.amount).toBe(0);
@@ -322,7 +322,7 @@ describe('AccountSection', () => {
     });
 
     expect(req!.traderKey).toBe(b64(store.accountStore.activeAccount.traderKey));
-    expect(req!.outputWithFee?.feeRateSatPerKw).toBe(2500);
+    expect(req!.outputWithFee?.feeRateSatPerKw).toBe('2500');
     expect(req!.outputWithFee?.address).toBe('abc123');
   });
 
@@ -375,7 +375,7 @@ describe('AccountSection', () => {
     });
 
     expect(req!.accountKey).toBe(b64(store.accountStore.activeAccount.traderKey));
-    expect(req!.feeRateSatPerKw).toBe(31250);
+    expect(req!.feeRateSatPerKw).toBe('31250');
     expect(req!.relativeExpiry).toBe(2016);
   });
 });

app/src/__tests__/components/pool/BatchStats.spec.tsx

@@ -1,6 +1,7 @@
 import React from 'react';
 import { runInAction } from 'mobx';
 import { act, waitFor } from '@testing-library/react';
+import Big from 'big.js';
 import { formatSats } from 'util/formatters';
 import { renderWithProviders } from 'util/tests';
 import { createStore, Store } from 'store';
@@ -25,7 +26,7 @@ describe('BatchStats', () => {
     jest.useFakeTimers();
     runInAction(() => {
       const nowSecs = Math.ceil(Date.now() / 1000);
-      store.batchStore.nextBatchTimestamp = nowSecs + 90;
+      store.batchStore.nextBatchTimestamp = Big(nowSecs + 90);
     });
     const { getByText } = render();
     expect(getByText('Next Batch')).toBeInTheDocument();

app/src/__tests__/components/pool/OrderFormSection.spec.tsx

@@ -71,12 +71,12 @@ describe('OrderFormSection', () => {
     });
 
     fireEvent.click(getByText('Place Bid Order'));
-    expect(bid!.details.amt).toBe(1000000);
+    expect(bid!.details.amt).toBe('1000000');
     expect(bid!.details.rateFixed).toBe(4960);
     expect(bid!.details.minUnitsMatch).toBe(1);
     expect(bid!.leaseDurationBlocks).toBe(2016);
     expect(bid!.minNodeTier).toBe(1);
-    expect(bid!.details.maxBatchFeeRateSatPerKw).toBe(253);
+    expect(bid!.details.maxBatchFeeRateSatPerKw).toBe('253');
   });
 
   it('should submit an ask order', async () => {
@@ -95,11 +95,11 @@ describe('OrderFormSection', () => {
     });
 
     fireEvent.click(getByText('Place Ask Order'));
-    expect(ask!.details.amt).toBe(1000000);
+    expect(ask!.details.amt).toBe('1000000');
     expect(ask!.details.rateFixed).toBe(4960);
     expect(ask!.details.minUnitsMatch).toBe(1);
     expect(ask!.leaseDurationBlocks).toBe(2016);
-    expect(ask!.details.maxBatchFeeRateSatPerKw).toBe(253);
+    expect(ask!.details.maxBatchFeeRateSatPerKw).toBe('253');
   });
 
   it('should submit an order with a different lease duration', async () => {
@@ -119,12 +119,12 @@ describe('OrderFormSection', () => {
     });
 
     fireEvent.click(getByText('Place Bid Order'));
-    expect(bid!.details.amt).toBe(1000000);
+    expect(bid!.details.amt).toBe('1000000');
     expect(bid!.details.rateFixed).toBe(2480);
     expect(bid!.details.minUnitsMatch).toBe(1);
     expect(bid!.leaseDurationBlocks).toBe(4032);
     expect(bid!.minNodeTier).toBe(1);
-    expect(bid!.details.maxBatchFeeRateSatPerKw).toBe(253);
+    expect(bid!.details.maxBatchFeeRateSatPerKw).toBe('253');
   });
 
   it('should reset the form after placing an order', async () => {

app/src/__tests__/store/accountStore.spec.ts

@@ -46,8 +46,8 @@ describe('AccountStore', () => {
   });
 
   it('should return sorted accounts', async () => {
-    const a = new Account(rootStore, { ...poolInitAccount, value: 300 });
-    const b = new Account(rootStore, { ...poolInitAccount, value: 100 });
+    const a = new Account(rootStore, { ...poolInitAccount, value: '300' });
+    const b = new Account(rootStore, { ...poolInitAccount, value: '100' });
     const c = new Account(rootStore, {
       ...poolInitAccount,
       expirationHeight: 5000,
@@ -76,8 +76,8 @@ describe('AccountStore', () => {
   });
 
   it('should excluded closed accounts in sorted accounts', async () => {
-    const a = new Account(rootStore, { ...poolInitAccount, value: 300 });
-    const b = new Account(rootStore, { ...poolInitAccount, value: 100 });
+    const a = new Account(rootStore, { ...poolInitAccount, value: '300' });
+    const b = new Account(rootStore, { ...poolInitAccount, value: '100' });
     const c = new Account(rootStore, {
       ...poolInitAccount,
       expirationHeight: 5000,
@@ -158,7 +158,7 @@ describe('AccountStore', () => {
 
   it('should create a new Account', async () => {
     expect(store.accounts.size).toEqual(0);
-    await store.createAccount(3000000, 4032);
+    await store.createAccount(Big(3000000), 4032);
     expect(store.accounts.size).toEqual(1);
     expect(store.activeAccount).toBeDefined();
   });
@@ -168,7 +168,7 @@ describe('AccountStore', () => {
       throw new Error('test-err');
     });
     expect(rootStore.appView.alerts.size).toBe(0);
-    await store.createAccount(3000000, 4032);
+    await store.createAccount(Big(3000000), 4032);
     await waitFor(() => {
       expect(rootStore.appView.alerts.size).toBe(1);
       expect(values(rootStore.appView.alerts)[0].message).toBe('test-err');
@@ -216,7 +216,9 @@ describe('AccountStore', () => {
   it('should deposit funds into an account', async () => {
     await store.fetchAccounts();
     const txid = await store.deposit(1);
-    expect(+store.activeAccount.totalBalance).toBe(poolDepositAccount.account?.value);
+    expect(store.activeAccount.totalBalance.toString()).toBe(
+      poolDepositAccount.account?.value,
+    );
     expect(txid).toEqual(poolDepositAccount.depositTxid);
   });
 
@@ -236,7 +238,9 @@ describe('AccountStore', () => {
   it('should withdraw funds from an account', async () => {
     await store.fetchAccounts();
     const txid = await store.withdraw(1);
-    expect(+store.activeAccount.totalBalance).toBe(poolWithdrawAccount.account?.value);
+    expect(store.activeAccount.totalBalance.toString()).toBe(
+      poolWithdrawAccount.account?.value,
+    );
     expect(txid).toEqual(poolWithdrawAccount.withdrawTxid);
   });
 

app/src/__tests__/store/buildSwapView.spec.ts

@@ -111,15 +111,15 @@ describe('BuildSwapView', () => {
   });
 
   it('should ensure amount is greater than the min terms', async () => {
-    store.setAmount(Big(loopInTerms.minSwapAmount - 100));
+    store.setAmount(Big(loopInTerms.minSwapAmount).sub(100));
     await store.getTerms();
-    expect(+store.amountForSelected).toBe(loopInTerms.minSwapAmount);
+    expect(store.amountForSelected.toString()).toBe(loopInTerms.minSwapAmount);
   });
 
   it('should ensure amount is less than the max terms', async () => {
     store.setAmount(Big(loopInTerms.maxSwapAmount + 100));
     await store.getTerms();
-    expect(+store.amountForSelected).toBe(loopInTerms.maxSwapAmount);
+    expect(store.amountForSelected.toString()).toBe(loopInTerms.maxSwapAmount);
   });
 
   it('should validate the conf target', async () => {
@@ -293,7 +293,7 @@ describe('BuildSwapView', () => {
     store.setDirection(SwapDirection.OUT);
     store.setAmount(Big(600));
 
-    let deadline = 0;
+    let deadline = '';
     // mock the grpc unary function in order to capture the supplied deadline
     // passed in with the API request
     injectIntoGrpcUnary((desc, props) => {
@@ -303,7 +303,7 @@ describe('BuildSwapView', () => {
     // run a loop on mainnet and verify the deadline
     rootStore.nodeStore.network = 'mainnet';
     store.requestSwap();
-    await waitFor(() => expect(deadline).toBeGreaterThan(0));
+    await waitFor(() => expect(+deadline).toBeGreaterThan(0));
 
     // inject again for the next swap
     injectIntoGrpcUnary((desc, props) => {
@@ -313,7 +313,7 @@ describe('BuildSwapView', () => {
     // run a loop on regtest and verify the deadline
     rootStore.nodeStore.network = 'regtest';
     store.requestSwap();
-    await waitFor(() => expect(deadline).toEqual(0));
+    await waitFor(() => expect(+deadline).toEqual(0));
   });
 
   it('should handle errors when performing a loop', async () => {
@@ -370,7 +370,12 @@ describe('BuildSwapView', () => {
   describe('min/max swap limits', () => {
     const addChannel = (capacity: number, localBalance: number) => {
       const remoteBalance = capacity - localBalance;
-      const lndChan = { ...lndChannel, capacity, localBalance, remoteBalance };
+      const lndChan = {
+        ...lndChannel,
+        capacity: `${capacity}`,
+        localBalance: `${localBalance}`,
+        remoteBalance: `${remoteBalance}`,
+      };
       const channel = Channel.create(rootStore, lndChan);
       channel.chanId = `${channel.chanId}${rootStore.channelStore.channels.size}`;
       channel.remotePubkey = `${channel.remotePubkey}${rootStore.channelStore.channels.size}`;

app/src/__tests__/store/channelStore.spec.ts

@@ -134,21 +134,21 @@ describe('ChannelStore', () => {
   it('should compute inbound liquidity', async () => {
     await store.fetchChannels();
     const inbound = lndListChannels.channelsList.reduce(
-      (sum, chan) => sum + chan.remoteBalance,
-      0,
+      (sum, chan) => sum.plus(chan.remoteBalance),
+      Big(0),
     );
 
-    expect(+store.totalInbound).toBe(inbound);
+    expect(+store.totalInbound).toBe(+inbound);
   });
 
   it('should compute outbound liquidity', async () => {
     await store.fetchChannels();
     const outbound = lndListChannels.channelsList.reduce(
-      (sum, chan) => sum + chan.localBalance,
-      0,
+      (sum, chan) => sum.plus(chan.localBalance),
+      Big(0),
     );
 
-    expect(+store.totalOutbound).toBe(outbound);
+    expect(+store.totalOutbound).toBe(+outbound);
   });
 
   it('should fetch aliases for channels', async () => {
@@ -189,7 +189,9 @@ describe('ChannelStore', () => {
     expect(channel.remoteFeeRate).toBe(0);
     // the alias is fetched from the API and should be updated after a few ticks
     await waitFor(() => {
-      expect(channel.remoteFeeRate).toBe(lndGetChanInfo.node1Policy.feeRateMilliMsat);
+      expect(channel.remoteFeeRate.toString()).toBe(
+        lndGetChanInfo.node1Policy.feeRateMilliMsat,
+      );
     });
   });
 

app/src/__tests__/store/nodeStore.spec.ts

@@ -49,8 +49,8 @@ describe('NodeStore', () => {
     expect(+store.wallet.channelBalance).toBe(0);
     expect(+store.wallet.walletBalance).toBe(0);
     await store.fetchBalances();
-    expect(+store.wallet.channelBalance).toEqual(lndChannelBalance.balance);
-    expect(+store.wallet.walletBalance).toEqual(lndWalletBalance.totalBalance);
+    expect(store.wallet.channelBalance.toString()).toEqual(lndChannelBalance.balance);
+    expect(store.wallet.walletBalance.toString()).toEqual(lndWalletBalance.totalBalance);
   });
 
   it('should handle errors fetching balances', async () => {
@@ -69,14 +69,14 @@ describe('NodeStore', () => {
   it('should handle a transaction event', () => {
     expect(+store.wallet.walletBalance).toBe(0);
     store.onTransaction(lndTransaction);
-    expect(+store.wallet.walletBalance).toBe(lndTransaction.amount);
+    expect(store.wallet.walletBalance.toString()).toBe(lndTransaction.amount);
   });
 
   it('should handle duplicate transaction events', () => {
     expect(+store.wallet.walletBalance).toBe(0);
     store.onTransaction(lndTransaction);
-    expect(+store.wallet.walletBalance).toBe(lndTransaction.amount);
+    expect(store.wallet.walletBalance.toString()).toBe(lndTransaction.amount);
     store.onTransaction(lndTransaction);
-    expect(+store.wallet.walletBalance).toBe(lndTransaction.amount);
+    expect(store.wallet.walletBalance.toString()).toBe(lndTransaction.amount);
   });
 });

app/src/__tests__/store/orderStore.spec.ts

@@ -75,13 +75,27 @@ describe('OrderStore', () => {
 
   it('should submit an ask order', async () => {
     await rootStore.accountStore.fetchAccounts();
-    const nonce = await store.submitOrder(OrderType.Ask, 100000, 2000, 2016, 100000, 253);
+    const nonce = await store.submitOrder(
+      OrderType.Ask,
+      Big(100000),
+      2000,
+      2016,
+      100000,
+      253,
+    );
     expect(nonce).toBe(hex(poolSubmitOrder.acceptedOrderNonce));
   });
 
   it('should submit a bid order', async () => {
     await rootStore.accountStore.fetchAccounts();
-    const nonce = await store.submitOrder(OrderType.Bid, 100000, 2000, 2016, 100000, 253);
+    const nonce = await store.submitOrder(
+      OrderType.Bid,
+      Big(100000),
+      2000,
+      2016,
+      100000,
+      253,
+    );
     expect(nonce).toBe(hex(poolSubmitOrder.acceptedOrderNonce));
   });
 
@@ -100,14 +114,14 @@ describe('OrderStore', () => {
       }
       return undefined as any;
     });
-    await store.submitOrder(OrderType.Bid, 100000, 2000, 2016, 100000, 253);
+    await store.submitOrder(OrderType.Bid, Big(100000), 2000, 2016, 100000, 253);
     expect(rootStore.appView.alerts.size).toBe(1);
     expect(values(rootStore.appView.alerts)[0].message).toBe(poolInvalidOrder.failString);
   });
 
   it('should throw if the fixed rate rate is too low', async () => {
     await rootStore.accountStore.fetchAccounts();
-    await store.submitOrder(OrderType.Bid, 100000, 0.9, 20000, 100000, 253);
+    await store.submitOrder(OrderType.Bid, Big(100000), 0.9, 20000, 100000, 253);
     expect(rootStore.appView.alerts.size).toBe(1);
     expect(values(rootStore.appView.alerts)[0].message).toMatch(/The rate is too low.*/);
   });