Java Modularity and Unit Testing: A Comprehensive Guide

In the world of Java development, as applications grow in complexity, managing dependencies and ensuring code quality becomes crucial. Java Modularity (introduced in Java 9) helps in organizing code into modular units, improving encapsulation and maintainability. Unit testing, on the other hand, is a fundamental practice to validate the functionality of individual units (like methods or classes) of code. This blog will explore how these two concepts work together, common practices, best practices, and provide example usage.

Table of Contents#

  1. Understanding Java Modularity
    • What is a Module?
    • Module Declaration (module-info.java)
    • Exporting and Opening Packages
    • Dependencies between Modules
  2. Unit Testing Basics
    • Purpose of Unit Testing
    • Popular Testing Frameworks (JUnit 5 as an Example)
    • Anatomy of a Unit Test
  3. Unit Testing in a Modular Java Project
    • Testing within a Module
    • Testing Dependencies between Modules
    • Mocking in a Modular Context
  4. Common Practices
    • Isolating Tests
    • Test Naming Conventions
    • Continuous Integration with Unit Tests
  5. Best Practices
    • High Test Coverage
    • Writing Readable Tests
    • Keeping Tests Fast
  6. Example Usage
    • A Simple Modular Java Project Structure
    • Writing Unit Tests for a Modular Class
  7. Conclusion
  8. References

1. Understanding Java Modularity#

What is a Module?#

A module in Java is a self - contained unit of code. It can contain packages, classes, and resources. Modules define their own dependencies on other modules and control which of their own packages are accessible to other modules.

Module Declaration (module-info.java)#

Each module has a module-info.java file. For example:

module myapp.module {
    // Declare dependencies
    requires java.base;
    requires another.module;
 
    // Export packages
    exports com.myapp.module.publicpackage;
 
    // Open packages (for reflection in other modules)
    opens com.myapp.module.reflectionpackage;
}

Exporting and Opening Packages#

  • Exporting: When you export a package (exports), other modules that depend on your module can access the public types (classes, interfaces, etc.) in that package.
  • Opening: If a package is opened (opens), other modules can use reflection to access non - public types (like private fields or methods) in that package. This should be used sparingly as it breaks encapsulation.

Dependencies between Modules#

Modules can declare dependencies using the requires keyword. For example, if module A needs functionality from module B, module A will have requires module B; in its module-info.java.

2. Unit Testing Basics#

Purpose of Unit Testing#

Unit testing helps in:

  • Verifying that individual units of code (like methods) work as expected.
  • Catching bugs early in the development cycle.
  • Facilitating refactoring as it provides a safety net.

JUnit 5 is widely used. It has features like:

  • Test Annotations: @Test to mark a method as a test, @BeforeEach to run code before each test, etc.
  • Assertions: Assertions.assertEquals(), Assertions.assertTrue(), etc. to check the expected results.

Anatomy of a Unit Test#

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
 
public class CalculatorTest {
 
    @Test
    public void testAddition() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }
}

In this example:

  • The @Test annotation marks the testAddition method as a test.
  • We create an instance of Calculator (the unit under test).
  • Call the add method and use assertEquals to check if the result is as expected.

3. Unit Testing in a Modular Java Project#

Testing within a Module#

  • Test Structure: Usually, in a modular project, test classes are placed in a separate directory (e.g., src/test/java).
  • Module Declaration for Tests: The test module (if it's a separate module) needs to declare dependencies on the module being tested. For example:
module myapp.module.test {
    requires myapp.module;
    requires junit.jupiter.api;
    exports com.myapp.module.testpackage;
}

Testing Dependencies between Modules#

  • Mocking Dependencies: If a module under test depends on another module, you can use mocking frameworks (like Mockito) to create mock objects. For example, if Module A depends on Module B and you want to test a class in Module A without fully depending on Module B:
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
 
public class ClassInModuleATest {
 
    @Test
    public void testMethod() {
        // Mock an object from Module B
        ObjectFromModuleB mockObject = mock(ObjectFromModuleB.class);
        when(mockObject.someMethod()).thenReturn("mocked result");
 
        ClassInModuleA classA = new ClassInModuleA(mockObject);
        String result = classA.methodUnderTest();
        // Assert the result
    }
}

Mocking in a Modular Context#

  • Module Dependencies for Mocking: The test module needs to declare dependencies on the mocking framework's module (e.g., requires org.mockito.core if using Mockito).

4. Common Practices#

Isolating Tests#

Each test should be independent of others. This means that the execution of one test should not affect the outcome of another. For example, avoid using static variables in tests that can be modified by other tests.

Test Naming Conventions#

Use descriptive names for tests. A common convention is test[MethodName][Scenario]. For example, testAdditionPositiveNumbers clearly indicates what the test is about.

Continuous Integration with Unit Tests#

Integrate unit tests with a continuous integration (CI) tool like Jenkins or GitHub Actions. This ensures that every code change is automatically tested.

5. Best Practices#

High Test Coverage#

Aim for high test coverage (but not at the cost of writing bad tests). Tools like JaCoCo can be used to measure code coverage. However, remember that 100% coverage doesn't guarantee bug - free code.

Writing Readable Tests#

  • Clear Setup: Make it easy to understand what is being tested. Use descriptive variable names in tests.
  • Assertions: Keep assertions simple and focused. If a test has multiple assertions, it may be testing too many things at once.

Keeping Tests Fast#

  • Avoid External Dependencies: Don't rely on slow external services (like databases or web services) in unit tests. Use in - memory databases (for database - related tests) or mocking for web service calls.
  • Parallel Execution: JUnit 5 supports parallel test execution. Configure it appropriately to speed up the test suite.

6. Example Usage#

A Simple Modular Java Project Structure#

myapp/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── myapp.module/
│   │   │       ├── module-info.java
│   │   │       └── com/
│   │   │           └── myapp/
│   │   │               └── module/
│   │   │                   └── MyClass.java
│   └── test/
│       ├── java/
│       │   └── myapp.module.test/
│       │       ├── module-info.java
│       │       └── com/
│       │           └── myapp/
│       │               └── module/
│       │                   └── test/
│       │                       └── MyClassTest.java

Writing Unit Tests for a Modular Class#

MyClass.java (in myapp.module):

package com.myapp.module;
 
public class MyClass {
 
    public int add(int a, int b) {
        return a + b;
    }
}

MyClassTest.java (in myapp.module.test):

package com.myapp.module.test;
 
import com.myapp.module.MyClass;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
 
public class MyClassTest {
 
    @Test
    public void testAdd() {
        MyClass myClass = new MyClass();
        int result = myClass.add(2, 3);
        assertEquals(5, result);
    }
}

7. Conclusion#

Java Modularity helps in organizing code in a more maintainable way, and unit testing is essential for ensuring code quality. By following the practices and best practices outlined in this blog, you can build robust, modular Java applications with reliable unit tests.

8. References#

2026-07