LEAPWORK No-Code Automation Tool
What is LEAPWORK?
One of the trends in Automation tools has been to minimize the need for coding to create test automation and Robotic Process Automation (RPA). LEAPWORK is a tool that implements a visual flow approach to automation. The user builds diagrams using common building blocks, to which the solution refers as “flows”. The goal of this is that both business and IT teams can understand the automation.
For example, an automated flow to log into a web application:
This approach to automation makes it easier for organizations to adopt and scale automation more quickly than with traditional automation tools such as UFT or Selenium. With faster scripting time and minimizing the creation of code, it can lower the costs to create and maintain scripts allowing automation specialists to build, execute, and maintain more scripts than a traditional approach to automation. It also allows those with less technical knowledge to have an expanded role in creating automation. LEAPWORK is built as a test automation tool first and can support RPA, however it may lack some of the more robust features of other RPA tools.
LEAPWORK takes a simple, powerful approach to test automation, and it essentially eliminates the need to manage code to focus on the business process flows. Flows (test cases) in LEAPWORK are generated quickly with the Studio Design Canvas using the following methods:
1. Smart Recorder – The Studio assists the user with application interaction and adds one block for each interaction with the necessary data as well as object capture during the session.
2. Manually add individual blocks – The user navigates through the various categories and selects the specific block to add and fills in the required data or objects as needed.
This opens the tool to be utilized by BAs with some technical knowledge to create the core automation. A sub-flow can be created by simply highlighting blocks to be included and selecting the option to “Create Sub-Flow”. This reduces the reliance on automation resources but does not eliminate it entirely. An automation resource would be needed to:
- Enhance the flows to ensure objects are properly identified
- Ensure adherence to best standards and practices
- Ensure data is properly injected
- Add additional synchronization as needed to avoid false positives
- Manage overall solution, etc.
It is very easy to set up and get going. The only consideration needed is selecting the ports to be used for the Controller and Agents. No issues occurred installing items locally or virtually, and after a reboot the machine was ready to go.
This tool works best when the flow is simplistic. The more complex the flow or data is, the harder it will be to follow the test case – each block and data element will have its own connection arrow which can make the flow representation in the tool hard to follow. A good reuse strategy can reduce this impact; however, it is likely that ROI will dip as flows increase in complexity.
LEAPWORK combines both automation developer and test management tools, reducing the need for additional tools. One potential drawback is the inability to run tests on same machine in parallel outside of Selenium Grid. Another drawback is that test status is at the overall level, it would be more desirable to have a detailed status (pass, fail, done, etc.) for each step.
It is worth a look as a low-code test automation/RPA solution. LEAPWORK is continuously adding new features and functionality to its platform, and we look forward to seeing what interesting improvements they will implement in future releases.
Here is a summary of our findings:
- Configured LEAPWORK to run 1 Controller, 2 Studio, and 2 Agent machines. All machines were able to successfully interact with each other.
- Successfully created scripts against web applications (Salesforce, MS Dynamics CRM, MS PowerApps), desktop applications (MS Office applications), and APIs with reusable flows, reusable objects, and data driven flows with external data.
- When recording, if the same object was interacted with multiple times (e.g. click Save button), a new object was created instead of using the same object multiple times.
- When iterating through data, if an iteration fails, LEAPWORK continues to the next iteration. When completed, LEAPWORK will not fail the execution if an iteration fails. Able to work around this using a variable to flag failures so when iteration completes the result will be failed.
- Successfully ran flows on demand and ran scheduled flows on various Agent machines.
- Able to successfully run on locked/logged off Agent machines.
- Successfully tested public REST API that can be used to trigger scheduled flows from Azure DevOps Pipeline.
- When running flows on an Agent, flows run faster than when running in the Studio. The flow can get ahead of the application, which can cause failures due to timeouts. We added additional synchronization points such as verifying browser title or verifying when an object exists to avoid getting false positives.
The LEAPWORK Architecture
The License Architecture has three parts:
These components are described in more detail below:
The Controller is a service that runs on a server that hosts and stores all LEAPWORK automation assets (scripts, objects, images, schedules, reports, results, etc.). It also controls the execution of the scripts and on which Agents they run.
The Studio is the end user client. The Studio is installed on laptops or virtual machines to create/debug/maintain automation cases, setup schedules (test sets), setup/maintain Agents (to execute runs), and analyze execution results. Admins can also adjust the configuration of the Controller including team setup within LEAPWORK, administer users, and assign user rights via the Studio. LEAPWORK can work with Active Directory as long as the Controller machine is in the same Domain as the Active Directory.
The Agent is a service that runs on a Windows machine to execute the scheduled cases one at a time when requested by either the Studio or Controller.
LEAPWORK supports all Windows-based cloud machines (as long they have a built-in graphical user interface) so the solution can be installed completely or partially in the cloud. You can have the solution hosted in the cloud, install a Studio on a local laptop, and access the Controller on the cloud as long as it can connect to the same network.
Web automation is built on top of Selenium, so it is possible for LEAPWORK to use Selenium Grid Agents to execute web tests. This approach can help reduce the cost of execution Agents, and allows you to run LEAPWORK web tests in parallel on the same machine. LEAPWORK also supports Sauce Labs, BrowserStack, Gridtastic, and LambdaTest to run web tests and run them on different operating systems and mobile devices through the cloud.
LEAPWORK Supported Technologies for Automation
LEAPWORK supports automation for the following:
- Web applications via Selenium, as well an add-in for Internet Explorer.
- Desktop applications built on the following technologies: Java, .Net, WPF, legacy mainframe, Telerik, ComponentOne, Infragistics, VB, and SAP.
- Image recognition so that it can interact with objects visually.
- Text Verification using OCR or AABBYY engines.
- Perform API automation through the HTTP request block to send requests and receive a response to REST and SOAP APIs.
UI Object Identification Strategy
LEAPWORK will select what it feels is the best strategy to use to uniquely identify an application object through a Self-Parent-Ancestor hierarchy which supports both absolute and relative paths. This can help identify dynamic objects. Overall, there are two methods used for identifying UI objects:
- X-path – for web applications
- UI Automation – for desktop applications
Users can add/change/modify strategies as needed, as well as parametrize values. An object can be reused across any flows or sub-flows as needed.
Data Driven Flows
A common practice is to implement data driven flows using external data to make automation more flexible and reusable. LEAPWORK comes with data-driven blocks to allow data to be read from:
- Excel and spreadsheet-like files
- Web Services
- PowerShell scripts
The data can be used across all flows and sub-flows within the test. It is possible to iterate through a specific row or through all rows of data returned.
Once a flow has completed, the results will contain a view of the execution flow that the user can open and replay. The results contain three elements:
- A video recording of the run: this can be configured to only record specific screenshots or turned off completely.
- Debug version of the Design Canvas: the active building block will be highlighted in orange during playback. Each building block will have a data-item node that highlights the following:
- Data values from the application
- Applied block parameters, settings, and attributes
- Data driven from external sources.
- Execution log containing information on the results for each building blocked executed during the run.
Note: the results only contain an overall status of passed or failed, not the status for the individual building block.
Here are some of the additional features within LEAPWORK not already mentioned:
- C building block to integrate C# code
- Logic blocks to control case flow
- Internal version control of flows, including flow status (Draft, Ready to Review, Publish)
- View what is running and when it is scheduled to run with accurate time estimates through the calendar assistant
- Share assets with other teams, restrict access, and partition work to avoid unintended changes
- Create internal dashboards
- Integrate with Power BI and Tableau to create reports to evaluate outcomes of the automation
- Data generators to build date/time, number, and password values
Get in touch with Olenick for more information and to learn how we can support your Automation efforts.