test(perps): migrate controller unit tests to core

packages/perps-controller/jest.config.js

@@ -18,18 +18,16 @@ module.exports = {
     // An object that configures minimum threshold enforcement for coverage results
     coverageThreshold: {
       global: {
-        branches: 100,
-        functions: 100,
-        lines: 100,
-        statements: 100,
+        branches: 70,
+        functions: 78,
+        lines: 80,
+        statements: 80,
       },
     },
   }),
 
-  // Coverage is scoped to the placeholder test file only (not synced source).
-  // The real source files are synced from Mobile and tested there.
-  // When tests are migrated from Mobile to Core, restore this to
-  // the default ('./src/**/*.ts') and raise thresholds accordingly.
+  // Coverage is collected from real source files. Barrel files are excluded
+  // because they only re-export the tested modules.
   // Applied after merge to fully replace (not concat) the base array.
-  collectCoverageFrom: ['./tests/placeholder.test.ts'],
+  collectCoverageFrom: ['./src/**/*.ts', '!./src/**/index.ts'],
 };

packages/perps-controller/tests/helpers/providerMocks.ts

@@ -0,0 +1,106 @@
+/* eslint-disable */
+/**
+ * Shared provider mocks for Perps tests
+ * Provides reusable mock implementations for HyperLiquidProvider and related interfaces
+ */
+import { type HyperLiquidProvider } from '@metamask/perps-controller';
+
+export const createMockHyperLiquidProvider =
+  (): jest.Mocked<HyperLiquidProvider> =>
+    ({
+      protocolId: 'hyperliquid',
+      initialize: jest.fn(),
+      isReadyToTrade: jest.fn(),
+      toggleTestnet: jest.fn(),
+      getPositions: jest.fn(),
+      getAccountState: jest.fn(),
+      getHistoricalPortfolio: jest.fn().mockResolvedValue({
+        totalBalance24hAgo: '10000',
+        totalBalance7dAgo: '9500',
+        totalBalance30dAgo: '9000',
+      }),
+      getMarkets: jest.fn(),
+      placeOrder: jest.fn(),
+      editOrder: jest.fn(),
+      cancelOrder: jest.fn(),
+      cancelOrders: jest.fn(),
+      closePosition: jest.fn(),
+      closePositions: jest.fn(),
+      withdraw: jest.fn(),
+      getDepositRoutes: jest.fn(),
+      getWithdrawalRoutes: jest.fn(),
+      validateDeposit: jest.fn().mockResolvedValue({ isValid: true }),
+      validateOrder: jest.fn().mockResolvedValue({ isValid: true }),
+      validateClosePosition: jest.fn().mockResolvedValue({ isValid: true }),
+      validateWithdrawal: jest.fn().mockResolvedValue({ isValid: true }),
+      subscribeToPrices: jest.fn(),
+      subscribeToPositions: jest.fn(),
+      subscribeToOrderFills: jest.fn(),
+      setLiveDataConfig: jest.fn(),
+      disconnect: jest.fn(),
+      updatePositionTPSL: jest.fn(),
+      calculateLiquidationPrice: jest.fn(),
+      calculateMaintenanceMargin: jest.fn(),
+      getMaxLeverage: jest.fn(),
+      calculateFees: jest.fn(),
+      getMarketDataWithPrices: jest.fn(),
+      getBlockExplorerUrl: jest.fn(),
+      getOrderFills: jest.fn(),
+      getOrders: jest.fn(),
+      getFunding: jest.fn(),
+      getCurrentAccountId: jest
+        .fn()
+        .mockResolvedValue(
+          'eip155:1:0x0000000000000000000000000000000000000001',
+        ),
+      getIsFirstTimeUser: jest.fn(),
+      getOpenOrders: jest.fn(),
+      subscribeToOrders: jest.fn(),
+      subscribeToAccount: jest.fn(),
+      setUserFeeDiscount: jest.fn(),
+      // WebSocket connection state methods
+      getWebSocketConnectionState: jest.fn(),
+      subscribeToConnectionState: jest.fn().mockReturnValue(() => undefined),
+      reconnect: jest.fn().mockResolvedValue(undefined),
+    }) as unknown as jest.Mocked<HyperLiquidProvider>;
+
+export const createMockOrder = (overrides = {}) => ({
+  orderId: 'order-1',
+  symbol: 'BTC',
+  side: 'buy' as const,
+  orderType: 'limit' as const,
+  size: '0.1',
+  originalSize: '0.1',
+  price: '50000',
+  filledSize: '0',
+  remainingSize: '0.1',
+  status: 'open' as const,
+  timestamp: Date.now(),
+  ...overrides,
+});
+
+export const createMockPosition = (overrides = {}) => ({
+  symbol: 'BTC',
+  size: '0.5',
+  entryPrice: '50000',
+  positionValue: '25000',
+  unrealizedPnl: '100',
+  marginUsed: '1000',
+  leverage: { type: 'cross' as const, value: 25 },
+  liquidationPrice: '48000',
+  maxLeverage: 50,
+  returnOnEquity: '10',
+  cumulativeFunding: {
+    allTime: '0',
+    sinceOpen: '0',
+    sinceChange: '0',
+  },
+  roi: '10',
+  takeProfitPrice: undefined,
+  stopLossPrice: undefined,
+  takeProfitCount: 0,
+  stopLossCount: 0,
+  marketPrice: '50200',
+  timestamp: Date.now(),
+  ...overrides,
+});

