Cetriolo - Guida rapida

Al fine di ottenere un migliore vantaggio dal test del software, le organizzazioni stanno attualmente facendo un passo avanti. Implementano importanti scenari di test di accettazione mentre lo sviluppo è in corso. Questo approccio è comunemente noto comeBehavior Driven Development (BDD).

Lo sviluppo guidato dal comportamento ci offre l'opportunità di creare script di test sia dal punto di vista dello sviluppatore che da quello del cliente. Quindi, all'inizio, gli sviluppatori, i project manager, i QA, i tester di accettazione degli utenti e il proprietario del prodotto (azionista), si riuniscono e fanno un brainstorming su quali scenari di test dovrebbero essere superati per chiamare questo software / applicazione di successo. In questo modo escogitano una serie di scenari di prova. Tutti questi script di test sono in semplice lingua inglese, quindi serve anche a scopo di documentazione.

Esempio

Se stiamo sviluppando una funzionalità di autenticazione utente, i seguenti possono essere alcuni scenari di test chiave, che devono essere superati per definirlo un successo.

  • L'utente dovrebbe essere in grado di accedere con il nome utente e la password corretti.

  • L'utente non dovrebbe essere in grado di accedere con un nome utente errato e una password corretta.

  • L'utente non dovrebbe essere in grado di accedere con il nome utente corretto e la password errata.

Come funziona

Quando il codice è pronto, anche gli script di test sono pronti. Il codice deve superare gli script di test definiti in BDD. In caso contrario, sarà necessario il refactoring del codice. Il codice viene bloccato solo dopo aver eseguito correttamente gli script di test definiti.

È un'idea molto semplice, ma ciò di cui abbiamo bisogno per implementare questo concetto. La risposta è: Behaviour Driven Development (BDD) Framework. Il cetriolo è uno di questi strumenti open source, che supporta lo sviluppo guidato dal comportamento. Per essere più precisi, Cucumber può essere definito come un framework di test, guidato da un semplice testo inglese. Serve come documentazione, test automatizzati e aiuto allo sviluppo, tutto in uno.

Allora cosa fa il cetriolo? Può essere descritto nei seguenti passaggi:

Cucumber legge il codice scritto in un semplice testo inglese (Language Gherkin - che verrà introdotto più avanti in questo tutorial) nel file delle caratteristiche (che verrà introdotto in seguito).

Trova la corrispondenza esatta di ogni passaggio nella definizione del passaggio (un file di codice - dettagli forniti più avanti nel tutorial).

Il pezzo di codice da eseguire può essere diversi framework software come Selenium, Ruby on Rails, ecc. Non tutti gli strumenti del framework BDD supportano tutti gli strumenti.

Questa è diventata la ragione della popolarità di Cucumber rispetto ad altri framework, come JBehave, JDave, Easyb, eccetera.

Cucumber supporta oltre una dozzina di diverse piattaforme software come:

  • Ruby on Rails
  • Selenium
  • PicoContainer
  • Quadro di primavera
  • Watir

Vantaggi del cetriolo rispetto ad altri strumenti

  • Cucumber supporta diversi linguaggi come Java.net e Ruby.

  • Funge da ponte tra il linguaggio commerciale e il linguaggio tecnico. Possiamo farlo creando un test case in semplice testo inglese.

  • Permette di scrivere lo script di test senza la conoscenza di alcun codice, consente anche il coinvolgimento di non programmatori.

  • Serve allo scopo del framework di test end-to-end a differenza di altri strumenti.

  • A causa della semplice architettura dello script di test, Cucumber fornisce la riusabilità del codice.

In questo capitolo, vedremo l'impostazione dell'ambiente per Cucumber con Selenium WebDriver e Java, su Windows Machine.

Prerequisiti per la configurazione dell'ambiente

Di seguito sono riportati i prerequisiti necessari per configurare:

Giava

Why we need- Java è un robusto linguaggio di programmazione. Cucumber supporta la piattaforma Java per l'esecuzione.

How to install -

Step 1 - Scarica jdk e jre dal seguente link http://www.oracle.com/technetwork/java/javase/downloads/index.html

Step 2 - Accetta il contratto di licenza.

Step 3 - Installa JDK e JRE.

Step 4 - Imposta la variabile d'ambiente come mostrato nelle schermate seguenti.

Eclisse

Why we need- Eclipse è un ambiente di sviluppo integrato (IDE). Contiene un'area di lavoro di base e un sistema di plug-in estensibile per la personalizzazione dell'ambiente.

How to install -

Step 1 - Assicurati che JAVA sia installato sulla tua macchina.

Step 2 - Scarica Eclipse da https://eclipse.org/downloads/

Step 3 - Unzip ed Eclipse è installato.

Esperto di

Why we need- Maven è uno strumento di automazione della compilazione utilizzato principalmente per i progetti Java. Fornisce una piattaforma comune per eseguire attività come la generazione del codice sorgente, la compilazione del codice, il confezionamento del codice in un jar, ecc. Successivamente, se una qualsiasi delle versioni del software viene modificata, Maven fornisce un modo semplice per modificare di conseguenza il progetto di test.

How to install -

Step 1 - Scarica Maven dal seguente link - https://maven.apache.org/download.cgi

Step 2 - Decomprimere il file e ricordare la posizione.

Step 3 - Crea la variabile d'ambiente MAVEN_HOME come mostrato nello screenshot seguente.

Step 4 - Modifica la variabile Path e includi Maven come mostrato nello screenshot seguente.

Step 5 - Scarica il plugin MAVEN da Eclipse.

Step 6 - Apri Eclipse.

Step 7 - Vai su Aiuto → Eclipse Marketplace → Cerca in Maven → Maven Integration for Eclipse → INSTALL.

Configura Cucumber con Maven

