TOSCA TUTORIAL

Tosca Tutorial – Table of Content

Tosca Tutorial #1: Tosca Overview

Tosca Tutorial #2: Tosca Automation Overview

Tosca Tutorial #3: Tricentis Tosca Setup – Install, Uninstall and License Configuration

Tosca Tutorial #4: Tosca Workspace Creation

Tosca Tutorial #5: Understanding of TOSCA Commander and Tosca User Management

Tosca Tutorial #6: Tosca Scanning – An Introduction to Modules

Tosca Tutorial #7: Tosca Test Case Creation

Tosca Tutorial #8: Tosca Parameters and Library– Buffer, Business Parameter, TCP

Tosca Tutorial #9:Tosca Test Execution, Reports, and Bug management

Tosca Tutorial #10: Test Case Design – An approach to test data management 

Tosca Tutorial #11: Tosca Test Data Management.

Tosca Tutorial #12: API Testing in Tosca

Tosca Tutorial #13: Tosca Interview Questions and Answers

In this Tosca Tutorial, we will learn about overview of Tosca Automation Tool which includes –

• Tosca Automation Tool
• Tosca Workspace
• Tosca Commander
• Tosca Automation

Tosca Automation Tool

Being a test tool, Tosca has the ability to automate the functional and regression testing scenarios. It is also capable of mobile and API testing, which is now mandatory for any product delivery in AGILE mode. Tosca supports scripts less automation i.e., scripts and coding is not required to automate any scenario. So, anyone can learn the tool easily and start developing test cases.TOSCA supports its users to build efficient test cases in a methodologically way and provide detailed reports for management.

Tosca Key Features Are:

• Model-Based Testing Approach: It’s one of the significant features of Tosca as a test automation tool. It helps Tosca to gain leverage over other automation tools. Tosca creates a model of AUT(application under test) to create the test case with out using of scripts.
• Risk-Based Testing Approach: As per the name explains, this feature helps users to assess the risk with respect to test cases and allows them to identify the right set of test scripts to minimize the risks. Following different black box testing approaches such as boundary testing, equivalence partitioning, decision box, linear expansion, etc. are utilized to reduce the test script count by ensuring the functional risk coverage. After completion of test execution, risks are measured based on the test results and risk coverage.
• Scriptless test cases: Tosca allows script less automation. It means test cases are created based on the modules which are added by drag and drop method, test data parameters, etc. after carefully incorporating the checkpoints. So, anybody can develop the test suite with minimum programming knowledge.
• Dynamic test data: Test data can be stored separately in a central repository.
• Easy to the maintenance of test cases:  In case of a change in application or data, it can be easily incorporated in the test suite by updating the centrally stored modules, library, and data.
• Distribute Execution: Tosca also provides a great feature to schedule and execute the test cases in different distributed systems in an unattended mode. It reduces the human efforts for testing.
• API Testing: Due to these features, we can test the applications which are partially developed through the API.
• Test Recording: Linear test cases can be developed through recording mode with checkpoints to save time.
• Detailed Reporting and execution logs: Tosca generates a detailed report with screenshots. Also, the report can be customized based on the requirements.
• Mobile Testing: Tosca is also capable of mobile(android and ios) test automation without using any third-party tools.
• Supports different kinds of applications: Tosca as a test automation tool, has the ability to automate most of the major applications such as Web, Salesforce, SAP, Powerbuilder, DotNet, android/ios devices, etc.
• Ability to integrate with third-party tools: It also allows us to integrate with any third-party tools like ALM, Perfecto, Selenium, Azure, etc.

Tosca Commander

The Tosca commander is the primary component of Tricentis Tosca Automation tool. It has the capability to manage all the activities which are involved with test automation. It has five primary sections – 

1. Module Sections – This section contains all the standard and user-defined modules which are required to build the automated test cases.

2. Testcase Section – Technical components of test cases are stored here.

3. TestCaseDesign Section – Dynamic test data are stored here, which are used by the test cases.

4. Execution Section – All the test executions are performed from this section through execution lists. After the execution, detailed logs are kept here.

5. Requirements Section – Requirements related information are stored here.

The primary functions of the Tosca Commander are mentioned below – 

• Tosca User management
• Scan applications to create modules
• Create a library
• Create a test case
• Test data parameterization using TCP, TCD, TDM, TDS
• Maintenance of test cases
• Test execution

Click here to read more on Tosca Commander.

Tosca Workspace

Tosca workspace is a place where any user can perform different activities such as test building, maintenance, execution etc. which are related to Tosca test automation. Workspace is created in the local drive. But it can also be created in a shared network drive or different databases as a central repository based on the business requirement. It is recommended that only one user should be assigned to a single workspace. 

For a multiuser environment, the workspace should be created in a central place which can be accessed by each of the users. 

In a Singleuser Workspace, only one user has access to the workspace. So, the managing of the data and sources is not required.

The Multiuser Workspace manages the data administration more simple as all data of a project are kept in a central location which is called Common Repository. So, in the multiuser workspace, the user has to check out(lock) the different components before modifying it to avoid any data loss. After finishing the update, the user has to check-in(unlock) the components to save the same in the common repository so that any other user can access it.

Pleas click here to learn Tosca Workspace in detailed exlanations.

Tosca Automation

We have to learn about below topics to understand the overview of Tosca Automation.

Tosca Modules:

The technical information of controls are stored in Tosca modules. The purpose of the technical information to steer the test objects.

To develop the test cases in Tosca, the first step is to scan the application and created the modules. We has to scan and create modules for all the required controls from each of the pages/screens of the test application. Each of the test objects which are available in application pages/ screens, are treated as “control” in Tosca. The controls which are required during test execution, has to be added as module’s attribute.

Two types of modules are available in Tricentis Tosca. Those are –

·        Classic Modules – It uses classic engines to steer the test objects.

·        XModules – On the other side, It uses TBox framework based Tosca XEngines.

Click here to learn more on Tosca Modules.

Tosca Test Case:

Test Case is a group of logical steps/ blocks of instructions to verify the specific functionality of an application under test(AUT). The Test Case can be either manual or automated. Through this article, we will explain about the automated Tosca test cases. Tosca Test Case is basically a combination of standard and user-defined modules with verification points.

Classification of Tosca Test Cases:

• Technical Test Cases
• Business Test Case

Technical Test Cases:

These are the physical Test Cases that are used to verify the test scenarios. It can be created after right-clicking on any folder available in the Test Cases section and selecting a circular arrow icon with blue color. There is a short cut keys are available to create Tosca test cases using the key combinations of “Ctrl+N” and “Ctrl+T.”  

Test Step: The test steps can be created by inserting (or drag -drop) the modules into the Test Cases. So, after adding the modules with actions and data in test case, are represented as test steps. After selecting the module or test step from the left panel, in the right side details section has appeared. Tosca Test Cases are supported below operations –

• If-Else Condition
• Condition
• Looping Statements
• Storage

Business Test Case:

Business Test Cases are used to create logical groups to define functional coverage. One business Test Case is a group of one or more technical Test Cases. We cannot execute it directly. It’s used only for monitoring the functional coverage of testing during the testing cycle.

Click here to learn more on test cases as a part to Tosca Automation.

Tosca Parameters:

Parameterization is an approach to feed test data through parameters or variables into the Test Cases. In this article, we will discuss parameters such as buffer and test configuration parameters.

Buffer – We can consider a variable as a Buffer in Tosca to store the data. The buffer scope is restricted to the local workspace. So, the buffer can not be accessed by any other test system as the buffer values are not updated to common repository.

Test Configuration Parameters – The shorter form of Test Configuration Parameters is TCP, which can be defined in the Test Case folder, Test Case, and execution list level. When the TCPs are defined in folder level, it can be access from all the child folders and test cases. The syntax for TCP to access the value is {CP[<logical name>]}. We can create, modify or view the TCPs from the Test Configuration section of any test case, folder, or execution list.

The configuration or test environment related data, which are unique for entire test suites, should be kept in test configuration parameters (TCPs) . The examples of the advisable TCP parameters are such as path of the application, URL, environment name, user details, reporting path, etc.

Tosca Library:

Test Step Block – It is a collection of test steps which is required to automate a small functionalities. Conceptually, it is the same as function or method. The logical grouping is done through Test Case level folders. The purpose of creating a test step block is for better readability and understanding of Test Cases.

For example, application login functionality is involved with steps – invoke browser, enter credential, and login verification. In this particular example, we need to create a folder within the test case which will be represented as test step block. Then, we will rename it to ApplicationLogin  and create three steps.

