TOC

Integrationstest im Frühling

Integrationstests im Frühjahr

1. Überblick

Integrationstests spielen eine wichtige Rolle im Anwendungsentwicklungszyklus, indem sie das End-to-End-Verhalten des Systems überprüfen.

In diesem Artikel erfahren Sie, wie Sie das Spring MVC-Testframework nutzen können, um Integrationstests zu schreiben und auszuführen, mit denen Controller getestet werden, ohne explizit einen Servlet-Container zu starten.

2. Vorbereitung

Die folgenden Maven-Abhängigkeiten werden zum Ausführen von Integrationstests benötigt, wie in diesem Artikel beschrieben. In erster Linie die neuesten Abhängigkeiten vonJUnit undSpring test: 


    junit
    junit
    4.12
    test


    org.springframework
    spring-test
    4.3.2.RELEASE
    test

Für eine effektive Bestätigung der Ergebnisse werden wir auchHamcrest undJSON path verwenden: 


    org.hamcrest
    hamcrest-library
    1.3
    test


    com.jayway.jsonpath
    json-path
    2.2.0
    test

3. Spring MVC-Testkonfiguration

Lassen Sie uns nun vorstellen, wie Sie die Spring-fähigen Tests konfigurieren und ausführen.

3.1. Aktivieren Sie Spring in Tests

Zunächst wird jeder Spring-fähige Test mit Hilfe von@RunWith(SpringJUnit4ClassRunner.class) ausgeführt. Der Läufer ist im Wesentlichen der Einstiegspunkt für die Verwendung des Spring Test-Frameworks.

Wir benötigen auch die Annotationen@ContextConfiguration, um die Kontextkonfiguration zu laden, undbootstrap the context that the test will use.

Werfen wir einen Blick: 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { ApplicationConfig.class })
@WebAppConfiguration
public class GreetControllerIntegrationTest {
    ....
}

Beachten Sie, dass wir in@ContextConfiguration, die KonfigurationsklasseApplicationConfig.class bereitgestellt haben, die die Konfiguration lädt, die wir für diesen bestimmten Test benötigen.

Wir haben hier eine Java-Konfigurationsklasse verwendet, um die Kontextkonfiguration anzugeben. Ebenso können wir die XML-basierte Konfiguration verwenden: 

@ContextConfiguration(locations={""})

Schließlich wird der Test auch mit@WebAppConfiguration – which will load the web application context. kommentiert

Standardmäßig wird die Root-Webanwendung unter dem Standardpfadsrc/main/webapp gesucht. Der Speicherort kann überschrieben werden, indem das Wertargument wie folgt übergeben wird: 

@WebAppConfiguration(value = "")

3.2. DasWebApplicationContext-Objekt

WebApplicationContext (wac) stellt die Konfiguration der Webanwendung bereit. Es lädt alle Application Beans und Controller in den Kontext.

Wir können jetzt den Webanwendungskontext direkt in den Test einbinden: 

@Autowired
private WebApplicationContext wac;

3.3. Verspotten von Webkontext-Beans

MockMvc bietet Unterstützung für Spring MVC-Tests. Es kapselt alle Webanwendungs-Beans und stellt sie zum Testen zur Verfügung.

Mal sehen, wie man es benutzt: 

private MockMvc mockMvc;
@Before
public void setup() throws Exception {
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}

Wir müssen dasmockMvc-Objekt in der mit Anmerkungen versehenen@Before-Methode initialisieren, damit wir es nicht bei jedem Test initialisieren müssen.

3.4. Überprüfen Sie die Testkonfiguration

In unserem Tutorial hier überprüfen wir tatsächlich, ob das ObjektWebApplicationContext(wac) ordnungsgemäß geladen wird. Wir werden auch überprüfen, ob die richtigenservletContext angehängt sind: 

@Test
public void givenWac_whenServletContext_thenItProvidesGreetController() {
    ServletContext servletContext = wac.getServletContext();

    Assert.assertNotNull(servletContext);
    Assert.assertTrue(servletContext instanceof MockServletContext);
    Assert.assertNotNull(wac.getBean("greetController"));
}

Beachten Sie, dass wir auch überprüfen, ob im Webkontext eineGreetController.java-Bohne vorhanden ist. Dadurch wird sichergestellt, dass die Spring-Beans ordnungsgemäß geladen werden.

