Esegui casi di test in parallelo e genera rapporti utilizzando lo strumento Karate

run test cases parallel generate reports using karate tool

Questo tutorial spiega come eseguire alcune operazioni di base sull'API, eseguire casi di test in parallelo e generare report con Karate Framework:

Abbiamo imparato come creare uno script di test di base nel nostro tutorial precedente, ora possiamo andare avanti con l'apprendimento di alcune operazioni di base che possono essere eseguite mentre si lavora con l'API e il Karate Framework. Esistono molte di queste operazioni e ne discuteremo alcune di uso comune in questo tutorial.

Approfondiremo anche il processo di esecuzione di casi di test in parallelo seguendo un approccio graduale. Discuteremo anche del rapporto corrente che viene generato automaticamente e lo confronteremo con il rapporto Cucumber che possiamo generare integrando un plugin.

Cosa imparerai:

• Lavorare con API e Karate Testing Tool
  • Esecuzione di varie operazioni
  • Esecuzione di operazioni postali
• Esegui casi di test in parallelo
• Integra il plugin Cucumber per i rapporti
• Conclusione
  • Lettura consigliata

Lavorare con API e Karate Testing Tool

Come discusso nel tutorial precedente, in .feature file che avevamo creato, potremmo usare diverse parole chiave per eseguire diverse operazioni sull'API. Karatè framework ci fornisce diverse parole chiave che possono essere utilizzate per eseguire varie azioni.

=> Lettura consigliata: Test API con Karate Framework

Esecuzione di varie operazioni

# 1) Stampa la risposta nella console

Stampa è una parola chiave fornita da Karate Framework per stampare il risultato nella console o nel file. Uno degli usi più comuni è stampare la risposta dell'API. Questo può essere molto utile per l'utente.

Possiamo farlo utilizzando le seguenti righe di codice:

Le righe di codice precedenti daranno il seguente output:

È così che possiamo stampare la risposta dell'API nella console a scopo di lettura, che può essere utilizzata al momento del debug.

# 2) Dichiarazione delle variabili

Possiamo dichiarare le variabili usando la parola chiave def nel framework Karate e quindi utilizzare le variabili dichiarate nel codice ove necessario.

Nell'esempio seguente, abbiamo aggiunto qualche altra riga di codice al file userDetails.feature file per aiutare a dichiarare le variabili nello script.

# 3) Affermare la risposta effettiva alla risposta attesa

Karate Framework aiuta a eseguire le operazioni relative alle asserzioni utilizzando l'estensione incontro parola chiave. Il incontro è intelligente perché lo spazio bianco non ha importanza e l'ordine delle chiavi non è importante.

Per usare parola chiave con corrispondenza, dobbiamo utilizzare il doppio segno di uguale '==' che rappresenta un confronto.

Ora proveremo ad approfondire alcuni usi di incontro parola chiave.

a) Quando l'intera risposta attesa è menzionata nel file .feature stesso.

In certi momenti abbiamo alcuni dati che vorremmo convalidare immediatamente nel file stesso. Di solito, tali tipi di dati vengono menzionati durante il debug del codice.

Potremmo fare lo stesso nel file .feature stesso come mostrato di seguito:

Se invii una richiesta all'URL 'Https://reqres.in/api/users/2' nel browser, quindi otterrai la seguente risposta:

Stiamo cercando di convalidare la risposta di cui sopra utilizzando il file * .feature.

Abbiamo usato il incontro parola chiave fornita dal Karate Framework, che aiuta a eseguire diversi tipi di Asserzioni nella risposta API.

Nota : Avremmo bisogno di trasformare la risposta API in una riga per eseguire il passaggio precedente. Puoi usare uno qualsiasi degli strumenti disponibili in linea.

b) Quando l'output previsto viene mantenuto in un file JSON esterno.

Nell'esempio sopra, abbiamo discusso uno scenario in cui avevamo dati limitati e la stessa risposta che era facile da gestire, ma negli scenari reali avremo serie gigantesche di risposte JSON che potremmo dover valutare.

Quindi, in quei casi, è meglio mantenere la risposta nel file esterno e poi verificare lo stesso.

Nell'esempio seguente discuteremo ulteriormente lo stesso:

• È necessario creare un file ExpectedOutput.json file nella nostra cartella Progetto come mostrato nell'immagine sottostante.

Crea una nuova risorsa pacchetto -> Crea un nuovo file ExpectedOutput.json

Memorizza la risposta JSON in questo file e salvalo.

Dovresti scrivere il seguente codice nel tuo file userDetails.feature file:

Nell'esempio sopra, stiamo prima leggendo il file ExpectedOutput.json e memorizzandone la risposta nella variabile Risultato atteso usando il seguenti righe di codice:

Quindi, stiamo inserendo l'asserzione utilizzando le seguenti righe di codice, dove stiamo facendo corrispondere il file Risposta effettiva con il Risultato atteso risposta con ' == ' operatore.

