TOSCA Automation: Beginner to Advanced Test Case Execution Guide

Introduction

In the fast-evolving world of software testing, TOSCA Automation has become a crucial tool for test engineers seeking efficient and codeless automation solutions. As software development cycles become shorter, the need for robust test automation has grown significantly. TOSCA Automation Testing provides a comprehensive platform that simplifies test case creation, execution, and maintenance while ensuring high accuracy and efficiency. Its model-based approach allows testers to automate complex scenarios with minimal effort, making it an ideal choice for organizations striving to improve software quality and accelerate release cycles. Whether you are a beginner or an advanced user, this guide will walk you through the entire process, from opening TOSCA to executing complex automated test cases with precision.

In this guide, you will learn step-by-step how to use TOSCA Automation for test execution. We will explore basic concepts like opening TOSCA Automation, scanning applications, and executing test cases in ScratchBook, ensuring you gain a solid foundation in automation testing. Then, we will dive into advanced topics such as buffer creation, waits, reusable libraries, and parameterization, all of which contribute to creating efficient and maintainable test automation frameworks. Additionally, you will gain insights into best practices for optimizing test execution, improving script reusability, and minimizing maintenance efforts. By the end of this guide, you will be well-equipped to leverage TOSCA Automation for robust and efficient test automation, optimizing software testing workflows, improving test coverage, and ensuring better application reliability.

Automation Using TOSCA

How to Open TOSCA?

To begin using TOSCA Automation, you need to follow a series of steps that will help you get started efficiently. Below is a detailed explanation of how to open TOSCA Commander and begin working with it.

1. Install and Launch TOSCA Commander
   
   • First, ensure that TOSCA Commander is installed on your system. If it is not installed yet, you may need to download and set up the required version from Tricentis or your organization’s designated software repository.
   • Once the installation is complete, you can proceed to launch the TOSCA Commander application.

2. Opening TOSCA Commander
   
   • To open TOSCA Commander, navigate to the Start Menu on your system.
   • In the search bar, type “TOSCA Commander” and select the application when it appears in the search results.
   • Alternatively, if you have a shortcut on your desktop or taskbar, you can double-click on the TOSCA Commander icon to launch it instantly.

3. Selecting a Workspace
   
   • When TOSCA Commander starts, a window will appear prompting you to either create a new workspace or open an existing workspace.
   • If you are using TOSCA for the first time, you may need to set up a new workspace by providing a name and specifying a location to store your projects.
   • If you have already been working with TOSCA Automation, you can simply choose your existing workspace and proceed.

4. Getting Started with Test Cases
   
   • After selecting or creating a workspace, TOSCA Commander will load the interface where you can begin working on test cases.
   • Ensure that all necessary configurations are set up correctly, and then navigate to the appropriate section to start creating your first test case.

5. Proceeding with Test Case Creation
   
   • Once TOSCA Commander is successfully opened, you are now ready to proceed with test automation.
   • You can explore different modules, start designing test cases, execute test scenarios, and manage automation workflows within the tool.

Create Your First Test Case

Creating your first test case in TOSCA Automation Testing involves scanning the application under test, setting up necessary automation steps, and executing the test case to verify its functionality. TOSCA Automation provides a structured approach to test automation, ensuring that UI elements are identified correctly and that test cases are executed seamlessly.

Scan Application in XScan

One of the fundamental steps in TOSCA Automation Tool is scanning the application to identify and capture UI elements for automation. TOSCA utilizes the XScan engine, a robust tool designed to scan applications and detect interactable elements. This is essential for creating modules that will be used in test cases.

Follow these steps to successfully scan an application using XScan:

1. Navigate to the Modules Section
   
   • Open TOSCA Commander and locate the Modules section in the workspace.
   • This is where scanned elements will be stored for use in test automation.

2. Initiate the XScan Engine
   
   • Click on the Scan Application button within the Modules section.
   • When prompted, select the XScan engine as the scanning method.

3. Open the Application to be Automated
   
   • Ensure that the application under test is open and ready for scanning.
   • If it is a web-based application, launch it in the appropriate browser before scanning.

4. Detect UI Elements using XScan
   
   • The XScan tool will highlight all interactable elements on the screen, such as buttons, text fields, dropdowns, and checkboxes.
   • Carefully review the highlighted elements to ensure accurate detection

5. Select and Add Elements to Modules
   
   • Choose the required UI elements necessary for test automation.
   • Click Add to Modules to save them in TOSCA’s module repository.

6. Save the Scanned Module for Future Use
   
   • Once the desired elements are added, save the scanned module.
   • This module will be referenced later when creating and executing test cases.

By completing the scanning process, you now have the necessary elements stored in Modules, allowing you to interact with the application in your test cases efficiently.

