Skip to the main content.

Curiosity Modeller

Design Complex Systems, Create Visual Models, Collaborate on Requirements, Eradicate Bugs and Deliver Quality! 

Product Overview Solutions
Success Stories Integrations
Book a Demo Release Notes
Free Trial Brochure
Pricing  

Enterprise Test Data

Stream Complete and Compliant Test Data On-Demand, Removing Bottlenecks and Boosting Coverage!

Explore Curiosity's Solutions

Our innovative solutions help you deliver quality software earlier, and at less cost!

robot-excited copy-1              AI Accelerated Quality              Scalable AI accelerated test creation for improved quality and faster software delivery.

palette copy-1                      Test Case Design                Generate the smallest set of test cases needed to test complex systems.

database-arrow-right copy-3          Data Subsetting & Cloning      Extract the smallest data sets needed for referential integrity and coverage.

cloud-cog copy                  API Test Automation              Make complex API testing simple, using a visual approach to generate rigorous API tests.

plus-box-multiple copy-1         Synthetic Data Generation             Generate complete and compliant synthetic data on-demand for every scenario.

file-find copy-1                                     Data Allocation                  Automatically find and make data for every possible test, testing continuously and in parallel.

sitemap copy-1                Requirements Modelling          Model complex systems and requirements as complete flowcharts in-sprint.

lock copy-1                                 Data Masking                            Identify and mask sensitive information across databases and files.

database-sync copy-2                   Legacy TDM Replacement        Move to a modern test data solution with cutting-edge capabilities.

Explore Curiosity's Resources

See how we empower customer success, watch our latest webinars, read our newest eBooks and more.

video-vintage copy                                      Webinars                                Register for upcoming events, and watch our latest on-demand webinars.

radio copy                                   Podcasts                                  Listen to the latest episode of the Why Didn't You Test That? Podcast and more.

notebook copy                                           eBooks                                Download our latest research papers and solutions briefs.

calendar copy                                       Events                                          Join the Curiosity team in person or virtually at our upcoming events and conferences.

book-open-page-variant copy                                          Blog                                        Discover software quality trends and thought leadership brought to you by the Curiosity team.

face-agent copy                               Help & Support                            Find a solution, request expert support and contact Curiosity. 

bookmark-check copy                            Success Stories                            Learn how our customers found success with Curiosity's Modeller and Enterprise Test Data.

file-document-multiple (1) copy                                 Documentation                            Get started with the Curiosity Platform, discover our learning portal and find solutions. 

connection copy                                  Integrations                              Explore Modeller's wide range of connections and integrations.

Better Software, Faster Delivery!

Curiosity are your partners for designing and building complex systems in short sprints!

account-supervisor copy                            Meet Our Team                          Meet our team of world leading experts in software quality and test data.

calendar-month copy                                         Our History                                Explore Curiosity's long history of creating market-defining solutions and success.

check-decagram copy                                       Our Mission                                Discover how we aim to revolutionize the quality and speed of software delivery.

handshake copy                            Our Partners                            Learn about our partners and how we can help you solve your software delivery challenges.

account-tie-woman copy                                        Careers                                    Join our growing team of industry veterans, experts, innovators and specialists. 

typewriter copy                             Press Releases                          Read the latest Curiosity news and company updates.

bookmark-check copy                            Success Stories                          Learn how our customers found success with Curiosity's Modeller and Enterprise Test Data.

book-open-page-variant copy                                                  Blog                                                Discover software quality trends and thought leadership brought to you by the Curiosity team.

phone-classic copy                                      Contact Us                                           Get in touch with a Curiosity expert or leave us a message.

7 min read

10 Common Concerns About Model-Based Testing

10 Common Concerns About Model-Based Testing

We rarely post ‘product’ articles here at Curiosity, preferring instead to draw on our team’s thought and expertise. This article is no different, though it does discuss certain features in Test Modeller.

However, the following article is intended primarily as a guide to common concerns regarding model-based testing, discussing the ways in which we’ve responded to them in Test Modeller. All the features discussed draw on Curiosity’s decades of collective experience in building model-based solutions. Each has been designed to remedy common challenges when implementing model-based test design, shortening it’s time to value while amplifying its benefits.

