Tosca Automation Tutorial: Model-Based Approach

In today’s quick software development world, it is important to keep apps high quality. A key part of this is software testing. Tosca automation is a strong tool that helps with this task. This blog, titled “Tosca Automation Tutorial: Model-Based Approach,” will cover the main points about Tosca. We will look into its new model-based method to make your software testing better.

Key Highlights

• Learn how Tricentis Tosca can make your software testing process easier.
• This blog gives a simple look at Tosca, its features, and how it helps with test automation.
• Find out how Tosca’s model-based approach allows you to create tests quickly, reuse them often, and ease maintenance.
• We will explore real-world examples of how Tosca works well in different environments.
• If you are new to Tosca or want to enhance your automation skills, this guide has helpful tips for using Tosca in your testing tasks.

Exploring the Core of Tosca Automation

Tosca automation, from Tricentis, is a top test automation tool. It helps make software testing easier and faster. Its simple design and strong features let you create, manage, and run automated tests easily. This means less manual work and faster software delivery.
Tosca is special because it uses a model-based approach. This means it creates reusable test pieces for the application being tested. Tosca simplifies technical details. As a result, both technical and non-technical people can join in test automation.

Unveiling the Features of Tosca Automation

Tosca is a powerful tool that makes testing easy and quick. One great feature of Tosca is how simple it is to create test cases. Users can use a drag-and-drop design to build their test cases. They do not need to know a lot about coding to do this.
Tosca offers excellent test data management. The platform helps you handle test data easily. This way, tests are completed with the right inputs and checks. A straightforward method to manage data cuts down on mistakes and makes test results more reliable.
Tosca is not just about basic needs. It offers many advanced features. These features include risk-based testing and API testing. Also, it connects easily with CI/CD pipelines. This makes it a great choice for software development today.

How Tosca Stands Out in the Automation Landscape

Tosca test automation stands out from other automation tools. It has special features that fit the needs of software testing. It is easy to use. Even those with little technical skills can use it without any trouble.
Tosca is not only about running tests. It covers the whole testing process. It works well with popular development and testing tools. This makes it easy for teams to add Tosca to what they already do. They can then work better together and get feedback faster.
Tosca works with many platforms and technologies. It can do several testing tasks. You can test web applications, mobile apps, APIs, or desktop applications using it. Tosca offers the flexibility and power you need to cover all tests completely.

What is Model-Based Approach?

The model-based approach changes how we make and manage test cases. It is different from the old script-based method. The traditional way takes a lot of time and is hard to keep up to date. Model-based testing focuses on creating a model of the application we are testing. This model is important because it illustrates how the app works. It includes details about its features, buttons, and logic.
With this method, the design of tests is separate from the code. This makes it easy to reuse tests and manage them. When the application is updated, testers only need to change the main model. These changes will then automatically update all connected test cases. This is very useful for keeping test suites current with changing applications. Therefore, it works well for quick development, especially in the functional testing of web applications.

Uniqueness of model-based approach

Model-based testing is important because it can change with the application. Rather than depending on weak scripts that may fail with each update, the model serves as a guide. This flexible approach helps keep tests helpful and efficient, even as software keeps changing.
This method is easy to understand. Testers can clearly see how the application works and what the test scenarios look like with the model. This visual approach supports teamwork between testers and developers. Both sides can understand and help with the testing process.

Enhance Reusability

At the core of model-based testing is reusable test libraries. These libraries keep parts of tests that you can use again. They include common actions, checks, and business tasks. When testers create a library of these reusable pieces, they can save a lot of time and effort. This helps them make new test cases much easier.
This method helps keep practice steady. When teams use ready-made and tested modules, they make fewer mistakes. They also stick to software processes.
We enjoy many benefits. These include better test coverage, faster test execution, and improved software quality. When companies use reusable test libraries, they can enhance their testing process. This helps them create great software that meets high standards.

Responsive Object Recognition

Tosca automation uses smart object recognition. This feature makes it different from regular testing tools. It allows Tosca to interact with application interfaces the same way a person would.
Tosca’s object recognition is more than just spotting items based on their features. It uses smart algorithms to learn the context and connections between different parts of the user interface. This helps Tosca deal with challenging situations in a better way.
Tosca is a good choice for testing apps that change regularly or need updates often. This includes testing for web, mobile, and desktop applications.

