Automate the Actxa App with Maestro

Write YAML-based E2E test flows that automate a real Android app on your phone.

Introduction

30 Second Summary

Every time you test a mobile app by hand, you tap the same buttons, scroll the same screens, and check the same text over and over. It works, but it does not scale.

In this project, you will build an automated end-to-end test suite that runs real user journeys on your phone using Maestro CLI. You will write YAML-based test flows that launch the Actxa app, navigate screens, scroll content, and verify that the right elements appear.

What You'll Build

A complete E2E testing automation suite for the Actxa app, running directly on your real Samsung S9+ phone and generating HTML test reports.

By the end of this project, you'll have:

  • A working Maestro CLI installation on Windows connected to your real phone via USB.
  • A set of YAML test flows that automate launching, navigating, scrolling, and verifying the Actxa app.
  • A multi-flow test suite organized into modular subflows with an HTML report showing pass/fail results.
  • Secret Mission: Add a login flow that automates signing into the app using environment variables for secure credential handling.

Are there any prerequisites?

You need Java 17+ installed on your machine, a Samsung S9+ with the Actxa app installed from the Play Store, and a USB cable to connect your phone to your PC. You should also have VS Code and Windows Terminal ready to go.

Install Maestro CLI and Connect Your Phone

Testing the Actxa app manually means tapping through screens one by one, checking if things look right, and repeating it every time something changes. Maestro CLI lets you automate those same journeys by writing simple YAML files that tell your phone what to do.

Before you can write any test flows, you need two things connected: the Maestro CLI running on your Windows PC, and your Samsung S9+ phone talking to it over USB. In this step, you will install Maestro, unlock developer access on your phone, and confirm the two can communicate.

In this step, get ready to:
  • Install Maestro CLI on your Windows PC.
  • Enable USB debugging on your Samsung S9+.
  • Verify Maestro can see and control your phone.
Download and install Maestro CLI on Windows

Maestro CLI is a command-line tool that sends test commands to your phone over ADB. On Windows, you install it by downloading a zip from GitHub and adding it to your system PATH.

What is Maestro CLI?

Maestro is an open-source mobile UI testing framework. The CLI version lets you run test flows from the terminal, which is the professional path for integrating tests into CI/CD pipelines later.

It requires Java 17 or higher, which you already have installed.

  • Open the Maestro GitHub Releases page in your browser.
  • Find the latest release (CLI 2.6.1) and download maestro.zip from the Assets section.
  • Extract the contents of the zip to C:\maestro.
  • You should now have a bin folder inside C:\maestro.

Why C:\maestro?

Placing Maestro in a short, stable path like C:\maestro avoids issues with spaces or special characters in folder names. The official Maestro docs recommend this location for Windows installs.

  • Open Windows Terminal by pressing the Windows key, typing Terminal, and pressing Enter.
  • Add the Maestro bin folder to your system PATH by running this command:
setx PATH "%PATH%;C:\maestro\bin"

What does this command do?

The setx command permanently adds C:\maestro\bin to your system PATH environment variable. This lets you run maestro from any terminal window without typing the full file path.

  • Close Windows Terminal completely.
  • Reopen Windows Terminal (press the Windows key, type Terminal, press Enter).
  • Verify the installation by running:
maestro --help

You should see Maestro's help output listing available commands.

✔️ I see Maestro help output

Maestro CLI is installed and ready. Move on to the next substep to set up your phone.

ⓧ I see a Java-related error

Maestro requires Java 17 or higher. Confirm your Java version by running:

java -version
  • If the output shows a version lower than 17, update your Java installation to 17 or higher.
  • Make sure your JAVA_HOME environment variable points to your Java 17+ installation folder.
  • After updating, close and reopen Windows Terminal, then run maestro --help again.

ⓧ Command not found