c) Corrispondenza / verifica di determinati valori dalla risposta

Finora abbiamo verificato l'intera risposta dell'API, ma ogni volta non vorresti verificare l'intera risposta. A volte, vorresti valutare solo una parte della risposta. Di solito, facciamo lo stesso quando usiamo gli altri strumenti per il test delle API o durante la creazione di un framework.

Per capirlo ulteriormente, prendiamo come esempio la seguente risposta JSON:

Se vogliamo verificare che il parametro azienda dovrebbe avere il valore come StatusCode settimanale, quindi dovremo creare un percorso JSON. Questo può essere fatto attraversando il file JSON e utilizzando il '.' (Operatore punto)

Il percorso JSON per la risposta precedente sarà:

ad.company == 'StatusCode Weekly'

Di seguito è riportato lo snippet di codice che ci aiuterà a valutare i valori per il particolare parametro. Questo codice appartiene a .feature file.

Di seguito è riportata la riga di codice, che esegue le asserzioni parametriche.

Utilizzando il percorso JSON, stiamo valutando i valori per i parametri.

Esecuzione di operazioni postali

Finora abbiamo coperto gli scenari di base del test di un'API quando il metodo era ' OTTENERE'. Ma quando lavoriamo nell'ambiente reale, dobbiamo inviare molte informazioni al server, quindi in tal caso, utilizziamo il ' INVIARE' metodo .

Questa sezione ti darà un'idea di come lavorare con la richiesta POST di base.

Facciamo alcune brevi idee sui parametri di cui abbiamo bisogno per inviare la richiesta POST.

# 1) Creazione di una richiesta POST, quando il corpo JSON è menzionato nel file * .feature

• Creare una funzione userDetailsPost.feature utilizzando i passaggi simili menzionati nel tutorial precedente.
• Scrivi le seguenti righe di codice:

Poiché si tratta di una richiesta POST, che deve sempre essere accompagnata da un corpo che deve essere inviato al server per una determinata risposta, abbiamo menzionato che sotto il seguente componente:

richiesta: Richiede un corpo JSON come richiesta richiesta con il metodo POST.

# 2) Creazione di una richiesta POST, quando il corpo JSON è menzionato in un file esterno

Di solito, avremo un enorme corpo di richieste, che sarebbe difficile menzionare nel file * .feature file. Quindi è meglio tenerlo nel file esterno.

• È necessario creare un file PostBody.json nella nostra cartella Progetto come mostrato di seguito. Crea una nuova risorsa pacchetto -> Crea un nuovo file PostBody.json e archivia il corpo JSON in questo file e salvalo.

Nota: Abbiamo menzionato il metodo Body of the POST nel file JSON sopra.

• Dovresti scrivere il seguente codice nel tuo userDetailsPost .feature file:

Stiamo leggendo il corpo JSON da PostBody.json utilizzando le seguenti righe di codice:

Nota: Tutti i userDeatils.feature i file che abbiamo creato fino ad ora richiederanno il file basic TestRunner.java file per eseguirli, che abbiamo creato nel nostro tutorial Basic Test Script come mostrato di seguito:

Esegui casi di test in parallelo

Ora, poiché abbiamo appreso i passaggi per creare uno script di test di base ed eseguito alcune operazioni di base sull'API, è ora di iniziare a lavorare nell'ambiente reale.

Di solito, dobbiamo eseguire i test case in parallelo, per rendere l'esecuzione più veloce. Fondamentalmente, l'idea è di ottenere più output in meno tempo.

Questa è una caratteristica fondamentale del framework e non dipende da JUnit, Maven o Grade. Ci permette di:

• Scegli facilmente le funzionalità e i tag per eseguire le suite di test in modo semplice.
• Visualizza i risultati paralleli nella cartella del plugin infallibile.
• Possiamo persino integrare i rapporti JSON di Cucumber per una migliore interfaccia utente (che sarà discussa a breve).

In Karate Framework, non è necessario eseguire molti passaggi per avviare l'esecuzione parallela dei nostri casi di test. Dobbiamo solo eseguire i seguenti passaggi:

1) Ora dobbiamo cambiare il file TestRunner.java file che abbiamo utilizzato fino ad ora. Il codice per l'esecuzione parallela deve essere scritto nel file sopra.

Tieni presente la riga seguente, durante l'esecuzione del codice in Parallelo:

quali sono i migliori downloader di musica

** Non possiamo usare l'annotazione @RunWith (Karate.class) quando stiamo cercando di lavorare in un ambiente parallelo.

Apri l'originale TestRunner.java file e usa il seguente codice ora:

** Il codice seguente sarà applicabile per JUnit 4 Maven dipendenza

Nello snippet di codice sopra, abbiamo incluso la riga di codice sottostante-

Risultati risultati = Runner.parallel (getClass (), 5);

Questa riga indica di eseguire l'istanza dei casi di test in parallelo recuperando dinamicamente le classi in Runtime.

