1. Preface
    1. About MarathonITE
    2. Supported Platforms
      1. Java/Swing™
      2. Java/FX™
      3. Web Applications
    3. What's New in MarathonITE 5.0
    4. Change Log a.k.a Version History
    5. System Requirements
    6. Copyright Notice
  2. Getting Started
    1. Introduction to Test Automation
      1. Unattended Testing
      2. Semi Automated Testing
      3. Exploratory Testing
    2. MarathonITE Projects
    3. Your First Project
      1. Java/Swing™ Test Project
        1. Application Under Test - SwingSet3
        2. Creating a Project
        3. Recording a Test
        4. Anatomy of a Test Script
        5. Running Tests
        6. Looking at Results
      2. Java/FX™ Test Project
        1. Application Under Test - Ensemble
        2. Creating a Project
        3. Recording a Test
        4. Anatomy of a Test Script
        5. Running Tests
        6. Looking at Results
      3. Web Application Test Project
        1. Application Under Test - DuckDuckGo Search
        2. Creating a Project
        3. Recording a Test
        4. Anatomy of a Test Script
        5. Running Tests
        6. Looking at Results
    4. MarathonITE Sample Projects
  3. User Guide
    1. Installation and Startup
    2. MarathonITE User Interface
      1. Views
      2. Editors
      3. Output Views
    3. Creating Marathonite Test Projects
    4. Recording Tests
    5. Managing Checklists
    6. Exploratory Tests
    7. Semi Automated Tests
    8. Executing Tests
      1. Executing a Test from Editor
        1. Debugging Scripts
        2. Using Script Console
      2. Executing Tests from Test Runner
      3. Executing Tests in Batch Mode
    9. Organizing Tests
      1. Organizing Tests in Folder Heirarchy
      2. Organizing Tests as Features and Stories
      3. Organizing Tests in Suites
      4. Linking Tests to TMS and Issue Manager
    10. Modularizing Test Scripts
      1. Module Methods
      2. Extract Method Refactoring
      3. Using Data Loops
      4. Convert to Data Loop Refactoring
    11. Data Driven Tests
      1. Convert to DDT Refactoring
  4. Advanced Scripting
    1. Ruby Programming Language
    2. Marathon and Ruby
    3. Selenium/WebDriver Bindings
      1. Java/Swing™ Components
      2. Java/FX™ Controls

3.3.Creating Marathonite Test Projects

When using MarathonITE to automate your application tests, you start with a project. A MarathonITE project is nothing but a folder in the file system. The project folder contains all the resources and artifacts related to the project.

MarathonITE keeps the application launch information in Fixtures. You need to start the application from within MarathonITE for testing it.

MarathonITE borrows the concept of Fixtures from JUnit. A fixture creates a known state for running a test against the application. A MarathonITE fixture also provides setup and teardown methods. These methods can perform operations before and after a test script. A project can have many fixtures. Every test case specifies a fixture used with it.

Creating a new Project

For creating a new project, you need to start marathonite without any arguments.

MarathonITE displays a project selection dialog. The project selection dialog allows you to create or edit projects. From the project selection dialog, click on the New button. MarathonITE displays a list of supported platforms. Currently the supported platforms are Java/Swing™ Java/FX™ and Web. Select a platform from the list.

MarathonITE shows new project dialog.

Configuring the Project

There are three sections in a MarathonITE project configuration. You need to provide generic information about the project in the Project section. In the Application section – you provide default fixture configuration. You can customize the script run-time in the Language section.

Project Section
Marathonite Project Tab - Web Application

In the Name field, enter a name for the project. Use the Browse button and select a folder. You can provide some free formatted text for the description field.

MarathonITE can link tests to various issues saved in an Issue Tracker. If you use a Issue tracker system (like BugZilla or Jira), enter a URL pattern in the Issue Tracker pattern field. A %s in the pattern field is the place holder for the Issue ID.

MarathonITE can also link test scripts to a test management system (TMS) like testlink. Enter a URL pattern in the Test Management pattern field. A %s in the pattern field is the place holder for a test case ID.

Language Section
Language Tab

Language section allows you to select a scripting language and customize it’s run-time. Currently, MarathonITE supports Ruby language.

MarathonITE bundles a JRuby run-time. You can change the version of JRuby used by setting the Ruby Home. Using a different version of JRuby might not be compatible with MarathonITE. Please use this override under advisement.

You can add more folders to ruby run-time using the Add Folders button and selecting a folder. All the folders provided in the list will be added to the ruby run-time path. You can use the script files from these folders using require statement in your scripts.

Application Section

MarathonITE creates a default fixture using the information from the application section. A project can have many fixtures.

The selected platform defines the launchers available for each of the fixtures. In the Application section, select an appropriate launcher from the drop-down menu.

1. Web Application – Web Application Launcher
You can use a Web Application launcher to test a web application. Any supported browser can start the application. Providing URL For Web Applications You configure the web application launcher by providing the following information:
  1. URL(Prefix)
    This is the initial part of the URL, typically the host name and the port number. You need to provide the port number only if it is not default.
  2. Start Path
    This is rest of the URL. MarathonITE creates a complete URL for the application by joining both URL and path.
  3. Default Browser
    The browser used by scripts by default. You can override this later through MarathonITE UI.
  4. Initial Window Size
    The size of the browser window. Whenever a script uses this fixture, the browser window is set to this size.
2. Web, Java/Swing™ and Java/FX™ – No Launcher

The launcher ‘No Launcher’ doesn’t launch an application under test. You can integrate your existing test suite into MarathonITE using this launcher.

Using this launcher you can implement tests that do not need the AUT. For example, this launcher to develop tests that test a REST API.

A Dummy Launcher to Import Test Scripts into Marathon

No further information is required for creating a launcher of this type.

Before You Start – Java/Swing™ and Java/FX™

Ensure that you are able to launch the application without any security prompts outside marathon. You may not be able to use Marathon if security prompts are shown by the application.

Check security prompt settings in Java Control Center.

Updating Policy Files

For using webstart/applet launchers you need to allow all permissions to MarathonITE‘s recorder and player agents. Please update the javaws.policy and java.policy files in lt;javahome>/lib/security folder.

You need to add the following lines to the above policy files:

Depending on the configuration, the javaws application might not be using the same JRE/JDK used by MarathonITE. You can find the current JRE used by webstart in the deployment.properties. For more details refer to Deployment Configuration File and Properties.

The easiest way may be to search for all javaws.policy and java.policy files in the system and add the above lines to them.

Warning

If the configuration is not proper, the MarathonITE might not respond for as much as 3 minutes. Please be patient.

3. Java/Swing™ and Java/FX™ – Java Commandline Launcher

When using this launcher, MarathonITE builds a command line to start the application. This is the default launcher for Java applications.

The launcher has two sections.

Providing Main class Name for Application Launch using Java Command

In the Main section you should provide:

  1. Class Name
    The main class to start the application
  2. Program Arguments
    The arguments that are passed to the application
  3. VM Arguments
    The arguments that are passed to the java command
  4. Working directory
    The folder from which the application must be started
  5. Java Home
    if you want to use an alternative version of Java to launch the application.

In the Class Path section you need to provide the list of Jars and folders that make up the class path.

4. Java/Swing™ and Java/FX™ – Command Line Launcher

If you launch your application using a executable or a batch script, you can use this launcher.

Providing Command for Application Launch

For creating a command line launcher, you need to provide the following information:

  1. Command/Batch Script
    Enter the path to the executable or the batch script in this field. If your command is in the PATH, you do not need to provide the full path. You can use the Browse button and select a command or script from the file system.
  2. Working directory
    The folder from which the application must be started
  3. Window Title
    In most cases, MarathonITE can identify application’s first window. Yet, if you find that MarathonITE times out when you start the application (though the application itself starts) set this field. In this field, provide the title of the first window of the application. The Window Title field allows regular expressions – start your value with a ‘/’ character. The title given here should be an exact match for the title of the first window of the application.
  4. Program Arguments
    The arguments that are passed to the application
  5. VM Arguments
    The arguments that are passed to the java command
  6. Java Home
    if you want to use an alternative version of Java to launch the application.
5. Java/Swing™ and Java/FX™ – WebStart Launcher

Java Web Start allows users to start an application from the Internet using a web browser. The javaws command launches a web start application. The user provides a path to a JNLP file to the command. The path can either be a local file or a URL.

MarathonITE provides a launcher that can launch a java application using javaws command.

Prividing JNLP file for WebStart application Launch

For using WebStart with MarathonITE, you create a web start launcher by providing the following information:

  1. URL/File
    Enter the URL to the JNLP file in this field. Alternatively, you can provide the path to a file from the file system.
  2. Window Title
    In this field, provide the title of the first window of the application. The Window Title field allows regular expressions – start your value with a ‘/’ character. The title given here should be an exact match for the title of the first window of the application.
  3. Program Arguments
    The arguments that are passed to the application
  4. VM Arguments
    The arguments that are passed to the java command
  5. Java Home
    MarathonITE uses this field to find the javaws command to execute. However, you can’t override the version of Java used with WebStart by setting this field.
6. Java/Swing™ and Java/FX™ – Executable Jar Launcher

Java allows you to distribute an application as a single JAR file. Most systems allow you to start the application by double clicking the JAR file.

You can use the Executable JAR launcher to create a fixture that can test a JAR’red application.

Providing an Executable JAR Path for Application Launch

For creating a fixture with this launcher, you need to provide the following information:

  1. JAR File
    Enter the path to the executable JAR in this field. You can use the Browse button and select a command or script from the file system.
  2. Working directory
    The folder from which the application must be started
  3. Window Title
    In most cases, MarathonITE can identify application’s first window. Yet, if you find that MarathonITE times out when you start the application (though the application itself starts) set this field. In this field, provide the title of the first window of the application. The Window Title field allows regular expressions – start your value with a ‘/’ character. The title given here should be an exact match for the title of the first window of the application.
  4. Program Arguments
    The arguments that are passed to the application
  5. VM Arguments
    The arguments that are passed to the java command
  6. Java Home
    if you want to use an alternative version of Java to launch the application.

Testing the Configuration

You can test the configuration and check for any errors by using the Test option. When you select the option, MarathonITE uses the given configuration to launch and connect to the webdriver.

Marathonite Testing Application Configuration for Web Applications

Once MarathonITE is able to connect to the driver – a window is shown. The window shows the standard output and error from the command – you can see any errors if MarathonITE is unable to connect to the webdriver intsance.

Click on the Close button. This should close the window.

Saving the Project

Click on the Save button to save the project. MarathonITE will close the project configuration window and you are presented with the project selection dialog with the newly created project already select.

Marathonite Project Selection Dialog with New Web Project Selected
Suggest Edit