Reusable Test Libraries and Steps

Reusable test libraries are key for Tosca’s model-based method. They help testers build test parts that are simple to join and use. This speeds up the test creation process. It also supports best practices in testing.
Testers can make and save test steps in these libraries. A test step means any action or engagement with the application they are testing. Some test steps can be simple, like clicking a button. Others can be more complicated, like filling out forms or moving through different screens.
By putting these common test steps in reusable libraries, Tosca helps teams create a strong test automation framework. This way, it cuts down on repeated tasks and makes maintenance simpler. It also ensures that tests remain consistent and trustworthy.

Streamlined Testing and Validation

Tosca’s method makes testing simpler and well-organized. It keeps the test logic apart from the code. This setup helps teams build and run tests more quickly. Because of this, they get feedback fast. It helps them spot and solve issues early in the software development process.
Finding problems early is key to keeping high quality in software development. With Tosca, testers can make test suites that look at many different scenarios. This way, applications can be tested thoroughly before they go live. It helps lower the number of costly bugs and problems in production.
When companies use Tosca’s easy testing and checking methods, they can make their software better. This saves them time when they launch their products. A better software position means they can provide great user experiences. It also helps them stay on top in today’s fast software world.

Step-by-Step Guide to Implementing Model-Based Approach in Tosca

Step 1: Understand Model-Based Approach in Tosca

Learn about Tosca’s approach to model-based testing. It focuses on making and reusing models of the application. This way makes it easier to create and keep test cases.

Benefits:
Broad Scenario Testing: Model based testing allows testing a wide range of scenarios without embedding logic or data into the test cases directly.
Code-Free Models: Models are visual, code-free, and highly reusable, making MBT accessible to non-developers.
Ease of Maintenance: Updating a single model or data set propagates to all tests relying on it, reducing maintenance time.

Step 2: Set Up Your Tosca Environment

• Install Tosca: Ensure you have the latest version of Tricentis Tosca installed.
• Download and Install: Visit Tricentis to download Tosca. Run the installer, accept terms, select components (like Tosca Commander), and complete the setup.
• Chrome Extension: For web automation, add the “Tosca Automation Extension” from the Chrome Web Store.
• Initial Setup: Launch Tosca, activate your license, and set up a new project workspace. Create folders for Modules, Test Cases, and Execution Lists.

• Click > create new
• In the subsequent Tosca Commander: Create new workspace window, select Oracle, MS SQL Server, or DB2 from the Select type of Repository drop-down menu.



• Click OK to create a new workspace



• To view the project structure, click on the Project



• Configure Project Settings: Set up your workspace. Also, adjust any necessary settings for your project in Tosca, such as database or API connections.

Step 3: Create the Application Model

• Find and Scan Your Application (AUT):
  1.Open the Scanner: Tosca has different scanning options based on the application type (web, desktop, or mobile). Launch the scanner through Tosca Commander > Scan Application.

  

  2.Identify Controls: For a web app, for example, open the browser and navigate to the AUT. Select the web scanner, and Tosca will display elements (buttons, input fields, etc.) as you hover over them.
  Right click on Modules > scan > Application

  

  3.Select and Capture: Click to capture relevant elements for testing. Tosca will record these elements in a structured format, enabling them for reuse in different test cases.

  

• Create Modules: Organize these parts into modules. These modules are the foundation for your test cases.
• Modules: Reusable components in Tosca for parts of an application (e.g., login screen with fields and buttons).
• Sub-Modules: Smaller sections within a Module, used for complex screens with multiple sections (e.g., product details in an e-commerce app).