The features discussed in this article, I hope, will therefore give you some food for thought around the role of modelling in software delivery, while also highlighting some technologies that we think are pretty new and exciting.

The article then concludes by asking a big question: Is it time to leave the word ‘model’ behind, embracing language more befitting of today’s technologies? We’d love to hear from you on this question – please take a minute to vote in our poll, letting us know what you think!

1.    Accelerators for in-sprint modelling

Common Concern #1: “There’s no way we have the time or expertise needed to model our systems.”

This is one of the most common concerns with model-based testing, and it makes a large degree of sense: How can you build models that are detailed enough to generate tests for complex systems, and yet build them quickly enough to test in-sprint?

With this in mind, Curiosity have designed Test Modeller to be an open technology, equipped with accelerators that shorten modelling time using existing assets in your software development lifecycle. You can import BPMN diagrams, Gherkin specifications, manual test cases, and much more. You can also use a UI Scanner and dictionary of modelling rules to rapidly build models, further reducing time to value.

2.    Seamless test automation

Concern #2: “Generated tests will never match the flexibility or sophistication of scripting.

Often teams worry that generating tests will limit their flexibility, undermining their ability to test complex systems in detail. We’ve therefore built Test Modeller as an accelerator to scripted test automation. It works seamlessly with coded frameworks, synchronising code from homegrown, open source and commercial frameworks. Code templates further generate bespoke scripts into code repositories.

This approach combines the simplicity of “low code” automation with the granularity of scripting. It allows coders to focus on the tricky bits of automation and non-coders to generate accurate tests for complex systems, all without requiring fiddly configuration.

3.    Simple models for testing complex systems

Concern #3: “My systems are too complex for visual models. It will become too cumbersome or too fiddley to model their intricate logic, and we will spend more time than it’s worth creating and maintaining logic.”

To avoid this challenge, we’ve equipped Test Modeller with a wide range of techniques for reflecting complex logic in visual flowcharts, all without compromising the simplicity of the models. You can easily overlay rules and constraints onto the flows, while using subflows to model reusable components. These tools are all designed to be lightweight and easy to apply, generating industrial-strength tests without producing overly-fiddly models

4.    Highly expressive test design

Concern #4: “We don’t have time to test everything in-sprint. How can you target test generation to fit testing in-sprint, without introducing negative risk?”

We’ve built Test Modeller with highly expressive techniques for targeting test generation based on time and risk. You don’t need to test everything and can measure what you are testing. For instance, you can apply coverage algorithms to components or end-to-end models, generating the smallest set of tests needed to “cover” the modelled logic. Feature Tags further focus test design on certain logic. These can be used to target negative testing or align your test suite with the high risk areas of the application.

5.    Test Data Built-In

Concern #5: “Visual models are good for testing simple UIs, but the backbone of our application is its APIs and back-end. There’s no way we can model these easily.” 

For most organisations today, testing requires consistently linked-up data journeys, capable of traversing mazes of interrelated components. In fact, the distinction between test case and data has become blurred, as tests involve firing vastly complex data journeys through systems, measuring their impact on the way. If the data’s misaligned, tests will fail. If it’s lacking in variety, testing will not be of sufficient coverage.

This is why we’ve built Test Modeller to integrate model-based test design seamlessly with on-the-fly test data resolution. To do this, we integrated Test Modeller closely with our own Test Data Automation, which in turn integrates with homegrown and commercial test data routines.

This approach builds a library of re-usable data “Find and Makes” that resolve as tests are generated and run from Test Modeller. The re-usable data lookups are arranged at the model level. During test generation, Test Modeller then passes variables from one lookup to the next, creating consistently chained-up data journeys. These data journeys might traverse a series of linked up UI screens or could equally be a web of APIs and back-end systems.

In this approach, any missing variables are generated on-the-fly, providing the volumes and variety of unique combinations needed to rigorously test complex systems. Meanwhile, parallelised automation avoids data clashes and data provisioning bottlenecks.Automated test data allocation during model-based testing

