Come controllare String nel corpo della risposta con mockMvc

Ho un semplice test di integrazione

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

Nell'ultima riga voglio confrontare la stringa ricevuta nel corpo della risposta con la stringa prevista

E in risposta ottengo:

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

Ho provato alcuni trucchi con content (), body () ma niente ha funzionato.

È possibile chiamare andReturn()e utilizzare l' MvcResultoggetto restituito per ottenere il contenuto come a String.

Vedi sotto:

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 risposta di @Sotirios Delimanolis fa il lavoro, tuttavia stavo cercando di confrontare le stringhe all'interno di questa affermazione mockMvc

Quindi eccolo qui

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

Naturalmente la mia affermazione fallisce:

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

perché:

  MockHttpServletResponse:
            Body = "Something gone wrong"

Quindi questa è la prova che funziona!

Spring MockMvc ora supporta direttamente JSON. Quindi dici solo:

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

e diversamente dal confronto di stringhe, dirà qualcosa come "campo mancante xyz" o "messaggio Previsto 'ok' got 'nok'.

Questo metodo è stato introdotto nella primavera 4.1.

Leggendo queste risposte, posso vedere molte cose relative alla versione 4.x di primavera, sto usando la versione 3.2.0 per vari motivi. Quindi cose come il supporto json direttamente dal content()non sono possibili.

Ho scoperto che l'utilizzo MockMvcResultMatchers.jsonPathè davvero semplice e funziona a meraviglia. Ecco un esempio di test di un metodo post.

Il vantaggio di questa soluzione è che stai ancora confrontando gli attributi, senza fare affidamento sul confronto completo delle stringhe json.

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

Il corpo della richiesta era solo una stringa json, che puoi facilmente caricare da un vero file di dati json se lo volevi, ma non l'ho incluso qui perché sarebbe deviato dalla domanda.

L'attuale json restituito sarebbe stato così:

{
    "data":"some value"
}

Tratto dal tutorial di 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 è disponibile da import static org.hamcrest.Matchers.*;

jsonPath è disponibile da import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

e il jsonPathriferimento può essere trovato qui

La sicurezza di primavera @WithMockUsere quella di Hamcrest containsStringrappresentano una soluzione semplice ed 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.")));
}

Altri esempi su github

Ecco un esempio su come analizzare la risposta JSON e persino su come inviare una richiesta con un bean in 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());
  }

Come puoi vedere qui Bookè un DTO di richiesta e UpdateBookResponseun oggetto di risposta analizzato da JSON. Potresti voler cambiare la ObjectMapperconfigurazione di Jakson .

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

Questo dovrebbe darti il ​​corpo della risposta. "Nome utente già utilizzato" nel tuo caso.

qui un modo più elegante

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

È possibile utilizzare il metodo 'getContentAsString' per ottenere i dati di risposta come stringa.

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

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

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

È possibile fare riferimento a questo collegamento per l'applicazione di prova.

Un possibile approccio è semplicemente includere la gsondipendenza:

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

e analizzare il valore per effettuare le verifiche:

@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!");
    }
}