feat: added test coverage

Author: Matt561

app/components/UI/Earn/selectors/featureFlags/index.test.ts

@@ -14,6 +14,8 @@ import {
   selectMusdConversionBlockedCountries,
   parseBlockedCountriesEnv,
   selectMusdConversionMinAssetBalanceRequired,
+  selectMusdTokenRegistrationChainIds,
+  MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK,
 } from '.';
 import mockedEngine from '../../../../../core/__mocks__/MockedEngine';
 import type { Json } from '@metamask/utils';
@@ -2146,4 +2148,58 @@ describe('Earn Feature Flag Selectors', () => {
       expect(result).toBe(0.01);
     });
   });
+
+  describe('selectMusdTokenRegistrationChainIds', () => {
+    it('returns chain IDs from remote flag when the flag is a non-empty array', () => {
+      const stateWithRemote = createStateWithRemoteFlags({
+        earnMusdTokenRegistrationChainIds: { chainIds: ['0x1', '0xe708'] },
+      });
+
+      const result = selectMusdTokenRegistrationChainIds(stateWithRemote);
+
+      expect(result).toEqual(['0x1', '0xe708']);
+    });
+
+    it('returns fallback chain IDs when remote flag is absent', () => {
+      const stateWithoutRemote = createStateWithRemoteFlags({});
+
+      const result = selectMusdTokenRegistrationChainIds(stateWithoutRemote);
+
+      expect(result).toEqual([...MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK]);
+    });
+
+    it('returns fallback chain IDs when remote flag chainIds is an empty array', () => {
+      const stateWithEmptyRemote = createStateWithRemoteFlags({
+        earnMusdTokenRegistrationChainIds: { chainIds: [] },
+      });
+
+      const result = selectMusdTokenRegistrationChainIds(stateWithEmptyRemote);
+
+      expect(result).toEqual([...MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK]);
+    });
+
+    it('returns fallback chain IDs when remote flag chainIds is not an array', () => {
+      const stateWithInvalidRemote = createStateWithRemoteFlags({
+        earnMusdTokenRegistrationChainIds: { chainIds: 'not-an-array' },
+      });
+
+      const result = selectMusdTokenRegistrationChainIds(
+        stateWithInvalidRemote,
+      );
+
+      expect(result).toEqual([...MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK]);
+    });
+
+    it('returns fallback chain IDs when remote flag is present but has no chainIds property', () => {
+      const stateWithMissingChainIds = createStateWithRemoteFlags({
+        earnMusdTokenRegistrationChainIds: {},
+      });
+
+      const result = selectMusdTokenRegistrationChainIds(
+        stateWithMissingChainIds,
+      );
+
+      expect(result).toEqual([...MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK]);
+    });
+  });
 });

app/components/UI/Earn/selectors/featureFlags/index.ts

