Come si differenzia Cucumber da JUnit?

Question

qualcuno può spiegare la differenza per me tra i Cucumber e Junit

Dalla mia comprensione sono entrambi utilizzati per testare codice Java, anche se non sono sicuro della differenza?

Sono semplicemente implementazioni di differenza della stessa suite di test o mirate a testare cose diverse?

Answer 1

Cetriolo e JUnit sono diversi e risolvono cose diverse.

Cucumber è un framework BDD (Behavior Driven Design) che prende "storie" o scenari scritti in lingue leggibili come l'inglese e trasforma quei testi leggibili in un test del software.

qui è una storia Esempio cetriolo:

cetriolo poi sa come trasformare questo testo in un test del software per assicurarsi che il software funziona come descritto. L'uscita vi dirà se la storia è in realtà ciò che il software fa e se no, che cosa era diversa:

Ecco dove il codice è fissato per far passare il test di cetriolo:

Questo rende quella che viene chiamata una "Specifica eseguibile" che è un bel modo di documentare tutte le funzionalità supportate dal software. Questo è diverso dalla normale documentazione perché senza il test corrispondente, qualcuno che legge il documento non sa se la documentazione è aggiornata.

Altri vantaggi di eseguibili Specifiche:

• non-programmatori possono leggere e comprendere i test
• non-programmatori possono scrivono i test dal momento che sono in inglese.

I risultati BDD e le specifiche eseguibili sono di livello molto elevato. Coprono le caratteristiche generali e forse alcuni casi limite come esempi ma non testano tutte le condizioni possibili o ogni percorso di codice. Anche i test BDD sono "test di integrazione" in quanto testano il funzionamento di tutti i moduli di codice, ma non eseguono alcun test completo.

Qui JUnit entra.

JUnit è un livello utensile inferiore "test Unit" che consente agli sviluppatori di testare ogni possibile percorso di codice nel codice. Ogni modulo del tuo codice (o classi, o anche metodi) è testato in isolamento. È molto più basso di un quadro BDD. Utilizzando la stessa storia della calcolatrice dell'esempio di Cucumber, i test di JUnit testano molti esempi di calcolo diversi e input non validi per assicurarsi che il programma risponda correttamente e calcoli correttamente i valori.

Speranza che aiuti

Answer 2

Cetriolo è il modo in cui è possibile eseguire lo sviluppo basato sul comportamento BDD. Qualcosa come te può convertire il tuo caso d'uso funzionale in storia di Cucumber. In questo senso puoi anche utilizzare Cucumber come DSL per il documento caso d'uso funzionale.

JUnit sull'altro lato è per il test dell'unità che sarebbe un metodo in Java. Quindi un uso può essere un test unitario (raramente però) al test di inegrazione o un test di sistema completo, questo è il tuo primo caso Cucumber. Unit Test sarà solo Unit Test.

Answer 3

Penso che Cucumber sia più utilizzato per i test di integrazione, mentre JUnit è più utilizzato nei test comportamentali. Inoltre, la sintassi di Cucumber è più accurata di JUnit, ma molto più complessa. Qui potete vedere un esempio di test di cetriolo:

package com.c0deattack.cucumberjvmtutorial; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 
import cucumber.runtime.PendingException; 

public class DepositStepDefinitions { 

    @Given("^a User has no money in their account$") 
    public void a_User_has_no_money_in_their_current_account() { 
     User user = new User(); 
     Account account = new Account(); 
     user.setAccount(account); 
    } 

    @When("^£(\\d+) is deposited in to the account$") 
    public void £_is_deposited_in_to_the_account(int arg1) { 
     // Express the Regexp above with the code you wish you had 
     throw new PendingException(); 
    } 

    @Then("^the balance should be £(\\d+)$") 
    public void the_balance_should_be_£(int arg1) { 
     // Express the Regexp above with the code you wish you had 
     throw new PendingException(); 
    } 

    private class User { 
     private Account account; 

     public void setAccount(Account account) { 
      this.account = account; 
     } 
    } 

    private class Account { 
    } 
} 

Si può vedere che JUnit è più semplice, ma non necessariamente meno potente:

import static org.junit.Assert.assertEquals; 

import org.junit.AfterClass; 
import org.junit.BeforeClass; 
import org.junit.Test; 

public class MyClassTest { 

    @Test(expected = IllegalArgumentException.class) 
    public void testExceptionIsThrown() { 
    MyClass tester = new MyClass(); 
    tester.multiply(1000, 5); 
    } 

    @Test 
    public void testMultiply() { 
    MyClass tester = new MyClass(); 
    assertEquals("10 x 5 must be 50", 50, tester.multiply(10, 5)); 
    } 
} 

Speranza che aiuta,

Clemencio Morales Lucas.