• Documentation
  • Tutorials
  • Case studies
  • White papers
  • Product

What's on this Page

    • Executable bundle for Java
      • Declaration
        • Plain text plans
        • Inline plans
        • Execution parameters
  • step
  • User guide
  • Executable bundles
Categories: USER GUIDE
This article references one of our previous releases, click here to go to our latest version instead.

Executable bundles

An Executable Bundle is a self-contained set of Plans and their related entities (Keywords, Parameters and Resources) that can be executed on a step controller. It is a beta feature that has been introduced with step 3.14.

Supported formats: Executable Bundles currently support Java as software platform. The format of an Executable Bundle for Java is a compiled jar containing Plans and their related entities as Java classes or resources. Additional software platforms like .NET might be supported in future releases.

Supported entities: Following entity types are currently supported:

  • Plans in plain-text format (*.plan files)
  • Inlined plain-text Plans using the newly introduced @Plan java annotation
  • Java Keywords
  • Inlined Parameters

Executable bundle for Java

The documentation of Execution bundles for Java is still under work. It will be completed and supplemented by tutorials and examples soon.

Declaration

An Executable Bundle for Java contains at least one Plan. Plans can either be specified in a .plan File following the plain-text format or as inline plain-text plan using the newly introduced @Plan java annotation.

Plain text plans

Plain text plans files can be simply added to an Executable bundle as jar resource and have to be referenced by a class using the class annotation step.junit.runners.annotations.Plans. The class annotation @Plans specifies the list of plain text plan file names to be executed. Please note that these plain-text plan files have to be located within the same java package as the class declaring them.

Here’s a simple example of a class referencing 2 plan files:

@Plans({"MyPlan1.plan", "MyPlan2.plan"}) //Reference 2 plans in plain-text format
public class MyTestSet1 {
}

MyPlan1.plan located as resource in the same package as the class MyTestSet1:

"Open Chrome"
"Search in google" search="STEP"

MyPlan2.plan located as resource in the same package as the class MyTestSet1:

"Open Chrome"
"Search in google" search="exense"

Inline plans

Inline plans are plain text plans that are directly defined within a Java-Class using the method annotation step.junit.runners.annotations.Plan. Inline Plans are java methods annotated by the annotation @Plan. The value of the annotation declares the Plan in plain-text syntax. The implementation of the annotated method is ignored.

Here’s a simple example of a class containing one inline plan:

public class MyTestSetUsingInlinePlans {
  @Plan("myKeyword")
  public void myInlinePlan() {}

  @Keyword
  public void myKeyword() {
    output.add("hello","world");
  }
}

For simple Plans made of only one Keyword the above example can be shortcuted as follows:

public class MyTestSetUsingInlinePlans {
  @Plan()
  @Keyword
  public void myPlanMadeOfOneKeyword() {
    output.add("hello","world");
  }
}

Execution parameters

Execution parameters can be defined using the class annotation step.junit.runners.annotations.ExecutionParameters.

Here’s an example of a class containing one inline Plan relying on one execution parameter declared by @ExecutionParameters:

@ExecutionParameters({"URL","https://url.com/"})
public class MyTestSetUsingInlinePlans extends AbstractKeyword {
  @Plan("myKeyword")
  public void myInlinePlan() {}

  @Keyword
  public void myKeyword() {
    System.out.println(properties.get("URL"));
  }
}

See Also

  • Controls
  • Plain text plans
  • Plan modularity
  • Keywords calls
  • Parameters
  • Getting Started
    • Overview
    • Quick setup (install)
    • Quick setup (SaaS)
    • My first Execution
    • Browser automation
    • Real-world scenario
    • Scaling out
  • Whats new?
    • Release notes
    • Roadmap
    • Weekly news
  • Admin guide
    • Database installation
    • Controller installation
    • Agent installation
    • Requirements
    • Backup & Restore
    • Housekeeping
    • Migration
    • Customization
    • Project management
    • Admin Views
    • Troubleshooting
    • Encryption Manager
  • User guide
    • Keywords
    • Plans
    • Executions
    • Notifications
    • Parameters
    • Dashboards
    • Monitoring
    • Scheduler
    • User Preferences
    • Event Broker Monitor
    • Executable bundles
    • Import/Export entities
  • Developer guide
    • Dev Overview
    • Keyword API
    • Measurement API
    • step client API
    • Event Broker API
  • Plugins
    • .NET agent
    • cypress Plugin
    • Node.js agent
    • ALM
    • Azure DevOps
    • Async packages
    • JMeter
    • SoapUI
    • PDF and Image compare
    • Artifact repository connector
    • Analytics and external DBs
  • Resources
    • Tutorials
    • Case Studies
    • White papers
    • Libraries
Step Logo
    • Documentation
    • Tutorials
    • Case studies
    • White papers
    • Product
    • Getting Started
    • Whats new?
    • Admin guide
    • User guide
    • Developer guide
    • Plugins
    • Resources