specflow tutorial ultimate guide bdd tool
Una guida completa al tutorial di Specflow e Behavior Driven Development (BDD):
Cos'è Specflow?
Specflow è un framework di test che supporta le pratiche BDD nel framework .NET. È un framework open source ospitato su GitHub. Aiuta nell'utilizzo di ATDD (Acceptance test driver development) per applicazioni .NET. Con questo, possiamo definire uno scenario in un inglese semplice definito dal linguaggio Gherkin che è chiaramente comprensibile da chiunque.
Ci sono vari strumenti per scrivere test nell'approccio BDD come Cucumber / JBehave per Java, Lettuce per Python, Jasmine per Javascript, Specflow per .NET.
BDD (Behaviour Driven Development) è un insieme di pratiche o un approccio simile a TDD (Test Driven Development), che mira a colmare il divario di comunicazione tra diversi stakeholder come Product, Developers e Testers.
L'obiettivo finale dell'approccio BDD è creare requisiti aziendali che possano essere compresi dall'intero team in modo da evitare incomprensioni e aiutare a fornire la funzionalità sviluppata nel modo più accettabile.
Una serie completa di tutorial su Specflow:
Leggi il file Serie completa di formazione Specflow per una migliore comprensione del concetto.
Tutorial n. 1: Introduzione a Specflow BDD Tool (Questo tutorial)
Tutorial n. 2: Specflow e selenio Esempio
Tutorial n. 3: Binding Specflow e concetti avanzati
Tutorial n. 4: Trasformazioni degli argomenti dei passaggi e tabelle Specflow
Tutorial n. 5: Documentazione di Specflow Living con sottaceti
Tutorial # 6: Generatore di rapporti Specflow
Tutorial # 7: Domande di intervista Specflow
Una breve panoramica dei tutorial nella serie Specflow:
Tutorial # | Descrizione |
---|---|
7 | Domande di intervista Specflow In questo tutorial è incluso un elenco delle più popolari domande e risposte dell'intervista di Specflow con esempi per consentirti di risolvere qualsiasi intervista di Specflow con successo al primo tentativo. |
uno | Introduzione a Specflow BDD Tool (Questo tutorial) Questo tutorial introduttivo ti spiegherà in dettaglio tutto su Specflow. Specflow è un framework di test che supporta le pratiche BDD nel framework .NET. È un framework open source ospitato su GitHub. Aiuta nell'utilizzo di ATDD (Acceptance test driver development) per applicazioni .NET. |
Due | Specflow e selenio Esempio Questo tutorial si concentrerà sull'integrazione di Selenium con il framework Specflow attraverso un semplice scenario di test di ricerca video sull'applicazione Youtube. Controllerai anche come condividere i dati tra diverse associazioni tramite campi di classi private. |
3 | Specflow e selenio Esempio Questo tutorial si concentrerà sull'integrazione del selenio con il framework Specflow attraverso un semplice scenario di test di ricerca video sull'applicazione Youtube. Controllerai anche come condividere i dati tra diverse associazioni tramite campi di classi private. |
4 | Trasformazioni degli argomenti dei passaggi e tabelle Specflow Questo tutorial informativo su Specflow spiegherà in dettaglio le trasformazioni degli argomenti dei passaggi che consentono conversioni di tipo personalizzate per gli argomenti Specflow per evitare il codice boilerplate e le tabelle Specflow sono utili quando è necessario passare molti campi / dati in un unico passaggio in una tabella di facile utilizzo formato. |
5 | Documentazione di Specflow Living con sottaceti Da questo tutorial su Specflow imparerai come generare una buona documentazione vivente attraverso un framework open source chiamato pickles utilizzando i tuoi file Specflow esistenti. |
6 | Generatore di rapporti Specflow In questo tutorial di Specflow Reporting, imparerai i modi per eseguire i test delle funzionalità Specflow insieme alla generazione di report HTML tramite l'eseguibile Specflow. |
Cominciamo con il primo tutorial di questa serie.
Cosa imparerai:
Introduzione a Specflow BDD Tool
Guarda il video tutorial:
Ecco un video tutorial su Specflow e Behavior Driven Development:
Caratteristiche di BDD
Le caratteristiche principali di BDD sono riassunte di seguito:
# 1) Cerca di definire il comportamento del sistema o della funzionalità in fase di sviluppo tramite un esempio o uno scenario. Ad esempio, se stai creando una semplice applicazione calcolatrice, i diversi comportamenti includono addizione, moltiplicazione, divisione, ecc.
Quindi, attraverso BDD, tutti gli stakeholder si incontreranno prima per decidere il comportamento dell'applicazione come Addition e avranno gli scenari come mostrato di seguito.
Given, I have 2 numbers 30 and 50 as input When I add these 2 numbers Then I should get an output of 80
Se vedi la rappresentazione di cui sopra, è uno scenario in un inglese semplice che è chiaramente comprensibile da chiunque e rende chiari i requisiti per una funzionalità (secondo i criteri di accettazione). Quindi il primo passo è articolare questi requisiti.
#Due) Ora, con una serie di questi scenari, il QA scrive test su questi e questo inizialmente fallirà poiché la funzionalità non è ancora sviluppata.
# 3) Ora, lo sviluppatore scrive un codice di funzionalità ed esegue nuovamente questi test.
# 4) I test possono passare o fallire. Se falliscono - refactoring del codice e ripetere il processo
# 5) Una volta completato il refactoring del codice, tutti gli scenari / test dovrebbero passare.
Quindi, in sostanza, BDD utilizza l'approccio TDD e lo porta al livello successivo avendo alcune specifiche comuni facilmente comprensibili sotto forma di scenari. Rappresentano anche la documentazione delle funzionalità in sé.
Ci sono vari strumenti per scrivere test nell'approccio BDD come Cucumber / JBehave per Java, Lettuce per Pitone , Jasmine per Javascript, Specflow per .NET.
qual è il caso d'uso nel test del software
In questo tutorial, ci concentreremo su Specflow.
Leggi anche => I migliori strumenti BDD e framework di test
Le parole chiave: date, quando e poi
Dal mondo dei test di unità, la maggior parte di noi ha familiarità con 3 A, ovvero Arrange, Act e Assert. Ora, dato, quando e poi sono i sostituti per questi nel mondo BDD.
Prendiamo un Esempio per capire ciascuno di questi. Supponiamo che tu stia elencando uno scenario per la convalida di un prodotto che viene aggiunto al carrello di un'applicazione di e-commerce che richiede l'accesso come prerequisito.
La specifica può essere scritta come segue:
Scenario: Products get added to cart for a logged in customer Given I have a logged-in customer on my application When I add 2 quantity of a product to my shopping cart Then the shopping cart should get updated and have the right product and quantity
Dato :Viene utilizzato per descrivere una serie di condizioni preliminari per lo scenario da definire. Ad esempio, nell'esempio, il prerequisito dello scenario è un cliente che ha effettuato l'accesso. Quindi confrontando con il Organizzare analogia in uno unit test, l'implementazione del passaggio dovrà garantire che vi sia un cliente connesso.
quando :Viene utilizzato per descrivere un'azione o una fase di esecuzione. Nell'esempio, mostra che il cliente sta cercando di aggiungere un prodotto al suo carrello. Quindi l'implementazione del passaggio per questo passaggio si occuperà del codice di simulazione per aggiungere un prodotto al carrello. Questo può essere paragonato al atto passaggio negli unit test.
Poi :Viene utilizzato per descrivere il risultato dello scenario ed essenzialmente dove devono essere inserite le convalide. Può essere paragonato al Asserire passo nel mondo degli unit testing. Nell'esempio qui, l'implementazione del passaggio asserirà se il prodotto è stato effettivamente aggiunto e la quantità è la stessa scelta dal cliente.
Il file delle caratteristiche
Il file delle funzionalità è essenzialmente un raggruppamento di più scenari per l'applicazione in fase di sviluppo o test. Può anche essere semplicemente pensato come diversi moduli dell'applicazione da cui l'applicazione può essere separata logicamente.
Per esempio:
Un'applicazione di e-commerce può decidere di avere diversi file di funzionalità di alto livello come:
- Funzionalità di accesso / disconnessione
- Carrello della spesa
- Pagamento ecc.
Cos'è Specflow?
Specflow è uno strumento che supporta le pratiche BDD nel framework .NET. È un framework open source ospitato su GitHub. Aiuta nell'utilizzo di ATDD (Acceptance test driver development) per applicazioni .NET.
Il vincolo dei requisiti aziendali per un'applicazione utilizzando il paradigma Specifica per esempio aiuta a comprendere meglio il comportamento dell'applicazione da parte di tutte le parti interessate e quindi si traduce nella spedizione del prodotto con le aspettative corrette.
Fa uso di Cetriolino sintassi per la creazione di funzionalità e scenari. Ha anche una discussione / sviluppatore attivo Forum .
Specflow - Guida introduttiva
In questa sezione, esploreremo l'installazione di specflow nell'IDE di Visual Studio e la creazione di file di funzionalità per una semplice applicazione String Utility.
Informazioni sull'applicazione di esempio
Illustreremo diverse funzionalità del framework Specflow in questo tutorial utilizzando un'applicazione calcolatrice che ha funzioni / interfacce per fornire diverse operazioni come:
- Aggiunta di 2 numeri.
- Sottraendo 2 numeri.
- Dividere e moltiplicare 2 numeri.
- Trovare la radice quadrata del numero dato.
Specflow Guida d'installazione
L'installazione di Specflow è un processo in 2 fasi
# 1) Installazione dei plug-in richiesti nell'IDE di Visual Studio.
- Per installare il plug-in specflow vai su Strumenti -> Estensione e aggiornamenti.
- Ora fai clic su 'Online' nel pannello di sinistra.
- Ora cerca specflow nel pannello di destra.
- Dai risultati della ricerca selezionare 'Specflow per Visual Studio 2017'.
#Due) Impostazione del progetto con file di funzionalità e definizioni di passaggi.
- Crea un nuovo progetto semplice in Visual Studio. Possiamo creare qualsiasi tipo di progetto come libreria di classi / applicazione console / progetto di unit test ecc. Per semplicità, stiamo prendendo in considerazione un progetto di libreria di classi. Assegna al progetto il nome 'SpecflowBasic'.
- Per eseguire gli scenari Specflow che creeremo, abbiamo bisogno di un test runner. Specflow fornisce un corridore pronto all'uso chiamato Specflow + Runner (che è una versione a pagamento e la versione gratuita introduce un ritardo).
(Sono disponibili anche altri runner per NUnit e MsTest che vedremo negli ulteriori articoli di questa serie).
Per installare Specflow + Runner - Passare a Strumenti -> Gestione pacchetti NuGet -> Console di Gestione pacchetti.
Una volta aperta la console di Gestione pacchetti, esegui il comando.
Install-Package SpecRun.SpecFlow
- Inoltre, per affermare i valori, avremo bisogno dell'aiuto di un framework di test. NUnit può essere una delle opzioni e le altre includono MsTest, ecc. Per installare il framework NUnit nell'applicazione, aprire la console di Gestione pacchetti e digitare il comando.
Install-Package NUnit
# 3) Crea una nuova classe denominata 'CalculatorApplication' che diventerà la nostra applicazione in prova. Questa è una classe semplice con funzioni per eseguire addizioni / moltiplicazioni / divisioni / radici quadrate ecc. Per l'input fornito. Ecco come appare la classe CalculatorApplication.
# 4) Una volta installato il pacchetto, creare 2 cartelle nel progetto e denominarle come Funzionalità e Definizioni dei passaggi per memorizzare rispettivamente i file delle funzionalità e le associazioni dei passaggi. Discuteremo in dettaglio il motivo di questa organizzazione di cartelle per le definizioni di Feature & Step.
# 5) Ora nella cartella delle funzionalità, aggiungi un nuovo file di funzionalità e chiamalo come CalculatorFeature.
Vedrai che per impostazione predefinita il file di funzionalità ha una descrizione in Funzionalità e scenario.
Sostituiscilo con quello che testeremo.
Feature: CalculatorFeature In order to test my application As a developer I want to validate different operations of the application Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should be 90 Scenario: Substract two numbers Given I have provided 70 and 20 as the inputs When I press substract Then the result should be 50 Scenario: Multiply two numbers Given I have provided 70 and 20 as the inputs When I press multiply Then the result should be 1400 Scenario: Divide two numbers Given I have provided 70 and 20 as the inputs When I press divide Then the result should be 3.5 Scenario: SquareRoot of number Given I have provided 70 as input When I press squareroot Then the result should be 8.37
# 6) Generazione di definizioni dei passaggi: Specflow fornisce un modo automatizzato per generare collegamenti / implementazioni per i diversi passaggi negli scenari di file di funzionalità. Ciò può essere ottenuto facendo clic con il pulsante destro del mouse sul file delle caratteristiche e facendo clic su 'Genera definizioni dei passaggi'.
Questo passaggio non garantisce un'implementazione per tutti i passaggi, ma fa del suo meglio per raggruppare i passaggi comuni in scenari e riutilizzare il maggior numero di collegamenti possibile. Tuttavia, fa il lavoro di evitare il codice boilerplate ogni volta che è necessario implementare un passaggio dello scenario.
Dopo aver cliccato 'Genera definizioni dei passaggi' , Verrà visualizzata una finestra che elenca le implementazioni del passo identificate che il processore ha rilevato. Si può selezionare o deselezionare secondo i requisiti.
Nelle sezioni successive, esamineremo maggiori dettagli sul menu a discesa Stile mostrato nello screenshot sopra.
Per ora, teniamoli tutti selezionati con le impostazioni predefinite. Facendo clic sull'anteprima verrà visualizzata un'istantanea di come apparirà l'implementazione.
Dopo aver creato le definizioni dei passaggi, tuttavia, se ci sono alcuni passaggi non implementati, i file Feature hanno un modo visivo per identificare le applicazioni non implementate. Mostra quei passaggi in un colore diverso rendendo assolutamente semplice sapere che ci sono alcuni passaggi che non hanno ancora un'implementazione (o che hanno definizioni di passaggio ambigue).
Una schermata di esempio mostra quanto segue:
Nota: Le definizioni dei passaggi possono essere create anche manualmente: qualsiasi file .cs con l'attributo [Binding] è una classe di implementazione del passaggio e la sintassi di Gherkin cercherà di corrispondere all'implementazione del passaggio dello scenario specificato
Esecuzione
Poiché abbiamo già aggiunto Specflow + Runner nella sezione precedente, l'esecuzione degli Scenari è piuttosto semplice (poiché è una versione di valutazione di Specrun, introduce un ritardo variabile di 10-20 secondi prima che gli scenari vengano eseguiti., Questo ritardo non è presente per le varianti registrate. e altri gusti di Specrun runner come NUnit e MsTest).
Se tutti i passaggi hanno non è stato implementato e se ci sono ancora associazioni che hanno uno stato in sospeso. Quindi l'output verrà visualizzato come in sospeso.
Proviamo a eseguire questi test / scenari a questo punto quando non è presente alcuna implementazione per le associazioni e gli scenari sono tutti in sospeso.
Ora proviamo a implementare la classe CalculatorApplication con i metodi che vogliamo testare, ad esempio addizione, sottrazione, moltiplicazione, divisione e sqrt.
Di seguito è riportato un esempio di codice di come appare la nostra classe CalculatorApplication:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SpecflowBasic { class CalculatorApplication { public int add(int input1, int input2) { return input1 + input2; } public int subsctract(int input1, int input2) { return input1 - input2; } public int multiply(int input1, int input2) { return input1 * input2; } public double divide(double input1, double input2) { return input2 != 0 ? Math.Round(input1 / input2, 2) : 0; } public double squareRoot(int input1) { return input1 != 0 ? Math.Round(Math.Sqrt(input1), 2) : 0; } } }
Una volta che l'applicazione è pronta, proviamo a capire i modi per implementare le associazioni per ciascuno dei passaggi dello scenario.
Vediamo passo dopo passo l'approccio per implementarli:
- Innanzitutto, abbiamo bisogno di un'istanza dell'applicazione che deve essere testata. Per semplicità, possiamo creare un'istanza della AUT (classe Application Under Test) nei collegamenti dei passaggi e utilizzare l'istanza istanziata per chiamare effettivamente metodi / funzioni diversi in base al passaggio implementato.
- Per acquisire l'input e l'output, stiamo dichiarando che le variabili contengono questi valori per chiamare le funzioni sull'istanza dell'applicazione.
Vediamo l'implementazione end-to-end di tutte le associazioni coinvolte nella convalida della funzionalità Aggiungi (il resto degli scenari la sta semplicemente estendendo).
Lo scenario Aggiungi appare come mostrato di seguito:
Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should
Vediamo l'implementazione del passaggio per ciascuno di questi singoli passaggi. Per l'utilizzo di tutte le implementazioni del passaggio, stiamo dichiarando un'istanza dell'applicazione sotto test e le variabili per contenere le variabili di input e output come mostrato di seguito:
// instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output;
Vediamo l'implementazione dei passaggi dello scenario uno per uno.
Passo 1: Dato che ho fornito 70 e 20 come gli ingressi.
[Given(@'I have provided (.*) and (.*) as the inputs')] public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; }
Qui, abbiamo appena inizializzato le variabili di input con i valori passati dai passaggi dello scenario. p0 e p1 sono i valori passati dalla fase dello scenario e verranno inizializzati rispettivamente come 70 e 20.
Passo 2: Quando premo aggiungi.
[When(@'I press add')] public void WhenIPressAdd() { output = app.add(input1, input2); }
Questa è la fase di esecuzione (o azione) in cui il metodo effettivo viene chiamato nell'applicazione sotto test. Si noti che poiché le variabili di input input1 e input2 contengono già i valori passati nel passaggio1, l'istanza dell'applicazione può chiamare il metodo con queste variabili.
Passaggio 3: - Allora il risultato dovrebbe essere 90.
[Then(@'the result should be (.*)')] public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); }
Questo è il passaggio di convalida (o asserzione) in cui l'output viene generato dalla chiamata al metodo e l'istanza dell'applicazione viene convalidata rispetto all'output previsto.
Si noti che il file Asserire la parola chiave utilizzata proviene da NUnit Framework, che restituisce true o false a seconda della convalida / aspettativa impostata. Nel caso in cui restituisca false, l'implementazione del passaggio fallirà e il risultato dello scenario verrà visualizzato come non riuscito.
quale strato del modello osi funziona con i telai?
Inoltre, si noti che la variabile di output ottiene il valore dal passaggio precedente in cui è stato chiamato il metodo effettivo sull'istanza dell'applicazione.
Analogamente a quanto sopra, le implementazioni Step per il resto dei passaggi dello scenario vengono eseguite nello stesso modo, la differenza sta nel chiamare metodi diversi sull'istanza dell'applicazione e nell'asserire valori di output diversi.
Una volta implementati tutti i passaggi dello scenario, i test possono essere eseguiti.
L'output risultante apparirà come mostrato di seguito:
È inoltre possibile visualizzare l'output del singolo scenario che elenca anche l'output dei singoli passaggi:
Conclusione
Spero che questo articolo ti abbia fornito una comprensione di base di cosa sia BDD e quali sono gli strumenti che supportano BDD per .NET dove abbiamo trattato Specflow.
Abbiamo anche discusso dell'installazione e dell'esecuzione dei file delle funzionalità Specflow con l'aiuto di un'applicazione di esempio.
File di codice
I file di codice utilizzati nell'applicazione sono mostrati di seguito:
CalculatorFeatureSteps.cs
using System; using TechTalk.SpecFlow; using NUnit; using NUnit.Framework; namespace SpecflowBasic.StepDefinitions { [Binding] public class CalculatorFeatureSteps { // instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output; [Given(@'I have provided (.*) and (.*) as the inputs')] public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; } [Given(@'I have provided (.*) as input')] public void GivenIHaveProvidedAsInput(int p0) { input1 = p0; } [When(@'I press add')] public void WhenIPressAdd() { output = app.add(input1, input2); } [When(@'I press substract')] public void WhenIPressSubstract() { output = app.subsctract(input1, input2); } [When(@'I press multiply')] public void WhenIPressMultiply() { output = app.multiply(input1, input2); } [When(@'I press divide')] public void WhenIPressDivide() { output = app.divide(input1, input2); } [When(@'I press squareroot')] public void WhenIPressSquareroot() { output = app.squareRoot(input1); } [Then(@'the result should be (.*)')] public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); } } }
CalculatorApplication.cs
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SpecflowBasic { class CalculatorApplication { public int add(int input1, int input2) { return input1 + input2; } public int subsctract(int input1, int input2) { return input1 - input2; } public int multiply(int input1, int input2) { return input1 * input2; } public double divide(double input1, double input2) { return input2 != 0 ? Math.Round(input1 / input2, 2) : 0; } public double squareRoot(int input1) { return input1 != 0 ? Math.Round(Math.Sqrt(input1), 2) : 0; } } }
packages.config
Il nostro prossimo tutorial ti illustrerà l'esempio End to End dell'utilizzo di Specflow e Selenium Webdriver!
Lettura consigliata
- Tutorial approfonditi su Eclipse per principianti
- Tutorial TestLink: una guida per i profani allo strumento di gestione dei test TestLink (Tutorial # 1)
- Tutorial Bugzilla: Tutorial pratico dello strumento di gestione dei difetti
- TestComplete Tutorial: una guida completa per lo strumento di test della GUI per principianti
- SeeTest Automation Tutorial: A Mobile Test Automation Tool Guide
- Tutorial sulla rete di computer: la guida definitiva
- Tutorial sullo strumento di test dell'accessibilità di WAVE
- Framework BDD (Behaviour Driven Development): un tutorial completo