Back to Blog
Blog

Expo E2E Testing: How to Test Your Expo App on iOS and Android

A practical guide to Expo E2E testing: which EAS build to test, simulator and APK profiles, Detox vs Appium vs BugRadar, worked failure examples and CI.

Written by
Gautam Agarwal
Read time
13 min read
Published
Expo E2E Testing: How to Test Your Expo App on iOS and Android

Quick answer: Expo E2E testing runs a standalone EAS build of your Expo app on a simulator, emulator or phone and drives it the way a user would, tapping, typing and checking each screen. It confirms that your JavaScript, native modules and app config work together in the build people install.

Testing in Expo Go is like test driving the showroom model. Your users drive the car that rolls out of EAS Build, with your own native modules, config plugins and keys. E2E tests belong in that car.

Key Takeaways

  • Test a standalone build: a development build waits for a dev server, so CI and cloud devices need a preview or simulator build.
  • An EAS profile with ios.simulator: true produces an iOS Simulator .app, and buildType: apk produces an installable Android .apk.
  • Expo Go ships a fixed set of native libraries, so purchases, push and custom native code need your own build.
  • Detox on Expo needs a config plugin, and for SDK 54 and later that plugin is community maintained.
  • EAS Update can change JavaScript after a build passes, so rerun journeys on the update's channel before promoting it.
  • BugRadar runs flows on EAS builds for iOS and Android, including builds uploaded straight from an EAS build hook.

What is Expo E2E testing?

Expo E2E testing checks a complete user journey inside a built Expo app. It follows the same spine as any mobile E2E test:

  1. Build. Create a standalone build with EAS Build.
  2. Drive. Launch it on a device and perform the user's actions.
  3. Assert. Confirm the expected screen, text or state appears.

The Expo part lives in step 1. Choosing the right build decides whether the test measures your real app or a stand in.

Where Expo apps break

LayerWhat can breakHow a test catches it
Build profileA development build waits for a dev serverLaunch the uploaded build on a fresh device
Native configA config plugin or app.json change alters permissions or entitlementsRun journeys after every prebuild
JavaScript bundleAn EAS Update ships code that needs native support the installed build lacksRun journeys on the update's channel before promoting it
PermissionsA denied prompt leaves the app stuckCover both the allow and the deny answer
Deep linksA link opens the wrong route, or lands on a blank screenOpen each important URL from outside the app
Store and push integrationsPurchases and pushes behave differently from Expo GoTest them in your own build

Expo Go, development build or release build: which one should you test?

BuildWhere JavaScript comes fromCustom native codeBest use
Expo GoYour dev serverExpo Go's built-in setQuick UI checks
Development buildYour dev serverAny library you addDaily development
Preview or simulator buildBundled inside the appAny library you addE2E tests on simulators, emulators and CI
Store buildBundled inside the appAny library you addRelease to the App Store and Google Play

The Expo development builds guide describes a development build as your own version of Expo Go, free to use any native library. That freedom is the reason to test your own build, and the dev server dependency is the reason to test a preview or simulator build rather than the development build itself.

With BugRadar: cloud runs need a standalone build, because a debug build loads JavaScript from Metro on your computer. For quick checks against a development build, BugRadar sandboxes can forward Metro's port with BugRadar sandbox forward 8081.

Why E2E testing matters for Expo apps

Prebuild rewrites your native project. Config plugins and app.json changes regenerate the ios and android folders, so a one line config change can alter permissions, entitlements or build settings.

Expo Go hides native gaps. A screen that works in Expo Go can behave differently once your own native modules load in a real build.

One codebase ships two apps. Permission prompts, keyboards and back navigation differ between iOS and Android.

Ways to run Expo E2E tests

Where tests runHow you get the buildBest for
Your machinenpx expo run:ios --configuration Release or npx expo run:android --variant releaseDebugging a failing journey
Expo WorkflowsAn E2E build profile plus a workflow file in .eas/workflows, triggered on every pull requestTeams that keep CI inside EAS
GitHub ActionsEAS Build, then the BugRadar GitHub ActionTeams that already use GitHub CI
EAS build hookUpload to BugRadar after each successful buildSaving CI minutes

The Expo E2E workflows guide shows the Expo Workflows route: an E2E build profile in eas.json, a YAML workflow that builds an .apk or .app, and a test job that runs on each pull request. Every route ends the same way, with a release style build on a simulator or emulator.

Detox vs Appium vs BugRadar for Expo

