Serenity BDD s pružinou a JBehave

1. Úvod

Predtým sme predstavili rámec BDD Serenity.

V tomto článku si predstavíme, ako integrovať Serenity BDD s Spring.

2. Závislosť od Maven

Aby sme umožnili Serenity v našom jarnom projekte, musíme pridať vyrovnanosť-jadro a vyrovnanosť-jar do pom.xml:

 test net.serenity-bdd serenity-core 1.4.0 test net.serenity-bdd serenity-spring 1.4.0 

Musíme tiež nakonfigurovať serenity-maven-plugin, čo je dôležité pre generovanie správ o testoch Serenity:

 net.serenity-bdd.maven.plugins serenity-maven-plugin 1.4.0 serenity-reporty po integrácii-test agregát 

3. Jarná integrácia

Test jarnej integrácie musí @RunWithSpringJUnit4ClassRunner. Ale nemôžeme použiť testovacieho bežca priamo so Serenity, pretože Serenity testy musia byť spustené SerenityRunner.

Pre testy so Serenity môžeme použiť SpringIntegrationMethodRule a SpringIntegrationClassRule na umožnenie injekcie.

Pri testovaní vychádzame z jednoduchého scenára: pri zadaní čísla sa pri pridávaní ďalšieho čísla vráti súčet.

3.1. SpringIntegrationMethodRule

SpringIntegrationMethodRule je a MethodRule použité na testovacie metódy. Kontext jari sa bude stavať predtým @ Predtým a potom @BeforeClass.

Predpokladajme, že máme vlastnosť, ktorú si môžeme vpichnúť do našich fazúľ:

 4 

Teraz pridajme SpringIntegrationMethodRule ako povoliť vloženie hodnoty v našom teste:

