JUnit Integration

JUnit integration allows you to execute Testerum tests from your IDE or from your Maven or Gradle build.

For a Junit integration, your Maven or Gradle project needs to depend on:

Testerum Junit Maven dependency:

<dependency>
    <groupId>com.testerum</groupId>
    <artifactId>testerum-junit</artifactId>
    <version>${testerum-junit.version}</version>
</dependency>

For the latest com.testerum:testerum-junit version please check Maven Central

For a JUnit Integration example you can see the class src/test/java/com/testerum/JunitTesterumTests.java in our Git Sample project:
Testerum Custom Steps Sample Project

Junit Integration Example:

package com.testerum;

import com.testerum.runner.junit5.TesterumJunitTestFactory;
import java.util.List;
import org.junit.jupiter.api.DynamicNode;
import org.junit.jupiter.api.TestFactory;

public class JunitTesterumTests {

    @TestFactory
    public List<DynamicNode> testerumTestsFactory() {
        return new TesterumJunitTestFactory("tests")
            .getTests();
    }
}

For this integration your class needs to be defined as a test class and the test factory method needs to be annotated with @TestFactory.

To allow JUnit know about the Testerum tests you need to create a instance of TesterumJunitTestFactory that accepts as a parameter the location of the Testerum tests.
This location can be relative to the project root.

TesterumJunitTestFactory is a builder class that has the following methods:

testPaths

Accepts a list of paths as String to a test file or feature directory.
If the path is a directory, all tests in that directory will be run.
If this call is missing, all tests will be run.
If the paths are relative, they will be resolved relative to the features directory.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    return new TesterumJunitTestFactory("tests")
            .testPaths("/path/to/some feature/", "/path/to/another-feature/File 1.test")
            .getTests();
}

tagsToInclude

Test or feature tag used to select what tests will run.
If no tag will be specified, the other options will be used to determine what to run (e.g. --test-path).
If a test has one of these tags, the test will be executed.
If a feature has one of these tags, all tests inside it (recursively) will be executed.
Exclude tags have priority over include tags, i.e. if a feature or a test have both an include tag and an exclude tag, the feature or test will NOT be executed.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    return new TesterumJunitTestFactory("tests")
            .tagsToInclude(Arrays.asList("web", "a_tag", "tag with spaces"))
            .getTests();
}

tagsToExclude

Test or feature tag used to select what tests will NOT run.
If a test has one of these tags, the test will NOT be executed.
If a feature has one of these tags, all tests inside it (recursively) will NOT be executed.
Exclude tags have priority over include tags, i.e. if a feature or a test have both an include tag and an exclude tag, the feature or test will NOT be executed.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    return new TesterumJunitTestFactory("tests")
            .tagsToExclude(Arrays.asList("web", "a_tag", "tag with spaces"))
            .getTests();
}

variablesEnvironment

The name of the variables environment to use.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    return new TesterumJunitTestFactory("tests")
        .variablesEnvironment("Acceptance")
        .getTests();
}

variableOverrides

Override Testerum variables.
This parameter accepts a Map<String, String> as a parameter.
This argument takes precedence over variablesEnvironment, if the same key is found in both.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    Map<String, String> variableOverrides = new HashMap<>();
    variableOverrides.put("URL", "http://localhost:8888");
    variableOverrides.put("USER_NAME", "Alex");

    return new TesterumJunitTestFactory("tests")
        .variableOverrides(variableOverrides)
        .getTests();
}

settingsFile

Path to a settings file.
The settings in this file override Testerum settings.
The file must be in the standard Java .properties format.

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    return new TesterumJunitTestFactory("tests")
        .settingsFile("/path/to/file.properties")
        .getTests();
}

settingOverrides

Override Testerum settings.
For a complete list of our settings please consult Runner documentation

Example:

@TestFactory
public List<DynamicNode> testerumTestsFactory() {
    Map<String, String> settingOverrides = new HashMap<>();
    settingOverrides.put("testerum.selenium.afterStepDelayMillis", "0");
    settingOverrides.put("testerum.selenium.driver.browserType", "CHROME");

    return new TesterumJunitTestFactory("tests")
        .settingOverrides(settingOverrides)
        .getTests();
}

getTests

Because the TesterumJunitTestFactory is a builder type of class you need to always call getTests() as the last method.
This method return the List<DynamicNode> required by the JUnit in order to execute the Testerum tests.

One big advantage of using the JUnit integration is that you can use breakpoints in your IDE to debug your Custom Steps.

Maven/Gradle Integration

Because of the JUnit Integration you can execute the Testerum tests as part of your build process. In order to execute the test as part of your Maven process just follow the steps from the JUnit Integration and configure Surefire plugin in your Maven build:

<build>
    <plugins>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <argLine>-Xmx1024m -Xms128m -Dfile.encoding=UTF8</argLine>
            </configuration>
        </plugin>

    </plugins>
</build>