Introduzione a Serenity BDD

1. Introduzione

In questo tutorial, daremo un'introduzione a Serenity BDD, un ottimo strumento per applicare lo sviluppo guidato dal comportamento (BDD). Questa è una soluzione per test di accettazione automatizzati che genera rapporti di test ben illustrati.

2. Concetti fondamentali

I concetti alla base di Serenity seguono i concetti alla base di BDD. Se vuoi saperne di più, controlla il nostro articolo su Cucumber e JBehave.

2.1. Requisiti

In Serenity, i requisiti sono organizzati in tre livelli:

  1. capacità
  2. Caratteristiche
  3. storie

In genere, un progetto implementa funzionalità di alto livello, gestione degli ordini ex e capacità di gestione dei membri in un progetto di e-commerce. Ogni capacità è composta da molte funzionalità e le funzionalità sono spiegate in dettaglio nelle storie degli utenti.

2.2. Passaggi e test

I passaggi contengono un gruppo di operazioni di manipolazione delle risorse. Può essere un'azione, una verifica o un'operazione relativa al contesto. Il formato classico Given_When_Then può essere riflesso nei passaggi.

E i test vanno di pari passo con i passaggi. Ogni test racconta una semplice user story, che viene eseguita utilizzando determinati Step .

2.3. Rapporti

Serenity non solo riporta i risultati dei test, ma li utilizza anche per produrre documentazione vivente che descrive i requisiti e i comportamenti dell'applicazione.

3. Testare con SerenityBDD

Per eseguire i nostri test serenità con JUnit, abbiamo bisogno di @RunWith il SerenityRunner , test di corridore. SerenityRunner strumentalizza le librerie di passi e garantisce che i risultati dei test vengano registrati e riportati dai giornalisti di Serenity.

3.1. Dipendenze di Maven

Per utilizzare Serenity con JUnit, dovremmo includere serenity-core e serenity-junit nel pom.xml:

 net.serenity-bdd serenity-core 1.2.5-rc.11   net.serenity-bdd serenity-junit 1.2.5-rc.11 

Abbiamo anche bisogno del plugin Serenity-Maven per avere rapporti aggregati dai risultati dei test:

 net.serenity-bdd.maven.plugins serenity-maven-plugin 1.2.5-rc.6   serenity-reports post-integration-test  aggregate    

Se vogliamo che Serenity generi report anche in caso di errore del test, aggiungere quanto segue al pom.xml:

 org.apache.maven.plugins maven-surefire-plugin 2.20  true  

3.2. Un esempio di punti di iscrizione

Inizialmente, i nostri test si basano sulla caratteristica tipica dei punti di adesione in un'applicazione di e-commerce. Un cliente può aderire al programma membro. Man mano che il cliente acquista beni sulla piattaforma, i punti di iscrizione aumenteranno e il grado di iscrizione del cliente aumenterà di conseguenza.

Ora scriviamo diversi test rispetto agli scenari descritti sopra e vediamo come funziona Serenity.

Per prima cosa, scriviamo il test per l'inizializzazione dell'appartenenza e vediamo di quali passaggi abbiamo bisogno:

@RunWith(SerenityRunner.class) public class MemberStatusIntegrationTest { @Steps private MemberStatusSteps memberSteps; @Test public void membersShouldStartWithBronzeStatus() { memberSteps.aClientJoinsTheMemberProgram(); memberSteps.theMemberShouldHaveAStatusOf(Bronze); } }

Quindi implementiamo i due passaggi come segue:

public class MemberStatusSteps { private Member member; @Step("Given a member has {0} points") public void aMemberHasPointsOf(int points) { member = Member.withInitialPoints(points); } @Step("Then the member grade should be {0}") public void theMemberShouldHaveAStatusOf(MemberGrade grade) { assertThat(member.getGrade(), equalTo(grade)); } }

Ora siamo pronti per eseguire un test di integrazione con mvn clean verify . I rapporti si troveranno in target / site / serenity / index.html :

Dalla relazione, possiamo vedere che abbiamo solo un test di accettazione "I membri dovrebbero iniziare con lo status di bronzo, ha la capacità di" e sta passando. Cliccando sul test, vengono illustrati i passaggi:

Come possiamo vedere, il rapporto di Serenity ci offre una comprensione approfondita di ciò che sta facendo la nostra applicazione e se allinea i nostri requisiti. Se abbiamo alcuni passaggi da implementare, possiamo contrassegnarli come @Pending :