DetoxAppiumBugRadar
Expo setupA config plugin plus npx expo prebuildInstall your EAS build on a deviceUpload the EAS build
Test formatJavaScript with JestClient code in several languagesA written flow, in YAML or the dashboard
Finding elementstestID, text or label matchersLocators such as accessibility IDsThe agent reads the live screen
Pull request feedbackYour CI job and reporterYour CI job and reporterA PR comment with videos plus a GitHub Check
CostFree, open sourceFree, open sourceFree tier, then paid plans

‍

One Expo specific detail: the Expo team removed the Detox plugin from its official config plugins repository, and a community maintained Detox config plugin now supports SDK 54 and later. Check that compatibility before an SDK upgrade.

__wf_reserved_inherit

How to set up Expo E2E testing

Step 1: Add EAS build profiles for testing

{

  "build": {

    "BugRadar-simulator": {

      "distribution": "internal",

      "ios": { "simulator": true }

    },

    "preview": {

      "distribution": "internal",

      "channel": "preview",

      "android": { "buildType": "apk" }

    }

  }

}

‍

eas build --platform ios --profile BugRadar-simulator

eas build --platform android --profile preview

With BugRadar: download the iOS build, compress the .app to a .zip and upload it; upload the Android .apk as it is. For real iPhones, an internal distribution profile that leaves out the simulator key produces an .ipa.

Step 2: Write your first test

```yaml

# .BugRadar/onboarding.flow.yaml

name: Onboarding

instructions: |

  Open the app as a new user and complete onboarding.

  Sign up with a new email address.

  Verify the home screen loads.

```

‍

With BugRadar: a flow describes what the user does and what they should see. The only required keys are name and instructions, the file lives in your repo under .BugRadar/, and BugRadar flows validate checks it before you push.

Step 3: Run tests locally

Install the simulator build on a booted iOS Simulator (this guide to Android emulator setup covers the Android side), then run:

BugRadar up --platform ios

BugRadar run onboarding --local

With BugRadar: the CLI detects every booted device, so an iOS Simulator and an Android Emulator run the same flow in one pass. Coding agents use the same path: tell Claude Code or Cursor "Build the feature. Test it locally using BugRadar and fix anything that fails."

Step 4: Run tests on every build

Expo teams have two options. The BugRadar GitHub Action can wait for an EAS build, download it and upload it. An EAS build hook can upload straight to BugRadar after each successful build, which saves CI minutes because the GitHub runner stays free. The BugRadar CI/CD docs include a complete EAS workflow.

With BugRadar: once builds arrive, the BugRadar GitHub bot reads each PR diff, selects or writes the relevant flows, runs them and posts a comment with videos plus a GitHub Check.

__wf_reserved_inherit

The Expo journey checklist

Expo's own testing advice covers happy paths, such as a successful sign up, and sad paths, such as invalid payment details. A complete suite covers both:

JourneyHappy pathSad path
OnboardingA new user reaches the home screenA skipped step or a back press mid flow
Sign up with an email codeThe code signs the user inA wrong or expired code
PermissionsAccess granted, feature worksAccess denied, the app explains and recovers
Push notificationsThe banner opens the right screenThe user denied notifications
PurchasesPremium unlocksDeclined or cancelled payment
Deep linksThe URL opens the right routeAn outdated or malformed URL

For the two hardest rows, see the guides on push notification testing and in-app purchase testing.

Testing EAS Update changes

EAS Update ships JavaScript to builds that are already installed, so a passing build can still break after an update lands. Two rules keep updates safe:

  • Native changes need a new build. An over the air update can change JavaScript, yet it leaves the signed app as it was, so entitlement, permission and native module changes all require a fresh EAS build.
  • Test the channel before promoting it. The preview profile in Step 1 sets channel: preview, so an update published to that channel reaches your test build first.

With BugRadar: rerun your suite against the preview build after each update to the preview channel, then promote the update once the flows pass.

Testing deep links

Expo Router gives every screen a URL, which makes deep links easy to break during a refactor. Test each URL that arrives from outside the app: links in emails, push payloads and marketing campaigns.

With BugRadar: coding agents can open a link inside an BugRadar sandbox with BugRadar sandbox open myapp://path, then check the screen with BugRadar sandbox look.

Testing SDK upgrades

An SDK upgrade regenerates the native project, so treat it like a new app. Rebuild both platforms, rerun every journey, and check any third party plugin's compatibility table first, as the Detox config plugin example shows.

Expo E2E testing examples

Each example starts from a failing run and traces it to a cause and a fix.

Example 1: The test build opens to a blank screen

Scenario: the team uploads its latest EAS build to a cloud simulator, and every flow fails on the first screen.

StepExpectedWhat the run showed
Launch the appWelcome screenA launcher asking for a development server
Tap "Get started"Sign up screenLauncher screen
Complete sign upHome screenLauncher screen