@RunWith (SerenityRunner.class) @ContextConfiguration (locations = "classpath: adder-beans.xml") verejná trieda AdderMethodRuleIntegrationTest {@Rule public SpringIntegrationMethodRule springMethodIntegration = nové SpringIntegrationMethodRule (); @Steps private AdderSteps adderSteps; @Value ("# {props ['adder']}" ") private int sčítač; @Test public void givenNumber_whenAdd_thenSummedUp () {adderSteps.givenNumber (); adderSteps.whenAdd (sčítač); adderSteps.thenSummedUp (); }}

Podporuje tiež anotácie na úrovni metód jarná skúška. Ak niektorá testovacia metóda popiera kontext testu, môžeme to označiť @DirtiesContext na to:

@RunWith (SerenityRunner.class) @FixMethodOrder (MethodSorters.NAME_ASCENDING) @ContextConfiguration (classes = AdderService.class) verejná trieda AdderMethodDirtiesContextIntegrationTest {@Steps private AdderServiceSteps adderService @ Pravidlo verejné SpringIntegrationMethodRule springIntegration = nové SpringIntegrationMethodRule (); @DirtiesContext @Test public void _0_givenNumber_whenAddAndAccumulate_thenSummedUp () {adderServiceSteps.givenBaseAndAdder (randomInt (), randomInt ()); adderServiceSteps.whenAccumulate (); adderServiceSteps.summedUp (); adderServiceSteps.whenAdd (); adderServiceSteps.sumWrong (); } @Test public void _1_givenNumber_whenAdd_thenSumWrong () {adderServiceSteps.whenAdd (); adderServiceSteps.sumWrong (); }}

V príklade vyššie, keď vyvolávame adderServiceSteps.whenAccumulate (), pole základného čísla v @Služba vstreknutý dovnútra adderServiceSteps sa zmení:

@ContextConfiguration (classes = AdderService.class) verejná trieda AdderServiceSteps {@Autowired private AdderService adderService; private int danéČíslo; súkromná int základňa; súkromná int suma; public void givenBaseAndAdder (int base, int adder) {this.base = base; adderService.baseNum (základ); this.givenNumber = sčítač; } public void whenAdd () {sum = adderService.add (givenNumber); } public void summedUp () {assertEquals (base + givenNumber, sum); } public void sumWrong () {assertNotEquals (base + givenNumber, sum); } public void whenAccumulate () {sum = adderService.accumulate (givenNumber); }}

Konkrétne priradíme súčet k základnému číslu:

@Service verejná trieda AdderService {private int num; public void baseNum (int base) {this.num = base; } public int currentBase () {return num; } public int add (int sčítač) {return this.num + sčítač; } public int akumulovať (int sčítač) {return this.num + = sčítač; }}

V prvom teste _0_givenNumber_whenAddAndAccumulate_thenSummedUp, zmení sa základné číslo, čím sa kontext zašpiní. Keď sa pokúsime pridať ďalšie číslo, nedostaneme očakávanú sumu.

Všimnite si, že aj keď sme prvý test označili ako @DirtiesContext, druhý test je stále ovplyvnený: po sčítaní je súčet stále nesprávny. Prečo?

Teraz, zatiaľ čo na úrovni metódy spracovania @DirtiesContext„Integrácia Serenity Spring“ obnoví iba kontext testu pre aktuálnu inštanciu testu. Základný kontext závislostí v @Kroky nebude prestavaný.

Tento problém obísť môžeme injekciou @Služba v našej súčasnej inštancii testu a urobiť službu ako explicitnú závislosť @Kroky:

@RunWith (SerenityRunner.class) @FixMethodOrder (MethodSorters.NAME_ASCENDING) @ContextConfiguration (classes = AdderService.class) verejná trieda AdderMethodDirtiesContextDependencyWorkaroundIntegrationTest {private AdderConstructorDependencySteps @Autowired private AdderService adderService; @ Pred public void init () {adderSteps = nový AdderConstructorDependencySteps (adderService); } // ...}
verejná trieda AdderConstructorDependencySteps {private AdderService adderService; public AdderConstructorDependencySteps (AdderService adderService) {this.adderService = adderService; } // ...}

Alebo môžeme vložiť krok inicializácie podmienky do @ Predtým časti, aby ste sa vyhli špinavému kontextu. Ale tento druh riešenia nemusí byť v niektorých zložitých situáciách k dispozícii.

@RunWith (SerenityRunner.class) @FixMethodOrder (MethodSorters.NAME_ASCENDING) @ContextConfiguration (classes = AdderService.class) verejná trieda AdderMethodDirtiesContextInitWorkaroundIntegrationTest {@Steps private AdderServiceSteps adderServiceSteps adderServiceSteps @ Pred verejnosťou void init () {adderServiceSteps.givenBaseAndAdder (randomInt (), randomInt ()); } // ...}

3.2. SpringIntegrationClassRule

Aby sme povolili anotácie na úrovni triedy, mali by sme použiť SpringIntegrationClassRule. Povedzme, že máme nasledujúce testovacie triedy; kontext každého kontextu:

@RunWith (SerenityRunner.class) @ContextConfiguration (triedy = AdderService.class) verejná statická abstraktná trieda Base {@Steps AdderServiceSteps adderServiceSteps; @ClassRule public static SpringIntegrationClassRule springIntegrationClassRule = nový SpringIntegrationClassRule (); void whenAccumulate_thenSummedUp () {adderServiceSteps.whenAccumulate (); adderServiceSteps.summedUp (); } void whenAdd_thenSumWrong () {adderServiceSteps.whenAdd (); adderServiceSteps.sumWrong (); } void whenAdd_thenSummedUp () {adderServiceSteps.whenAdd (); adderServiceSteps.summedUp (); }}
@DirtiesContext (classMode = AFTER_CLASS) verejná statická trieda DirtiesContextIntegrationTest rozširuje Base {@Test public void givenNumber_whenAdd_thenSumWrong () {super.whenAdd_thenSummedUp (); adderServiceSteps.givenBaseAndAdder (randomInt (), randomInt ()); super.whenAccumulate_thenSummedUp (); super.whenAdd_thenSumWrong (); }}
@DirtiesContext (classMode = AFTER_CLASS) verejná statická trieda AnotherDirtiesContextIntegrationTest rozširuje Base {@Test public void givenNumber_whenAdd_thenSumWrong () {super.whenAdd_thenSummedUp (); adderServiceSteps.givenBaseAndAdder (randomInt (), randomInt ()); super.whenAccumulate_thenSummedUp (); super.whenAdd_thenSumWrong (); }}

V tomto príklade budú všetky implicitné injekcie prestavané na úrovni triedy @DirtiesContext.

3.3. SpringIntegrationSerenityRunner

Je tu pohodlná trieda SpringIntegrationSerenityRunner čím sa automaticky pridajú obidve pravidlá integrácie vyššie. S týmto bežcom môžeme spustiť testy vyššie, aby sme v našom teste nešpecifikovali pravidlá testovania metód alebo tried:

@RunWith (SpringIntegrationSerenityRunner.class) @ContextConfiguration (locations = "classpath: adder-beans.xml") verejná trieda AdderSpringSerenityRunnerIntegrationTest {@Steps private AdderSteps adderSteps; @Value ("# {props ['adder']}" ") private int sčítač; @Test public void givenNumber_whenAdd_thenSummedUp () {adderSteps.givenNumber (); adderSteps.whenAdd (sčítač); adderSteps.thenSummedUp (); }}

4. Integrácia SpringMVC

V prípadoch, keď potrebujeme iba otestovať komponenty SpringMVC so Serenity, môžeme jednoducho využiť RestAssuredMockMvc v pokoji zaistený namiesto vyrovnanosť-jar integrácia.

4.1. Maven závislosť

Musíme pridať spoľahlivú závislosť spring-mock-mvc na istotu pom.xml:

 io.rest-zabezpečený test Spring-Mock-MVC 3.0.3 

4.2. RestAssuredMockMvc v akcii

Poďme teraz otestovať nasledujúci radič:

@RequestMapping (value = "/ sčítač", produkuje = MediaType.APPLICATION_JSON_UTF8_VALUE) @RestController verejná trieda PlainAdderController {private final int currentNumber = RandomUtils.nextInt (); @GetMapping ("/ current") public int currentNum () {return currentNumber; } @PostMapping public int add (@RequestParam int num) {return currentNumber + num; }}

Môžeme využiť výhody nástrojov na posmievanie sa z MVC RestAssuredMockMvc Páči sa ti to:

@RunWith (SerenityRunner.class) verejná trieda AdderMockMvcIntegrationTest {@Before public void init () {RestAssuredMockMvc.standaloneSetup (nový PlainAdderController ()); } @Steps AdderRestSteps kroky; @ Test public void givenNumber_whenAdd_thenSummedUp () vyvolá výnimku {steps.givenCurrentNumber (); steps.whenAddNumber (randomInt ()); steps.thenSummedUp (); }}

Zvyšná časť sa potom nelíši od toho, ako ju používame pokojný:

verejná trieda AdderRestSteps {private MockMvcResponse mockMvcResponse; private int currentNum; @Step ("získať aktuálne číslo") public void givenCurrentNumber () hodí UnsupportedEncodingException {currentNum = Integer.valueOf (given () .when () .get ("/ adder / current") .mvcResult () .getResponse (). getContentAsString ()); } @Step ("pridanie {0}") public void whenAddNumber (int num) {mockMvcResponse = given () .queryParam ("num", num) .when () .post ("/ adder"); currentNum + = num; } @Step ("mám súčet") public void thenSummedUp () {mockMvcResponse .then () .statusCode (200) .body (equalTo (currentNum + "")); }}

5. Serenity, JBehave a Spring

Podpora integrácie Serenity Spring funguje bez problémov s JBehave. Napíšme náš testovací scenár ako príbeh JBehave:

Scenár: Používateľ môže zadať číslo do sčítačky a získať súčet Dané číslo Keď zadám ďalšie číslo 5 do sčítačky Potom dostanem súčet čísel

Logiku môžeme implementovať v a @Služba a vystaviť akcie prostredníctvom API:

@RequestMapping (value = "/ sčítač", produkuje = MediaType.APPLICATION_JSON_UTF8_VALUE) @RestController verejná trieda AdderController {private AdderService adderService; public AdderController (AdderService adderService) {this.adderService = adderService; } @GetMapping ("/ current") public int currentNum () {return adderService.currentBase (); } @PostMapping public int add (@RequestParam int num) {return adderService.add (num); }}

Teraz môžeme vytvoriť test Serenity-JBehave pomocou RestAssuredMockMvc nasledovne:

@ContextConfiguration (classes = {AdderController.class, AdderService.class}) verejná trieda AdderIntegrationTest rozširuje SerenityStory {@Autowired private AdderService adderService; @BeforeStory public void init () {RestAssuredMockMvc.standaloneSetup (nový AdderController (adderService)); }}
verejná trieda AdderStory {@Steps AdderRestSteps restSteps; @Given ("a number") public void givenANumber () vyvolá výnimku {restSteps.givenCurrentNumber (); } @When ("Zadám ďalšie číslo $ num do sčítačky") public void whenISubmitToAdderWithNumber (int num) {restSteps.whenAddNumber (num); } @Then ("dostanem súčet čísel") public void thenIGetTheSum () {restSteps.thenSummedUp (); }}

Môžeme iba označiť SerenityStory s @ContextConfiguration, potom sa vstrekovanie pružín povolí automaticky. To funguje úplne rovnako ako @ContextConfiguration na @Kroky.

6. Zhrnutie

V tomto článku sme sa venovali integrácii Serenity BDD s Spring. Integrácia nie je úplne dokonalá, ale určite sa tam dostáva.

Úplnú implementáciu nájdete ako vždy v projekte GitHub.


$config[zx-auto] not found$config[zx-overlay] not found