Java Unit Testing With JUnit

Testing is an integral aspect of the software development process, ensuring the delivery of a quality application. Conducting a series of tests helps identify and eliminate bugs and issues within the system. Among them, the unit test is used to validate the behavior of the specific section of the code. 

A variety of frameworks are available that can get you started with unit testing. Established Java development company leverages JUnit for this purpose, as it simplifies the Java unit testing process. It is important to learn about its intricacies and implementation. 

Therefore, this blog focuses on the overview of unit testing, its benefits, the JUnit testing framework, and how to use it to write and execute unit tests. 

1. Overview of Unit Testing

Unit testing is an integral part of the testing and QA process, It focuses on identifying errors and bugs in various parts of the code. It is a method to validate that individual components or units in a software program are functioning properly. Java testing frameworks and tools like TestNG and JUnit are used to write automated tests to verify the behavior of isolated code units, including the units of code like interfaces, classes, and methods. 

Testing every unit in isolation ensures that they work up to expectations. In the case of failure, it is easy to pinpoint which unit is not functioning correctly. For example, unit testing is a QA technique used to break down an app code into building blocks and examine them separately to find if they are defective. When every component works well individually, you have a fully functional application. 

Unit testing is effective for multiple reasons.

• Error Detection at Early Stages: It is performed as soon as a programmer writes the code helping prevent bugs from propagating to other code components.
• Improved Debugging: Unit testing allows you to easily pinpoint the location of a problem by breaking the code into several smaller units.
• Makes the Process Agile: You can refactor the code with the help of unit tests because any issues introduced by your changes can be quickly identified.
• Documentation: When developers write unit tests describing the working of a particular piece, they are effectively documenting their work.
• Improved Software Design: Test-driven development or TDD is used as a reference to write easily testable code leading to better-designed software. 

2. Overview of JUnit

JUnit is a Java-based framework designed for unit testing. Programmers can use this open-source framework for writing and running automated tests. Every time you add a new code in Java, it’s essential to re-execute the tests to ensure that changes don’t break the existing app functionalities. 

You can quickly write tests for your app code to validate its behavior with the help of a range of assertions and annotations from JUnit. It organizes these tests into different classes, comprising methods to assess specific aspects of Java code. 

JUnit provides different types of graphs that allow you to track the progress of the test. If the graph indicates a green color, then it means the tests are running smoothly. However, the test is considered a failure if it shows a red color. 

JUnit simplifies the process of writing efficient and reliable tests in different programming languages. Primarily used for unit testing, JUnit also supports other tests like integration testing and functional testing. 

3. Why Use JUnit For Java Unit Testing?

Using JUnit, you can write unit tests and find and fix bugs at an early stage of the development process. This can speed up Java development and help you deliver high-quality software solutions. If your project prioritizes quality or demands a test-driven development approach, then JUnit is an ideal option for you. 

JUnit allows you to create automated tests that can be seamlessly integrated into the development workflow. You have to write the tests, run them, and then sit back and wait for the results. There is no need to test everything manually. Tests written with JUnit enable you to validate the code behavior at the unit level. 

Many reasons make JUnit a compelling choice for Java unit testing. Its adherence to Test-Driven Development (TDD) principles, offers seamless integration with IDE. Additionally, JUnit is compatible with Continuous Integration/Continuous Deployment (CI/CD) practices and boasts a rich set of features., Its strong community support further enhances its utility. With its extensive ecosystem, Junit makes it easy to write efficient, reliable, and maintainable unit tests to ensure Java code quality.

4. Setting Up the Environment

Below is a step-by-step process for setting up JUnit for a Java project. 

Step 1: Check For Java Installation

Open the terminal and run the following command. 

Running the above command shows if there is any version of Java installed in your system. If Java is not installed, then go to its official website to download the latest version of Java Development Kit. 

Step 2: Set JAVA Environment

As the below image shows, set the JAVA_HOME environment variable to the root directory location on your system. It’s where Java is installed. 

You also need to add the Java compiler’s location to the System Path. 

Step 3: Download the IDE of Your Choice

Now, pick a suitable IDE or text editor, such as Visual Studio Code, IntelliJ IDEA, and Eclipse for Java programming. Install an IDE you prefer to use in your system. 

