Gradle test task in JUnit - Build an Automation Script

Run JUnit tests using Gradle test task

Preconditions (2)

Step 1: Open terminal or command line at the project root directory

Step 2: Run the command 'gradle test'

Step 3: Observe the console output for test execution results

Step 4: Verify that all tests pass without errors or failures

✅ Expected Result: Gradle runs all JUnit tests and reports test summary showing all tests passed

Automation Requirements - JUnit 5 with Gradle

Assertions Needed:

Verify that the Gradle test task completes successfully

Verify that the test report contains all executed tests

Verify that no tests failed or were skipped

Best Practices:

Use Gradle's built-in test task to run tests

Keep test classes and methods annotated properly with @Test

Use Gradle's test logging to capture detailed test results

Do not hardcode test paths; rely on Gradle conventions

Automated Solution

JUnit

/*
 * This is a sample JUnit 5 test class to be run by Gradle test task.
 * Save this file under src/test/java/com/example/ExampleTest.java
 */
package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class ExampleTest {

    @Test
    void addition_shouldReturnCorrectSum() {
        int result = 2 + 3;
        assertEquals(5, result, "2 + 3 should equal 5");
    }
}

/*
 * To run tests, open terminal at project root and run:
 * gradle test
 *
 * Gradle will compile and run all tests under src/test/java.
 * Test results will be shown in console and saved under build/reports/tests/test/index.html
 */

This code defines a simple JUnit 5 test class with one test method.

The test method checks that 2 + 3 equals 5 using assertEquals. This is a basic assertion to verify test execution.

Gradle automatically detects and runs all tests in src/test/java when you run gradle test.

The test results appear in the console and also generate an HTML report under build/reports/tests/test/index.html.

This setup follows Gradle conventions and JUnit 5 best practices for test automation.

Common Mistakes - 5 Pitfalls

{'mistake': 'Not adding JUnit 5 dependency in build.gradle', 'why_bad': "Without the JUnit 5 dependency, tests won't compile or run, causing build failures.", 'correct_approach': "Add the JUnit 5 dependency in the dependencies block of build.gradle, e.g., implementation 'org.junit.jupiter:junit-jupiter:5.9.3' and configure test task to use JUnit Platform."}

{'mistake': 'Placing test classes outside src/test/java directory', 'why_bad': "Gradle only runs tests located in src/test/java by default, so tests outside won't be executed.", 'correct_approach': 'Always place test classes under src/test/java following package structure.'}

Using JUnit 4 annotations with JUnit 5 dependency

{'mistake': "Running tests with 'gradle build' and ignoring test failures", 'why_bad': "'gradle build' runs tests but may continue build even if tests fail, hiding test failures.", 'correct_approach': "Use 'gradle test' to focus on tests and check test reports carefully."}

{'mistake': 'Hardcoding test class names in Gradle test task configuration', 'why_bad': 'Hardcoding limits flexibility and requires changes when tests change.', 'correct_approach': "Use Gradle's default test discovery which runs all tests automatically."}

Bonus Challenge

Now add data-driven testing with 3 different input values for addition

Show Hint

Practice

1. What is the primary purpose of the Gradle test task in a JUnit project?

easy

A. To compile the Java source code into bytecode

B. To run automated tests and check if the code works correctly

C. To deploy the application to a server

D. To clean the build directory before building

Solution

1. Step 1: Understand the Gradle test task role

   The test task in Gradle is designed to run automated tests, such as those written with JUnit, to verify code correctness.

2. Step 2: Differentiate from other Gradle tasks

   Tasks like compileJava compile code, clean removes build files, and deployment is separate. Only test runs tests.

3. Final Answer:

   To run automated tests and check if the code works correctly -> Option B

4. Quick Check:

   Gradle test = run tests [OK]

Hint: Remember: 'gradle test' runs your tests [OK]

Common Mistakes:

• Confusing test task with compile or clean tasks
• Thinking test deploys the app
• Assuming test cleans build files

2. Which of the following is the correct command to run JUnit tests using Gradle from the terminal?

