Merge branch 'develop' into brian/polygonzeroaddress

.circleci/scripts/check_mmi_trigger.sh

@@ -9,6 +9,12 @@ if [ -z "$CIRCLE_PULL_REQUEST" ] || [ -z "$GITHUB_TOKEN" ]; then
   exit 0
 fi
 
+if [[ $CIRCLE_BRANCH = 'develop' || $CIRCLE_BRANCH = 'master' || $CIRCLE_BRANCH =~ ^Version-v[0-9.]* ]]; then
+  echo "Long-running branch detected, running MMI tests."
+  echo "run_mmi_tests=true" > mmi_trigger.env
+  exit 0
+fi
+
 # Extract PR number from the pull request URL
 PR_NUMBER=$(echo "$CIRCLE_PULL_REQUEST" | awk -F'/' '{print $NF}')
 

ui/hooks/useAccountTrackerPolling.test.ts

@@ -0,0 +1,143 @@
+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(),
+}));
+
+let originalPortfolioView: string | undefined;
+
+describe('useAccountTrackerPolling', () => {
+  beforeEach(() => {
+    // Mock process.env.PORTFOLIO_VIEW
+    originalPortfolioView = process.env.PORTFOLIO_VIEW;
+    process.env.PORTFOLIO_VIEW = 'true'; // Set your desired mock value here
+
+    mockPromises = [];
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Restore the original value
+    process.env.PORTFOLIO_VIEW = originalPortfolioView;
+  });
+
+  it('should poll account trackers for network client IDs when enabled and stop on dismount', async () => {
+    process.env.PORTFOLIO_VIEW = 'true';
+
+    const state = {
+      metamask: {
+        isUnlocked: true,
+        completedOnboarding: true,
+        selectedNetworkClientId: 'selectedNetworkClientId',
+        networkConfigurationsByChainId: {
+          '0x1': {
+            chainId: '0x1',
+            defaultRpcEndpointIndex: 0,
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId',
+              },
+            ],
+          },
+          '0x89': {
+            chainId: '0x89',
+            defaultRpcEndpointIndex: 0,
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId2',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { unmount } = renderHookWithProvider(
+      () => useAccountTrackerPolling(),
+      state,
+    );
+
+    // Should poll each client ID
+    await Promise.all(mockPromises);
+    expect(accountTrackerStartPolling).toHaveBeenCalledTimes(2);
+    expect(accountTrackerStartPolling).toHaveBeenCalledWith(
+      'selectedNetworkClientId',
+    );
+    expect(accountTrackerStartPolling).toHaveBeenCalledWith(
+      'selectedNetworkClientId2',
+    );
+
+    // Stop polling on dismount
+    unmount();
+    expect(accountTrackerStopPollingByPollingToken).toHaveBeenCalledTimes(2);
+    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,128 @@
+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',
+              },
+            ],
+          },
+          '0x89': {
+            nativeCurrency: 'BNB',
+            defaultRpcEndpointIndex: 0,
+            rpcEndpoints: [
+              {
+                networkClientId: 'selectedNetworkClientId2',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const { unmount } = renderHookWithProvider(
+      () => useCurrencyRatePolling(),
+      state,
+    );
+
+    await Promise.all(mockPromises);
+    expect(currencyRateStartPolling).toHaveBeenCalledTimes(1);
+    expect(currencyRateStartPolling).toHaveBeenCalledWith(['ETH', 'BNB']);
+
+    // Stop polling on dismount
+    unmount();
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledTimes(1);
+    expect(currencyRateStopPollingByPollingToken).toHaveBeenCalledWith(
+      'ETH,BNB_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);
+  });
+});