Step 4: Create a Project Folder

Open your IDE and create a new project. The process of new project creation is different in different IDEs.

Step 5: Configuring Build Tools

Now, you need to pick the right build tools, such as Gradle and Maven, for your Java project. We will go through the instructions for both of them. 

1. Using Maven

Create a new file named pom.xml in the root directory of your project that serves as the configuration file for Maven. Add a few dependencies to this pom.xml as shown below.

Save the pom.xml file. Now, whenever you build your project, Maven will automatically download the JUnit 5 dependencies. 

2. Using Gradle:

Go to the root directory of your project and open the build.gradle. It would have the Gradle build script. Go to the dependencies section of the build.gradle file and add the following dependencies to it.

Save the build.gradle file. Whenever you build your project, the Gradle will automatically download the JUnit 5 dependencies.

Once the dependencies are all set up, you can start writing unit tests with JUnit. Create a new test class and use @Test to annotate the test methods. Run the Gradle or Maven commands or use your IDE to execute the unit tests. 

Further Reading on: Java IDEs for Java Development

5. How to Write Unit Tests for Java with JUnit?

Unit testing involves specifying inputs to explore specific paths in the software and determining the expected output. The test passes if the code returns the expected value. If not, it is considered as a failure. In the event of a failure, programmers would then have to address the issues and re-test the unit of code until it passes.

Before you start writing test cases with JUnit, set up a test method for every isolated unit you want to test. Identify the test methods using annotations and determine the appropriate execution order and timing for each one. 

Every test method is equipped with one or more assertions, which are static methods that are used to compare the actual results with the expected ones. That ought to determine whether the tested unit works up to expectations or not. 

Let’s see how we can use JUnit for Java unit testing. The process given below utilizes Maven and JUnit 5 for unit testing in Java. 

6. How to Use Maven and JUnit to Write Unit Tests?

This section provides you with a step-by-step guide to writing unit tests in Java with the help of build systems like Maven and automated testing frameworks like JUnit.

6.1 Setting Up an Empty Maven Project

Download JUnit and then configure it as a dependency for the project to write and run unit tests. We would accomplish that by using Maven here. To create a simple structure for your Maven project, follow the steps as shown in the below Screenshots.

Finishing these steps will create a directory structure given below in the “unitTesting” directory in your Maven project.

Now, it’s time to edit the pom.xml file to add JUnit and get started with unit testing. 

6.2 Adding JUnit to Maven

You can add JUnit to your Maven project by adding it to the latter’s dependencies tag. Open your pom.xml file and add the following dependency tag inside it. If the Maven already has a JUnit dependency, then replace it with the latest because we are using JUnit 5 to write unit tests. Once you are done with it, the code snippet of your dependencies tag will look like this.

<dependencies>
	<dependency>
		<groupId>org.junit.jupiter</groupId>
		<artifactId>junit-jupiter-engine</artifactId>
		<version>5.11.3</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Add the Surefire plugin from Maven to the pom.xml file’s build plugin tag to allow it to find and run unit tests. 

<build>
	<plugins>
		<plugin>
			<groupId>org.apache.maven.plugins</groupId>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.8.1</version>
		</plugin>
	</plugins>
</build>

To enable the Maven to find the tests, adhere to the Maven naming conventions. It includes post-fixing the test class with “Test” and adding the test files inside src/test/java directory with the appropriate package.

Here we are testing a geometrical Triangle class representing a triangle. It can tell if the perimeter of the triangle is calculated correctly or not using sides a, b, and c.

You can find the Triangle class in here.

Add your test file inside src/test/java in com.junit.demo.unitTesting package. 

To save the file in another directory, just configure the Maven using the testSourceDirectory property in your POM file. 

6.3 Creating Your First JUnit Test

Here, we will use a given signature to get the Perimeter of the Triangle.

public double getPerimeter() {
        return sideA + sideB + sideC;
 }

The getPerimeter method in the Triangle class calculates and returns the perimeter of a triangle by summing up the lengths of its three sides: sideA, sideB, and sideC.

Unit Test Code:

package com.junit.demo.unitTesting;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Tag;
public class TriangleTest {
	@Test
	void testPerimeterCalculation() {
		Triangle triangle = new Triangle(3, 4, 5);
		double perimeter = triangle.getPerimeter();
		assertEquals(12, perimeter);
	}
}

