Gradle dependency setup in JUnit - Build an Automation Script

Verify JUnit dependency setup in Gradle project

Preconditions (2)

Step 1: Open the build.gradle file in the project root

Step 2: Add the JUnit Jupiter dependency under the dependencies block: testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'

Step 3: Add the test task configuration to use JUnit Platform

Step 4: Save the build.gradle file

Step 5: Run the command 'gradle test' in the project root directory

Step 6: Observe the test execution output

✅ Expected Result: Gradle downloads the JUnit Jupiter dependency, compiles the test classes, and runs the tests using JUnit Platform. The test task completes successfully with test results displayed.

Automation Requirements - JUnit 5 with Gradle

Assertions Needed:

Verify that the build.gradle file contains the correct JUnit Jupiter dependency line

Verify that the Gradle test task runs successfully without errors

Verify that the test report is generated after running tests

Best Practices:

Use explicit version numbers for dependencies

Use testImplementation configuration for test dependencies

Configure the test task to use JUnit Platform explicitly

Keep build.gradle file clean and well formatted

Automated Solution

JUnit

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import java.io.*;
import java.nio.file.*;
import java.util.stream.*;

public class GradleDependencySetupTest {

    @Test
    void testBuildGradleContainsJUnitDependency() throws IOException {
        Path buildFile = Paths.get("build.gradle");
        assertTrue(Files.exists(buildFile), "build.gradle file should exist");

        try (Stream<String> lines = Files.lines(buildFile)) {
            boolean containsJUnit = lines.anyMatch(line -> line.contains("testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'"));
            assertTrue(containsJUnit, "build.gradle must contain JUnit Jupiter dependency");
        }
    }

    @Test
    void testGradleTestTaskRunsSuccessfully() throws IOException, InterruptedException {
        ProcessBuilder builder = new ProcessBuilder();
        builder.command("gradle", "test");
        builder.redirectErrorStream(true);
        Process process = builder.start();

        String output;
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
            output = reader.lines().collect(Collectors.joining("\n"));
        }

        int exitCode = process.waitFor();
        assertEquals(0, exitCode, "Gradle test task should exit with code 0");
        assertTrue(output.contains("BUILD SUCCESSFUL"), "Gradle build should be successful");
        assertTrue(output.contains("Test run finished"), "Test run output should be present");
    }

    @Test
    void testTestReportIsGenerated() {
        Path reportDir = Paths.get("build", "reports", "tests", "test");
        assertTrue(Files.exists(reportDir), "Test report directory should exist");

        try (Stream<Path> files = Files.list(reportDir)) {
            boolean hasHtmlReport = files.anyMatch(path -> path.toString().endsWith(".html"));
            assertTrue(hasHtmlReport, "Test report HTML file should be present");
        } catch (IOException e) {
            fail("Failed to list test report directory");
        }
    }
}

This test class verifies the Gradle dependency setup for JUnit in three ways:

• testBuildGradleContainsJUnitDependency: Reads the build.gradle file and checks if the JUnit Jupiter dependency line is present. This ensures the dependency is declared correctly.
• testGradleTestTaskRunsSuccessfully: Runs the gradle test command as a process, captures the output, and asserts the build is successful and tests run. This confirms Gradle can execute tests using the dependency.
• testTestReportIsGenerated: Checks if the test report directory and HTML report file exist after running tests. This verifies that test results are generated and accessible.

Each test uses clear assertions with helpful messages. The code uses standard Java APIs and JUnit 5 assertions. This approach simulates a real-world verification of Gradle dependency setup and test execution.

Common Mistakes - 5 Pitfalls

{'mistake': 'Not specifying the JUnit version explicitly in build.gradle', 'why_bad': 'This can cause unpredictable builds if Gradle uses an older or incompatible JUnit version.', 'correct_approach': "Always specify the exact JUnit Jupiter version in the dependency line, e.g., 'org.junit.jupiter:junit-jupiter:5.9.3'."}

{'mistake': "Using 'implementation' instead of 'testImplementation' for JUnit dependency", 'why_bad': 'JUnit is only needed for testing, so including it in the main compile classpath increases build size unnecessarily.', 'correct_approach': "Use 'testImplementation' configuration for test dependencies to keep them separate."}

{'mistake': 'Not configuring the test task to use JUnit Platform', 'why_bad': 'Gradle might not run JUnit 5 tests correctly without this configuration.', 'correct_approach': "Add 'useJUnitPlatform()' in the test task configuration in build.gradle."}

Hardcoding file paths without considering OS differences

Ignoring the test task output and exit code

Bonus Challenge

Now add data-driven testing with 3 different Gradle versions to verify compatibility of JUnit dependency setup.

Show Hint