6
votes

Y a-t-il un cadre Java BDD capable de réutiliser, alors? (avec diverses étape)

Je recherche un cadre Java BDD avec possibilité de réutiliser des tests d'unité et d'intégration.

En d'autres termes 1. donné une condition préalable. 2. quand - selon l'environnement 3. alors vérifie les résultats de quand

Je veux pouvoir changer en changeant quand, et en gardant donné et alors intact, modifiez le type du test, par exemple en simple service de repos:

  1. test unitaire
    • donné
      • génère un objet pojo
      • quand
        • reçoit Pojo de donné
        • appelle le service interne avec ce pojo
        • reçoit le résultat de la forme Pojo du service
        • Awards a reçu Pojo à alors
        • alors
          • vérifie pojo de quand
          • Test d'intégration
            • donné
              • génère un objet pojo
              • quand
                • reçoit Pojo de donné
                • chiffre de la pojo dans le format de service externe
                • Appels Service externe
                • reçoit le format de service externe du service exposé
                • Transforms reçus Résultat à Pojo
                • Awards a reçu Pojo à alors
                • alors
                  • vérifie pojo de quand

                    Donc, par exemple, donné et puis se comporte de la même manière, pour l'intégration et les tests d'unité, et simplement changeur lorsque la portée du test va de l'unité à l'intégration .

                    quelqu'un peut-il me dire dans la bonne direction?

                    Je ne veux pas réinventer la roue


1 commentaires

Il y a une bonne discussion sur les frameworks BDD en Java sur Stackoverflow ici: Stackoverflow.com/questions/1068785/...


3 Réponses :


0
votes

Junit?

Il est tout à fait possible d'avoir une classe de base abstraite avec un @Before méthode (c'est-à-dire "" "") et une méthode courante avec des assertions (c'est-à-dire ").


0 commentaires

8
votes

Disclamer: Je suis l'auteur de jgiven.

jgiven fournit exactement cela. C'est un cadre BDD pour Java où des scénarios sont construits par des classes de théâtre. Pour votre exemple, vous avez besoin de quatre classes de stade: édifice, quandinternalservice, lorsqueexternalservice, et howoutput. Ensuite, vous pouvez écrire deux tests: P>

Essai d'unité pour le service interne: strong> p> xxx pré>

Test d'intégration pour le Service externe: strong> p> xxx pré>

Les classes de scène puis ressemblent à ceci: strong> p>

public class GivenInput extends Stage<GivenInput> {
    @ProvidedScenarioState
    InputPojo input;

    public GivenInput some_input() {
       input = new InputPojo();
       return self();
    }
}

public class WhenInternalService extends Stage<WhenInternalService> {
    @ExpectedScenarioState
    InputPojo input;

    @ProvidedScenarioState
    OutputPojo output;

    public WhenInternalService the_internal_service_is_called() {
        output = new InternalService().invoke(input);
        return self();
    }
}

public class WhenExternalService extends Stage<WhenExternalService> {
    @ExpectedScenarioState
    InputPojo input;

    @ProvidedScenarioState
    OutputPojo output;

    public WhenExternalService the_external_service_is_called() {
        ExternalInput externalInput = transformToExternal(input);
        ExternalOutput externalOutput = new ExternalService().invoke(external);
        output = transformToInternal(externalOutput);
        return self();
    }
}

public class ThenOutput extends Stage<ThenOutput> {
    @ExpectedScenarioState
    OutputPojo output;

    public ThenOutput the_result_is_correct() {
        assertThat(output).isNotNull();
        return self();
    }
}


2 commentaires

J'utilise jgiven personnellement récemment et je suis un fan instantané - plus de "sandwichs de concombre" pour moi :-)


Je suis heureux d'entendre que :-)