T-Plan Robot Documentation

1.Document Collection #

All documents listed below are bundled inside the distributed T-Plan Robot Enterprise binaries and they are available locally from within the product through the Help links and buttons.


Release notes contain installation, execution and migration instructions, dependencies, platform support, known issues and notes on compatibility with previous versions.
User Guide and Tutorial covering all aspects of Getting Started through to Reporting etc.
The Command Line (CLI) Reference lists command line options supported by the T-Plan Robot Enterprise binary. The same options are also accepted as parameters of programmatically created automated testing threads.
The TPR Language Reference is a complete specification of the TPR test script language supported by the latest release of T-Plan Robot Enterprise. Its goal is to provide a complete syntax and functionality reference to those who write automated test scripts using this tool and its testing framework. As the scripting language is tightly coupled with the Java Test Script API, it is also intended to provide a complementary functionality reference for design of Java test scripts.
The GUI Reference provides help related to components of the T-Plan Robot Enterprise GUI, such as the main menu and tool bar, script editor, tool panel, desktop viewer and standalone windows and dialogs.
The Java API reference comprises of Java development manuals and a JavaDoc collection built from the Java source code comments. It provides information on writing of Java test scripts and customization procedures.
Integration Reference describes integration with T-Plan test management products, especially with T-Plan Professional.

For all other information including videos, FAQ’s, articles & white papers etc. These are available through the top level support page.

Yes No Suggest edit
Last updated on February 11th, 2019

1.7.Integration Reference #

Contents

1. Overview
2. Product Integration Guides
3. Generic Integration

1. Overview


This document provides a top-level summary information on how to integrate T-Plan Robot Enterprise with 3rd party solutions.

2. Product Integration Guides


This chapter lists existing integration guides for particular software products.

Product Name Description
T-Plan Professional T-Plan Professional (TPP) is a test management tool produced by T-Plan. It supports export of test cases to Robot test scripts, automation execution and result reporting. For details refer to the online integration guide.
Continuous Integration(Hudson, Jenkins) Our online T-Plan Robot Enterprise And Continuous Integration guide provides a instructions on how to integrate with Jenkins. The steps may be reused for Hudson.
Java IDE (Netbeans, Eclipse) There are no IDE specific plugins for direct integration with T-Plan Robot Enterprise. Robot’s project structure is however compatible with the one used by most IDEs and the project folder may serve as home of both the Robot and Netbeans/Eclipse projects. This enables development of Java test scripts and any supporting Java code in both environments in parallel.
Detailed instructions on how to set up a Netbeans development environment are maintained in our Developing Java Test Scripts document. The steps may be reused for Eclipse or another IDE.
AdderLink iPEPS AdderLink iPEPS – This document describes how to set up VNC connection between T-Plan Robot Enterprise and the AdderLink iPEPS KVM switch, for EPOS Test Automation.
HP ALM / Quality Center Integration Describes the setup, operation and features of integrating T-Plan Robot Enterprise with HP ALM / Quality Center. Please refer to the integration guide.

3. Generic Integration


The following Robot features, plugins and tools are suitable for integration with 3rd party solutions:

  • The Robot’s Command Line Interface(CLI) is designed to support easy generic integration:
    • To execute a script or schedule use the -r/–run option.
    • The System Under Test (SUT) can be specified at the start up through the -c/–connect and -p/–password options. The scripts may otherwise connect on their own using the Connect command.
    • Custom values can be passed to the script through the -v/–variable options.
    • On production of headless environments (terminal/rsh/telnet connections) use the -n/–nodisplay option to suppress the GUI.
    • The overall result of the automation is indicated back through the process exit code (0 is PASS, anything else is FAIL). For more details parse the XML report created by the script through a call of the Report command. It’s path may be set from the CLI through the -v option (-v "_REPORT_DIR=<targetDir>").
  • The TPR language provides a few commands suitable for simple integration:
    • The Exec command can execute a local OS command, for example to pass some data to another process through the CLI.
    • The File and Excel commands allow to read and write data from and to plain text, CSV or MS Excel files. This can be used for simple communication with another process.
    • The SendMail command sends an email from the script.
    • The environment (system) variables are seen in the script as the _ENV_ prefixed variables. For example, the Path variable on MS Windows is available as the _ENV_Path variable.
  • The Robot’s Java API is ideal for those who wish to integrate with a Java app or framework or to call custom functionality from test scripts:
    • Java test scripts can be started from any 3rd party Java app. To call the TPR code from Java create a wrapping Java test script and call the TPR file(s) using the run(java.lang.String) method.
    • Java test scripts can call any 3rd party functionality and are ideal to implement connectivity from test scripts to your framework. The classes may declare the parameters to create a user friendly GUI editor. The compiled Java code may be then packaged to a JAR file called test script plugin and plugged back to the TPR language through the Include and Run commands. This system allows you to mix Java and TPR code as you wish. For reference code examples see the free open source Extent Reports and SQL Database plugins on our Plugins web site.
    • Several Robot features can be customized at the Java API level through parameters and system properties.
  • The Utilities plugin delivers the FileControl script which allows to feed TPR or Java code to a running Robot instance on the fly. Your framework may provide the data and task flow and drive Robot to do the automation.
  • The Remote Control client allows to communicate with a running Robot instance over TCP/IP. It supports to perform basic script tasks such as start or stop test scripts, get the current execution status or kill the server. This functionality allows to build a distributed system which controls Robot instances on remote machines.
Yes No Suggest edit
Last updated on March 20th, 2019

1.7.1.HP ALM / Quality Center Integration #

Introduction

This guide provides instructions on how to setup both T-Plan Robot and HP Quality Center in order to integrate your automation scripts, allowing you to execute and view the results from the context of HP ALM.

HP Quality Center is a quality management software solution offered by the HP Software Division of Hewlett Packard. HP Quality Center is a component of the HP Application Lifecycle Management (“ALM”) software solution set.

The integration is achieved by utilising the VAPI-XP test type within Quality Center to launch console based applications i.e. T-Plan Robot.

T-Plan Robot is compatible with the CLI and even offers a “CLI Wizard” to help determine the correct required command and save as an executable file such as .bat. It is this that we will use to allow the integration to drive T-Plan Robot.

Setting up T-Plan Robot

Within T-Plan Robot there needs to be two aspects in place to allow the execution and reports to run successfully from and with HP ALM.

1 – ALM specific report output directory
2 – Generate a Script executable

Report Output Directory

Each T-Plan Robot script contains a “Report” command which allows to specify the output report format and location. The default location for script output is within the <projectDir>\reports\<custom> directory, however this doesn’t lend itself to the integration due to its dynamic nature. Instead we recommend to store your output files to a static directory of your choice which ALM will read from.

T-Plan Robot does allow for saving of multiple report files within a single “Report” command using a semi-colon separated list of filenames. We also recommend making use of the zip format output which will allow all associated output files to be uploaded to ALM post execution.

A sample report command might therefore look as follows:
Report “Results.xml;..\ALMReports\Results.xml;..\ALMReports\Results.html;..\ALMReports\Results.zip”

OutputPaths

NOTE: Relative paths for the report output are resolvable against the currently set “Output Path” of the Robot Project. Absolute paths are also accepted.

Test Script Executable

Within T-Plan Robot use the CLI Wizard located under the Tools main menu option to generate the script executable (.bat) file.

Complete the form as you need in order to successfully launch and run your desired T-Plan Robot script from the resulting executable file:

NOTE: As you can see, the resulting batch file will call the T-Plan Robot application and test scripts using the relevant files, therefore these all need to be accessible form the driving machine.

With the desired settings in place select “Save To File” and save the executable batch file in an accessible (shared) location.

Quality Center

To run the T-Plan Robot executable file (created above) from the context of HP ALM and correctly return the output results we need to configure Quality Center a particular way.

Setting up Quality Center

we have to create a “VAPI_XP” script using the following options…

Within the ALM “Test Plan” section, create a new test:
ALM_NewTest

Give your new test an appropriate name and set the type to “VAPI-XP-TEST”:
ALM_NewTest2

Ensure “VBScript” is selected as the Script Language and select Next:
ALM_NewTest3

Set the test type to “Console Application Test”:
ALM_NewTest4

Within the “Application Executable File” field enter the full path to the Robot script batch file (created using the Robot CLI Wizard earlie) and the click the “+” button. The entry should then be added into the bottom field:
ALM_NewTest5

Select “Finish” to complete the New Test wizard:
ALM_NewTest6

The resulting test script now has the ability to call the T-Plan Robot script executable in order to run the automated script. However in order for it to also correctly pickup the Robot automation results we need to amend the generated VBScript.

Select the “Test Script” tab for your newly created test:
ALM_VBEdit

The auto-generated VBScript ‘Sub’ code should be replaced with the following:

NOTE: The file paths for the XTools.run and the OutputReport commands (lines 20-24) should be set according to your Robot Project location

Save your code changes using the mini toolbar:

ALM_VBEditSave

Now that we have our new test prepared and able to run our T-Plan Robot automation script, we can now place that into a “Test Set” within the “Test Lab” section of ALM allowing us to initiate the execution.

Firstly you need to select or create a Test Set for which to link the script to:
ALM_NewTestSet

ALM_TestSetName

Next associate your test with the new Test Set by clicking “Select Tests” and then either double click or drag your Test from the right hand pane:
ALM_ShowTests

ALM_LinkTest

You are now ready to execute your T-Plan Robot automation scripts from HP ALM!

Test Execution

To perform an execution run from ALM, highlight the desired test and select “Run”:
ALM_RunTest

Ensure both options are checked for “Run all Test Locally” and “Enable Log” before selecting “Run”:
ALM_RunLocally

Upon completion of the execution run you should see confirmation of the status:
ALM_RunningConf

ALM_CompleteConf

Viewing Test Results

Clicking on the test in the Execution Grid opens the “Test Instance Details” screen, from here you can again see the status:
ALM_RunResult

Clicking the attachment icon gives you quick access to the output report for that instance, otherwise you can select the executions “Run ID” to open up the “Run Details” screen. Selecting the Attachments option on the left will then give you access to the T-Plan output report/files:
ALM_ResultReport

Summary

T-Plan Robot automated test scripts can be executed from the context of HP ALM through the use of the CLI. The results of said executions are then visible also directly from within HP ALM.

