Alex works as a Presales Engineer at Broadcom with a focus on Continuous Testing solutions. He comes from a full-stack developer background and has worked with several companies writing mission-critical software in a variety of languages. Additionally, he has a focus on test automation - specifically with bleeding edge UI test automation frameworks. When he isn't outside hiking, climbing, or skiing with his wife, he is usually gaming or coding for fun. 

Become a JMeter and Continuous Testing Pro

Start Learning

Test Your Website Performance NOW! |

arrowPlease enter a URL with http(s)
Feb 25 2020

What is Scriptless Testing?

Test Automation is Hard.


It’s no secret that the way we write and test software has dramatically changed in recent years with the advent of Agile. More frequent releases are necessary to keep pace with an increasingly competitive environment. The need for automated testing is immediate, but the path to test automation has traditionally required specific skill sets and comes at a hefty cost in terms of script creation and maintenance efforts.


Let’s face it. Scripting automated UI tests with Selenium can be extremely daunting initially, and turn into a massive headache later on. Dealing with the countless - and quite often sporadic - issues between Webdriver (Selenium’s underlying framework) and the web browsers where tests execute has sent many of us into loops of trial and error when things go wrong (and they do!). When an element on a page is moved or altered or when a new feature is added which renders many of my tests broken, we then have to determine which scripts are affected and manually update them.


Given that UIs are almost always the direct interface our users (both internal and external) have to interact with our system, it is extremely important to validate that these UI interfaces function as intended. In other words, we have to test our UIs. For many years this typically meant we had to take on the daunting task of writing hundreds - if not thousands - of native Selenium test automation scripts. But what if we could create automated UI tests without having to script them out by hand?


What is a ‘Scriptless’ testing tool and how does it work?


A Scriptless Test Automation tool provides an abstraction from the underlying test automation code such that the creation of a test is more focused on business logic validation. The human effort required to create a test is drastically simplified - instead of writing code, you would simply indicate which steps need to be performed. The Scriptless tool then internally translates those human-friendly steps into the actual execution code behind the scenes during test execution. The end result: an ultra-accessible interface to define your tests without having to write any code.


Ideally, a scriptless testing tool should have the ability to:

1. Easily generate test steps in a test case

2. Store reusable elements or objects

3. Record test cases

4. Execute test cases on multiple browsers/versions

5. Execute tests cases both on premise and in the cloud

6. Handle test data variance

7. Report on test outcomes and

8. Integrate with the rest of our tooling


Let’s take a closer look at these specific capabilities and how scriptless automation tools provide a simplistic but effective approach to each of them.


Test Steps:

When using a Scriptless tool to define tests, you would identify what needs to happen as opposed to how it needs to happen. For instance, you might choose a “Click” action and identify which thing you want to click - that’s it! You might need to fill out a form on a page for your test, so you would simply say which values to type for each of the form fields - it's that simple! You don't need to worry about waiting for the elements to be visible on the page, you don't need to define the xpath for finding the elements, you don't need to worry about entering/leaving focus of input fields, and most importantly you don't need to write even a single line of code! Test steps are built using common language that everyone understands, and the hyper technical ‘how’ is kept under the hood where it belongs.


For example, the screenshot below shows part of a test in a scriptless tool. Notice how each test step clearly describes what will happen in a simplistic and easily understandable fashion.


Scriptless Test Automation


Object Repository:

Further, a UI-focused Scriptless Test Automation tool typically provides a mechanism to store reusable Objects (or elements on a web page) that you need to interact with in your tests. For instance, the ‘Login Button’ on a user login page. With traditional Selenium testing frameworks, it is quite often a requirement to have knowledge of the html locator (CSS Class, ID, Xpath, etc) of any element your tests need to interact with. With Scriptless solutions, you would simply reference the ‘human readable’ named Objects in your shared Object Repository for each step in your test. As a test creator, you wouldn’t need to know how to locate that button on the page, you would just indicate that you need to click the ‘Login Button’. The actual element locator information is stored in a central place, and if it ever needs to be updated you would only need to change it in one place. Further, the scriptless tool should have built-in mechanisms to detect the change and suggest corrective modification. All tests using that Object would automatically make use of the updated locator methods, and none of the testers would have to even know about it!


Test Recorder:

The more advanced Scriptless tools provide a “Record” capability that further streamlines test creation. Typically, these scriptless test recorders allow you to capture sequences of actions you are performing in your local browser while interacting with a web page and translate that series of recorded actions into a repeatable test. This allows you to quickly create stored, repeatable tests by simply stepping through them in your browser. Further, the most advanced solutions will even match the elements you interacted with in a recorded test to any pre-existing Objects you already have in your Object Repository - only creating new Objects for elements which didn’t already exist. The result of this matching mechanism is an automatically managed Object Repository that prevents duplication.