Open an Application in TOSCA Automation

After scanning the required application elements, the next step is to automate the process of launching the application as part of your test case. This ensures that the test can execute independently without manual intervention.

Follow the steps below to open an application in TOSCA:

1. Create a New Test Case
   
   • In TOSCA Commander, navigate to the Test Cases section.
   • Click Create New Test Case and assign a relevant name for easy identification.

2. Add the TBox Start Program Module
   
   • The TBox Start Program module is used to launch applications automatically.
   • Drag and drop this module into your newly created test case.

3. Configure the Application Path
   
   • Specify the full file path of the application executable.
   • If automating a web-based application, provide the browser path along with the application URL.

4. Set Execution Properties
   
   • Define additional execution settings such as:
     • Wait Time: Set a delay to allow the application to load fully before proceeding.
     • Window State: Configure whether the application should open in maximized, minimized, or default state.

Once these steps are completed, TOSCA Automation will be able to open the application automatically during test execution.

Close an Application in TOSCA Automation

Closing an application after execution is just as important as launching it. Proper closure ensures that the system is not overloaded with background processes and prevents conflicts in subsequent test runs.

To close an application in TOSCA, follow these steps:

1. Use the TBox Close Application Module
   
   • Drag and drop the TBox Close Application module into the test case.
   • This module is designed to close applications gracefully.

2. Configure the Module for Proper Closure
   
   • Ensure that the correct application name or process is specified for closure.
   • If required, set additional properties such as forced closure in case of unresponsive applications.

3. Verify that No Background Processes Remain Active
   
   • Before proceeding to the next test execution, check that no residual background processes of the application are running.
   • This helps prevent interference with subsequent test cases, ensuring smooth execution.

By implementing a proper closure process, you maintain system efficiency and prevent unintended errors in your automated tests.

Execute Test Case in ScratchBook

Before finalizing a test case, TOSCA Automation provides a ScratchBook feature that allows testers to execute test cases in a temporary environment. This helps in verifying test case functionality and debugging any issues before official execution.

To execute a test case in ScratchBook, follow these steps:

1. Right-Click on the Created Test Case
   
   • Navigate to the Test Cases section in TOSCA Commander.
   • Locate the test case you want to execute and right-click on it.

2. Select ‘Run in ScratchBook’
   
   • From the context menu, click on Run in ScratchBook to start execution.
   • TOSCA will now execute the test case in a temporary execution space, without impacting existing execution results.

3. Observe Execution Results in ExecutionList
   
   • Once the test case runs, navigate to the ExecutionList to view the detailed execution results.
   • The ExecutionList will display logs, screenshots (if configured), and error messages (if any).

4. Debug and Refine Test Steps if Necessary
   
   • If any step fails, review the logs and make necessary modifications to the test case.
   • Refine test steps and re-execute in ScratchBook until the test case runs successfully.

Using ScratchBook before final execution allows testers to ensure error-free test cases, saving time and improving overall automation accuracy.

Advanced Concepts in TOSCA Automation

As you progress in TOSCA Automation, you will encounter powerful features designed to enhance test efficiency, streamline execution, and optimize test management. These advanced functionalities help reduce redundancy, improve reusability, and ensure seamless automation workflows.

By leveraging these capabilities, testers can create more adaptable and maintainable test scripts, enhancing overall reliability. Key advanced concepts in TOSCA Automation include buffer creation, wait mechanisms, inbuilt functions, reusable libraries, and template-based parameterization. Each of these plays a crucial role in handling dynamic test scenarios, optimizing execution, and improving test data management.

A deeper understanding of these features enables testers to develop robust automation strategies, ensuring efficient execution and minimal maintenance efforts. The following sections will explore these concepts in detail, highlighting their significance and implementation.

Buffer Creation

Buffers in TOSCA automation serve as temporary storage locations that allow you to store values dynamically during test execution. These stored values can be retrieved and reused later within the same or subsequent test cases, making the automation process more dynamic and efficient.

To create a buffer in TOSCA, follow these steps:

1. Use the TBox Set Buffer module
   
   • This module enables the creation of buffers and assigning values to them during test execution.

2. Assign a name and define a dynamic value
   
   • When creating a buffer, you must provide a unique name for identification.
   • The value stored in the buffer can be set dynamically based on the context of the test case execution

3. Retrieve the buffer value when required
   
   • Later in the test execution, you can reference the stored buffer value using the syntax {B[BufferName]}.
   • This allows for data reuse, making test cases more flexible and adaptive to different scenarios.

By implementing buffering, you reduce hard-coded values and enable dynamic test data handling, improving test maintainability and execution flexibility.

Waits in TOSCA