2) Crea un duplicato userDetails.feature file come indicato di seguito sotto il src / test / java cartella.

Ora siamo tutti pronti per l'esecuzione parallela con Due . Caratteristiche file.

3) Vai a TestRunner.java file creato nel passaggio precedente e eseguilo come JUnit Test. Con questo, eseguiremo i nostri casi di test in formato parallelo.

Per una facile leggibilità, alcune informazioni sono presentate da Karate Framework nella console, ogni volta che l'esecuzione del Test è completata.

Il risultato è simile al seguente:

Con l'esecuzione parallela, tutte le funzionalità verranno eseguite in parallelo e anche gli scenari verranno eseguiti in un formato parallelo.

Seguendo i passaggi precedenti, sarai in grado di avviare l'esecuzione parallela di base del test API, utilizzando il Karate Framework.

** Puoi studiare i test paralleli attraversando i vari filtri nella pagina Esecuzione parallela

Integra il plugin Cucumber per i rapporti

Poiché stiamo usando il Corridore di JUnit per l'esecuzione di diversi scenari che sono stati menzionati nei diversi * .feature file, crea automaticamente un rapporto per ciascuno dei file di funzionalità archiviati nel percorso target / report infallibili.

Genera un file Rapporto formattato interfaccia utente di base per presentare i casi di test che sono stati eseguiti.

Tuttavia, i rapporti che vengono generati non sono molto piacevoli in termini di interfaccia utente e per condividere i rapporti con gli stakeholder, abbiamo bisogno di qualcosa che sia più facile da usare e facilmente comprensibile.

Per ottenere un tale formato di reportistica, Karate Framework offre un'opzione per l'integrazione Plugin per la segnalazione dei cetrioli che ci aiuterà a generare un report in formato grafico, che sarà più presentabile.

Di seguito sono riportati i passaggi per integrare lo stesso:

# 1) Aggiungi quanto segue Segnalazione di cetrioli dipendenza dal tuo POM.xml

#Due) Modifica il file TestRunner.java quando è presente un solo file * .feature file nel progetto.

Dobbiamo aggiornare il nostro file TestRunner.java, con il seguente metodo generateReport () per il plugin Cucumber.

Nel codice sopra menzionato, stiamo eseguendo le seguenti azioni:

• Creazione di una nuova istanza di File
• Fornire il percorso per archiviare i file nella cartella di destinazione
• Creazione di un oggetto ReportBuilder che creerà un nuovo report Cucumber

Nota : Il codice di cui sopra funziona bene quando abbiamo single *. caratteristica file nel nostro progetto.

# 3) Modifica il file TestRunner.java quando sono presenti multiple * .feature file nel progetto.

Avremmo bisogno di aggiungere una riga di codice (evidenziata in grassetto sotto) per garantire che l'esecuzione parallela sia curata, mentre gli scenari vengono eseguiti per la generazione del report.

Dopo aver eseguito i passaggi sopra menzionati, saremo in grado di creare con successo un report grafico dell'interfaccia utente ben rappresentato utilizzando il Cetriolo - segnalazione collegare.

Possiamo trovare il report al seguente percorso nel nostro progetto come mostrato nell'immagine qui sotto:

Il seguente report è stato generato per il nostro progetto, per tutte le operazioni che abbiamo eseguito fino ad ora in questo tutorial di Karate Framework:

Conclusione

Per riassumere, in questo tutorial abbiamo discusso le operazioni di base che sono utili su base giornaliera mentre si lavora con il Quadro di karate e come eseguire più file * .feature in parallelo. Abbiamo anche imparato a creare un report grafico per gli utenti che utilizzano il Segnalazione di cetrioli collegare.

Per prima cosa, abbiamo discusso le operazioni di base che possono essere eseguite sull'API. Abbiamo discusso di come possiamo inviare il corpo / richiesta POST al server, menzionando il corpo nel file * .feature stesso (che di solito non è una pratica consigliata) o utilizzando un file esterno (una pratica consigliata, al fine di mantenere un codice pulito).

In secondo luogo, dopo aver seguito alcuni passaggi di base, è possibile eseguire correttamente il risultato del test per due * .feature file che sono stati eseguiti in parallelo, semplicemente aggiungendo poche righe di codice nel file TestRunner.java file che abilita l'avvio dell'esecuzione parallela.

Inoltre, abbiamo imparato come trasformare il rapporto di prova JUnit nativo in un rapporto Cucumber integrando il file Segnalazione dei cetrioli collegare. Il plug-in ci consente di generare report che hanno un'interfaccia utente migliore, sono molto più comprensibili per l'utente e quindi forniscono una migliore esperienza utente per le parti interessate con cui vengono condivisi questi report.

A questo punto, dovresti essere in grado di eseguire alcune operazioni di base, eseguire i casi di test parallelamente e generare un rapporto di facile lettura per gli utenti.

<