Cause: the uploaded build came from the development profile, which includes expo-dev-client and waits for a dev server.

Fix: build from a profile that leaves out developmentClient, such as BugRadar-simulator or preview, so JavaScript ships inside the app.

Example 2: Push arrives on Android and stays silent on iOS

Scenario: an order update push reaches the Android Emulator, and the same flow fails on the iOS Simulator.

StepExpectedWhat the iOS run showed
Allow notificationsPermission grantedPermission granted
Backend sends the pushBanner appearsNo banner
Tap the bannerOrder screenHome screen

Cause: the simulator profile produced an app that lacks the APNs entitlement.

Fix: add the expo-notifications config plugin, which adds aps-environment to the iOS app during prebuild, then rebuild.

With BugRadar: BugRadar tests real APNs and FCM delivery on its virtual devices, from the permission prompt to the tap. See this walkthrough of push notification testing.

Example 3: The paywall works in Expo Go and fails in the build

Scenario: the subscription screen looks right in Expo Go. In the preview build, the purchase fails.

StepExpectedWhat the build run showed
Open the paywallPlans listedPlans listed
Buy the monthly planPremium screenPurchase error
Reopen the appPremium screenPaywall

Cause: in Expo Go, the purchases SDK runs a preview mode, so the real native module and its API key first ran in the build.

Fix: test purchases only in your own build, using a dedicated test key.

With BugRadar: with RevenueCat Test Store, the agent selects a successful, failed or cancelled purchase and checks entitlement state after the app reopens. This ranking of mobile app testing tools compares other approaches, and leased inboxes handle email codes, as this guide to OTP testing shows.

Example 4: An update crashes builds that passed yesterday

Scenario: the team publishes an EAS Update to the preview channel. Test builds that passed the day before now fail at launch.

StepExpectedWhat the build run showed
Open the paywallPlans listedPlans listed
Buy the monthly planPremium screenPurchase error
Reopen the appPremium screenPaywall

Cause: the update called a native module that only exists in a newer build.

Fix: ship native changes through a new EAS build, and keep updates to JavaScript that the installed build already supports.

With BugRadar: a flow that relaunches the app after the update catches this before the update reaches production.

Common Expo E2E problems and fixes

SymptomLikely causeFix
Launcher asks for a dev serverA development build was uploadedBuild from a profile that leaves out developmentClient
iOS build rejected by the simulatorA device build or an Intel x86_64 buildUse ios.simulator: true and build on Apple silicon or EAS
Push silent on iOS onlyMissing APNs entitlementAdd the expo-notifications config plugin
Detox build errors after an SDK upgradePlugin and Detox versions out of stepMatch the plugin's compatibility table
Tests pass, real devices fail on pushRe-signed .ipa loses push entitlementsTest push on simulators, other journeys on devices
A passing build crashes after an updateThe update needs native code the build lacksShip native changes in a new build
A deep link opens the home screenA route renamed during a refactorTest every external URL after navigation changes

‍

The Expo E2E process, summarized

StepWhat you doOutput
1. ProfileAdd simulator and APK profiles to eas.jsonTest build profiles
2. BuildRun EAS Build for both platforms.app and .apk
3. WriteCover onboarding, login, purchases and pushFlows for vital journeys
4. Run locallyRun on a simulator and an emulatorA passing first run
5. AutomateUpload from CI or an EAS build hookResults on every PR
6. DiagnoseTrace each failure to its causeA fix in the app or the build

Conclusion

Expo E2E testing is mostly a build decision. Test a standalone simulator or preview build, keep your config plugins in mind, and treat every failing run as a symptom to trace back to its cause.

A good first step this week: add the two test profiles to eas.json, build once for each platform, and run your onboarding journey as an BugRadar flow on both.

__wf_reserved_inherit

FAQs

Can you run E2E tests in Expo Go?

You can check simple screens, though Expo Go lacks your custom native code, so test your own build.

Which EAS profile should E2E tests use?

Use an internal profile with ios.simulator: true for iOS and buildType: apk for Android.

Does Detox work with Expo?

Yes, through a config plugin and prebuild; SDK 54 and later rely on a community maintained plugin.

Can BugRadar test an Expo development build?

Cloud runs need a standalone build; sandboxes can forward Metro's port for development builds.

How do Expo builds reach BugRadar automatically?

Use the BugRadar GitHub Action or an EAS build hook that uploads after each successful build.

Should you test EAS Updates?

Yes. Run your journeys on the update's channel before promoting it to production.

‍

‍

Fix bugs, not tests.

Talk to an expert.

Book 30 minutes with our team. We'll show you BugRadar running on your app.

Start building.

Describe a user journey and watch an agent run it on iOS, Android, and web.

Try for free