Test Step Library – It’s a location to create our reusable test step components. The Library can be created under any folder available in the Test Cases section. There is a limitation that we can not create more than one Library within a root folder.

Library creation – First, need to right-click on any folder available in TestCase section and select the “create teststep library” folder icon with L symbol. The shortcut keys to create library folder are the combination of  “Ctrl+N” and “Ctrl+L”.

Tosca Execution:

Once we have created test cases in the TestCases section of Tosca Commander, we can proceed with one of the following options for test execution –

· Execution in Tosca ScratchBook

· Execution in Tosca ExecutionList

Execution in ScratchBook: It is advisable to execute test cases in ScratchBook to ensure the test case completeness during the test development and maintenance phase. The execution log created in scratchbook will not available for future reference as it’s a kind of temporary log. We can also drill down and execute individual TestSteps as well.

Execution in ExecutionList: The actual test execution cycle has to be done from ExecutionList which are created for the particular cycle. The result logs which are created in ExecutionList can be used for future reference. This logs are saved in common repository. We can integrate the execution list with external system for continuous testing.

Get more details on Tosca execution, please click here.

Conclusion:

Through this article, we have learned about the overview of different Tosca Automation activities such as, Tosca Automation Tool, Tosca Workspace, Tosca Commander and Tosca Automation. Also, please click here to understand more from Tricentie Support portal.

Tosca Tutorial – Table of Content

Tosca is now become one of the leading test automation tool which follows the script less methodology. Through out the entire Tosca tutorial, we have already learned about the different Tosca components and test automation approach. Now we are going to explain the concepts of API Testing in TOSCA.

Tosca Tutorial #1: Tosca Overview

Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration

Tosca Tutorial #3: Tosca Workspace Creation

Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management

Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules

Tosca Tutorial #6: Tosca Test Case Creation

Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP

Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management

Tosca Tutorial #9: Test Case Design – An approach to test data management 

Tosca Tutorial #10: Tosca Test Data Management.

Tosca Tutorial #11: API Testing in Tosca

Tosca Tutorial #12: Tosca Interview Questions and Answers

In this “API Testing in TOSCA” article, we will explain the overview of API and the detailed steps of automated API Testing in TOSCA.

API Testing in Tosca

What is API?

API is the shorter form of Application Program Interface. It’s working as an interface which allows two applications to communicate with each other through common message formats such as, XML, JSON, etc. Let’s consider the below figure to understand more on API–

Assume, we have four different applications – SAP App, Mobile Apps, Web Portal and Billing System, which are integrated by common interface as API. Here API is working as an interpreter. Each of the system interacting with each other by sending an API request and receiving the API response. Basically, each system is communicating with API and based on the request, API routes the messages to the target system.

Purposes of API:

• Communicate between different applications.
• It’s platform-independent.
• Development of one system is not dependant with another.
• Fast and secure communication.
• Easy to integrate many applications.

Different Types of API:

REST API (Representational State Transfer): It’s a web service API which is now an essential part of modern web-based applications such as, Facebook, Netflix, etc. REST API should comply with below standards –

• Stateless – It does not allow to store the data they received from a requestor.
• Client-Server Architecture – Client and Server’s REST APIs should be independent with each other.
• Cache – The cache is storing the browsing data for a specific period of time.
• Uniform Interface – Communication should be HTTP requests using URL, CRUD(Create, Read, Update, Delete) and JSON.
• Layered System – REST APIs should use different architecture layers which contributes towards a clear hierarchy.
• Code on demand – It’s an optional rule to transmit code within the application through the API.

RPC API (Remote Procedure Call): These are the simplest API which is used from old days. The aim of RPC is to execute code on the server system. It was easier for application developers to develop applications involving more programs or services in the RPC API.

There are two types of RPC APIs – XML-RPC and JSON-RPC.

SOAP API (Simple Object Access Protocol): It is also one kind of web API. SOAP is the first to define the process about the applications to use a network connection to manage services. It’s a special protocol which is defined by the World Wide Web Consortium (W3C).

API Testing in TOSCA:

Before understanding the API Testing in TOSCA, first, we need to understand the “What is API Testing?”.

What is API Testing? 

The API Testing is an approach to test the API components of any software product in efficient way. To perform API testing, we need to validate the API response received based on the API request. The main moto of API testing is to test the core functionality, reliability, performance and security through the API. API Testing is ideal for testing the core functionality of the application when the all the application is partially developed. So, it allows us to start the testing before the integration of the software components.

For more information on API Testing, please click here.

API Testing in TOSCA:

The goal of API testing is to ensure that the core functionalities of the application work as expected without interacting in the UI layer. To perform the API Testing, always, we need to take help from any third party tools like Postman, UFT, TOSCA, etc.

Here, TOSCA is one of the best automation tools for API Testing.

Benefits API Testing in TOSCA:

• API testing can be used to validate the core functionalities even when the UI hasn’t been developed/modified. Hence testing can be initiated much before actual functional testing (UI based) is done.
• Frequent application changes can be tested quickly. 
• It is easy to maintain test cases in TOSCA.
• The API testing in TOSCA can be done much faster.
• Standalone Tosca API Scanning Wizard is available to scan the API in the easiest way.
• Easy to create Tosca test scenarios.

Supported Standards for API Testing in TOSCA:

Web Service Standards	SOAP 1.1, SOAP 1.2, REST
Transport Layer	HTTP 1.1, IPv4, IPv6
Message Format	XML, JSON
Message Description Language	OData 4.0, SWAGGER, WSDL 1.1, WADL, XSD, JSON Schema
Authentication	Basic Authentication, Kerberos/SPNEGO, NTLM

Process flow for API Testing in TOSCA:

API Services – Identify the API details and functional flow for automation.

API Scan – Scan the API and create Tosca modules.

Create Test Case – Generate test cases and perform cleanup with parameterization.

Run – Execute the test cases and share the reports to stack holders.

Step by Step Guide to Perform Automation of API Testing in Tosca:

Step1# Collect API Details – We need to collect below API Information of the sample application,

• Endpoint: http://webservice.toscacloud.com/rest/swagger/docs/v2Credential: Username1/Password1
• Web Service Standards: REST
• Message Format: JSON

Step2# Identify Scenarios and data formats for the API Request.

Test Scenario – After logging into the sample swagger application, need to add a new coffee brand and verify.

Data Format – Data need to be passed through JSON format.

Step3# Manually Verify the scenario using tools like Postman (Optional). Please go through the article on Postman to understand the process to test the API.

Step4# Scan the API with the endpoint reference. Scanning steps are mentioned below –

1) Open the API Scan wizard from “API Testing” tab available in TOSCA Header section.

2) Click on URI button and enter the endpoint address. Now click on OK to start scanning.

3) After a few moments, API scan will be completed, and scanned API modules are displayed in the API Scan Wizard.

Step5# Create modules and test cases – Selecting the root folder, i.e. “Swagger Demo CoffeeShop V2”, click on “API Test Case” to generate modules and test cases in the TOSCA. For every transaction, there are two parts – one for request and another for the response.

Step6# Cleanup scenarios: Auto-generated test cases can be used as a base suite which needs to be cleaned by removing the unwanted folders, create module attributes to parametrize the response values such as, authentication token which will be required to perform any transaction.

Post Coffee (Modules for API Request) –

After assigning the parameters, the API Test Case will look like below,

Step7# Execute API Test Case in TOSCA – First of all, we need to add the newly created test case into the execution list. Now, the execution can be initiated by clicking on “Run” button. As it’s an API Testing, no application UI will be visible through out the execution. After completion of execution, Report will look like below, 

Conclusion:

In this “API Testing in TOSCA” article, we have learned about API and API Testing in TOSCA. To know more on API testing in Tosca from Tricenties support portal, please click here.

Tosca Tutorial – Table of Content

We have broken the entire Tosca tutorial into the below list of articles. Now we are going to understand about the concepts of Tosca Test Case Design and Test Data management through out this tutorial. We have wrote this article with simple words and keep the write up shorts which help the new comer to understand the concept easily with lesser time.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

In this Tosca Test Case Design and Test data Management article, we will learn about the step by step implementation approach of Tosca Test Case Design and overview of Test Data Management. If you want to prepare for TOSCA Interview Questions, please click here.

Tosca Test Case Design (TCD)

