Automate more, faster, with Test Modeller – TMX Integration

The QA community has been speaking about functional test automation for a long time now, but automated test execution rates remain too low. A major reason is that test automation for many organisations still means complex scripting and time-consuming test maintenance – all at a time when skilled engineers are in short supply.

5 Reasons Curiosity are excited to have integrated Test Modeller with Critical Logic’s TMX

This is one reason why Curiosity created Test Modeller, a Model-Based Test Automation tool that generates automated tests and data directly from easy-to-build flowcharts. We have since worked with Critical Logic to integrate Test Modeller with TMX, another tool that simplifies the creation of rigorous automated tests.

TMX creates a central repository of automation objects and actions from existing frameworks, enabling a simple, dropdown approach to creating comprehensive automated tests. The tests are then executed using new or existing tools, including QTP, IBM Rational Functional Tester, Ranorex, TestPartner, Microsoft Coded UI, and EggPlant. TMX also supports open source tools like AutoIT and Selenium, while tests can further be executed in almost any custom framework.

It is now possible to import objects and actions from the TMX repository to flowcharts in Test Modeller, quickly using them to generate and maintain a rigorous set of automated tests. TMX then compiles the automated test scripts, ready to execute them across a wide range of commercial and open source frameworks:

1.     Everyone can automate using a visual, low code approach

One of the greatest challenges facing organizations striving to automate more is the new skillset required. Automating tests often requires scripting experience and developer skills, in a time when automation engineers are in short supply.

Often, organization’s achieve limited degrees of automation, with isolated “islands of quality” created by overburdened engineering teams. Those without developer backgrounds meanwhile are faced with the time and frustration of having to learn to code from scratch, while still keeping up with testing cycles.

Test Modeller makes automated testing of complex applications simple, generating comprehensive automated tests from easy-to-use flowcharts:

 

Automated tests are generated from easy-to-use flowcharts, created using a visual,
drag-and-drop approach.

The visual models are created rapidly from existing requirements, tests, and recorded activity. Automation objects and actions are then specified in the nodes of the model, using drop-down menus. No substantial coding experience is needed in this low code approach, defining automated tests using a fill-in-the-blanks methodology:

A low code, fill-in-the-blanks approach: simply order a series of objects and actions to
form an automated test, specifying from a range of possible parameters.

You can then generate optimized, automated tests directly from the model, allowing everyone to automate their tests regardless of their coding background.

2.    A simple approach, but not simple tests – you can create tests that match your system precisely

In spite of the simplicity of this low code approach, automated tests can be created for complex systems. Automation engineers can create custom objects and actions, or can import them to Test Modeller from existing frameworks via the TMX repository. This enables the flexibility required to test a complex system precisely, without compromising the simplicity of test creation.

Actions and objects imported from TMX to Test Modeller are made available in the drop-down menus used to create automated tests. This enables the creation of custom tests that map precisely to complex systems, but do not require developer skills to produce.

A small core of automation engineers can create custom actions, feeding the re-usable assets to testers and business analysts to quickly build tests using the fill-in-the-blanks approach.

A small core of automation engineers maintains a framework, exposing re-usable custom
objects and actions to Test Modeller. Everyone can automate tests, even with
minimal coding knowledge.

Subflows enable even more re-usability and allow non-technical users to chain common components of a system together into end-to-end tests. Once automation logic and data has been defined for a component once, that model can be dragged-and-dropped from a shared repository to a master flow:

A model has been created for testing the validation of a log-in screen. It can quickly be
dragged-and-dropped to the flowchart in future, along with all the automation logic and
data associated with that model.

Subflows contain all the automation logic and data associated with the model. Testing complex systems therefore becomes quicker and simpler the more you test, with a growing library of re-usable models, as well as re-usable automation actions and objects.

3.    Rigorous automated testing without the bottlenecks

This Model-Based approach to generating automated tests further drives up the speed and quality of testing. Automatic test generation removes the bottleneck of repetitious scripting. It further uses powerful coverage algorithms to generate the tests, creating the smallest set of tests needed to “cover” the model.

These tests are the equivalent to paths through a model, that can be identified automatically, just as a GPS identifies routes through a city map. Using tried-and-tested optimization techniques, you can test more in fewer tests, shortening test cycles without compromising testing rigour.

Test cases are equivalent to paths through the model, that can be identified rapidly
using automated optimization algorithms.

4.    Minimize maintenance – test an application within the same iteration as a change has been made to it

A significant challenge for successful test automation is maintenance: manually created tests and data must be laboriously checked and updated every time the system changes. Often, the time saved during test execution is outweighed by the time spent maintaining tests in future, a bottleneck that forces testing to roll over to the next iteration as large parts of the system are left untested.

The rigorous tests and data created in Test Modeller are tied directly to the central models, and update with them. This avoids the delays of manual maintenance, as all tests and data are maintained from central models. Simply edit the model, re-synchronise your tests with TMX, and your regression pack is up-to-date. Full version control meanwhile allows you to roll back to previous versions of your model, testing a given version of the system with the relevant tests.

5.    Single Pane of Glass Automation avoids Vendor Lock

The optimised tests pushed back to TMX can be executed across a comprehensive range of frameworks, exporting compiled scripts to proprietary or open source frameworks, or to Continuous Delivery tools. This avoids vendor lock and allows you to continually test in the frameworks best suited to your system and skills. The “single pane of glass” approach of using central models to produce tests for a range of frameworks further reduces the need for costly and copious licenses, generating tests for a range of frameworks from one tool.

“Single Pane of Glass” automation creates tests for a range of frameworks, all
maintained from central models.

Rigorous automated testing within an iteration

These are just some of the reasons why Curiosity are excited to have integrated Test Modeller with TMX. The joint test automation solution makes it possible to test complex applications rigorously, within the same iteration as any changes have been made to the system under test. Sound too good to be true? Speak with a Curiosity expert to get started!

[Image: Pixabay]