The PATH was not updated correctly. Try these fixes:

  • Confirm the folder C:\maestro\bin exists and contains files (including maestro.bat or similar executables).
  • Re-run the setx command from above in a fresh terminal window.
  • Close and reopen Windows Terminal again. PATH changes only take effect in new terminal sessions.
  • If it still fails, open System Properties (search for "Environment Variables" in Windows), find Path under User variables, and manually add C:\maestro\bin.

On macOS or Linux?

If you are following along on macOS or Linux instead, you can install Maestro with a single command:

curl -fsSL "https://get.maestro.mobile.dev" | bash
Enable USB debugging on your Samsung S9+

Maestro communicates with your phone through ADB (Android Debug Bridge). For ADB to connect, you need to unlock a hidden menu on your phone called Developer Options, then enable USB debugging.

  • On your Samsung S9+, open Settings.
  • Tap About phone.
  • Tap Software information.
  • Tap Build number seven times in a row.
  • You will see a message saying you are now a developer. If prompted, enter your PIN or password to confirm.

What are Developer Options?

Developer Options is a hidden settings menu on Android that gives you access to debugging tools. It is hidden by default to prevent accidental changes, which is why you unlock it by tapping Build number repeatedly.

  • Go back to the main Settings screen.
  • Scroll to the bottom and tap Developer options.
  • Find USB debugging and toggle it on.
  • Connect your Samsung S9+ to your PC using a USB cable.
  • A prompt will appear on your phone asking to allow USB debugging from this computer. Tap Allow.

Don't see the USB debugging prompt?

Make sure your USB cable supports data transfer, not just charging. Try a different cable if the prompt never appears.

If you previously denied the prompt, go to Developer options, tap Revoke USB debugging authorizations, then reconnect the cable.

Help me troubleshoot USB debugging on my Samsung S9+.

Verify the connection

Now that your phone is connected and authorized, confirm that Maestro can actually see it.

  • In Windows Terminal, verify Maestro can communicate with your phone by running:
maestro hierarchy

What does this command do?

The maestro hierarchy command reads the current UI state of whatever is displayed on your phone screen. It prints the element tree as XML-like data, showing every text label, button, and view currently visible.

Later you will use this command to find the exact text and IDs of elements you want to tap or assert in your test flows.

You should see XML-like output listing UI elements from your phone's current screen.

✔️ I see XML element data

Your connection is working. Maestro can see and interact with your phone.

ⓧ I see an error or no device found

  • Make sure your phone screen is unlocked and awake when you run the command.
  • Disconnect and reconnect the USB cable. Check that the authorization prompt appears again on your phone and tap Allow.
  • Try running maestro hierarchy again after reconnecting.

Help me fix Maestro not detecting my Android phone.

Your tools are connected and ready. Next up, you will write your first YAML test flow that launches the Actxa app and verifies the dashboard loads.

Write Your First Flow - Launch and Verify Dashboard

Your Maestro CLI is installed and talking to your Samsung S9+. Now it's time to write your first automated test flow.

Maestro uses YAML files to define test flows. Each flow is a sequence of commands that tell Maestro what to do on the device. Your first flow will launch the Actxa app and verify that the dashboard screen appears.

In this step, get ready to:
  • Create the project folder and your first YAML flow file.
  • Write a flow that launches the Actxa app and verifies the dashboard.
  • Run the flow against your real phone and see live results.
Create the project structure

Every test automation project starts with a dedicated folder to keep your flow files organized. You will create a folder called actxa-tests on your Desktop and set up your first flow file inside it.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir actxa-tests
cd actxa-tests
  • Create your first flow file by running:
New-Item launch-app.yaml
  • Confirm the file exists by running:
ls

You should see launch-app.yaml in the output.

  • Open the folder in VS Code by running:
code .

VS Code opens with your actxa-tests folder loaded in the Explorer sidebar. You should see launch-app.yaml listed there.

code . not recognized?

If PowerShell does not recognize code, the VS Code CLI was not added to your PATH during installation. Open VS Code manually instead.

  • Press the Windows key to open your search bar.
  • Type VS Code and press Enter to open it.
  • Click File in the top menu bar, then Open Folder.
  • Navigate to your Desktop and select the actxa-tests folder.