To create a sub-module (Right click on the module > create folder

Step 4: Design Test Cases Using the Model

• Define Test Steps: Drag and Drop Elements: In Tosca Commander, start a new test case and drag elements from modules to create test steps. Arrange these steps in the order users typically interact with the application (e.g., navigating to login, entering credentials, and submitting).



• Specify Actions and Values: For each step, specify actions (click, input text) and values (e.g., “username123” for a login field).



Input (Standard): Enters values into test objects (e.g., text fields, dropdowns).
Verify: Checks if test object values match expected results.
Buffer: Captures and stores data from test objects for later use.
WaitOn: Pauses execution until a specific condition is met on a test object.
Constraint: Defines conditions for filtering or selecting rows in tables.
Select: Selects items or rows in lists, grids, or tables based on criteria.

• Parameterize Test Steps: Include parameters to make tests flexible and based on data. This helps you run tests with various inputs.

Step 1: Create a Test Sheet in Test Case Design

• Go to the Test Case Design section in Tosca.



• Create a New Test Sheet: Right-click on the Test Case Design folder and select

  

• Create Test Sheet Name your test sheet, e.g., “Environment Test Data.”



• Add Test Cases/Parameters to the Test Sheet:
• Add rows for the different environments (QA, Prod, and Test) with their respective values.
  1.Right click on the sheet > Create Instance

  

  2.Create your own instance e.g., “QA, PROD”

  

  3.Double-click on the sheet for a more detailed instance view.

  

  4.Right click on the sheet > Create Attribute

  

  5.Inside the attribute, add parameters (e.g., URL, Username, Password).

  

  6.For single attributes, we can add multiple instance values [Right click on the attribute > click create instance]

  

  7.We can create a multiple instance (Test data) for single attribute

  

  8.And select user 1 or user 2 according to you test case from drop-down
  Note: Newly added instance will be displayed under the attribute drop-down

  

Step 2: Create Buffers and Link to Test Case

• Create Test Case: Open Tosca, right-click the desired folder, choose Create Test Case, and name it has “Buffer”.



• Add Set Buffer Module: In Modules, locate Standard Modules > TBox > Set Buffer, and drag it into the test case.



• Convert Test Case to Template: Right-click on the test case, select Convert to Template. This action makes the test case reusable with different data.



• Drag and drop, to map the test sheet from Test Case Design to the Test Case Template



• After mapping the test sheet to the template test case, you can assign the test sheet attributes to buffer values for reuse within the test steps



• Now, you can generate template instances for the created instance, Right-click on the Template Test Case and click > Create TemplateInstance.



• Tosca will create separate instances under the template test case, each instance populated with data from one row in the test sheet.

Step 3: Run the Test Case and View Buffer Values in Tosca

Run the test case and view buffer values in Tosca:

• Navigate to the Template Test Case Instances:
  -Go to Test Cases in Tosca and locate the instances generated from your template test case.
• Run the Test Case:
  -Right-click on an instance (or the template test case itself) and select Run.
  -Tosca will execute the test case using the data from the test sheet, which has been mapped to buffers.



• Check the Execution Log:
  -After execution completes, right-click on the instance or test case and select Execution Log.
  -In the Execution Log, you’ll see detailed results for each test step. This allows you to confirm that the correct buffer values were applied during each step.



• Open the Buffer Viewer:
  -To further inspect the buffer values, open the Buffer Viewer:
  -Go to View > Buffer (or click on the Buffer Viewer icon in the toolbar).
  -The Buffer Viewer will display all buffer values currently stored for the test case, including the values populated from the test sheet.



• Verify Buffer Values in Buffer Viewer:
  -In the Buffer Viewer, locate and confirm the buffer names (e.g., URL_Buffer, Username_Buffer) and their corresponding values. These should match the values from the test sheet for the executed instance.
  -Verify that each buffer holds the correct data based on the test sheet row for the selected instance (e.g., QA, Prod, Test environment data).
• Re-run as Needed:
  -If needed, you can re-run other instances to verify that different buffer values are correctly populated for each environment or row.

Step 4: Using Buffers in Test Cases

• In any test step where you want to use a buffered value, type {B[BufferName]} (replace BufferName with the actual name of your buffer).
• For example, if you created a buffer called URL, use {B[URL]} in the relevant test step field to retrieve the buffered URL.

Step 5: Build Reusable Libraries and Test Step Blocks

• Create Libraries: Build libraries or testing steps that can be reused. This saves time and reduces work that needs to be done repeatedly.
• Divide and Organize: Arrange reusable sections so you can use them in various test cases and projects.

Step 6: Execute Test Cases

In Tosca, test cases can be executed in two main ways:

Steps to Execute TestCases in Scratchbook

• Select TestCases/TestSteps in Tosca’s TestCases section.
• Right-click and choose Run in Scratchbook.



• View Results directly in Scratchbook (pass/fail status and logs).

Steps to Set Up an Execution List in Tosca

• Identify the TestCases: Determine the test cases that need to be included based on the testing scope (e.g., manual, automated, API, or UI tests).
• Organize Test Cases in the Test Case Folder: Ensure all required test cases are organized within appropriate folders in the Test Cases section.
• Create an Execution List:
  -Go to the Execution section of Tosca.
  -Right-click > Create Execution List. Name the list based on your testing context (e.g., “Smoke Suite” or “Regression Suite”).



• Drag and Drop Test Cases:
  -Navigate back to the TestCases section.
  -Drag and drop the test cases (or entire test case folders if you want to include multiple tests) into your execution list in the Execution section.

  

  –Save and Execute: Save the execution list, then execute it by right-clicking and selecting Run.

  

  -The execution will start, and progress is shown in real-time.

  

  – After execution, you can view the pass/fail status and logs in Execution Results

• Navigate to Execution Results:
  -Navigate back to the TestCases section.
  -You’ll see each TestCase with a pass (green) or fail (red) status.

Step 7: Review and Validate Test Results

• Generate Reports:
  -After execution, go to Execution Results.
  -Right-click to print reports in various formats (Excel, PDF, HTML, etc.) based on your requirements.



• Choose Export Format:
  -Select the desired format for the export. Common formats include:
  -Excel (XLSX)
  -PDF
  -HTML
  -XML

  

  -After exporting your execution results to a PDF in Tosca, you can view the PDF



• Check Results: Use Tosca’s reporting tools to look at the test execution results. See if there are any issues.
• Record and Document Findings: Write down everything you find. This includes whether the tests pass or fail and any error details.

Step 8: Maintain and Update Models and Test Cases

• Get used to changes: Update your sections and test cases as your application grows. Make changes directly in the model.
• Make it easy to reuse: Keep improving your parts and libraries. This will help them remain usable and function well.

Benefits of using the Model-Based Approach in Tosca Automation

The benefits of using Tosca’s model-based approach are many. First, it greatly speeds up test automation. A major reason for this is reusability. When you create a module, you can use it for several test cases. This saves time and effort when making tests.
One big benefit is better software quality. A model-based approach helps teams build stronger and more complete Tosca test suites. The model provides a clear source of information. This allows the test cases to show how the application works correctly. It also helps find mistakes that may be missed otherwise.

Comparison of the Model-Based Approach with traditional methods of Tosca Automation

When you look at the model-based approach and compare it to the old Tosca automation methods, the benefits are clear. Traditional testing requires scripts. This means it takes a long time to create test suites. It is also hard to maintain them. As applications become more complex, this problem gets worse.
The model-based approach helps teams be flexible and quick. It allows them to adapt to changes smoothly. This is key for keeping up with the fast pace of software development. The back-and-forth process works well with modern development methods like Agile and DevOps.

Real-world examples of successful implementation of the Model-Based Approach in Tosca Automation

Many companies from different industries have had great success with Tosca’s model-based approach for automation. These real examples show the true benefits of this method in different environments and various applications.

Conclusion

In conclusion, using the Model-Based Approach in Tosca Automation can really help with your testing. This method makes it easier to find objects and allows you to create reusable test libraries. With this approach, you will check your work and test more effectively. Following this method can lead to better efficiency and higher productivity in automation. Model-based testing with Tosca helps you design and run tests in a smart way. By trying this new approach, you can improve your automation skills and keep up in the fast-changing world of software testing. Companies like Codoid are continually innovating and delivering even better testing solutions, leveraging tools like Tosca to enhance automation efficiency and results. Check out the benefits and real examples to see what Tosca Automation offers with the Model-Based Approach.

Frequently Asked Questions

The post Tosca Automation Tutorial: Model-Based Approach appeared first on Codoid.

Source: Read More