Step 1 - Crea un progetto Maven.

  • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

  • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

  • Fornisci ID artefatto (l'ID artefatto è il nome del vaso senza versione. Puoi scegliere qualsiasi nome, che è in minuscolo). Fare clic su Fine.

Step 2 - Apri pom.xml.

  • Vai a Esplora pacchetti sul lato sinistro di Eclipse.

  • Espandi il progetto CucumberTest.

  • Individuare pom.xml file.

  • Fare clic con il tasto destro e selezionare l'opzione, aprire con "Editor di testo".

Step 3 - Aggiungi dipendenza per il selenio: questo indicherà a Maven quali file jar di selenio devono essere scaricati dal repository centrale al repository locale.

  • Aperto pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

  • All'interno del tag dependencies, crea il tag dependency (<dependency> </dependency>).

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 4 - Aggiungi dipendenza per Cucumber-Java: questo indicherà Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza

<dependency> 
   <groupId>info.cukes</groupId>
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 5 - Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 6 - Aggiungi dipendenza per JUnit: questo indicherà Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 7 - Verifica i binari.

  • Una volta pom.xml è stato modificato con successo, salvalo.

  • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

Sarai in grado di vedere un repository Maven come mostrato nello screenshot seguente.

  • Crea un file di caratteristiche (da trattare in seguito).

  • Creare un file di definizione del passaggio (da trattare in seguito).

  • Crea un corridore JUnit per eseguire il test (da trattare in seguito).

Finora, abbiamo capito bene il cetriolo e cosa fa. Esegue gli script di test, che sono stati definiti nel file delle caratteristiche (da trattare nei capitoli successivi). La lingua in cui è scritto questo file eseguibile di funzionalità è nota comeGherkin. Gherkin è un semplice linguaggio di testo inglese, che aiuta lo strumento - Cucumber a interpretare ed eseguire gli script di test.

Si potrebbe pensare che, è stato discusso molte volte che Cucumber supporta un semplice testo inglese, quindi perché abbiamo bisogno di una lingua separata: i cetriolini. La risposta sta nel concetto di Behavior Driven Development.

Come discusso in precedenza, abbiamo visto che BDD incorpora prospettive diverse durante la creazione di script di test. Può essere una prospettiva di sviluppo, una prospettiva di business, ecc. Detto questo, avremo bisogno di persone di comunità diverse come sviluppatori, project manager, proprietari di prodotti e tester durante lo sviluppo di script di test. Poiché queste persone non appartengono alla stessa categoria, c'è il rischio di non utilizzare il linguaggio comune per la concettualizzazione dello script di test. Questo è stato il punto di evoluzione per Gherkins.

Gherkin fornisce l'insieme comune di parole chiave nel testo inglese, che può essere utilizzato da persone di comunità diverse e tuttavia ottiene lo stesso risultato sotto forma di script di test.

Esempio

Feature - Funzionalità di accesso per un sito di social networking. Given Sono un utente di un sito di social networking. When Inserisco username come username1. And Inserisco la password come password 1. Then Dovrei essere reindirizzato alla home page del sito.

Lo scenario sopra menzionato è di una funzionalità chiamata login utente. Tutte le parole evidenziate in grassetto sono parole chiave Gherkin.

Esempio di poche altre parole chiave:

  • Background
  • But
  • *
  • Schema dello scenario
  • Examples

Gherkin analizzerà ogni passaggio scritto nel file di definizione del passaggio (da trattare in seguito). Quindi i passaggi menzionati nel file delle caratteristiche e nel file di definizione dei passaggi (da trattare in seguito) dovrebbero corrispondere.

È possibile individuare i barattoli Gherkin nella cartella Dipendenze Maven in Esplora pacchetti. Viene scaricato insieme agli altri barattoli di cetriolo. Assomiglierà al seguente screenshot:

Un altro fatto interessante su Gherkin è che supporta non solo l'inglese ma molte altre lingue native come francese, finlandese, indonesiano, ungherese, hindi, urdu, gujarati, ecc.

UN Featurepuò essere definito come unità autonoma o funzionalità di un progetto. Facciamo un esempio molto comune di un sito di social networking. Come si presenta la caratteristica di questo prodotto / progetto? Poche caratteristiche di base possono essere determinate come:

  • Crea e rimuovi l'utente dal sito di social networking.

  • Funzionalità di accesso utente per il sito di social networking.

  • Condivisione di foto o video sul sito di social network.

  • Invio di una richiesta di amicizia.

  • Logout.

Ormai è chiaro che ogni funzionalità indipendente del prodotto in prova può essere definita come una caratteristica quando parliamo di Cucumber. È una buona pratica in seguito, quando si avvia il test, che prima di derivare gli script di test, dovremmo determinare le funzionalità da testare.

Una funzionalità di solito contiene un elenco di scenari da testare per quella funzionalità. Un file in cui memorizziamo le funzionalità, la descrizione delle funzionalità e gli scenari da testare è noto comeFeature File. Vedremo di più sui file di funzionalità nel capitolo successivo.

La parola chiave per rappresentare una caratteristica sotto test in Gherkins è "Feature". La best practice suggerita è scrivere una piccola descrizione della caratteristica sotto il titolo della caratteristica nel file della caratteristica. Ciò soddisferà anche la necessità di una buona documentazione.

Esempio

Feature - Funzionalità di accesso per un sito di social networking.

L'utente dovrebbe essere in grado di accedere al sito del social network se il nome utente e la password sono corretti.

All'utente dovrebbe essere mostrato il messaggio di errore se il nome utente e la password non sono corretti.

L'utente dovrebbe essere indirizzato alla home page, se il nome utente e la password sono corretti.

File di funzionalità

Il file, in cui sono scritti i test di Cucumber, è noto come feature files. È consigliabile che ci dovrebbe essere un file di funzionalità separato, per ogni funzionalità in prova. L'estensione del file delle caratteristiche deve essere ".feature".

È possibile creare tutti i file di funzionalità necessari. Per avere una struttura organizzata, ogni funzionalità dovrebbe avere un file di funzionalità.

Ad esempio -

Suor n Caratteristica Nome del file di funzionalità
1 Login utente userLogin.feature
2 Condividi il post sharePost.feature
3 Creare un profilo createAccount.feature
4 Eliminare l'account deleteAccount.feature

La convenzione di denominazione da utilizzare per il nome della caratteristica, il nome del file della caratteristica dipende dalla scelta dell'individuo. Non esiste una regola di base in Cucumber sui nomi.

Un semplice file di funzioni è costituito dalle seguenti parole chiave / parti:

  • Feature - Nome della funzione in prova.

  • Description (facoltativo) - Descrivi la funzione in prova.

  • Scenario - Qual è lo scenario di prova.

  • Given - Prerequisito prima che i passaggi del test vengano eseguiti.

  • When - Condizione specifica che deve corrispondere per eseguire il passaggio successivo.

  • Then - Cosa dovrebbe accadere se la condizione menzionata in QUANDO è soddisfatta.

Esempio

Feature - Accesso utente sul sito di social networking.

L'utente dovrebbe essere in grado di accedere al sito del social network quando il nome utente e la password sono corretti.

All'utente dovrebbe essere visualizzato un messaggio di errore quando il nome utente e la password non sono corretti.

L'utente dovrebbe essere indirizzato alla home page se il nome utente e la password sono corretti.

Outline - Funzionalità di accesso per un sito di social networking.

L'utente specificato naviga su Facebook. Quando inserisco Username come "<username>" e Password come "<password>". Quindi, il login dovrebbe avere esito negativo.

| username  | password  |
| username1 | password1 |

* AND la parola chiave viene utilizzata per mostrare la congiunzione tra due condizioni. AND può essere utilizzato con qualsiasi altra parola chiave come GIVEN, WHEN e THEN.

Non ci sono dettagli logici scritti nel file delle caratteristiche.

Definizioni dei passaggi

Abbiamo pronto il nostro file di funzionalità con gli scenari di test definiti. Tuttavia, questo non è il lavoro completo fatto. Cucumber non sa quale parte di codice deve essere eseguita per uno scenario specifico delineato in un file di funzionalità.

Ciò richiede la necessità di un file intermedio - Step Definition. Il file di definizione dei passaggi memorizza la mappatura tra ogni passaggio dello scenario definito nel file delle caratteristiche con un codice di funzione da eseguire.

Quindi, ora quando Cucumber esegue un passaggio dello scenario menzionato nel file delle caratteristiche, scansiona il file di definizione del passaggio e capisce quale funzione deve essere chiamata.

Esempio di file di definizione del passaggio

public void goToFacebook() { 
   driver = new FirefoxDriver(); 
   driver.navigate().to("https://www.facebook.com/"); 
} 
@When "^user logs in using Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$" public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then"^login should be unsuccessful$" 
public void validateRelogin() { 
   if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
         System.out.println("Test Pass");
   } else { 
      System.out.println("Test Failed"); 
   } 
   driver.close(); 
}

Quindi con ogni funzione, qualunque sia il codice che si desidera eseguire con ogni passo del test (cioè DATO / ALLORA / QUANDO), è possibile scriverlo nel file di definizione del passo. Assicurati che il codice / funzione sia stato definito per ciascuno dei passaggi.

Questa funzione può essere funzioni Java, dove possiamo usare sia i comandi Java che Selenium per automatizzare i nostri passaggi di test.

Scenarioè una delle strutture principali di Gherkin. Ogni scenario inizia con la parola chiave "Scenario:" (o uno localizzato) ed è seguito da un titolo opzionale dello scenario. Ogni funzionalità può avere uno o più scenari e ogni scenario è costituito da uno o più passaggi. Un esempio molto semplice di scenario può essere:

Scenario - Verifica la funzionalità della Guida.

Dato l'utente naviga su Facebook.

Quando l'utente fa clic su Guida, si apre la pagina della Guida.

Considera un caso in cui è necessario eseguire uno scenario di test più di una volta. Supponiamo di dover assicurarci che la funzionalità di accesso funzioni per tutti i tipi di titolari di abbonamento. Ciò richiede l'esecuzione dello scenario della funzionalità di accesso più volte. Copia incolla gli stessi passaggi per rieseguire il codice, non sembra essere un'idea intelligente. Per questo, Gherkin fornisce un'altra struttura, che è lo schema dello scenario.

Lo schema dello scenario è simile alla struttura dello scenario; l'unica differenza è la fornitura di più input. Come puoi vedere nell'esempio seguente, il test case rimane lo stesso e non ripetibile. In fondo abbiamo fornito più valori di input per le variabili "Username" e "Password". Durante l'esecuzione del test effettivo, Cucumber sostituirà la variabile con i valori di input forniti ed eseguirà il test. Una volta eseguito pass-1, il test verrà eseguito nuovamente per la seconda iterazione con un altro valore di input. Tali variabili o segnaposto possono essere rappresentati con "<>" mentre vengono citati con istruzioni gherkin.

Esempio

Scenario Outline- Funzionalità di accesso per un sito di social networking. L'utente specificato naviga su Facebook.

Quando l'utente accede utilizzando il nome utente come "<username>" e la password come "<password>", il login dovrebbe essere riuscito.

| username | password  | 
| user1    | password1 | 
| user2    | password2 |

Ci sono alcuni suggerimenti e trucchi per definire in modo intelligente gli scenari di cetriolo.

  • Ogni passaggio dovrebbe essere chiaramente definito, in modo da non creare confusione per il lettore.

  • Non ripetere lo scenario di test, se necessario utilizzare lo schema dello scenario per implementare la ripetizione.

  • Sviluppare una fase di test in modo che possa essere utilizzata all'interno di più scenari e schemi di scenari.

  • Per quanto possibile, mantieni ogni passaggio completamente indipendente. Ad esempio: "Dato che l'utente è loggato". Questo può essere suddiviso in due fasi

    • Dato l'utente inserisce il nome utente.
    • Fare clic su login.