Reusable Keywords:

As you start building out your tests, you may realize that there are many common sequences of test steps across many tests. What if you could somehow make these sequences of steps reusable? Scriptless tools that provide this ability allow you to dramatically reduce test definition efforts by generalizing these common sequences, allowing any test creator to make use of them in their tests without having to recreate the underlying steps themselves. Again, if these ‘sequences’ need to be updated, that can be performed in one place and all tests using them would automatically be updated.


Scriptless Test Automation


Handling Test Data Variance/Iteration:

Test data variance is typically the cause for large numbers of tests. You may, for example, need to test filling out a Registration Form on a page by entering an address for each of the 50 US States to ensure my registration form allows users from anywhere in the country to ‘sign up’. Does this mean you need 50 different tests when the only thing changing is the values entered in the form? No! The most advanced Scriptless solutions will allow you to parameterize the values of your test steps, which means instead of “Enter address field as 123 Main St.”, you would instead say “Enter address field as {address}”.


how to set up scriptless testing


You could then upload my data variations that cover all of my scenarios (in this example 50 rows of data, one for each US State), and the solution will run through the test for each of the data variations. In this case, all you have to do is create a single scriptless test with parameterized values in the steps and then simply provide the data variations you need to test - and you now have all of the required validations covered!


Test Execution:

Once tests are defined, the next thing we will want to do is run them! A robust Scriptless tool should provide an execution engine directly embedded in the platform such that execution is simply the click of a button. Multi-browser support is very important here - we need to validate a consistent user experience across the various web browsers our users might use.


Further, much of the pain with Selenium is experienced in the resource-intensive nature of execution and problems faced with achieving optimal concurrency. Setting up and maintaining test environments to provision UI test execution is generally a painful effort which requires constant nurturing, and continuous test environment outages/problems can easily consume a large amount of valuable time. An ideal solution would abstract the execution infrastructure from the user entirely and simply handle running tests in the most efficient way possible given available resources. In other words, a tester shouldn’t have to worry about how their tests are executed.


Execution Reporting:

Given that tests are defined and executed in one central place, we now have unified execution reports that are consistent across tests for all of the applications we test. A comprehensive Scriptless tool will have highly consumable test reporting that includes all relevant metrics/data (assertions, broken steps, execution timing/duration, failures, logs, test data used, etc.) as well as the ability to step through the actual execution of the test, ideally in an interactive video format. The consistency in reporting streamlines communication channels between Development, QA, and the Business.



Automating our application builds, functional testing, and deployments (CI/CD) is an integral part of achieving optimal efficiency and improving quality, so it is absolutely imperative that any Scriptless platform provides an agnostic interface for integrating with the limitless variety of tooling one might have - from defect management systems to CI tools (e.g. Jenkins) to release/project tracking software. This interface is most often a flexible API which provides a mechanism to invoke the available operations (e.g. running a test, getting test results) programatically. Out of the box integrations are great, but with the ever-growing variety of tools (from open-source to proprietary to home-grown), it isn’t possible to cover them all. Therefore, an exposed API is the most comprehensive solution to enable integrations with any tool.


The Bottom Line Value


The reusability factor of a Scriptless solution directly impacts the efficiency gains realized from its usage. The Centralized stored objects, shared step sequences, object change detection mechanisms and self healing locators found in scriptless tools will collectively and significantly reduce the creation and maintenance efforts associated with testing as compared to traditional test automation scripting approaches.


The ability to create and make use of shared step sequences, Object change detection mechanisms, and self-healing locators will collectively and significantly reduce the maintenance efforts associated with testing as compared to traditional test automation scripting approaches. The ability to create tests in a simplified interface has the obvious benefit of reducing the time to create tests, but the value does not stop there. Given the fact that tests can be created without any coding knowledge, this allows even non-technical personnel to contribute to the test design/creation efforts. Since the barrier to entry is lowered, the pool of people who can create tests widens when adopting a Scriptless approach to testing. This allows us to more naturally practice the true spirit of Agile where everyone owns quality and ensures alignment between the business objective requirements and the software which implements them.


With the proper Scriptless test automation solution, the daunting task of automating large backlogs of manual tests is significantly optimized, the otherwise cumbersome maintenance of those automated tests becomes far more manageable, and the typical challenges with provisioning test execution are sufficiently abstracted and handled - allowing us to focus on what we need to test instead of how those tests will run.


To find out more about BlazeMeter’s Continuous Testing platform, click here, or put your URL in the box below to start testing for yourself.

arrowPlease enter a URL with http(s)

Interested in writing for our Blog?Send us a pitch!