Help me fix the code . command in PowerShell

Write the launch flow

A Maestro flow file has two sections separated by ---. The top section holds configuration (the app ID, a name for the flow, and optional tags). The bottom section holds the commands that Maestro runs on the device.

  • In VS Code, click on launch-app.yaml in the Explorer sidebar to open it.
  • Paste the following code into the file:
appId: com.actxa.actxa
name: Launch and Verify Dashboard
tags:
  - smoke
---
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
- assertVisible: ".*[Ss]teps.*"

What does this flow do?

  • appId: com.actxa.actxa tells Maestro which app to target. This is the Actxa app's Android package name.
  • name and tags are metadata that help organize your tests. The smoke tag marks this as a quick sanity check.
  • --- separates configuration from commands.
  • launchApp opens the Actxa app on your phone.
  • waitForAnimationToEnd pauses for up to 5000 milliseconds while the app finishes loading animations.
  • assertVisible: ".*[Ss]teps.*" checks that text matching "Steps" or "steps" appears on screen. This confirms the dashboard loaded.

Why use a regex pattern like .*[Ss]teps.*?

Maestro selectors are regex-based by default. The .* matches any surrounding text, and [Ss] handles both uppercase and lowercase. This makes your test resilient to minor text changes in future app updates.

  • Save launch-app.yaml by pressing Ctrl+S.

Seeing red squiggles in VS Code?

YAML is sensitive to indentation. Make sure timeout: 5000 is indented with exactly 4 spaces under waitForAnimationToEnd:. Tabs will cause errors.

Help me fix YAML indentation in my Maestro flow file

✔️ Awesome, I've got everything!

Great. Make sure you have saved the file before moving on.

ⓧ I'd like to double check the full code

Here is the complete launch-app.yaml file. Make sure yours matches exactly:

appId: com.actxa.actxa
name: Launch and Verify Dashboard
tags:
  - smoke
---
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
- assertVisible: ".*[Ss]teps.*"
Run the flow against your real phone

With your flow file saved, you can run it against your Samsung S9+. Maestro will take control of the phone, launch the Actxa app, and verify the dashboard appears.

  • Make sure your phone is unlocked and connected via USB.
  • In Windows Terminal, make sure you are inside the actxa-tests folder. Run the flow by executing this command:
maestro test launch-app.yaml

What happens when you run this?

Watch your phone as Maestro takes control. You will see the Actxa app launch automatically. Maestro waits for animations to finish, then checks the screen for text matching "Steps".

In the terminal, Maestro prints a live progress report. Each command shows a pass or fail status as it executes. A green checkmark means the command succeeded.

When the flow completes, the terminal displays a summary showing that all commands passed. Your phone shows the Actxa dashboard screen.

Flow failed on assertVisible?

The text on your dashboard might not match the regex pattern. Use maestro hierarchy in a separate terminal to see the exact text elements on your current screen. Look for the text that represents your step count and update the assertVisible pattern to match it.

Also make sure the Actxa app is not showing a sync screen or popup that hides the dashboard. If it is, increase the timeout value to give the app more time to load.

Help me debug why my Maestro assertVisible command is failing

Connection error or device not found?

Check that your phone is still connected and unlocked. Run maestro hierarchy to confirm the connection is still active. If it fails, unplug and replug the USB cable, then tap Allow on the phone if prompted to authorize the computer again.

Help me fix the Maestro device connection on Windows

Your first automated test flow is running against a real device. Next up, you will write a flow that navigates between multiple screens in the Actxa app.

Navigate Between Screens

Your launch flow proves the Actxa app opens and lands on the dashboard. A real user does more than open the app, though.

In this step, you will write a flow that taps between screens, waits for content to load, and verifies the app navigated correctly. This is the core pattern you will repeat for every navigation test you ever write.

