Mobile testing

Native Android & iOS testing with Appium

Tap through your app once and get an idiomatic Appium test that runs on real devices — in the same workspace as your web suites.

Mobile is where suites rot fastest. Capabilities drift between Appium versions, the same flow needs different locators on Android and iOS, waits are guesswork, and a failure on a device you cannot see is close to undebuggable.

Testver treats mobile like the rest of your testing: record on a real device, generate a test in your language, run it locally or on a device cloud, and triage the result next to your web runs rather than in a separate tool.

Android & iOSAppium 2Plain EnglishReal devicesDevice cloudsBeta

Beta · available now

End to end

How mobile testing actually runs here

From an untouched project to a gate on your pipeline, without swapping out the tools your team already knows.

  1. 1

    Switch the project to Mobile — or Both

    Workspace modes adapt the whole UI to what you test, so a mobile project shows device tooling and a mixed project shows both surfaces.

  2. 2

    Connect a device

    A phone plugged into your machine, or a device on BrowserStack, LambdaTest or Sauce Labs. The workflow and the reports are identical either way.

  3. 3

    Record by using the app

    Tap through the journey and the AI Record Agent writes an Appium test in your language, preferring stable accessibility ids over brittle XPath.

  4. 4

    Handle hybrid screens without special-casing

    Webview content inside a native app is captured with its DOM and tagged by context, so generated code addresses the right layer instead of guessing.

  5. 5

    Run, watch and repair

    Live device view while it runs, then failure analysis and Auto-Heal for mobile locators — verified by a re-run before anything is kept.

What that buys you

One workspace

Mobile beside web

Shared scheduling, run history, trends and CI gating, instead of a separate mobile tool with its own silo of results.

Real devices

Local or cloud, same flow

USB-connected phones and three device clouds run the same suite, so you can develop locally and scale out for coverage.

Hybrid ready

Native and webview together

Context-tagged capture means hybrid apps do not need a separate strategy or a separate suite.

Not only recording

Author mobile flows by describing them

Recording is the quickest way to capture a journey you can perform, but you do not always have the app in hand. AI Assistance writes and updates mobile tests from plain English too, with your project’s context — so it reuses your helpers and locator conventions instead of inventing new ones.

  • Describe a scenario and get an idiomatic Appium test in your language
  • Refactor, extend or debug an existing mobile test the same way
  • Reuses the page objects and helpers already in your mobile project
  • Every tool call permission-gated, and the code lands in your repo

Add a test that applies promo code SAVE20 in the cart and asserts the order total.

CheckoutTest.javaJava · Appium
@Test
public void checkoutAppliesPromoCode() {
    driver.findElement(AppiumBy.accessibilityId("cart-tab")).click();
    driver.findElement(AppiumBy.accessibilityId("promo-input")).sendKeys("SAVE20");
    driver.findElement(AppiumBy.accessibilityId("apply-promo")).click();

    assertEquals("$79.20",
        driver.findElement(AppiumBy.accessibilityId("order-total")).getText());
}

What you get for mobile testing

AI Record for mobile

Tap-through capture that generates clean Appium code with self-healing locators.

Plain-English authoring

AI Assistance writes, extends and debugs mobile tests from a description, with your project’s context.

Android & iOS from one project

Both platforms in the same workspace and the same reporting.

Real devices, local or cloud

USB-connected phones, or BrowserStack, LambdaTest and Sauce Labs device clouds.

Live device view

Watch the run as it happens instead of reading a log afterwards.

Hybrid & webview support

DOM capture and context tagging so generated code targets the right layer.

Auto-Heal for mobile locators

Broken ids repaired from what the session saw, then verified by a re-run.

Already using a framework?

Testver wraps it rather than replacing it. Pick yours to see exactly how it fits.

Also works with Android · iOS · WebdriverIO mobile

Quickstart

Start testing mobile in three commands

No account required to install, nothing to configure first, and your existing project works as-is.

1

Install it

One global npm package. Node 18 or newer is the only prerequisite.

terminal
npm install -g @testver/testver
2

Go to your test project

Testver runs from inside the framework project you want to test, so change into that folder first.

terminal
cd path/to/your-test-project
3

Start the dashboard

Opens at localhost:3700. Testver detects the framework, language and structure of the project you started it in and lists your tests — no configuration to write.

terminal
testver serve

Typically under five minutes, start to first generated test.

Full installation guide — prerequisites, ports, running as a service

Mobile testing questions, answered

Do we need a separate tool for mobile testing?
No. Mobile lives in the same Testver workspace as your web and API suites, sharing scheduling, run history, reporting and CI gating.
Do we have to record every mobile test?
No. Recording is the fastest route when you have the app in front of you, but AI Assistance also writes and updates mobile tests from a plain-English description, reusing the helpers and locator conventions already in your project.
Can we run on real devices rather than emulators?
Yes — phones connected to your own machine, or real devices on BrowserStack, LambdaTest and Sauce Labs device clouds.
Does it handle hybrid apps with webview screens?
Yes. Webview content is captured with its DOM and tagged by context, so the generated test addresses the native layer or the web layer correctly.
Ready to upgrade your test suite?

Keep your framework. Add AI and a premium toolset.

Set up in minutes. Self-host on your own hardware. Describe a test in plain English and get working code in your own framework — in a fraction of the time.