@Pending @Step("When the member exchange {}") public void aMemberExchangeA(Commodity commodity){ //TODO }

La relazione ci ricorderebbe cosa è necessario fare dopo. E nel caso in cui un test fallisca, può essere visto anche nel rapporto:

Ciascun passaggio fallito, ignorato o saltato verrà elencato rispettivamente:

4. Integrazione con JBehave

Serenity può anche integrarsi con i framework BDD esistenti come JBehave.

4.1. Dipendenze di Maven

To integrate with JBehave, one more dependency serenity-jbehave is needed in the POM:

 net.serenity-bdd serenity-jbehave 1.24.0 

4.2. JBehave Github REST API Test Continued

As we have introduced how to do REST API testing with JBehave, we can continue with our JBehave REST API test and see how it fits in Serenity.

Our story was:

Scenario: Github user's profile should have a login payload same as username Given github user profile api When I look for eugenp via the api Then github's response contains a 'login' payload same as eugenp

The Given_When_Then steps can be migrated to as @Steps without any changes:

public class GithubRestUserAPISteps { private String api; private GitHubUser resource; @Step("Given the github REST API for user profile") public void withUserProfileAPIEndpoint() { api = "//api.github.com/users/%s"; } @Step("When looking for {0} via the api") public void getProfileOfUser(String username) throws IOException { HttpResponse httpResponse = getGithubUserProfile(api, username); resource = retrieveResourceFromResponse(httpResponse, GitHubUser.class); } @Step("Then there should be a login field with value {0} in payload of user {0}") public void profilePayloadShouldContainLoginValue(String username) { assertThat(username, Matchers.is(resource.getLogin())); } }

To make JBehave's story-to-code mapping work as expected, we need to implement JBehave's step definition using @Steps:

public class GithubUserProfilePayloadStepDefinitions { @Steps GithubRestUserAPISteps userAPISteps; @Given("github user profile api") public void givenGithubUserProfileApi() { userAPISteps.withUserProfileAPIEndpoint(); } @When("looking for $user via the api") public void whenLookingForProfileOf(String user) throws IOException { userAPISteps.getProfileOfUser(user); } @Then("github's response contains a 'login' payload same as $user") public void thenGithubsResponseContainsAloginPayloadSameAs(String user) { userAPISteps.profilePayloadShouldContainLoginValue(user); } }

With SerenityStories, we can run JBehave tests both from within our IDE and in the build process:

import net.serenitybdd.jbehave.SerenityStory; public class GithubUserProfilePayload extends SerenityStory {}

After the verify build finished, we can see our test report:

Compared to plain text report of JBehave, the rich report by Serenity gives us a more eye-pleasing and live overview of our story and the test result.

5. Integration With REST-assured

It is noteworthy that Serenity supports integration with REST-assured. To have a review of REST-assured, take a look at the guide to REST-assured.

5.1. Maven Dependencies

To make use of REST-assured with Serenity, the serenity-rest-assured dependency should be included:

 net.serenity-bdd serenity-rest-assured 1.2.5-rc.11 

5.2. Use REST-assured in Github REST API Test

Now we can replace our web client with REST-assured utilities:

import static net.serenitybdd.rest.SerenityRest.rest; import static net.serenitybdd.rest.SerenityRest.then; public class GithubRestAssuredUserAPISteps { private String api; @Step("Given the github REST API for user profile") public void withUserProfileAPIEndpoint() { api = "//api.github.com/users/{username}"; } @Step("When looking for {0} via the api") public void getProfileOfUser(String username) throws IOException { rest().get(api, username); } @Step("Then there should be a login field with value {0} in payload of user {0}") public void profilePayloadShouldContainLoginValue(String username) { then().body("login", Matchers.equalTo(username)); } }

After replacing the implementation of userAPISteps in the StepDefition, we can re-run the verify build:

public class GithubUserProfilePayloadStepDefinitions { @Steps GithubRestAssuredUserAPISteps userAPISteps; //... }

In the report, we can see the actual API invoked during the test, and by clicking on the REST Query button, the details of request and response will be presented:

6. Integration With JIRA

As of now, we already have a great test report describing details and status of our requirements with Serenity framework. But for an agile team, issue tracking systems such as JIRA are often used to keep track of requirements. It would be better if we could use them seamlessly.

Luckily, Serenity already supports integration with JIRA.

6.1. Maven Dependencies

To integrate with JIRA, we need another dependency: serenity-jira-requirements-provider.

 net.serenity-bdd serenity-jira-requirements-provider 1.1.3-rc.5 

6.2. One-way Integration

To add JIRA links in the story, we can add the JIRA issue using story's meta tag:

Meta: @issue #BDDTEST-1

Inoltre, l'account ei collegamenti JIRA dovrebbero essere specificati nel file serenity.properties alla radice del progetto:

jira.url= jira.project= jira.username= jira.password=

Quindi ci sarebbe un collegamento JIRA aggiunto al rapporto:

Serenity supporta anche l'integrazione a due vie con JIRA, possiamo fare riferimento alla documentazione ufficiale per maggiori dettagli.

7. Riepilogo

In questo articolo abbiamo introdotto Serenity BDD e molteplici integrazioni con altri framework di test e sistemi di gestione dei requisiti.

Sebbene abbiamo coperto la maggior parte di ciò che Serenity può fare, sicuramente può fare di più. Nel nostro prossimo articolo, tratteremo di come Serenity con il supporto di WebDriver può permetterci di automatizzare le pagine delle applicazioni web usando la sceneggiatura.

Come sempre, il codice di implementazione completo può essere trovato nel progetto GitHub.