Automated data “Find and Makes” resolve as tests are generated, producing consistent
data sets for tests.

6.    Built to scale

Concern #6: “Modelling will add a maintenance overhead. There’s no way we can update models every time something in our system changes and modelling simply will not scale for a system of our complexity.”

To test complex systems quickly, Test Modeller emphasises re-usability and traceability. Every model becomes a re-usable subprocess, making testing faster over time. Building models for new functionality or for integration and system testing then becomes as quick and simple as assembling visual blocks into master models.

If a change is made to one model, it ripples across every flowchart in which that model features. This makes in-sprint testing a reality, as making updates in central models replaces maintaining copious test cases and scripts. Meanwhile, it supports scalability: you don’t need to update logic in every place that it occurs, but can instead update one modelled subprocess.End-to-end test generation with model-based testing

Re-usable subflows simplify and accelerate end-to-end and integration testing.

7.    Re-usability across stakeholders and functions

Concern #7: “I’d prefer to be working in my automation framework or test management tool – I don’t want to also have to tend to models in addition to that.”

As well as tackling system complexity, this re-usability minimises duplicate effort. It enables cross-function teams to test and develop at speed, combating silos and the delays created by cross-team constraints. Teams can continue working in their preferred tools and formats, while making the product of their work available to others.

For instance, testers and designers without deep coding skills can re-use automation built by those with coding skills. This reduces the burden on automation engineers, who can focus on feeding new code into their frameworks. Similarly, cross-functional teams can re-use test data lookups from a central catalogue. This eliminates the delays created by siloed data provisioning, while again minimising duplicate effort and the burden on any one team.

8.    More than ‘just another test tool’

Concern #8: “Model-based testing is a bygone from the days of Waterfall projects with siloed testing. We’re a cross-functional team, delivering in short iterations – we can’t model out cause-and-effect logic for our system.”

Overall, we’ve built Test Modeller for modern software delivery best practices, supporting cross-functional collaboration and parallelisation. Its BPMN-style flowcharts are already familiar to business users and system designers, while testers and automation engineers can easily integrate test cases, automated tests and test data routines. The central flowcharts then become a collaboration piece, avoiding miscommunication and the rework it creates. Meanwhile feature teams work in parallel, developing code and designing automated tests from the same specifications.

9.    An open technology – no vendor lock!

Concern #9: “Any proprietary approach to generating tests will lock us in. We’ll be limited by the functions produced by the vendor and soon we will not be able to test our systems rigorously. Nor will we be able to adopt the tools we want, including best-of-breed open source technologies.”

The concern about vendor lock is a big one, and rightly so – it’s not only frustrating when we can’t use the tools we want, but it can also impair testing’s ability to adapt to new systems and approaches.

We’ve therefore designed Test Modeller to be a fully extensible, open technology. It comes equipped with a wide-range of out-of-the-box integrations, while API connectivity and Curiosity’s in-house integration engine quickly connect Test Modeller to new technologies. This allows software testers, developers and designers to work in the tools best for them, while still pooling skills and knowledge collaboratively in models. It further enables a “Single Pane of Glass” approach, generating assets into a wide range of integrated tools.

This extensibility avoids vendor lock and future proofs software delivery. Teams can seamlessly move to new technologies, integrating them into Test Modeller. Meanwhile, all generated assets become available in their preferred technologies, so that testing and development is never limited by any one tool.

10. In-Sprint Maintenance

Concern #10: “Modelling will be a time-consuming process that we can’t afford to introduce – we have enough things to do already!”

One significant benefit of the approach taken in Test Modeller has been indicated but is worth emphasising: Test Modeller can eliminate the maintenance of existing test scripts, data and test cases. All these assets are instead linked to central flowcharts, and update as the models change.

Instead of trying to align mountains of repetitive tests, testers can update a model in one place, re-generating rigorous test suites. This reactive automation helps to combat technical debt, making sure that testing occurs in the same sprint as system changes.

Modelling in this approach becomes an accelerator to testing, rather than an addition process. Teams can focus on developing and testing new logic, rapidly regenerating targeted regression suites in-sprint.

When is a model no longer a model?