packages/perps-controller/tests/helpers/serviceMocks.ts

@@ -0,0 +1,246 @@
+/* eslint-disable */
+/**
+ * Shared service mocks for Perps service tests
+ * Provides reusable mock implementations for ServiceContext and related types
+ */
+
+import {
+  type ServiceContext,
+  type PerpsControllerState,
+  type InitializationState,
+  type PerpsControllerMessenger,
+  type PerpsPlatformDependencies,
+} from '@metamask/perps-controller';
+
+/**
+ * Create a mock EVM account (KeyringAccount)
+ */
+export const createMockEvmAccount = () => ({
+  id: '00000000-0000-0000-0000-000000000000',
+  address: '0x1234567890abcdef1234567890abcdef12345678' as `0x${string}`,
+  type: 'eip155:eoa' as const,
+  options: {},
+  scopes: ['eip155:1'],
+  methods: ['eth_signTransaction', 'eth_sign'],
+  metadata: {
+    name: 'Test Account',
+    importTime: Date.now(),
+    keyring: { type: 'HD Key Tree' },
+  },
+});
+
+/**
+ * Create a mock PerpsPlatformDependencies instance.
+ * Returns a type-safe mock with jest.Mock functions for all methods.
+ * Uses `as unknown as jest.Mocked<PerpsPlatformDependencies>` pattern
+ * to ensure compatibility with both the interface contract and Jest mock APIs.
+ *
+ * Architecture:
+ * - Observability: logger, debugLogger, metrics, performance, tracer (stateless utilities)
+ * - Platform: streamManager (mobile/extension specific capabilities)
+ * - Controllers: consolidated access to all external controllers
+ */
+export const createMockInfrastructure =
+  (): jest.Mocked<PerpsPlatformDependencies> =>
+    ({
+      // === Observability (stateless utilities) ===
+      logger: {
+        error: jest.fn(),
+      },
+      debugLogger: {
+        log: jest.fn(),
+      },
+      metrics: {
+        trackEvent: jest.fn(),
+        isEnabled: jest.fn(() => true),
+        trackPerpsEvent: jest.fn(),
+      },
+      performance: {
+        now: jest.fn(() => Date.now()),
+      },
+      tracer: {
+        trace: jest.fn(() => undefined),
+        endTrace: jest.fn(),
+        setMeasurement: jest.fn(),
+        addBreadcrumb: jest.fn(),
+      },
+
+      // === Platform Services ===
+      streamManager: {
+        pauseChannel: jest.fn(),
+        resumeChannel: jest.fn(),
+        clearAllChannels: jest.fn(),
+      },
+
+      // === Feature Flags (platform-specific version gating) ===
+      featureFlags: {
+        validateVersionGated: jest.fn().mockReturnValue(undefined),
+      },
+
+      // === Market Data Formatting ===
+      marketDataFormatters: {
+        formatVolume: jest.fn((v: number) => `$${v.toFixed(0)}`),
+        formatPerpsFiat: jest.fn((v: number) => `$${v.toFixed(2)}`),
+        formatPercentage: jest.fn((p: number) => `${p.toFixed(2)}%`),
+        priceRangesUniversal: [],
+      },
+
+      // === Cache Invalidation ===
+      cacheInvalidator: {
+        invalidate: jest.fn(),
+        invalidateAll: jest.fn(),
+      },
+
+      // === Rewards (DI — no RewardsController in Core yet) ===
+      rewards: {
+        getPerpsDiscountForAccount: jest.fn().mockResolvedValue(0),
+      },
+
+      // === Disk Cache (cold-start persistence) ===
+      diskCache: {
+        getItem: jest.fn().mockResolvedValue(null),
+        getItemSync: jest.fn().mockReturnValue(null),
+        setItem: jest.fn().mockResolvedValue(undefined),
+        removeItem: jest.fn().mockResolvedValue(undefined),
+      },
+    }) as unknown as jest.Mocked<PerpsPlatformDependencies>;
+
+/**
+ * Create a mock PerpsControllerState
+ */
+export const createMockPerpsControllerState = (
+  overrides: Partial<PerpsControllerState> = {},
+): PerpsControllerState => ({
+  activeProvider: 'hyperliquid',
+  isTestnet: false,
+  initializationState: 'initialized' as InitializationState,
+  initializationError: null,
+  initializationAttempts: 0,
+  accountState: null,
+  perpsBalances: {},
+  depositInProgress: false,
+  lastDepositTransactionId: null,
+  lastDepositResult: null,
+  withdrawInProgress: false,
+  lastWithdrawResult: null,
+  lastCompletedWithdrawalTimestamp: null,
+  lastCompletedWithdrawalTxHashes: [],
+  withdrawalRequests: [],
+  withdrawalProgress: {
+    progress: 0,
+    lastUpdated: 0,
+    activeWithdrawalId: null,
+  },
+  depositRequests: [],
+  isEligible: true,
+  isFirstTimeUser: {
+    testnet: true,
+    mainnet: true,
+  },
+  hasPlacedFirstOrder: {
+    testnet: false,
+    mainnet: false,
+  },
+  watchlistMarkets: {
+    testnet: [],
+    mainnet: [],
+  },
+  tradeConfigurations: {
+    testnet: {},
+    mainnet: {},
+  },
+  marketFilterPreferences: {
+    optionId: 'volume',
+    direction: 'desc',
+  },
+  lastError: null,
+  lastUpdateTimestamp: Date.now(),
+  hip3ConfigVersion: 0,
+  selectedPaymentToken: null,
+  cachedMarketDataByProvider: {},
+  cachedUserDataByProvider: {},
+  ...overrides,
+});
+
+/**
+ * Create a mock ServiceContext with optional overrides
+ * Note: infrastructure is no longer part of ServiceContext - it's now injected
+ * into service instances via constructor.
+ */
+export const createMockServiceContext = (
+  overrides: Partial<ServiceContext> = {},
+): ServiceContext => ({
+  tracingContext: {
+    provider: 'hyperliquid',
+    isTestnet: false,
+  },
+  errorContext: {
+    controller: 'TestService',
+    method: 'testMethod',
+  },
+  stateManager: {
+    update: jest.fn(),
+    getState: jest.fn(() => createMockPerpsControllerState()),
+  },
+  ...overrides,
+});
+
+/**
+ * Create a mock PerpsControllerMessenger for testing inter-controller communication.
+ * The messenger.call() method should be configured in each test to return appropriate values.
+ *
+ * Common messenger actions used:
+ * - 'AccountTreeController:getAccountsFromSelectedAccountGroup' - returns array of accounts
+ * - 'KeyringController:signTypedMessage' - returns signature string
+ * - 'NetworkController:getState' - returns { selectedNetworkClientId: string }
+ * - 'NetworkController:getNetworkClientById' - returns { configuration: { chainId: string } }
+ * - 'AuthenticationController:getBearerToken' - returns bearer token string
+ *
+ * @param overrides - Optional partial messenger to override default behavior
+ */
+export const createMockMessenger = (
+  overrides?: Partial<PerpsControllerMessenger>,
+): jest.Mocked<PerpsControllerMessenger> => {
+  const mockEvmAccount = createMockEvmAccount();
+  const base = {
+    call: jest.fn().mockImplementation((action: string) => {
+      // Default implementations for common actions
+      if (
+        action === 'AccountTreeController:getAccountsFromSelectedAccountGroup'
+      ) {
+        return [mockEvmAccount];
+      }
+      if (action === 'KeyringController:getState') {
+        return { isUnlocked: true };
+      }
+      if (action === 'KeyringController:signTypedMessage') {
+        return Promise.resolve('0xSignatureResult');
+      }
+      if (action === 'NetworkController:getState') {
+        return { selectedNetworkClientId: 'mainnet' };
+      }
+      if (action === 'NetworkController:getNetworkClientById') {
+        return { configuration: { chainId: '0x1' } };
+      }
+      if (action === 'AuthenticationController:getBearerToken') {
+        return Promise.resolve('mock-bearer-token');
+      }
+      return undefined;
+    }),
+    publish: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    registerActionHandler: jest.fn(),
+    registerMethodActionHandlers: jest.fn(),
+    unregisterActionHandler: jest.fn(),
+    // Additional methods used by PerpsController
+    registerEventHandler: jest.fn(),
+    registerInitialEventPayload: jest.fn(),
+    unregisterEventHandler: jest.fn(),
+    clearEventSubscriptions: jest.fn(),
+  };
+  return {
+    ...base,
+    ...overrides,
+  } as unknown as jest.Mocked<PerpsControllerMessenger>;
+};