Annotationè un testo predefinito, che ha un significato specifico. Permette al compilatore / interprete di sapere cosa fare durante l'esecuzione. Il cetriolo ha le seguenti annotazioni:

  • Given -

    • Descrive il prerequisito per l'esecuzione del test.

    • Esempio: DATO Sono un utente di Facebook

  • When -

    • Definisce il punto di attivazione per l'esecuzione di qualsiasi scenario di test.

    • Esempio: QUANDO inserisco "<username>"

  • Then -

    • Quindi contiene il risultato atteso per l'esecuzione del test.

    • Esempio: POI il login dovrebbe essere riuscito.

  • And -

    • Fornisce la condizione AND logica tra due istruzioni. AND può essere utilizzato insieme alle dichiarazioni GIVEN, WHEN e THEN.

    • Esempio: QUANDO inserisco "<username>" E inserisco "<password>"

  • But -

    • Indica la condizione OR logica tra due istruzioni. OR può essere utilizzato insieme alle dichiarazioni GIVEN, WHEN e THEN.

    • Esempio: POI il login dovrebbe essere riuscito. MA la home page non dovrebbe mancare.

  • Scenario -

    • I dettagli sullo scenario sotto il test devono essere acquisiti dopo la parola chiave "Scenario:"

    • Esempio -

      Scenario:

      DATO Sono un utente di Facebook

      QUANDO entro nel mio

      E inserisco il mio

      POI il login dovrebbe avere successo.

      MA la home page non dovrebbe mancare.

  • Scenario Outline - (da trattare in seguito)

  • Examples - (da trattare in seguito)

  • Background -

    • Lo sfondo generalmente contiene le istruzioni su cosa impostare prima dell'esecuzione di ogni scenario. Tuttavia, viene eseguito dopo l'hook "Before" (da trattare in seguito). Quindi questo è l'ideale per essere utilizzato per il codice quando vogliamo configurare il browser web o vogliamo stabilire la connettività del database.

      • Esempio -

        Sfondo:

        Vai alla home page di Facebook.

Scenario di esempio

Automatizziamo uno scenario per comprendere meglio le annotazioni.

Step 1

Crea un progetto di test Maven denominato come AnnotationTest.

  • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

  • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

  • Fornisci ID artefatto (l'ID artefatto è il nome del file jar senza versione. Puoi scegliere qualsiasi nome in minuscolo).

  • Fare clic su Fine.

  • Aperto pom.xml −

    • Vai a Esplora pacchetti sul lato sinistro di Eclipse.

    • Espandi il progetto AnnotationTest.

    • Individua il file pom.xml.

    • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

  • Aggiungi dipendenza per Selenium - Questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

    • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

    • All'interno del tag dependencies, crea il tag dependency (<dependency> </dependency>).

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

  • Aggiungi dipendenza per Cucumber-Java: questo indicherà Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Verifica i binari.

    • Una volta modificato con successo pom.xml, salvalo.

    • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

Step 2

Crea un pacchetto denominato Annotation in src/test/java

  • Seleziona il progetto appena creato.

  • Fare clic con il tasto destro e selezionare "Nuovo".

  • Seleziona l'opzione come "Pacchetto".

  • Assegnalo "Annotazione".

  • Salvarlo.

Step 3

Crea un file di funzionalità denominato annotation.feature.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file un nome come outline.feature.

  • Scrivi il seguente testo all'interno del file e salvalo.

Feature: annotation 
#This is how background can be used to eliminate duplicate steps 

Background: 
   User navigates to Facebook Given 
   I am on Facebook login page 

#Scenario with AND 
Scenario: 
   When I enter username as "TOM"
   And I enter password as "JERRY" 
   Then Login should fail 

#Scenario with BUT 
Scenario: 
   When I enter username as "TOM" 
   And I enter password as "JERRY" 
   Then Login should fail 
   But Relogin option should be available

Step 4

Crea un file di definizione del passaggio.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file il nome annotation.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Annotation; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class annotation { 
   WebDriver driver = null; 
   @Given("^I am on Facebook login page$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter username as \"(.*)\"$") 
   public void enterUsername(String arg1) {   
      driver.findElement(By.id("email")).sendKeys(arg1); 
   }
	
   @When ("^I enter password as \"(.*)\"$") public void enterPassword(String arg1) { driver.findElement(By.id("pass")).sendKeys(arg1); driver.findElement(By.id("u_0_v")).click(); } @Then("^Login should fail$") 
   public void checkFail() {  
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test1 Pass"); 
      } else { 
         System.out.println("Test1 Failed"); 
      } 
      driver.close(); 
   } 
	
   @Then("^Relogin option should be available$") 
   public void checkRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test2 Pass"); 
      } else { 
         System.out.println("Test2 Failed"); 
      } 
      driver.close(); 
   }
}

Step 5

Crea un file di classe corridore.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna un nome al file, ad esempio runTest.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Annotation; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { 
}

Step 6

Esegui il test utilizzando l'opzione -

  • Seleziona il file runTest.java da Esplora pacchetti.

  • Fare clic con il tasto destro e selezionare l'opzione ‘Run as’

  • Seleziona JUnit test.

Osserverai le seguenti cose quando esegui questo file di classe:

  • Facebook si apre in una nuova istanza del browser Web Firefox.

  • TOM verrà passato come input al campo del nome utente.

  • JERRY verrà passato come input al campo della password.

  • Fare clic su Login.

  • Sul browser verrà visualizzato un messaggio relativo all'accesso non riuscito.

  • Nella console, vedrai stampato "Test Pass"

  • Passaggio risultato da 1. a 5. Verrà eseguito nuovamente per nome utente come "" e password come "".

Scenario outlinesostanzialmente sostituisce variabile / parole chiave con il valore dalla tabella. Ogni riga della tabella è considerata uno scenario.

Continuiamo con lo stesso esempio della funzione di accesso a Facebook. Finora abbiamo eseguito uno scenario: dopo aver fornito il nome utente corretto, l'accesso è riuscito. Supponiamo ora di voler controllare se il login ha esito positivo per tutti e tre i possibili tipi di input, che sono nome utente, indirizzo e-mail o numero di telefono. Per ottenere ciò, avremo bisogno di scrivere tre diversi scenari, in cui ogni scenario varierà a seconda del tipo di input, l'accesso è riuscito. In questo caso, gli scenari appariranno come i seguenti.

Scenario:

Dato l'utente naviga su Facebook

Quando inserisco nome utente e password corretti

Quindi il login dovrebbe avere successo

Scenario:

Dato l'utente naviga su Facebook

Quando inserisco l'indirizzo e-mail e la password corretti

Quindi il login dovrebbe avere successo

Scenario:

Dato l'utente naviga su Facebook

Quando inserisco il numero di telefono e la password corretti

Quindi il login dovrebbe avere successo

Qui, se vediamo da vicino, per i tre scenari precedenti: le dichiarazioni sono le stesse, cambia solo il parametro di input (nome utente / indirizzo e-mail / numero di telefono). È qui che entra in gioco l'importanza dello schema dello scenario.

Quando definiamo uno scenario con lo schema dello scenario, possiamo specificare uno scenario di test e in fondo possiamo fornire una serie di input. Lo scenario verrà eseguito tante volte quante sono gli input forniti.

Esempio

Creiamo un esempio di schema di uno scenario:

Step 1 - Crea un progetto di test Maven denominato come ScenarioOutlineTest

  • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

  • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

  • Fornisci ID artefatto (l'ID artefatto è il nome del file jar senza versione. Puoi scegliere qualsiasi nome in minuscolo).

  • Fare clic su Fine.

  • Aperto pom.xml -

    • Vai a Esplora pacchetti sul lato sinistro di Eclipse.

    • Espandi il progetto CucumberTest.

    • Individua il file pom.xml.

    • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

  • Aggiungi dipendenza per Selenium - Questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

    • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

    • All'interno del tag dependencies, crea il tag dependency (<dependency> </dependency>).

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

  • Aggiungi dipendenza per Cucumber-Java: questo indicherà Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Verifica i binari.

    • Una volta modificato con successo pom.xml, salvalo.

    • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

Step 2 - Crea un pacchetto denominato "struttura" sotto src/test/java

Step 3 - Crea un file di funzionalità denominato “outline.feature”

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna un nome al file come “outline.feature”

    • Scrivi il seguente testo all'interno del file e salvalo.

      Feature - Schema dello scenario

      Scenario Outline - Funzionalità di accesso per un sito di social networking.

      Dato l'utente naviga su Facebook

      Quando inserisco il nome utente come "<username>" e la password come "<password>"

      Quindi il login dovrebbe fallire

Example -

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Note- Qui, l'annotazione di esempio descrive l'intervallo di input da fornire durante l'esecuzione dello scenario. Lo scenario di test verrà eseguito per ciascuno degli input forniti. Quindi, nell'esempio fornito, lo scenario di test verrà eseguito tre volte.

Step 4 - Crea un file di definizione del passaggio.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file il nome stepdefinition.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Outline;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class stepdefinition { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   }    
}

