Is it a good practice to unit test controller classes in Spring MVC - spring

Question

I used to unit test my controller classes just like any other normal Java class. I mean without using Spring's MockMvc. But then I realized that this way I won't be able to be sure that I've set up the MVC configuration correctly. So if I have controller like this:
#Restcontroller
#RequestMapping("/cars")
public class CarController{
private CarService carService;
public CarController (CarService service){this.carService = service};
#GetMapping
public List<Car> getCar(#RequestParam("filter") String filter){
if(filter!=null && !filter.trim().equal("")){
//omitted for brevity
}
}
}
and if I unit test its getCar method directly, even if the test passes, that won't mean my controller is alright. So instead of unit testing, I started actually doing integration testing. Something like this:
mockMvc.perform(get("/v1/cars?filter = Honda")).... bla bla bla
Recently a question arose if we should first unit test and the integration test rest controllers. At first glance, it seems to me that integration test does, in the end, check the correct behavior of the controller. But on the other hand, how good is that to rely on integration test only.

Answer 1

I personally never found unit testing controllers useful. In an ideal case a Controller is relatively slim, as it only calls a few methods of service objects and returns a result. IMO unit testing would mean (over)using the verify() method. (I.e. did the controller call the service method with the correct arguments.)
For example in my case a well written controller method looks like this:
#LoggingInfo
#PostMapping(value = "/someRoute",
produces = "application/json",
consumes = "application/json")
#ApiOperation(value = "Some description", response = SomeDTO.class)
public #ResponseBody
CompletableFuture<ResponseEntity> someControllerMethod(
#Validated(ValidationSequence.class) #RequestBody SomeDTO someDTO) {
return service
.doSomething(someDTO)
.thenApply((String var) -> ResponseEntity.ok(ResponseDTO.builder()
.myField(Collections.singleton(var)).build()));
}
To what extent would unit testing this method add value to the application?
For me, the game-changer was the use of integration tests. Here it turns out if all the spring magic is working correctly, such as:
Validators that were triggered by annotations
The order of (different) validators
The converters (i.e. see Jackson in action)
Exception handlers (are the thrown exceptions actually caught by the annotated exception handlers)
Hope this helps.