Mockito org.mockito.exceptions.misusing.InvalidUseOfMatchersException: Invalid use of argument matchers! 0 matchers expected, 1 recorded:

Question

first of all I try to write unit-test for remote service to get weather and using restTemplate then implement ClientHttpRequestInterceptor to get remote request && remote response for logging purpose now i try to mock restTemplate to write unit-test and get the following error

When using matchers, all arguments have to be provided by matchers.
For example:
    //correct:
    someMethod(anyObject(), eq("String by matcher"));

For more info see javadoc for Matchers class.

and here you here code i wrote for unit-test

@RunWith(MockitoJUnitRunner.class)
public class WeatherRemoteServiceTest {

    @Mock CustomResttemplate restTemplate;

    @Mock WeatherRemoteUtilies weatherUtilies;

    @InjectMocks WeatherRemoteService weatherRemote;

    @Test
    public void testRetrieveWeather() {

        ResponseEntity<String> MockResponse= new ResponseEntity<String>(HttpStatus.OK);

        Mockito.when(weatherUtilies.buildRequestParams(Mockito.anyString()))
                        .thenReturn(Mockito.any(MultiValueMap.class));
        ResponseEntity<String> responseEntity = new ResponseEntity<String>("sampleBodyString", HttpStatus.OK);
        Mockito.when(restTemplate.buildRestTemplate().exchange(
                                   Matchers.anyString(), 
                                   Matchers.any(HttpMethod.class),
                                   Matchers.<HttpEntity<?>> any(), 
                                   Matchers.<Class<String>> any()
                                  )
                                 ).thenReturn(responseEntity);
        assertEquals(weatherRemote.retrieveWeather("ciaro").getStatusCode(), HttpStatus.OK);
    }

}

and here is code for business logic itself

@Service
public class WeatherRemoteService {

    private final Logger logger= LoggerFactory.getLogger(this.getClass());

    @Value("${openweather.url}")
    private String url;

    @Autowired
    private WeatherRemoteUtilies weatherUtilies;

    @Autowired
    private CustomResttemplate customRestTemplate;

    public ResponseEntity<?> retrieveWeather(String city) {

        logger.info(Constants.CLASS_NAME+this.getClass().getName()+Constants.METHOD_NAME+new Object() {}.getClass().getEnclosingMethod().getName());
        logger.debug(Constants.METHOD_ARGUMENTS+city);
        RestTemplate restRequest= customRestTemplate.buildRestTemplate();
        HttpHeaders headers= new HttpHeaders();
        headers.set("Accept",MediaType.APPLICATION_JSON_UTF8_VALUE);
        UriComponentsBuilder uri= UriComponentsBuilder.fromUriString(url).
                path("/data/2.5/weather")
                .queryParams(weatherUtilies.buildRequestParams(city));
        HttpEntity<String>entity= new HttpEntity<>(headers);
        ResponseEntity<String>WeatherResponse=restRequest.exchange(uri.toUriString(), HttpMethod.GET, entity, String.class);
        logger.info(Constants.END_METHOD);
        return WeatherResponse;
    }



}

code for RestTemplateInterceptor

public class RestTemplateInterceptor implements ClientHttpRequestInterceptor {

    private final Logger logger =LoggerFactory.getLogger(this.getClass());

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
            throws IOException {
        logRequest(request, body);
        ClientHttpResponse httpResponse= execution.execute(request, body);
        logResponse(httpResponse);
        return httpResponse;
    }

    private void logRequest(HttpRequest request, byte[] body) throws IOException {
        logger.info(Constants.START_REMOTE_REQUEST);
        logger.info("URI            :{}", request.getURI().toString());
        logger.info("Method         :{}", request.getMethod().toString());
        logger.info("Headers        :{}", request.getHeaders().toString());
        logger.info("Request body   :{}", new String(body,"UTF-8").toString());
        logger.info(Constants.END_REMOTE_REQUEST);
    }

    private void logResponse(ClientHttpResponse response) throws IOException {
        logger.info(Constants.START_REMOTE_RESPONSE);
        logger.info("Status code    :{}", response.getStatusCode().toString());
        logger.info("Status text    :{}", response.getStatusText().toString());
        logger.info("Headers        :{}", response.getHeaders().toString());
        logger.info("Response body  :{}", StreamUtils.copyToString(response.getBody(), Charset.defaultCharset()));
        logger.info(Constants.END_REMOTE_RESPONSE);
    }
}

then setInterceptor on RestTemplate factory using the following code

public class CustomResttemplate {

    public RestTemplate buildRestTemplate() {
        SimpleClientHttpRequestFactory simpleFactory= new SimpleClientHttpRequestFactory();
        simpleFactory.setOutputStreaming(false);
        ClientHttpRequestFactory factory = new BufferingClientHttpRequestFactory(simpleFactory);

        RestTemplate restTemplate= new RestTemplate(factory);
        restTemplate.setInterceptors(Collections.singletonList(new RestTemplateInterceptor()));

        return restTemplate;
    }
}

Answer 1

Your problem is where you write

.thenReturn(Mockito.any(MultiValueMap.class))

You actually have to tell Mockito what to return. You can't use a matcher here. Matchers are for verifying, and for setting up what conditions to stub. You can't use them to tell Mockito what to return from a stubbed call.

Create a specific MultiValueMap to pass to thenReturn .