Quick run through QF-Test

The most important features of QF-Test summarized.

• Introduction: Supported technologies
• Tree structure, variables, capture & replay
• Documentation: Tutorial, manual, (starter)videos
• Test execution and reports, Connection to build tools: Jenkins
• Scripting: Jython, Groovy, JavaScript
• Component recognition
• Further features
• Help from QFS: blog, training and support

Transcript

Welcome! In the next few minutes, we’ll show you how QF-Test helps teams build stable, maintainable UI test automation across web, desktop, and mobile applications.

QF-Test supports a wide range of technologies – from Java desktop UIs and modern web apps to APIs, mobile apps, PDFs, and hybrid applications.

Tests in QF-Test are displayed in a user-friendly graphical tree view. This tree contains action nodes such as mouse clicks and so-called check nodes that verify properties of your application’s user interface.

Control structures like loops or if/else decisions are also supported by this tree. Setting and using variables is likewise straightforward using the QF-Test interface.

For better modularization – that is, for reusing previously created test steps – QF-Test provides test steps, test cases, test sets, and so-called procedures. All of these can be created and managed directly in the tree view.

Test Recording

The easiest way to create tests in QF-Test is via capture & replay. You start a test recording using the record button in QF-Test and then perform the desired steps in your application.

At the heart of QF-Test is a graphical, tree-based view of your tests that makes complex test logic transparent and maintainable – even for large test suites. After stopping the recording, the executed steps appear in the QF-Test tree view as individual nodes. You can then reorder and edit them, for example using drag and drop.

You can find detailed information about the nodes in the graphical tree and about test creation in the extensive QF-Test documentation.

The tutorial includes a quick-start guide that shows you how to set up your application with its UI technology in QF-Test.

QF-Test also comes with an extremely comprehensive and user-friendly manual that describes all features of QF-Test and includes a powerful search function and navigation aids.

And there’s also the QF-Test blog, where new tips and tricks for using QF-Test are published regularly.

In addition to this wealth of written information, you’ll find overview videos and QF-Test basics videos on the QF-Test website under “Videos.” These guide you step by step through testing your application with QF-Test, creating test cases, evaluating test results, and much more.

Test Execution and Evaluation

Once you have recorded your first test cases with QF-Test, you can execute them either directly from within QF-Test using the play button or via the command line using the so-called batch mode.

At the end of each test run, you receive a detailed QF-Test log showing all executed steps.

In case of errors, the log contains the error message along with detailed screenshots.

QF-Test also generates summary reports for you in either HTML or JUnit XML format, which makes it easy to integrate QF-Test into build tools such as Jenkins or TeamCity.

Here you can see an example of a QF-Test HTML report.

For execution via Jenkins, QF-Test provides its own Jenkins plugin, which you can install from the Jenkins plugin directory.

Videos covering test execution, test evaluation, and Jenkins integration are also available on our video page.

Scripting

In addition to the action nodes provided by QF-Test – such as mouse clicks, checks, text input, and text extraction – QF-Test also allows you to integrate your own code into test runs. This is done using so-called script nodes.

Scripts can be implemented in the scripting languages Jython (a Python derivative), Groovy (a Java derivative), or JavaScript.

There are two types of script nodes: SUT script nodes, which allow you to access your test application, and server script nodes, which let you implement and execute arbitrary code during a test run. The possibilities offered by these scripts are virtually unlimited and are, of course, described in the QF-Test manual in the “Scripting” chapter, as well as in several videos on our website.

Component Recognition

One of QF-Test’s key strengths is its reliable detection and re-detection of individual elements of a graphical user interface. This means your tests don’t break just because a button moves a few pixels or the layout changes.

QF-Test refers to these tracked elements as “components.” Components are recorded together with their corresponding actions when creating a test suite.

From a recorded action such as a mouse click, you can easily navigate to the associated recorded component via the context menu. There you’ll see that components are not identified solely by X-Y coordinates, but also by other properties – for example, in this case, by their label.

If available in the application under test, components can also be recognized using IDs or names defined by the developers. Assigning meaningful names to the most important components of your application results in very stable and robust test cases.

QF-Test’s component recognition algorithm can also be adapted and extended in many ways using so-called resolver scripts.

SmartID

For even more flexibility, AQF-Test allows you to dynamically address available components using so-called SmartIDs instead of previously recorded components. To do this, you select the recognition criteria that are most meaningful for your component and specify only those using the compact SmartID syntax.

For simple use cases, this allows you to avoid maintaining component nodes and even manual component recording altogether.

CustomWebResolver

Using a so-called CustomWebResolver, you can also make your web application and the UI components of the framework you are using easier to test with QF-Test.

Here, you define a kind of translation table between the properties of your UI component library and QF-Test’s component concept. Once this is done, QF-Test can record much more stable and intuitive tests and checks for your application’s UI elements.

For certain JavaScript component libraries such as Vaadin, Angular Material, ZK, and others, QF-Test already provides such integrations. If your application supports accessibility via the ARIA standard, these features can also be used out of the box with QF-Test.

Components in the Documentation

Details about component recognition and resolver concepts can of course be found in the QF-Test manual.

In particular, we recommend the “Components” chapter in the user manual, as well as the chapters “Scripting,” “Web,” and “APIs for Extensions,” which contain detailed descriptions of all resolver interfaces.

Naturally, there are also several videos on this topic available.

Additional Features

By now, we’ve explored many ways to create UI tests with QF-Test.

QF-Test offers many additional features for test design and for working efficiently with the tool itself:

Dependencies in QF-Test are a useful way to execute preconditions and postconditions for test cases efficiently and only when necessary.

Data drivers enable data-driven testing. This means you create a test case once in QF-Test, and QF-Test automatically repeats it once for each available dataset from an Excel file, SQL database, or other sources.

There is an integrated debugger that allows you to analyze test cases step by step. Skip nodes, repeat them, or even move the current execution point. QF-Test also lets you to inspect and modify the current variable values.

In the QF-Test context menu, you’ll find various small helpers – such as the “Convert Node” command and many others – that enable fast refactoring or simple static analysis of your test suites.

You can organize test suites into projects to represent complex project structures.

All of these features are, of course, documented in videos and the manual.

There you’ll also find tips and tricks, for example for “distributed test development” or instructions on how to perform load testing with QF-Test.

Conclusion

Whew – that was a lot of interesting features that QF-Test offers for efficient and robust test automation.

If you’re now interested in trying out QF-Test yourself and using it with your project, visit the QF-Test website at qftest.com, click on “Free Trial,” and get a free trial license today so you can take advantage of the many QF-Test features. This also gives you free access to our well-regarded support team.

So, if you’re looking for reliable, maintainable UI test automation backed by excellent documentation and support, give QF-Test a try.