streamalism.org

1. Prehľad

Testovanie integrácie hrá dôležitú úlohu v cykle vývoja aplikácií overovaním komplexného správania systému.

V tomto článku uvidíme, ako môžeme využiť testovací rámec Spring MVC na písanie a spustenie integračných testov, ktoré testujú radiče bez explicitného spustenia kontajnera Servlet.

2. Príprava

Nasledujúce Maven závislosti sú potrebné na spustenie integračných testov, ako je popísané v tomto článku. Najdôležitejšie sú najnovšie závislosti JUnit a Spring Test:

 junit junit 4.12 test org.springframework jarny test 4.3.2.RELEASE test 

Pre efektívne uplatnenie výsledkov použijeme aj cestu Hamcrest a JSON:

 org.hamcrest hamcrest-library 1.3 test com.jayway.jsonpath json-path 2.2.0 test 

3. Jarná konfigurácia testu MVC

Poďme si teraz predstaviť, ako nakonfigurovať a spustiť jarné povolené testy.

3.1. Povoliť jar v testoch

Najskôr bude každý test povolený pre jar spustený pomocou @RunWith (SpringJUnit4ClassRunner.class); bežec je v podstate vstupným bodom pre začatie používania rámca jarného testu.

Potrebujeme tiež @ContextConfiguration anotácie na načítanie kontextovej konfigurácie a bootstrap kontext, ktorý použije test.

Pozrime sa na to:

@RunWith (SpringJUnit4ClassRunner.class) @ContextConfiguration (classes = {ApplicationConfig.class}) @WebAppConfiguration verejná trieda GreetControllerIntegrationTest {....}

Všimnite si, ako v @ContextConfiguration, poskytli sme ApplicationConfig.class trieda konfigurácie, ktorá načíta konfiguráciu potrebnú pre tento konkrétny test.

Na zadanie konfigurácie kontextu sme tu použili konfiguračnú triedu Java; podobne môžeme použiť konfiguráciu založenú na XML:

@ContextConfiguration (locations = {""})

Nakoniec - test je tiež anotovaný @WebAppConfiguration - ktorý načíta kontext webovej aplikácie.

V predvolenom nastavení vyhľadáva koreňovú webovú aplikáciu na predvolenej ceste src / main / webapp; miesto je možné prekonať prejdením hodnotu atribút ako:

@WebAppConfiguration (hodnota = "")

3.2. The WebApplicationContext Objekt

WebApplicationContext (wac) poskytuje konfiguráciu webovej aplikácie. Načíta všetky fazule aplikácie a radiče do kontextu.

Teraz budeme môcť prepojiť kontext webovej aplikácie priamo s testom:

@Autowired private WebApplicationContext wac;

3.3. Vysmievanie sa fazule kontextu webu

MockMvc poskytuje podporu pre jarné testovanie MVC. Zahŕňa všetky fazule webových aplikácií a sprístupňuje ich na testovanie.

Pozrime sa, ako to používať:

súkromné ​​MockMvc mockMvc; @ Pred verejným nastavením neplatnosti () vyvolá výnimku {this.mockMvc = MockMvcBuilders.webAppContextSetup (this.wac) .build (); }

Musíme inicializovať mockMvc objekt v @ Predtým komentovanú metódu, aby sme ju nemuseli inicializovať vo vnútri každého testu.

3.4. Overte konfiguráciu testu

Pre náš návod tu si overme, či načítame WebApplicationContext objekt (wac) správne. Overíme tiež, či je to správne servletContext sa pripája:

@Test public void danéWac_whenServletContext_thenItProvidesGreetController () {ServletContext servletContext = wac.getServletContext (); Assert.assertNotNull (servletContext); Assert.assertTrue (servletContext instanceof MockServletContext); Assert.assertNotNull (wac.getBean ("greetController")); }

Všimnite si, že tiež kontrolujeme, či a GreetController.java bean existuje vo webovom kontexte - čo zaisťuje správne načítanie jarných bôbov.

V tomto okamihu sa nastaví test integrácie. Pozrime sa, ako môžeme testovať metódy zdrojov pomocou MockMvc objekt.

4. Písanie integračných testov