The testPerimeterCalculation method is a JUnit test that checks if the getPerimeter method in the Triangle class works correctly. Here’s a step by step process of what it does.

1. Create a Triangle: It creates a triangle with sides 3, 4, and 5.
2. Calculate the Perimeter: Calls the getPerimeter method to get the perimeter.
3. Check the Result: Compares the result to the expected value of 12 using assertEquals.

If the calculated perimeter matches the expected value (12), the test passes. If not, it fails, signaling an issue with the perimeter calculation.

You can easily check the actual behavior of a code unit with the help of a large range of assertion methods available in JUnit 5 documentation. 

6.4 Running Your JUnit Tests

After adding all the JUnit dependencies and configuring the Maven, you can run the tests and evaluate the results. JUnit allows you to run the tests directly from the command line in the IDE. You can also use the preferred build system like Gradle or Maven. Here, in this example, we are utilizing Maven on the command line to simplify running the JUnit tests. 

Use the following command to run the whole test suite.

mvn test

If you only want to run tests from certain test classes then utilize the following command.

Passing testing running in the command line would give an output looking like this. 

The above code shows that a single unit test was conducted which ran for 0.067ms and passed. A failing test would give an output like this. 

7. How to Filter JUnit Tests Using Tags?

JUnit enables you to categorize the test cases and execute groups of unit tests together. Categorization helps you find the test type and determine in which phase of CI you need to run it. You can also define the environment in which to conduct the test for example, whether to perform a unit test only in development or during both production and testing. 

To group test cases, use @Tag annotation and filter relevant test cases. Add the tag by running the below code.

package com.junit.demo.unitTesting;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Tag;
public class TriangleTest {
	@Tag("unitTestingForPerimeterCalculation")
	@Test
	void testPerimeterCalculation() {
		Triangle triangle = new Triangle(3, 4, 5);
		double perimeter = triangle.getPerimeter();
		assertEquals(12, perimeter);
	}
}

To filter the tests tagged with unittest from the Maven’s command line:

8. Unit Testing Best Practices

After getting a detailed understanding of the fundamentals of unit testing, we have also learned how to write tests effectively. But just writing tests for the sake of it won’t cut it. You need to write it well or you won’t get accurate results. Therefore, this section offers best practices for writing unit tests in Java. 

8.1 Create Simple Tests

Testing doesn’t require complicated code. It’s best to keep your test codes as simple as possible. A complex code would be riddled with errors. A simple code that can indicate the possible execution path would have minimal errors. Because of that, the test would be more efficient and the results more accurate. 

8.2 Follow the AAA Pattern

The Arrange, Act, and Assert structure, widely known as the AAA pattern, helps write readable unit tests and organize them. 

First, you have to Arrange everything for the unit test. This includes setting variables, instantiating objects, defining expected results, and doing the necessary setup to run the test. 

Naturally, after thorough planning, comes action. Once you have arranged for a unit test, Act. This means running the tests and saving their results.

Next, analyze the results and Assert whether a particular unit of code is behaving up to expectations. Match the expected results against the obtained ones in this step. Unit test frameworks such as JUnit offer several assertion methods, also known as matches, used specifically for this purpose. 

8.3 Write Deterministic Tests

You need to create a unit test with consistent behavior. For example, when you execute the test on the same code 10 times, then the test must deliver the same result every time. The test must either succeed 10 times or fail. Such inconsistent behavior often indicates problems in the tests. This happens when you don’t write deterministic tests or when they rely on external dependencies, environmental values, and other test cases. 

You can run the deterministic and independent unit tests under any setting. Having a non-deterministic test makes it difficult to understand the problem in the code, rendering the tests useless. 

9. Conclusion

JUnit is a robust Java framework that simplifies unit testing. It’s an indispensable tool for both beginners and experienced developers alike. Providing a rich set of features, including test suites, assertions, and annotations, JUnit helps you create reliable unit tests to deliver high-quality software applications. 

In this article, we discussed unit testing, and its benefits along with the JUnit testing framework, and how to write and run unit tests in Java. We also looked at the unit testing best practices to ensure that your Java code remains robust, reliable, and easily maintainable.