🔷 Tosca Automation

What is Tosca?

Tricentis Tosca is an enterprise-grade, continuous testing platform that uses a model-based test automation (MBTA) approach. Unlike script-based tools like Selenium or Playwright where you write code to automate tests, Tosca allows you to create automated tests without writing a single line of code.

Tosca was developed by Tricentis, an Austrian software company that is now one of the leaders in the continuous testing space. It is widely adopted across industries like banking, insurance, healthcare, retail, and telecommunications — wherever complex enterprise applications (SAP, Salesforce, Oracle, mainframes) need rigorous end-to-end testing.

Tosca supports automation across a wide range of technologies:

• Web applications (HTML5, Angular, React, etc.)
• Desktop applications (Windows/.NET, Java Swing/FX)
• Mobile applications (iOS, Android)
• SAP (GUI, Fiori, S/4HANA)
• APIs / Web Services (REST, SOAP, GraphQL)
• Mainframe / Terminal emulators
• Database testing (Oracle, SQL Server, PostgreSQL)
• Salesforce, ServiceNow, Oracle EBS and other packaged applications

What Are the Advantages of Tosca?

Tosca stands out from other automation tools due to several enterprise-focused advantages:

Tosca Architecture

Understanding Tosca’s architecture is essential for working effectively with the platform. Tosca follows a multi-tier architecture consisting of the following layers:

1. Workspace Layer (Repository)

The Workspace is the central repository where all Tosca artifacts are stored — modules, test cases, test data, execution lists, and results. It can be backed by:

• SQLite — for single-user, local development and learning.
• SQL Server / Oracle — for multi-user, enterprise environments with concurrent access.

2. Tosca Commander (Client Layer)

The Tosca Commander is the main desktop application (Windows-based) where testers design, manage, and execute tests. It provides the graphical interface for all test automation activities.

3. Tosca Server (Execution Layer)

For distributed and remote execution, Tosca Server (also called DEX — Distributed Execution) manages test execution across multiple machines. It coordinates which tests run where, handles parallel execution, and collects results.

4. Engine Layer

Tosca uses specialized engines to interact with different technologies:

Main Components of Tosca

Tosca Commander organizes all test automation activities into several key sections (visible as tabs/panels in the Commander UI):

Tosca Commander — Deep Dive

Tosca Commander is the heart of the Tosca platform — the desktop application where you spend most of your time designing, building, and managing automated tests. It runs on Windows and connects to a Workspace (local SQLite or shared SQL Server database).

Commander Interface Layout

When you open Tosca Commander, you see several key panels:

• Left Panel — Workspace Tree: A hierarchical tree view showing all your Modules, TestCases, ExecutionLists, and other artifacts organized in folders. This is your primary navigation.
• Center Panel — Details View: Shows the contents of whatever item you select in the tree — module controls, test case steps, execution results, etc.
• Right Panel — Properties: Displays properties and metadata for the selected item (name, description, technical attributes, etc.).
• Bottom Panel — Search & Messages: Search across all workspace artifacts and view system messages/warnings.

Key Workspace Sections in Commander

Installation of Tosca

Installing Tosca involves downloading the installer from Tricentis and following a guided setup process. Here is the step-by-step procedure:

Prerequisites

• Operating System: Windows 10/11 or Windows Server 2016+
• RAM: Minimum 8 GB (16 GB recommended for enterprise workspaces)
• Disk Space: At least 10 GB free for installation
• .NET Framework: Version 4.7.2 or higher must be installed
• License: A valid Tosca license key from Tricentis (trial or enterprise)

Installation Steps

1. Download the Installer: Log in to the Tricentis Support Portal (support.tricentis.com) and download the latest Tosca Commander installer package (.exe or .msi).
2. Run the Installer: Double-click the installer and follow the setup wizard. Accept the license agreement and choose the installation directory (default: C:\Program Files (x86)\TRICENTIS\Tosca Testsuite).
3. Select Components: Choose which components to install:
   • Tosca Commander (required — the main application)
   • Tosca XScan (recommended — for scanning application UIs)
   • Tosca CI (optional — for CI/CD pipeline integration)
   • DEX Agent (optional — for distributed remote execution)
4. Configure the Workspace: After installation, launch Tosca Commander. On first launch, you will be prompted to create a new workspace:
   • Choose SQLite for local/learning purposes (single-user, file-based).
   • Choose SQL Server for team environments (multi-user, shared database).
5. Activate the License: Enter your Tricentis license key when prompted. For trial versions, you can request a time-limited key from the Tricentis website.
6. Verify Installation: Open Tosca Commander. If the workspace tree loads with the default folder structure (Modules, TestCases, Execution, Requirements), the installation is successful.

How Are Modules Created in Tosca?

Modules are the foundation of Tosca automation. A Module represents a screen, page, or section of your application and contains the controls (UI elements) that Tosca will interact with during test execution.

Module Creation via XScan (Recommended Method)

Tosca XScan is the built-in scanning tool that automatically identifies UI elements in your application and creates modules from them. This is the fastest and most reliable way to create modules:

1. Open XScan: In Tosca Commander, right-click on the Modules folder and select “Scan Application” or press the XScan button in the toolbar.
2. Select the Technology: Choose the appropriate engine:
   • HTML for web applications
   • .NET for Windows desktop apps
   • SAP for SAP GUI
   • Java for Java Swing/FX applications
3. Point to Your Application: XScan will display your running application. Click on the page or screen you want to scan.
4. Select Controls: XScan highlights all identifiable elements (text fields, buttons, dropdowns, tables, labels). Select the ones you need for your test by checking them.
5. Save the Module: Click “Save”. Tosca creates a Module in the Modules folder containing all selected controls with their technical properties (ID, name, class, XPath, etc.).

What a Module Contains

Creating a Custom Module in Tosca Commander

While XScan handles most module creation, there are situations where you need to create or customize modules manually — for example, when dealing with complex dynamic elements, custom controls, or when you want to add calculated/derived attributes.

Steps to Create a Custom Module

1. Navigate to Modules Folder: In the Tosca Commander workspace tree, expand the Modules section.
2. Create a New Module: Right-click on the Modules folder (or a subfolder) and select “Create Module”. Give it a meaningful name (e.g., “Custom — Payment Gateway”).
3. Add Module Attributes (Controls): Right-click on the newly created module and select “Create Module Attribute”. For each attribute:
   • Set the Name (e.g., “CardNumber”, “ExpiryDate”, “PayButton”).
   • Set the XPath / ID / CSS Selector that identifies the element in the application.
   • Set the ActionMode (Input, Verify, Click, Select, WaitFor).
4. Configure Steering Parameters: For each attribute, configure how Tosca interacts with the control:
   • Input: Type a value into the field.
   • Verify: Check that the field contains an expected value.
   • Click: Click a button or link.
   • Select: Choose an option from a dropdown.
   • WaitFor: Wait until the element appears/disappears.
5. Save and Test: Save the module, then use it in a TestCase to verify it works correctly with your application.

Create a TestCase

A TestCase in Tosca represents a complete test scenario. It is built by combining one or more Modules (as TestSteps) and defining the data values for each step. No coding is required — you build test cases by drag-and-drop.

Step-by-Step: Creating a TestCase

1. Navigate to TestCases: In the Tosca Commander workspace tree, go to the TestCases section.
2. Create a New TestCase: Right-click and select “Create TestCase”. Give it a descriptive name, e.g., “TC_001 — Valid Login”.
3. Add TestSteps (Modules): Drag a Module from the Modules section into the TestCase. Each module becomes a TestStep. For a login test, you might add:
   • Step 1: “Open Browser” module — navigates to the login URL.
   • Step 2: “Login Page” module — enters username and password, clicks Login.
   • Step 3: “Dashboard Page” module — verifies the welcome message appears.
   • Step 4: “Close Browser” module — closes the browser session.
4. Define Input Values: For each TestStep, fill in the values for each module attribute:
   • Username field → admin@company.com
   • Password field → SecurePass123
   • Login button → {CLICK}
   • Welcome message → {VERIFY: Welcome, Admin!}
5. Save the TestCase: Save and review the test case structure in the detail panel.

TestCase Structure Example

Executing TestCases

Once your test cases are built, it’s time to run them. Tosca provides multiple execution options depending on your needs:

1. Local Execution (ScratchBook)

The quickest way to run a test case during development and debugging:

1. In the TestCases section, right-click your test case.
2. Select “Run in ScratchBook”.
3. Tosca opens a browser (or your target application), executes each step, and shows results in real time.
4. After execution, the ScratchBook shows a pass/fail status with screenshots for each step.

2. ExecutionList (Structured Execution)

For formal test runs — regression suites, sprint testing, or release validation:

1. Navigate to the Execution section in the workspace tree.
2. Right-click and select “Create ExecutionList”. Name it (e.g., “Regression Suite — Sprint 12”).
3. Drag test cases from the TestCases section into the ExecutionList.
4. Configure execution settings:
   • Execution Environment: Local machine or remote DEX agent.
   • Browser/Platform: Chrome, Firefox, Edge, or mobile emulator.
   • Parallel vs Sequential: Run tests one after another or in parallel.
5. Click “Run” to start execution.

3. Distributed Execution (DEX)

For large-scale enterprise execution across multiple machines:

• Install DEX Agents on remote machines.
• Register agents with the Tosca Server.
• In the ExecutionList, assign test cases to specific agents or let Tosca auto-distribute.
• Monitor execution progress in real time from the Commander dashboard.

Understanding Execution Results