AI Test Automation Demo: A Hands On Walkthrough with ContextQA

This tutorial follows a live ContextQA product demo from start to finish. ContextQA is a software test automation and developer productivity platform, and the walkthrough shows how a tester moves from a blank project to recorded, automated tests that run across browsers and devices.

You will see the real flow the presenter used: signing in, reading the dashboard, recording a test with the Chrome extension, editing steps without code, and reviewing results. Follow along in your own account to get the most from it.

Getting started and logging in

Everything begins on the ContextQA website. From there you can reach the product documentation, the Chrome extension that powers record and play and the low-code no-code features, and the free trial sign up.

1. Open the ContextQA website and start a free trial sign up.
2. Once your account is created, you are taken to the account page where you can log in.
3. Install the Chrome extension from the link on the site, since record and play and the no-code features rely on it.
4. Log in to the portal to land on your dashboard.

Reading the dashboard

After you log in, the dashboard gives you a high level view of your testing. On a brand new org it looks fairly empty, but over time it fills in with real history and trends.

The dashboard summarizes your last run history and shows trends for week, month, and quarter. It reports the total number of test cases and how many are passing, failing, or not yet executed, with breakdowns by feature and by label. It also surfaces details from the most recent execution, so you can see what happened in your last run.

For example, after a cross browser run you can open the result and see the auto heal status, the full execution trace, a video of the run, and the visual regression comparison. This is the same detail you will return to every time you debug a failure.

Creating test cases the agile way

The demo opens with a common situation. A tester joins a new project during sprint planning, there is no automation in place yet, and development is happening in parallel. ContextQA is built to let you start work immediately rather than wait for the app to be ready.

While requirements are still being discussed, you can create a new test case as a placeholder, much like you would in a tracking tool. You give it a title, set priority to low, medium, or high, add a status, and apply labels to mark it as a functional test or group it with related work.

1. Create a new test case for the feature you are about to cover, for example a home screen.
2. Add the steps you would normally perform, such as going to a website and entering values, even if the screen is not ready yet.
3. Add assertions as you go, for example verify the URL or verify the title.
4. While the app is still being built, mark each step pass or fail manually so you can log your testing effort.
5. When the feature is ready, click run, then update any values that changed.

The point of this flow is that the manual steps you write become the automation. When the build is ready you usually only need to update a value or two, so there is no rework when the team finishes.

Recording a test with the Chrome extension

When you already have a working application, you do not have to type every step. The record and play feature captures your actions for you through the Chrome extension.

1. Open the test case and start recording with the extension.
2. Perform the scenario in the browser, for example log in, click into an admin area, and log out.
3. Watch each action appear on the right side as a step written in plain English.
4. If you are unsure what a step points to, use the extension to highlight that element on the page.
5. Add any assertions you need, such as verify the title, verify the URL, or check tags and other details.
6. Stop recording, and the captured steps are saved to your test case.

Because the steps are recorded and described in plain English, you do not need to remember which template to pick or write any code. This becomes especially helpful for longer user journeys.

Running tests and reviewing results

Once a test is recorded or written, go back to the portal and click run. ContextQA executes the steps in the cloud and collects evidence as it goes.

Every execution captures screenshots of each step, a video of the run, the full trace, and the network and console logs. The first run also stores screenshots that feed visual regression, where ContextQA compares a golden copy against the current copy and flags differences on the page. Several parts of this use AI, including the visual regression and the root cause analysis.

When a step fails, the result tells you what failed and why. In the demo, a step timed out because an element could not be found, and the report said exactly that. From there you can open the run, navigate step by step, and review the visual differences, network activity, and any errors.

Finding the issue and fixing it is fairly easy with ContextQA. If something changed, it is a fill in the blanks change, so you do not need to know programming.

Auto heal is built in. Most of the time ContextQA finds an element on its own because it has many ways to locate it, so it does not depend on a single locator. When auto heal cannot find an element, you always have the option to re-record that step, which is how the presenter recovered a failed step during the demo.

Editing, parameterizing, and reusing steps

Editing a test is a no-code experience. You change values in place, and ContextQA keeps your tests robust by letting you parameterize the parts that change.

You can store elements in a shared repository so you do not hunt for selectors again. Using the extension, right click an element on any page, choose the ContextQA find locator option, and save it with a name like username or login. After that you can reference the same element by its label across steps and tests, and if it changes you update it once and the change applies everywhere.

For data, you have several options. You can parameterize values like username and password and pull them from environment variables, so the same test runs against your local environment or someone else's without rewriting it. You can also create data profiles with multiple sets of usernames and passwords and run the same test against each set, which is data driven testing.

Common steps can be turned into a step group, which is a set of reusable steps such as a login flow. A step group behaves like a test case, so it supports parameters and environment variables, and you reuse it wherever you need it instead of repeating yourself. The demo also showed API testing, where you send a request, capture the response, and assert on a field, either on its own or inside an end-to-end test.

Test suites, test plans, and cross browser testing

To run more than one test together, you group test cases into a test suite. To control how they run, you create a test plan.

1. Create a test suite and add the test cases you want to group, for example a login test and another scenario.
2. Create a test plan and add the test suite to it.
3. Add the browsers you want, such as Chrome, Firefox, and Edge, and choose devices.
4. Select the environment the plan should run against.
5. Click run, and ContextQA executes the suite across every configuration.

In the demo, two test cases ran across three browsers, which produced six results. Each result includes the video and the details of what happened, so when a test passed in one browser and failed in another, the report showed which selector could not be found. You can also schedule plans for nightly regression or smoke runs, and trigger the same plan from CI tools or through a webhook and API endpoint.

Next steps

Start by signing up, installing the Chrome extension, and recording a short login flow so you can see record and play, plain English steps, and a full result with video and trace. Then add a couple of assertions, parameterize the username and password, and turn the login into a reusable step group.

When you are comfortable, group your tests into a suite, build a test plan across Chrome, Firefox, and Edge, and review the cross browser results. From there you can explore data profiles, API testing, mobile testing, and the Jira integration to map your tests back to requirements.