What are some advanced techniques for mocking API calls with Mockito

1. Stubbing Sequential Responses**

Sometimes, you need your mock to return different values on successive calls. This can be achieved by chaining multiple `thenReturn` calls:

java
when(mockApi.getData()).thenReturn("Response1").thenReturn("Response2");

In this example, the first call to `getData()` will return "Response1", and the second call will return "Response2".

2. Using Argument Matchers**

Argument matchers allow you to stub methods based on specific argument values. This is useful when you need to test how your code behaves with different inputs:

java
when(mockApi.processData(anyString())).thenReturn("Processed Data");

Here, `anyString()` is an argument matcher that matches any string argument passed to `processData`.

3. Implementing Complex Logic with Answers**

You can use Mockito's `Answer` interface to implement complex logic for your stubs. This is particularly useful when you need to perform actions based on the arguments passed to a method:

java
when(mockApi.login(any(Callback.class))).thenAnswer(i -> {
    Callback callback = i.getArgument(0);
    callback.notify("Success");
    return null;
});

In this example, when `login` is called with a `Callback` object, it notifies the callback with a success message.

4. Verifying API Calls**

After setting up your mocks, it's crucial to verify that they are called as expected. Mockito provides methods like `verify` to check if a method was called a certain number of times:

java
verify(mockApi, times(1)).getData();

This ensures that `getData()` was called exactly once during the test.

5. Resetting Mocks Between Tests**

To keep your tests isolated, you should reset your mocks between test runs. Mockito provides `reset` methods for this purpose:

java
Mockito.reset(mockApi);

However, a better practice is to create mocks within each test method, ensuring a clean slate for each test.

6. Using Spies for Partial Mocking**

Spies allow you to partially mock objects, which is useful for testing legacy code or when you need to test some real methods while mocking others:

java
DecimalFormat decimalFormatSpy = spy(new DecimalFormat());
when(decimalFormatSpy.format(anyLong())).thenReturn("Mocked Format");

In this case, all methods of `DecimalFormat` will behave normally unless explicitly stubbed.

7. Dynamic Mocking**

While Mockito primarily supports static mocking, you can achieve dynamic behavior by using `Answer` objects or external tools that support dynamic data mocking. However, Mockito itself does not natively support dynamic mocking based on request parameters or real-time conditions like some other frameworks do[4].

8. Testing Error Scenarios**

Don't forget to test how your code handles errors. You can stub your mocks to throw exceptions or return error responses:

java
when(mockApi.getData()).thenThrow(new IOException("Mocked Exception"));

This ensures that your code can gracefully handle unexpected errors from external APIs.

By incorporating these techniques into your testing strategy, you can create robust unit tests that effectively isolate and verify the behavior of your code when interacting with external APIs.