Mobile App Test Automation with ContextQA
A walkthrough of the ContextQA mobile demo, where you upload an app APK, connect to an emulator, record taps and inputs on the running app, then run the test with no code.
What you will learn
- How to start a mobile test from the ContextQA mobile inspector
- How to upload your app APK and connect it to an emulator
- How to record actions like tapping the home icon, dismissing a prompt, and selecting buttons
- How to inspect a selected element and read its properties before adding a step
- How to label steps with your own terminology, such as tap or double click
- How to run the recorded mobile test and view the execution results
Session outline
- Open the mobile inspector and check the device profile
- Upload your app APK and connect to the emulator
- Wait for the app to load on the connected device
- Record the first action by tapping the home icon
- Add steps for prompts such as agree, continue, and dismiss
- Inspect a selected element and review its properties
- Label each step and save the test case
- Run the test and review the execution details
This guide walks through a live ContextQA demo of mobile app test automation. The goal is simple. You take a mobile app, record a few real actions on it, then run those actions back as an automated test. There is no code to write. You tap through the app the way a user would, and ContextQA turns each tap into a step.
The session focuses on the basics, uploading an app APK, connecting it to an emulator, recording a short flow, and running the test. If you have built a test on the web with ContextQA, this will feel familiar. The workflow is the same, and the main difference is that you are working with mobile elements instead of web elements.
What you need before you start
You need your app APK file and access to the ContextQA mobile inspector. In the demo the APK was stored locally and connected to a local emulator. The team also mentioned that a cloud based emulator was in progress, so over time you would not need to set up a device locally.
Recording your first mobile test, step by step
The demo built a short test case by tapping through the opening screens of the app. Here is the flow it followed.
- Open the mobile inspector and check the device profile. This shows the device the test will run on. In the demo it was connected to a local emulator.
- Upload your app APK and connect it. Once you connect, ContextQA loads the app onto the device.
- Wait for the app to load. Give it a moment to come up before you start tapping.
- Record the first action. The demo tapped the home icon, selected the action, and named it as a home screen step.
- Add the next steps as prompts appear. The flow added an agree and continue step, then a continue button, then a dismiss step for a popup.
- Inspect a selected element when you need to. You can review the element and its properties in the selected element section before you add the step.
- Label each step in your own words, then save the test case.
Each action you take on the app becomes a step in the test. You tap, ContextQA captures the action, and the step is added to your list. You can keep going until you have covered the part of the app you want to check.
Inspecting elements and labeling steps
When you select an element, ContextQA shows its properties so you can confirm what you are working with. In the demo the team checked a text field and looked for a hint property. Recognition of a field can depend on properties like this being present. An older app version did not surface some of those properties, which affected whether the field was picked up. Checking the selected element first helps you understand what is available.
Step labels are flexible. You can use your own terminology, such as tap or double click. The labels do not need to match an exact pattern, so you can name steps in a way that reads clearly for your team. This keeps the test easy to follow later.
You do not need to follow this pattern. You can have your own terminology, like tap or double click or whatever works for you.
Running the test and viewing results
Once the test case is saved, you run it and ContextQA starts executing each step on the connected device. Execution runs the recorded flow for you, step by step. When the run finishes, the execution details appear so you can review what happened.
Mobile execution can take a little longer than a fast local web run while the device works through the flow. Give it a few minutes to complete, then read the results to see how each step performed.
When to use this
This approach fits teams that want to automate mobile app checks without writing test code. It is a good match when you want to cover core user flows, such as opening the app, getting past prompts, and reaching a key screen, and you want those checks to run again and again.
Because the recording flow mirrors the web flow in ContextQA, your team can move between web and mobile testing without learning a separate process. You record real actions, name them clearly, and run them on a connected device.
Next steps
Start small. Upload your APK, connect to the emulator, and record a short flow that opens your app and clears the first few prompts. Save it, run it, and review the execution details. Once that runs cleanly, extend the test with more steps to cover the screens that matter most to your users.
Key takeaways
- ContextQA records mobile actions visually, so you can build a test without writing code.
- You upload your app APK and connect it to an emulator, then record taps and inputs directly on the running app.
- Each recorded action becomes a labeled step that you can name in your own words.
- Mobile testing in ContextQA works in a similar way to web testing, with the difference being mobile elements.
- After you save and run the test, ContextQA executes the steps and reports the results.
Frequently asked questions
In ContextQA you open the mobile inspector, upload your app APK, and connect it to an emulator. You then tap through the app while ContextQA records each action as a step. When you save and run the test, it replays those steps for you, so no code is required.
Inside the mobile inspector you choose your app APK file and connect it. ContextQA loads the app onto the connected device so you can start recording. In the demo the APK was stored locally and connected to a local emulator.
The demo runs the app on a connected emulator while you record. At the time of the session the emulator was local, and the team noted that a cloud based emulator was in progress so you would not need to set anything up locally.
As you tap items such as the home icon, an agree button, or a dismiss prompt, ContextQA captures each action and adds it as a step to your test case. You can review the selected element and its properties, then save the step.
Yes. You can use your own terminology for each step, such as tap or double click. The labels are flexible and do not need to match an exact pattern, which keeps the test readable for your team.
Once you have recorded and saved your steps, you run the test case and ContextQA begins executing each step on the connected device. When the run finishes, the execution details appear so you can review the results.
Recognition of a text field can depend on element properties, such as a hint property being present. In the demo an older app version did not surface some properties, which affected whether a field was picked up. Checking the selected element properties helps you confirm what is available.
The workflow is similar. You record actions and add steps the same way, and the main difference is that the elements are mobile elements rather than web elements. If you can build a web test in ContextQA, the mobile flow will feel familiar.
Ready to automate your testing?
Put this tutorial into practice. Create your first test in plain English and let ContextQA handle the rest.