Model-Based Testing: The Advanced Level of Test Automation

  November 19, 2019

To capture test specifications, understand the criteria and ensure the best coverage, you need to change the approach to gathering, analyzing and engineering product requirements. Enter model-based testing (MBT), a strategy that helps leverage test automation more thoroughly, especially when it comes to requirements adjustment.

Test automation is inevitable for faster and more efficient mobile app testing. Provided that you care about streamlining the workflow and taking advantage of the latest development methodologies, of course. But many teams find it challenging to create and update test cases in an environment of ever-changing requirements.

In the Capgemini 2019 Continuous Testing Report, 40% of respondents said their current approach to requirements gathering and analysis is not automated. This means that, in most cases, testing is not incorporated into the initial phase of setting the requirements. At this stage, a lot of time and effort – respondents reported about 40-70% – is spent on clarifying specifications.

In the DevOps environment, you can’t afford to spend time so inefficiently. But the model-based approach offers maximum test coverage with the smallest number of test cases, as well as maintaining them when the requirements change.

What Is Model-Based Testing and How Does It Work?

Model-based testing (MBT) means using models for describing test environments and test strategies, generating test cases, test execution and test design quality. MBT ensures the possibility to trace the correspondence between requirements, models, code and test cases used for the tested system.

These models are used to generate automatic test cases, and they represent how we expect the system to behave under test. The process looks like this:

  1. You create models to capture the behavior of the system that is tested.
  2. Using MBT tools like fMBT or Modbat, you interpret this behavior to develop manual testing scripts.
  3. The tool generates scripts for automated testing.

Model creation is a part of the software development life cycle, as opposed to the independent test script development. The entire team has to focus on building a testable product and models that outline a real-life user experience.

Model-based testing has to become an integral part of product design from the stage of requirements specification. Both developers and testers can focus on the models that are created to cover system requirements only and build a testable application from the start. As a result, the team can reduce test suite maintenance and generate more tests using different algorithms.

Model-based testing can be used in combination with popular testing tools and automation frameworks, helping the team create both manual and automated scripts and increase the coverage.

How to Start with Model-Based Testing?

It’s impossible to introduce model-based testing to the entire business processes at once. The capabilities of MBT should be implemented gradually. At the initial stage, the typical scenario presupposes manual creation of test designs, where requirement changes have a significant and often unpredictable impact on tests.

Implementing model-based testing starts with model creation. Models can be created by business analysts, developers or testers and can cover any level of requirements, from business logic to user story, and link them to each other.

Once the models are ready, you can automatically generate test cases. These tests will also be updated automatically once you introduce any changes to the model. The MBT tools will help you identify the updated tests, the new ones that have been created and tests that became obsolete due to the model changes.

Another capability of model-based testing is test optimization for the maximum coverage with the least number of tests. Manual calculation of the test coverage is significantly less efficient and less accurate than MBT options. In addition to the automated creation and updating of model-based tests, the MBT approach allows tracing the correlation between tests and requirements, i.e., maintain traceability.

The next level of MBT implementation is automating the entire process of test automation. Believe us: the tautology is justified. First, you need to connect models and test automation engines to generate test scripts. This will reduce the time it takes to create scripts for automated tests and will make maintaining these scripts easier under model changes.

Once you’re able to generate automated tests from models, you can integrate these tests into your CI processes and tools. By integrating with test data management, service virtualization, performance testing and more, MBT can achieve its full potential.

With the help of data analytics and machine learning, MBT can be further optimized to a dynamic adaptive framework that will be able to predict testing routes, offer quality risk evaluation, forecast defects and so on.

The Challenges of Model-Based Testing Implementation

While model-based testing is cost-efficient and profitable for business in the long run, introducing this approach to the settled company processes may be a challenge.

Before the adoption of MBT, the mindset and the business culture have to shift to modeling. This means that the organization should reconsider its approach to development and testing entirely. Models have to become a part of the development workflow, which brings changes to the infrastructure.

The choice of an MBT tool may be an issue, as well. It has to be scalable, provide solid test coverage and enable building complex models. Searching and implementing a tool like this will take some time, but once you find the tool that’s right for you, you’ll get cost-efficient testing with less maintenance.

But problem number one is the MBT learning curve.

Software developers need to know how to develop a testable product, and knowing the coding paradigms has to complement the testing skills. Testers, in their turn, need to embrace the new model-based testing approach instead of the traditional testing methods. As soon as all of this is settled, the approach takes away some of the tasks business analysts, developers and testers struggle to optimize.


MBT and behavior-driven development will be the leading trends in testing for the next several years, according to Capgemini. These trends will ensure better integration of business analyst teams with the development and QA departments, improving the reaction to changing requirements and the possibility to provide continuous delivery.

Powered by AI testing and machine learning, model-based testing will bring tremendous time and money savings to businesses by enabling the highest degree of test automation. After all, model-based testing is a natural advancement of test automation.