In this step, get ready to:
  • Create a navigation flow that taps between app screens.
  • Handle loading delays with animation waits and retry options.
  • Run the flow on your real phone and debug selector issues.
Create the navigation flow file

A single-screen check is not enough to prove an app works. You need to verify that tapping navigation elements actually takes the user to the expected screen and back.

  • In VS Code, create a new file called navigate-screens.yaml inside your actxa-tests folder.
  • Paste the following flow into the file:
# Configuration: identify the app and tag this flow
appId: com.actxa.actxa
name: Navigate Between Screens
tags:
  - navigation
---
# Launch the app and confirm we start on the dashboard
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
- assertVisible: ".*[Ss]teps.*"

# Tap the Sleep tab and verify it loads
- tapOn:
    text: ".*[Ss]leep.*"
    retryTapIfNoChange: true
- waitForAnimationToEnd:
    timeout: 3000
- assertVisible: ".*[Ss]leep.*"

# Press back and verify the dashboard returns
- back
- waitForAnimationToEnd:
    timeout: 3000
- assertVisible: ".*[Ss]teps.*"

What does this flow do?

  • The config section above --- sets the app ID, gives the flow a human-readable name, and tags it as a navigation test.
  • launchApp opens the Actxa app on your phone. waitForAnimationToEnd pauses until the screen settles (up to 5 seconds).
  • assertVisible checks that text matching the regex .*[Ss]teps.* appears on screen. This confirms you are on the dashboard.
  • tapOn taps the element whose text matches .*[Ss]leep.*. The retryTapIfNoChange: true flag tells Maestro to try tapping again if nothing on screen changes after the first attempt.
  • back presses the system back button, then another assertVisible confirms you returned to the dashboard.
  • Save navigate-screens.yaml.

File not saving?

Make sure the file is inside the actxa-tests folder, not one level up. Check the VS Code Explorer sidebar to confirm the file sits alongside launch-app.yaml.

Help me figure out why my YAML file is not in the right folder.

✔️ Awesome, I've got everything!

Great. Make sure you have saved the file before moving on.

ⓧ I'd like to double check the full code

appId: com.actxa.actxa
name: Navigate Between Screens
tags:
  - navigation
---
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
- assertVisible: ".*[Ss]teps.*"
- tapOn:
    text: ".*[Ss]leep.*"
    retryTapIfNoChange: true
- waitForAnimationToEnd:
    timeout: 3000
- assertVisible: ".*[Ss]leep.*"
- back
- waitForAnimationToEnd:
    timeout: 3000
- assertVisible: ".*[Ss]teps.*"
Handle animations and loading delays

The Actxa app syncs health data from your fitness tracker when it opens. This means screens take a moment to settle before all UI elements are visible.

Why waitForAnimationToEnd?

Without a wait, Maestro would try to tap or assert immediately after a screen change. If the app is still loading, the target element might not exist yet, and the flow would fail. waitForAnimationToEnd tells Maestro to pause until the screen stops changing pixels.

The timeout value (in milliseconds) sets the maximum time Maestro will wait. 5000 ms for the initial app launch gives the data sync time to finish. 3000 ms for subsequent screen transitions is usually enough for a simple navigation tap.

Why retryTapIfNoChange?

Sometimes a tap does not register on a real device. The screen might still be animating, or the touch target might be partially obscured. Setting retryTapIfNoChange: true makes Maestro automatically retry the tap if nothing on screen changed after the first attempt.

Run and iterate on your selectors

Now you will run the flow against your real phone. Expect that selectors might need adjusting. The regex patterns match common text in the Actxa app, but your specific app version or language settings could display slightly different labels.

  • Run the navigation flow by executing this command in Windows Terminal:
maestro test navigate-screens.yaml

Watch your phone as Maestro takes control. You should see the app launch, the Sleep screen appear, and then the dashboard return. The terminal shows a live progress report with pass or fail status for each command.

What if a command fails?