Synchronization is a crucial aspect of test automation to ensure that test steps interact with the application at the right moment. TOSCA Automation provides multiple types of wait mechanisms to handle timing and synchronization issues effectively.

Types of Waits in TOSCA

1. Explicit Waits
   • This method involves defining a fixed wait time before proceeding to the next step.
   • It is implemented using the TBox Wait module, where you specify the duration (e.g., Wait for 5 seconds) before executing the next action.

2. Conditional Waits
   • Instead of relying on fixed delays, conditional waits allow the test execution to proceed only when a specific condition is met.
   • For example, you can configure TOSCA Automation to wait until a button becomes visible before clicking it.

3. Implicit Waits
   • With implicit waits, TOSCA automatically waits for elements to be present and available before interacting with them.
   • This ensures smoother execution by preventing failures due to slight delays in UI element loading.

By leveraging waits in TOSCA, test execution becomes more robust and adaptable to application response times, reducing test failures caused by timing issues.

Inbuilt Functions in TOSCA

TOSCA Automation offers a variety of built-in functions that enhance automation by performing common operations such as random number generation, string manipulation, and date functions. These functions help eliminate the need for external scripts or additional logic, making automation simpler and more efficient.

Commonly Used Inbuilt Functions

1. Random Number Generation
   
   • The function TOSCA.RandomNumber(1,100) generates a random number between 1 and 100.
   • This is particularly useful when working with test data that requires randomness, such as generating test user IDs or transaction numbers.

2. String Manipulation
   
   • The function TOSCA.Concat(“Hello”, “World”) concatenates two strings, resulting in “HelloWorld”.
   • This function is useful for creating dynamic test inputs, such as combining first names and last names to form a full name.

3. Date Functions
   
   • The function TOSCA.CurrentDate(“dd/MM/yyyy”) retrieves the current date in the specified format.
   • This is useful when testing date-dependent functionalities, such as verifying expiration dates or timestamps.

Using inbuilt functions reduces manual effort and increases the flexibility of automated test cases.

Reusable Library

A Reusable Library in TOSCA is a collection of test case modules designed to optimize automation by avoiding redundant steps. Instead of repeatedly creating the same steps in multiple test cases, you can create reusable modules and call them wherever required.

Steps to Create a Reusable Library

1. Identify common actions
   
   • Find repetitive test steps that are frequently used across multiple test cases.
   • Examples include logging in, navigating to a specific page, or entering common data.
2. Create reusable modules
   
   • Develop independent modules that contain these common actions.
   • Ensure they are modular, flexible, and parameterized for different test scenarios.
3. Use the Call TestCase feature
   
   • Instead of duplicating the same test steps, use the Call TestCase feature to reference the reusable modules within other test cases.

By implementing Reusable Libraries, test automation becomes more efficient, structured, and easier to maintain, reducing redundancy and saving time.

Template Creation – Parameterization

Parameterization is a crucial feature in test automation that allows a single test case to be executed with multiple sets of data. Instead of creating separate test cases for different input values, TOSCA provides a Template-based approach to handle parameterized executions efficiently.

Components of Template Creation

1. Instances & Attributes
   
   • A template is created by converting a standard test case into a reusable structure.
   • Attributes (parameters) are defined to allow variable data inputs for different test scenarios.
2. Create a Template
   
   • Convert an existing test case into a template, enabling data-driven test execution.
3. Define Attributes
   
   • Specify the parameters that will change in different test executions.
   • For example, if testing a login form, username and password can be set as attributes.
4. Create Instances
   
   • Define multiple instances containing different sets of input data.
   • Each instance represents a different test scenario, allowing for comprehensive test coverage.
5. Execute the Template
   
   • Run the test template with different sets of parameter values, enabling data-driven automation.

Using Templates in TOSCA Automation, you can efficiently execute test cases with different input values, improving test reusability and reducing the effort required for maintaining multiple test scripts.

Key Takeaways

• TOSCA Automation simplifies test execution with a codeless, model-based approach.
• Beginners can start by scanning applications, opening applications, and executing test cases in ScratchBook.
• Advanced users can leverage buffers, waits, reusable libraries, and parameterized templates for efficient automation.
• TOSCA’s inbuilt functions further enhance automation capabilities and flexibility.

Conclusion

Mastering TOSCA Testing is crucial for excelling in automation. From basic test cases to advanced parameterization, TOSCA Automation provides a robust framework for efficient application testing.

Earning a TOSCA certification boosts career prospects, validating expertise and increasing job opportunities. Many organizations prefer certified professionals for their hands-on skills and deep automation knowledge.

Practicing real-world scenarios, contributing to automation communities, and staying updated with TOSCA advancements will keep you ahead.

Start your TOSCA Automation journey today, get certified, and elevate your automation skills!