This is an approach to isolate the test data from the technical sections of test cases. So, the data and test cases are kept separately. The Tosca Test Case Design section has the capability to break our test cases into a logical structure. It is also help us to plan and design the testcases in a efficient and structured way to reduce the development and maintenance efforts.

Use the Tosca Test Case Design section is performing the below activities – 

• Create the testsheets, which is a combination of all possible test cases for any particular scenario or template. Basically, testsheets are holding the data for different combinations.
• The concept of class in test case design approach, helps to reuse the common data across the test cases which reduce the efforts of data management.
• With the help of instances, we can create the specific data for TestSheets, TCD Attributes, or TCD classes.
• Create TestCase Templates and assign the Testsheets.
• We need to instantiate or re-instantiate Templates to generate the instance test cases as per the testsheets.
• Manage test data in testsheets and execute the instance test cases

Test Case Design objects:

The table below lists all components available in the Test Case Design section, and keyboard shortcuts where applicable.

• Folder – The test case design folder is used to group the test sheets or classes in a logical way.
• TestSheet – TestSheet is a list of data for all possible combinations of Tosca test cases. Each data set represents one unique test case.
• Attribute – It’s referred to as the different data parameters corresponding to each application field.
• Attribute(not business-relevant) – It’s used for comment or description purposes.
• Attribute(result) – It’s used for result purposes.
• Instances Collection – It holds the Instances i.e., all possible values available for particular attribute.
• Instances – This is the value of each attribute/parameter. It can be created TestSheets, Attributes, or Class level. Instances of Testsheets are basically a test case name.
• Class – This is similar to testsheets, but it’s used for the reusable purpose. All the common data are stored here, which can be reused in multiple testsheets.
• Class reference – It’s acting as a link of Classes from Testsheets. We can create it with the drag-drop method.

Object hierarchies in Test Case Design:

• A TestSheet may have Attributes, Instances, TestSteps, and class references.
• A class may be the combinations of class Attributes and Instances.
• Again, an Attribute can keeps further Attributes and Instances.
• A Step can keeps more Steps and Attributes.

Step-by-step process to implement Test Case Design:

• Step1: Create the Class if there is some common sections are available for multiple test cases. For example, Login is a common section in most of the application. So, we need to create a class as per the below diagram –

• Step2: Create testsheets as per the below structure and link the classes. Testsheets are used for the unique individual scenario. Based on the different data combinations, different test cases will be generated as per the instances of testsheets.

• Step3: Create template test cases. We can convert any existing technical test case into a template test case by selecting “the Convert to Template Testcase” option after right-clicking on it.

• Step4: Assign the testsheet into the template test case by drag and dropping the testsheet into the template test case. Only one testsheet can be assigned to one template. After this, we can assign the Test Case Design data Attributes/ parameters into the test steps by drag-drop method or typing. Syntax for linking the parameters – {XL[parameter_name]}. The template test case can not be executed.

• Step5: After assigning the data parameters, we need to generate the instance test cases. It can be done by opting the option Instantiate or Re-instantiate by right-clicking on template test cases. After the, all the possible test cases will be generated based on the data combinations of test sheets.

• Step6: Now, we can create an execution list to execute the instance test cases.

Advantages to TCD:

• · Dynamic handling of objects/data is easy
• · Reusability of test cases
• · No scripting involved
• · Data and technical components are kept separately. In the case of data change, no need to modify the test cases.

Disadvantages of TCD:

• · Test case design section is very complicated
• · A little expensive
• · The UI takes time to understand

Reference Link – https://documentation.tricentis.com/tosca/1300/en/content/testcase_design/testcase_design_intro.htm

Tosca Test Data Management (TDM)

Test Data Management is an approach to manage the required test data for test execution. It will help us to use the data which are stored externally. 

• Test data management is an another important component for data management which is available along with the standard installation of Tricentis Tosca Test suite.
• DB2, MS SQL Server and Oracle repositories – Tosca test data management (TDM) component uses the same database which is used to create the common repository of the workspace.
• SQLite repositories – For SQLite, TDM uses the separate repository to store the data.
• After creation of a new workspace, by default Tosca is getting connected with the repository.
• If required, Tosca is able to connect different database as TDM repository instead of default database.

Connecting to a TDM repository: Create Configuration parameter as TDMConnection in the root level and assign connection string in below format -<Databasetype>(<ConnectionString>)[dynamicmode=<on or off>,schema=<Schemaname>]

Standard module to handle TDM:

The standard module path – “Standard modules->Test Data Management->Test Data Management – Legacy.” 

• TDM Create Object – The TDM Create Object module helps to create a fresh TDM object for a specific object type. Initially, the new TDM object can be created with empty value.
• TDM Find Single Object – It is used to search for a TDM object within the TDM repository.
• TDM Set Attribute – Set Attribute module is able to set the values for any existing TDM object.
• TDM Set State – This module is able to set the values of state for any existing TDM object.
• TDM Add Association – This module is used to define an association between two TDM objects. This association receives an individual role name which allows the mapping.
• TDM Remove Association – This module is used to remove the association between TDM objects.
• TDM Delete Object – This module is used to delete the TDM Objects from the TDM repositories.
• TDM Save – This Module saves the TDM object in the TDM repository.

Click here to learn more on Test Data Management.

Conclusion:

In this Tosca Test Case Design and Test data Management article, we have learned about Test Case Design and Test Data Management. Click here to understand more from the Tricentis Support portal on this topic.

Please click to read the most important topic of TOSCA Tutorial – Understanding of Tosca Case Creation.

Tosca Tutorial – Table of Content

We have segregated the entire Tosca tutorial into the below articles. We have wrote this “Tosca Execution” article in a simple wording with examples which can be very helpful for entry level software tester to understand the concept easily. The moto of this article is to understand the concepts of Tosca Execution.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca

Tosca Tutorial #12: Tosca Interview Questions and Answers

Through out the “Tosca Execution and Tosca Issues” article, we will provide the step by step guidance on Tosca Execution process . Also, we will explain the overview of Tosca Issues.

Tosca ExecutionList – Overview of Test Execution

Why Automation Test Execution?

Test execution is a process to verify the application functionality based on the test cases. The test execution can done manually or through automated approach. In this article, we will learn the automation test execution for the test cases developed in Tosca. The primary purposes of automation test executions with the help of Tosca are –

• Reduce human efforts.
• Increase functional coverage.
• Ensure the quality of the delivery by avoiding unwanted human efforts.
• Reduce costs and test execution duration.
• Easy to data management and test maintenance.
• More professional way of test reporting to the stack holders.
• Unattended test execution through the distributed execution model of Tosca.

Approach to capture screenshots during execution?

• Screen Capture of Failed TestSteps: Tosca is able to capture the screens for each test steps that failed due to verification of dialog failures. For the test cases which are created using Classic Engines, Tosca allows to capture screen on user aborts. The captured screenshot will be available in the path – @{Environment.ProjectDir}\\Screenshots. Path to configure this setting – 

• Engines 3.0 – Project->Settings->TBox->Logging->Screenshots 

• Classic Engines – Project->Settings->Engine->Logging Options->Screenshots 

• Off – Tosca will not take the screenshot.

• Dialog Failure – It allows Tosca Commander to capture a screenshot for dialog failure.

• Verification Failure – It allows Tosca Commander to capture a screenshot for verification failure.

• Screen Capture of TestStepValues: Based on the configuration, Tosca is allows to capture the screens for each TestStepValues that uses the action mode as Input during the execution. We can use the same configuration, to check the screens which are captured during test execution.

The option for screen capture of test step values, is available for following Engine 3.0 – DotNet, AnyUI, XBrowser, UIA, and the test automation, done based on the image.

To activate it, we need to change the global setting Screen Flow from path Project->Settings->Engine->Doku Snapper.

Also, the same thing can be achieved by adding the configuration parameter ScreenFlow and ScreenFlowPath in the execution list.

The execution log will be looks like –  

• DokuSnapper:  It is used to generate a Microsoft® Word document that contains screenshots and data on all executed TestSteps. Instead of capturing screenshots in every TestStep, DokuSnapper consolidates all data in one word document. 

We can enable it by changing the Enable Snapper value to True from the path – Project->Settings->Engine->Doku Snapper.

The generated document will be looks like – 

How to execute test cases in Tosca?

Once we are done with the Test Case creation with the Tosca Commander TestCases section, we will follow the below mentioned approaches for further proceedings:

· Execute test cases in ScratchBook

· Execute test cases from Execution List

Execute test cases in ScratchBook:

Tricentis advises using the ScratchBook for a dry run (to check the test case readiness) only, as the results do not store for future reference. We also could perform the execution of individual TestSteps.