@@ -367,7 +367,6 @@ export const MUSD_TOKEN_REGISTRATION_CHAIN_IDS_FALLBACK = [
  * Remote flag takes precedence over the local fallback.
  * If both are unavailable or invalid, defaults to mainnet and Linea.
  */
-// TODO: Test me
 export const selectMusdTokenRegistrationChainIds = createSelector(
   selectRemoteFeatureFlags,
   (remoteFeatureFlags): string[] => {

app/components/UI/Earn/utils/musdConversionTransaction.test.ts

@@ -14,6 +14,7 @@ import { parseStandardTokenTransactionData } from '../../../Views/confirmations/
 import { MUSD_TOKEN_ADDRESS_BY_CHAIN } from '../constants/musd';
 import {
   createMusdConversionTransaction,
+  ensureMusdTokenRegistered,
   replaceMusdConversionTransactionForPayToken,
 } from './musdConversionTransaction';
 
@@ -54,6 +55,11 @@ jest.mock('../constants/musd', () => ({
    * Mutable mapping so tests can override per-case.
    */
   MUSD_TOKEN_ADDRESS_BY_CHAIN: {},
+  MUSD_TOKEN: {
+    symbol: 'mUSD',
+    name: 'MetaMask USD',
+    decimals: 6,
+  },
 }));
 
 type MockedFindNetworkClientIdByChainId = (chainId: Hex) => string | undefined;
@@ -91,6 +97,23 @@ interface MockedEngineContext {
   ApprovalController?: {
     rejectRequest: jest.Mock<void, [string, unknown]>;
   };
+  TokensController?: {
+    state: {
+      allTokens: Record<string, Record<string, { address: string }[]>>;
+    };
+    addToken: jest.Mock<
+      Promise<void>,
+      [
+        {
+          address: string;
+          decimals: number;
+          name: string;
+          symbol: string;
+          networkClientId: string;
+        },
+      ]
+    >;
+  };
 }
 
 const mockedProviderErrors = providerErrors as jest.Mocked<
@@ -162,6 +185,19 @@ describe('musdConversionTransaction', () => {
 
   const approvalControllerReject = jest.fn<void, [string, unknown]>();
 
+  const tokensControllerAddToken = jest.fn<
+    Promise<void>,
+    [
+      {
+        address: string;
+        decimals: number;
+        name: string;
+        symbol: string;
+        networkClientId: string;
+      },
+    ]
+  >();
+
   beforeEach(() => {
     jest.clearAllMocks();
 
@@ -182,6 +218,10 @@ describe('musdConversionTransaction', () => {
       ApprovalController: {
         rejectRequest: approvalControllerReject,
       },
+      TokensController: {
+        state: { allTokens: {} },
+        addToken: tokensControllerAddToken,
+      },
     };
 
     (MUSD_TOKEN_ADDRESS_BY_CHAIN as Record<string, Hex>)['0x1'] =
@@ -721,4 +761,117 @@ describe('musdConversionTransaction', () => {
       expect(newTransactionId).toBeUndefined();
     });
   });
+
+  describe('ensureMusdTokenRegistered', () => {
+    const MUSD_ADDRESS = '0xmusdAddress' as Hex;
+    const CHAIN_ID = '0x1' as Hex;
+    const NETWORK_CLIENT_ID = 'mainnet';
+
+    beforeEach(() => {
+      (MUSD_TOKEN_ADDRESS_BY_CHAIN as Record<string, Hex>)[CHAIN_ID] =
+        MUSD_ADDRESS;
+    });
+
+    describe('when mUSD token address is not configured for the chain', () => {
+      it('returns early without calling addToken', async () => {
+        const unknownChainId = '0xdead' as Hex;
+
+        await ensureMusdTokenRegistered({
+          chainId: unknownChainId,
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+
+        expect(tokensControllerAddToken).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when mUSD token is already registered for the chain', () => {
+      it('does not call addToken when the token exists for one account', async () => {
+        mockedEngine.context.TokensController = {
+          state: {
+            allTokens: {
+              [CHAIN_ID]: {
+                '0xaccountAddress': [{ address: MUSD_ADDRESS }],
+              },
+            },
+          },
+          addToken: tokensControllerAddToken,
+        };
+
+        await ensureMusdTokenRegistered({
+          chainId: CHAIN_ID,
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+
+        expect(tokensControllerAddToken).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when mUSD token is not yet registered', () => {
+      it('calls addToken with the correct token metadata and networkClientId', async () => {
+        mockedEngine.context.TokensController = {
+          state: { allTokens: {} },
+          addToken: tokensControllerAddToken,
+        };
+        tokensControllerAddToken.mockResolvedValue(undefined);
+
+        await ensureMusdTokenRegistered({
+          chainId: CHAIN_ID,
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+
+        expect(tokensControllerAddToken).toHaveBeenCalledTimes(1);
+        expect(tokensControllerAddToken).toHaveBeenCalledWith({
+          address: MUSD_ADDRESS,
+          decimals: 6,
+          name: 'MetaMask USD',
+          symbol: 'mUSD',
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+      });
+
+      it('calls addToken when the chain entry exists but no accounts hold mUSD', async () => {
+        mockedEngine.context.TokensController = {
+          state: {
+            allTokens: {
+              [CHAIN_ID]: {
+                '0xaccountAddress': [{ address: '0xdifferentTokenAddress' }],
+              },
+            },
+          },
+          addToken: tokensControllerAddToken,
+        };
+        tokensControllerAddToken.mockResolvedValue(undefined);
+
+        await ensureMusdTokenRegistered({
+          chainId: CHAIN_ID,
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+
+        expect(tokensControllerAddToken).toHaveBeenCalledTimes(1);
+        expect(tokensControllerAddToken).toHaveBeenCalledWith({
+          address: MUSD_ADDRESS,
+          decimals: 6,
+          name: 'MetaMask USD',
+          symbol: 'mUSD',
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+      });
+
+      it('calls addToken when allTokens has no entry for the chain', async () => {
+        mockedEngine.context.TokensController = {
+          state: { allTokens: { '0xe708': {} } },
+          addToken: tokensControllerAddToken,
+        };
+        tokensControllerAddToken.mockResolvedValue(undefined);
+
+        await ensureMusdTokenRegistered({
+          chainId: CHAIN_ID,
+          networkClientId: NETWORK_CLIENT_ID,
+        });
+
+        expect(tokensControllerAddToken).toHaveBeenCalledTimes(1);
+      });
+    });
+  });
 });