Maestro tells you exactly which step failed and why. If assertVisible fails, the text on your screen does not match the regex pattern. If tapOn fails, no element with matching text was found.

To inspect what text is actually on screen, run maestro hierarchy in a separate terminal window. This prints the full UI element tree so you can find the exact text or content description to use in your selector.

Flow failing on the tapOn step?

The Actxa app may label its Sleep tab differently depending on your app version or language. Run maestro hierarchy while on the dashboard screen. Look for the element that represents the Sleep section and copy its exact text into your regex pattern.

Also confirm your phone screen is unlocked and the USB cable is connected. Maestro communicates over ADB, so a disconnected cable means no commands reach your device.

Help me debug why my navigation flow is failing on the tapOn step.

Your navigation flow proves the app can move between screens and return safely. Next up, you will test scrolling through content and verifying that elements below the fold actually load.

Scroll and Assert Content

Your navigation flow proved that Maestro can tap between screens and verify transitions. Now you'll tackle content that lives below the visible area of the screen.

Many apps display data that requires scrolling to reach. The Actxa app shows health metrics like heart rate data further down the dashboard. In this step, you'll write a flow that scrolls until specific content appears and verifies it loaded correctly.

In this step, get ready to:
  • Create a scroll-and-assert flow YAML file.
  • Run the flow to verify Maestro scrolls your phone and finds hidden content.
Create the scroll flow file

Some UI elements only appear after the user scrolls down. Maestro's scrollUntilVisible command handles this by scrolling incrementally and checking after each scroll whether the target element has appeared.

  • In VS Code, create a new file called scroll-content.yaml inside your actxa-tests folder.
  • Add the following flow content to the file:
# Configuration section - identifies the app and tags this flow
appId: com.actxa.actxa
name: Scroll and Assert Content
tags:
  - content
---
# Launch the app and wait for the dashboard to load
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
# Scroll down until heart rate content becomes visible
- scrollUntilVisible:
    element: ".*[Hh]eart [Rr]ate.*"
# Verify the heart rate content actually loaded
- assertVisible: ".*[Hh]eart [Rr]ate.*"
# Return to the previous screen
- back

What does this code do?

The configuration section is the same pattern you used in your earlier flows. The content tag categorizes this as a content-verification flow.

  • scrollUntilVisible scrolls the screen in small increments, checking after each scroll whether the target element has appeared. The element parameter uses a regex pattern to match text containing "Heart Rate" regardless of capitalization.
  • assertVisible confirms the element is actually on screen after the scroll completes. Without this assertion, you would only know Maestro scrolled but not whether it found what it was looking for.
  • back presses the system back button to return to the previous screen, leaving the app in a clean state.
  • Save scroll-content.yaml.

File not saving?

Make sure the file is inside the actxa-tests folder, not in a subfolder or your home directory. Check for any red underline in VS Code that might indicate a YAML syntax error like incorrect indentation.

help me fix a YAML syntax error in my Maestro flow file

✔️ Awesome, I've got everything!

Great. Make sure you've saved the file before moving on.

ⓧ I'd like to double check the full code

Here is the complete scroll-content.yaml file for comparison:

appId: com.actxa.actxa
name: Scroll and Assert Content
tags:
  - content
---
- launchApp
- waitForAnimationToEnd:
    timeout: 5000
- scrollUntilVisible:
    element: ".*[Hh]eart [Rr]ate.*"
- assertVisible: ".*[Hh]eart [Rr]ate.*"
- back
Combine scrolling with assertions

The scroll-then-assert pattern is the foundation for testing any content that lives below the fold. Each pair works as a unit: scroll to reveal, then assert to prove it loaded.

How does scrollUntilVisible work under the hood?

Maestro doesn't scroll to the bottom all at once. It performs small scroll gestures and checks the screen after each one. If the target element appears, scrolling stops immediately. If Maestro reaches the bottom of the scrollable area without finding the element, the command fails.