Executing the test cases from the list of Execution :

The Execution segments provides a feature of selecting and preparing multiple TestCases for execution. Execution performed in ExecutionList will be available for further future reference.

Step-by-step procedure to prepare and run test cases from Execution Section:

• Step1# Create Execution List Folder in the Executions section by selecting the “Create Execution List Folder” icon after right-clicking on any folder.
• Step2# Similarly, we need to create our execution List component under the newly created execution list folder.
• Step3# We can add the test cases(which are created in the last article) into the execution list from the TestCases section by the drag-drop method. The complete execution list will look like below –

• Step4# Now, we need to configure the execution behavior, such as the screen capture mechanism. For our learning purpose, we have enabled Take screenshots of TestStepValues and DockuSnapper.
• Step5# Now, we can execute the one, multiple, or entire test cases based on the selection. We execute the test case by pressing the F6 key or click on the run button after right-clicking on the selected test cases/ execution list. 
• Step6# Understand and process your test results. The execution log is showing below with highlighted screenshot path – 

Also, the dokusnapper has been created in the default path   “%AppData%\\TRICENTIS\\TOSCA TestSuite\\7.0.0\\dokusnapper\\” with the document name staring with the test case name.

Tosca Issues

Explain the concept of Tosca Issues?

The issue is nothing but the reason for the test failure. The route cause of the issue is a valid valid defect in the application or there is a enhancement in the application (FeatureRequest). During the automation execution, the issue or defect has to be logged and linked to the test case.

• Defect – This is an application issue i.e., the application is not working as per test steps (expectation). The defect has to be fixed by the application developer.  

• Feature-request – If the application has been enhanced, the application will not be in synched with test cases which results the failure of the test case. As it’s a valid change in the application, the test case has to be updated based on this. This scenario has to be treated as a feature request.

We can log the issues in the Issues section or in the Execution section.

• Step#1:  Navigate to the Issues section.
• Step#2: To create an issue, we need to right-click on Issue folder and select either of the issue type option between Create Defect or Create FeatureRequest which are available in context menu. After selection of type, Tosca Commander creates a new issue and automatically asks to change the name.
• Step#3: In the next step, we can either provide a new name or use the default name by pressing Enter.
• Step#4: Now, we need to enter the below details for the different fields available – 
  • ID – We can define our own ID standards or use the Ids from any external systems.
  • State – The state field explains the current status of the issue. The value range can be customized based on the standards.
  • Type – Always two types are available here which can be changed at any time.
  • Description – This field represents the problem statements of the issue. Based on the description, developers take the action. The description should contain all the information to recreate the issue.
  • Severity – The severity represents the impact of the issue. This field accept the integer value only.
  • Priority – It describe the urgency of the issue to get it fixed. This field also accepts the integer values.

Conclusion:

In this article of Tricentis Tosca Tutorial, we have learned about how to perform Tosca Execution and raise Tosca Issues. Please click here to get more information from the support portal.

Please click to read the next article – Overview of Tosca Test Case Design.

Tosca Tutorial – Table of Content

We have combined the entire Tosca tutorial with the below articles. You can read each of the articles by clicking on the link.

In this “Create Tosca Test Cases..” article, we have explained the step by step approach to develop Tosca Test cases in simple words which will help the new comers to understand easily. Also, we are going to learn about Tosca Parameters and Reusable TestStepBlock. To get the flavors of Tosca interview questions, please click here.

Create Tosca Test Cases

What is Test Case in software testing?

Test case is a set of instructions to ensure the quality of the software product. In other word, it is a combination of steps to walk-through the application with defined checkpoints. The test cases are written based on the requirements. Test cases can be designed for manual or automated testing. In this Tosca Test Case Creation article, we are going to discuss about Test Cases that are automated by Tosca. The Tosca Test Cases are created by using the both standard and user defined modules with required test data and verification points.

Tosca Test Case Classification: Two types of test cases are available in Tosca. Those are –

• Technical Test Cases
• Business Test Case

Technical Test Cases

Technical Test Case:

This are the actual test cases in Tosca which keeps all the technical information to steer the controls during execution. The technical test cases can be created by right-clicking on any folder which are available in TestCase section and selecting the blue colored circular arrow icon. The short cut key for new test case creation are “Ctrl+N” and “Ctrl+T.”  

Test Step: 

Test steps are created by adding the modules (standard or user defined) into the test case by drag-drop or insert method. For each of the modules in test cases are treated as test step. In the left panel of any testcases is showing the test steps and in the right side, the details about step actions are shown.

In this test step details section, we need to choose/enter appropriate attribute values for ActionMode and Value to complete the Test Cases. The different ActionModes are –

• Input – Mostly used while entering data, perform click operations.
• Insert – It’s used for insert purpose.
• Verify – Need to select this option during verification. In the value field, we need to provide the condition.
• Buffer – It’s used to set the value to buffer.
• Walton – It’s used for synchronization purposes to wait(predefined time) until the condition is satisfied.
• Select – Used while hierarchy levels are available and need to work on child items.
• Constraint – Used for checking for a particular value, mostly used in the table’s column.

Also, there is another attribute WorkState, is optionally used for displaying the status of Tosca Test Case development. Different states are –

• PLANNING – When the Test Case development is in the planning and analysis phase.
• IN_WORK – It shows the development is in progress.
• COMPLETED – It shows that development is completed.

Different Operation Supported by Tosca:

• If-Else condition – Tosca allows us to add “if-else” condition by right-clicking on Test Case and selecting the option “Create If statements…”. Under the condition section of the “If-Else” section, we need to write the verification step for the condition.

• Looping Statement – Tosca supports While and Do-While looping structure. Create a loop; we need to right-click on Test Case, click on the ‘…’ icon, and after that, select the required looping type.

Also, we can convert a test case folder into a loop by defining the Repetition property with a looping counter.

• Tosca Condition – We can add a condition in the Test Case, folder, test step, reusable test step block, step attribute level by updating the condition property. The condition can be implemented based on the business parameter, TCD Parameter, constant value, etc.

      Step-by-step Guide to Create Tosca Test Cases

Sample functional scenario: We are going to automate below test scenario with the help of Tosca –

• Step1: Open sample application provided by Tricentis for learning purpose with URL http://sampleapp.tricentis.com/101/
• Step2: Click on Automobile Tab to open the “Enter Vehicle Data” section.
• Step3: Enter mandatory fields and click on Next and verify that the “Enter Insurant Data” section appears.
• Step4: Click on the Prev button.
• Step5:  Verify that the “Enter Vehicle Data” section is displayed with previously entered data.

Technical Test Case creation steps:

• Step1: Open the URL manually to scan Modules for Home page, “Enter Vehicle Data” section, and “Enter Insurant Data” section with required controls. You can refer to the last article about Tosca Modules while creating modules. The modules will look like –

• Step2: Create a folder structure and a new Test Case in the Test Cases section. Also, create three folders in Test Case as the best practices –
  • PreCondition – Open application, initial dataset related test steps are kept here.
  • Workflow – Application navigation, data entry, verification steps are kept here.
  • PostCondition – Closing of applications are kept here.

• Step3: Drag & Drop the standard modules “Open Url” and provide URL in the value attribute. We can change the module names after adding it in Test Case based on the test steps.

• Step4: Drag and drop the module “Tricentis Vehicle Insurance | Home” into the Test Case (Workflow folder) to click on the Automobile tab.   

• Step5: Drag and drop the module “Enter Vehicle Data” into the Test Case. Enter input data and click on Next.

• Step6: Drag and drop the module “Enter Insurant Data” into the Test Case to verify the availability of “First Name” and “Last Name.” After verification, you need to perform click operation on “Prev” button control.   

• Step7: Again, using the module “Enter Vehicle Data,” verify that previously selected data are stored here.  

• Step8: Add module to close the browser and rename all the test step modules based on the functional step.

• Step9: Now execute the Test Case in the scratch book (Right-click on Test Case and click on Run in Scratch book) to check the correctness of the Test Case. By default, execution will start in browser Internet Explorer. The log will be generated. If we want to execute from Chrome, we need to add TCP Browser with value as “Chrome.”

Business Test Case

The business test cases are the logical groups of technical test cases. Each of the business test case represents the functionality coverage which is designed based on the requirements. The business test cases are not executable. Only, we can monitor the testing coverage through this.

Steps to create business Test Cases –

