Answer interface for dynamic responses in JUnit - Build an Automation Script

Automate dynamic response verification using Answer interface in JUnit

Preconditions (3)

Step 1: Mock the service method to return different responses dynamically using Answer interface

Step 2: Call the service method with a test input

Step 3: Capture the returned response

Step 4: Verify the response matches the expected dynamic output

✅ Expected Result: The test should pass confirming the service method returns correct dynamic responses as mocked

Automation Requirements - JUnit 5 with Mockito

Assertions Needed:

Assert that the returned response equals the expected dynamic value

Best Practices:

Use Mockito's Answer interface to simulate dynamic responses

Use descriptive test method names

Use assertions from JUnit Jupiter API

Keep test methods independent and focused

Automated Solution

JUnit

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.doAnswer;

import org.junit.jupiter.api.Test;
import org.mockito.stubbing.Answer;

public class DynamicResponseTest {

    interface Service {
        String getResponse(String input);
    }

    @Test
    void testDynamicResponseUsingAnswer() {
        Service mockService = mock(Service.class);

        // Use Answer to return dynamic response based on input
        Answer<String> dynamicAnswer = invocation -> {
            String arg = invocation.getArgument(0);
            return "Response for " + arg;
        };

        when(mockService.getResponse(anyString())).thenAnswer(dynamicAnswer);

        String input = "testInput";
        String expected = "Response for testInput";

        String actual = mockService.getResponse(input);

        assertEquals(expected, actual, "The dynamic response should match the expected output");
    }
}

This test uses Mockito to create a mock of a Service interface.

The Answer interface is implemented with a lambda that returns a dynamic string based on the input argument.

We then stub the getResponse method to use this dynamic answer.

When calling getResponse with "testInput", it returns "Response for testInput".

The assertion verifies the returned value matches the expected dynamic response.

This approach helps test methods that return different outputs based on inputs without hardcoding multiple stubs.

Common Mistakes - 3 Pitfalls

{'mistake': 'Hardcoding return values instead of using Answer for dynamic responses', 'why_bad': 'It limits test flexibility and does not simulate real dynamic behavior', 'correct_approach': "Use Mockito's Answer interface to generate responses based on input parameters"}

Using incorrect Mockito syntax like when().thenReturn() with multiple inputs expecting dynamic output

Not importing static Mockito methods causing compilation errors

Bonus Challenge

Now add data-driven testing with 3 different inputs to verify dynamic responses

Show Hint