Développement axé sur le comportement pour java - quel framework utiliser? [en attente]

En tant qu'auteur de JGiven Je dois être en désaccord avec sody que Java n'a pas assez de flexibilité pour la création DSL. Dans JGiven, les tests BDD se présentent comme suit:

@Test
public void users_can_login {
    given()
       .a_registered_user()
       .and().the_login_page_is_shown();

    when()
       .the_user_enters_correct_credentials()
       .and().the_login_button_is_pressed();

    then()
       .the_welcome_page_is_shown();
}

JGiven est utilisé avec JUnit ou TestNG et vous écrivez vos tests en Java simple.

Sauf si votre product owner/qa/customer doit être capable de lire les tests, utilisez Spock. C'est un outil très simple, mais améliore la lisibilité des tests. Grâce à ses fonctionnalités puissantes, vous n'avez pas besoin de Mockito, Hamcrest ni d'AssertJ. Et il a de superbes tests paramétrés. En fait, c'est" juste " un meilleur JUnit - un outil général pour l'exécution automatisée de tâches simples, qu'il s'agisse de tests unitaires, de tests d'intégration ou de tests d'acceptation.

Craignant Groovy? Pourquoi? Il est très similaire à java. Le plus vous l'apprenez, plus votre code est expressif et court. Vos tests seront plus courts et plus lisibles. Groovy est une drogue de passerelle vers le meilleur côté de la JVM.

Vous n'aimez pas les langages dynamiques? Eh bien, c'est - tests, et les tests sont exécutés par le serveur CI après chaque commit, droit? Si votre code se casse, vous le saurez après quelques minutes. Vous n'avez pas de serveur CI ou n'exécutez pas de tests régulièrement? Alors ne vous embêtez pas avec le choix d'un cadre de test et allez corriger votre processus. Tests cassés sont inutile et si vous n'exécutez pas les tests régulièrement, ils se casseront bientôt.

Allez avec JBehave/Cucumber si vous en avez besoin; Sinon, utilisez Spock.

Une Autre alternative serait de Spectre - voir https://github.com/greghaskins/spectrum

Spectrum prend en charge la syntaxe RSpec/Mocha et, dans sa prochaine version, prendra également en charge la syntaxe Gherkin, ainsi que l'intégration des règles JUnit (il interagit donc avec Mockito, Spring, etc. via les membres @Rule et @ClassRule).

Divulgation complète-Je suis un contributeur à ce projet OS

Exemple:

@RunWith(Spectrum.class)
public class TestSomething {{
    Supplier<Something> freshTestObject = let(Something::new);

    describe("The component", () -> {
        it("is tested by specs", () -> {
            // the "let` above gives us a new instance of the object
            // in each spec
            freshTestObject.get().doSomething();

            // using your favourite assertion framework
            assertThat(something.get().getSomething()).isEqualTo(42);
        });
    });
}}

Spectrum affiche un résultat de test hiérarchique dans votre JUnit console. Sa force réside dans le mélange de l'implémentation Java de l'exécution de la spécification avec la définition de la spécification - cela peut être plus direct que les frameworks qui s'appuient sur des fichiers de fonctionnalités et collent du code pour les analyser, surtout s'il est nécessaire de passer les résultats d'une étape du test à une autre.

Spectrum vise à être polyglotte, il devrait donc sembler familier aux utilisateurs de plusieurs frameworks existants.

Belle discussion! Je ne savais pas JGiven, mais je vais jeter un oeil dedans.

De plus, je suis l'auteur de COLA Tests, un nouveau framework qui prend en charge la syntaxe complète de gherkin (exactement la même que Cucumber), il est vraiment facile à configurer, surtout par rapport à JBehave et ne nécessite pas JUnit runner.

Fondamentalement, utilisez simplement les bibliothèques auxquelles vous êtes déjà habitué!

Voici un exemple de test Spring Controller (les histoires peuvent être chargées à partir d'un fichier):

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = { WebAppContext.class })
public class HelloWorldControllerTest extends BaseColaTest {

    private final String stories =
        "Feature: Introduce REST endpoint\n"
            + "Scenario: Should say hello\n"
            + "Given a web endpoint\n"
            + "When hit by a get request\n"
            + "Then the HTTP status will be OK\n"
            + "And the body will say hello world";

    @Resource
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;
    private ResultActions result;

    @Given("a web endpoint")
    public void given() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
    }

    @When("hit by a get request")
    public void when() throws Exception {
        result = mockMvc.perform(get("/helloWorld"));
    }

    @Then("the HTTP status will be OK")
    public void thenOk() throws Exception {
        result.andExpect(status().isOk());
    }

    @Then("the body will say hello world")
    public void thenHello() throws Exception {
        result.andExpect(content().string("Hello World!"));
    }
}

Donnez à Ginkgo4j un coup. Il utilise les lamda de Java 8 pour refléter l'approche utilisée par RSpec de Ruby et Ginkgo de Go.

Cette bibliothèque vous permet de créer des tests expressifs et riches en contenu.

```

package com.github.paulcwarren.ginkgo4j.examples;

import static com.github.paulcwarren.ginkgo4j.Ginkgo4jDSL.*;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

import org.junit.runner.RunWith;

import com.github.paulcwarren.ginkgo4j.Ginkgo4jRunner;

@RunWith(Ginkgo4jRunner.class)
public class BookTests {
    private Book longBook;
    private Book shortBook;
    {
        Describe("Book", () -> {
            BeforeEach(() -> {
                longBook = new Book("Les Miserables", "Victor Hugo", 1488);
                shortBook = new Book("Fox In Socks", "Dr. Seuss", 24);
       });

       Context("Categorizing book length", () -> {
           Context("With more than 300 pages", () -> {
               It("should be a novel", () -> {
                   assertThat(longBook.categoryByLength(), is("NOVEL"));
               });
           });

           Context("With fewer than 300 pages", () -> {
               It("should be a short story", () -> {
                   assertThat(shortBook.categoryByLength(), is("NOVELLA"));
              });
           });
       });
       });
     }
}

```

Prend également en charge Spring.

(divulgation Complète. Je suis l'auteur de cette bibliothèque).