fix: add unit test for assets polling loops

ui/hooks/useAccountTrackerPolling.test.ts

@@ -0,0 +1,118 @@
+import { renderHookWithProvider } from '../../test/lib/render-helpers';
+import {
+  accountTrackerStartPolling,
+  accountTrackerStopPollingByPollingToken,
+} from '../store/actions';
+import useAccountTrackerPolling from './useAccountTrackerPolling';
+
+let mockPromises: Promise<string>[];
+
+jest.mock('../store/actions', () => ({
+  accountTrackerStartPolling: jest.fn().mockImplementation((input) => {
+    const promise = Promise.resolve(`${input}_tracking`);
+    mockPromises.push(promise);
+    return promise;
+  }),
+  accountTrackerStopPollingByPollingToken: jest.fn(),
+}));
+
+describe('useAccountTrackerPolling', () => {
+  beforeEach(() => {
+    mockPromises = [];
+    jest.clearAllMocks();
+  });
+
+  it('should poll account trackers for network client IDs when enabled and stop on dismount', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        selectedNetworkClientId: 'selectedNetworkClientId',
+        networkConfigurationsByChainId: {
+          '0x1': {
+            chainId: '0x1',
+            defaultRpcEndpointIndex: 0,
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { unmount } = renderHookWithProvider(
+      () => useAccountTrackerPolling(),
+      state,
+    );
+
+    // Should poll each client ID
+    await Promise.all(mockPromises);
+    expect(accountTrackerStartPolling).toHaveBeenCalledTimes(1);
+    expect(accountTrackerStartPolling).toHaveBeenCalledWith(
+      'selectedNetworkClientId',
+    );
+
+    // Stop polling on dismount
+    unmount();
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledTimes(1);
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledWith(
+      'selectedNetworkClientId_tracking',
+    );
+  });
+
+  it('should not poll if onboarding is not completed', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: false,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useAccountTrackerPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(accountTrackerStartPolling).toHaveBeenCalledTimes(0);
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when locked', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: false,
+        completedOnboarding: true,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useAccountTrackerPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(accountTrackerStartPolling).toHaveBeenCalledTimes(0);
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when no network client IDs are provided', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useAccountTrackerPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(accountTrackerStartPolling).toHaveBeenCalledTimes(0);
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+});

ui/hooks/useCurrencyRatePolling.test.ts

@@ -0,0 +1,119 @@
+import { renderHookWithProvider } from '../../test/lib/render-helpers';
+import {
+  currencyRateStartPolling,
+  currencyRateStopPollingByPollingToken,
+} from '../store/actions';
+import useCurrencyRatePolling from './useCurrencyRatePolling';
+
+let mockPromises: Promise<string>[];
+
+jest.mock('../store/actions', () => ({
+  currencyRateStartPolling: jest.fn().mockImplementation((input) => {
+    const promise = Promise.resolve(`${input}_rates`);
+    mockPromises.push(promise);
+    return promise;
+  }),
+  currencyRateStopPollingByPollingToken: jest.fn(),
+}));
+
+describe('useCurrencyRatePolling', () => {
+  beforeEach(() => {
+    mockPromises = [];
+    jest.clearAllMocks();
+  });
+
+  it('should poll currency rates for native currencies when enabled and stop on dismount', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        useCurrencyRateCheck: true,
+        selectedNetworkClientId: 'selectedNetworkClientId',
+        networkConfigurationsByChainId: {
+          '0x1': {
+            nativeCurrency: 'ETH',
+            defaultRpcEndpointIndex: 0,
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { unmount } = renderHookWithProvider(
+      () => useCurrencyRatePolling(),
+      state,
+    );
+
+    await Promise.all(mockPromises);
+    expect(currencyRateStartPolling).toHaveBeenCalledTimes(1);
+    expect(currencyRateStartPolling).toHaveBeenCalledWith(['ETH']);
+
+    // Stop polling on dismount
+    unmount();
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledTimes(1);
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledWith(
+      'ETH_rates',
+    );
+  });
+
+  it('should not poll if onboarding is not completed', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: false,
+        useCurrencyRateCheck: true,
+        networkConfigurationsByChainId: {
+          '0x1': { nativeCurrency: 'ETH' },
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useCurrencyRatePolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(currencyRateStartPolling).toHaveBeenCalledTimes(0);
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when locked', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: false,
+        completedOnboarding: true,
+        useCurrencyRateCheck: true,
+        networkConfigurationsByChainId: {
+          '0x1': { nativeCurrency: 'ETH' },
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useCurrencyRatePolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(currencyRateStartPolling).toHaveBeenCalledTimes(0);
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when currency rate checking is disabled', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        useCurrencyRateCheck: false,
+        networkConfigurationsByChainId: {
+          '0x1': { nativeCurrency: 'ETH' },
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useCurrencyRatePolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(currencyRateStartPolling).toHaveBeenCalledTimes(0);
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+});

ui/hooks/useTokenDetectionPolling.test.ts

@@ -0,0 +1,139 @@
+import { renderHookWithProvider } from '../../test/lib/render-helpers';
+import {
+  tokenDetectionStartPolling,
+  tokenDetectionStopPollingByPollingToken,
+} from '../store/actions';
+import useTokenDetectionPolling from './useTokenDetectionPolling';
+
+let mockPromises: Promise<string>[];
+
+jest.mock('../store/actions', () => ({
+  tokenDetectionStartPolling: jest.fn().mockImplementation((input) => {
+    console.log('PASSING HERE ....', input);
+    const promise = Promise.resolve(`${input}_detection`);
+    mockPromises.push(promise);
+    return promise;
+  }),
+  tokenDetectionStopPollingByPollingToken: jest.fn(),
+}));
+
+describe('useTokenDetectionPolling', () => {
+  beforeEach(() => {
+    mockPromises = [];
+    jest.clearAllMocks();
+  });
+
+  it('should poll token detection for chain IDs when enabled and stop on dismount', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        useTokenDetection: true,
+        selectedNetworkClientId: 'selectedNetworkClientId',
+        networkConfigurationsByChainId: {
+          '0x1': {
+            chainId: '0x1',
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { unmount } = renderHookWithProvider(
+      () => useTokenDetectionPolling(),
+      state,
+    );
+
+    // Should poll each chain
+    await Promise.all(mockPromises);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledTimes(1);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledWith(['0x1']);
+
+    // Stop polling on dismount
+    unmount();
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledTimes(1);
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledWith(
+      '0x1_detection',
+    );
+  });
+
+  it('should not poll if onboarding is not completed', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: false,
+        useTokenDetection: true,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useTokenDetectionPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledTimes(0);
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when locked', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: false,
+        completedOnboarding: true,
+        useTokenDetection: true,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useTokenDetectionPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledTimes(0);
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when token detection is disabled', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        useTokenDetection: false,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useTokenDetectionPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledTimes(0);
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not poll when no chains are provided', async () => {
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        useTokenDetection: true,
+        networkConfigurationsByChainId: {
+          '0x1': {},
+        },
+      },
+    };
+
+    renderHookWithProvider(() => useTokenDetectionPolling(), state);
+
+    await Promise.all(mockPromises);
+    expect(tokenDetectionStartPolling).toHaveBeenCalledTimes(0);
+    expect(tokenDetectionStopPollingByPollingToken).toHaveBeenCalledTimes(0);
+  });
+});