Note- Nel codice sopra, dobbiamo definire una funzione con due argomenti di input: uno username e l'altro sarà per la password. Quindi, per ogni set di input fornito nel tag di esempio, verrà eseguito Set of GIVEN, WHEN e THEN.

Step 5 - Crea un file di classe corridore.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna un nome al file come runTest.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})

public class runTest { }

  • Esegui il test utilizzando l'opzione -

    • Selezionare runTest.java file da Package Explorer.

    • Fare clic con il tasto destro e selezionare l'opzione ‘Run as’.

    • Seleziona JUnit test.

Osserverai le seguenti cose quando esegui questo file di classe

  • Facebook si apre in una nuova istanza del browser Web Firefox.

  • Nome utente1 e password1 verranno passati come input al campo nome utente e password.

  • Fare clic su Login.

  • Sul browser verrà visualizzato un messaggio relativo all'accesso non riuscito.

  • Nella console, vedrai stampato "Test Pass".

  • I risultati da 1 a 5 verranno rieseguiti per nome utente2 e password2.

In poche parole, quando lo scenario non cambia ma cambia solo il valore dei dati, è consigliabile utilizzare le tabelle dei dati di struttura dello scenario.

Sembra semplice quando abbiamo solo uno, due o forse cinque scenari in un file di funzionalità. Tuttavia, nella vita reale non accade. Per ogni funzionalità in prova, potremmo avere 10, 20 o un numero maggiore di scenari in un singolo file di funzionalità. Possono rappresentare uno scopo diverso (Smoke test / Regression test), diverse prospettive (Sviluppatore / QA / BA), diversi stati (Pronto per l'esecuzione / Lavori in corso), ecc.

Per questo, Cucumber ha già fornito un modo per organizzare l'esecuzione dello scenario utilizzando i tag nel file delle caratteristiche. Possiamo definire ogni scenario con un tag utile. Successivamente, nel file runner, possiamo decidere quale tag specifico (e così come gli scenari) che vogliamo che Cucumber esegua. Il tag inizia con "@". Dopo "@" puoi avere qualsiasi testo pertinente per definire il tuo tag. Capiamolo con un esempio.

Supponiamo che ci siano due o più scenari in un file di funzionalità. Vogliamo eseguire solo uno scenario come parte del test del fumo. Quindi la prima cosa è identificare quello scenario e la seconda è taggarlo con il testo "@SmokeTest" all'inizio dello scenario. Diamo uno sguardo approfondito a questo -

Step 1 - Crea un progetto Maven denominato come cucumberTag.

Step 2- Crea un pacchetto denominato cucumberTag sotto src/test/java

Step 3- Crea un file di funzionalità denominato cucumberTag.feature.

Scrivi il seguente testo all'interno del file e salvalo. Questo file di funzionalità contiene due scenari in cui solo uno è stato contrassegnato comeSmokeTest etichetta.

Feature - Tag cetriolo

Scenario Outline - Funzionalità di accesso per un sito di social networking.

Dato l'utente naviga su Facebook

Quando inserisco il nome utente come "<username>" e la password come "<password>"

Quindi il login dovrebbe fallire

Esempi

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Lo scenario #following è stato contrassegnato come SmokeTest e dovrebbe essere eseguito. @Test del fumo

Scenario:

Dato l'utente naviga su Facebook

Quando inserisco il nome utente come "<>" e la password come "<>"

Quindi l'utente dovrebbe essere reindirizzato per riprovare ad accedere

Step 4 - Crea un file di definizione del passaggio.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file un nome come cucumberTag.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package cucumberTag;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class cucumberTag { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") public void validateRelogin() { if(driver.getCurrentUrl().equalsIgnoreCase( "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ System.out.println("Test Pass"); } else { System.out.println("Test Failed"); } driver.close(); } @Then("^User should be redirected to login retry$") 
   public void loginRetry() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Step 5 - Crea un file di classe corridore.

  • Crea una classe di corridori chiamata come runTest.java all'interno della confezione.

  • Scrivi il codice seguente.

  • Salva il file.

package cucumberTag; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

  • Esegui l'opzione di test.

  • Fare clic con il tasto destro e selezionare l'opzione ‘Run as’.

  • Seleziona JUnit test.

Osserverai le seguenti cose, quando esegui questo file di classe.

  • Facebook si apre in una nuova istanza del browser Web Firefox.

  • Nessun valore verrà fornito al campo nome utente e password.

  • Fare clic su Login.

  • La pagina dei tentativi di accesso verrà caricata.

Non ci sono limiti nella definizione dei tag all'interno del file delle caratteristiche. In base alle tue esigenze, puoi derivare i tag da utilizzare e gli scenari da eseguire.

Esistono principalmente due tipi di tag:

  • Default tag- I tag predefiniti hanno i loro significati predefiniti. Esempio @ Dev, @ Ignore

  • Custom tag - Il tag personalizzato offre la massima flessibilità per scegliere il testo appropriato per definire il tag.

Il tag può anche essere definito a livello di funzionalità. Una volta definito un tag a livello di funzionalità, si garantisce che tutti gli scenari all'interno di quel file di funzionalità ereditino quel tag. A seconda della natura dello scenario, possiamo utilizzare più di un tag per la singola funzionalità. Ogni volta che Cucumber trova una chiamata appropriata, verrà eseguito uno scenario specifico.

Il cetriolo fornisce anche un modo per invertire la scelta dei tag. Considera che su 25 scenari definiti, 10 sono contrassegnati come test del fumo. Siamo tenuti a eseguire solo scenari di test di regressione.

Per questo, possiamo usare "~" nella classe runner JUnit per escludere lo scenario del test del fumo. Sarà simile al seguente.

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}, 
   tags = {"~@SmokeTest"})
	
public class runTest { }

Durante la definizione di più tag, possiamo anche definire logiche e / o logiche e operazioni.

  • Definizione logica o in classe corridore - @dev,@wip - Dice che gli scenari che corrispondono a uno qualsiasi di questo tag devono essere eseguiti.

  • Definizione logica o in classe corridore - [@dev,~@wip] − Dice che gli scenari che corrispondono a entrambi questi tag devono essere eseguiti.

Mentre lavoriamo sull'automazione, potremmo affrontare una varietà di scenari. Ogni scenario ha un significato e bisogni diversi.

Fin dall'inizio, abbiamo preso un esempio di funzionalità di accesso per un sito di social networking, dove avevamo solo due parametri di input da passare. Pensiamo a qualche altra possibilità. Che ne dici della funzionalità "Registrazione nuovo utente"? In genere, quali possono essere i parametri di input durante la registrazione di un nuovo utente per un sito di social networking? Qualcosa di simile al seguente -

  • Nome utente
  • Indirizzo email
  • Password
  • Reinserire la password
  • Birthdate
  • Gender
  • Numero di telefono

Feature - Nuova registrazione utente.

Verificare che la registrazione del nuovo utente non sia andata a buon fine dopo aver passato gli input errati.

Dato che sono su una nuova pagina di registrazione utente.

Quando inserisco il nome utente e un indirizzo e-mail come indirizzo e-mail e la password come, e reinserisco la password come e Data di nascita come e Sesso come e numero di telefono come allora la registrazione dell'utente non dovrebbe avere successo.

A prima vista sembra un po 'disordinato. Quindi, esiste un modo migliore per gestire una tale porzione di input? La risposta può essere "Tabella dati". La tabella dati è un insieme di input da fornire per un singolo tag. Questo tag può essere GIVEN, WHEN o THEN.

Scriviamo lo scenario sopra con l'aiuto della tabella dei dati e sarà simile al seguente:

Dato che sono su una nuova pagina di registrazione utente

Quando inserisco dati validi nella pagina

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

Quindi la registrazione dell'utente dovrebbe andare a buon fine.

Esempio

Automatizziamo un esempio di una tabella dati.

