So überprüfen Sie den String im Antworttext mit mockMvc

Ich habe einen einfachen Integrationstest

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

In der letzten Zeile möchte ich die im Antworttext empfangene Zeichenfolge mit der erwarteten Zeichenfolge vergleichen

Und als Antwort bekomme ich:

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

Versuchte einige Tricks mit content (), body (), aber nichts funktionierte.

Sie können andReturn()das zurückgegebene MvcResultObjekt aufrufen und verwenden , um den Inhalt als zu erhalten String.

Siehe unten:

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 Antwort erledigt den Job, aber ich suchte nach einem Vergleich von Zeichenfolgen innerhalb dieser mockMvc-Behauptung

Hier ist es also

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

Natürlich scheitert meine Behauptung:

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

weil:

  MockHttpServletResponse:
            Body = "Something gone wrong"

Das ist also ein Beweis dafür, dass es funktioniert!

Spring MockMvc unterstützt jetzt direkt JSON. Also sagst du einfach:

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

und im Gegensatz zum String-Vergleich wird so etwas wie "fehlendes Feld xyz" oder "Nachricht erwartet" angezeigt.

Diese Methode wurde im Frühjahr 4.1 eingeführt.

Wenn ich diese Antworten lese, sehe ich viel in Bezug auf Spring Version 4.x. Ich verwende Version 3.2.0 aus verschiedenen Gründen. Dinge wie json support direkt von der content()sind also nicht möglich.

Ich fand, dass die Verwendung MockMvcResultMatchers.jsonPathwirklich einfach ist und ein Vergnügen ist. Hier ist ein Beispiel zum Testen einer Post-Methode.

Der Vorteil dieser Lösung besteht darin, dass Sie immer noch mit Attributen übereinstimmen und sich nicht auf vollständige Vergleiche mit JSON-Zeichenfolgen verlassen.

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

Der Anfragetext war nur eine JSON-Zeichenfolge, die Sie leicht aus einer echten JSON-Mock-Datendatei laden können, wenn Sie möchten, aber ich habe das hier nicht aufgenommen, da es von der Frage abgewichen wäre.

Der tatsächlich zurückgegebene JSON hätte folgendermaßen ausgesehen:

{
    "data":"some value"
}

Entnommen aus dem Tutorial des Frühlings

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 ist erhältlich bei import static org.hamcrest.Matchers.*;

jsonPath ist erhältlich bei import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

und jsonPathReferenz finden Sie hier

@WithMockUserDer containsStringMatcher von Spring Security und Hamcrest bietet eine einfache und elegante Lösung:

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

Weitere Beispiele zu Github

Hier ist ein Beispiel, wie Sie die JSON-Antwort analysieren und sogar eine Anforderung mit einer Bean in JSON-Form senden:

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

Wie Sie hier sehen können, Bookist dies ein Anforderungs-DTO und UpdateBookResponseein Antwortobjekt, das von JSON analysiert wurde. Möglicherweise möchten Sie die ObjectMapperKonfiguration des Jakson ändern .

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

Dies sollte Ihnen den Hauptteil der Antwort geben. "Benutzername bereits vergeben" in Ihrem Fall.

hier eine elegantere Art und Weise

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

Sie können die Methode 'getContentAsString' verwenden, um die Antwortdaten als Zeichenfolge abzurufen.

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

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

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

Sie können diesen Link für die Testanwendung verwenden.

Ein möglicher Ansatz besteht darin, einfach die gsonAbhängigkeit einzuschließen:

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

und analysieren Sie den Wert, um Ihre Überprüfungen vorzunehmen:

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