Intégration du ressort de concombre

Intégration de ressort de concombre

1. Vue d'ensemble

Cucumber est un framework de test très puissant écrit dans le langage de programmation Ruby, qui suit la méthodologie BDD (behavior-driven development). Son objectif est de permettre aux développeurs d'écrire des cas d'utilisation de haut niveau en texte clair pouvant être vérifié par des parties prenantes non techniques, et de les transformer en tests exécutables, écrits dans un langage appelé Gherkin.

Nous en avons déjà discuté dans undifferent article.

Et leCucumber-Spring Integration est destiné à faciliter l'automatisation des tests. Une fois que nous avons intégré les tests Cucumber à Spring, nous devrions pouvoir les exécuter avec la construction Maven.

2. Dépendances Maven

Commençons à utiliser l'intégration Cucumber-Spring en définissant les dépendances Maven - en commençant par la dépendance Cucumber-JVM:


    info.cukes
    cucumber-java
    1.2.4
    test

La version la plus récente de Cucumber JVM peut être trouvéehere.

Ensuite, nous allons ajouter la dépendance de test JUnit et Cucumber:


    info.cukes
    cucumber-junit
    1.2.4
    test

La version la plus récente de Cucumber JUnit peut être trouvéehere.

Et enfin, la dépendance de printemps et de concombre:


    info.cukes
    cucumber-spring
    1.2.4
    test

La version la plus récente de Cucumber Spring peut être trouvéehere.

3. Configuration

Nous allons maintenant voir comment nous pouvons intégrer Cucumber dans une application de service Spring Micro. La première étape consiste à créer une application Spring Boot - pour laquelle nous suivrons lesSpring-Boot application article.

Ensuite, nous allons créer un service Spring REST dans l'application Boot et écrire le test Cucumber pour ce service REST.

3.1. Contrôleur REST

Dans un premier temps, créons une classe de contrôleur pour une API REST simple:

@RestController
public class VersionController {
    @RequestMapping(method={RequestMethod.GET},value={"/version"})
    public String getVersion() {
        return "1.0";
    }
}

3.2. Définitions de l'étape de concombre

Le coureur JUnit utilise le framework JUnit pour exécuter le test de concombre. Tout ce dont nous avons besoin est de créer une seule classe vide avec une annotation@RunWith(Cucumber.class):

@RunWith(Cucumber.class)
@CucumberOptions(features = "src/test/resources")
public class CucumberTest {
}

Nous pouvons voir l'annotation@CucumberOptions où nous spécifions l'emplacement du fichier Gherkin, également connu sous le nom de fichier d'entités. À ce stade, Cucumber reconnaît le langage Gherkin; vous pouvez en savoir plus sur Gherkin dans l'article mentionné dans l'introduction.

Alors maintenant, créons un fichier de fonction Cucumber:

Feature: the version can be retrieved
  Scenario: client makes call to GET /version
    When the client calls /version
    Then the client receives status code of 200
    And the client receives server version 1.0

Et jetons un œil au fichier d'entités. Le scénario consiste à effectuer un appel GET à l'url du service REST/version et à affirmer la réponse.

L'étape suivante consiste à créer la méthode dans la classe Java pour qu'elle corresponde à ce cas de test:

@When("^the client calls /version$")
public void the_client_issues_GET_version() throws Throwable{
    executeGet("http://localhost:8080/version");
}

@Then("^the client receives status code of (\\d+)$")
public void the_client_receives_status_code_of(int statusCode) throws Throwable {
    HttpStatus currentStatusCode = latestResponse.getTheResponse().getStatusCode();
    assertThat("status code is incorrect : "+
    latestResponse.getBody(), currentStatusCode.value(), is(statusCode));
}

@And("^the client receives server version (.+)$")
public void the_client_receives_server_version_body(String version) throws Throwable {
    assertThat(latestResponse.getBody(), is(version));
}

Nous devons maintenant exécuter ces méthodes de test de concombre à l'aide de Maven et Spring. Créez une classe pouvant être exécutée avec Spring-JUnit afin que Maven puisse exécuter les classes de test suivantes:

@ContextConfiguration(
  classes = SpringDemoApplication.class,
  loader = SpringApplicationContextLoader.class)
@WebAppConfiguration
@IntegrationTest
public class SpringIntegrationTest {

}

Désormais, toutes les définitions de concombre peuvent aller dans une classe Java distincte qui s'étend à la classe Java mentionnée ci-dessus:

public class StepDefs extends SpringIntegrationTest {

    @When("^the client calls /version$")
    public void the_client_issues_GET_version() throws Throwable {
        executeGet("http://localhost:8080/version");
    }
}

Nous sommes tous prêts pour un essai.

Nous pouvons faire une exécution rapide via la ligne de commande, en exécutant simplementmvn clean install -Pintegration - Maven exécutera les tests d'intégration et affichera les résultats dans la console.

3 Scenarios ([32m3 passed[0m)
9 Steps ([32m9 passed[0m)
0m1.054s

Tests run: 12, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 9.283 sec - in
  com.example.CucumberTest
2016-07-30 06:28:20.142  INFO 732 --- [Thread-2] AnnotationConfigEmbeddedWebApplicationContext :
  Closing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext:
  startup date [Sat Jul 30 06:28:12 CDT 2016]; root of context hierarchy

Results :

Tests run: 12, Failures: 0, Errors: 0, Skipped: 0

4. Conclusion

Après avoir configuré Cucumber with Spring, il sera pratique d’utiliser les composants configurés par Spring lors des tests BDD. Ceci est un guide simple pour intégrer le test Cucumber dans une application Spring-Boot.

Vous pouvez trouver un exemple de projet basé sur le code de cet article dans lelinked GitHub repository.

TOC