perf(e2e): speed up Appium smoke login flow (#32821)

## **Description**

Ports the **login performance fixes** from
`MMQA-1995-networks-appium-migration` into a focused branch so Appium
smoke tests unlock faster without pulling in the full networks
migration.

**Why:** Appium smoke specs spend ~20s per test probing the developer
menu even when the login screen is already visible after fixture
bootstrap. That adds up across large smoke shards and slows local/CI
feedback.

**What changed:**
- Skip redundant dev-menu waits when the login screen is already visible
- Tighter timeouts for dev-menu probes, login view assertions, and
login-button settle time
- Extract `wallet-home-readiness.ts` and use iOS-specific wallet
detection in `waitForAppReady` for faster session-persisted fast paths
- Improve push-notification sheet dismissal after login (tap "Not now"
instead of confirm)
- Harden Playwright assertions for missing elements during
login/dev-menu flows

**Files touched:**
- `tests/flows/general.flow.ts`
- `tests/flows/wallet.flow.ts`
- `tests/flows/wallet-home-readiness.ts` (new)
- `tests/flows/general.flow.test.ts`
- `tests/page-objects/wallet/LoginView.ts`
- `tests/framework/PlaywrightAdapter.ts`
- `tests/framework/PlaywrightAssertions.ts`

## **Changelog**

CHANGELOG entry: null

## **Related issues**

Refs: MMQA-1995 — Appium smoke login performance (split from networks
Appium migration work)

## **Manual testing steps**

```gherkin
Feature: Appium smoke login performance

  Scenario: login unlock completes without redundant dev-menu waits
    Given an Appium smoke test that uses loginToAppPlaywright with fixture bootstrap
    And the app restarts with a persisted session that lands on the login screen

    When the login flow runs on Android or iOS
    Then the developer menu is not probed when the login screen is already visible
    And the wallet home is reached with reduced settle and assertion timeouts
```

- [x] `yarn jest tests/flows/general.flow.test.ts`
- [ ] Appium smoke login path validated on Android (local emulator)
- [ ] Appium smoke login path validated on iOS (when available)

## **Screenshots/Recordings**

N/A — E2E test infrastructure only; no end-user UI changes. CI
performance/login job output can be used as validation evidence.

### **Before**

N/A

### **After**

N/A

## **Pre-merge author checklist**

- [x] I've followed [MetaMask Contributor
Docs](https://github.com/MetaMask/contributor-docs) and [MetaMask Mobile
Coding
Standards](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/CODING_GUIDELINES.md).
- [x] I've completed the PR template to the best of my ability
- [x] I've included tests if applicable
- [x] I've documented my code using [JSDoc](https://jsdoc.app/) format
if applicable
- [x] I've applied the right labels on the PR (see [labeling
guidelines](https://github.com/MetaMask/metamask-mobile/blob/main/.github/guidelines/LABELING_GUIDELINES.md)).
Not required for external contributors.

#### Performance checks (if applicable)

- [x] I've tested on Android
  - Ideally on a mid-range device; emulator is acceptable
- [x] I've tested with a power user scenario
- Use these [power-user
SRPs](https://consensyssoftware.atlassian.net/wiki/spaces/TL1/pages/edit-v2/401401446401?draftShareId=9d77e1e1-4bdc-4be1-9ebb-ccd916988d93)
to import wallets with many accounts and tokens
- [x] I've instrumented key operations with Sentry traces for production
performance metrics
- See [`trace()`](/app/util/trace.ts) for usage and
[`addToken`](/app/components/Views/AddAsset/components/AddCustomToken/AddCustomToken.tsx#L274)
for an example

For performance guidelines and tooling, see the [Performance
Guide](https://consensyssoftware.atlassian.net/wiki/spaces/TL1/pages/400085549067/Performance+Guide+for+Engineers).

## **Pre-merge reviewer checklist**

- [ ] I've manually tested the PR (e.g. pull and build branch, run the
app, test code being changed).
- [ ] I confirm that this PR addresses all acceptance criteria described
in the ticket it closes and includes the necessary testing evidence such
as recordings and or screenshots.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Changes are limited to E2E test infrastructure and timeouts; no
production app logic, with modest risk of flakiness if timeouts are too
aggressive on slow CI devices.
> 
> **Overview**
> **Speeds up Appium smoke login** by cutting redundant waits and
tightening probes when the app is already on login or wallet home.
> 
> `loginToAppPlaywright` now tries a **2s wallet-home fast path** first,
**skips developer-menu dismissal** when the login screen is visible
(avoiding ~20s of absent Continue/xmark probes), uses **shorter login
view assertions**, and runs **post-login modal dismissal after** wallet
home is ready. Dev-menu Playwright flows use a shared **800ms probe**
and **2s** close assertions; unit expectations were updated accordingly.
> 
> **iOS wallet readiness** moves into new `wallet-home-readiness.ts` and
is reused in `waitForAppReady` (Appium iOS) and
`waitForWalletHomePlaywright`, replacing duplicated logic removed from
`wallet.flow.ts`.
> 
> **Push notification existing-user sheet** dismissal now waits for the
sheet, taps **Not now** (id or text), and asserts the sheet closes
instead of tapping confirm.
> 
> **Framework hardening:** `PlaywrightAdapter.waitForDisplayed` no-ops
on missing elements when `reverse` is set; `expectElementToNotBeVisible`
treats non-existent elements and certain `TypeError`s as success.
**Login** Appium tap uses **10s** timeout, fewer enabled-stable reads,
and **300ms** post-enable settle.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
f57da7a. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: javiergarciavera <javiergarciavera@users.noreply.github.com>

Author: javiergarciavera

tests/flows/general.flow.test.ts

@@ -130,7 +130,10 @@ describe('general.flow Playwright dev screens', () => {
       PlaywrightAssertions.expectElementToNotBeVisible,
     ).toHaveBeenCalledWith(
       closeButton,
-      expect.objectContaining({ timeout: 5000 }),
+      expect.objectContaining({
+        timeout: 2000,
+        description: 'Dev Menu Close Button should not be visible',
+      }),
     );
     expect(
       (PlaywrightAssertions.expectElementToNotBeVisible as jest.Mock).mock

tests/flows/general.flow.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '../framework/logger';
 import Assertions from '../framework/Assertions';
 import {
+  FrameworkDetector,
   Gestures,
   PlaywrightAssertions,
   PlaywrightGestures,
@@ -12,13 +13,16 @@ import LoginView from '../page-objects/wallet/LoginView';
 import WalletView from '../page-objects/wallet/WalletView';
 import { PlatformDetector } from '../framework/PlatformLocator';
 import { resolveE2EWaitTimeoutMs } from '../framework/Constants';
+import { isWalletHomeReadyOnIOS } from './wallet-home-readiness';
 // eslint-disable-next-line import-x/no-nodejs-modules
 import { execSync } from 'node:child_process';
 
 const logger = createLogger({
   name: 'GeneralFlow',
 });
 
+const DEV_MENU_PROBE_TIMEOUT_MS = 800;
+
 /**
  * Dismisses development build screens.
  * Handles 'Development servers' and 'Developer menu' screens.
@@ -119,12 +123,12 @@ const closeDeveloperMenuPlaywright = async (): Promise<void> => {
       exact: true,
     });
     await PlaywrightAssertions.expectElementToBeVisible(closeButton, {
-      timeout: 2000,
+      timeout: DEV_MENU_PROBE_TIMEOUT_MS,
       description: 'Dev Menu Close Button should be visible',
     });
     await PlaywrightGestures.waitAndTap(closeButton);
     await PlaywrightAssertions.expectElementToNotBeVisible(closeButton, {
-      timeout: 5000,
+      timeout: 2000,
       description: 'Dev Menu Close Button should not be visible',
     });
     return;
@@ -141,12 +145,12 @@ const closeDeveloperMenuPlaywright = async (): Promise<void> => {
   try {
     const closeButton = await PlaywrightMatchers.getElementByText('Close');
     await PlaywrightAssertions.expectElementToBeVisible(closeButton, {
-      timeout: 2000,
+      timeout: DEV_MENU_PROBE_TIMEOUT_MS,
       description: 'Dev Menu Close Button should be visible',
     });
     await PlaywrightGestures.waitAndTap(closeButton);
     await PlaywrightAssertions.expectElementToNotBeVisible(closeButton, {
-      timeout: 5000,
+      timeout: 2000,
       description: 'Dev Menu Close Button should not be visible',
     });
     return;
@@ -166,7 +170,7 @@ const dismissDeveloperMenuOnboardingPlaywright = async (): Promise<void> => {
     const continueButton =
       await PlaywrightMatchers.getElementByText('Continue');
     await PlaywrightAssertions.expectElementToBeVisible(continueButton, {
-      timeout: 5000,
+      timeout: DEV_MENU_PROBE_TIMEOUT_MS,
       description: 'Dev Menu Continue Button should be visible',
     });
 
@@ -238,28 +242,37 @@ export const waitForAppReady = async (
   logger.debug('Waiting for app to reach login or wallet home...');
 
   while (Date.now() < deadline) {
-    try {
-      await Assertions.expectElementToBeVisible(WalletView.container, {
-        description: 'Wallet home should be visible',
-        timeout: 3000,
-      });
-      logger.debug(
-        `App on wallet home after ${Date.now() - startTime}ms — skipping login wait`,
-      );
-      return;
-    } catch {
-      // Not on wallet yet.
+    if (FrameworkDetector.isAppium() && PlatformDetector.isIOS()) {
+      if (await isWalletHomeReadyOnIOS()) {
+        logger.debug(
+          `App on wallet home after ${Date.now() - startTime}ms (iOS readiness) — skipping login wait`,
+        );
+        return;
+      }
+    } else {
+      try {
+        await Assertions.expectElementToBeVisible(WalletView.container, {
+          description: 'Wallet home should be visible',
+          timeout: 3000,
+        });
+        logger.debug(
+          `App on wallet home after ${Date.now() - startTime}ms — skipping login wait`,
+        );
+        return;
+      } catch {
+        // Not on wallet yet.
+      }
     }
 
     try {
       await Assertions.expectElementToBeVisible(LoginView.container, {
         description: 'Login view should be stable',
         timeout: 3000,
       });
-      await sleep(1500);
+      await sleep(500);
       await Assertions.expectElementToBeVisible(LoginView.container, {
         description: 'Login view should remain visible',
-        timeout: 2000,
+        timeout: 1500,
       });
       logger.debug(`App ready on login after ${Date.now() - startTime}ms`);
       return;

tests/flows/wallet-home-readiness.ts

@@ -0,0 +1,66 @@
+import PlaywrightMatchers from '../framework/PlaywrightMatchers';
+import { withImplicitWait } from '../framework/PlaywrightUtilities';
+import { WalletViewSelectorsIDs } from '../../app/components/Views/Wallet/WalletView.testIds';
+import { LoginViewSelectors } from '../../app/components/Views/Login/LoginView.testIds';
+
+const IOS_WALLET_HOME_INDICATOR_IDS = [
+  WalletViewSelectorsIDs.WALLET_HEADER_ROOT,
+  WalletViewSelectorsIDs.WALLET_HAMBURGER_MENU_BUTTON,
+  WalletViewSelectorsIDs.ACCOUNT_ICON,
+  WalletViewSelectorsIDs.WALLET_SCROLL_VIEW,
+  WalletViewSelectorsIDs.ACTION_BUTTONS_CONTAINER,
+] as const;
+
+const isElementDisplayedById = async (testId: string): Promise<boolean> => {
+  try {
+    return await withImplicitWait(500, async () => {
+      const el = await PlaywrightMatchers.getElementById(testId, {
+        exact: true,
+      });
+      return await el.isVisible();
+    });
+  } catch {
+    return false;
+  }
+};
+
+const isAnyWalletHomeIndicatorDisplayedOnIOS = async (): Promise<boolean> => {
+  for (const testId of IOS_WALLET_HOME_INDICATOR_IDS) {
+    if (await isElementDisplayedById(testId)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const isWalletScreenExistsWithLoginHiddenOnIOS = async (): Promise<boolean> => {
+  try {
+    return await withImplicitWait(500, async () => {
+      const walletScreen = await PlaywrightMatchers.getElementById(
+        WalletViewSelectorsIDs.WALLET_CONTAINER,
+        { exact: true },
+      );
+      if (!(await walletScreen.unwrap().isExisting())) {
+        return false;
+      }
+      const loginContainer = await PlaywrightMatchers.getElementById(
+        LoginViewSelectors.CONTAINER,
+        { exact: true },
+      );
+      return !(await loginContainer.isVisible());
+    });
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * iOS Appium wallet readiness — `wallet-screen` may exist but report
+ * `displayed === false` while child indicators are visible.
+ */
+export const isWalletHomeReadyOnIOS = async (): Promise<boolean> => {
+  if (await isAnyWalletHomeIndicatorDisplayedOnIOS()) {
+    return true;
+  }
+  return isWalletScreenExistsWithLoginHiddenOnIOS();
+};

tests/flows/wallet.flow.ts

@@ -47,7 +47,6 @@ import { getPasswordForScenario } from '../framework/utils/TestConstants';
 import { resolveE2EWaitTimeoutMs } from '../framework/Constants';
 import PlaywrightUtilities, {
   getDriver,
-  withImplicitWait,
 } from '../framework/PlaywrightUtilities';
 import AccountListBottomSheet from '../page-objects/wallet/AccountListBottomSheet';
 import MetaMetricsOptInView from '../page-objects/Onboarding/MetaMetricsOptInView';
@@ -57,73 +56,14 @@ import OnboardingInterestQuestionnaireView from '../page-objects/Onboarding/Onbo
 import ExperienceEnhancerBottomSheet from '../page-objects/Onboarding/ExperienceEnhancerBottomSheet';
 import { fetchProductionFeatureFlags } from '../performance/feature-flag-helper';
 import { ExistingUserSheetSelectorsIDs } from '../../app/components/Views/Notifications/PushNotificationOnboarding/ExistingUserSheet/ExistingUserSheet.testIds';
-import { WalletViewSelectorsIDs } from '../../app/components/Views/Wallet/WalletView.testIds';
-import { LoginViewSelectors } from '../../app/components/Views/Login/LoginView.testIds';
+import { isWalletHomeReadyOnIOS } from './wallet-home-readiness';
 
 const logger = createLogger({
   name: 'WalletFlow',
 });
 
-const IOS_WALLET_HOME_INDICATOR_IDS = [
-  WalletViewSelectorsIDs.WALLET_HEADER_ROOT,
-  WalletViewSelectorsIDs.WALLET_HAMBURGER_MENU_BUTTON,
-  WalletViewSelectorsIDs.ACCOUNT_ICON,
-  WalletViewSelectorsIDs.WALLET_SCROLL_VIEW,
-  WalletViewSelectorsIDs.ACTION_BUTTONS_CONTAINER,
-] as const;
-
 const WALLET_HOME_POLL_INTERVAL_MS = 250;
 
-const isElementDisplayedById = async (testId: string): Promise<boolean> => {
-  try {
-    return await withImplicitWait(500, async () => {
-      const el = await PlaywrightMatchers.getElementById(testId, {
-        exact: true,
-      });
-      return await el.isVisible();
-    });
-  } catch {
-    return false;
-  }
-};
-
-const isAnyWalletHomeIndicatorDisplayedOnIOS = async (): Promise<boolean> => {
-  for (const testId of IOS_WALLET_HOME_INDICATOR_IDS) {
-    if (await isElementDisplayedById(testId)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const isWalletScreenExistsWithLoginHiddenOnIOS = async (): Promise<boolean> => {
-  try {
-    return await withImplicitWait(500, async () => {
-      const walletScreen = await PlaywrightMatchers.getElementById(
-        WalletViewSelectorsIDs.WALLET_CONTAINER,
-        { exact: true },
-      );
-      if (!(await walletScreen.unwrap().isExisting())) {
-        return false;
-      }
-      const loginContainer = await PlaywrightMatchers.getElementById(
-        LoginViewSelectors.CONTAINER,
-        { exact: true },
-      );
-      return !(await loginContainer.isVisible());
-    });
-  } catch {
-    return false;
-  }
-};
-
-const isWalletHomeReadyOnIOS = async (): Promise<boolean> => {
-  if (await isAnyWalletHomeIndicatorDisplayedOnIOS()) {
-    return true;
-  }
-  return isWalletScreenExistsWithLoginHiddenOnIOS();
-};
-
 /**
  * Waits for the wallet home screen to be ready after login.
  * On iOS, `wallet-screen` may exist but report `displayed === false` while
@@ -659,25 +599,46 @@ export const loginToApp = async (password?: string): Promise<void> => {
 export const dismissPushNotificationExistingUserSheet =
   async (): Promise<void> => {
     try {
-      await withImplicitWait(500, async () => {
-        const btn = await asPlaywrightElement(
+      const sheetTitle = await asPlaywrightElement(
+        encapsulated({
+          detox: () =>
+            Matchers.getElementByID(ExistingUserSheetSelectorsIDs.TITLE),
+          appium: () =>
+            PlaywrightMatchers.getElementByText('Never miss a move', true),
+        }),
+      );
+      await PlaywrightAssertions.expectElementToBeVisible(sheetTitle, {
+        timeout: 5_000,
+        description: 'Push notification existing user sheet',
+      });
+
+      try {
+        const notNowById = await asPlaywrightElement(
           encapsulated({
             detox: () =>
               Matchers.getElementByID(
-                ExistingUserSheetSelectorsIDs.BUTTON_CONFIRM,
+                ExistingUserSheetSelectorsIDs.BUTTON_NOT_NOW,
               ),
             appium: () =>
               PlaywrightMatchers.getElementById(
-                ExistingUserSheetSelectorsIDs.BUTTON_CONFIRM,
+                ExistingUserSheetSelectorsIDs.BUTTON_NOT_NOW,
                 { exact: true },
               ),
           }),
         );
-        if (await btn.unwrap().isDisplayed()) {
-          await PlaywrightGestures.waitAndTap(btn, { timeout: 5_000 });
-          logger.debug('Dismissed push notification existing user sheet');
-        }
+        await PlaywrightGestures.waitAndTap(notNowById, { timeout: 5_000 });
+      } catch {
+        const notNowByText = await asPlaywrightElement(
+          PlaywrightMatchers.getElementByText('Not now', true),
+        );
+        await PlaywrightGestures.waitAndTap(notNowByText, { timeout: 5_000 });
+      }
+
+      await PlaywrightAssertions.expectElementToNotBeVisible(sheetTitle, {
+        timeout: 10_000,
+        description: 'Push notification existing user sheet should close',
       });
+      logger.debug('Dismissed push notification existing user sheet');
     } catch {
       // Sheet not present — no-op
     }
@@ -710,29 +671,39 @@ export const loginToAppPlaywright = async (
 
   await dismissAndroidSystemOverlaysPlaywright();
   await waitForAppReady(resolveE2EWaitTimeoutMs(60_000));
-  await dismissDeveloperMenuPlaywright();
-  await dismissAndroidSystemOverlaysPlaywright();
 
+  // Fast path: already on wallet home (e.g. session persisted across tests).
   try {
-    await waitForWalletHomePlaywright(resolveE2EWaitTimeoutMs(3_000));
+    await waitForWalletHomePlaywright(2_000);
     await dismissPostLoginModals();
     return;
   } catch {
     // Login screen expected — continue below.
   }
 
+  // Dev menu overlays wallet/explore, not the login screen. Probing it while
+  // login is visible wastes ~20s on absent Continue/xmark/Close elements.
+  const onLoginScreen = await Utilities.isElementVisible(
+    LoginView.container,
+    1500,
+  );
+  if (!onLoginScreen) {
+    await dismissDeveloperMenuPlaywright();
+    await dismissAndroidSystemOverlaysPlaywright();
+  }
+
   await PlaywrightAssertions.expectElementToBeVisible(
     asPlaywrightElement(LoginView.container),
     {
       description: 'Login view container',
-      timeout: resolveE2EWaitTimeoutMs(30_000),
+      timeout: 5_000,
     },
   );
   await PlaywrightAssertions.expectElementToBeVisible(
     asPlaywrightElement(LoginView.passwordInput),
     {
       description: 'Login password input',
-      timeout: resolveE2EWaitTimeoutMs(10_000),
+      timeout: 3_000,
     },
   );
 
@@ -741,9 +712,8 @@ export const loginToAppPlaywright = async (
   await LoginView.enterPassword(password ?? '');
   await LoginView.tapLoginButton();
 
-  await dismissPostLoginModals();
-
   await waitForWalletHomePlaywright(resolveE2EWaitTimeoutMs(30_000));
+  await dismissPostLoginModals();
 };
 
 /**