Zu diesem Zeitpunkt ist die Einrichtung des Integrationstests abgeschlossen. Lassen Sie uns sehen, wie wir Ressourcenmethoden mit dem ObjektMockMvctesten können.

4. Integrationstests schreiben

In diesem Abschnitt gehen wir auf die grundlegende Operation ein, die über das Testframework verfügbar ist.

Wir zeigen, wie Anforderungen mit Pfadvariablen und -parametern gesendet werden. Im Folgenden werden einige Beispiele aufgeführt, die zeigen, wie Sie sicherstellen können, dass der richtige Ansichtsname aufgelöst wird oder dass der Antworttext den Erwartungen entspricht.

Die folgenden Snippets verwenden statische Importe aus den Klassen MockMvcRequestBuilders oderMockMvcResultMatchers.

4.1. Überprüfen Sie den Namen der Ansicht

Rufen wir den Endpunkt von/homePageaus unserem Test als: auf 

http://localhost:8080/spring-mvc-test/

or 

http://localhost:8080/spring-mvc-test/homePage

Code-Auszug: 

@Test
public void givenHomePageURI_whenMockMVC_thenReturnsIndexJSPViewName() {
    this.mockMvc.perform(get("/homePage")).andDo(print())

      .andExpect(view().name("index"));
}

Lassen Sie uns das zusammenfassen:

  • Die Methodeperform() ruft eine Methode zum Abrufen von Anforderungen auf, dieResultActions zurückgibt. Mit diesem Ergebnis können wir bestimmte Erwartungen an die Antwort wie Inhalt, HTTP - Status, Header usw. Haben

  • andDo(print()) druckt die Anfrage und Antwort. Dies ist hilfreich, um im Fehlerfall eine detaillierte Ansicht zu erhalten

  • andExpect() erwartet das angegebene Argument. In unserem Fall erwarten wir, dass "Index" überMockMvcResultMatchers.view() zurückgegeben wird

4.2. Überprüfen Sie den Antworttext

Wir werden den Endpunkt von/greetaus unserem Test aufrufen als: 

http://localhost:8080/spring-mvc-test/greet

Erwartete Ausgabe: 

{
    "id": 1,
    "message": "Hello World!!!"
}

Code-Auszug: 

@Test
public void givenGreetURI_whenMockMVC_thenVerifyResponse() {
    MvcResult mvcResult = this.mockMvc.perform(get("/greet"))
      .andDo(print()).andExpect(status().isOk())
      .andExpect(jsonPath("$.message").value("Hello World!!!"))
      .andReturn();

    Assert.assertEquals("application/json;charset=UTF-8",
      mvcResult.getResponse().getContentType());
}

Mal sehen, was genau los ist:

  • andExpect(MockMvcResultMatchers.status().isOk()) überprüft, ob der Antwort-http-StatusOk ist, d.h. 200. Dadurch wird sichergestellt, dass die Anforderung erfolgreich ausgeführt wurde

  • andExpect(MockMvcResultMatchers.jsonPath(“$.message”).value(“Hello World!!!”)) überprüft, ob der Antwortinhalt mit dem Argument „Hello World!!!“ übereinstimmt. Hier haben wirjsonPath verwendet, die den Antwortinhalt extrahieren und den angeforderten Wert bereitstellen

  • andReturn() gibt das verwendeteMvcResult-Objekt zurück, wenn wir etwas überprüfen müssen, das von der Bibliothek nicht erreicht werden kann. Sie können sehen, dass wirassertEquals hinzugefügt haben, um dem Inhaltstyp der Antwort zu entsprechen, die aus dem Objekt vonMvcResultextrahiert wird

4.3. Senden SieGET Anfrage mit Pfadvariable

Wir werden den Endpunkt von/greetWithPathVariable/{name}aus unserem Test aufrufen als: 

http://localhost:8080/spring-mvc-test/greetWithPathVariable/John

Erwartete Ausgabe: 

{
    "id": 1,
    "message": "Hello World John!!!"
}

Code-Auszug: 

@Test
public void givenGreetURIWithPathVariable_whenMockMVC_thenResponseOK() {
    this.mockMvc
      .perform(get("/greetWithPathVariable/{name}", "John"))
      .andDo(print()).andExpect(status().isOk())

      .andExpect(content().contentType("application/json;charset=UTF-8"))
      .andExpect(jsonPath("$.message").value("Hello World John!!!"));
}