V tejto časti si prejdeme základné operácie dostupné prostredníctvom testovacieho rámca.

Ukážeme si, ako posielať požiadavky s premennými cesty a parametrami. Ďalej postupujeme s niekoľkými príkladmi, ktoré ukazujú, ako tvrdiť, že je vyriešený správny názov zobrazenia alebo či je telo odpovede podľa očakávania.

Nasledujúce úryvky používajú statické importy z MockMvcRequestBuilders alebo MockMvcResultMatchers triedy.

4.1. Overte názov zobrazenia

Vyvolame / homePage koncový bod z nášho testu ako:

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

alebo

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

Úryvok kódu:

@Test public void givenHomePageURI_whenMockMVC_thenReturnsIndexJSPViewName () {this.mockMvc.perform (get ("/ homePage")). AndDo (print ()) .andExpect (view (). Name ("index")); }

Poďme to rozdeliť:

• hrať() metóda zavolá metódu get request, ktorá vráti VýsledokActions. Pomocou tohto výsledku môžeme mať očakávania týkajúce sa odpovede, ako je obsah, stav HTTP, hlavička atď
• andDo (print ()) vytlačí požiadavku a odpoveď. To je užitočné na získanie podrobného zobrazenia v prípade chyby
• andExpect ()bude očakávať uvedený argument. V našom prípade očakávame, že sa vráti index MockMvcResultMatchers.view ()

4.2. Overte telo odpovede

Budeme sa dovolávať / pozdravujem koncový bod z nášho testu ako:

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

Očakávaný výstup:

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

Úryvok kódu:

@Test public void givenGreetURI_whenMockMVC_thenVerifyResponse () {MvcResult mvcResult = this.mockMvc.perform (get ("/ greet")) .andDo (print ()). AndExpect (status (). IsOk ()) .andExpect ($on .message "). value (" Hello World !!! ")) .andReturn (); Assert.assertEquals ("application / json; charset = UTF-8", mvcResult.getResponse (). GetContentType ()); }

Pozrime sa presne, čo sa deje:

• andExpect (MockMvcResultMatchers.status (). isOk ())overí, či je stav HTTP odpovede Ok t.j. 200. To zaisťuje, že požiadavka bola úspešne vykonaná
• andExpect (MockMvcResultMatchers.jsonPath („$. message“). value („Hello World !!!“)) overí, či sa obsah odpovede zhoduje s argumentom „Ahoj svet !!!„. Tu sme použili jsonPath ktorý extrahuje obsah odpovede a poskytuje požadovanú hodnotu
• andReturn ()vráti MvcResult objekt, ktorý sa používa, keď musíme overiť niečo, čo nie je v knižnici dosiahnuteľné. Vidíte, že sme pridali assertEquals aby sa zhodoval s typom obsahu odpovede, ktorý sa extrahuje z MvcResult objekt

4.3. Odoslať ZÍSKAJTE Žiadosť s premennou cesty

Budeme sa dovolávať / greetWithPathVariable / {name} koncový bod z nášho testu ako:

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

Očakávaný výstup:

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

Úryvok kódu:

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

MockMvcRequestBuilders.get („/ greetWithPathVariable / {name}“, „John“) pošle žiadosť ako „/ greetWithPathVariable / John“.

Toto je jednoduchšie s ohľadom na čitateľnosť a informovanosť o parametroch, ktoré sa dynamicky nastavujú v adrese URL. Upozorňujeme, že môžeme odovzdať toľko parametrov cesty, koľko je potrebné.

4.4. Pošli ZÍSKAJTE Vyžiadajte si s parametrami dotazu

Zavoláme / greetWithQueryVariable? name = {name} koncový bod z nášho testu ako:

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

Očakávaný výstup:

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

Úryvok kódu:

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

param („meno“, „John Doe“) pridá parameter dopytu do súboru ZÍSKAJTE žiadosť. Je to podobné ako / greetWithQueryVariable? name = John% 20Doe“.

Parameter dopytu je možné implementovať aj pomocou štýlu šablóny URI:

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

4.5. Pošli POST Žiadosť

Budeme sa dovolávať / greetWithPost koncový bod z nášho testu ako:

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

Očakávaný výstup:

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

Úryvok kódu:

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

MockMvcRequestBuilders.post („/ greetWithPost“) pošle žiadosť o príspevok. Premenné cesty a parametre dotazu je možné nastaviť podobným spôsobom, ako sme sa pozreli skôr, zatiaľ čo údaje formulára je možné nastaviť pomocou param () metóda podobná iba parametru dotazu ako:

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

Údaje formulára:

id = 1; meno = John% 20Doe

Očakávaný výstup:

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

Úryvok kódu:

@Test public void givenGreetURIWithPostAndFormData_whenMockMVC_thenResponseOK () {this.mockMvc.perform (post ("/ greetWithPostAndFormData"). Param ("id", "1") .param ("name", "John Doe")) aDo )). andExpect (status (). isOk ()) .andExpect (content (). contentType ("application / json; charset = UTF-8")) .andExpect (jsonPath ("$. message"). value (" Hello World John Doe !!! ")) .andExpect (jsonPath (" $. Id "). Value (1)); }

