test(perps): fix integration CI after rebase

Author: racitores

app/components/UI/Perps/hooks/usePerpsFlipPosition.integration.test.ts

@@ -1,16 +1,15 @@
 /**
- * Integration test — perps "reverse position" flow.
+ * Integration test — perps validation contract for flip-shaped market orders.
  *
  * Sits next to `usePerpsFlipPosition.test.ts` (a unit test that mocks
  * `usePerpsTrading` wholesale and never reaches the provider). This file
- * exercises the REAL `HyperLiquidProvider.validateOrder` against the exact
- * `OrderParams` shape `TradingService.flipPosition` constructs today.
+ * exercises the REAL `HyperLiquidProvider.validateOrder` against a
+ * flip-shaped market order without caller-provided price data.
  *
- * The bug: market reverse orders aren't given `currentPrice`. Validator's
- * fallback only fires for `orderType === 'limit'`. Result: aborts with
- * `ORDER_PRICE_REQUIRED`. See `app/controllers/perps/providers/HyperLiquidProvider.ts`
- * line ~6745–6770 (validateOrder) and `services/TradingService.ts` line
- * ~1918 (flipPosition).
+ * Direct validation still requires either `currentPrice` or `usdAmount`.
+ * The full TradingService/provider place-order path fetches live price data
+ * before validation, so the user-facing flip flow is covered separately by
+ * `orderLifecycleFlow.integration.test.ts`.
  *
  * Setup is delegated to the perps integration harness — see
  * `tests/integration/harnesses/perps.ts` (rules + factory) and
@@ -23,14 +22,13 @@
 import { buildPerpsIntegrationHarness } from '../../../../../tests/integration/harnesses/perps';
 import { PERPS_ERROR_CODES } from '@metamask/perps-controller';
 
-describe('Perps reverse position — integration', () => {
-  describe('reproduces the production bug', () => {
-    it('rejects a flip-position market order with ORDER_PRICE_REQUIRED', async () => {
+describe('Perps reverse position validation — integration', () => {
+  describe('direct provider validation', () => {
+    it('rejects a market order without price context', async () => {
       const { provider } = buildPerpsIntegrationHarness();
 
-      // Exact OrderParams shape that `TradingService.flipPosition` constructs
-      // when reversing a 1-BTC long: 2x size, market, opposite side,
-      // no currentPrice, no usdAmount.
+      // Flip-shaped order params: 2x size, market, opposite side,
+      // no caller-provided currentPrice, no usdAmount.
       const result = await provider.validateOrder({
         symbol: 'BTC',
         isBuy: false,
@@ -43,7 +41,7 @@ describe('Perps reverse position — integration', () => {
     });
   });
 
-  describe('confirms the bug surface', () => {
+  describe('valid price contexts', () => {
     it('passes when usdAmount is provided (one possible fix shape)', async () => {
       const { provider } = buildPerpsIntegrationHarness();
 

app/components/UI/Perps/integration/componentFlow.integration.test.tsx

@@ -8,10 +8,14 @@
  */
 
 import { fireEvent, screen, waitFor } from '@testing-library/react-native';
+import { type Position } from '@metamask/perps-controller';
 import React from 'react';
 
 import { buildPerpsComponentHarness } from '../../../../../tests/integration/harnesses/perps-component';
-import { PerpsFlipPositionConfirmSheetSelectorsIDs , PerpsOrderViewSelectorsIDs } from '../Perps.testIds';
+import {
+  PerpsFlipPositionConfirmSheetSelectorsIDs,
+  PerpsOrderViewSelectorsIDs,
+} from '../Perps.testIds';
 import PerpsFlipPositionConfirmSheet from '../components/PerpsFlipPositionConfirmSheet';
 import PerpsOrderView from '../Views/PerpsOrderView/PerpsOrderView';
 