Step 1 - Creare un progetto di test Maven denominato "DataTableTest".

  • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

  • Fornire group Id (l'ID di gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

  • Fornire artifact Id (l'ID artefatto è il nome del vaso senza versione. Puoi scegliere qualsiasi nome in minuscolo).

  • Fare clic su Fine.

  • Apri pom.xml -

    • Vai a Esplora pacchetti sul lato sinistro di Eclipse.

    • Espandi il progetto CucumberTest.

    • Individua il file pom.xml.

    • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

  • Aggiungi dipendenza per Selenium: questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

    • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

    • All'interno del tag delle dipendenze, crea il tag delle dipendenze. (<dependency> </dependency>).

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

  • Aggiungi dipendenza per Cucumber-Java: questo indicherà Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Verifica i binari.

    • Una volta modificato con successo pom.xml, salvalo.

    • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

Step 2 - Crea un pacchetto denominato dataTable sotto src/test/java

Step 3 - Crea un file Feature.

  • Crea un file di caratteristiche, denominato come dataTable.feature all'interno del pacchetto dataTable (vedere la sezione schema dello scenario per passaggi più dettagliati).

  • Scrivi il testo seguente.

    Feature - Tabella dati

    Verificare che la registrazione del nuovo utente non sia andata a buon fine dopo aver passato input errati.

    Scenario:

    Dato che sono nella pagina di registrazione del nuovo utente

    Quando inserisco dati non validi nella pagina

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

Quindi la registrazione dell'utente dovrebbe fallire

  • Salva il file.

Step 4 - Crea file di definizione della fase.

  • Creare il file di definizione del passaggio denominato "dataTable.java" all'interno del pacchetto dataTable (vedere la sezione Schema dello scenario per i passaggi più dettagliati).

  • Scrivi il codice seguente.

package dataTable; 

import java.util.List; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.WebElement; 
import org.openqa.selenium.firefox.FirefoxDriver; 
import org.openqa.selenium.support.ui.Select;

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 
import cucumber.table.DataTable; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^I am on new user registration page$") public void goToFacebook() { //Intiate web browser instance. driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter invalid data on the page$") 
   public void enterData(DataTable table){ 
      //Initialize data table 
      List<list> data = table.raw();
      System.out.println(data.get(1).get(1)); 
      
      //Enter data
      driver.findElement(By.name("firstname")).sendKeys(data.get(1).get(1));
      driver.findElement(By.name("lastname")).sendKeys(data.get(2).get(1));
      driver.findElement(By.name("reg_email__")).sendKeys(data.get(3).get(1));     
      driver.findElement(By.name("reg_email_confirmation__")).
         sendKeys(data.get(4).get(1)); 
      driver.findElement(By.name("reg_passwd__")).sendKeys(data.get(5).get(1)); 
      
      Select dropdownB = new Select(driver.findElement(By.name("birthday_day"))); 
      dropdownB.selectByValue("15"); 
		
      Select dropdownM = new Select(driver.findElement(By.name("birthday_month")));
      dropdownM.selectByValue("6"); 
		
      Select dropdownY = new Select(driver.findElement(By.name("birthday_year")));
      dropdownY.selectByValue("1990"); 
		
      driver.findElement(By.className("_58mt")).click(); 
      // Click submit button driver.findElement(By.name("websubmit")).click(); 
   } 
	
   @Then("^User registration should be unsuccessful$") 
   public void User_registration_should_be_unsuccessful() {
      if(driver.getCurrentUrl().equalsIgnoreCase("https://www.facebook.com/")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

  • Salva il file.

Step 5 - Crea un file di classe corridore.

  • Crea una classe runner denominata runTest.java all'interno del pacchetto.

  • Scrivi il codice seguente.

package dataTable; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { }

  • Salva il file.

  • Esegui il test utilizzando l'opzione

    • Seleziona il file runTest.java da Esplora pacchetti.

    • Fare clic con il tasto destro e selezionare l'opzione Esegui come.

    • Seleziona JUnit test.

È possibile osservare le seguenti cose dopo l'esecuzione riuscita.

  • Il sito Web di Facebook viene caricato.

  • I dati verranno inseriti nella pagina di registrazione.

  • Fare clic sul pulsante Invia.

  • Vedremo che la home page non verrà visualizzata e sulla console verrà scritto “Test Pass”.

Commentè fondamentalmente un pezzo di codice destinato a scopo di documentazione e non per l'esecuzione. Che si tratti di un file di definizione del passaggio o di un file di funzionalità, per renderlo più leggibile e comprensibile. Quindi, è importante usare / inserire commenti nei punti appropriati del file. Questo aiuta anche durante il debug del codice. I file delle caratteristiche del cetriolo possono contenere commenti in qualsiasi luogo. Per inserire commenti, dobbiamo solo iniziare l'istruzione con il segno "#".

Diversi linguaggi di programmazione hanno norme diverse per la definizione dei commenti. Vediamo come se la cava Cucumber.

  • File di definizione del passaggio: se si utilizza Java come piattaforma, contrassegnare i commenti con "//".

  • File di funzionalità: in caso di file di funzionalità, è sufficiente inserire # prima di iniziare il commento.

Esempio

Il testo evidenziato nel programma fa riferimento ai commenti nel codice.

Feature: annotation 

#This is how background can be used to eliminate duplicate steps 
Background: 
User navigates to Facebook 
Given I am on Facebook login page 

#Scenario with AND 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 

#Scenario with BUT 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 
But Relogin option should be available

Cetriolo hookci permette di gestire meglio il flusso di lavoro del codice e ci aiuta a ridurre la ridondanza del codice. Possiamo dire che è un passaggio invisibile, che ci consente di eseguire i nostri scenari o test.

Per comprendere meglio questa nozione, prendiamo un esempio di un file di caratteristiche e un file di definizione dei passaggi.

La parte evidenziata nell'affermazione fornita svolge effettivamente il compito di configurare il webdriver e terminare la sessione del webdriver. Quindi, in realtà non è rilevante per l'essenza della "dichiarazione data", ed è più simile a una configurazione per il test. Inoltre, se pensiamo con una prospettiva più ampia, in caso di più scenari per questa funzione, questa configurazione e pulizia del webdriver verranno eseguite con ciascuna istruzione fornita. Logicamente, ha senso eseguire la configurazione e la pulizia una sola volta.

Quindi, per portare l'ottimizzazione, è possibile utilizzare gli hook. Più spesso usiamo due tipi di ganci: gancio "Prima" e gancio "Dopo". Metodo / funzione / parte di codice, definiti negli hook Prima e Dopo, vengono sempre eseguiti, anche se lo scenario viene superato o fallito.

Come suggerisce il nome, prima che l'hook venga eseguito ben prima di qualsiasi altro scenario di test, e dopo che l'hook venga eseguito dopo aver eseguito tutti gli scenari.

Gli hook vengono definiti solo all'interno del file di definizione del passaggio.

Automatizziamo un esempio di hook prima e dopo.

Step 1 - Crea il progetto Maven come hookTest, aggiungi la dipendenza necessaria in pom.xml.

Step 2 - Crea un pacchetto Java denominato hookTest in src/test/java

Step 3 - Creare un file di definizione del passaggio denominato come hookTest.java sotto il pacchetto.

package hookTest; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class hookTest {
   WebDriver driver = null; 
	
   @Before public void setUp(){ 
      driver = new FirefoxDriver(); 
   } 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/");
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") public void I_enter_Username_as_and_Password_as(String arg1, String arg2) { driver.findElement(By.id("email")).sendKeys(arg1); driver.findElement(By.id("pass")).sendKeys(arg2); driver.findElement(By.id("u_0_v")).click(); } @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
	
   @After public void cleanUp(){ 
      driver.close(); 
   } 
}

Step 4 - Creare un file di funzionalità denominato "hookTest.feature" nel pacchetto.

Feature - Schema dello scenario.

Scenario Outline - Hook Test

Dato l'utente naviga su Facebook

Quando inserisco il nome utente come "<username>" e la password come "<password>"

Quindi il login dovrebbe fallire

Esempi

| username  | password  | 
| username1 | password1 |

Step 5 - Crea un file di classe corridore.

  • Creare la classe runner come runTest.java all'interno del pacchetto dataTable (vedere la sezione Schema dello scenario per passaggi più dettagliati).

  • Scrivi il codice seguente.

package hookTest; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})  

public class runTest { }

  • Salva il file.

  • Esegui il test utilizzando l'opzione -

    • Seleziona il file runTest.java da Esplora pacchetti.

    • Fare clic con il tasto destro e selezionare l'opzione Esegui come.

    • Seleziona JUnit test.

Quindi ora quando eseguiamo questo, la seguente sarà la sequenza di esecuzione.

  • Prima del collegamento: configurare il webdriver e altri prerequisiti per eseguire il test.

  • Dichiarazione data

  • Quando dichiarazione

  • Quindi dichiarazione

  • Dopo l'hook: chiudi il webdriver ed esegui il processo di pulizia.

Ganci contrassegnati

Possiamo anche indicare se vogliamo che gli hook prima e dopo vengano eseguiti solo con un tag specifico. Example- @Before ('@ Web'). Lo stesso concetto di tag logico e / o può essere applicato anche con gli hook.Example - @Before (@ dev, @ wip), @Before (@ dev, ~ @ wip)

Il cetriolo può essere utilizzato per testare quasi tutti i sistemi informatici. Finora abbiamo visto come eseguire un test utilizzando Eclipse IDE. C'è un altro modo attraverso il quale possiamo eseguire il test Cucumber che è tramite l'interfaccia della riga di comando. Allora qual è il vantaggio di farlo?

L'esecuzione di qualsiasi framework di test dal Terminale ha i suoi vantaggi, come l'override delle configurazioni di esecuzione menzionate nel codice.

Per eseguire il test Cucumber con il prompt dei comandi, utilizzare i seguenti passaggi dopo la configurazione del sistema.

Step 1- Crea un progetto di test Maven denominato commandLine.

  • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

  • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

  • Fornisci ID artefatto (l'ID artefatto è il nome del file jar senza versione. Puoi scegliere qualsiasi nome in minuscolo).

  • Fare clic su Fine.

  • Apri pom.xml -

    • Vai all'esploratore di pacchetti sul lato sinistro di Eclipse.

    • Espandi il progetto CucumberTest.

    • Individuare pom.xml file.

    • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

  • Aggiungi dipendenza per Selenium - Questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

    • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

    • All'interno del tag delle dipendenze, crea il tag delle dipendenze. (<dependency> </dependency>).

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

  • Aggiungi dipendenza per Cucumber-Java: questo indicherà Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Verifica i binari.

    • Una volta modificato con successo pom.xml, salvalo.

    • Vai a Progetto → Pulisci - Ci vorranno pochi minuti.

Step 2 - Creare un pacchetto denominato "outline" in src / test / java

Step 3 - Creare un file di funzionalità denominato "commandLine.feature".

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file un nome come "commandLine.feature"

  • Scrivi sotto il testo all'interno del file e salvalo.

    Feature - Schema dello scenario

    Scenario Outline - Funzionalità di accesso per un sito di social networking.

    Dato che l'utente naviga su Facebook

    Quando inserisco il nome utente come "<username>" e la password come "<password>"

    Quindi il login dovrebbe fallire

Esempi

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

Note- Qui, l'annotazione di esempio descrive l'intervallo di input da fornire durante l'esecuzione dello scenario. Lo scenario di test verrà eseguito per ciascuno degli input forniti. Quindi, nell'esempio fornito, lo scenario di test verrà eseguito tre volte.

Step 4 - Crea un file di definizione del passaggio.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file il nome commandLine.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Outline; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; i
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^user navigates to facebook$") public void goToFacebook() { driver = new FirefoxDriver(); driver.navigate().to("https://www.facebook.com/"); } @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

Note- Nel codice, dobbiamo definire una funzione con due argomenti di input: uno username e l'altro sarà per la password. Quindi, per ogni set di input fornito nel tag di esempio, verrà eseguito il set di GIVEN, WHEN e THEN.

Step 5 - Crea un file di classe corridore.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file un nome come, runTest.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

  • Apri un prompt dei comandi.

  • Vai alla directory in cui risiede questo pacchetto "commandLine". e: \ Workspace \ LoginTest \ src> cd test \ java

  • Esegui il comando mvn test: vedrai che tutti gli scenari descritti nel file delle caratteristiche sono stati eseguiti (se non ci sono errori). Infine, in basso troverai le seguenti informazioni.

Risultato

This describes the total test run, along with failure if any.

Il comando precedente esegue tutto come menzionato nella classe JUnit Runner. Tuttavia, se vogliamo sovrascrivere le configurazioni menzionate nel Runner, di seguito sono riportati i pochi esempi per farlo.

  • Ora esegui il comando mvn test - Dcucumber.options = "- help" sul prompt dei comandi. L'esecuzione di questo stamperà tutte le opzioni disponibili.

  • Per eseguire solo tag specifici, eseguire il comando mvn test -Dcucumber.options = "- tags @SmokeTest" sul prompt dei comandi. Eseguirà solo i tag contrassegnati con @SmokeTest.

  • Per modificare il formato del risultato, eseguire il comando E: \ Workspace \ LoginTest> mvn test -Dcucumber.options = "- plugin junit: target / cucumber-junit-report.xml" sul prompt dei comandi Modifica il report formato al generatore di rapporti JUnit.

È importante capire cos'è Junit prima di iniziare la nostra discussione su Cucumber JUnit Runner. JUnitè un framework di unit test open source per il linguaggio di programmazione Java. JUnit è stato importante nello sviluppo dello sviluppo basato sui test ed è uno di una famiglia di framework di unit test, noti collettivamente come xUnit che hanno avuto origine con SUnit.

Vantaggi dell'utilizzo di JUnit

  • L'unità ha un file Graphical User Interface (GUI), che consente di scrivere e testare il codice sorgente in modo rapido e semplice.

  • JUnit consente allo sviluppatore di creare suite di test in modo incrementale per misurare i progressi e rilevare effetti collaterali indesiderati.

  • Il test può essere eseguito continuamente.

  • JUnit mostra l'avanzamento del test in una barra che normalmente è verde ma diventa rossa quando un test fallisce.

Ormai, abbiamo visto i vantaggi dell'utilizzo di JUnit, ma il motivo per cui ne stiamo discutendo in questo momento è il framework Cucumber. Da un lato, Cucumber offre a persone non tecniche un modo per definire casi di test per un prodotto e, dall'altro, la nostra aspettativa è un'esecuzione fluida e tempestiva di tali casi di test.

JUnit funge da ponte tra questi due. Quindi, il flusso di esecuzione sarà simile al seguente:

  • Le parti interessate annotano il file delle caratteristiche.

  • Il file di definizione del passaggio verrà creato di conseguenza.

  • Specificare la classe runner JUnit per eseguire la serie di casi di test.

  • Dopo aver eseguito la classe runner JUnit -

    • Analizzerà il file delle caratteristiche di Gherkin.

    • Eseguirà le funzioni scritte nel file di definizione del passaggio in base alle istruzioni del file di funzionalità.

    • JUnit combinerà il risultato del test case.

    • Creerà il rapporto di prova nel formato specificato (che può essere html / JSON).

Il punto importante qui è come configurare JUnit per fare tutte queste cose? Di seguito sono riportati i passaggi:

Step 1 - Installa Java.

  • Scarica jdk e jre dal link http://www.oracle.com/technetwork/java/javase/downloads/index.html

  • Accetta il contratto di licenza.

  • Installa JDK e JRE.

  • Imposta la variabile d'ambiente come mostrato nello screenshot seguente.

Step 2 - Installa Eclipse.

  • Why we need- Eclipse è un ambiente di sviluppo integrato (IDE). Contiene un'area di lavoro di base e un sistema di plug-in estensibile per la personalizzazione dell'ambiente.

  • How to install -

    • Assicurati che JAVA sia installato sulla tua macchina.

    • Scarica Eclipse da http://www.eclipse.org/downloads

    • Unzip ed Eclipse è installato.

Step 3 - Installa Maven.

  • Why we need- Maven è uno strumento di automazione della compilazione utilizzato principalmente per i progetti Java. Fornisce una piattaforma comune per eseguire attività come la generazione del codice sorgente, la compilazione del codice, il confezionamento del codice in un jar, ecc. Inoltre, in seguito, se una delle versioni del software viene modificata, Maven fornisce un modo semplice per modificare di conseguenza il progetto di test.

  • How to install -

    • Scarica Maven - https://maven.apache.org/download.cgi

    • Decomprimere il file e ricordare la posizione.

    • Crea la variabile d'ambiente MAVEN_HOME come mostrato nello screenshot seguente.

  • Modifica la variabile Path e includi Maven come mostrato nello screenshot seguente.

  • Scarica il plugin MAVEN da Eclipse.

    • Apri Eclipse.

    • Aiuto → Eclipse Marketplace → Cerca maven → Maven Integration for Eclipse → INSTALL.

Step 4 - Come configurare Cucumber con Maven

  • Crea un progetto Maven in Eclipse.

    • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

    • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

    • Fornisci ID artefatto (l'ID artefatto è il nome del file jar senza versione. Puoi scegliere qualsiasi nome in minuscolo).

    • Fare clic su Fine.

  • Apri pom.xml

    • Vai a Esplora pacchetti sul lato sinistro di Eclipse.

    • Espandi il progetto CucumberTest.

    • Individua il file pom.xml.

    • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

  • Aggiungi dipendenza per Selenium - Questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

    • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

    • All'interno del tag delle dipendenze, crea il tag delle dipendenze. (<dependency> </dependency>).

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

  • Aggiungi dipendenza per Cucumber-Java - Indica Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per Cucumber-JUnit: questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

  • Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

    • Crea un altro tag di dipendenza.

    • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

  • Verifica i binari

    • Una volta pom.xml è stato modificato con successo, salvalo.

    • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

    • Dopodiché sarai in grado di vedere un repository Maven come lo screenshot seguente.

Step 5 - Crea file di caratteristiche (da trattare in seguito).

Step 6 - Creare un file di definizione della fase (da trattare in seguito).

Step 7 - Crea un corridore Junit per eseguire il test (da trattare in seguito).

Eseguiamo test per comprendere la stabilità di un prodotto, quindi che si tratti di test manuale o test automatizzato, è molto importante generare un report conciso che possa rappresentare la stabilità di un prodotto. Quindi, mentre automatizziamo il nostro scenario di test con Cucumber, è essenziale sapere quanto meglio possiamo generare i nostri rapporti sui test di Cucumber. Poiché sappiamo che Cucumber è un framework BDD, non dispone di un meccanismo di segnalazione di fantasia.

Per raggiungere questo obiettivo, dobbiamo integrare Cucumber con altri strumenti open source come Ant / Junit. Qui, prenderemo ulteriori esempi di JUnit perché fornisce supporto per il linguaggio Java.

Esaminiamo i dettagli dei diversi formati di report, disponibili e facili da usare:

Formato grazioso (report HTML)

Pretty Format genera il rapporto di prova Cucumber in formato HTML, cioè un file HTML. È il formato di report più leggibile. Genera il rapporto nello stesso modo in cui è un file di funzionalità, quindi anche la traccia è facilitata. Inoltre, è possibile specificare la posizione in cui si desidera che questo rapporto venga posizionato dopo l'esecuzione del test. Può essere -

  • Local Directory - È possibile specificare la directory di destinazione per il report come qualsiasi directory locale della macchina in cui verrà eseguito il test.

  • Server Directory- Inoltre, abbiamo una disposizione per specificare una directory di destinazione come qualsiasi directory sul server, che è accessibile pubblicamente. Questo generalmente aiuta quando vogliamo che i nostri clienti / stakeholder visualizzino i risultati del test in un dato momento.

Esempio

Automatizziamo un esempio di un bel formato.

Step 1 - Crea un progetto Maven denominato cucumberReport in Eclipse.

Step 2 - Crea un pacchetto denominato CucumberReport sotto src/test/java

Step 3 - Crea un file di funzionalità denominato cucumberReport.feature

Scrivi il seguente testo all'interno del file e salvalo.

Feature - Rapporto sui cetrioli

# Questo serve per controllare il risultato del test per il caso di test Pass

Scenario: Esiste la funzionalità di accesso

Dato che ho aperto il browser

Quando apro il sito web di Facebook

Quindi dovrebbe esistere il pulsante di accesso

#Questo serve per controllare il risultato del test per il caso di test non riuscito

Scenario: La password dimenticata esiste

Dato che ho aperto il browser

Quando apro il sito web di Facebook

Quindi dovrebbe esistere il collegamento Password dimenticata

Note- Qui lo scenario prima passerà, mentre il secondo scenario fallirà. In modo che possiamo testimoniare come appare il rapporto di passaggio e fallito.

Step 4 - Crea un file di definizione del passaggio.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file il nome cucumberReport.java

  • Scrivi il seguente testo all'interno del file e salvalo.

package CucumberReport; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class cucumberReport { 
   WebDriver driver = null;
	
   @Given("^I have open the browser$") 
   public void openBrowser() { 
      driver = new FirefoxDriver();
   } 
	
   @When("^I open Facebook website$") public void goToFacebook() { driver.navigate().to("https://www.facebook.com/"); } @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail");
      }
   } 
	
   @Then("^Forgot password link should exist$") 
   public void forgotPWD() { 
      if(driver.findElement(By.id("")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else {
         System.out.println("Test 1 Fail");
      } 
   } 
}

Step 5 - Crea un file di classe corridore.

  • Crea una classe di corridori chiamata runTest.java all'interno della confezione.

  • Scrivi il codice seguente. Salva il file.

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( 
   format = {"pretty", "html:target/Destination"} ) 
//Specifying pretty as a format option ensure that HTML report will be generated. 
//When we specify html:target/Destination - It will generate the HTML report 

inside the Destination folder, in the target folder of the maven project.
 
public class runTest { }

  • Esegui il test utilizzando l'opzione

    • Selezionare runTest.java file da Package Explorer.

    • Fare clic con il tasto destro e selezionare l'opzione, Run as.

    • Seleziona JUnit test.

Osserverai le seguenti cose quando esegui questo file di classe.

Entrambi gli scenari verranno eseguiti uno per uno.

Una cartella denominata Destinazione verrà creata all'interno della directory di destinazione.

Il rapporto sarà lì denominato "Index.html".

Apri Index.html con il browser web.

Vedrai il rapporto menzionato nell'immagine seguente:

Evidenzia esattamente il colore dello scenario fallito. Inoltre, vedrai l'evidenziazione per il passaggio non riuscito in quello scenario. Questo rende il debug molto semplice.

Rapporto JSON

Ormai abbiamo visto quanto sia facile il report HTML. Tuttavia, se vogliamo trasmettere queste informazioni di report a qualsiasi altra applicazione, è un po 'complicato in caso di report HTML. Ecco la necessità di un altro formato di rapporto. La notazione dell'oggetto script JSON-Java è un altro formato per la generazione di rapporti di prova Cucumber. JSON è un oggetto contenente molte informazioni archiviate in formato testo. I rapporti JSON apportano un valore diverso alla tabella. Il report JSON può anche essere utilizzato come payload di informazioni da trasferire tra diversi server. Inoltre, può essere utilizzato per essere visualizzato come una pagina web. In poche parole, i report JSON possono essere utilizzati da altre applicazioni.

What is payload information?Quando i dati vengono inviati su Internet, ciascuna unità trasmessa include sia le informazioni di intestazione che i dati effettivi inviati. L'intestazione identifica l'origine e la destinazione del pacchetto, mentre i dati effettivi sono indicati come payload. Per generare un report JSON, è sufficiente apportare una modifica al file runner.

  • Modificare l'opzione di formato nel file del corridore come segue.

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( format={"json:target/Destination/cucumber.json"}) 

//When we specify json:target/Destination/cucumber.json - It will generate the JSON  
report inside the Destination folder, in the target folder of the maven project.

public class runTest {}

  • Esegui il test utilizzando l'opzione -

    • Selezionare runTest.java file da Package Explorer.

    • Fare clic con il tasto destro e selezionare l'opzione Run as.

    • Seleziona JUnit test.

  • Osserverai le seguenti cose quando esegui questo file di classe.

    • Entrambi gli scenari verranno eseguiti uno per uno.

  • Il rapporto sarà lì chiamato come cucumber.json (come previsto nella classe runner).

  • Aperto cucumber.json file con l'editor di testo.

  • Vedrai il rapporto menzionato nello screenshot seguente dopo aver posizionato interruzioni di riga -

Note - JSON è meno leggibile rispetto al formato di report HTML.

È molto probabile che il test non riesca a causa di motivi sconosciuti. Identificare la causa del guasto e correggerla è molto importante. Questo processo è noto comedebugging. Di seguito sono riportati alcuni suggerimenti e trucchi, che rendono il debug di Cucumber un po 'facile.

L'opzione di debug è disponibile con Eclipse. Posiziona il punto di interruzione. Fare clic sul file ed eseguire il debug utilizzando i seguenti passaggi:

Step 1 - Posiziona i punti di interruzione manuali nel file di definizione del passaggio di Ruby.

Esempio

require 'ruby-debug' 
Then /^the process should exit cleanly$/ do 
breakpoint 
assert @exited_cleanly, "Process did not exit cleanly: #{@stdout}" 
end

Step 2 - Possiamo anche definire una fase di debug separata come la seguente nel file di definizione della fase.

Then /^I debug$/ do 
breakpoint 
0 
end

Step 3 - Webratè lo strumento predefinito per testare i cetrioli con Rails. Ti consente di fare cose come fare clic su link, digitare e inviare moduli e così via.

Ci saranno momenti in cui provi a fare clic su qualcosa, ad esempio, e non è presente. Otterrai una grande quantità di HTML restituito e capire cosa significa esattamente può essere un vero ostacolo.

save_and_open_page

Webrat fornisce un metodo save_and_open_page che cattura l'HTML corrente, lo salva e quindi lo aprirà in un browser per te. Estremamente utile.

When /^I follow "(.*)"$/ do |link| 
save_and_open_page 
click_link(link) 
end

Per eseguire il test Cucumber con Java, di seguito sono riportati i passaggi.

Step 1 - Installa Java -

  • Scarica jdk e jre da

    http://www.oracle.com/technetwork/java/javase/downloads/index.html

  • Accetta il contratto di licenza.

  • Installa JDK e JRE.

  • Imposta la variabile d'ambiente come mostrato nell'immagine seguente.

Step 2 - Installa Eclipse IDE -

  • Assicurati che JAVA sia installato sulla tua macchina.

  • Scarica Eclipse da https://eclipse.org/downloads/

  • Unzip ed Eclipse installato.

Step 3 - Installa Maven -

  • Scarica Maven -https://maven.apache.org/download.cgi

  • Decomprimere il file e ricordare la posizione.

  • Crea la variabile d'ambiente MAVEN_HOME come mostrato nell'immagine seguente.

  • Modifica la variabile Path e includi Maven.

  • Scarica il plugin MAVEN da Eclipse

    • Apri Eclipse.

    • Aiuto → Eclipse Marketplace → Cerca maven → Maven Integration for Eclipse → INSTALL

Step 4 - Configura Cetriolo con Maven.

  • Crea un progetto Maven.

    • Vai a File → Nuovo → Altri → Maven → Progetto Maven → Avanti.

    • Fornisci l'ID del gruppo (l'ID del gruppo identificherà il tuo progetto in modo univoco in tutti i progetti).

    • Fornisci ID artefatto (l'ID artefatto è il nome del file jar senza versione. Puoi scegliere qualsiasi nome in minuscolo).

    • Fare clic su Fine.

Step 5 - Apri pom.xml -

  • Vai all'esploratore di pacchetti sul lato sinistro di Eclipse.

  • Espandi il progetto CucumberTest.

  • Individua il file pom.xml.

  • Fare clic con il tasto destro e selezionare l'opzione Apri con "Editor di testo".

Step 6 - Aggiungi dipendenza per Selenium - Questo indicherà Maven, quali file jar Selenium devono essere scaricati dal repository centrale al repository locale.

  • Apri pom.xml è in modalità di modifica, crea il tag delle dipendenze (<dependencies> </dependencies>), all'interno del tag del progetto.

  • All'interno del tag delle dipendenze, crea il tag delle dipendenze. (<dependency> </dependency>)

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

Step 7 - Aggiungi dipendenza per Cucumber-Java: indica Maven, quali file Cucumber devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 8 - Aggiungi dipendenza per Cucumber-JUnit - Questo indicherà Maven, quali file Cucumber JUnit devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

Step 9- Aggiungi dipendenza per JUnit: indica Maven, quali file JUnit devono essere scaricati dal repository centrale al repository locale.

  • Crea un altro tag di dipendenza.

  • Fornisci le seguenti informazioni all'interno del tag di dipendenza.

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

Step 10 - Verifica i binari.

  • Una volta modificato con successo pom.xml, salvalo.

  • Vai a Progetto → Pulisci - Ci vorranno alcuni minuti.

  • Sarai in grado di vedere un repository Maven.

Step 11 - Crea un pacchetto in src/test/java denominato come cucumberJava.

Step 12 - Crea file di caratteristiche

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file un nome come cucumberJava.feature.

  • Scrivi il seguente testo all'interno del file e salvalo.

    Feature: CetrioloJava

    Scenario: Esiste la funzionalità di accesso

    Dato che ho aperto il browser

    Quando apro il sito web di Facebook

    Quindi il pulsante di accesso dovrebbe uscire

Step 13 - Crea file di definizione della fase -

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al nome del file un nome come annotation.java.

  • Scrivi il seguente testo all'interno del file e salvalo.

package CucumberJava; 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

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

public class cucumberJava { 
   WebDriver driver = null; 
   @Given("^I have open the browser$") public void openBrowser() { driver = new FirefoxDriver(); } @When("^I open Facebook website$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
   @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail"); 
      } 
      driver.close(); 
   } 
}

Step 14 - Crea un file di classe corridore.

  • Seleziona e fai clic con il pulsante destro del mouse sulla struttura del pacchetto.

  • Fare clic su "Nuovo" file.

  • Assegna al file il nome runTest.java.

  • Scrivi il seguente testo all'interno del file e salvalo.

package cucumberJava; 
import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 
public class runTest { 
}

Step 15 - Esegui il test utilizzando l'opzione -

  • Seleziona il file runTest.java da Esplora pacchetti.

  • Fare clic con il tasto destro e selezionare l'opzione, Run as.

  • Seleziona JUnit test.

Osserverai le seguenti cose durante l'esecuzione:

  • Si aprirà un'istanza del browser Web Firefox.

  • Si aprirà la pagina di accesso di Facebook sul browser.

  • Rileverà il pulsante di accesso.

  • Il browser si chiuderà.

  • Nella finestra JUnit, vedrai uno scenario con un segno di spunta verde, che indica il successo dell'esecuzione del test.

Il linguaggio Ruby ha i seguenti vantaggi:

  • È facile da capire.

  • È un linguaggio orientato agli oggetti.

  • È una potente libreria di classi.

  • Ha un enorme supporto online.

Di seguito è riportato il processo graduale di come Cucumber funziona con Ruby.

Step 1 - Installa Ruby.

  • Vai alla pagina di download di RubyInstaller.

  • Scarica la versione più adatta al tuo sistema operativo (es. 32 o 64 bit).

  • Esegui l'exe scaricato.

  • Durante l'installazione, seleziona l'opzione "Aggiungi Ruby ..." e "Associa ...", come mostrato nell'immagine seguente.

Step 2 - Scarica ed estrai Dev kit.

  • Vai alla pagina di download di RubyInstaller.

  • Scarica la versione Devkit più adatta al tuo sistema operativo (es. 32 o 64 bit).

  • Estrai il devkit nella cartella c: \ Ruby \ Devkit.

  • Apri il prompt dei comandi.

  • All'interno di Ruby devkit, esegui il seguente comando.

C:\Ruby\devkit> ruby dk.rb init 
C:\Ruby\devkit> ruby dk.rb install

Step 3 - Installa il cetriolo e altre gemme di rubino.

  • Per installare Cucumber, prima aggiorna l'attuale configurazione delle gemme

C:\Users\Admin> gem update –system

  • Successivamente, installa le gemme necessarie per il test web di Cucumber.

C:\Users\Admin> gem install --no-ri --no-rdoc rspec 
C:\Users\Admin> gem install --no-ri --no-rdoc win32console 
C:\Users\Admin> gem install --no-ri --no-rdoc watir-webdriver 
C:\Users\Admin> gem install --no-ri --no-rdoc cucumber

  • Esegui il cetriolo

C:\Users\Admin\Documents>cucumber –init 
C:\Users\Admin\Documents>cucumber

Step 4 - Installa IDE - KOMODO.

  • Vai alla pagina http://www.activestate.com/komodo-ide/downloads

  • Scarica il programma di installazione di prova gratuito.

  • Fare doppio clic sull'exe scaricato.

  • Segui la procedura di installazione.

  • Termina l'installazione e apri l'IDE.

Step 5 - Installa Watir - Vai al prompt dei comandi ed esegui il seguente comando, "gem install watir"

Step 6 - Installa rspec - Vai al prompt dei comandi ed esegui il seguente comando, "gem install rspec"

Step 7 - Crea file di caratteristiche.

  • Apri l'editor KOMODO.

  • Fare clic sull'icona del nuovo file.

  • Scrivi il testo seguente.

    Feature: Gli utenti devono essere in grado di cercare contenuti utilizzando Google.

    Scenario: Cerca un termine.

    Dato che sono entrato "watir" nella query.

    Quando clicco "search"

    Allora dovrei vedere alcuni risultati

  • Clic save icona.

  • Assegna il nome a CucumberRuby.

  • Scegli una cartella qualsiasi, ad esempio: “e:\WithRuby”

  • Salva il file.

Step 8 - Crea file di definizione della fase.

  • Apri l'editor KOMODO.

  • Fare clic sull'icona del file "Nuovo".

  • Scrivi il codice seguente.

require "watir-webdriver" 
require "rspec/expectations" 

Given /^I have entered "([^"]*)" into the query$/ do |term| 
@browser ||= Watir::Browser.new :firefox 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set term 
end 

