Unit testing concept in JUnit - Framework Patterns

Framework Mode - Unit testing concept

Folder Structure

project-root/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── example/
│   │               └── app/
│   │                   └── Calculator.java
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── app/
│                       └── CalculatorTest.java
├── pom.xml
└── README.md
    

This is a typical Maven project structure for JUnit unit tests. Production code is under src/main/java. Test code is under src/test/java.

Test Framework Layers

• Production Code Layer: Contains the actual classes and methods to be tested (e.g., Calculator.java).
• Test Layer: Contains JUnit test classes with test methods that verify small units of code (e.g., CalculatorTest.java).
• Utilities Layer: Helper classes or methods for common test tasks (optional in simple unit tests).
• Configuration Layer: Handles test settings like test profiles or environment variables.

Configuration Patterns

Unit tests usually run in a simple environment, but configuration can include:

• Build Tool Config: Use pom.xml to add JUnit dependency and configure test execution.
• Test Profiles: Use Maven profiles or system properties to switch configurations if needed.
• Mocking Setup: Configure mocking frameworks (like Mockito) if tests need to isolate units.

<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>5.9.3</version>
  <scope>test</scope>
</dependency>
    

Test Reporting and CI/CD Integration

• JUnit Reports: Maven Surefire plugin generates XML and HTML reports after test runs.
• CI/CD Integration: Configure Jenkins, GitHub Actions, or GitLab CI to run tests on each commit.
• Fail Fast: Tests fail quickly if a unit test fails, preventing broken code from progressing.
• Code Coverage: Integrate tools like JaCoCo to measure how much code is tested.

Best Practices for Unit Testing Framework

1. Isolate Tests: Each test should test one small piece of code independently.
2. Use Descriptive Names: Test method names should clearly say what they check.
3. Keep Tests Fast: Unit tests should run quickly to encourage frequent runs.
4. Arrange-Act-Assert Pattern: Structure tests with setup, action, and verification steps.
5. Use Assertions Properly: Assert expected results clearly to catch errors early.

Self Check

Where in this folder structure would you add a new unit test class for a new feature called StringUtils?

Key Result

Organize unit tests under src/test/java mirroring production code, use JUnit for isolated, fast, and clear tests with proper configuration and reporting.

Practice

1. What is the main purpose of a unit test in JUnit?

easy

A. To check small parts of code for errors early

B. To test the entire application at once

C. To deploy the application automatically

D. To write documentation for the code

Solution

1. Step 1: Understand unit test scope

   Unit tests focus on small parts or units of code, not the whole app.

2. Step 2: Identify main goal

   The goal is to find errors early by testing these small parts individually.

3. Final Answer:

   To check small parts of code for errors early -> Option A

4. Quick Check:

   Unit test purpose = check small code parts early [OK]

Hint: Unit tests check small code parts, not whole app [OK]

Common Mistakes:

• Confusing unit tests with integration or system tests
• Thinking unit tests deploy or document code
• Assuming unit tests cover the entire application

2. Which annotation is used in JUnit to mark a method as a test?

easy

A. @Run

B. @Assert

C. @Test

D. @Check

Solution

1. Step 1: Recall JUnit test annotation

   JUnit uses @Test to mark methods as tests.

2. Step 2: Verify other options

   @Run, @Check, and @Assert are not valid JUnit test annotations.

3. Final Answer:

   @Test -> Option C

4. Quick Check:

   JUnit test method = @Test annotation [OK]

Hint: JUnit test methods use @Test annotation [OK]

Common Mistakes:

• Using @Run instead of @Test
• Confusing @Assert with test annotation
• Assuming @Check is a JUnit annotation

3. What will be the result of this JUnit test?

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

public class CalcTest {
    @Test
    void testSum() {
        int result = 2 + 3;
        assertEquals(5, result);
    }
}

medium

A. Test passes successfully

B. Test fails with assertion error

C. Compilation error due to missing import

D. Runtime exception occurs

Solution

1. Step 1: Analyze the test logic

   The test calculates 2 + 3 and stores 5 in result.

2. Step 2: Check assertion

   assertEquals(5, result) compares expected 5 with actual 5, so it matches.

3. Final Answer:

   Test passes successfully -> Option A

4. Quick Check:

   2+3=5 matches expected 5 [OK]

Hint: If expected equals actual, test passes [OK]

Common Mistakes:

• Assuming test fails when values match
• Thinking import is missing (it's present)
• Expecting runtime errors without cause

4. Identify the error in this JUnit test code:

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

public class SampleTest {
    @Test
    public void testMultiply() {
        int result = 3 * 4
        assertEquals(12, result);
    }
}

medium

A. Incorrect import statement

B. Wrong assertion method used

C. Test method missing @Test annotation

D. Missing semicolon after multiplication statement

Solution

1. Step 1: Check syntax in testMultiply method

   The line 'int result = 3 * 4' is missing a semicolon at the end.

2. Step 2: Verify other parts

   @Test annotation is present, assertion method is correct, imports are correct.

3. Final Answer:

   Missing semicolon after multiplication statement -> Option D

4. Quick Check:

   Java statements need semicolons [OK]

Hint: Look for missing semicolons in Java test methods [OK]

Common Mistakes:

• Ignoring missing semicolon errors
• Thinking @Test annotation is missing
• Assuming wrong assertion method

5. You want to write a unit test that checks if a method throws an exception when given invalid input. Which JUnit 5 feature should you use?

hard

A. Use @BeforeEach to catch exceptions

B. assertThrows to verify the exception is thrown

C. assertEquals to compare exception messages

D. Use @Disabled to skip the test

Solution

1. Step 1: Understand exception testing in JUnit 5

   JUnit 5 provides assertThrows to check if a specific exception is thrown by code.

2. Step 2: Evaluate other options

   assertEquals compares values, not exceptions; @BeforeEach runs before tests; @Disabled skips tests.

3. Final Answer:

   assertThrows to verify the exception is thrown -> Option B

4. Quick Check:

   Use assertThrows for exception tests [OK]

Hint: Use assertThrows to test exceptions in JUnit 5 [OK]

Common Mistakes:

• Using assertEquals to check exceptions
• Misusing @BeforeEach for exception handling
• Disabling tests instead of testing exceptions