We’re always staying on top of the trends in the automation world, and one of the most recent is composable automation. In fact, it’s so recent that there isn’t really anything out there about it, so it’s our mission to tell you as much about composable automation as possible! We’ll look specifically at composable test automation and its benefits to give your testing the reusable edge that it’s been lacking.
“Composable automation” is a tricky phrase. If you Google it, the only thing you see on the front page with that exact phrasing is a Minecraft mod (ok, that might be specific to me as I have racked up a truly ridiculous number of hours on Minecraft). The more common term to come up is “composable enterprise”, which is a phrase that Gartner coined a couple of years ago. A composable enterprise is a modular business made up of building blocks that can easily be swapped out, promoting reusability, agility, speed, and more.
Composable automation is built on the same principles as a composable enterprise in that you build whatever you’re automating in a modular fashion, like putting LEGOs together. What this exactly looks like depends on what industry you’re in and what you’re automating. Many businesses use composable automation without even realizing it. For example, composable commerce is an approach that uses the best parts of commerce technology to automate their business. Microservices are a great way to build the perfect architecture for your needs. Composable commerce allows businesses to use different services for their website, checkout process, promotions, and more.
In the world of testing, composable automation, or composable test automation, is comprised of building blocks of groups of maybe five or six steps that you can use to build your tests. This is reusability and agility on steroids. Let’s look at some example test cases from an eCommerce site. Your first test will have the basic elements of logging into the website, which consists of finding the login screen, typing in your username and password, and then logging in. The second test varies and splits into multiple prongs where the tester searches for different items, adds them to the cart, and eventually checks out. The logging-in portion is standalone in this case but is a common function that could be copied over to dozens, even hundreds of other tests. But the time-saver in this particular test is the search. The tester can reuse the same checkpoint over and over, each time just changing the contents of the search box entry and the name of the item clicked on. Clicking on the search button, asserting that the item is there, and adding that item to the cart are all reusable test steps, and this reusability is specific to a certain type of testing.
We like to look at four levels of testing: manual, automated, codeless, and Virtuoso’s low-code/no-code. With manual testing, there is absolutely no level of reusability - no LEGOs whatsoever. A test is completed by a tester once and then has to be completed over and over by hand. Run-of-the-mill, coded automated testing like Selenium has a higher percentage of reusable components, so your LEGO bricks are mostly rectangles with some squares and novelty blocks thrown in. But then you have to worry about dynamic data not carrying over between test cases, plus reusable test steps take longer to build and they’re more likely to fail. Codeless testing hits the pitfalls of brittle tests and a lack of customizability, so all your LEGO bricks are standard rectangles.
Both coded and standard codeless test automation face a main issue for reusability: environments. If you want to run a test suite on different browsers, devices, or operating systems, you would need to write a different set of tests for each. But with each low-code/no-code Virtuoso checkpoint (which can contain as many or as few steps as you like), they are completely reusable in every environment, plus they use ML-driven self-healing to handle dynamic data and eliminate brittle tests. Low-code/no-code gives you all the versatility you need, so you can build exactly what you’re looking for and reuse it easily. Ever build one of the LEGO botanical sets? There are lots of interesting flower petals and pieces that come together to build something unique, but at the end of the day, still modular.
As I hope we’ve made abundantly clear, one of the main benefits of composable automation is reusability. This leads directly to the second benefit of saving time. Of course, you have to build up your library of testing checkpoints, but they’re all usable the moment they’re written. Then instead of rewriting each checkpoint, you can even avoid copy-and-pasting by simply clicking on the building block you need.
These benefits of reusability and speed can even help users of enterprise systems like CRMs and policy and claims systems where many companies all use the same software. By having composable test automation journeys ready to go, these tests can all be run not only cross-environmentally, but also cross-customer. By partnering with an enterprise that has composable test automation packs already put together, customers can accelerate implementation with fewer people. *
Another benefit is the readiness of data in each checkpoint. Testing is primarily about helping you decide whether your application is ready to move on to the next stage, whether that’s introducing a new feature, testing in another environment, or releasing. Data is a huge part of ensuring that your tests are robust enough to properly assist you in your decisions. Powerful composable automation building blocks will have data already loaded up and ready to go to test your systems without you having to manually add in data each time you add a checkpoint to your journey.
We’ll delve further into what composable automation actually looks like in Virtuoso in our next blog (which will be linked here once it’s live), but if you’re dying of curiosity, you can always try out our free trial to see how you can create the building blocks for your tests and see the power and benefits of composable automation for yourself!