When /^I click "([^"]*)"$/ do |button_name| @browser.button.click end Then /^I should see some results$/ do 
@browser.div(:id => "resultStats").wait_until_present 
@browser.div(:id => "resultStats").should exist 
@browser.close 
End

  • Fare clic sull'icona Salva.

  • Dai il nome come CucumberRuby.rb

  • Scegli una cartella qualsiasi, ad esempio: “e:\WithRuby”

  • Salva il file.

Step 9 - Crea il file di prova.

  • Apri l'editor KOMODO.

  • Fare clic sull'icona del file "Nuovo".

  • Scrivi il codice seguente.

require "rubygems" 
require "test/unit" 
require "watir-webdriver" 

class GoogleSearch < Test::Unit::TestCase 
def setup 
@browser ||= Watir::Browser.new :firefox 
end 

def teardown 
@browser.close 
end 

def test_search 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set "watir" 
@browser.button.click 
@browser.div(:id => "resultStats").wait_until_present assert 
@browser.title == "watir - Google Search" 
end 
end

  • Fare clic sull'icona Salva.

  • Assegna al file il nome test.rb e scegli una cartella qualsiasi, ad esempio: "e: \ WithRuby"

  • Salva il file.

Step 10 - Esegui il file delle caratteristiche.

  • Vai al prompt dei comandi.

  • Vai alla directory e:\WithRuby

  • Esegui il seguente comando.

e:\With Ruby>ruby test.rb

Osserverai le seguenti cose durante l'esecuzione:

  • Si aprirà un'istanza del browser web.

  • La pagina web di Google.com verrà caricata.

  • Cerca nel testo watir sarà inserito.

  • Il pulsante di ricerca verrà posizionato.

  • I risultati della ricerca verranno visualizzati sulla pagina web.

  • L'istanza del browser verrà chiusa.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved