/ March 5, 2017 / petrikainulainen

Running End-to-End Tests With Gradle

Lesson Progress:

← Back to Topic

After we have finished this lesson, we

Know how we can configure the source and resource directories of our end-to-end tests.
Understand how we can declare the dependencies of our end-to-end tests.
Can start our web application before our end-to-end tests are run and stop it after our end-to-end tests have been run.
Understand how we can run end-to-end tests with Gradle.

This lesson assumes that:

Watch the Lesson

The text version of this lesson is given in the following:

The Requirements of Our Gradle Build

The requirements of our Gradle build are:

Our end-to-end tests must have a separate source directory. The src/end-to-end-test/java directory must contain the source code of our end-to-end tests.
Our end-to-end tests must have a separate resource directory. The src/end-to-end-test/resources directory must contain the resources of our end-to-end tests.
We must be able to run either unit tests, integration tests, end-to-end tests, or all tests.
If an end-to-end test fails, our build must fail as well.
Integration, unit, and end-to-end tests must have different HTML report directories.

Let’s start by configuring the source and resource directories of our end-to-end tests.

Configuring the Source and Resource Directories of Our End-to-End Tests

As we remember, we can configure the source and resource directories of our end-to-end tests by using the Gradle TestSets plugin.

Because we have already applied and configured this plugin, we can configure the source and resource directories of our end-to-end tests by adding a new test set called endToEndTest to our Gradle build. When we add this test set to our Gradle build, we must ensure that the root directory of the created source set is: src/end-to-end-test.

After we have added a new test set to our Gradle build, the relevant part of our build.gradle file looks as follows:

testSets {
    integrationTest { dirName = 'integration-test' }
    endToEndTest { dirName = 'end-to-end-test' }
}

Additional Reading:

This configuration adds a source set called: endToEndTest to our build and configures the root directory of the source set. In other words, the src/end-to-end-test/java directory contains the source code of our our end-to-end tests and the src/end-to-end-test/resources directory contains the resources of our end-to-end tests.

Let’s move on and find out how we can declare the dependencies of our end-to-end tests.

Declaring the Dependencies of Our End-to-End Tests

When we added a new test set to our build, the Gradle TestSets plugin created two dependency configurations that are described in the following:

The endToEndTestCompile dependency configuration contains the dependencies that are required to compile our end-to-end tests. It also contains all dependencies that are required to compile our unit tests.
The endToEndTestRuntime dependency configuration contains the dependencies that are needed when our end-to-end tests are run. It also contains all dependencies that are required to compile our end-to-end tests and to run our unit tests.

In other words, when we want to configure the dependencies of our end-to-end tests, we have to add the following snippet to our build.gradle file:

dependencies {
    endToEndTestCompile(
            //Add dependencies that are required to compile
            //our end-to-end tests.
    )
    endToEndTestRuntime(
            //Add dependencies that are required to run
            //our end-to-end tests.
    )
}

Additional Reading:

Getting Started With Gradle: Dependency Management

Next, we will configure the task that runs our end-to-end tests.

Configuring the Task That Runs Our End-to-End Tests

When we added a test set called endToEndTest to our build, the Gradle TestSets plugin created a task called endToEndTest that runs our end-to-end tests. However, because we need to fulfill the requirements of our Gradle build, we have to make some changes to its configuration. We can make these changes by following these steps:

First, we have to ensure that integration tests are run before end-to-end tests and that end-to-end tests are run when we invoke the build task. We can do this by following these steps:

Ensure that our end-to-end tests are run before the check task and that the check task fails the build if an end-to-end test fails.
Ensure that our integration tests are run before our end-to-end tests. This guarantees that our integration tests are run even if our end-to-end tests fail.

After we have made these changes, the relevant part of our build.gradle file looks as follows:

check.dependsOn integrationTest
check.dependsOn endToEndTest
endToEndTest.mustRunAfter integrationTest
integrationTest.mustRunAfter test

Additional Reading:

Second, we have to configure the endToEndTest task by following these steps:

Ensure that our end-to-end tests are run by JUnit. Even though JUnit is enabled by default, we have to do this because we want to make changes to the JUnit configuration.
Configure JUnit to run only end-to-end tests that belong to the EndToEndTest category. We can do this by setting the fully qualified class name of the EndToEndTest interface as the value of the includeCategories JUnit configuration option.
Ensure that Gradle prints the information that is written to System.out or System.err when our end-to-end tests are run. By the way, we have to do this only if our end-to-end tests write information to System.out.

After we have configured the endToEndTest task, the relevant part of our build.gradle file looks as follows:

endToEndTest {
    useJUnit {
        includeCategories 'com.testwithspring.intermediate.EndToEndTest'
    }
    testLogging {
        showStandardStreams = true
    }
}

Let’s move on and find out how we can start and stop our web application.

Starting and Stopping Our Web Application

Before we can run our end-to-end tests, we have to start our web application before our end-to-end tests are run and stop it after our end-to-end tests have been run. If we are using Spring Framework, we can run our web application by using the Gretty Gradle plugin. We can configure this plugin by following these steps:

First, we have to declare the dependencies of our build script by following these steps:

Configure Gradle to use the Bintray’s JCenter Maven repository when it resolves the dependencies of our build script.
Add the Gretty Gradle plugin dependency to the classpath configuration.

After we have configured the dependencies of our build script, the relevant part of our build.gradle file looks as follows:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath(
        	'io.spring.gradle:dependency-management-plugin:1.0.0.RELEASE',
            'org.unbroken-dome.gradle-plugins:gradle-testsets-plugin:1.2.0',
            'org.akhikhl.gretty:gretty:+'
        )
    }
}

Second, we have to apply the Gretty Gradle plugin. After we have done this, the relevant part of our build.gradle file looks as follows:

apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'io.spring.dependency-management'
apply plugin: 'org.unbroken-dome.test-sets'
apply plugin: 'org.akhikhl.gretty'

Third, we have to configure the Gretty Gradle plugin by following these steps:

Ensure that used servlet container listens to the port 8080.
Configure the context path of our application.
Ensure that our application is run by using Jetty 9.3.
Ensure that Gretty starts our web application before our end-to-end tests are run and stops it after our end-to-end tests have been run.

After we have configured the Gretty Gradle plugin, the relevant part of our build.gradle file looks as follows:

gretty {
    httpPort = 8080
    contextPath = '/'
    servletContainer = 'jetty9.3'
    integrationTestTask = 'endToEndTest'
}

If we are using Spring Boot, we can start and stop our application by leveraging its testing support. We will talk more about this when we learn to configure our end-to-end tests.

Additional Reading:

We are now ready to run our end-to-end tests. Let’s find out how we can do it.