@@ -81,13 +85,12 @@ describe('Perps component flows — integration', () => {
   });
 
   describe('reversing a position from a rendered confirmation sheet', () => {
-    it('surfaces ORDER_PRICE_REQUIRED from a rendered flip button press', async () => {
+    it('submits the flip market order from a rendered button press', async () => {
       // Arrange
       const perps = buildPerpsComponentHarness();
       try {
         perps.harness.setupTradingReady();
-        const openLongBTC = {
-          coin: 'BTC',
+        const openLongBTC: Position = {
           symbol: 'BTC',
           size: '0.1',
           entryPrice: '50000',
@@ -99,6 +102,8 @@ describe('Perps component flows — integration', () => {
           maxLeverage: 50,
           returnOnEquity: '0',
           cumulativeFunding: { allTime: '0', sinceOpen: '0', sinceChange: '0' },
+          takeProfitCount: 0,
+          stopLossCount: 0,
         };
         perps.renderWithFlow(
           <PerpsFlipPositionConfirmSheet position={openLongBTC} />,
@@ -113,20 +118,28 @@ describe('Perps component flows — integration', () => {
 
         // Assert
         await waitFor(() => {
-          expect(perps.mocks.showToast).toHaveBeenCalledWith(
-            expect.objectContaining({
-              labelOptions: expect.arrayContaining([
-                expect.objectContaining({
-                  label: 'Order failed',
-                }),
-              ]),
-            }),
-          );
+          expect(perps.mocks.exchangeClient.order).toHaveBeenCalledTimes(1);
         });
-        expect(perps.mocks.exchangeClient.order).not.toHaveBeenCalled();
-        expect(
-          screen.getByTestId(PerpsFlipPositionConfirmSheetSelectorsIDs.SHEET),
-        ).toBeOnTheScreen();
+        expect(perps.mocks.exchangeClient.order).toHaveBeenCalledWith(
+          expect.objectContaining({
+            orders: [
+              expect.objectContaining({
+                a: 0,
+                b: false,
+                t: { limit: { tif: 'FrontendMarket' } },
+              }),
+            ],
+          }),
+        );
+        expect(perps.mocks.showToast).toHaveBeenCalledWith(
+          expect.objectContaining({
+            labelOptions: expect.arrayContaining([
+              expect.objectContaining({
+                label: 'Order filled',
+              }),
+            ]),
+          }),
+        );
       } finally {
         perps.teardown();
       }

app/components/UI/Perps/integration/orderLifecycleFlow.integration.test.ts

@@ -20,6 +20,7 @@
  */
 
 import { renderHook, act } from '@testing-library/react-native';
+import { type OrderResult, type Position } from '@metamask/perps-controller';
 
 import { buildPerpsFlowHarness } from '../../../../../tests/integration/harnesses/perps-flow';
 import { usePerpsTrading } from '../hooks/usePerpsTrading';
@@ -73,22 +74,20 @@ describe('Perps order lifecycle — FLOW integration', () => {
    *     → result.current.flipPosition({ position })
    *       → Engine.context.PerpsController.flipPosition (shim)
    *         → real TradingService.flipPosition
-   *           → constructs OrderParams with size=2x, no currentPrice
+   *           → constructs OrderParams with size=2x
    *           → real provider.placeOrder(orderParams)
-   *             → real validateOrder
-   *               → returns ORDER_PRICE_REQUIRED (production bug)
+   *             → fetches live price for validation
+   *             → mocked SDK exchange.order
    *
-   * Shape A could only catch the bug by calling `provider.validateOrder`
-   * directly. Shape B catches it through the actual user-facing chain —
-   * proving the TradingService → provider seam is genuinely covered.
+   * Shape B catches the actual user-facing chain, proving the
+   * TradingService → provider seam is genuinely covered.
    */
-  describe('reversing a position via the hook chain (production bug)', () => {
-    it('reproduces the ORDER_PRICE_REQUIRED bug end-to-end', async () => {
+  describe('reversing a position via the hook chain', () => {
+    it('places the flip market order end-to-end', async () => {
       // Arrange
       const { harness } = buildPerpsFlowHarness();
       harness.setupTradingReady();
-      const openLongBTC = {
-        coin: 'BTC',
+      const openLongBTC: Position = {
         symbol: 'BTC',
         size: '0.1', // positive = long; flipPosition will compute 2x = 0.2
         entryPrice: '50000',
@@ -100,30 +99,39 @@ describe('Perps order lifecycle — FLOW integration', () => {
         maxLeverage: 50,
         returnOnEquity: '0',
         cumulativeFunding: { allTime: '0', sinceOpen: '0', sinceChange: '0' },
+        takeProfitCount: 0,
+        stopLossCount: 0,
       };
       const { result } = renderHook(() => usePerpsTrading());
 
       // Act — through the real hook → real TradingService → real provider chain
-      let flipResult: Awaited<
-        ReturnType<typeof result.current.flipPosition>
-      > | null = null;
+      let flipResult: OrderResult | null = null;
       await act(async () => {
         flipResult = await result.current.flipPosition({
-          position: openLongBTC as never,
+          symbol: 'BTC',
+          position: openLongBTC,
         });
       });
 
-      // Assert — flipPosition returns a failed result with the right error
-      // code. The bug is reachable because TradingService constructs the
-      // OrderParams without `currentPrice`, and the real provider's
-      // `validateOrder` rejects market orders without a price.
+      // Assert — flipPosition succeeds because the provider fetches the
+      // current market price before running order validation.
       expect(flipResult).not.toBeNull();
-      expect(flipResult).toMatchObject({ success: false });
-      expect((flipResult as { error: string }).error).toMatch(
-        /ORDER_PRICE_REQUIRED/,
+      if (!flipResult) {
+        throw new Error('Expected flipPosition to return a result');
+      }
+      expect(flipResult).toMatchObject({ success: true });
+      expect(harness.mocks.exchangeClient.order).toHaveBeenCalledTimes(1);
+      expect(harness.mocks.exchangeClient.order).toHaveBeenCalledWith(
+        expect.objectContaining({
+          orders: [
+            expect.objectContaining({
+              a: 0,
+              b: false,
+              t: { limit: { tif: 'FrontendMarket' } },
+            }),
+          ],
+        }),
       );
-      // SDK was never called — validation aborted the flow before placement.
-      expect(harness.mocks.exchangeClient.order).not.toHaveBeenCalled();
     });
   });
 });

jest.config.js

@@ -74,6 +74,7 @@ const config = {
     '.*/e2e/.*\\.spec\\.(ts|js)$',
     '.*/e2e/pages/',
     '.*/e2e/selectors/',
+    '.*\\.integration\\.test\\.(ts|tsx)$',
     '.*\\.view\\.test\\.(ts|tsx)$',
   ],
   coverageReporters: ['text-summary', 'lcov'],

tests/integration/harnesses/perps-component.tsx

@@ -45,7 +45,8 @@ jest.mock('react-native-gesture-handler', () => {
       Simultaneous: jest.fn((...gestures) => gestures),
     },
     PanGestureHandler: ReactActual.forwardRef(
-      ({ children }: { children: React.ReactNode }, _ref) => children,
+      ({ children }: { children: React.ReactNode }, _ref: React.Ref<unknown>) =>
+        children,
     ),
   };
 });
@@ -184,11 +185,15 @@ import {
   PerpsStreamProvider,
   type PerpsStreamManager,
 } from '../../../app/components/UI/Perps/providers/PerpsStreamManager';
+import type {
+  ToastOptions,
+  ToastRef,
+} from '../../../app/component-library/components/Toast/Toast.types';
 import { AccessRestrictedProvider } from '../../../app/components/UI/Compliance';
 import Routes from '../../../app/constants/navigation/Routes';
 import { initialStatePerps } from '../../component-view/presets/perpsStatePreset';
 
-type ToastOptionsForHarness = Record<string, unknown>;
+type ToastOptionsForHarness = ToastOptions;
 
 interface PerpsComponentRenderOptions {
   stateOverrides?: DeepPartial<RootState>;
@@ -319,7 +324,9 @@ export function buildPerpsComponentHarness(
   const flowHarness = buildPerpsFlowHarness(options);
   const showToast = jest.fn<void, [ToastOptionsForHarness]>();
   const closeToast = jest.fn<void, []>();
-  const toastRef = { current: { showToast, closeToast } };
+  const toastRef: React.RefObject<ToastRef | null> = {
+    current: { showToast, closeToast },
+  };
 
   const renderWithFlow = (
     component: React.ReactElement,

tests/integration/harnesses/perps-flow.ts

@@ -7,8 +7,8 @@
  * etc.) and exercise the chain ALL the way from hook → Engine →
  * shim controller → real TradingService → real provider → mocked SDK.
  * Catches bugs that live in the hook → controller wiring AND inside
- * TradingService (e.g. the perps reverse-position bug, where TradingService
- * constructs `OrderParams` without `currentPrice` and the provider rejects).
+ * TradingService, including multi-step flows where service-generated
+ * `OrderParams` must stay compatible with provider validation.
  *
  * Both harnesses coexist intentionally:
  *   - `perps.ts`        → Shape A. Fast, sharp failure isolation. Best for
@@ -23,8 +23,7 @@
  *   - `TradingService` — instantiated with the harness's mocked platform deps
  *   - `HyperLiquidProvider` (instantiated through the inner perps harness)
  *   - All in-memory state transitions, validation, asset mapping
- *   - The seam between TradingService and provider — where the perps
- *     reverse-position bug lives
+ *   - The seam between TradingService and provider
  *
  * MOCKED (the I/O boundary + non-perps app surface):
  *   - SDK clients, wallet, subscription cache, readiness cache (via inner harness)
@@ -115,8 +114,8 @@ import {
   type PerpsIntegrationHarness,
   type PerpsHarnessOptions,
 } from './perps';
-import { TradingService } from '../../../app/controllers/perps/services/TradingService';
-import type { ServiceContext } from '../../../app/controllers/perps/services/ServiceContext';
+import { TradingService } from '@metamask/perps-controller/services/TradingService';
+import type { ServiceContext } from '@metamask/perps-controller';
 import { createMockInfrastructure } from '../../../app/components/UI/Perps/__mocks__/serviceMocks';
 
 export interface PerpsFlowHarness {
@@ -196,6 +195,7 @@ export function buildPerpsFlowHarness(
         provider: harness.provider,
         params,
         context: buildServiceContext('closePosition'),
+        reportOrderToDataLake,
       }),
     flipPosition: (params: { position: unknown }) =>
       tradingService.flipPosition({