• Step1: Create a folder structure and a new Test Case in the Test Cases section.
• Step2: The business test cases can be created by right-clicking on any folder, available in TestCase section and choosing the orange colored circular arrow icon. Also, business test case can be created by clicking on short cut keys “Ctrl+N” and “Ctrl+B.”  
• Step3: Drag and drop selected technical Test Cases into this business Test Case.

Tosca Parameters and Library

In the last example, we have provided the test data directly in the Test Cases as a hardcoded value. The main disadvantage of this approach is whenever we need to change the data; we need to update the Test Case. Also, the common test step block, such as log in with different credential, can not be reused. So, to bypass this, we need to go for parameterization.

Parameterization is a methodology to avoid use of hard coded data to make the test case dynamic and test data driven. Tosca allows many ways to perform parameterization. The important approaches are Buffer, Test Configuration Parameter (TCP), Business Parameter, TCD, TCP, etc. We will explain the buffer and test configuration parameter (TCP) in this article.

Buffer 

We can say the buffer is a special kind of variable in Tosca to store run time values. Only difference is that the buffer keeps the value after the execution over. The scope of buffer is restricted to the local workspace only as the buffere value can not be updated to shared repository. There is different standard modules are available in Tosca to work with buffers. The important modules are –

• TBox Set Buffer – This module is used to create the buffer as per the name provided in the attribute section. The value provided in the attribute’s value section will be stored in the buffer. We can create more than one bufferers using this module.
• TBox Name To Buffer – This module is used to store the Test Case name into the buffer for which name is provided in the attribute value field. We need to execute the Test Case from the execution list to store the Test Case name. Otherwise, it will store as “Scratch book.”
• TBox Delete Buffer – It’s used to delete the existing buffers. The buffer name should be mentioned in the attribute’s value section.
• TBox Partial Buffer – This module is used to extract or verify the partial text of a buffer. 

The syntax of buffer to read the value is  {B[Buffer_Name]}

Buffer can be created by using ActionMode as Buffer for any test step (buffer name should be the test step value) instead of using Set Buffer module. Also, using {XB[Buffer_Name]}, buffer can be created from a verification test step dynamically.

For more details on a buffer, please refer Tricentis support portal.

Test Configuration Parameters – This is the another way to parameterize the test data. The Test Configuration Parameters(TCP) can be created in test case, folder or execution list level. If the test configuration parameters are defined in parent folder level, same parameter values can be retrieved from sub folder and all the test cases available under that parent folder. To create TCP, we need to select the “Create Test Configuration Parameter” option after right-clicking on test case or folder level. The syntax to read TCP parameter is {CP[TCP Name]}. The TCPs are visible in the Test Configuration section of every Test Case, folder, or execution list.

Ideally, we should use the test configuration parameters for the common or configuration related data which are applicable for through out the test suites. The examples of the TCP are Application path or URL, credential, environment details, reporting path, etc.

Tosca provides basic test configuration parameters that are used for test settings in the Tosca workspace. Like if we want to execute the Test Case in the Chrome browser, we need to add TCP as Browser with value Chrome.

To add TCP, right-click on Test Case and click on a small square shape with violet color (Create test configuration parameter…). Also, it can be created by pressing on “Ctrl+N, Ctrl+.”. Click here to learn more.

In the below screenshot, we have changed the previously created Test Case with TCP as a part of parameterization.

• Step1: Create Test Configuration Parameters to store the test data.

• Step2: Create buffers to store the values of TCP. This is an optional step; through this step, we try to show the usage of buffers as data parameterization.

• Step3: Replacing the hardcoded test data from the test case with buffers.

Note: In this section, we have learned about the basics of parameterization. In the advanced level of Tosca, we will learn advanced parameterization techniques such as TCD, TDM, TDS, etc.

Tosca Library

The Tosca library, available in TestCase section, is a place to store the reusable components of the test cases. The each element with in the Library is known as Reusable Test Step Block.

Test Step Block 

It is a grouping of test steps/ modules to perform some specific task such as login, logout, create record, etc. The test step block can be created using the Test case level folder. It helps to increase the readability and reduces the efforts for maintenance.

For an example, application launch functionality is involved with steps – invoke exe, enter user credential, and verify login. Here, we need to define a folder in a test case with a logical name as Launch Application and write three steps there.

Test Step Library –

This is the place, where we can create the reusable test step block. The Library can be created with in any folder available in TestCase section. But, there is a restriction that only one library can be created with in single folder. To create the Library, we need to right-click on any folder and select the folder icon(Create TestStep Library) which have the symbol “L”. Also, we can create the library using the shortcut keys Ctrl+N, Ctrl+L.

Reusable Test Step Block – When we defined a Test Step Block within the Test Step Library section, it’s acted as Reusable Test Step Block. We can create it in two ways –

1. New Reusable Test Step Block – Right-click on the Library folder and click on Create Reusable TestStepBlock icon(folder icon with a reusability symbol). Shortcut key for this – Ctrl+N, Ctrl+R. After the creation of the reusable block, we need to write the test steps here.
2. Convert Existing Test Step Block – By the drag-drop method, we can convert any existing TestStepBlock into Reusable TestStepBlock.

After the creation of Reusable TestStepBlock, we can drag and drop it into any Test Case to use. In the test cases, it’s only referred to as a link instead of physical steps. It can only be modified from the Library section.

Business Parameter –

It’s an approach to pass test data into the Reusable Test Step Block through the parameters. The parameters of the Reusable Test Step Block is called a Business Parameter. So, with the help of this, we can use the Reusable Test Step Block for a different set of test data. Steps to create Business Parameters –

• Right-click on Reusable Test Step Block and click on icon [P] to create Business Parameter Container.
• Right-click on this container, click on the blue-colored square icon to create each of the parameters.
• Rename the Parameters based on data type and implement it in the test steps by removing the existing data.
• Pass the data from the Test Cases through this business parameters.

Reusable Test Step Block structure with business parameters:

Test Case after calling the Reusable Test Step Block:

In this “Create Tosca Test Cases” article of Tricentis Tosca Tutorial, we have learned about how to create Tosca Test Cases and parameters.  Please click to read the next article of TOSCA Tutorial – Understanding of Tosca Execution List and Reports.

TOSCA Tutorial – Table of Content

The Tosca Tutorial are consists of below articles which are explained the different components of Tosca. While writing the article, we have considered the knowledge of entry level software tester so that they can understand this article easily.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

In this Tosca Modules with Tosca Scan article , we will discuss about the Tosca Scan procedure to create Tosca Module with brief descriptions of different terms. Step by step screens are attached for easy understanding of Tosca Scanning approach.

Tosca Modules

Concepts of Tosca Modules:

Tosca Modules keeps the technical properties of any control that is refer to any test object.

Basically, module creation is the first step to start with test case development in Tosca Commander. Module has to be created for the unit of functional block of the test application. These functional units are, for instance, pages or screens of test websites or any window applications. Any input fields such as buttons, text box, combo list, etc. are known as controls. The controls which are required for test execution, has to be captured in Module as ModuleAttributes.

Tosca modules are classified into below two categories –

·        Classic Modules – It is created by classic engines during the scanning. 

·        XModules – It uses XEngines which are based on the Tosca TBox framework. 

The each components of a module are known as ModuleAttributes and the components are known as controls. The Classic Modules have the classic ModuleAttributes, and on the other hand, the XModules have the XModuleAttributes.

Classic Engines: In the early phase of Tosca, Classic Engines are developed to processes the the TestCase information and steers the test object. There is respective engines are available to steer any test object.

TBox: The reference of Tosca Tbox framework algorithm is the basis for XEngines to steer any controls. Same can be applied to steer GUI and non-GUI objects.

XEngines: With the help of XDefinitions, the XEngines are defined in Tosca. The controls for the test objects are hierarchically structured through the XDefinition. So, the tree structure of the test objects are mapped with controls of any modules.

The Tosca TBox is compatible with the below engines:-

·        Tosca XScan 3.0 – After scanning the test objects (GUI or Non GUI), each time Tosca creates Modules which contains the technical properties. This technical properties are required to steer any test objects as controls. Scanning can be done from Modules sections only. So, modules are saved in “Module” section. We can scan any application by Right-clicking onto a Module folder and select the technology of the application such as, desktop, mobile, html, SAP, etc.

·        Tosca AnyUI Engine 3.0 –  It allows applications with user interfaces to be steered, independent of the underlying technology.

·        Tosca API Engine 3.0 –API Engine creates modules for application programming interfaces which is accessed through web service media.

