0Pricing
Groovy & Gradle: JVM Automation and Build Engineering · Pelajaran

Pengujian Unit & Integrasi

Konfigurasikan Gradle untuk menjalankan pengujian JUnit, TestNG, atau Spock, serta mengelola dependensi pengujian.

Pengujian Unit & Integrasi adalah pelajaran Groovy & Gradle: JVM Automation and Build Engineering gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Groovy & Gradle: JVM Automation and Build Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Why Test? Gradle's Role

Automated testing is crucial for software quality. It helps find bugs early and ensures your code works as expected after changes.

Gradle provides excellent built-in support for running various types of tests, making it easy to integrate testing into your build process.

  • Unit Tests: Verify small, isolated parts of your code.
  • Integration Tests: Check how different parts of your system work together.

Gradle's Default Test Setup

When you apply the java plugin in Gradle, it automatically configures a test task for you. This task is responsible for finding and running your unit tests.

By default, Gradle looks for test classes in src/test/java (or src/test/groovy) and expects them to follow standard naming conventions (e.g., ending with Test).

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}
// The 'java' plugin automatically creates a 'test' task.
// No explicit 'test' task definition needed here.

Integrating JUnit 5

To write tests, you need a testing framework. JUnit 5 is a popular choice for Java and Groovy. You declare it as a testImplementation dependency in your build.gradle file.

testImplementation means the dependency is only available when compiling and running tests, not for your main application code.

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
}

Your First Unit Test

Let's create a simple Calculator class. We'll add a main method to this class to make it runnable for demonstration. Unit tests will then verify its methods independently.

package com.coddykit;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println("2 + 3 = " + calc.add(2, 3));
    }
}

Writing Your Unit Test

Now, let's write a JUnit 5 test for our Calculator. This test will verify the add method works correctly. Gradle's test task will find and run this test.

package com.coddykit;

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

public class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3), "2 + 3 should be 5");
    }
}

Run Tests with Gradle

To run your unit tests, simply execute the test task from your project's root directory in the command line. Gradle will compile your tests, run them, and report the results.

A successful run means all tests passed! If a test fails, Gradle will show you the details.

// In your terminal, navigate to the project root and run:
// gradle test
//
// Expected output will include details about test execution.
// Example excerpt:
// > Task :test
// com.coddykit.CalculatorTest > testAdd() PASSED
//
// BUILD SUCCESSFUL in ...

Reviewing Test Results

After running tests, Gradle generates detailed reports. By default, these reports are found in the build/reports/tests/test directory.

You'll find an HTML report (index.html) that provides a user-friendly overview of all test runs, including successes, failures, and skipped tests.

  • HTML Report: Visual summary of all tests.
  • XML Report: Machine-readable format for CI/CD tools.
// Locate your test reports here:
// build/reports/tests/test/index.html

What are Integration Tests?

While unit tests check isolated components, integration tests verify that different parts of your application work correctly when combined.

They often involve interacting with databases, APIs, or other external services, making them slower but crucial for overall system health.

  • Unit Tests: Fast, isolated, test single units.
  • Integration Tests: Slower, involve multiple components, test interactions.

Separate Integration Source Set

It's good practice to separate integration tests from unit tests. This allows you to run them independently. You can do this by defining a new source set in your build.gradle.

This source set will have its own compilation and runtime classpath, distinct from your main and unit test code.

// build.gradle
plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

sourceSets {
    integrationTest {
        java {
            srcDirs = ['src/integrationTest/java']
        }
        resources {
            srcDirs = ['src/integrationTest/resources']
        }
        compileClasspath += main.output + test.output
        runtimeClasspath += main.output + test.output
    }
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'

    integrationTestImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    integrationTestRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
    // Add other integration-specific dependencies here
}

Custom Task for Integration Tests

Once you have a separate source set, you need a custom Gradle task to run your integration tests. This task will be of type Test and configured to use your integrationTest source set.

You can then run this task from the command line: gradle integrationTest. It's common to make the check task depend on integrationTest so that gradle check runs both unit and integration tests.

// build.gradle (continued from previous scene)
task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    shouldRunAfter test // Ensures unit tests run first
}

check.dependsOn integrationTest // Make 'check' task also run integration tests

Quick Check: Test Types

Consider the following scenarios:

  1. Testing a single method of a utility class without any external dependencies.
  2. Testing if your application can successfully connect to a database and retrieve data.

Which scenario best describes a unit test, and which describes an integration test?

Recap: Unit & Integration Testing

Great job! You've learned how to set up and run tests with Gradle.

  • Gradle's java plugin provides a default test task.
  • We added JUnit 5 dependencies using testImplementation.
  • We wrote and ran basic unit tests using gradle test.
  • We understood the difference between unit and integration tests.
  • We configured a separate source set and custom task for integration tests.

Next, we'll explore how to generate and interpret detailed test reports!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengujian Unit & Integrasi” gratis?

Ya — teks lengkap “Pengujian Unit & Integrasi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Groovy & Gradle: JVM Automation and Build Engineering, upgrade ke CoddyKit PRO. Kursus Groovy & Gradle: JVM Automation and Build Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengujian Unit & Integrasi”?

Konfigurasikan Gradle untuk menjalankan pengujian JUnit, TestNG, atau Spock, serta mengelola dependensi pengujian. Kamu berlatih Groovy & Gradle: JVM Automation and Build Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Groovy & Gradle: JVM Automation and Build Engineering?

Tidak diperlukan pengalaman sebelumnya. Groovy & Gradle: JVM Automation and Build Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Pengujian Unit & Integrasi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Groovy & Gradle: JVM Automation and Build Engineering ini?

Ya. Setiap pelajaran Groovy & Gradle: JVM Automation and Build Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengujian Unit & Integrasi
  2. Laporan & Penyaringan Pengujian
  3. Cakupan Kode & Analisis Statis
  4. Fixture Pengujian dan Kode Pengujian Bersama
← Kembali ke Groovy & Gradle: JVM Automation and Build Engineering