• Documentation
  • Tutorials
  • Blogs
  • Product

What's on this Page

  • Plan structure
  • Plan formats
  • Key concepts
    • Plan types
    • Structure & Execution
  • Advanced uses
    • Advanced Groovy expressions
    • Remote plan invocation
    • Interacting with a running plan
  • Step
  • User guide
  • Plans
Categories: USER GUIDE PLANS
This article references one of our previous releases, click here to go to our latest version instead.

Plans

A Plan in Step is 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 Plans in our tutorials.

Plan structure

In its most basic form a Plan consists of a sequence of Keywords. To build up more complex automation scenarios, Step also supports a wide range of Controls and the modular composition of Plans. A Plan therefore consist of the composition of Keywords calls, Controls and calls to other Plans.

From a model point of view, a Plans is structured as a tree, each node being either a Keyword call, a Control or a call to another Plan. Click the links in the table below to learn more about each type of node.

Plan nodes
Keywords
Controls
Other plans
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.

Supported Plan formats
Visual plan editor (UI)
YAML
Natural language (plain text)
Java
The full-featured visual plan editor of the Step UI enables intuitive design of Plans Within automation packages, Plans can be defined in a declarative way as YAML The so-called natural language syntax of Step enables the specification of Plans in an easily readable language. This syntax is particularly suited for business-facing plan specifications For advanced uses, Step also supports the programmatic implementation of 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:

    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.

    See Also

    • Controls
    • Using variables in Plans
    • Calling Keywords in Plans
    • Java Plan API
    • Parameters
    • Home
    • Whats new?
    • Set up
    • Administration
    • SaaS guide
    • User guide
      • Keywords
      • Plans
        • Keyword calls
        • Controls
        • Plan modularity
        • Variables
        • Visual Plan editor
        • Plain text plans
        • Java Plan API
      • Executions
      • Agent provisioning
      • Alerting and notifications
      • Bookmarks
      • Incidents
      • Parameters
      • Analytics
      • Monitoring
      • Schedules
      • Event Broker Monitor
      • Import/Export entities
      • User account
      • Versioning
    • Developer guide
    • DevOps
    • Plugins
    • Libraries
    Step Logo
      • Documentation
      • Tutorials
      • Blogs
      • Product
      • Home
      • Whats new?
      • Set up
      • Administration
      • SaaS guide
      • User guide
        • Keywords
        • Plans
          • Keyword calls
          • Controls
          • Plan modularity
          • Variables
          • Visual Plan editor
          • Plain text plans
          • Java Plan API
        • Executions
        • Agent provisioning
        • Alerting and notifications
        • Bookmarks
        • Incidents
        • Parameters
        • Analytics
        • Monitoring
        • Schedules
        • Event Broker Monitor
        • Import/Export entities
        • User account
        • Versioning
      • Developer guide
      • DevOps
      • Plugins
      • Libraries