·        Tosca Database Engine 3.0 – It allows to work with databases as a part of database automation.

·        Tosca DotNet Engine 3.0 – It allows WinForms applications to be tested that were built with Microsoft dotNET Framework 4.6.

·        Tosca Java Swing Engine 3.0 – It is used to scan the Java Swing applications for test automation.

·        Tosca JavaFX Engine 3.0 – It is used to scan the JavaFX applications for test automation

·        Tosca Java SWT Engine 3.0 – It is used to scan the Java SWT applications for test automation

·        Tosca JSON Engine 3.0 – JSON is the shorter form of JavaScript Object Notation which defines a compact format for data communication. Tosca JSON Engine is used to create, modify or verify the JSON.

·        Tosca Mobile+ Engine – It allows different types of mobile applications (e.g. web, native, hybrid apps) to be steered on both smartphones and tablets. For older version of android/ios, these engines are used for scanning.

·        Tosca Mobile Engine 3.0 – It is used to test mobile apps on both smartphones and tablets.

·        Tosca SAP Engine 3.0 – It is used to scan and test the SAP applications.

·        Tosca Webservice Engine 3.0 – Tosca Webservice Engine 3.0 allows Webservices to be steered via Hypertext Transfer Protocol (HTTP). Webservices using SOAP (Simple Object Acces Protocol) or REST Webservices (Representational State Transfer) can be steered.

·        Tosca XML Engine 3.0 – It is used to interact with XML data to change, create or verify the data.

What is the Standard Module?

With the workspace creation, Tosca provides few modules which are used to perform very common operations such that open file, invoke application, string operations, buffer operations, close application, verifications, etc. These modules are known as standard modules. The most important standard modules are – 

TBox Automation Tools:

• · Basic Windows Operations
• · Buffer Operations
• · Expression Evaluation
• · File Operations
• · Folder Operations
• · Numeric Operations
• · Process Operations
• · Resource Handling
• · Selenium
• · Timing

TBox XEngines:

• · Parameter Data
• · Database
• · Html
• · File, XML, JSON
• · Mail
• · Mobile
• · SAP, Java
• · Excel
• · Pdf
• · Host

Test Data Service:

• · TestData – Find & provide record
• · TestData – Create & provide new record
• · TestData – Update Record
• · TestData – Move record to TDS type
• · TestData – Delete Record
• · TestData – Update type
• · TestData – Expert Module

Tosca Scan: 

Scanning through Tosca is an approach to create Tosca modules which contain all the technical information for any test application.

Step-by-step guide of Tosca Scan to create a module:

We can initiate Tosca scan either right-clicking on Module folder or selecting the dynamic menu Modules and click on Scan icon. In this application, we will learn the scanning with a sample web application. 

Tosca Scan – Classic Modules: 

Tosca wizard is a part Tricentis Tosca and used for classic scanning to create classic modules. Generally, for legacy applications which are not properly compatible for TBox Scan, we are using this approach of scanning. We can open the Tosca wizard as a standalone application from Start Menu or by selecting the option “Scan More->Legacy Scan” during scanning. Please click here to read more on this topic.

• Main Navigation Panel – Shows the scanned controls.
• Automation Property – Mandatary technical information about the selected controls.
• Scan – Start scanning of the entire region.
• Scan Region – Scan selected region.
• Create Module – Save to create a module for the scanned region. Classic modules are looking like below image – 

Tosca Scan – Tbox Module:

Tosca XScan is a part Tricentis Tosca and used for TBox scanning to create Tbox modules. During the scanning, we need to select the engines based on the test application. Scanning steps – 

• Step# 1: Go to Modules section and select scan path “ScanàApplication”.
• Step# 2: Select the test application from “Application Selection” screen and click on Scan button.
• Step#3: Xscan screen will be displayed. Here all the available controls are shown here along with technical properties of each of the controls. Based on the properties selected, the control is getting identified by Tosca. There are four different ways to identify the controls – 
  • Identify by Properties – Here based on the technical properties of the test object, controls are getting identified. Always we should prefer technical properties like name, id, class, test, inner text to recognize the controls in the application.If the properties are not enough to identify any particular controls, we should go for other “Identified by” options which are available in Tbox Scan.
  • Identify by Anchor – In this method, we need to identify the test object with the reference of any other object which was identified uniquely. It uses algorithm Shortest Path or Coordinate for referenced controls. Here, we need to follow the options after clicking on “Select on Screen” button.
  • Identify by Image – Based on the image view of the test object. We can allow Tosca to recognize the control. But this is not a preferred method, and it should have opted at the last when all other options are not able to recognize the test objects.
  • Identify by Index – Index is basically the number of occurrence of the test object. It’s denoted by numeric value, starting with 1.We can highlight the selected controls using the “Highlight selection” option. Also, we can directly select a control from the application itself by choosing the option “Select on Screen”. Once the object identifies uniquely, we need to click Save or Finish Screen icon (available in the left top) to create a module.
• Step# 4: Click on “Finish Screen” to clear the current scanned information. After this, click on Start Screen option to start afresh scanning of a new page.

Conclusion

In this article of Tricentis Tosca Tutorial, we have covered about Tosca Workspace Creation so that we can start with working with Tosca Commander. Need more information, please click here to visit Tricentis Support portal.

TOSCA Tutorial – Table of Content

The entire Tosca Tutorial has been covered through twelve articles which are specified in the below table of content. The “Overview of Tosca Commander” article has been written in simple languages and concepts are explained with images so that any entry level tester can learn the process in a quick time.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

Through out this Tosca Commander & Tosca User Management article , we will explain about the overview of different components available in Tosca Commander along with Tosca user management – create, update, deactivate user. To get prepared for the Tosca interviews, please click here.

Tosca Commander

What is TOSCA Commander?

The primary component of this tool is the TOSCA commander which is used to test case development, maintenance and execution. The core features of the Tosca Commander are specified below – 

• Tosca User management to add, edit, remove users
• Scan applications to create modules
• Creation of reusable library
• Creation of test cases
• Parameterization of Test Data using TCP, TCD, TDM, TDS
• Maintenance of test cases
• Managing of Test execution

Now, we are going to briefly discuss different options available in Tosca Commander which are used frequently for different automation activities:-

PROJECT: 

• Info – It provides the details about the workspace.
• New – It is used for creating a new workspace.
• Open – We can open any existing workspace through this option.
• Settings – We can view/change the configurations of different Tosca components.
• Accounts  – We can log in to Tosca cloud through this option.
• License – We can configure the license through this instead of using License wizard.

HOME: 

• Search – We can search for any components which are available in Tosca workspace.
• Project – We can view the hierarchy of different Tosca components or sections.
• Scratch book – We can view the scratch book where the temporary execution logs are stored.
• Sections – We can open any particular section.
• Update all – If the workspace is connected with the common repository, we can sync the local copy of workspace with the common repository.
• Checkin all – Commit/push any changes which are done in the local workspace into the common repository.
• Checkout – Lock/reserve any particular root folder or components for an update. Through the checkout process, we can prevent other users from working on the same component.
• Checkout Tree – It will check out all the child components available within the selected folder.
• Import Subset – It is used to import any other subset or backup copy of workspaces.
• Export – We can export the workspace copy as a subset/ backup.
• Exploratory Testing – We can start the exploratory testing feature of Tosca Commander for scenario recording for testing or training purpose.
• Manual Testcase – It’s used to create manual test cases.
• Automated Test Case – It’s used to create automated test cases through recording.

TOOLS: 

Buffer Views – We can view the buffers which are created in the workspace. 

TEST CASES: 

The options available in these tabs are used for creating different components of test cases.

Create Folder –

It’s used to create any folder.

Run in Scratchbook –

We can execute any or part of test cases in the scratch book.  

API TESTING:

All the API Testing related options are available here. Please refer the API Testing section to learn more.

Sections of Tosca Commander: 

We are now going to understand the overview of different sections of the Tosca Commander, which are frequently used for test automation. Here all the sections have three parts –

• Left position – Navigation/Hierarchy of folder/components 
• Central position – Details of each selected folder/components, Test configuration (if applicable)
• Right position – Properties of each selected folders or components.

Components of Tosca Commander:

We will discuss more on the important sections in the related topics of this tutorial.

Project – It provides the hierarchy view of the different folders/ components, available in the workspace. 

Module – Modules (AUT objects map) are stored here.

Testcase – Technical components of any test cases are saved here. 