You can chain multiple scrollUntilVisible and assertVisible pairs in a single flow to verify several below-the-fold sections. Each pair targets a different piece of content, building a full content-verification checklist.

Use maestro hierarchy to find scroll targets

If you want to scroll to other content on the screen, run maestro hierarchy in your terminal while the app is open. The output shows every text label and content description visible in the current view hierarchy. Use those strings as your regex targets.

Run the flow against your phone

Time to see Maestro scroll your phone automatically. Make sure your Samsung S9+ is connected and the screen is unlocked.

  • Run the scroll flow by executing this command in Windows Terminal:
maestro test scroll-content.yaml
  • Watch your phone as Maestro launches the Actxa app, then scrolls the dashboard until heart rate content appears.
  • In the terminal, you should see each command pass with a checkmark. The output confirms that scrollUntilVisible found its target and assertVisible verified it.

Flow failing on scrollUntilVisible?

If Maestro cannot find the heart rate element, your app's dashboard might use different text. Run maestro hierarchy while the app is open and scroll down manually to see what text labels are available. Update the regex pattern in your YAML to match what you see.

Also confirm your phone screen is unlocked and the USB cable is securely connected. A disconnected device causes Maestro to hang or time out.

help me debug why Maestro scrollUntilVisible is failing on my phone

Your three flows now cover launching, navigating, and scrolling. Next up, you'll chain them all into a single test suite and generate an HTML report.

Run the Full Suite with Reports

Your individual flows each test one piece of the Actxa app in isolation. In real test automation, you run all your tests together as a single suite so you can see the overall health of the app in one go.

In this step, you will chain your three flows into a test runner that executes them sequentially. Then you will generate an HTML report that shows pass/fail results for every flow.

In this step, get ready to:
  • Create a test runner flow that chains all your individual flows into one suite.
  • Run the full suite and generate an HTML test report.
  • Review the report in your browser to see pass/fail results.
Create the test runner flow

A test runner flow uses the runFlow command to call other flow files in sequence. This keeps each test focused on one responsibility while letting you execute everything with a single command.

  • In VS Code, create a new file called run-all-tests.yaml inside your actxa-tests folder.
  • Add the following content to run-all-tests.yaml:
appId: com.actxa.actxa
name: Actxa Full Test Suite
tags:
  - suite
---
- launchApp
- runFlow: "launch-app.yaml"
- runFlow: "navigate-screens.yaml"
- runFlow: "scroll-content.yaml"

What does this flow do?

The configuration section names the suite and tags it with suite for filtering later.

Below the --- separator, launchApp opens the Actxa app once. Each runFlow command then executes a sub-flow file in order. If any sub-flow fails, Maestro reports which one and which command within it caused the failure.

  • Save run-all-tests.yaml.
  • Confirm the file exists by running:
ls

You should see run-all-tests.yaml listed alongside your other three flow files.

Don't see the file?

Make sure you saved the file inside the actxa-tests folder and not in a parent or nested directory. Check the VS Code Explorer sidebar to confirm its location.

Help me find where my file was saved.

✔️ Awesome, I've got everything!

Great. Double check you have saved run-all-tests.yaml and you are ready to run the full suite.

ⓧ I'd like to double check the full code

appId: com.actxa.actxa
name: Actxa Full Test Suite
tags:
  - suite
---
- launchApp
- runFlow: "launch-app.yaml"
- runFlow: "navigate-screens.yaml"
- runFlow: "scroll-content.yaml"
Run the full suite with HTML report generation

Maestro can produce an HTML report alongside running your tests. The --format flag tells Maestro which report type to generate, and --output sets the destination file.

  • Run the entire test suite and generate an HTML report by running this command:
maestro test --format html --output report.html run-all-tests.yaml

What does this command do?

  • maestro test tells Maestro to execute the flow file.
  • --format html generates a human-readable HTML report instead of the default format.
  • --output report.html saves the report to a file called report.html in your current directory.
  • run-all-tests.yaml is the suite flow that chains your individual test flows.

