test: add os support

Author: racitores

app/components/UI/Bridge/Views/BridgeView/BridgeView.integration.test.tsx

@@ -9,8 +9,9 @@ import { renderIntegrationScreenWithRoutes } from '../../../../../util/test/inte
 import Routes from '../../../../../constants/navigation/Routes';
 import { initialStateBridge } from '../../../../../util/test/integration/presets/bridge';
 import BridgeView from './index';
+import { describeForPlatforms } from '../../../../../util/test/platform';
 
-describe('BridgeView (integration)', () => {
+describeForPlatforms('BridgeView (integration)', () => {
   it('renders input areas and hides confirm button without tokens or amount', () => {
     const { getByTestId, queryByTestId } = renderBridgeView({
       overrides: {

app/util/test/integration/README.md

@@ -1,4 +1,4 @@
-# Integration Test Framework
+# Component View Test Framework
 
 This folder contains a lightweight integration testing framework with the following goals:
 
@@ -7,6 +7,33 @@ This folder contains a lightweight integration testing framework with the follow
 - Provide view-specific presets and render helpers for concise, declarative tests
 - Avoid mocking hooks or selectors – the UI should consume Redux state naturally
 
+## Platform Matrix (iOS / Android)
+
+- By default, you can execute tests for both platforms using the platform helpers.
+- Import helpers and define tests parameterized by platform:
+
+```ts
+import { itForPlatforms, describeForPlatforms } from '../../platform';
+import { renderBridgeView } from './renderers/bridge';
+
+describeForPlatforms('BridgeView', ({ os }) => {
+  itForPlatforms('renders BridgeView', () => {
+    const { getByTestId } = renderBridgeView({ deterministicFiat: true });
+    // Platform-specific assertions if needed
+    // if (os === 'ios') { ... } else { ... }
+  });
+});
+```
+
+- To filter globally, use `TEST_OS`:
+  - `TEST_OS=ios yarn jest <path>`
+  - `TEST_OS=android yarn jest <path>`
+  - Without `TEST_OS`, both `ios` and `android` run.
+
+- To filter per test:
+  - `itForPlatforms('name', fn, { only: 'ios' })`
+  - `itForPlatforms('name', fn, { skip: ['android'] })`
+
 ## Principles
 
 - Single Engine mock: `app/util/test/integration/mocks.ts`

app/util/test/integration/stateFixture.ts

@@ -275,6 +275,20 @@ export function createStateFixture(options?: {
                       },
                     },
                   },
+                  bridgeConfigV2: {
+                    minimumVersion: '0.0.0',
+                    maxRefreshCount: 5,
+                    refreshRate: 30000,
+                    support: true,
+                    chains: {
+                      // enable mainnet as src/dest
+                      [`eip155:${parseInt(chainIdHex, 16)}`]: {
+                        isActiveSrc: true,
+                        isActiveDest: true,
+                        isGaslessSwapEnabled: false,
+                      },
+                    },
+                  },
                 },
               },
               CurrencyRateController: {

app/util/test/platform.ts

@@ -0,0 +1,127 @@
+import { Platform } from 'react-native';
+
+export type RNPlatform = 'ios' | 'android';
+
+type PlatformFilter =
+  | RNPlatform
+  | RNPlatform[]
+  | { only?: RNPlatform | RNPlatform[]; skip?: RNPlatform[] };
+
+const SCOPE_KEY = '__MM_TEST_PLATFORM_SCOPE__';
+
+function normalizeArray<T>(value: T | T[] | undefined): T[] {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+function getDefaultPlatforms(): RNPlatform[] {
+  const scoped = (globalThis as Record<string, unknown>)[SCOPE_KEY] as
+    | RNPlatform
+    | undefined;
+  if (scoped === 'ios' || scoped === 'android') {
+    return [scoped];
+  }
+  const env = (process.env.TEST_OS ?? '').toLowerCase();
+  if (env === 'ios' || env === 'android') {
+    return [env as RNPlatform];
+  }
+  return ['ios', 'android'];
+}
+
+function resolveTargetPlatforms(filter?: PlatformFilter): RNPlatform[] {
+  const defaultTargets = getDefaultPlatforms();
+
+  if (!filter) {
+    return defaultTargets;
+  }
+
+  if (typeof filter === 'string' || Array.isArray(filter)) {
+    const only = normalizeArray(filter) as RNPlatform[];
+    return only.length ? only : defaultTargets;
+  }
+
+  const only = normalizeArray(filter.only) as RNPlatform[];
+  const skip = new Set(normalizeArray(filter.skip) as RNPlatform[]);
+
+  const base = (only.length ? only : defaultTargets) as RNPlatform[];
+  return base.filter((p) => !skip.has(p));
+}
+
+/**
+ * Runs a test body for each targeted platform, defaulting to both iOS and Android.
+ * Use TEST_OS=ios|android to globally filter, or the filter parameter to narrow per test.
+ */
+export function itForPlatforms(
+  name: string,
+  testFn: (ctx: { os: RNPlatform }) => void | Promise<void>,
+  filter?: PlatformFilter,
+) {
+  const targets = resolveTargetPlatforms(filter);
+  for (const os of targets) {
+    it(`${name} [${os}]`, async () => {
+      const originalOS = Platform.OS;
+      Platform.OS = os;
+      try {
+        await testFn({ os });
+      } finally {
+        Platform.OS = originalOS;
+      }
+    });
+  }
+}
+
+/**
+ * Same as itForPlatforms but focused (runs only these tests).
+ */
+export function itOnlyForPlatforms(
+  name: string,
+  testFn: (ctx: { os: RNPlatform }) => void | Promise<void>,
+  filter?: PlatformFilter,
+) {
+  const targets = resolveTargetPlatforms(filter);
+  for (const os of targets) {
+    it.only(`${name} [${os}]`, async () => {
+      const originalOS = Platform.OS;
+      Platform.OS = os;
+      try {
+        await testFn({ os });
+      } finally {
+        Platform.OS = originalOS;
+      }
+    });
+  }
+}
+
+/**
+ * Group tests under a describe for each targeted platform.
+ */
+export function describeForPlatforms(
+  name: string,
+  define: (ctx: { os: RNPlatform }) => void,
+  filter?: PlatformFilter,
+) {
+  const targets = resolveTargetPlatforms(filter);
+  for (const os of targets) {
+    describe(`${name} [${os}]`, () => {
+      const originalOS = Platform.OS;
+      beforeAll(() => {
+        Platform.OS = os;
+        (globalThis as Record<string, unknown>)[SCOPE_KEY] = os;
+      });
+      afterAll(() => {
+        Platform.OS = originalOS;
+        delete (globalThis as Record<string, unknown>)[SCOPE_KEY];
+      });
+      define({ os });
+    });
+  }
+}
+
+/**
+ * Utility to compute target platforms if you need custom loops.
+ */
+export function getTargetPlatforms(filter?: PlatformFilter): RNPlatform[] {
+  return resolveTargetPlatforms(filter);
+}