TestCaseDesign – The test data which are required to execute any specific test case, can be kept in TestCaseDesign section. This approach helps to manage test data in efficient and dynamic way. Also the technical components and test data can be isolated through this section.

Execution – Test execution management can be done through this section. We can define execution list, trigger execution and analyzing the execution logs to investigate any issues.

Requirements – Requirements related information is stored here. 

Issues – This section is used to maintain/ track any execution issues or bugs. Basically, defect management can be done through these options.

Reporting – Different kinds of standard or custom reports are stored here such as functionality coverage, execution status, requirement, bug status etc.

Test Planning – Plan and track all the testing activities as we work in Tricentis Tosca.

TOSCA User Management

In a Multiuser environment, the workspace data are stored in a central databases which is known as Common Repository. Multiple users should have the access to this repository. Here, Tosca User Management come into the picture to manages the users who are going to work with this workspace. The administrator has the rights to create, edit, delete any users. Also, access role can be defined for security purposes. To update data (modules, testcases, TDM, etc), first of all, user has to check out the component to restrict any other users to access it. After finishing the update, user has to check in the component to sync the update with the repository.

So, to connect the common repository, we need to provide access to each of the user .i.e. the administrator has to create individual users.

The below activities can be performed as a part of Tosca User management: 

• · Create, activate user and assign groups.
• · Assignment of roles.
• · Deactivating users.
• · Password reset.

Creating and activating user: 

Administrator has to follow the below steps to create and activate user – 

• Step1# Open the project window via Home->Project.
• Step2# Checkout root folder and switch to the Tosca User management tab. This shows all the user groups available with in the workspace.
• Step3# Right-click on any of the user group and click on Create User icon and enter details to create the user.
• Step4# Check the checkbox available in Enable column to activate the user. 
• Step5# drag and drop the user in a different group to assign a different role. Also, we can change the user level.

Deactivating users: 

Uncheck the checkbox available in Enable column to deactivate any user.

Password Reset: 

Right-click on any user and click on Set Password option to create/update password.

Conclusion

Through out this “Tosca Commander and User Management” article of Tricentis Tosca Tutorial, we have explained about Tosca Commander and Tosca User Management approach which will going to help to develop the test case. Please click here to learn from Tricentis Support portal.

TOSCA Tutorial – Table of Content

While writing the “Tosca Workspace Creation” tutorial, we have used simple explanation so that entry level tester can understand the concepts easily. The entire Tosca tutorial is broken into below articles –

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

In this Tosca Workspace Creation article , we will discuss about step by step procedure to create Tosca workspace to start our hands on Tosca Automation activities. If you want to prepare for TOSCA Interview Questions, please click here.

TOSCA Workspace Creation

About Tosca Workspace

The Tosca workspace is acted as a repository of requirements, test cases, modules, and other components of Tosca. To develop, maintain or execute the test cases, we need to connect the workspace first. Otherwise, we will not be able to perform any automation activities. Workspace is created in the local drive. The workspace has to be defined in local work system. But it can also be defined in shared network drive. The data of the Tosca workspace, can be synched with different databases (SqlLite, SqlServer, DB2, Oracle) which an be acted as a central repository.

In a multiuser environment, i.e. more than one users are accessing the tool, the Tosca workspace has to created in central repositories. Tosca allows to create the workspace in different databases such as Oracle, SqlLite, DB2, SQLServer etc.

In a Singleuser Workspace, only one user is able to connect and work with Tosca. So, the central repository is not required here.

In the Multiuser Workspace, the data management is more simple and easier as the data are stored in shared databases which are known as common repositories. To perform any transaction (add, edit, delete) in a multiuser workspace, we need to lock the corresponding records first. It will restrict any other users to manipulate the same records. After completion of the transaction, w need to unlock the records. In Tosca, locking of data is know as check out and unlock is known as check in.

Common Repository Location Types: 

There are six different location types available to create a common repository for multiuser workspace. Those are – 

• 1.     None – It’s applicable for single user workspace, i.e. no common repository is required.
• 2.     Tricentis Cloud Repository – If we select this option, then the repository will be created in Tricentis hosted cloud server. To create this type of workspace, we need to login to Tricentis cloud during workspace creation.
• 3.     SQLite – In this case, the repository will be created SQLite database. During the creatin, we need to specify 
• the SQLite path and the repository name(only for creation) during the creation of workspace.
• 4.     Oracle -Here, the repository has to be created in Oracle database. While creating the repository, we need to specify the Oracle schema name(optional) and the connection string  during the Tosca workspace creation.
• 5.     MS SQL Server – In this case, the repository will be created SQL Server database. During the creatin, we need to specify the database schema name(optional) and the connection string during the creation of workspace.
• 6.     DB2 – In this case, the repository will be created the DB2 database. During the creatin, we need to specify the database schema name(optional) and the connection string 
• during the creation of workspace.

Note: After creating of the common Tosca repository, we need to access the workspace using the default user “Admin” with empty password. But while connecting the existing common repository, the user credential should have created prior to the creation of local workspace by the Admin. Also, to work with databases, the corresponding database driver should be installed.

Steps to Create Tosca Workspace:

• 1. Open the Tosca Commander. 

• 2. Open new workspace creation wizard by the following navigation – PROJECT->New.

• 3.     Enter below details based on the availability of fields –
  • “Select type of repository” – applicable for single user workspace.
  • “Use existing repository” – Select the checkbox if the common repository is already available.
  • “Create a new repository in” or ”Select existing repository” – It’s required for SQLite.
  • “Select name for new repository” – It’s required for SQLite.
  • “Schema name” – optional field while using Oracle, SQL Server and DB2 database.
  • “Connection string” – Connection string to connect the selected database.
  • “Create a new workspace in:” – Localdrive path where to create the local workspace.
  • “Select name for new workspace” – This field specify the name of the workspace.
  • “Use workspace template” – We need to check this while creating a common repository to load the default components.

• 4.     In below example, we will be working with SQLite databases.

• 5.     After entering all the details, we need to click on “OK” button to create the workspace. This step will take few minutes to complete. After the successful creation of workspace, the window will close automatically, and user authentication popup will appear to login to the workspace.

• 6. After providing the default credential, we can open the workspace and start the working with Tosca Commander.
• 7. After launching the Tosca for the first time, UI view will looks like –

Conclusion

In this “Tosca Workspace Creation” article, we have explained about the steps of Tosca Workspace Creation process. It will help us to connect the workspace and start working with Tosca Commander. Please, click here to read more from Tricentis Support portal.

Summary of Tricentis TOSCA Tutorial

We have segregated the entire Tosca tutorial in to below articles. We have wrote this article(TOSCA Tutorial) in simple language and keep the article short with the required concepts only so that any entry level software tester can understand this article in a shorter span of time.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

In this article Tricentis Tosca Setup, we will discuss about step by step procedure to Install Tosca, uninstall and license configuration. If you want to prepare for TOSCA Interview Questions, please click here.

Download TOSCA

Trial Version:

1. Open Tricenties official site to download software.
2. Click on the “Request a Demo” button available in right top corener of the website available in section Tricenties Tosca.

• Enter the details in the form and click on “Request Demo” button to submit.

• Once the form has been submitted, Tricenties support team will contact you for the demo and understand the expectations. After that you will be able to request for trial version of tosca through email/ telephone.

Download for registered user:

Open the tricentis support portal and download the latest tosca version in your local drive. In this article, we will work with TOSCA 13.2 Patch Level 3.

INSTALL TOSCA

Basic System Requirement for Tosca Commander:

Hardware requirements:

• CPU: i5 Dual-Core 2.4Ghz
• RAM: 8GB
• Hard disk space: 10GB
• Network: 100 mbps

Software requirements:

• Microsoft® .NET Framework Version 4.8 (Win 7, Win 8.1, Win 10)
• Microsoft Visual C++ 2010, 2012, 2013, 2015.
• 32 bit or 64 bit(recommended) – both are supported by tosca.

For more details on system requirements for TOSCA installation, please visit tricentis support portal.

Installation Steps:

• Step#1: Click on Installation Setup file from local directory.
• Step#2: Accept License agreement and Continue.

• Step#3: After auto verification of prerequisites, click on Next to proceed.

• Step#4: Select Tosca Commander option for standard installation. But you can customize or installation based on the requirements. After the selection click on Next to proceed.

• Step#5: Change Installation paths if required and Next.

• Step#6: Please select the checkbox if you want to send the usage statistics to Tricentis. Click on Next.

• Step#7: Review and click on Install.

• Step#8: Accept if any popups and wait for installation to be completed.