Vo vyššie uvedenom útržku kódu sme pridali dva parametre id ako „1“ a názov ako „John Doe“.

5. MockMvc Obmedzenia

MockMvc poskytuje elegantné a ľahko použiteľné API na volanie webových koncových bodov a kontrolu a presadzovanie ich odpovedí súčasne. Napriek všetkým výhodám má niekoľko obmedzení.

V prvom rade používa podtriedu DispatcherServlet vybavovať žiadosti o testy. Konkrétnejšie TestDispatcherServlet je zodpovedný za volanie ovládačov a vykonávanie všetkých známych jarných kúziel.

The MockMvc trieda to zabalí TestDispatcherServlet vnútorne. Zakaždým teda pošleme žiadosť pomocou hrať() metóda, MockMvc použije podkladové TestDispatcherServlet priamo. Preto neexistujú žiadne skutočné sieťové pripojenia, a teda nebudeme testovať celý sieťový zásobník počas používania MockMvc.

Tiežpretože Spring pripravuje falošný kontext webovej aplikácie na zosmiešnenie požiadaviek a odpovedí HTTP, nemusí podporovať všetky funkcie plnohodnotnej aplikácie Spring.

Toto falošné nastavenie napríklad nepodporuje presmerovania HTTP. To sa na začiatku nemusí zdať také významné. Spring Boot však niektoré chyby zvláda presmerovaním aktuálnej požiadavky na server /chyba koncový bod. Takže ak používame MockMvc, nemusíme byť schopní otestovať niektoré zlyhania API.

Ako alternatíva k MockMvc, môžeme vytvoriť skutočnejší kontext aplikáciea potom použite RestTemplate alebo si byť istí, že našu aplikáciu otestujeme.

Napríklad pomocou Spring Boot je to jednoduché:

@RunWith (SpringRunner.class) @SpringBootTest (webEnvironment = RANDOM_PORT) verejná trieda GreetControllerRealIntegrationTest {@LocalServerPort súkromný int port; @Before public void setUp () {RestAssured.port = port; } @Test public void givenGreetURI_whenSendingReq_thenVerifyResponse () {given (). Get ("/ greet") .then () .statusCode (200); }}

Týmto spôsobom každý test vykoná skutočnú požiadavku HTTP na aplikáciu, ktorá počúva na náhodnom porte TCP.

6. Záver

V tomto tutoriáli sme implementovali niekoľko jednoduchých testov integrácie povolených pomocou Spring.

Pozreli sme sa tiež na WebApplicationContext a MockMVC vytváranie objektov, ktoré hralo dôležitú úlohu pri volaní koncových bodov aplikácie.

Keď sa pozrieme ďalej, priblížili sme, ako môžeme posielať ZÍSKAJTE a POST požiadavky s variáciami odovzdávania parametrov a ako overiť stav odpovede HTTP, hlavičku a obsah.

Na záver sme vyhodnotili aj niektoré obmedzenia MockMvc. Poznanie týchto obmedzení nás môže viesť k tomu, aby sme sa informovane rozhodli o tom, ako implementujeme naše testy.

Nakoniec je implementácia všetkých týchto príkladov a útržkov kódu k dispozícii v GitHub.