The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Unit Testing with JUnit

Next ►
►

Unit testing is a crucial part of software development that ensures individual components of your application work as expected. In this section, we will explore how to perform unit testing in a Spring Boot application using JUnit.

What is Unit Testing?

Unit testing involves testing individual units or components of a software application. The goal is to validate that each unit of the software performs as designed. A unit is the smallest testable part of any software, typically a function or method.

Why Use JUnit for Unit Testing?

JUnit is a popular testing framework for Java applications. It provides:

  • Annotations to identify test methods.
  • Assertions to test expected results.
  • Test runners to execute tests and report results.

Setting Up JUnit in Spring Boot

Spring Boot projects typically include JUnit by default. If not, you can add it to your pom.xml (for Maven) or build.gradle (for Gradle).

Maven Dependency

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

Gradle Dependency

testImplementation 'org.springframework.boot:spring-boot-starter-test'

Writing Your First Unit Test

Let's create a simple Spring Boot application and write a unit test for a service class.

Step 1: Create a Spring Boot Application

  1. Create a new Spring Boot project.
  2. Add a simple service class.
package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class CalculatorService {
    public int add(int a, int b) {
        return a + b;
    }
}

Step 2: Write a Unit Test for the Service Class

  1. Create a test class in the src/test/java directory.
  2. Use JUnit annotations to define test methods.
package com.example.demo.service;

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

public class CalculatorServiceTest {

    private final CalculatorService calculatorService = new CalculatorService();

    @Test
    public void testAdd() {
        int result = calculatorService.add(2, 3);
        assertEquals(5, result, "2 + 3 should equal 5");
    }
}

Explanation of the Test Code

  • @Test: Marks the method as a test method.
  • assertEquals(expected, actual, message): Asserts that the expected value equals the actual value. If not, the test fails with the provided message.

Running the Tests

You can run the tests using your IDE, Maven, or Gradle.

Using IDE

Most IDEs like IntelliJ IDEA or Eclipse allow you to run tests directly from the editor.

Using Maven

mvn test

Using Gradle

gradle test

Practical Exercises

Exercise 1: Write a Unit Test for a Subtraction Method

  1. Add a subtract method to the CalculatorService class.
public int subtract(int a, int b) {
    return a - b;
}
  1. Write a unit test for the subtract method.
@Test
public void testSubtract() {
    int result = calculatorService.subtract(5, 3);
    assertEquals(2, result, "5 - 3 should equal 2");
}

Solution

@Test
public void testSubtract() {
    int result = calculatorService.subtract(5, 3);
    assertEquals(2, result, "5 - 3 should equal 2");
}

Exercise 2: Test Edge Cases

  1. Add edge case tests for the add and subtract methods.
@Test
public void testAddWithNegativeNumbers() {
    int result = calculatorService.add(-2, -3);
    assertEquals(-5, result, "-2 + -3 should equal -5");
}

@Test
public void testSubtractWithNegativeNumbers() {
    int result = calculatorService.subtract(-5, -3);
    assertEquals(-2, result, "-5 - -3 should equal -2");
}

Solution

@Test
public void testAddWithNegativeNumbers() {
    int result = calculatorService.add(-2, -3);
    assertEquals(-5, result, "-2 + -3 should equal -5");
}

@Test
public void testSubtractWithNegativeNumbers() {
    int result = calculatorService.subtract(-5, -3);
    assertEquals(-2, result, "-5 - -3 should equal -2");
}

Common Mistakes and Tips

  • Not Isolating Tests: Ensure each test is independent and does not rely on the outcome of another test.
  • Ignoring Edge Cases: Always test edge cases, such as negative numbers, zero, and large values.
  • Not Using Assertions Properly: Use the appropriate assertion methods provided by JUnit to validate test outcomes.

Conclusion

In this section, we covered the basics of unit testing in Spring Boot using JUnit. We learned how to set up JUnit, write simple unit tests, and run them. We also explored practical exercises to reinforce the concepts. Unit testing is an essential skill for any developer, and mastering it will help you build robust and reliable applications.

Next, we will delve into integration testing, where we will test how different parts of the application work together.

◄ Previous
◄
Next ►
►

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved