Why integration tests verify component interaction in JUnit - Automation Benefits in Action

Verify interaction between UserService and UserRepository components

Preconditions (2)

Step 1: Create a new user object with name 'Alice' and email '[e-mail]'

Step 2: Call UserService.createUser(user) to save the user

Step 3: Call UserService.getUserByEmail('[e-mail]') to retrieve the user

Step 4: Verify that the retrieved user is not null

Step 5: Verify that the retrieved user's name is 'Alice'

Step 6: Verify that the retrieved user's email is '[e-mail]'

✅ Expected Result: UserService correctly saves and retrieves user data through UserRepository, confirming component interaction

Automation Requirements - JUnit 5

Assertions Needed:

assertNotNull for retrieved user

assertEquals for user name and email

Best Practices:

Use @BeforeEach to set up test data

Use dependency injection or constructor injection for UserService and UserRepository

Use in-memory database for isolation

Keep tests independent and repeatable

Automated Solution

JUnit

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class UserServiceIntegrationTest {

    private UserRepository userRepository;
    private UserService userService;

    @BeforeEach
    void setUp() {
        userRepository = new InMemoryUserRepository(); // simple in-memory implementation
        userService = new UserService(userRepository);
    }

    @Test
    void testCreateAndRetrieveUser() {
        User user = new User("Alice", "[e-mail]");
        userService.createUser(user);

        User retrieved = userService.getUserByEmail("[e-mail]");

        assertNotNull(retrieved, "Retrieved user should not be null");
        assertEquals("Alice", retrieved.getName(), "User name should match");
        assertEquals("[e-mail]", retrieved.getEmail(), "User email should match");
    }
}

// Supporting classes for completeness
class User {
    private final String name;
    private final String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() { return name; }
    public String getEmail() { return email; }
}

interface UserRepository {
    void save(User user);
    User findByEmail(String email);
}

class InMemoryUserRepository implements UserRepository {
    private final Map<String, User> storage = new HashMap<>();

    @Override
    public void save(User user) {
        storage.put(user.getEmail(), user);
    }

    @Override
    public User findByEmail(String email) {
        return storage.get(email);
    }
}

class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser(User user) {
        userRepository.save(user);
    }

    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}

This test verifies the interaction between UserService and UserRepository. The @BeforeEach method sets up a fresh in-memory repository and service before each test to keep tests independent.

The test testCreateAndRetrieveUser creates a user, saves it via UserService, then retrieves it by email. Assertions check that the retrieved user is not null and that the name and email match the input.

This confirms that UserService correctly uses UserRepository to store and fetch data, which is the core purpose of integration testing: verifying that components work together as expected.

Common Mistakes - 3 Pitfalls

Testing UserService methods without verifying UserRepository interaction

Using a real database instead of an in-memory database for integration tests

Not resetting data between tests

Bonus Challenge

Now add data-driven testing with 3 different user inputs to verify component interaction for multiple cases

Show Hint

Practice

1. Why do integration tests verify component interaction in JUnit testing?

easy

A. To measure the performance of individual components

B. To check if different parts of the system work together correctly

C. To test a single method in isolation

D. To check the syntax of the code

Solution

1. Step 1: Understand the purpose of integration tests

   Integration tests focus on verifying how multiple components interact, not just individual parts.

2. Step 2: Compare with other test types

   Unit tests check single methods, performance tests measure speed, and syntax checks are done by compilers, so these are not the focus of integration tests.

3. Final Answer:

   To check if different parts of the system work together correctly -> Option B

4. Quick Check:

   Integration tests = component interaction check [OK]

Hint: Integration tests check multiple parts working together [OK]

Common Mistakes:

• Confusing integration tests with unit tests
• Thinking integration tests check only one method
• Assuming integration tests measure performance

2. Which JUnit annotation is commonly used to write an integration test method?

easy

A. @Test

B. @BeforeEach

C. @Mock

D. @Ignore

Solution

1. Step 1: Identify the annotation for test methods

   The @Test annotation marks a method as a test method in JUnit, used for both unit and integration tests.

2. Step 2: Understand other annotations

   @BeforeEach runs setup code before each test, @Mock creates mock objects, and @Ignore skips tests; none define test methods themselves.

3. Final Answer:

   @Test -> Option A

4. Quick Check:

   @Test marks test methods [OK]

Hint: Use @Test to mark integration test methods [OK]

Common Mistakes:

• Using @BeforeEach as test method annotation
• Confusing @Mock with test method annotation
• Thinking @Ignore runs tests

3. Given the following JUnit integration test snippet, what will be the assertion result?

public class ServiceIntegrationTest {
  @Test
  void testServiceAndRepoInteraction() {
    Service service = new Service(new Repository());
    String result = service.processData("input");
    assertEquals("processed: input", result);
  }
}

medium

A. Test fails due to null pointer exception

B. Test fails because assertion compares wrong values

C. Test passes because service processes input correctly

D. Test fails due to syntax error

Solution

1. Step 1: Analyze the test setup and method call

   The Service is created with a Repository, then processData is called with "input" which returns "processed: input".

2. Step 2: Check the assertion

   The assertion expects "processed: input" which matches the returned result, so the assertion will pass.

3. Final Answer:

   Test passes because service processes input correctly -> Option C

4. Quick Check:

   Expected = Actual = test passes [OK]

Hint: Match expected and actual strings in assertions [OK]

Common Mistakes:

• Assuming null pointer without checking code
• Confusing expected and actual in assertEquals
• Thinking syntax error exists in valid code

4. Identify the error in this JUnit integration test code snippet:

@Test
void testUserService() {
  UserService userService = new UserService(null);
  String name = userService.getUserName(1);
  assertEquals("Alice", name);
}

medium

A. Passing null to UserService causes NullPointerException

B. assertEquals arguments are reversed

C. Missing @BeforeEach annotation

D. Test method name is invalid

Solution

1. Step 1: Check object initialization

   UserService is created with null, likely causing a NullPointerException when getUserName is called.

2. Step 2: Review assertion and annotations

   assertEquals arguments are correct, @BeforeEach is optional, and method name is valid, so no errors there.

3. Final Answer:

   Passing null to UserService causes NullPointerException -> Option A

4. Quick Check:

   Null input causes runtime error [OK]

Hint: Check object dependencies are not null [OK]

Common Mistakes:

• Assuming assertion arguments are reversed
• Thinking @BeforeEach is mandatory for all tests
• Believing method names must follow special rules

5. In a JUnit integration test, why is it important to verify the interaction between Service and Repository components rather than testing them separately?

hard

A. Because testing components separately is not possible in JUnit

B. Because unit tests cannot test any logic inside components

C. Because integration tests run faster than unit tests

D. Because integration tests reveal issues in how components communicate and share data

Solution

1. Step 1: Understand integration test purpose

   Integration tests check if components like Service and Repository work together correctly, including data passing and method calls.

2. Step 2: Compare with unit tests and other options

   Unit tests do test logic inside components, integration tests are usually slower, and JUnit supports both separate and combined tests.

3. Final Answer:

   Because integration tests reveal issues in how components communicate and share data -> Option D

4. Quick Check:

   Integration tests = communication check [OK]

Hint: Integration tests find communication bugs between parts [OK]

Common Mistakes:

• Thinking unit tests cannot test logic
• Assuming integration tests are faster
• Believing JUnit can't test components separately