The above instructions allow you to setup both T-Plan Robot and HP ALM (QC) in order to achieve this functionality. The above steps are also potentially a starting point from where you can further edit and enhance the integration to suit. Perhaps you want to pass some parameters at run-time, perhaps you want to retrieve other files etc., by following the above principles this should all be possible.

Yes No Suggest edit
Last updated on February 11th, 2019

1.7.2.Continuous Integration #

Contents:

1. Introduction
2. CI Installation
3. Create Project
4. Integrate Project
5. Design Automation
6. Integrate Automation
7. Advanced Tips
8. Conclusion

1. Introduction

This document describes how to set up a Continuous Integration job that builds an application and executes T-Plan Robot Enterprise automated testing. The guide uses Jenkins as the tool of choice. Integration with Hudson is not covered but the steps are very similar.

2. CI Installation

Download Jenkins from: http://jenkins-ci.org

The native release is the easiest way to go. In this guide we will install native Windows release of Jenkins 1.563 on a Windows 8.1 system.

The native installer sets up Jenkins to start as a Windows service. This is not suitable for integration with Robot relying on the Local Desktop or iOS Mirror connections because the service won’t have sufficient privileges to start local UI applications. For the needs of our example integration we will have to disable the Jenkins service:

  1. Open Services:
    • Windows 8: Go to the Start screen and type “view local services”
    • Windows 7 and older: Open the Control Panel, search for Services and open “View local services” from the “Administrative Tools” group
  2. Double click the Jenkins service, stop it and set the Start Type to “Disabled”
TIP: For details on how to integrate Jenkins running as a service with T-Plan Robot see the Advanced Tips chapter.

To start Jenkins manually open a command prompt, change to the Jenkins install directory (typically C:\Program Files\Jenkins or C:\Program Files (x86)\Jenkins) and execute:

To open the Jenkins web interface open http://localhost:8080 in a web browser.

3. Create Project

For the purpose of this guide we will use a simple Java application developed with Netbeans. It displays a simple message window with a Close button. As the application is a Java one it will work fine on any Java supported platform such as MS Windows, Mac OS X, Linux, Unix or Solaris OS. You can download the application source code and its project from the following link:

Download the demo Java application (~20 kB)

You don’t need to have NetBeans installed for this example. You must only install Ant and Java Development Kit (JDK) if you don’t have it. These are needed for compilation and building of the sample Java project.

Install alternative #1: Use the Jenkins tools

  1. Click “Manage Jenkins” in the Jenkins home
  2. Click Configure
  3. Use the “Add JDK” and “Add Ant” buttons to install/configure JDK and Ant

Install alternative #2: Manual installation and configuration

  1. Download JDK and install it: http://www.oracle.com/technetwork/java/javase/downloads/index.html
  2. Download the Ant binary distribution (ZIP) from http://ant.apache.org and unzip it to the local hard drive, for example to "C:\Program Files\Ant"
  3. Put the "C:\Program Files\Ant\bin" folder to the system path and configure the JAVA_HOME variable:
    • Windows 8: go to the Start screen and type “system”
    • Windows 7 and older: open Control Panel and select System
    • Select Advanced System Settings -> Environment Variables, double click the Path variable from the System variables table and append a semicolon ; and the path to the variable value:
      <previous_path>;C:\Program Files\Ant\apache-ant-1.9.4\bin
    • Add a new System variable, the name is JAVA_HOME and the value is the JDK install path (for example C:\Program Files\Java\jdk1.7.0_51)

    • Restart Jenkins to pick up the system changes. If you started Jenkins from a command prompt close it and start a new one.
    • To verify the result open a command prompt (Windows+R, “cmd”) and execute “ant.bat”. The system must recognize the command. If there’s a message like “tools.jar not found” you haven’t set the JAVA_HOME variable properly.
TIP: If you have a NetBeans installation it contains an Ant instance you may reuse. Some NetBeans releases also contain a JDK. You must only configure the variables or add the locations through the Jenkins’ Configure page.

4. Integrate Project

The next step is to integrate the project of your application with CI (Jenkins). For simplicity we presume that the application is not under a version control (CVS, SVN etc).

  1. Click “New Item” in the Jenkins home
  2. Give the item a name, such as “DemoApp”, choose “Build a free-style software project” and click OK.
  3. Leave the Source Code Management option on “None”. You may change it to CVS, SVN or any other supported system as needed.
  4. Click “Add build step”. As Netbeans use Ant select the “Invoke Ant” option. Add two targets separated by a space:
    clean jar
  5. Click Save

The project is now set. To initialize the local project workspace we have to build it:

  1. Go to Jenkins home, click DemoApp and select “Build Now” from the left menu.
  2. In the Build History select the link to the build log.
  3. Select Console Output” from the left menu.
    • If the project is under a version control it should show success because Jenkins pulls the project from the server.
    • As our example does not use any version control the build will fail with a message that Ant can not find the build.xml file. Download the sample project and unzip it into the location mentioned in the log (typically <user_home>\.jenkins\jobs\DemoApp\workspace). Then go back to the project page and click “Build Now” again. This time it should succeed.

Congratulations, your demo Java project is integrated with Jenkins now! The further configuration is up to your needs now. You may set up Jenkins to build the project on a regular schedule. If the project is under version control you may also trigger builds after every source code change.

The next step is to design a simple T-Plan Robot automated test and integrate it into the build process.

5. Design Automation

Before we design the automated testing we have to choose the test environment configuration. T-Plan Robot supports a number of architectures that involve one or more machines and/or mobile devices. For an overview see the Supported Configurations tutorial topic.

For the purpose of this guide we will choose the simplest single-machine scenario. We will test the application on the Jenkins machine using the Local Desktop connection. The T-Plan Robot project with the test code can be downloaded here:

Download the T-Plan Robot test project (4 kb)

The test project is cross platform and it will work on any Java supported platform (MS Windows, Mac OS X, Unix, Linux, Solaris OS). Unzip the project archive and open the folder it contains using File->Open Project under the T-Plan Robot GUI. The project contains one test script (tpr/Jenkins.tpr) and one template image of the icon used by the Close button of the test application.

The script tests a very simple scenario:

  1. Start the demo application.
  2. Verify that the application started properly. This is achieved though searching the screen for the Close button icon.
  3. Click the Close button.
  4. Verify that the application shut down properly. The script ensures that the Close button is no longer visible.