Watch your phone as Maestro takes control. It launches the Actxa app and executes each sub-flow in sequence. The terminal shows live progress for each command.

  • Wait for the suite to finish. You should see a summary in the terminal showing which flows passed and which (if any) failed.
  • Confirm report.html was created by running:
ls

You should see report.html in the output alongside your YAML files.

Suite failed or no report generated?

If a flow fails, Maestro still generates the report showing which step failed. Check the terminal output for the exact command that caused the failure and adjust your selectors.

If no report.html file appeared, make sure you included both --format html and --output report.html in your command. Without --output, Maestro defaults to writing report.xml instead.

Help me troubleshoot why my Maestro test suite is failing.

Review the report

The HTML report gives you a visual summary of your test results. This is the same format you would use in a CI/CD pipeline to track test health over time.

  • Open report.html in your browser by double-clicking it in File Explorer, or by running:
start report.html

The report shows which flows passed, which failed, and provides a summary of the entire suite run.

Why HTML reports?

HTML reports are human-readable and easy to share with your team. Maestro also supports --format junit which produces XML for CI/CD tools like Jenkins. For local development, HTML gives you a quick visual check of your suite's health.

Secret mission

Automate the Login Flow

Your test suite currently assumes the app is already logged in. What happens when a user opens the app for the first time? In this secret mission, you will automate the full login flow using environment variables to keep credentials out of your YAML files.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing costs. Decide whether to keep your test files for future use or remove everything from your machine.

Resources you used:

  • YAML test flow files in your actxa-tests folder (local, no cost).
  • HTML report file in your actxa-tests folder (local, no cost).
  • Maestro CLI installed at C:\maestro (local, no cost).
  • USB Debugging enabled on your Samsung S9+ (phone setting, no cost).

Keep everything running

No action needed. Choose this if you plan to keep writing test flows for the Actxa app or other apps on your phone.

  • Your actxa-tests folder stays on your Desktop with all your YAML flows and the HTML report.
  • Maestro CLI stays installed at C:\maestro and available in your terminal.
  • USB Debugging remains enabled on your phone. This does not affect battery life or performance.

Pause - I'll come back to this later

Disable USB Debugging on your phone to prevent accidental ADB connections. Your local files and Maestro installation stay in place for when you return.

  • On your Samsung S9+, go to Settings > Developer options and toggle off USB debugging.
  • Disconnect your USB cable.
  • Your actxa-tests folder and Maestro installation remain untouched on your PC.

Delete - I don't want to use this again

Remove all project files and the Maestro CLI installation from your machine.

  • Delete your project folder by running this command in Windows Terminal:
Remove-Item -Recurse -Force ~\Desktop\actxa-tests
  • Delete the Maestro CLI installation by running:
Remove-Item -Recurse -Force C:\maestro
  • Remove C:\maestro\bin from your system PATH. Open Settings > System > About > Advanced system settings > Environment Variables. Select Path under User variables, click Edit, find the C:\maestro\bin entry, and click Delete.
  • On your Samsung S9+, go to Settings > Developer options and toggle off USB debugging.
  • Disconnect your USB cable from your PC.

macOS/Linux alternative

If you followed the macOS/Linux install path, remove Maestro by running:

rm -rf ~/.maestro
rm -rf ~/Desktop/actxa-tests

That's a Wrap!

That's a Wrap!

Nice work! You have built a complete E2E test automation suite for the Actxa app running on your real Samsung S9+ phone.

You've learned how to:

  • Installed Maestro CLI on Windows and connected a real Android device via USB for physical device test automation.
  • Written YAML-based test flows using core commands like launchApp, tapOn, assertVisible, scrollUntilVisible, and runFlow to automate real user journeys through the Actxa app.
  • Organized tests into modular subflows and generated an HTML test report showing pass/fail results for your full test suite.
  • Secret Mission: Automated the login flow using environment variables for secure credential handling.

Ready to quiz yourself?