MockMvcRequestBuilders.get(“/greetWithPathVariable/{name}”, “John”) sendet die Anfrage als "/greetWithPathVariable/John".

Dies wird in Bezug auf die Lesbarkeit und die Kenntnis der Parameter, die in der URL dynamisch festgelegt werden, einfacher. Diese Methode beschränkt sich nicht darauf, die Anzahl der Pfadparameter zu übergeben.

4.4. GET Anfrage mit Abfrageparametern senden

Wir werden den Endpunkt von/greetWithQueryVariable?name={name}aus unserem Test aufrufen als: 

http://localhost:8080/spring-mvc-test
  /greetWithQueryVariable?name=John%20Doe

Erwartete Ausgabe: 

{
    "id": 1,
    "message": "Hello World John Doe!!!"
}

Code-Auszug: 

@Test
public void givenGreetURIWithQueryParameter_whenMockMVC_thenResponseOK() {
    this.mockMvc.perform(get("/greetWithQueryVariable")
      .param("name", "John Doe")).andDo(print()).andExpect(status().isOk())
      .andExpect(content().contentType("application/json;charset=UTF-8"))
      .andExpect(jsonPath("$.message").value("Hello World John Doe!!!"));
}

param(“name”, “John Doe”) hängt den Abfrageparameter an die Anforderung vonGETan. Es ist ähnlich wie „/greetWithQueryVariable?name=John%20Doe“.

Der Abfrageparameter kann auch mithilfe des URI-Vorlagenstils implementiert werden: 

this.mockMvc.perform(
  get("/greetWithQueryVariable?name={name}", "John Doe"));

4.5. POST Anfrage senden

Wir werden den Endpunkt von/greetWithPostaus unserem Test aufrufen als: 

http://localhost:8080/spring-mvc-test/greetWithPost

Erwartete Ausgabe: 

{
    "id": 1,
    "message": "Hello World!!!"
}

Code-Auszug: 

@Test
public void givenGreetURIWithPost_whenMockMVC_thenVerifyResponse() {
    this.mockMvc.perform(post("/greetWithPost")).andDo(print())
      .andExpect(status().isOk()).andExpect(content()
      .contentType("application/json;charset=UTF-8"))
      .andExpect(jsonPath("$.message").value("Hello World!!!"));
}

MockMvcRequestBuilders.post(“/greetWithPost”) sendet die Post-Anfrage. Pfadvariablen und Abfrageparameter können auf ähnliche Weise wie zuvor festgelegt werden, während Formulardaten über die Methodeparam()festgelegt werden können, die nur den Abfrageparametern ähnelt: 

http://localhost:8080/spring-mvc-test/greetWithPostAndFormData

Formulardaten: 

id=1;name=John%20Doe

Erwartete Ausgabe: 

{
    "id": 1,
    "message": "Hello World John Doe!!!"
}

Code-Auszug: 

@Test
public void givenGreetURIWithPostAndFormData_whenMockMVC_thenResponseOK() {
    this.mockMvc.perform(post("/greetWithPostAndFormData").param("id", "1")
      .param("name", "John Doe")).andDo(print()).andExpect(status().isOk())

      .andExpect(content().contentType("application/json;charset=UTF-8"))
      .andExpect(jsonPath("$.message").value("Hello World John Doe!!!"))
      .andExpect(jsonPath("$.id").value(1));
}

Im obigen Code-Snippet haben wir 2 Parameter id als "1" und name als "John Doe" hinzugefügt.

5. Fazit

In diesem kurzen Lernprogramm haben wir einige einfache Integrationstests implementiert, die von Spring unterstützt werden.

Wir haben uns auch die ObjekterstellungWebApplicationContext undMockMVC angesehen, die beim Aufrufen der Endpunkte der Anwendung eine wichtige Rolle spielten.

Im weiteren Verlauf haben wir erläutert, wie wirGET- undPOST-Anforderungen mit Variationen der Parameterübergabe senden können und wie der HTTP-Antwortstatus, der Header und der Inhalt überprüft werden.

Schließlich ist die Implementierung all dieser Beispiele und Codefragmente inhttps://github.com/eugenp/tutorials/tree/master/spring-mvc-java. verfügbar

Related