Why integration tests verify component interaction in JUnit - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Integration Tests

Why do integration tests focus on verifying the interaction between components rather than testing components individually?

A Because integration tests focus on performance metrics rather than component behavior.

B Because integration tests only test the user interface without checking backend logic.

C Because integration tests replace unit tests by testing components in isolation.

D Because integration tests check if components work together correctly, catching issues missed by unit tests.

💡 Hint

Think about what happens when separate parts of a system connect and exchange data.

Integration tests verify that different components communicate and work together as expected. Unit tests check components alone, but integration tests catch problems in their interaction.

❓ Predict Output

intermediate

JUnit Integration Test Result

What will be the result of this JUnit integration test that verifies interaction between two components?

JUnit

class ServiceA {
    ServiceB b;
    ServiceA(ServiceB b) { this.b = b; }
    String callB() { return b.getData(); }
}

class ServiceB {
    String getData() { return "data"; }
}

@Test
void testServiceAandBInteraction() {
    ServiceB b = new ServiceB();
    ServiceA a = new ServiceA(b);
    assertEquals("data", a.callB());
}

A Test fails due to compilation error in ServiceA constructor.

B Test fails because assertEquals compares wrong values.

C Test passes because ServiceA correctly calls ServiceB and returns expected data.

D Test fails due to NullPointerException because ServiceB is not initialized.

💡 Hint

Check if ServiceB is properly created and passed to ServiceA.

The test passes because ServiceB is instantiated and injected into ServiceA. The call to ServiceB's method returns "data" as expected.

❓ assertion

advanced

Correct Assertion for Component Interaction

Which assertion best verifies that two components interact correctly by checking the output of their combined behavior?

A assertEquals(expectedOutput, componentA.callComponentB());

B assertTrue(componentA != null);

C assertNull(componentB);

D assertFalse(componentA.callComponentB().isEmpty());

💡 Hint

Look for an assertion that compares actual output to expected output from the interaction.

Option A directly compares the expected output with the actual output from the interaction, ensuring correctness. Other options check unrelated conditions.

🔧 Debug

advanced

Debugging Failed Integration Test

An integration test fails with a NullPointerException when calling a method on a dependent component. What is the most likely cause?

A The test class is missing a main method.

B The dependent component was not properly instantiated or injected before use.

C The assertion statement has incorrect expected value.

D The test method is missing the @Test annotation.

💡 Hint

NullPointerException usually means an object reference is null when accessed.

If a dependent component is null, calling its method causes NullPointerException. Proper instantiation or injection is required before use.

❓ framework

expert

Best Practice for Integration Test Setup in JUnit

Which JUnit 5 feature is best suited to initialize shared components once before all integration tests run to verify component interaction?

A @BeforeAll annotated static method to set up shared components once for all tests.

B @BeforeEach annotated method to set up components before each test method.

C Using @TestInstance(Lifecycle.PER_METHOD) to create new instances for each test.

D Using @AfterEach annotated method to clean up components after each test.

💡 Hint

Think about initializing expensive resources only once for all tests.

@BeforeAll runs once before all tests and is ideal for setting up shared components to test their interaction efficiently.