easy

A. gradle checkTests

B. gradle runTests

C. gradle executeTests

D. gradle test

Solution

1. Step 1: Recall the standard Gradle test command

   The official Gradle command to run tests is gradle test. This triggers the test task which runs JUnit tests.

2. Step 2: Verify other options are invalid

   Commands like runTests, executeTests, and checkTests are not standard Gradle commands and will cause errors.

3. Final Answer:

   gradle test -> Option D

4. Quick Check:

   Run tests with gradle test [OK]

Hint: Use exactly 'gradle test' to run tests [OK]

Common Mistakes:

• Adding extra words like run or execute
• Using non-existent Gradle commands
• Confusing test with build or run

3. Given this snippet in build.gradle:

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "failed"
    }
}

What will be the output when you run gradle test and all tests pass?

medium

A. Both passed and failed test events are shown in the console

B. Only failed tests are shown in the output

C. No output because logging is disabled

D. Only passed tests are shown, failed tests are ignored

Solution

1. Step 1: Understand the testLogging configuration

   The testLogging block with events "passed", "failed" means Gradle will log passed and failed test events when they occur.

2. Step 2: Predict output when all tests pass

   Since all tests pass, passed test events are shown. Failed events do not occur, so they are not shown. Therefore, only passed test events appear in the console.

3. Final Answer:

   Both passed and failed test events are shown in the console -> Option A

4. Quick Check:

   Passed and failed events configured to show; failed events absent if none fail [OK]

Hint: Check testLogging events to know what shows [OK]

Common Mistakes:

• Assuming no output if tests pass
• Thinking only failed tests show by default
• Ignoring testLogging configuration

4. You added this to your build.gradle:

test {
    useJUnitPlatform()
    testLogging {
        events "passed", "failed"
    }
    include '**/MyTests.java'
}

But running gradle test runs no tests. What is the likely problem?

medium

A. The include pattern should use forward slashes and match class files, not source files

B. You forgot to add useJUnit() instead of useJUnitPlatform()

C. The testLogging block disables test execution

D. Gradle test task cannot filter tests by include patterns

Solution

1. Step 1: Understand the include pattern usage

   The include pattern filters test classes by their compiled class file names, not source files. It should match **/MyTests.class or use package style with forward slashes.

2. Step 2: Identify why no tests run

   Using **/MyTests.java does not match any compiled test classes, so no tests run.

3. Final Answer:

   The include pattern should use forward slashes and match class files, not source files -> Option A

4. Quick Check:

   Include matches class files, not .java [OK]

Hint: Include filters need class file patterns, not source files [OK]

Common Mistakes:

• Using .java instead of .class in include patterns
• Confusing useJUnitPlatform with test execution
• Thinking testLogging disables tests

5. You want to customize the Gradle test task to run only tests tagged with @Tag("fast") in JUnit 5. Which build.gradle snippet correctly configures this?

hard

A. test {
includeTags 'fast'
}

B. test {
useJUnitPlatform()
includeTags 'fast'
}

C. test {
useJUnitPlatform {
includeTags 'fast'
}
}

D. test {
useJUnitPlatform()
testLogging {
includeTags 'fast'
}
}

Solution

1. Step 1: Recall how to filter tests by tags in Gradle

   Gradle's useJUnitPlatform accepts a configuration block where you can specify includeTags to run only tests with certain tags.

2. Step 2: Check each option for correct syntax

   test { useJUnitPlatform { includeTags 'fast' } } correctly places includeTags 'fast' inside the useJUnitPlatform block. Other options place it incorrectly or omit useJUnitPlatform.

3. Final Answer:

   test { useJUnitPlatform { includeTags 'fast' } } -> Option C

4. Quick Check:

   Tag filtering goes inside useJUnitPlatform block [OK]

Hint: Put includeTags inside useJUnitPlatform block [OK]

Common Mistakes:

• Placing includeTags outside useJUnitPlatform
• Adding includeTags inside testLogging
• Omitting useJUnitPlatform call