Cómo verificar String en el cuerpo de respuesta con mockMvc

Tengo una prueba de integración simple.

@Test
public void shouldReturnErrorMessageToAdminWhenCreatingUserWithUsedUserName() throws Exception {
    mockMvc.perform(post("/api/users").header("Authorization", base64ForTestUser).contentType(MediaType.APPLICATION_JSON)
        .content("{\"userName\":\"testUserDetails\",\"firstName\":\"xxx\",\"lastName\":\"xxx\",\"password\":\"xxx\"}"))
        .andDo(print())
        .andExpect(status().isBadRequest())
        .andExpect(?);
}

En la última línea, quiero comparar la cadena recibida en el cuerpo de respuesta con la cadena esperada

Y como respuesta obtengo:

MockHttpServletResponse:
          Status = 400
   Error message = null
         Headers = {Content-Type=[application/json]}
    Content type = application/json
            Body = "Username already taken"
   Forwarded URL = null
  Redirected URL = null

Intenté algunos trucos con content(), body() pero nada funcionó.

Puedes llamar andReturn() y usar el devuelto MvcResult objeto para obtener el contenido como un String.

Vea abajo:

MvcResult result = mockMvc.perform(post("/api/users").header("Authorization", base64ForTestUser).contentType(MediaType.APPLICATION_JSON)
            .content("{\"userName\":\"testUserDetails\",\"firstName\":\"xxx\",\"lastName\":\"xxx\",\"password\":\"xxx\"}"))
            .andDo(MockMvcResultHandlers.print())
            .andExpect(status().isBadRequest())
            .andReturn();

String content = result.getResponse().getContentAsString();
// do what you will 

La respuesta de @Sotirios Delimanolis hace el trabajo, sin embargo, estaba buscando cadenas de comparación dentro de esta afirmación de mockMvc

Asi que aqui esta

.andExpect(content().string("\"Username already taken - please try with different username\""));

Por supuesto, mi afirmación falla:

java.lang.AssertionError: Response content expected:
<"Username already taken - please try with different username"> but was:<"Something gone wrong">

porque:

  MockHttpServletResponse:
            Body = "Something gone wrong"

¡Así que esta es una prueba de que funciona!

Spring MockMvc ahora tiene soporte directo para JSON. Así que solo dices:

.andExpect(content().json("{'message':'ok'}"));

y a diferencia de la comparación de cadenas, dirá algo como “campo faltante xyz” o “mensaje esperado ‘ok’ obtuvo ‘nok’.

Este método se introdujo en Spring 4.1.

Al leer estas respuestas, puedo ver muchas cosas relacionadas con Spring versión 4.x, estoy usando la versión 3.2.0 por varias razones. Por lo tanto, cosas como la compatibilidad con json directamente desde el content() no es posible.

Descubrí que usando MockMvcResultMatchers.jsonPath es muy fácil y funciona de maravilla. Aquí hay un ejemplo que prueba un método de publicación.

La ventaja de esta solución es que todavía está haciendo coincidir los atributos, sin depender de las comparaciones completas de cadenas json.

(Usando org.springframework.test.web.servlet.result.MockMvcResultMatchers)

String expectedData = "some value";
mockMvc.perform(post("/endPoint")
                .contentType(MediaType.APPLICATION_JSON)
                .content(mockRequestBodyAsString.getBytes()))
                .andExpect(status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$.data").value(expectedData));

El cuerpo de la solicitud era solo una cadena json, que puede cargar fácilmente desde un archivo de datos simulado json real si lo desea, pero no lo incluí aquí porque se habría desviado de la pregunta.

El json real devuelto se habría visto así:

{
    "data":"some value"
}

Tomado de la primavera tutorial

mockMvc.perform(get("https://stackoverflow.com/" + userName + "/bookmarks/" 
    + this.bookmarkList.get(0).getId()))
    .andExpect(status().isOk())
    .andExpect(content().contentType(contentType))
    .andExpect(jsonPath("$.id", is(this.bookmarkList.get(0).getId().intValue())))
    .andExpect(jsonPath("$.uri", is("http://bookmark.com/1/" + userName)))
    .andExpect(jsonPath("$.description", is("A description")));

is está disponible desde import static org.hamcrest.Matchers.*;

jsonPath está disponible desde import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

y jsonPath se puede encontrar la referencia aquí

primavera de seguridad @WithMockUser y Hamcrest’s containsString matcher es una solución simple y elegante:

@Test
@WithMockUser(roles = "USER")
public void loginWithRoleUserThenExpectUserSpecificContent() throws Exception {
    mockMvc.perform(get("/index"))
            .andExpect(status().isOk())
            .andExpect(content().string(containsString("This content is only shown to users.")));
}

Más ejemplos en github

Un enfoque posible es simplemente incluir gson dependencia:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
</dependency>

y analice el valor para hacer sus verificaciones:

@RunWith(SpringRunner.class)
@WebMvcTest(HelloController.class)
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private HelloService helloService;

    @Before
    public void before() {
        Mockito.when(helloService.message()).thenReturn("hello world!");
    }

    @Test
    public void testMessage() throws Exception {
        MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/"))
                .andExpect(status().isOk())
                .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON_VALUE))
                .andReturn();

        String responseBody = mvcResult.getResponse().getContentAsString();
        ResponseDto responseDto
                = new Gson().fromJson(responseBody, ResponseDto.class);
        Assertions.assertThat(responseDto.message).isEqualTo("hello world!");
    }
}