Details
How self-healing automation and targeted AI assistance can help QA teams build reliable UI tests while remaining in control.
Faster release cycles are increasing the pressure on QA teams to automate more testing without creating a growing maintenance burden. In this demonstration, SmartBear Solutions Engineer Vinnie White shows how TestComplete converts recorded manual workflows into automated UI tests, supports reusable no-code test steps, and uses self-healing to keep tests running when application objects or selectors change.
The session also demonstrates a focused use of generative AI: extracting the changing numeric portion of an order ID, storing it as a variable, and reusing it in another test. Together, these capabilities show how teams can combine resilient UI automation with targeted AI assistance while keeping testers responsible for reviewing and approving changes.
TestComplete allows a tester to record interactions with an application and convert those actions into an automated keyword test.
This gives manual testers a practical entry point into automation without requiring them to write an entire test framework or script every interaction from scratch.
Recorded workflows appear as readable test steps that testers can organize and enhance. More advanced operations can be added through drag-and-drop controls, and frequently used workflows can be turned into reusable components.
This approach helps teams introduce automation without excluding testers who have limited programming experience.
UI tests frequently depend on selectors and object properties that can change when developers or AI agents modify an application.
In the demonstration, the mapped XPath for a login button was intentionally broken. TestComplete identified a similar object at runtime, continued the test, and reported the substitution as a warning instead of stopping the entire regression run.
Self-healing does not silently rewrite the permanent object mapping. TestComplete records the substitution and allows the tester to review and accept the replacement selectors.
This keeps a human in the loop while preventing an expected UI change from unnecessarily interrupting an overnight regression suite.
End-to-end workflows often produce changing values, such as an order ID generated during a purchase.
The demonstration shows how the numeric part of a generated order message can be extracted, saved as a variable, and passed into a separate order-checking workflow. This allows the test to function across repeated runs instead of relying on a hard-coded ID.
Rather than asking AI to generate and control an entire test suite, the demonstration uses it to solve a specific problem: creating logic to isolate the changing order number from a longer text string.
Giving the AI access to relevant project and page context helped produce guidance tailored to the TestComplete workflow.
The speaker describes adding project-specific context and guidance so the AI can better understand the TestComplete workspace and the page being tested.
This reduces ambiguity and makes the generated suggestion more applicable than a generic response based only on a short prompt.
The session positions AI and self-healing as support for the tester rather than replacements for QA judgment.
TestComplete can identify likely object matches and AI can suggest implementation logic, but the tester continues to review warnings, approve mapping changes, and control how automation is incorporated into the regression process.
Recording accelerates the move from manual to automated testing
Practical implication: Begin with stable, repeatable manual workflows and record them as keyword tests before adding more advanced logic.
Object identification should tolerate application changes
Practical implication: Use self-healing for selector changes, but require testers to review and approve proposed object-map updates.
Passing with a warning can preserve useful test results
Practical implication: Distinguish between genuine functional failures and maintenance issues caused by changed selectors so one altered object does not invalidate an entire regression run.
Dynamic values should be captured at runtime
Practical implication: Extract generated identifiers and store them as variables instead of hard-coding values that will change during every execution.
AI works best on clearly scoped testing problems
Practical implication: Use AI for focused tasks such as generating a parsing function, then review the output before adding it to a production test suite.
Relevant context improves AI-generated assistance
Practical implication: Supply the AI with the page structure, project conventions, expected output, and tool-specific constraints needed to generate an appropriate solution.
QA remains accountable for test reliability
Practical implication: Treat AI and self-healing recommendations as proposals that testers validate rather than automatic changes that bypass review.
Q: How does TestComplete turn a manual workflow into an automated test?
A: A tester starts a recording and performs the workflow in the application. TestComplete captures those interactions and converts them into test steps that can be replayed, organized, and enhanced.
Q: Do testers need to write code to begin using TestComplete?
A: Not necessarily. The demonstration uses recording and keyword testing to create automation without requiring scripting at the beginning. Testers can also add operations through drag-and-drop controls.
Q: What is self-healing in TestComplete?
A: Self-healing allows TestComplete to identify a similar runtime object when the selector or mapped properties expected by a test no longer match the application.
Q: Does a self-healed test automatically change the permanent object mapping?
A: The demonstrated workflow reports the substitution as a warning and allows the tester to review and accept the proposed update. This keeps the tester involved in changing the permanent mapping.
Q: Why did the test pass when the login button’s XPath was broken?
A: TestComplete identified a runtime object sufficiently similar to the mapped login button. It used the replacement object to continue the test and recorded a warning so the tester could inspect the difference afterward.
Q: How can self-healing help regression testing?
A: It can prevent a minor selector change from stopping an entire nightly regression run. The test can continue when an appropriate replacement object is found while still notifying the tester that maintenance may be required.
Q: How was AI used in the demonstrated test?
A: AI was used to help create logic that extracted the numeric order ID from a longer confirmation message. The value was saved as a variable and reused in a separate workflow that searched for the newly created order.
Q: Why did the order ID need to be stored dynamically?
A: Every newly created order had a different ID. A fixed value would work for only one execution, while a runtime variable allowed the end-to-end test to work repeatedly.
Q: Does the session recommend handing the entire testing process to AI?
A: No. The speaker recommends keeping the tester in control and using AI selectively where it can accelerate a defined task or reduce repetitive work.
Vincent Whyte: We often find that AI draws attention to the need to automate more of the quality process and prepare for faster release cycles. That is what this session is about.
How do we prepare for this shift when testing desktop, web-based, and mobile applications? How can QA teams prepare for quicker feature releases? How can we automate more effectively and consistently?
TestComplete helps testers create automation quickly. You can set up and run automated tests within minutes.
It provides resilient object recognition, flexible approaches to automation, and self-healing capabilities.
If an application changes, selectors and object properties may also change. That becomes an even bigger concern when AI is contributing to development changes.
QA may not always know what changed until a new build or automated test is run. TestComplete can adapt when an object changes because of refactoring or another application update.
The next goal is to establish a repeatable regression suite. TestComplete supports consistent automated execution, whether tests run nightly or through another scheduled process.
One of the main benefits of TestComplete is that it allows people with different skill levels to begin using automation.
If I’m a manual tester who needs to automate a workflow quickly, I can create a new TestComplete test by selecting “New Test.” I’ll call this one “Webinar Test.”
From here, I can record the workflow. The process itself is straightforward: I click “Record,” perform the actions as a manual tester, and TestComplete generates the automation.
I can also enhance the workflow by dragging and dropping additional operations. If I need something more advanced, I can add it to the test and organize reusable workflows from the project panel.
For this example, I’m recording a short desktop workflow. We’ll also discuss web testing and maintenance, but the basic process is the same.
I record my actions, launch the application under test, and create a keyword test. No scripting is required at this stage. I only need to perform the workflow, and TestComplete captures the actions within the recording.
Maintenance and refactoring are also important for web and desktop testing.
In this example, I intentionally broke the mapping for the login button. If I open the name mapping, you can see that I added an incorrect XPath.
When I run the test, TestComplete attempts to sign in, but it cannot initially identify the login button through the expected mapping.
The situation is the same whether a developer or an AI agent changed the control. The QA team may not know about the change before an overnight build or regression test starts.
Instead of creating an unnecessary failure, TestComplete attempts to self-heal.
It assesses the object and determines that another object in the application is similar to what the test expects. Rather than failing, the test uses the similar object and continues.
You can see that the test self-healed. It generates a warning indicating that the test passed but that an object substitution occurred.
When I open the detailed log, I can review the expressions and XPaths TestComplete found at runtime. The permanent name mapping remains unchanged until I review the proposed replacement.
From the log, I can accept the new mapping.
The key point is that the test did not fail. If I’m running an overnight regression suite, an unnecessary failure caused by a changed selector has not stopped the test.
Genuine failures still occur, of course. But this is not a functional failure. It is a change in the application’s object properties that could otherwise cause the regression suite to fail.
TestComplete passes the test with a warning because its intelligent object-recognition capabilities determined that the runtime object was similar to the mapped one.
It uses the selectors found at runtime, continues the test, and then informs the tester that the original object was replaced with a similar one.
The tester remains in the loop and can decide whether to accept the change. When the tester accepts it, TestComplete updates the mapping file with the correct selectors.
This is a good example of combining domain expertise with intelligent assistance.
The tester remains behind the wheel, while TestComplete detects changes introduced by a developer or an AI agent in the application under test.
The next example uses a web-based workflow. I have two tests called “Check Order” and “Sample Run.”
The Sample Run test moves through an online purchasing workflow. It selects an item, completes the purchase, and creates an order.
Once the order is created, I want to capture the order ID.
The confirmation message says something like, “The order ID is 4758,” but I only need the number 4758. I don’t need the rest of the message.
I asked Claude how to extract that value, and I’ll show you the resulting workflow.
It suggested creating a script that retrieves the order number and saves it as a variable for use in the Check Order workflow.
I then created another step in the end-to-end workflow. It runs a different test, navigates to the orders section, and places the order number that was just created into the search field.
Every order receives a different number, so the value needs to be dynamic. The workflow needs to capture and reuse the correct number every time the test runs.
I connected Claude with the relevant TestComplete project context and created project-specific guidance.
That additional context provided guardrails for the feedback loop and helped the AI understand what I was trying to accomplish.
For example, I gave it information about the page and explained that I needed only the numeric value.
The project and workspace context supplied additional guardrails and made the generated assistance more relevant to TestComplete. It also helped reduce the risk of receiving a generic or unsuitable response.
Here we have a successful test.
This is a useful way to begin incorporating AI into an existing testing toolset. The AI was assigned a focused problem, given the relevant context, and used to support a tester-controlled workflow.
TestComplete includes additional intelligent capabilities, but I’ve covered only a few of them in this session.
Keeping the tester behind the wheel remains important. The most effective approach is to use AI where it is appropriate while retaining human control over the quality process.
That balance helps teams manage risk while using automation and AI to reach the desired outcome more efficiently.
Presenters:
Vincent Whyte
Senior Solutions Engineer, SmartBear
Join Now for More Content & Events
For event and sponsorship inquiries, please email: [email protected]