If you set the variable APP_HOME variable (line #3) to the location where you unzipped the demo application you can execute the script right away. Requirements:

  • Java installed and put on the system path (presume you’ve already done it under 3. Create Project)
  • T-Plan Robot 3.5.2 or higher (or at least 3.5.2Beta from 19 May 2014 or newer) which introduced support of the "Exec kill" command. The script will also execute on older releases but it will not kill the application if it for some reason fails to close. The Jenkins build will then hang because it will wait for all processes to complete.

In order to produce a reasonable test report the script creates a few result objects. It creates an XML report at line 17. It gives the script a name and a number (line 23) and it creates two step results (lines 40 and 54) and a screen shot (line 41). To view the resulting report see the Test Results tree node of the Robot project or open the online copy here.

In the next step we will integrate the test script into Continuous Integration.

6. Integrate Automation

Integration with CI is enabled thanks to the T-Plan Robot command line interface (CLI). The most important options:

CLI Option Description
-r/–run <path> Execute the test script or schedule specified by <path>.
-c/–connect
-p/–password
Connect to a test environment. The password is optional and should be used only where required, such as for example for VNC Server connections. Connection can be also established directly from the script through the Connect command (TPR scripts) or connect() method call (Java scripts).
-n/–nodisplay Execute in the CLI mode without displaying the GUI. It is recommended for production environments because this mode consumes less system resources (CPU, RAM). This option is required for remotely started executions (telnet, rsh/ssh).
-v/–variable <name=value> Override a variable value. This option may be specified multiple times to override multiple variables. It is typically used to parametrize the script execution or to change the behavior through setting of the standard (predefined) variables. For example, to make the script save the report to C:\reports specify: -v "_REPORT_DIR=C:\reports"

To create the start command suitable for CI integration use the CLI Wizard tool. To start it select Tools->CLI Wizard in Robot:

  • “Test script -> choose Jenkins.tpr from the demo project
  • “File paths -> absolute
  • OPTIONAL: Set “Connect to” to “java://localhost”. This is not really needed because our script calls the Connect command to start the connection on its own.
  • OPTIONAL: Set on “Execute the script in the CLI mode”
  • OPTIONAL: We will further instruct Robot to store the report (test results) to a unique directory under the Jenkins workspace. To do so we will set the _REPORT_DIR Robot standard variable to a value like:

%WORKSPACE%\reports\%BUILD_NUMBER%

The WORKSPACE system variable will be set by Jenkins to the application workspace path. The BUILD_NUMBER one will contain the unique build number. For example, if the workspace is C:\Users\JohnDoe\.jenkins\jobs\DemoApp\workspace and the build number is 3 the report will be stored to: C:\Users\JohnDoe\.jenkins\jobs\DemoApp\workspace\reports\3

This will make the report available at the following URL. You may also navigate to the report from Jenkins through the Workspace link in the project’s (job’s) menu.

http://localhost:8080/job/DemoApp/ws/reports/3/results.xml

This allows you to send the test result URL by email after every build. This can be achieved through the Email-ext (Email Extension) Jenkins plugin. To enable valid URLs you will also have to go to Manage Jenkins -> Configure and set the Jenkins Location to a valid host name. For other report options see the Advanced Tips chapter.

  • Once you are done with the CLI Wizard click the Copy To Clipboard button.

To integrate the automation to the build process simply add a new build step:

  1. Go to Jenkins home, click DemoApp and select “Configure” from the left menu.
  2. Click “Add Build Step” in the Build section and choose “Execute Windows batch command”
  3. Paste the CLI command into the Command field.
  4. Save the changes and select Build Now. Jenkins will now build the application AND run the automation.
  5. The Jenkins build will succeed only if the build and automation finish successfully. It will fail if the build or automation fails. The test results will be stored to a unique build-specific folder in the Jenkins workspace and can be viewed in the web browser.
TIP: To debug the test script under Jenkins remove the -r and -n options from the command temporarily. This will make Jenkins start the Robot GUI without starting the automation. You may then execute the script manually in Robot and debug it. Jenkins will not complete the build until you close Robot.

7. Advanced Tips

Automation under Jenkins running as a service

Jenkins running as a service is typically restricted in two areas:

  1. The process doesn’t have permissions to start GUI applications. This prevents it from integration with Robot automation based on the Local Desktop and iOS Mirror connections. Other “remote” connections such as VNC Server (except for Local Desktop over VNC) and Android Over ADB can be integrated with Jenkins in the service mode provided that you start Robot with the -n/–nodisplay CLI option.
  2. The process usually runs under a user account with limited file system permissions. Impacts on Robot:
    • If there’s no valid user home folder the Robot process will fail to save changes to the user configuration file. You will see a few exceptions in the log but the program will continue using the default factory settings. As Robot stores the license key location to the configuration file you may see the process fail for a missing license. To work around this save the key file to the Robot’s installation directory from where it will be picked up automatically. Alternatively add a CLI option like:
      -o "config.licenseKeys=<license_key_path>"
      The -o/–option option may be specified repeatedly to customize preferences from the configuration file. Robot version 4.0 will address these limitations with the new --cfg and --licensekey options.
    • If the process has no permissions to create folders in the default system temporary location the application log service (Help->Log Viewer in the Robot’s GUI) will be disabled. All logs will be printed out to the terminal (command prompt) only.
    • If the process has no permissions to create files in the system temporary location the Robot process will crash or not work properly. It is necessary to grant the process at least these permissions.

Automated processes wrapped into a custom Java code (example) will require an extra step. Due to a limitation in Robot 3.5.2 and earlier it is necessary to set the cliMode field of the ApplicationSupport class as follows before the class is instantiated for the first time. When it’s omitted the ApplicationSupport constructor will throw a java.lang.ExceptionInInitializerError. This is fixed in releases > 4.0.

Linking reports to the Jenkins UI

The latest Robot report can be optionally linked to the project’s menu and header page:

The steps:

  1. Install the HTML Publisher Plugin
  2. The plugin unfortunately can’t handle report paths containing Jenkins build variables such as %BUILD_NUMBER%. It can only link to static locations in the project workspace. To work around this we have to make the Robot script create an HTML copy of the report in a stable directory. To achieve it add the following command to the Jenkins.tpr script:
  3. Select Configure in the DemoApp menu. Select “Add post-build action” and choose “Publish HTML reports”. Configure the parameters as follows:
    HTML directory to archive: reports\latest
    Index page[s]: results.html
    Report title: Latest T-Plan Robot Report
  4. Save the changes and execute the build to make the link appear in the menu.

8. Conclusion

With the steps above allow you will be able to integrate T-Plan Robot automated testing with the Continuous Integration tool of your choice. The principles of the CLI integration can be applied to integration with virtually any other framework.

The document does not cover other test environment configurations involving multiple test machines. These will be discussed later.

Should you have any question please contact the T-Plan Support team.

Yes No Suggest edit
Last updated on April 16th, 2019

1.7.4.Professional Integration #

Contents:

1. T-Plan Integration Overview
2. Tight And Loose Integration
3. Entity Mapping
4. T-Plan Professional Set Up
4.1 T-Plan REST Service
4.2 T-Plan SOA Service
5. Integration Overview
5.1 Import
5.2 Export
6. T-Plan Professional 7.0 Integration Overview
6.1 Configuration
6.2 Creating And Attaching Scripts
6.3 Automation Scheduling And Execution

1. T-Plan Integration Overview

This document describes integration of Robot with T-Plan Professional 7.0 (TPP) and higher as well as typical use cases and processes.

T-Plan Professional is a sophisticated test management tool designed around the V-Model principle. It is modular in design and it clearly differentiates between the Analyze, Design and Manage phases of the software cycle:

  1. The Analyze phase defines what to test and allows to gather and review the requirements from which the testing will be derived and define a set of test conditions (features to be tested). The point is to track major software requirements usually described by the formal documentation (such as Requirements Specification) to make sure they get addressed by QA.
  2. The Design phase focuses on how to test and creates a test specification hierarchy to model the test plan. A structure with test  scripts (also referred to as “test cases”) with detailed instructions represented by test steps are created in this phase.
  3. The Manage phase allows to plan when to test and deals with scheduling and test execution (both manual and automated).

Robot integrates with the Design and Management phases. While the Design phase clearly corresponds to the process of writing Robot automated test scripts, the Manage one deals with execution of automated testing and tracking of test results.

2. Tight And Loose Integration

The products support two approaches, a tight or loose integration.

A tight integration means that automation is fully managed through the T-Plan Professional GUI which is able to:

  1. Associate a script entity in Design with an automated test script and also to break such relation. It is in plain words possible to create a mapping like “this script entity is automated (or no longer automated) by this T-Plan Robot script”.
  2. Create an automated script template from the data in the T-Plan database and export it to Robot.
  3. Display a read-only view of the automated script and eventually start the Robot to edit the script.
  4. Execute automation in Manage for an automated script entity (or entities). Robot is started in GUI mode to execute each single script (sequential approach – no support of parallel executions in this version) and test results are automatically imported to the T-Plan database at the end of each execution.

There are three basic requirements on Robot automated test scripts to be eligible for tight integration:

  1. One Robot test script (a single file) must automate exactly one T-Plan Professional script. This is necessary because T-Plan Professional allows to associate script entities with automated scripts in 1:1 relation only.
  2. The automated script must have one of the registered extensions (.tpr or .java). As T-Plan Professional integrates also with other automated testing products, this requirement enables to identify the tool to handle the automated script.
  3. The automated script must be self connecting to the system under test (through the Connect command). As T-Plan Professional doesn’t maintain any information about available test environments, it is up to the script itself to get connected.

As T-Plan Professional is a strictly Windows application and integrates with locally installedRobot, tight integration is in fact available just on Windows. As Robot operates in a client-server mode, the system under test (SUT) may be still any of the supported server systems.

Loose integration on the other way allows to stand away from the T-Plan Professional GUI and work with the T-Plan test management products on the database level (through a SOA web service). T-Plan Professional in this mode doesn’t know about existence of automated test scripts; it is however able to accept and display test results from automation as long as they correspond to existing Design entities. Robot GUI supports approximately the same functionality as the T-Plan Professional GUI features discussed above:

  1. Automated script templates may be created in Robot through the Import T-Plan Script  window. It allows to connect to the T-Plan database, select a script entity from Design and create a template with the corresponding structure.
  2. Test results may be exported to T-Plan database either automatically through the integration CLI options or manually through the Export  Results To T-Plan  window. Test result source may be in case of manual import either data from recently executed scripts stored in the memory or an XML report saved through the Report command.

It is important to realize that tight and loose integration approaches may be freely and flexibly combined. Association of a Design script entity with an automated script gives you just the option to manage automation through the T-Plan Professional GUI. The same automated script may be also executed manually or through a scheduling system and the test results may be imported through the Robot loose integration features. There are no limitations applied to how you execute the automated testing.

Both approaches have advantages and disadvantages:

  • Tight integration provides a comfortable and seamless all-in-one solution. It was designed to support users who have followed the T-Plan process and they decide to start with automation. It is also suitable for beginners and on environments with a low number of systems under test.
  • Loose integration allows to take full advantage of Robot capabilities such as platform independence, extensive CLI and ability to test on multiple desktop servers in parallel. It is suitable for more advanced users and provides solution for automation across various operating systems and complex test environments. Ability to save results to XML allows to review the test results before importing them and it also supports scenarios with no connection to the T-Plan database (for example executing automation in an isolated environment or at the customer site). Loose integration is also convenient for those who already have automation in place and decide to take advantage of T-Plan management products to bring structure to their QA efforts.

3. Entity Mapping

The corner stone of mapping among the T-Plan Professional entities and PRODUCT_NAME automated test results are the Script and Step commands. They must be called in Robot automated scripts to produce recognizable test results and associate them with script entities in the T-Plan database.

The Script command labels the start or end of a particular script entity in a Robot automated script. It’s argument, the script number is a unique number assigned to each T-Plan entity at the creation time. To find out the number open the Design module of T-Plan Professional, select the script of interest and look for the Number field under the Attributes tab as is shown on the following picture.

The Step command creates result of a single test step. Step instances should be always placed into a script body (meaning between the Script start and Script end pair of commands). The command supports the same attributes as T-Plan Professional step entities such as Name, Instructions, Expected Result, Actual Result and Notes. It also defines step status (meaning result) which is one of:

  • Not Tested (“nt”) which is default,
  • Tested & Passed (code “pass”),
  • Tested & Failed (“fail”),
  • Not Available (“na”)

The overall script result in T-Plan Professional is derived from the step results. If there’s at least one failed step, the script result is Tested & Failed. See the T-Plan Professional documentation for  more information.

Steps in Robot automated scripts are in fact not associated with step entities in the T-Plan database. An automated test script may but doesn’t have to contain the same steps as the corresponding script entity in T-Plan Professional. The point is that automated testing may follow different steps to perform testing of a test case than the manual one. That’s why parity between Step commands and step entities in T-Plan database is not enforced and T-Plan Professional is ready to import any results based just on a valid script entity number.

The following picture shows an example of steps under the Script Instructions tab of a script in T-Plan Professional Design.

Both T-Plan Professional and Robot provide GUI tools to export the script entity data into an automated testing script template. See the following chapters. A short example of such a template for the script entity number 336 displayed on the picture above follows:

The template may be used as base of a new automated script. It is up to the user to add code snippets automating individual steps into the indicated empty lines, for example using the Script Recorder.

If the script entity structure gets updated on the T-Plan Professional side, for example some steps are added, updated or removed, the changes have to be applied manually to the corresponding automated script. The template may in such a case serve as a source of structure code for update of an the existing one.

Here is a fully functional example of a Robot script which automates the first step of the script entity number 336 displayed on the previous screenshots. If such a script is executed, it produces a result of the Logon step which may be recorded to the T-Plan database:

4. T-Plan Professional Setup

All communication between Robot and T-Plan Professional (respectively the T-Plan database) is realized through a web service built on top of the Service Oriented Architecture (SOA) technology as follows:

The service must be installed and running and both products must know its location (URL) to execute correctly any of the integration features.

4.1 T-Plan REST Service

For the latest instruction on the T-Plan REST service installation and operation please contact the T-Plan support.

4.2 T-Plan SOA Service

The T-Plan SOA service is a gateway to the T-Plan database used for all data exchange between Robot and T-Plan Professional 7. It typically runs on the same server as the T-Plan database. As it is a web service operating on the HTTP/SOAP protocol, it may be accessed over the network.

The server is delivered as a separate piece of software. Its installer is typically located under the Robot/SOA folder in the T-Plan installation bundle. There is no particular setting at the install time and the only prerequisite is to have the .NET Framework 3.5 SP1 installed. The server requires post-installation configuration as follows:

    1. Start the T-Plan SOA Service Manager application from the T-Plan menu group.
    2. Select the Configuration tab in the manager window and take advantage of the Install admin.xml button to configure the service with the T-Plan configuration file created during set up of T-Plan Administrator. If you don’t know its location, you may alternatively populate the Admin Server, Admin Database and authentication details manually in the fields provided. The server and DB names should be the same as the one displayed in the T-Plan Professional logon window. Select  Apply after you finish.
    3. Switch back to the Service Control tab and restart the service through Restart. The service by default runs on address http://localhost:4000 (when connecting to a local DB) or http://<yourservername>:4000 (when connecting to a remote DB over the network) . If the default HTTP port of 4000 is already used by another application, you may optionally change it to a custom one. The TCP port is not used by Robot and is reserved for other applications.You can leave the service account as Local System but it must be added as a SQL Server 2008 user with appropriate access to databases. Otherwise change the service account to a one that has ‘Log on as Service’ rights as follows:
      • Start Menu->Run->’secpol.msc’
      • Double click ‘Local Policies’ -> ‘User Rights Assignment’ -> ‘Log on as a service’
      • Add your account to the list.
    4. Close the manager window through Close but make sure the service is up and running and the Windows icon tray displays the T-Plan icon. You may double click it to reopen the manager any time.
    5. To test whether your configuration works correctly start T-Plan Robot Enterprise, open the Import or Export window and provide the SOA service address and credentials in the first screen. If you are able to proceed to the “Step 2: T-Plan Database” screen with the Next button, your service works properly and Robot is able to exchange data with the SOA service.

5. Integration Overview

Robot integration features support two basic tasks:

  1. Import of structure of a T-Plan Professional script entity into a Robot automated script.
  2. Export of test results from automation to a T-Plan Professional test suite entity.

Both tasks can be performed either manually through the GUI or automatically through the integration CLI.

5.1 Import

For automated import from CLI refer to the T-Plan Integration CLI Options chapter of the CLI Reference.

To import structure of an existing T-Plan Professional script entity from the Robot GUI follow these steps:

    1. Select Tools->Import T-Plan Script  in the main GUI menu. Alternatively open the File->New Test Script window and select Choose under the “Populate the test script with a structure imported from T-Plan Professional” option.
    2. The first wizard screen asks you to provide the SOA or REST URL and credentials to the T-Plan database (see the T-Plan SOA Service chapter). The second wizard screen allows to select the database name and group. The credentials and database details are equal to the ones you provide when logging on to T-Plan Professional. Be aware that Robot saves values provided in this screen to the configuration file so that you don’t have to enter them every time. As configuration is saved to a plain text file in your home folder, it is insecure to save the database user name and password this way. Deselect the “Save the credentials…” check box to avoid storing of user name and password if necessary.
    3. The third wizard screen displays the T-Plan Professional Design tree with available specification and script entities. Select a script to import from and hit Finish.
    4. The wizard opens the New Test Script window to define the script name, type (TPR/Java), location and path and report settings. Then it creates the test script and populates it with the template:

Be aware that there’s no functionality allowing to check structure of an existing automated script against its counterpart in T-Plan Professional Design. If the script entity structure gets updated on the T-Plan Professional side, for example some steps are added, updated or removed, the changes have to be applied to the corresponding automated script manually. The template may in such a case serve as a source of structure code (Step commands) for update of the the existing automated script.

Similarily there is no way to create a new script entity in Design from an automated script which must always refer to a valid script entity number. If you already have automation in place and you decide to create a corresponding structure in the T-Plan database, create it using T-Plan Professional first and then map the entities to automated scripts.

Future versions of both products may deliver improvements in these areas.

5.2 Export

For automated import from CLI refer to the T-Plan Integration CLI Options chapter of the CLI Reference. Be aware that the CLI doesn’t allow to export results from XML reports. This feature is currently available only in GUI.

To export test results from automation into T-Plan database:

    1. Select Tools->Export Results To T-Plan  in the main GUI menu.
    2. The first two screens are identical with the Import T-Plan Script wizard. The first one asks you to provide the SOA URL and credentials to the T-Plan database (see the T-Plan SOA Service chapter). The second wizard screen allows to select the database name and group. The credentials and database details are equal to the ones you provide when logging on to T-Plan Professional. Be aware that Robot saves values provided in this screen to the configuration file so that you don’t have to enter them every time. As  configuration is saved to a plain text file in your home folder, it is insecure to save the database user name and password this way. Deselect the “Save the credentials…” check box to avoid caching of user name and password if necessary.
    3. The third wizard screen displays the T-Plan Professional Manage tree with available test suite and script entities. There are three options:
      1. Create a new test suite in T-Plan Manage option will create a new test suite entity in the Manage tree to save the test results to. This option requires the New Test Suite Name field to be populated with a valid name. If you select a test suite in the tree, it will serve as parent node for the new test suite. Default parent is the root Manage node.
      2. Rewrite results of an existing test suite option will rewrite test results of an existing test suite entity. Any data contained in the test suite are purged first. This mode requires that a valid test suite node is selected in the tree.
      3. Append results to an existing test suite option will append test results to an existing test suite entity. This mode is intended to merge disjunctive sets of test results. If the selected entity already contains data for the same scripts and steps, this operation will lead to result duplication. This mode requires that a valid test suite node is selected in the tree.
      4. The last wizard screen allows to select source of test result data. There are two options:
        1. Export results from XML file(s). This option allows to define a list of XML files which were created by the Report command of previously executed automated scripts. Results will be exported in the selected order.
        2. Export results of previously executed script(s) offers a list of results generated by automated test scripts executed by this PRODUCT_NAME instance from the application start. This list is maintained just in the memory and all such results are discarded when the application exits (this doesn’t impact data saved to XML).

        Both lists provide a View Results button which displays the test result XML in a web browser. For test results stored in memory the tool creates a temporary XML file which gets deleted after viewing.

      5. Once you select at least one valid result source, select the Finish button to complete the export. If the operation is successful, the dialog is disposed without any confirmation message.

Be aware that the current implementations can export just Step command results and it is not possible to upload other automation output objects, such as screenshots, warnings and reports. It is therefore recommended to use XML reports alongside with T-Plan management software to preserve these output for eventual review. Future versions of both products may deliver improvements in this area.

6. T-Plan Professional 7.0 Integration Overview

This chapter describes GUI features of T-Plan Professional 7.0 supporting integration with Robot . The functionality is demonstrated on simple use cases. We presume that you already have created some data in T-Plan Professional Design module, in particular a test specification with at least one script and several steps. For more details refer to the T-Plan Professional 7.0 documentation.

6.1 Configuration

Before you proceed to the examples, make sure that Robot is properly configured in the Extensions section. To do so navigate to the Administration->Extensions menu in the T-Plan Professional GUI as follows:

If you don’t see the Robot Extension in the panel, right click the extensions list and choose the Robot Extension from the “Append to end of list” menu. If this item is not present in the there, create folder RobotExtn under C:\Program Files\T-Plan\Extensions\T-Plan (or your custom install directory) and retry.

T-Plan Professional populates default values except the SOA address from registry entries created by the T-Plan Robot Windows installer (HKEY_LOCAL_MACHINE\SOFTWARE\T-Plan\Robot). If you intend to integrate the tool with a standalone Robot ZIP distribution, you will have to fill in the extension data on your own.

  • The Robot installation path points to the installation directory. The default value is C:\Program Files\T-Plan\Robot. For the standalone ZIP distribution the path should point to where you unzipped the product.
  • Default suite number specifies the default Test Script node number in Manage to import test results from automation to. The value of -1 indicates that test suites should be created right under the Manage node.
  • The SOA address is an URL pointing to the SOA web service. The SOA must be executing in order to make the integration features work correctly in both products. See the T-Plan SOA Service chapter for details. If you are connecting to a remote test database, ask your T-Plan database administrator to get you access to the SOA.

Should you need to customize the way T-Plan Professional calls Robot (such as which Java environment should be used or how much heap memory is the application allowed to allocate), refer to the Integration With T-Plan Professional chapter of the Release Notes document for instructions.

6.2 Creating And Attaching Scripts

Now, let’s show the integration on an example. A typical view of the T-Plan Professional  Design module with data looks as follows:

Right mouse click on a script entity opens up a context menu. There are two items of interest:

  1. Create new Robot script creates a template of automated script from the selected entity and opens it in Robot . You will be prompted for the automated script file name. It is highly recommended to store the test script into a T-Plan Robot project to make it populated with the default path and report options. An association between the script entity and the automated script is also created and saved to the T-Plan database.
  2. Browse Robot script allows to browse an already existing automated script from the file system and create the association. Robot is not started in such a case.

When the context menu gets opened for an entity which already has an association, the menu items are different:

  1. Load this script in Robot starts Robot and opens the associated automated script for editing.
  2. Browse Robot script allows to break the current association and create a new one with another existing automated script from the file system.
  3. Detach Robot script removes the association from the T-Plan database. The automated script itself is not affected by this step and can be reattached any time through the previous menu item.

5.3 Automation Scheduling And Execution

To schedule execution of the script from the previous example select  Copy in the context menu in Design and paste the entity into a test suite in the Manage module. An example of the result follows:

To execute the associated automated script just select  Execute in Robot in the node context menu. This action may be also started from any higher level node where it executes all scripts in the selected subtree which are associated with an automated script. T-Plan Professional in this case starts the Robot GUI, executes the automated testing and imports the test results into the Automated Script Results tab.

It is useful to realize that while script associations are managed by T-Plan Professional, other integration functionality such as export of script entity structure or import of automated testing results are provided by Robot and T-Plan Professional just takes advantage of the Integration CLI to have Robot execute these tasks. The practical impact is that any task available in the T-Plan Professional menus may be also performed outside of T-Plan Professional.

Yes No Suggest edit
Last updated on April 16th, 2019

1.8.Advanced Recorder #

Advanced Recorder

User Guide

Summary

This document covers the workings of the new recorder functionality provided within the 4.1 release of T-Plan Robot Enterprise. It intends to describe each option available whilst also providing a guide on how to use the feature.

The feature has been completely redesigned from the ground up to offer a much more robust end product whilst providing a comfortable user experience along the way.

The main driver for this update was the fact that the previous recorder feature produced code that contained hard coded coordinates as a basis for any mouse actions that were performed and therefore recorded. This led many users to the wrong assumption that T-Plan Robot was a coordinate based application – which it isn’t!

The areas covered in this document are as follows:

  1. Pre-requisites
  2. Functionality

  3. Related Information

Pre-requisites

The Recorder is a standard feature within T-Plan Robot Enterprise and is therefore available to all users, almost immediately. In order to make use of the Recorder feature you must first ensure that you have a few certain things in place. Until you have the following in place the recorder option will remain disabled.

Firstly you must ensure that you are connected to a test environment. You can connect via several avenues including the Robot launch screen, the Robot menus or using the menu toolbar.

The recorder feature is available for all of the different connection types.

Secondly you must have a Test Script created and open in the editor, which in turn requires the presence of a Test Project.

Both a Project and Test Script can be created under the File menu option.

At least one Test Script must be open when the recorder is initiated as it will act as the target for the resulting code.

Functionality

Once all of the pre-requisites are in place you can start using the Recorder feature to automatically generate your script commands based on actions you perform against the currently connected test environment.

The following image shows a typical setup whilst connected to a mobile device. From here we are ready to start recording…

There are a number of ways to initiate the Recorder, these include:

    • Select Script|Record from the Robot menu
    • Use the keyboard shortcut: Ctrl+Alt+R
    • Select the Record icon from the Ribbon bar

The recorder offers three different recording modes. We will discuss each mode in turn throughout the following chapters.

    1. Interactive Mode
    2. Rapid Mode
    3. Legacy Mode

Interactive Mode

This mode gives the user great control at every stage of the recording process. Following each action performed against the live environment the user is able to define the exact commands and parameters that they wish to produce – all achieved through simple dialogs.

NOTE: This recording mode is not available when using the “Local Desktop” connection.

For this scenario we will select the icon:

This will invoke the recorder mode selection window providing the three options already mentioned. For this section we will continue with the first, “Interactive”, mode:

Once the recorder has been initiated it will then react to every mouse action you perform within the Desktop Viewer window or on your keyboard (as long as your mouse is over the Desktop Viewer to give it focus).

Keyboard actions will be posted directly to the script editor with no interaction required.

When performing a mouse action, i.e. Click, the first thing that Robot does is to analyze the current display:

The purpose of this analysis is to allow Robot to determine the best image template(s) to create. It does so using a complex algorithm to ascertain the best crop section which follows the standard best practises for template creation; keep as small as possible/needed while remaining unique. Remember also that the image template doesn’t always necessarily need to have any meaning in its own right.

For further guidelines on best practices please see our general help text and online tutorial.

Once Robot has completed this task internally it will present the suggested crop area along with some controls to customize the action further.

Along with details of the size and location of the cropped selection you will also see a few options, as follows:

Confirm the selected area and the click point are correct and continue.

Customize the resulting action based on the current selection. (Explained further below)

“Name”

This is the name you wish to give to the auto-generated Image Collection.

Existing Collections. Select this if you wish to append the new template to an existing image collection.

To explain each of these options a little further

Confirm:

Once you have confirmed the desired action Robot will proceed to apply the action to the SUT, create the Image Collection/template and also insert the required script command into the active editor.

Customize:

If you select to customize the action you will be presented with three sub options:

    • Skip – Will apply the click action into the SUT without recording it to your test script.
    • Cancel – Will discard the action completely. It will not be applied to the test environment, nor will it generate any code within your test script.
    • Design code with Component Capture – as it suggests, this will invoke the Component Capture wizard allowing you to customize the action that you wish to be recorded into your test script.

(For more details on this option please see the Component Capture section of the online documentation.)

Name:

When entering the name manually, should it match an existing collections name the field will be highlighted yellow.

The collection name can be entered as a single value or as a folder path using the standard OS path separator. For example in Windows you could enter “Apps\Web\Browser\”.

For instances where any folder does not already exist, it will be created otherwise it will be appended at the point of the lowest level existing folder.

Existing Collections:

Selecting the existing collections button will open a small dialog presenting the “Component Images” tree. This allows you to browse all available collections in which to add your new template images.

Should you manually enter or select an existing collection that already contains a similar image template you will be asked to confirm whether or not you still wish to create the new template.

You will notice that any keyboard actions applied during the recording process do not invoke any interactive dialogs; instead Robot immediately inserts the relevant script commands into the active editor. Additionally, Robot will insert a “wait” parameter in any command immediately prior to the “Type” or “Press” command.

TIP: When applying keyboard actions ensure the mouse pointer remains within the bounds of the Desktop Viewer window in order that the SUT retains the focus and therefore also remains the target of the action.

Rapid Mode

The ‘Rapid’ mode allows you to concentrate initially on the task at hand, which is to quickly and efficiently record the actions you perform against your test environment such that they can then be replayed thereafter. It does so without interruption instead presenting you with the option to customize the recorded data upon completion.

Given the nature of testing on the “Local Desktop” this is the default recording mode when using this connection type. For this same reason the “interactive” mode is not available under the “Local Desktop” connection.

Once connected to your desired test environment the recording is initiated in the standard ways, as listed previously.

Once “Rapid Mode” selection has been made you can immediately begin to perform the desired actions against the SUT.

As the name suggests there will be no interactions or popup dialogs presented by Robot, allowing you an uninterrupted session to record your test.

TIP: When using the “Local Desktop” connection you must press RIGHT CTRL to end the recording session and return to the Robot UI.

When you have completed your recording session Robot will display the “Recorder History” window in the right hand pane.

The Recorder History pane also links in with the script editor such that when a line of code is clicked it will not only be highlighted itself but will also display the related captured image(s). Similarly, selecting a captured image on the right will highlight the related line of code in the editor.

The Recorder History panel is presented in a tree view which contains a folder for each recording session performed within the current Robot session. Within each folder it will list each image collection that was generated during the recording.

Within the Rapid mode the image collections are automatically named based on the convention:

Click comp<mmdd>-<n>

The mini toolbar offers just a few options, namely the ability to Delete the selected image collection.

Delete the currently selected image collection.

Quick access to the Script Recorder Preferences.

Open the Recorder feature Help text.

Close the Recorder History panel.

Upon selecting Delete, you will be asked to confirm this action before the data is permanently deleted.

Below the image collection tree you will see a preview thumbnail of each image template that was automatically captured during the recording process for the currently selected collection. This may range from a single template, as below, to a number of templates.

If Robot detects that the clicked item can be displayed differently under certain states it may attempt to capture of these. For example, a button can have various states such as natural, hovered, pressed, etc.

Although Robot captures these various image templates based on a complex intelligent algorithm they may require slight modification to ensure they are as you need. Changes can be made by clicking the image preview or selecting the “Edit” button:

This will open the “Template Preview” window where you can adjust or reselect the desired template area. Here you can also set/reset the click point as required. Once complete select “Save & Close”.

Similarly, you may find that Robot occasionally captures additional or unwanted template images. These can easily be removed from the collection by selecting the “Delete” button below the relevant template preview.

Finally, the bottom pane displays the actual script command that was generated by the recorder for the currently selected collection.

As always any generated code can be edited at any time directly in the script editor window, using any of the scripting aids and wizards. Additionally, the command can be edited from the context of the Recorder History window by selecting the “Update” button.

This will invoke the properties for the command allowing you to adjust any parameters as required, including perhaps the search area, tolerance level (“passrate”), etc.

Legacy Mode

This mode reuses the pre 4.1 recoding mechanism.  It records mouse and keyboards actions directly into the script editor with no interruptions or popup interactions. All mouse actions that are performed against the SUT during the recording generate script commands that are based on the mouse location using a coordinate approach.

This mode is generally used where the AUT is stable in terms of its layout and design.

Any changes that are required for the captured commands are achieved through the script editor window using he standard scripting aids and wizards.

As the “legacy” mode produces code based on the “Mouse”, “Type” and “Press” commands there is no built in mechanism to ‘wait’ for something to occur, therefore, this mode also inserts a “Wait” parameter for each command thus recording and eventually executing your actions in real time.

Any required image/text comparisons, verification points or screenshots should be inserted after the recording and can be generated using the standard menus and scripting aids.

Related Information

New Scripting Command

Along with the new recorder feature comes a brand new scripting command – “Click”.

The Click command offers a much simplified method of searching for an item and then clicking it, when using either of the image, text or object search types.

Previously a simple ‘find and click’ action required the combination of firstly the search (waitfor/compareto) followed then by an If/Else statement to handle the success or failure outcomes, with the “Mouse click” command within the relevant branch such as:

All of this code can now be replaced with a single simplified command as follows:

The Click command supports the same search parameters as the regular “Waitfor” and “Compareto” commands. It can also be employed with either the image, text or object search methods. All of the parameters and options can be applied and edited through the new “Click” command Properties dialog – see below.

New “Click” Command Properties Dialog

Along with the addition of the new “Click” command comes a new corresponding properties dialog allowing you to create or amend any aspect of the command through a point and click action as opposed to worrying about the code syntax should you make the same changes directly within the code editor.

The “Click Properties” dialog is essentially split into two main sections, as highlighted below. The top section relates to the search options – what you want to find on the screen. Select the desired tab to set the search type (Image, Object or Text) and view all of the corresponding options and parameters.

The bottom section then handles the subsequent click action should the preceding search succeed.

Yes No Suggest edit
Last updated on July 10th, 2019

2.Product Change Log #

2.1.Change Log 5.0.x #

This document describes new features, changes and bug fixes delivered by T-Plan Robot Enterprise 5.0.x releases.

Contents:
Version 5.0.5 Updates
Version 5.0.4 Updates
Version 5.0.3 Updates
Version 5.0.2 Updates
Version 5.0.1 Updates
Version 5.0 Overview

The latest public release available: T-Plan Robot Enterprise 5.0.5.


Version 5.0.5 Updates

T-Plan Robot release 5.0.5 delivers a number of key updates and bug fixes.
It is recommended that anyone running 5.0.x upgrades to this release.

Bug Fixes:

RB-226 Leave Robot in the task bar when recording on Local Desktop
RB-224 Add File preference to disable file back up
RB-223 Browser command to display a syntax error on an invalid Xpath
RB-222 Expose Selenium element attributes to the script
RB-221 Make the GoogleVision Test button display failure details
RB-220 Configure Selenium not to dismiss alerts automatically
RB-219 Wrong OCR results window title
RB-218 Update the license terms for HC Robo
RB-217 Enable division producing non-terminal numbers
RB-216 String operators such as “startswith” may fail when the argument is a number
RB-215 NullPointerException pop up from Java test script compiler
RB-214 Robot GUI hides on Linux even if it is not on the automated screen
RB-213 The ‘exists’ operator is broken
RB-212 Press Ctrl gets converted to Press CONTROL by Properties window


Version 5.0.4 Updates

T-Plan Robot release 5.0.4 delivers a number of key updates and bug fixes particularly in relation to the Browser command and the iOS over Xcode connection.
It is recommended that anyone running 5.0.x upgrades to this release.

Bug Fixes:

RB-207 Unexpected results of numeric expressions working with large numbers
RB-206 Mouse click at “search2” coordinates reports syntax error
RB-205 Lift the scaled Local Desktop limitation for Java 8 and non-Windows environments
RB-204 Make use of local new line character optional for the File command
RB-203 Excel find stops at cell throwing a formula error
RB-202 Excel command fails to preserve existing macros
RB-201 “Excel find” with plain text matching fails to evaluate formulas
RB-200 Loading of a project containing a shortcut/symbolic link fails
RB-199 Detect library conflicts and display a warning
RB-198 Memory issues with iOS video over USB on Mac Mojave
RB-197 Support HTTP redirection when loading online resources
RB-196 Can not connect iOS Over Xcode through the Connect command
RB-195 Stale comparison log shown in the log and Image Doctor pop up
RB-194 Repeat the Browser action for stale or not yet visible elements
RB-193 Suppress status bar error notifications for Browser Open
RB-192 Chrome crashes on typing to a non-text web element
RB-191 XML report corrupted by an unsupported character reference
RB-190 For syntax fails for trailing spaces
RB-189 Resolution of nested variables fails


Version 5.0.3 Updates

T-Plan Robot release 5.0.3 delivers a number of key updates and bug fixes.
It is recommended that anyone running 5.0.x upgrades to this release.

Bug Fixes:

RB-188 Enforce a minimum timeout between keyboard operations
RB-187 Make local clipboard set operation synchronous
RB-186 Batch file executed with Exec fails for paths with spaces
RB-185 Set off zip bomb protection in the Excel command
RB-184 Package ADB libraries with Robot
RB-182 GUI freeze after clicking OK in Interactive recording mode
RB-181 Command key not working on Mac OS X Mojave
RB-180 Local Desktop keyboard mapping fails on Mac OS X Mojave
RB-179 Robot for Mac fails to start with JRELoadError on Mac OS X Mojave
RB-177 Android over ADB connection fails to load the tplanrobot DLL
RB-176 Improve handling of large Excel files
RB-174 Can not delete license session with License Manager
RB-173 Missing string in “File create” property window
RB-172 Use local system new line character when writing to a file
RB-171 Improve iOS Over Xcode on Mac OS X Mojave and Xcode 10
RB-170 WebDriverAgent v4 fails to compile on Xcode 10
RB-169 Paused script may fail to stop from the GUI
RB-168 Java test script executed from TPR fails to pause properly
RB-167 Excel file viewer fails to display type of selected cell
RB-166 Failure to execute included Java code in the GUI mode
RB-165 Script and project file navigators crash on directories with a symbolic link
RB-164 Make the File command skip the leading BOM character
RB-163 Remove/hide “Legacy” recording mode
RB-162 Edits to a Code Template created via a ‘copy’ are reflected in the original (source)
RB-158 Performance improvements
RB-157 Excel set must init new cells with the row or column format
RB-156 Android over ADB connection broken for Android 9
RB-155 Excel fails to copy merged cells properly
RB-152 CLI Wizard “run from the project folder” problem
RB-151 Excel Copy&Paste between different formats fails
RB-150 Sendmail command to support the CC and BCC fields
RB-149 Commented lines with indent can not be uncommented
RB-148 The Find in Path window must open files in the UTF-8 encoding
RB-147 Set the Local Desktop connection to always use stored keyboard layout by default
RB-138 Excel command properties window displays default values if variables have been used
RB-124 Local Desktop fails to map the # character on German keyboard


Version 5.0.2 Updates

T-Plan Robot release 5.0.2 delivers a number of key updates and bug fixes.
It is recommended that anyone running 5.0.x upgrades to this release.

Updates:

  1. Encryption of config files that store passwords (RB-133)
  2. Enable support of OpenJDK 12 (RB-84)
  3. Support connections to the License Server through a network proxy (RB-108)
    Proxy settings should be supported within the UI and also via CLI.
  4. Enable editing of the CLI Wizard start command (RB-144)

Bug Fixes:

RB-146 Help in the Browser command context menu fails to open
RB-145 Make the Browser command wait between connections
RB-142 Selenium driven Chrome crashes for JavaScript alert pop up
RB-141 Waitfor command does not work with “text” method
RB-140 Incorrect _WEB variable count and indices
RB-139 Executing multiple Excel commands via a Run command fails with compile error
RB-137 Tesseract 4.0+ compatibility issues
RB-136 Invalid network shortcuts cause recurring popup in Robot
RB-134 Custom font size is not applied to variable values


Version 5.0.1 Updates

T-Plan Robot release 5.0.1 delivers a number of key bug fixes.
It is recommended that anyone running 5.0 upgrades to this release.

Bug Fixes:

RB-132 Tolerate abundant “Excel close” and “File close” calls
RB-129 The “File open” command fails to view the file from the context menu
RB-128 Excel select populates cell variables for non-existent cells
RB-127 Variable value dialogue does not open
RB-126 NPE thrown by Java test script on processing of compiler errors
RB-125 Connection Manager data fails to load for an empty RDP server name
RB-123 Incorrect stack displayed in history logs
RB-121 External links are failing
RB-120 Overwriting image template without making any changes resets click point back to original location
RB-119 Java converter Issue
RB-117 If doesn’t handle empty strings in expressions properly
RB-116 If reports syntax error for string operators of “exists” or “endswith”


Version 5.0 Overview

T-Plan Robot release 5.0 delivers a number of new key features along with bug fixes and updates to existing functionality.
The highlights of these updates being the enhancement of OCR capabilities with integrations to both ABBYY and Google Vision and the ability to now perform object identification of web browser elements through the Web Driver integration.

New features:

  1. Support for Google Vision API (RB-86) – More Info…
    Version 5.0 introduced support of Optical Character Recognition (OCR) through the Google Vision API cloud service.
  2. Switch Robot help to the online docs (RB-73)
  3. Enable ABBYY network license (RB-54)
  4. Selenium WebDriver integration (RB-6) – More Info…
    Version 5.0 delivers integration with Selenium WebDriver to enable combined image based and web browser automation from a single script.
  5. Support of ABBYY Fine Reader 12 OCR engine (RB-5) – More Info…
    Version 5.0 introduces support of ABBYY Fine Reader 12 which is a prime OCR engine featuring higher speed and better results (accuracy) than the free Tesseract OCR one. It is a commercial product which is offered by T-Plan Ltd at an extra cost.

Updates:

  1. Variables Tab to display local variables (RB-111)
  2. Browser Find commands do not “wait” for items to display (RB-75)
  3. Update the packaged POI (Excel) library to the latest available (RB-66)
  4. Variables table to be searchable and sortable (RB-18)

Bug Fixes:

RB-114 NullPointerException thrown on selection of a template in the Code Templates window
RB-113 File command ignores the encoding preference
RB-112 Copying a Code Template should force a new shortcut key to allow saving
RB-110 Can not stop script when connection waits for a license
RB-107 Robot for Mac OS online update issues
RB-106 License Manager displays wrong license server version
RB-96 GoogleVision account authentication is not verified in Preferences.
RB-37 ABBYY OCR matched text bounding box incorrect location when search area is defined

Yes No Suggest edit
Last updated on August 15th, 2019

2.2.Change Log 4.4.x #

This document describes new features, changes and bug fixes delivered by T-Plan Robot Enterprise 4.4.x releases.

Contents:
Version 4.4.7 Updates
Version 4.4.6 Updates
Version 4.4.5 Updates
Version 4.4.4 Updates
Version 4.4.3 Updates
Version 4.4.2 Updates
Version 4.4.1 Updates
Version 4.4 Overview

The latest public release available: T-Plan Robot Enterprise 4.4.7.


Version 4.4.7 Updates

Release 4.4.7 delivered a new expression evaluator to introduce additional operators and enable support of ‘functions’. You can easily switch between the new evaluator and the legacy one within the Preferences/Language screen.

Bug Fixes:

RB-109: Expression evaluator design limitations
RB-105: RDP connection fails with library load error
RB-103: Numeric expressions with unary minus are not calculated properly


Version 4.4.6 Updates

Bug Fixes:

RB-103: Numeric expressions with unary minus are not calculated properly
RB-102: Change of click point in image editor fails to enable the Save button
RB-100: Failed to parse XML report for RAP synchronization purposes
RB-99: RTF text copied to clipboard gets corrupted if not in UTF-8
RB-98: Failed to retrieve text from PDF copied into Local Desktop clipboard
RB-97: OCR text search pop up contains wrong result summary
RB-95: Java code blocks fail to execute on JDK 11
RB-94: CLI execution does not stop properly with CTRL+C


Version 4.4.5 Updates

This release addresses a high priority bug causing blurred images to be retrieved by the Local Desktop connection on Java 9 and higher (RB-90).
The release has also been updated to meet the upcoming OpenJDK 12 changes. Compatibility with Java 12 will be confirmed shortly after the JDK release, planned tentatively for March 2019.

Bug Fixes:

RB-92: Failed to open project Java script referenced by the Run command
RB-91: Export Comments displays an error when there are no comments
RB-90: Local Desktop produces blurry image on Java 9+
RB-89: The Text Hits window skips lines with the same text


Version 4.4.4 Updates

New features:

  1. Enable support of OpenJDK 11 (RB-79)
    Robot was updated to be OpenJDK 11 compatible. Standalone plugins distributed separately from the Robot releases will be verified against JDK 11 soon.
  2. RDP updates (RB-77, RB-79)
    The RDP client was updated to support connection to the latest Windows 10 systems. Additional improvements and features:

    • Network Level Authentication (NLA)
    • Clipboard transfer
    • CLI option driven features such as auto reconnection and support of shared paths (path redirection, drive mapping)
    • Setting of the CLI options from the script using the _RDP_OPTIONS variable
  3. Option to save Recorder History information (RB-60)
    The data from script recording sessions may be saved to a dedicated project folder and preserved across Robot sessions.
  4. Excel command to support copy & paste of cells (RB-59)
    The Excel command was enhanced with the “copy” and “paste” actions allowing to copy data (cells) and paste them to another position, sheet or even Excel file.
  5. Repeat failed image comparison for another cursor position (RB-43)
    The image comparison commands such as CompareTo, WaitFor, Click and Drag were updated to move the mouse and retry on a comparison failure. This is to address failures to find components on the screen caused by presence of the mouse pointer over the target location. The feature is off by default and must be enabled in the Execution screen of the Preferences window.

Bug Fixes:

RB-83: The TPR compiler refuses variables with trailing back slash
RB-81: Make the RDP progress messages localized
RB-76: Capture throws NPE for an empty template image crop area
RB-74: Excel select called from Java fails to evaluate cell formula
RB-71: Scripts executing on Windows 10 Local Desktop pause without reason
RB-70: Scheduler does not work with tprs containing Japanese characters
RB-69: Failed to discard script backup at startup
RB-68: iOS Over Xcode: WDA crashes for an object not being KVC-compliant
RB-67: Android Over ADB connection failure
RB-65: ClassNotFoundException thrown when executed from TestNG
RB-64: Issues recording and executing high-resolution environments
RB-63: Recorder generating incorrect command for a right click action during Local Desktop recording
RB-62: Deleting Click entries in the Recorder History pane should not collapse the tree
RB-61: Tesseract OCR detector issues
RB-58: String split ignores empty values
RB-57: Unable to “open referenced file” if parameters are defined
RB-56: GUI delays caused by Java test script compilation
RB-55: NPE thrown when evaluating a variable value
RB-51: Highlight tabs of modified script editors
RB-50: Large schedule rendering issues
RB-47: Unlocalized messages in Preferences->Debugging Tools
RB-46: Failed to open encrypted release descriptor
RB-45: Attempt to connect to RDP Server from Win Server 2012 crashes Java


Version 4.4.3 Updates

New features:

  1. Print out execution history logs to terminal (RB-30)
    The history log delivered in 4.4.2 was enhanced with an option to print out the history logs also to the console/terminal. The messages are printed out on the fly as they are generated without any limits. This is useful for integration with 3rd party frameworks which observe the output. For details see the Log command.
  2. Rotate the iOS Over Xcode screen on the F4 key (RB-29)
    Press the F4 key to rotate the screen manually or from a script on the iOS Over Xcode connection.
  3. ADB connection to support simulation of “Recent Apps” key press (RB-26)
    To bring up the “Recent Apps” screen on the Android Over ADB connection use the middle mouse click or press the INSERT key.
  4. Schedule to reflect failed tasks in the exit code (RB-25)
    Schedules executed using the -r/–run CLI option returns 0 if all tasks pass or the exit code of the first failed task. This allows to detect the schedule result from external frameworks such as Continuous Integration.
  5. Accept “Command” key for Mac within the scripting language (RB-19)
    There’s a new recognized key called COMMAND. It is an alias of the WINDOWS one. It is produced by the script recorder and the Keyboard Tool on Mac OS to make the keyboard operations more obvious to Mac users.
  6. Make Sendmail command support SSL (RB-15)
    The Sendmail command now supports connection to SSL secured SMTP (typically port 465).

Bug Fixes:

RB-41: Compareto method=”text” throws ArrayOutOfBoundsException
RB-40: Set smooth mouse moves on by default
RB-39: Clipboard text returned by VNC server may break test reports
RB-38: High memory usage pop up blocking an automated testing session
RB-34: Image based OCR delivers wrong text match coordinates
RB-33: MacOS – Failed connection does not release license
RB-32: Connection to local desktop over VNC fails to close the Login dialog
RB-31: Schedule warning dialog displays incorrect sentence
RB-28: Login dialog hangs intermittently on connection crash
RB-24: Disable close button on “shutdown or restart” dialog in License Key Manager window
RB-23: Incorrectly generated log text due to an IllegalArgumentException
RB-22: Corrupted Japanese characters in log.html
RB-20: Execution queuing not working in CLI
RB-16: iOS Over Xcode keyboard support broken on iOS 11.2
RB-9: Excel command fails to save changes to cells of certain types
RB-8: Script history log fails to create intermittently in the GUI mode
RB-7: Memory management improvements (partial fix)
RB-4: Corrupted Japanese characters in the license session table
RB-3: The “move” parameter of the Click command doesn’t get applied to OCR and Object search
RB-2: Click and Drag dialogs fail to display mouse parameter hints
RB-1: Help on Click/Drag from the context menu fails to open


Version 4.4.2 Updates

New features:

  1. Allow per command setting of default “wait” delay value (CR-1016)
    All commands supporting the “wait” parameter accept the default value through a script variable called _[commandNameInUpperCase]_WAIT.
    For example, the following line of code will make all Type commands wait 1 second after typing unless the parameter is specified.
    Var _TYPE_WAIT=1s
  2. Optional detailed script execution logging (CR-1015)
    The script execution logger was enhanced to provide detailed logging capturing the last moments of the script execution. To activate the feature go to the Edit->Preferences->Log Command screen and look for the Script History Log controls.
  3. Minor GUI improvements (CR-1014)
  4. Provide a global switch to make Click and Drag continue despite image comparison failure (CR-1013)
    The Click/Drag commands observe the newly supported _CLICK_CONTINUE and _DRAG_CONTINUE variables for the default value of the continue parameter. For example to make all Click commands not terminate the script by default set the variable to “true” at the beginning of your script using:
    Var _CLICK_CONTINUE=”true”

Bug Fixes:

PRB-3947: Mapping of Connect onto Java method call fails
PRB-3946: Fetch dates from Excel file in format subject to the locale
PRB-3945: RDP connection mouse and keyboard I/O issues
PRB-3944: User mouse move fails to pause Local Desktop execution in CLI mode
PRB-3943: Support entry of CLI parameters through a JSON file
PRB-3942: Broken links to scripts in the execution log
PRB-3941: Memory management improvements
PRB-3940: Local Desktop init phase issue
PRB-3939: ADB Over Android w/ screen mirroring fails on new devices
PRB-3938: New variable _LAST_CMP_COMMAND holding the last executed image comparison command
PRB-3937: Failed to copy template images to the XML report folder
PRB-3936: Disable smooth mouse moves by default
PRB-3935: Fix memory leaks
PRB-3934: Back up data created through Excel and File commands
PRB-3933: Enable custom script editor font size
PRB-3932: Adjust comparison area for scaled templates
PRB-3931: iOS Over Xcode drag/swipe is unreliable (full fix)
PRB-3930: iOS Over Xcode doesn’t support long and double tap
PRB-3929: XML parsing may fail for leading BOM character


Version 4.4.1 Updates

New features:

  1. The automation results now display the exit stack trace and other report elements such as screen shots (CR-1012)
  2. Support of the new license server with improved security was implemented (CR-1011)

Bug Fixes:
PRB-3928: Improve thread safety
PRB-3927: Can not create some Step and Script commands in Java test script using the property window
PRB-3926: Unsupported drag command in the Java API
PRB-3925: Unresponsive UI after Ctrl+C in the project tree
PRB-3924: Fresh installation may hang for a long time if license file key is used
PRB-3923: License Manager fails to show key details when opened at start up
PRB-3921: Connect command compiler too strict
PRB-3920: Waitfor fails for a NullPointerException
PRB-3919: iOS Over Xcode skips keyboard layouts on some devices
PRB-3918: CLI Wizard crashes if the last connection is iOS Over Xcode
PRB-3917: Local Desktop recording fails on some Windows systems
PRB-3916: InterruptedException print out after Local Desktop recording


Version 4.4 Overview

New features:

  1. Updated iOS Over XCode connection enables system-wide automation of iOS 10+ devices over Xcode 8+ and lightning USB (IMS CR-1003).
  2. Hiding of sensitive data in test scripts via Safe Box (IMS CR-1007).
  3. The new “diff” algorithm allows to compare two desktop screenshots and highlight the differences (IMS CR-1004).
  4. The report generator was improved to record the screen image, command properties and template images when the script gets terminated for image comparison failure (IMS CR-1006).
  5. Support of Java 9 (IMS PRB-3908).
  6. There’s a new variable allowing the test script to set a limit of search2 matches (IMS CR-1005).

Bug Fixes:

PRB-3915: Local Desktop recorder hangs on Mac OS when accessibility is not enabled
PRB-3914: Android device window fails to show connected devices
PRB-3913: Add mouse press and release methods to Java test script API
PRB-3912: Store Screenshot command templates as collections to the report folder
PRB-3911: License error pop up not displaying in the system task bar
PRB-3910: Waiting for a free license doesn’t work for license server
PRB-3909: Failed to create heap dump
PRB-3908: Robot not compatible with Java 9
PRB-3907: Enable zoom out to less than 100% in image editors
PRB-3906: Safe saving of files
PRB-3905: Save script changes automatically to prevent data loss
PRB-3904: Windows/Command+A key closes the iOS Mirror connection
PRB-3903: Populate template variables even on comparison failure
PRB-3902: Can’t run a script with procedures from a structured block
PRB-3901: Lost configuration file

Yes No Suggest edit
Last updated on July 10th, 2019

2.3.Change Log 4.3.x #

This document describes new features, changes and bug fixes delivered by T-Plan Robot Enterprise 4.3.x releases.

Contents:
Version 4.3.1 Updates
Version 4.3 Overview

T-Plan Robot Enterprise version 4.3.1 was officially released on 26th September 2017.

The IMS references in the text refer to our T-Plan Incident Management System (IMS).


Version 4.3.1 Updates

New Features:

  1. Expose display properties on multi-screen environments (IMS CR-1001)
    The Local Desktop connection populates new variables with parameters (location and size) of all displays. Image comparison features such as the CompareTo, Waitfor match/mismatch, Click and Drag commands also expose number of the screen the text or component was found on. This allows scripts to program different behavior depending on the component location.
  2. Support Click and Drag actions from image node context menu (IMS CR-1002)

Bug Fixes:

PRB-3900: Unexpected behavior of the Variable table component
PRB-3899: Simplify the VNC Server documentation
PRB-3898: Improve ADB mirror video responsiveness and performance
PRB-3897: Unnecessary exception print outs
PRB-3896: Latest Android Studio breaks the Android Over ADB connection


Version 4.3 Overview

New features:

  1. Support of testing over the RDP protocol (IMS CR-1000).
    Robot hosted on MS Windows can automate any other system running an RDP server such as MS Windows (via Terminal Services), Mac or Unix/Linux. It can also drive any VirtualBox guest system (virtual machine).
  2. Support of the new generation of the Robot Automation Portal (RAP) (IMS CR-999).
  3. A new Service manager was introduced allowing management of Robot running as a Windows system service (IMS CR-998).
Yes No Suggest edit
Last updated on April 16th, 2019

2.4.Change Log 4.2.x #

This document describes new features, changes and bug fixes delivered by T-Plan Robot Enterprise 4.2.x releases.

Contents:
Version 4.2.2 Updates
Version 4.2.1 Updates
Version 4.2 Overview

T-Plan Robot Enterprise version 4.2.2 was officially released released on 10 July 2017.

The IMS references in the text refer to our T-Plan Incident Management System (IMS).


Version 4.2.2 Updates

Bug Fixes:

PRB-3889: Variables passed to schedule task are not created in the CLI mode
PRB-3888: Low script execution performance in the CLI mode
PRB-3887: Misleading error message on report() failure
PRB-3886: Latest version of IE fails to open local help files
PRB-3885: Escaped Java literals not retrieved correctly by the Properties window
PRB-3884: Excel command uses sheet index instead of ordinary number
PRB-3883: Move files to Recycle Bin instead of deleting them
PRB-3882: OutOfMemoryError on recurring schedule executions
PRB-3881: Editing of an executing script displays intermittent procedure errors
PRB-3880: Remove deprecated Waitfor Update preference
PRB-3879: Mouse drag with Alt pressed leaves the modifier on
PRB-3878: Broken help links in the initial Login window
PRB-3877: Unnecessary exception shown in image comparison
PRB-3876: Editor search performance issues
PRB-3875: Waitfor mismatch doesn’t handle image collections as expected
PRB-3874: The “String matches” command doesn’t support fuzzy match as documented
PRB-3873: Java API: Report null context properly
PRB-3872: Exit command fails for the ‘block’ and ‘procedure’ scopes
PRB-3871: Command parameter values containing numbers in curly braces not handled properly
PRB-3870: Schedule editor issues
PRB-3869: Object Search called from Java with cmparea exceeding the screen size crashes
PRB-3868: Connection Manager fails to save Static Image connection on Windows
PRB-3867: iOS Mirror fails to start and connect to Reflector 2


Version 4.2.1 Updates

New features:

  1. Support of the Robot Automation Portal (RAP) (CR-991).
    It is a web application allowing to monitor and manage T-Plan Robot Enterprise driven automation over the TCP/IP network (internet and/or intranet) from a web browser.

Bug fixes:

PRB-3866: Connection established through the CLI options not applied to schedule scripts
PRB-3865: CLI variables not passed to schedule scripts
PRB-3864: Crippled file paths of project copied from Windows to Mac/Linux
PRB-3863: Slow Schedule execution and large project loading
PRB-3862: Preferences window too wide
PRB-3861: Splash screen issues
PRB-3860: Local Desktop clipboard text not converted properly (java.nio.ByteBuffer)


Version 4.2 Overview

New features:

  1. There are two connection improvements addressing automation of mobile devices:
    • The new iOS over Xcode connection enables full iOS device control over the USB cable from a Mac OS X development environment (IMS CR-977).
    • The existing Android over ADB connection was improved to support transfer of the screen data through a video stream (IMS CR-985).
  2. The Connection Manager stores data of your known connections (IMS CR-981).
    Connections may have names which can be used to connect without having to specify all the parameters.
  3. There’s a new method of integration with T-Plan Professional 8.1 based on a REST web service (IMS CR-978).
  1. Click and Drag command enhancements (IMS CR-982):
    • Click supports tasks such as “click 20 points to the right from an object” through the newly introduced move parameter.
    • Both commands allow the script to continue if the target click or drag object is not found (the continue parameter).
    • A simple integration with the Step command allows to record a test step and populate it with the pass or fail result (the step parameter).
Yes No Suggest edit
Last updated on April 16th, 2019

3.License Installation #

T-Plan Robot supports two methods of applying the application licenses. The sections below describe each method.

For more information on how T-Plan Robot Enterprise is licensed please read our Robot FAQ’s.

Yes No Suggest edit
Last updated on December 6th, 2017

3.1.Files Based Licensing #

Using the basic license file approach, you can instruct T-Plan Robot to locate and use a provided license using your standard file system.

If the license file is saved to the T-Plan Robot installation directory, it will be automatically picked up when T-Plan Robot is next launched.

Alternatively the license file itself can be saved to any accessible file directory, either on your local workstation or on a shared network directory. In this case when T-Plan Robot is first launched you will be asked to browse to your designated license file(s) or you can add further licenses from within the tool using the “License Key Manager”, accessed under the application Tools menu.

Multiple license files can be used, from multiple locations at any one time.

Yes No Suggest edit
Last updated on December 6th, 2017

3.2.License Server #

Using the T-Plan License Server allows you to centrally manage and control your license usage across your organization.

The T-Plan License Server runs on your internal network and dynamically assigns application access based on a “first come first served”, concurrent policy based on your license restrictions.

Installation

The License Server must be installed on a Windows 64bit environment.

Install the license server using the supplied msi. It should be installed on a centrally accessible machine as all Robots will need to communicate with it.During the License Server installation you can define the desired URL and port for which each T-Plan Robot instance will use to communicate with the License Server and ultimately obtain a license.

Activation

In order to apply a supplied license within your T-Plan License Server you must first activate it. The T-Plan License Server Configuration utility allows you to browse to your provided license file. If it has not yet been activated you will be presented with the option to do so ‘online’, or manually paste the “Activation Block” as communicated by the T-Plan Support Team.
Once the Activation Block section in populated you should select “Update License” which will attempt to Save the activated license – it is this activated license which is used moving forward.
When back to the initial screen select “Update” to apply the new activated license.

Usage

In order for Robot to communicate with the License Server you need to tell Robot to use this method as opposed to the default file based approach.

When Robot is launched for the first time, if no valid license file is found you will be presented with the license warning dialog, from here you can open the License Key Manager window.
Within the License Key Manager window select the “License Server” tab and enter the License Server machine URL i.e. http://TPlanLicenseServer:8080.
Selecting “Refresh” should then populate the top section with details about your license allowance, with the lower pane showing any existing ‘live’ Robot instances.

 

Yes No Suggest edit
Last updated on July 14th, 2017

4.Robot Automation Portal (RAP) #

This document describes the features, changes and bug fixes delivered by T-Plan Robot Automation Portal (RAP) releases.

The RAP is a web based management solution that allows the control, scheduling, reporting and execution of the T-Plan Robot army or bots deployed at an organisation. The solution is predominantly deployed by customers performing RPA (Robotic Process Automation) but is also utilised by customers for test automation management.

Yes No Suggest edit
Last updated on June 21st, 2017

4.1.System Requirements #

The T-Plan RAP Portal is available for Docker, or Windows 2012 R2 & Windows 2016.

Docker

The Portal Server and application components are available as Docker containers, and work with the following configurations:

  • Docker CE on Windows 10 Pro
  • Docker CE on Ubuntu/Debian Linux

The Docker containers can be obtained by contacting T-Plan Support.

Windows 2012 R2 & Windows 2016

The following prerequisites are required for installing the T-Plan RAP Portal components on Windows 2012 R2 & Windows 2016:

  • NodeJS 6.10 +
  • Java Runtime Environment 1.8 or higher
  • IIS
  • URL Rewrite module for IIS, 2.0
  • MySQL 5.7

The Windows installer for T-Plan RAP Portal will not permit installation until these prerequisites are satisfied.

Yes No Suggest edit
Last updated on May 30th, 2018

4.2.RAP on Windows #

Installing RAP on Windows.

The RAP server and application are supported on Windows 2012 R2 & Windows 2016. Prior to installation, the following prerequisites must be installed and configured:

  • Node JS – V6.10+
  • IIS and URL Rewrite Module 2.0
  • MySQL Server (not required locally – a remote server can be specified in the configuration)
  • Java Runtime Environment (JRE) 1.8+

Installing the Components.

Run the Installation media. This will require elevated permission.

Post Installation Configuration.

Once the installation media has been run successfully, the components can be configured. Begin by preparing the MySQL database – log into MySQL either locally, or remotely (you will need to log in as a user with create database and grant permissions). Create the database and grant permissions to the user account you which to use.

Now run the T-Plan RAP Configuration Tool. Start at the “RAP Database” tab and enter the correct details for your MySQL installation. Now click the “Test” button – if the connection details are valid, you will see the “Create Schema” dialog:

Click “Yes” to create the RAP database. When the DB setup has completed, click “Test” again to verify the installation:

Now click “Update” on the dialog to write the updated configuration:

Click the “Data Server” tab and ensure the ports selected for HTTP and HTTPS (if required) are set to valid values for your server. Ensure these ports are open on the Windows Firewall if necessary. If you change any items – don’t forget to click “Update” to write the new configuration.

Click the “Web App” tab. Ensure the “SOA URL” is set to an address that is valid from browsers using the Web application. For example, if this server exists on your Intranet, and users will only connect from within the Intranet, then this should be set to the Intranet address of this server. If this server is exposed to the Internet, and users will be connecting across the Internet, then this should be set to the Internet address of this server. Click “Update” to save the configuration.

Now start the T-Plan RAP Service using the Windows Service Manager:

You should now be able to log into the RAP Application locally as SysAdmin (default password is ‘sysadmin1’):

Click the Config button on the Toolbar and enter the following into the “sharedfilestore” setting:

C:\\ProgramData\\T-Plan\\Reports

Now restart the T-Plan RAP Service:

Log back into the application and it should be ready to use.

Note: Although not recommended, if you are installing on Windows Server 2012 (not R2) then you will have to add the MIME Type of ‘.json’ with a MIME of ‘application/json’ to allow the serving of JSON files. [Windows Server 2012 R2 has this MIME already added in the default installation of IIS].

Yes No Suggest edit
Last updated on May 30th, 2018

4.3.Architecture #

Yes No Suggest edit
Last updated on May 30th, 2018
Suggest Edit

Call us today at +44 (0)1209 614 714 or Email us at sales@t-plan.com

Command your Robots – Your virtual workforce!

Menu