Plans
Plans are the implementation of an automation scenario such as a functional test case, a load test, an RPA routine, or a synthetic monitoring probe. Plans combine building blocks called Keywords with various controls that build up the execution logic of the automation scenario.
As a beginner, make sure to understand the key concepts explained in the following sections before creating your first Plan. You will also find various ways to create different types of Plan in our tutorials.
Node types
There are three basic types of nodes that can be used within a plan. Click the links in the table below to learn more about each type.
| Keywords are the fundamental building blocks of a Plan and are designed to be shared between multiple Plans | As in any programming language, Control structures are the type of nodes used for influencing the execution flow of the scenario | A Plan can call other Plans via a special control in order to achieve modular Plan design. |
Plan formats
Step provides three ways of designing, visualizing, and executing Plans. To learn more about each approach, click the links in the table below.
| The most intuitive way to create a Plan is the Visual interface. Design is done visually via drag & drop and button clicks | Offers a text representation of a plan, allowing for storage in third-party tools such as ALM test case descriptions or as files in a Git repository | For a programmatic implementation of a plan by a developer, this is the most advanced way to create and use plans. See the Java Plan API page for more information. |
Key concepts
This section contains a description of the most important concepts that you need to understand in order to design and execute plans successfully. For information about Step architecture and framework, see the Step documentation home page.
Plan types
Step provides different types of Plans to cater for various automation needs. The available Plan types are Sequence, TestCase, TestScenario, TestSet and AssertionPlan. When creating a Plan, you can select the appropriate Plan type from the drop-down menu, as illustrated in the following screenshot:
For extensive flexibility, each type of Plan is also available as Control component, letting you combine the unique characteristics of different Plan types in a single Plan construct. In other words, you can leverage the features of multiple Plan types by adding them as Control components in the same Plan.
This flexibility let you design comprehensive automation plans that suit your specific needs, making use of the strengths of different Plan types.
The Plan configuration view showing the root of your Plan.
In plain text, the root of your plan will be a Session node by default.
Find out about all possibilities in our Javadocs.
Depending on the type, child nodes will either be executed in parallel (for instance, if the root is a TestSet or a TestScenario) or in sequence. If you are not sure of the Plan type, make sure to select the Sequence type.
Structure & Execution
Plans are implemented by a tree of elements, referred to as nodes. The order of nodes in a tree, respective to their parents and siblings, determines the order of nodes execution.
Here is an example showing the node tree in the Visual plan editor:
Variables in Plan
Variables are used throughout plans to pass information from one node to another, or to store the result of a dynamic computation.
Variable types
Similar to any programming language, Step supports the use of variables in Plans. The variables declared and used in a Plan are called Plan variables. A Plan variable is a container that stores a data value under a specific name.
Like in classical programming languages, Step supports the following types of variables:
- String: stores text (Default type of variables in Step)
- Number: can be integer, long, float, or double
- Boolean: stores values with two states: true or false
- Complex Java objects: lets you define expressions for performing advanced data handling
When passing or setting a variable into the value field of a control or Keyword input, Groovy execution will be required for numbers, booleans, and complex Java objects. The Groovy toggle is a powerful feature in Step that lets you add dynamic behavior to a plan without modifying your Keywords.
Declaring variables in Plan
In Step, you have different ways to declare Plan variables:
- Using Set control: the most common way to declare a Plan Variable is to use the dedicated Set control in your Plan
- Using Parameters: Parameters declared in the web interface under Parameters are made available to the Plan as Variables
- Using Execution Parameters: Execution Parameters selected at the start of execution (Environment, etc) are also made available to the Plan as Variable. See Executing a Plan
Variables in Set control
Using the Visual Plan editor, you can use the Set control as follow to declare a variable:
This would declare a variable called “myVar” as String and set its value to “This is a string value”.
To declare a variable as an integer, toggle the dynamic field button as follow:
Using the plain text editor, you can use the Set control as follows to declare a variable:
Set city="Basel"
MyKeyword Parameter1="Welcome to ${city}"
Set City="Bern"
MyKeyword Parameter1="Welcome to ${city}"Similar to the Visual Plan Editor, you can also use Groovy expressions in the declaration of variables .
Set birthyear=2006
Set age=2019-birthdayIn this case, the variable “birthyear” will be declared as integer. The variable “age” will also be declared a integer as the result of the operation “2019-birthday”
Find out about all possibilities in our Javadocs
See also Controls
Variables in Parameters
Parameters declared in the web interface through the Parameters page are automatically declared by Step as variables at the beginning of the execution and can thus be accessed in the Plan like any other Plan variable.
Variables in Execution parameters
The parameters selected for the execution of a Plan (like “Environment”) are called Execution parameters. These Execution Parameters are also declared by Step as Plan variables at the beginning of the execution and can be accessed in the Plan like any other Plan variable.
Accessing variables
Variables can be accessed practically everywhere in Plans and can also be passed to Keywords.
Using the Visual Plan Editor, you can access previously defined variables in every field that has the dynamic field button as shown in the following screenshot. The variables are available as binding in Groovy expressions.
In this example, we pass the content of the variable “myVar” to the first parameter of the Keyword “My Keyword”.
Using the plain text syntax you can use the following syntax to access the content of previously declared variables:
Set birthyear=2013
Set age=2019-birthyear
Set city="Lucerne"
MyKeyword Parameter1="I was born in ${city} in ${birthyear} and I am now ${age} years old"This would call the Keyword “MyKeyword” and set the value of variable “Parameter1” to “I was born in Lucerne in 2013 and I am now 6 years old”
Find out about all possibilities in our Javadocs
Undo, redo, and discard your changes
Using the top-level buttons on the Plan page, it is possible to undo or redo a single modification that you performed while working on a Plan:
It is also possible to discard all the changes you performed on a Plan to retrieve its “initial” state by clicking on the “Discard all” button:
Advanced uses
Links and information about advanced Plan uses are provided in the following sections.
Advanced Groovy expressions
Advanced use of Groovy expressions as well as sample plans, are provided in our Resources > Library section.
Remote plan invocation
The Step Java client, as well as REST API, can be used for invoking plans remotely. Check out the stepClient API for more information on remote Plan invocations and triggers.
Interacting with a running plan
The Async semantics provided by the Async & Event plugin allows for real-time interactions with a running plan. One can use the WaitForEvent control to poll the event queue and influence the plan’s execution logic.