• Step#9: Once done, please click on Finish to complete installation.

• Step#10: Open TOSCA Commander from start menu to verify installation.  

Uninstall TOSCA

During up-gradation of Tricentis Tosca it is strongly recommended to completely uninstall Tricentis Tosca and install latest version to avoid any unexpected errors.

Uninstall Process Steps:

• Step#1: Navigate to Control Panel and Click on “Programmes and Features”:

• Step#2: Select Tricenties Tosca and Click on Uninstall:

• Step#3: Wait for process completion and restart the system.

Tricentis Tosca License Configuration

• Step#1: Open the “Tosca License Configuration” wizard from the start menu.

• Step#2: Based on the available licenses, please select the desire option. And click Ok. Here we are selecting second option i.e. “Connect to Self-Hosted License Server”.

• Step#3: Enter the license server details and click on OK to complete the configuration. Default post should be 7070.

• Step#4: License Configured successfully.

• Step#5: For trial license, at step2, please select the first option and enter the user details which are created after registering in Tricentis portal.

Conclusion

In this article of Tricentis Tosca Tutorial, we have covered the setup of Tricentis TOSCA testing tool so that we can start with working with Tosca. Click here to understand more from Tricentis Support portal.

Please click to read the next article of TOSCA Tutorial – Complete Study of TOSCA Commander.

Tosca Tutorial

The list of articles on Tosca Tutorial are mentioned in the table of content which will be explain through out the entire Tutorial. All the the articles are written in simple languages with proper example which will help the entry level software tester to understand in short time.

• Tosca Tutorial #1: Tosca Overview
• Tosca Tutorial #2: Tricentis Tosca Setup – Install, Uninstall and License Configuration
• Tosca Tutorial #3: Tosca Workspace Creation
• Tosca Tutorial #4: Understanding of TOSCA Commander and Tosca User Management
• Tosca Tutorial #5: Tosca Scanning – An Introduction to Modules
• Tosca Tutorial #6: Tosca Test Case Creation
• Tosca Tutorial #7: Tosca Parameters and Library– Buffer, Business Parameter, TCP
• Tosca Tutorial #8:Tosca Test Execution, Reports, and Bug management
• Tosca Tutorial #9: Test Case Design – An approach to test data management 
• Tosca Tutorial #10: Tosca Test Data Management.
• Tosca Tutorial #11: API Testing in Tosca
• Tosca Tutorial #12: Tosca Interview Questions and Answers

In this article, we will start with TOSCA Overview. To get the flavors of Tosca interviews, you can check the most frequently asked interview questions with answers from here.

Tosca Overview

The purpose of this tutorial is to describe a complete and detailed overview of TOSCA as a test automation tool for beginners.

• Concepts of Software Testing:
  • Software testing is an important step to assure the quality of software products. It ensures that the requirements are fullfilled as per the expectations. Testing can be done in the different phases of Software development life cycles. Those are –
• Unit Testing – Done by software developer at the time of development.
• Integration Testing – After developing the different components, each of the components need to be integrated to make an unique product. After the integration, the integration testing is required to verify that the entire setup (includes all the software components) is working fine as a single product.
• System Testing – After the integration testing, the system testing is required to ensure the quality of the software.
• User Acceptance Testing –
  • It is one type of black box testing. The business team (end user of the software product) is responsible to perform this testing to verify that all the requirements are fulfilled.
  • The Software or application testing can be performed manually or through some automated approach. There is multiple test automation tool is available in the marked to automate the testing process. In this article, we are going to explain the overview of TOSCA as a test automation tool.
• What is Automation testing?
  • Today, the IT industry demands the quality and the efficacy with minimum human efforts to deliver any kind of IT services. Here, automation testing is playing a big role for testing services. Automation testing is a service to automate the testing process and scenarios to reduce the human efforts. In the automation vertical, the leading tools like QTP (UFT), RFT, and Selenium were consuming the major spaces. Now Tosca is giving tough competition to these tools.
• Why Tosca?
  • Tosca is one of the market leading tool in the present days. It has the ability to perform functional and regression testing as well. The API testing which has n important role in AGILE process, can be done through TOSCA. Now a days, marked demands lesser testing efforts and lesser training span on the tool. In this aspect, Tosca is best suited tool as it supports the script less testing which will consume minimum time to learn. Tosca user can write efficient test cases with minimum skill set. Also, it generates a standard test reports for the management with out much customization.

Tosca Key Features:

• Model-Based Testing Approach: This is the main features of Tosca as a test automation tool. Due to this Tosca is more suitable than other test automation tools which are available in the market. As a part of test case development, we have to create modules for each of the unit level functionalities. All the technical properties of test objects are stored in the modules which will be merged during the test creation along with test data.
• Risk-Based Testing Approach: The another important aspect of Tosca as it supports the risk-based testing approach. Tosca is capable of assess the risk with the test cases. Basically, it can identify the subset of entire test suite which will minimize the chances of risks. Once the execution is completed, risks are measured by considering the test execution result and the risk coverage.
• Script less test cases: Tosca supports script less automation which means that test cases can be developed by drag and drop method of modules in the TestCase section of Tosca. The test data parametrization and implementations of checkpoints, can be done through the configuration. So, anyone will be able to develop tests with minimum skillset and training.
• Dynamic test data:  The dynamic test data can be kept separately from the technical testcases. To achieve this, Tosca provides advance features such as, TDM, TCD, TDS etc.
• Easy to maintain:  If there is an application or data enhancement, same can be incorporated in the entire test suite by updating the modules or data in the central repository. The efforts spent here, is lesser with compare to any of the other test automation tools.
• Distribute Execution: It signifies about the distribution of test execution in multiple system to reduce the human efforts and execution cycle. Based on the configuration of distributed execution, we can schedule the test execution in multiple systems.
• API Testing: API testing is very useful when the entire application is not ready but some of the application components are developed. Using the API, Tosca is able to test the corresponding application components.
• Test Recording: Tosca is able to record test scenario to generates linear test cases along with checkpoints to save time. This feature is very useful for one time testing only.
• Detailed Reporting: Tosca generates step by step execution reports and logs with captured screens. The execution logs are very useful while investigating any errors.
• Mobile Testing: Tosca supports the testing of mobile apps in both android and iOS devices. For iOS testing, additional MAC infrastructure is required.
• Supported applications:  Tosca is compatible with different types of applications such as Salesforce, SAP, Web, Powerbuilder, DotNet, Mainframe, Mobile devices, etc.
• Integration with third-party tools: Tosca helps to integrate with third party tools with minimum customization such as Perfecto, Selenium, Azure, Jenkins etc.

TOSCA Architecture:

TOSCA is designed and developed by TRICENTIS Technology & Consulting GmbH (An Austrian Software Company based in Vienna). The test tool TOSCA have the below interfaces –

• GUI – The Graphical User Interface
• API – Application Programming Interface
• CLI – Command Line Interface
• Integrated Test Management

The latest version of TOSCA Commander which is available in the market is 13.3. The main components of Tosca are mentioned below –

• Tosca Wizard
• Tosca Commander
• Tosca Executor
• Test Repository

TOSCA Commander: 

TOSCA commander is the core backbone of the tool to develop, manage, execute, and analysis of test scripts creation. Tosca Commander has the five sections which are used in most of the projects – 

• Module – All the Modules(keep the technical information of the test object) are stored in this section.
• Testcase – The technical components of any test cases are kept in this section.
• TestCaseDesign – This section is used to isolate the test data from the testcase in a well organized manner. The main intention of this section is not to touch the technical test cases to modify the test data.
• Execution – This sections keeps the logs of test execution results in execution list. Basically, it is used to manage the test execution.
• Requirements – All the requirements related information are stored in this section.

A detailed study of different sections is available in the next article.

Tosca Supported platform:

• Frameworks and programming languages: dotNet including WPF, Java, VB, Delphi.
• Web browsers: Firefox, Internet Explorer, Chrome.
• Application Development Environment: PowerBuilder.
• Host Applications: 3270, 5250.
• MS programs: MS Outlook, MS excel
• Enterprise Application: Seibel, SAP.
• Protocols and hardware: Flash, Webservices (SOAP),ODBC.

Conclusion

In this introductory article of Tosca overview, we have covered the overview of Tricentis TOSCA testing tool, Tosca Commander and Workspace. Please click here, to navigate to the Tosca support portal for more information.

Please click to read the next article of TOSCA Tutorial – Complete Study of TOSCA Commander.