Como verificar String no corpo da resposta com mockMvc

Eu tenho teste de integração simples

@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(?);
}

Na última linha, quero comparar a sequência recebida no corpo da resposta à sequência esperada

E em resposta eu recebo:

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

Tentei alguns truques com conteúdo (), corpo (), mas nada funcionou.

Você pode chamar andReturn()e usar o MvcResultobjeto retornado para obter o conteúdo como um String.

Ver abaixo:

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 

@Sotirios Delimanolis reply fazer o trabalho, no entanto, eu estava procurando comparar seqüências de caracteres dentro desta afirmação mockMvc

Então aqui está

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

É claro que minha afirmação falha:

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"

Portanto, isso é prova de que funciona!

O Spring MockMvc agora tem suporte direto para JSON. Então você apenas diz:

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

e, diferentemente da comparação de cadeias, ele diz algo como "campo ausente xyz" ou "mensagem Esperado 'ok' obteve 'nok'.

Este método foi introduzido no Spring 4.1.

Lendo essas respostas, posso ver muita coisa relacionada à versão 4.x do Spring, estou usando a versão 3.2.0 por vários motivos. Portanto, coisas como o json support diretamente do content()não são possíveis.

Eu descobri que o uso MockMvcResultMatchers.jsonPathé realmente fácil e funciona. Aqui está um exemplo de teste de um método de postagem.

O bônus com esta solução é que você ainda está correspondendo aos atributos, não confiando nas comparações completas do json string.

(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));

O corpo da solicitação era apenas uma string json, que você pode carregar facilmente de um arquivo de dados simulado json real, se quisesse, mas eu não o incluí aqui, pois teria se desviado da pergunta.

O json real retornado teria a seguinte aparência:

{
    "data":"some value"
}

Retirado do tutorial da primavera

mockMvc.perform(get("/" + 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á disponível em import static org.hamcrest.Matchers.*;

jsonPath está disponível em import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

e jsonPathreferência pode ser encontrada aqui

@WithMockUserO containsStringmatcher de segurança de primavera e hamcrest cria uma solução simples e 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.")));
}

Mais exemplos no github

Aqui está um exemplo de como analisar a resposta JSON e até como enviar uma solicitação com um bean no formato JSON:

  @Autowired
  protected MockMvc mvc;

  private static final ObjectMapper MAPPER = new ObjectMapper()
    .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
    .registerModule(new JavaTimeModule());

  public static String requestBody(Object request) {
    try {
      return MAPPER.writeValueAsString(request);
    } catch (JsonProcessingException e) {
      throw new RuntimeException(e);
    }
  }

  public static <T> T parseResponse(MvcResult result, Class<T> responseClass) {
    try {
      String contentAsString = result.getResponse().getContentAsString();
      return MAPPER.readValue(contentAsString, responseClass);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  @Test
  public void testUpdate() {
    Book book = new Book();
    book.setTitle("1984");
    book.setAuthor("Orwell");
    MvcResult requestResult = mvc.perform(post("http://example.com/book/")
      .contentType(MediaType.APPLICATION_JSON)
      .content(requestBody(book)))
      .andExpect(status().isOk())
      .andReturn();
    UpdateBookResponse updateBookResponse = parseResponse(requestResult, UpdateBookResponse.class);
    assertEquals("1984", updateBookResponse.getTitle());
    assertEquals("Orwell", updateBookResponse.getAuthor());
  }

Como você pode ver aqui, o BookDTO de solicitação UpdateBookResponseé e o objeto de resposta é analisado a partir do JSON. Você pode alterar a ObjectMapperconfiguração do Jakson .

String body = mockMvc.perform(bla... bla).andReturn().getResolvedException().getMessage()

Isso deve fornecer o corpo da resposta. "Nome de usuário já utilizado" no seu caso.

aqui uma maneira mais elegante

mockMvc.perform(post("/retrieve?page=1&countReg=999999")
            .header("Authorization", "Bearer " + validToken))
            .andExpect(status().isOk())
            .andExpect(content().string(containsString("regCount")));

Você pode usar o método 'getContentAsString' para obter os dados de resposta como sequência.

    String payload = "....";
    String apiToTest = "....";

    MvcResult mvcResult = mockMvc.
                perform(post(apiToTest).
                content(payload).
                contentType(MediaType.APPLICATION_JSON)).
                andReturn();

    String responseData = mvcResult.getResponse().getContentAsString();

Você pode consultar este link para o aplicativo de teste.

Uma abordagem possível é simplesmente incluir gsondependência:

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

e analise o valor para fazer suas verificações:

@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();
        HelloController.ResponseDto responseDto
                = new Gson().fromJson(responseBody, HelloController.ResponseDto.class);
        Assertions.assertThat(responseDto.message).isEqualTo("hello world!");
    }
}