In spite of all the changes, updates and new technology we’ve introduced, Curiosity face a recurring challenge when discussing Test Modeller. The term ‘model’ means a lot of different things to different people, frequently bringing negative associations.

For some people, the idea of ‘modelling’ will mean too much complexity and too much effort. For others, ‘models’ sound like an over-simplification, one that will prevent them testing complex systems in detail. For many people, ‘modelling’ suggests a huge upfront time investment, and subsequently an additional process to reckon with.

When Curiosity built Test Modeller, we were aware of these concerns and more, and crafted capabilities to respond to them. Our team brought decades of collective experience in model-based testing, building Test Modeller to a be a flexible and collaborative tool. We purposefully built it to be capable of testing complex systems rapidly, all while maximising re-usability and simplifying test design.

Yet, with all the updated technologies and techniques discussed in this article, the term ‘model’ has remained the same. When discussing Test Modeller as a ‘modelling’ tool, we often therefore find ourselves first discussing the many things that our approach is not, when we would rather be discussing what our proposed approach is.

With this in mind, we’re currently asking ourselves: “is it time to leave the word ‘model’ behind”? Has the technology moved on, whereas the word ‘model’ remains too closely tied to the limitations of past approaches? Does ‘model’ have too much baggage?

This is no easy decision, especially given that most of our team have been involved in the “model-based” space for several years or decades. First, we’d like to hear from you to get your thoughts.

Currently, we are discussing the ‘models’ of Test Modeller as ‘flows’: a human-readable, easy to manage asset that maps and tests complex system logic. What do you think? Should we ditch the language of ‘model’ and make the leap into the new world of flow-driven testing?

Take 2 minutes to to vote in our poll – we’d love to hear from you!

 
5 Reasons to Model During QA: “Shift Left” QA Uproots Design Defects

5 Reasons to Model During QA: “Shift Left” QA Uproots Design Defects

Model-Based Testing (MBT) itself is not new, but Model-Based Test Automation is experiencing a resurgence in adoption. Model-Based Testing is the...

Read More
5 Reasons to Model During QA, Part 3/5: Coverage Focuses QA

5 Reasons to Model During QA, Part 3/5: Coverage Focuses QA

Welcome to part 3/5 of 5 Reasons to Model During QA! Part one of this series discussed how modelling enables “shift left” QA, eradicating potentially...

Read More
5 Reasons to Model During QA, Part 4/5: Faster QA Reaction Times

5 Reasons to Model During QA, Part 4/5: Faster QA Reaction Times

Welcome to part 4/5 of 5 Reasons to Model During QA! If you have missed any previous instalments, use the following links to see how modelling can:

Read More
Containers for Continuous Testing

Containers for Continuous Testing

Application development and testing has been revolutionised in the past several years with artifact and package repositories, enabling delivery of...

Read More
How to Scale Mobile Test Generation

How to Scale Mobile Test Generation

Welcome to Part 5/5 in our “Scalable Mobile Test Automation" series!

Read More
Bringing Clarity to Complexity: Visual Models in Requirements Engineering

Bringing Clarity to Complexity: Visual Models in Requirements Engineering

In the dynamic, interconnected world of software development, clarity is key. Yet, requirements engineering - the process of defining, documenting,...

Read More
Q&A – Cypress.io UK Community Meetup – Model-Based Testing for Cypress

Q&A – Cypress.io UK Community Meetup – Model-Based Testing for Cypress

Yesterday, I had the immense pleasure of presenting on the second Cypress.io UK Community Meetup. My talk was called “Introducing model-based testing...

Read More
5 Reasons to Model During QA, Part 2/5: Automated Test Generation

5 Reasons to Model During QA, Part 2/5: Automated Test Generation

Welcome to part 2/5 of 5 Reasons to Model During QA! Part one of this series discussed how formal modelling enables “shift left” QA. It discussed how...

Read More
Model-Based Testing Can Lead the Way in IT Change

Model-Based Testing Can Lead the Way in IT Change

IT change remains a persistent struggle for most organisations today. Software teams are aware of the need to move faster and be more agile; yet,...

Read More