spring boot unit test assertion error

Question

Working on a spring boot based Rest project I have a controller like this which calls service and service layer call dao layer. Now I am writing unit test code for controllers. when I run this the error says

java.lang.AssertionError: expected:<201> but was:<415>

I don't know where I am doing wrong:

    public class CustomerController {
        private static final Logger LOGGER = LogManager.getLogger(CustomerController.class);
        @Autowired
        private CustomerServices customerServices;
        @Autowired
        private Messages MESSAGES;
        @Autowired
        private LMSAuthenticationService authServices;
        @RequestMapping(value = "/CreateCustomer", method = RequestMethod.POST)
        public Status createCustomer(@RequestBody @Valid Customer customer, BindingResult bindingResult) {
            LOGGER.info("createCustomer call is initiated");
            if (bindingResult.hasErrors()) {
                throw new BusinessException(bindingResult);
            }
            Status status = new Status();
            try {
                int rows = customerServices.create(customer);
                if (rows > 0) {
                    status.setCode(ErrorCodeConstant.ERROR_CODE_SUCCESS);
                    status.setMessage(MESSAGES.CUSTOMER_CREATED_SUCCESSFULLY);
                } else {
                    status.setCode(ErrorCodeConstant.ERROR_CODE_FAILED);
                    status.setMessage(MESSAGES.CUSTOMER_CREATION_FAILED);
                }
            } catch (Exception e) {
                LOGGER.info("Cannot Create the Customer:", e);
                status.setCode(ErrorCodeConstant.ERROR_CODE_FAILED);
                status.setMessage(MESSAGES.CUSTOMER_CREATION_FAILED);
            }
            return status;
        }
              }

The test for the CustomerController.

    public class CustomerControllerTest extends ApplicationTest {

        private static final Logger LOGGER = LogManager.getLogger(CustomerControllerTest.class);


        @Autowired
        private WebApplicationContext webApplicationContext;

        private MockMvc mockMvc;

        @MockBean
        private CustomerController customerController;

        @Before
        public void setup() {
            this.mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
        }

        Status status = new Status(200,"customer created successfully","success");

        String customer = "{\"customerFullName\":\"trial8900\",\"customerPhoneNumber\": \"trial8900\", \"customerEmailID\": \"trial8900@g.com\",\"alternateNumber\": \"trial8900\",\"city\": \"trial8900\",\"address\":\"hsr\"}";

        @Test   
        public void testCreateCustomer() throws Exception {

            String URL = "http://localhost:8080/lms/customer/CreateCustomer";
            Mockito.when(customerController.createCustomer(Mockito.any(Customer.class),(BindingResult) Mockito.any(Object.class))).thenReturn(status);
            // execute
            MvcResult result = mockMvc.perform(MockMvcRequestBuilders.post(URL)
                    .contentType(MediaType.APPLICATION_JSON_UTF8)
                    .accept(MediaType.APPLICATION_JSON_UTF8)
                    .content(TestUtils.convertObjectToJsonBytes(customer))).andReturn();
            LOGGER.info(TestUtils.convertObjectToJsonBytes(customer));

            // verify
            MockHttpServletResponse response = result.getResponse();
            LOGGER.info(response);
            int status = result.getResponse().getStatus();

            LOGGER.info(status);

            assertEquals(HttpStatus.CREATED.value(), status);
        }

    }

Answer 1

Use the below base test class for your setUp and converting json to string and string to json

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Main.class)
@WebAppConfiguration
public abstract class BaseTest {
   protected MockMvc mvc;
   @Autowired
   WebApplicationContext webApplicationContext;

   protected void setUp() {
      mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
   }
   protected String mapToJson(Object obj) throws JsonProcessingException {
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.writeValueAsString(obj);
   }
   protected <T> T mapFromJson(String json, Class<T> clazz)
      throws JsonParseException, JsonMappingException, IOException {

      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.readValue(json, clazz);
   }
}

Also verify that your post call has happened or not check the below sample

Mockito.doNothing().when(customerServices).create(Mockito.any(Customer.class));
       customerServices.create(customer);
       Mockito.verify(customerServices, Mockito.times(1)).create(customer);

       RequestBuilder requestBuilder =  MockMvcRequestBuilders.post(URI)
                                                             .accept(MediaType.APPLICATION_JSON).content(inputInJson)
                                                             .contentType(MediaType.APPLICATION_JSON);

       MvcResult mvcResult = mvc.perform(requestBuilder).andReturn();
       MockHttpServletResponse response = mvcResult.getResponse();
       assertEquals(HttpStatus.OK.value(), response.getStatus());

Answer 2

HTTP status 415 is "Unsupported Media Type". Your endpoint should be marked with an @Consumes (and possibly also @Produces) annotation specifying what kinds of media types it expects from the client, and what kind of media type it returns to the client.

Since I see your test code exercising your production code with MediaType.APPLICATION_JSON_UTF8, you should probably mark your endpoint as consuming and producing APPLICATION_JSON_UTF8.

Then you also need to make sure that there is nothing terribly wrong going on in your error handling, because in the process of catching the exceptions generated by your production code and generating HTTP responses, your error handling code may be generating something different, e.g. generating an error status response with a payload containing an HTML-formatted error message, which would have a content-type of "text/html", which would not be understood by your test code which expects json.