add batchtransfertokens tests

Author: sstraatemans

packages/apps/rwa-demo/src/hooks/__tests__/batchTransferTokens.test.ts

@@ -0,0 +1,210 @@
+import { renderHook } from '@testing-library/react-hooks';
+import { useBatchTransferTokens } from '../batchTransferTokens';
+import { useGetInvestors } from '../getInvestors';
+
+describe('batchTransferTokens hook', () => {
+  const mocksHook = vi.hoisted(() => {
+    return {
+      useAsset: vi.fn().mockReturnValue({
+        paused: true,
+      }),
+      useFreeze: vi.fn().mockReturnValue({
+        frozen: false,
+      }),
+      useGetInvestors: vi.fn().mockReturnValue({
+        data: [
+          { accountName: 'k:he-man', alias: 'he-man' },
+          { accountName: 'k:skeletor', alias: 'skeletor' },
+        ],
+      }),
+      useAccount: vi.fn().mockReturnValue({
+        account: {
+          address: 'k:he-man',
+        },
+        sign: vi.fn(),
+        isMounted: true,
+        isInvestor: true,
+        balance: 0,
+      }),
+
+      useTransactions: vi.fn().mockReturnValue({
+        addTransaction: vi.fn(),
+      }),
+      useNotifications: vi.fn().mockReturnValue({
+        addNotification: vi.fn(),
+      }),
+    };
+  });
+
+  beforeEach(async () => {
+    vi.mock('./../account', async () => {
+      const actual = await vi.importActual('./../account');
+      return {
+        ...actual,
+        useAccount: mocksHook.useAccount,
+      };
+    });
+
+    vi.mock('./../freeze', async () => {
+      const actual = await vi.importActual('./../freeze');
+      return {
+        ...actual,
+        useFreeze: mocksHook.useFreeze,
+      };
+    });
+
+    vi.mock('./../getInvestors', async () => {
+      const actual = await vi.importActual('./../getInvestors');
+      return {
+        ...actual,
+        useGetInvestors: mocksHook.useGetInvestors,
+      };
+    });
+
+    vi.mock('./../asset', async () => {
+      const actual = await vi.importActual('./../asset');
+      return {
+        ...actual,
+        useAsset: mocksHook.useAsset,
+      };
+    });
+
+    vi.mock('./../transactions', async () => {
+      const actual = await vi.importActual('./../transactions');
+      return {
+        ...actual,
+        useTransactions: mocksHook.useTransactions,
+      };
+    });
+
+    vi.mock('@kadena/kode-ui/patterns', async () => {
+      const actual = await vi.importActual('@kadena/kode-ui/patterns');
+      return {
+        ...actual,
+        useNotifications: mocksHook.useNotifications,
+      };
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return the correct properties', async () => {
+    const { result } = renderHook(() => useBatchTransferTokens());
+    expect(result.current.hasOwnProperty('isAllowed')).toBe(true);
+    expect(result.current.hasOwnProperty('submit')).toBe(true);
+  });
+
+  describe('isAllowed', () => {
+    it('should return true, when account is Mounted when contract is NOT paused,when account is not frozen, when account isInvestor', () => {
+      mocksHook.useAccount.mockImplementation(() => ({
+        ...mocksHook.useAccount.getMockImplementation(),
+        isMounted: true,
+        isInvestor: true,
+      }));
+
+      mocksHook.useAsset.mockImplementation(() => ({
+        ...mocksHook.useAsset.getMockImplementation(),
+        paused: false,
+      }));
+
+      mocksHook.useFreeze.mockImplementation(() => ({
+        ...mocksHook.useFreeze.getMockImplementation(),
+        frozen: false,
+      }));
+
+      const { result } = renderHook(() => useBatchTransferTokens());
+
+      expect(result.current.isAllowed).toBe(true);
+    });
+
+    it('should return false, when account is NOT Mounted when contract is NOT paused,when account is not frozen, when account isInvestor', () => {
+      mocksHook.useAccount.mockImplementation(() => ({
+        ...mocksHook.useAccount.getMockImplementation(),
+        isMounted: false,
+        isInvestor: true,
+      }));
+
+      mocksHook.useAsset.mockImplementation(() => ({
+        ...mocksHook.useAsset.getMockImplementation(),
+        paused: false,
+      }));
+
+      mocksHook.useFreeze.mockImplementation(() => ({
+        ...mocksHook.useFreeze.getMockImplementation(),
+        frozen: false,
+      }));
+
+      const { result } = renderHook(() => useBatchTransferTokens());
+
+      expect(result.current.isAllowed).toBe(false);
+    });
+
+    it('should return false, when account is Mounted when contract is paused,when account is not frozen, when account isInvestor', () => {
+      mocksHook.useAccount.mockImplementation(() => ({
+        ...mocksHook.useAccount.getMockImplementation(),
+        isMounted: true,
+        isInvestor: true,
+      }));
+
+      mocksHook.useAsset.mockImplementation(() => ({
+        ...mocksHook.useAsset.getMockImplementation(),
+        paused: true,
+      }));
+
+      mocksHook.useFreeze.mockImplementation(() => ({
+        ...mocksHook.useFreeze.getMockImplementation(),
+        frozen: false,
+      }));
+
+      const { result } = renderHook(() => useBatchTransferTokens());
+
+      expect(result.current.isAllowed).toBe(false);
+    });
+
+    it('should return false, when account is Mounted when contract is NOT paused,when account is frozen, when account isInvestor', () => {
+      mocksHook.useAccount.mockImplementation(() => ({
+        ...mocksHook.useAccount.getMockImplementation(),
+        isMounted: true,
+        isInvestor: true,
+      }));
+
+      mocksHook.useAsset.mockImplementation(() => ({
+        ...mocksHook.useAsset.getMockImplementation(),
+        paused: false,
+      }));
+
+      mocksHook.useFreeze.mockImplementation(() => ({
+        ...mocksHook.useFreeze.getMockImplementation(),
+        frozen: true,
+      }));
+
+      const { result } = renderHook(() => useBatchTransferTokens());
+
+      expect(result.current.isAllowed).toBe(false);
+    });
+
+    it('should return false, when account is Mounted when contract is NOT paused,when account is NOT frozen, when account NOT isInvestor', () => {
+      mocksHook.useAccount.mockImplementation(() => ({
+        ...mocksHook.useAccount.getMockImplementation(),
+        isMounted: true,
+        isInvestor: false,
+      }));
+
+      mocksHook.useAsset.mockImplementation(() => ({
+        ...mocksHook.useAsset.getMockImplementation(),
+        paused: false,
+      }));
+
+      mocksHook.useFreeze.mockImplementation(() => ({
+        ...mocksHook.useFreeze.getMockImplementation(),
+        frozen: false,
+      }));
+
+      const { result } = renderHook(() => useBatchTransferTokens());
+
+      expect(result.current.isAllowed).toBe(false);
+    });
+  });
+});