Questo tutorial è un'introduzione al test delle API utilizzando Karate Framework. Imparate la struttura di Karate Test Script e i passi per costruire il primo script di test:
API è un acronimo che sta per Application Programming Interface (Interfaccia di programmazione di un'applicazione). In termini semplici, possiamo definirla come un intermediario software che consente la comunicazione tra le applicazioni.
Abbiamo bisogno di test API perché:
- I risultati vengono pubblicati più velocemente, quindi non è più necessario aspettare per vedere se l'API funziona bene.
- Con una risposta più rapida, anche l'implementazione di queste API diventa più veloce, consentendo quindi tempi rapidi.
- Il rilevamento precoce dei guasti, anche prima della creazione dell'interfaccia utente dell'app, ci consente di ridurre i rischi e di correggere gli errori.
- Consegna su larga scala possibile in tempi più brevi.
Per poter lavorare al test delle API, sono disponibili sul mercato diversi strumenti come Postman, Mocha e Chai, che hanno dimostrato buoni risultati e un utilizzo efficace per il test delle API, ma che sono fortemente influenzati dal codice. Per poterli utilizzare, è necessario essere tecnicamente validi e avere familiarità con i linguaggi di programmazione.
Il Karate Framework risolve egregiamente questo problema degli strumenti software precedenti.
Cos'è il quadro del karate
Karate? Parliamo di Karate. È quello giapponese? Che ne pensate? Potrebbe essere che il grande Bruce Lee lo abbia sviluppato nel tempo libero.
Anche se vorremmo approfondire le interessanti radici del Karate, per il momento parliamo del Strumento per il karate che è stato sviluppato da Peter Thomas , uno dei grandi strumenti che vengono in soccorso dei tester API.
Il framework Karate segue lo stile Cucumber per la scrittura del programma, che segue l'approccio BDD. La sintassi è facile da capire anche per i non programmatori. Inoltre, questo framework è l'unico strumento di test delle API che ha combinato l'automazione delle API e il test delle prestazioni in un unico strumento autonomo.
Fornisce agli utenti la possibilità di eseguire i casi di test in parallelo e di eseguire i controlli JSON e XML.
Da queste informazioni si possono dedurre alcuni punti chiave per comprendere meglio lo strumento del Karate:
- Karate è un framework di testing BDD anziché TDD.
- Questa caratteristica è un fattore di svolta, in quanto consente un maggiore utilizzo e accesso da parte di molte persone, indipendentemente dal loro background tecnico o dalle loro capacità.
- Utilizza il file delle caratteristiche di Cucumber e il linguaggio Gherkins per scrivere il test, che è molto facile da capire.
Tutte queste caratteristiche lo rendono uno degli strumenti di automazione più favorevoli oggi disponibili.
Storia del quadro del karate
Creato da ' Peter Thomas scritto in Java e la maggior parte delle persone si aspettava che anche i suoi file fossero nello stesso linguaggio, ma fortunatamente non è così.
Il software di automazione è un'estensione di Cucumber e quindi eredita l'uso dei file Gherkins nel suo funzionamento. La grande differenza tra i due è che Karate non fa uso di Java durante i test, mentre Cucumber sì.
È proprio per questo motivo che si rivolge ai non programmatori, poiché la sintassi di Gherkins è super leggibile e completa. Per questo motivo Karate è il più adatto e consigliato per entrare nel mondo del testing automatizzato delle API.
Di seguito sono riportate alcune caratteristiche del Karate Testing Framework:
- Utilizza il linguaggio Gherkins, di facile comprensione.
- Non richiede conoscenze tecniche di programmazione come quelle di Java.
- Si basa sui popolari standard del cetriolo.
- È facile creare una struttura.
- Il test parallelo è una funzionalità fondamentale che viene fornita da Karate stesso, quindi non dobbiamo dipendere da Maven, Gradle , ecc.
- UI per il debug del test.
- Richiamo di un file di funzioni da un altro file.
- Fornisce il supporto per il test del driver dei dati che è costruito internamente, quindi non è necessario dipendere da framework esterni.
- Inoltre, può essere integrato con Cucumber per migliorare i rapporti dell'interfaccia utente e aumentare la chiarezza.
- Fornisce supporto interno per la configurazione di commutazione in diversi ambienti di test (QA, Stage, Prod, Pre-Prod).
- Supporto continuo per l'integrazione CI/CD che può essere utile.
- In grado di gestire varie chiamate HTTP:
- Supporto Web Socket
- Richiesta SOAP
- HTTP
- Gestione dei cookie del browser
- HTTPS
- Dati del modulo HTML
- Richiesta XML
Confronto tra Karate e Rest-Assured
Riposo assicurato È una libreria basata su Java per testare i servizi REST. Utilizza il linguaggio Java per scrivere le linee di codice. Aiuta a testare numerose categorie di richieste, che portano alla verifica di diverse combinazioni di logica aziendale.
Struttura del karate Uno strumento basato su Cucumber/Gherkins, usato per testare servizi SOAP e REST.
La tabella seguente elenca alcune differenze più importanti tra Rest-Assured & Karate Framework:
| S.No | Base | Struttura del karate | REST assicurato |
|---|---|---|---|
| 1 | Lingua | Utilizza una combinazione di cetrioli e cetriolini. | Utilizza il linguaggio Java |
| 2 | Codice Dimensione | Di solito, le righe di codice sono meno, poiché seguono una struttura simile a quella di Cucumber. | Il numero di righe di codice è maggiore poiché prevede l'utilizzo del linguaggio Java. |
| 3 | Conoscenze tecniche richieste | I non programmatori possono facilmente scrivere il codice dei cetriolini | Sono richieste conoscenze tecniche per scrivere codice Java |
| 4 | Test guidati dai dati | Necessità di utilizzare TestNG o un sistema equivalente per supportare lo stesso. | I tag interni possono essere utilizzati per supportare i test sui dati |
| 5 | Fornisce il supporto per le chiamate SOAP | Sì, fornisce | È legato solo a una richiesta REST |
| 6 | Test paralleli | Sì, i test paralleli sono facilmente supportati anche dalla generazione di report paralleli. | Anche se qualcuno ha provato a farlo, il tasso di insuccesso è superiore a quello di successo. |
| 7 | Segnalazione | Fornisce un reporting interno, quindi non deve dipendere da plugin esterni. Possiamo anche integrarlo con il plugin di reporting Cucumber per una migliore interfaccia utente. | Necessità di dipendere da plugin esterni come Junit, TestNG |
| 8 | Supporto CSV per i dati esterni | Sì, da Karate 0.9.0 | No, è necessario utilizzare il codice o la libreria Java |
| 9 | Automazione dell'interfaccia utente web | Sì, da Karate 0.9.5 l'automazione della Web-UI è possibile. | No, non è supportato |
| 10 | Esempio di GET | Param dato val1 = 'nome1' | given(). |
Quindi, come dimostrano le differenze di cui sopra, si può affermare che il Karate è una delle cose più semplici che chiunque possa fare.
Strumenti necessari per lavorare con Karate Framework
Ora che abbiamo acquisito le conoscenze di base su Karate Framework, analizziamo i processi e gli strumenti necessari per configurare l'ambiente Karate.
#1) Eclissi
Eclipse è un ambiente di sviluppo integrato utilizzato nel campo della programmazione informatica, soprattutto per la programmazione Java. Come già detto, Karate è scritto in Java, quindi ha più senso che Eclipse sia l'IDE di riferimento per il software di test API. Un'altra ragione è che si tratta di uno strumento open-source, e questo è un motivo piuttosto forte per optare per questo strumento.
Nota: Possiamo anche usare IntelliJ, Visual Studio e altri editor disponibili sul mercato.
#2) Maven
Si tratta di uno strumento di automazione della compilazione utilizzato principalmente per la costruzione di progetti Java. È un modo per impostare un ambiente Karate e scrivere il codice. Per configurare Eclipse con i requisiti di Maven, potete fare clic qui per l'installazione di Maven.
Quando si lavora in Maven, utilizzare le dipendenze Maven che aiutano a supportare Karate Framework.
Le seguenti dipendenze saranno utilizzate con Maven in pom.xml.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate-junit4 0.9.5 test
Nota: Le ultime versioni potrebbero essere disponibili nel repository Maven.
#3) Gradle
Gradle è un'alternativa a Maven e può essere usato allo stesso modo. Hanno le loro somiglianze e differenze, ma possono essere usati allo stesso modo per impostare un ambiente per i nostri codici Karate.
È più facile da usare, flessibile e si consiglia di usarlo quando la nostra applicazione ha dei requisiti di modularizzazione e gestione con un gruppo di plug-in. Il codice di configurazione di Gradle assomiglia a questo,
testCompile 'com.intuit.karate:karate-junit4:0.6.0' testCompile 'com.intuit.karate:karate-apache:0.6.0'
Nota: È possibile utilizzare MAVEN o GRADO.
#4) Impostazione dell'ambiente Java nel sistema
È necessario configurare l'ambiente JDK e JRE per iniziare a utilizzare gli script di Karate Framework.
Struttura del copione del test di karate
Uno script di test Karate è noto per il possesso dell'estensione ".feature". Questa proprietà è ereditata da Cucumber. Anche l'organizzazione dei file secondo le convenzioni Java è ugualmente consentita. Siete liberi di organizzare i vostri file secondo le convenzioni dei pacchetti Java.
Tuttavia, le linee guida di Maven indicano che la memorizzazione dei file non Java deve essere fatta separatamente e che essi vengono memorizzati in una cartella src/test/risorse E i file Java sono conservati sotto src/main/java .
Ma i creatori di Karate Framework credono fermamente che si debbano tenere fianco a fianco sia i file Java che quelli non Java. Secondo loro, è molto più facile cercare i file *.java e *.feature quando sono tenuti insieme, piuttosto che seguire la struttura standard di Maven.
Questo può essere fatto facilmente modificando il file pom.xml come segue (per Maven):
src/test/java **/*.java ...
Di seguito viene illustrata la struttura generale del Karate Framework:
Ora, poiché questo framework Karate utilizza il file Runner, che è necessario anche in Cucumber per eseguire i file delle caratteristiche, la maggior parte della scrittura seguirà gli standard di Cucumber.
Ma, a differenza di Cucumber, i passaggi non richiedono una definizione chiara in Karate e questo, a sua volta, aumenta la flessibilità e la facilità delle operazioni. Non abbiamo bisogno di aggiungere il collante extra che di solito dobbiamo aggiungere quando seguiamo il framework di Cucumber.
La classe "Runner" è quasi sempre denominata TestRunner.java.
Il file TestRunner.java avrà quindi la forma di:
import com.intuit.karate.junit4.Karate; import org.junit.runner.RunWith; @RunWith(Karate.class) public class TestRunner { } E parlando del .caratteristica contiene tutti gli scenari di test che devono essere verificati per assicurarsi che l'API funzioni secondo i requisiti previsti.
Un file *.feature generico ha un aspetto simile a quello mostrato di seguito:
Caratteristica: recuperare i dettagli dell'utente Scenario: testare la chiamata get per i dettagli dell'utente Dato l'url '//reqres.in/api/users/2' Quando il metodo GET Poi lo stato 200
Creare il primo script di base per il test di Karate
Questa sezione vi aiuterà a iniziare la creazione del vostro primo script di test, che vi sarà utile per convertire le API sotto forma di framework Karate.
Prima di scrivere gli script di base per i test di Karate, installate i seguenti requisiti sul vostro computer:
- IDE Eclipse
- Maven. Impostare il percorso Maven appropriato.
- JDK & JRE. Impostare il percorso appropriato.
Vediamo l'approccio passo dopo passo:
#1) Creare un nuovo MAVEN Progetto nell'editor di Eclipse
- Aprire Eclipse
- Fare clic su File. Selezionare Nuovo progetto.
- Selezionare il progetto Maven
- Scegliere la posizione dell'area di lavoro.
- Selezionare l'archetipo (di solito si sceglie " Maven-archetipo-quickstart 1.1 " per i progetti Maven semplici).
- Fornire l'ID del gruppo e l'ID dell'artefatto (nel nostro esempio abbiamo usato i seguenti valori).
- ID gruppo : Karate
- ID artefatto: KarateTestScriptsSample
- Fare clic su Fine per completare l'impostazione.
#2) Una volta creato, sarà possibile vedere la seguente struttura nella finestra Esplora progetto.
#3) Includere tutte le dipendenze.
Il nostro primo passo, dopo la configurazione, sarà quello di includere tutte le dipendenze che saranno richiesti per l'esecuzione. Manterremo tutti i tag sotto POM.xml (supponendo che si sia già a conoscenza dell'uso di POM.xml).
- Aprire POM.xml e copiare il codice seguente sotto il tag dependency e salvare il file.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate-junit4 0.9.5 test
Clicca qui per la fonte.
#4) Facciamo un brainstorming dello scenario, cosa vogliamo testare in questo script di test di Karate Basic.
Scenario:
Verrà testata un'API con questo URL.
Percorso: api/utenti/2
Metodo: GET
E dobbiamo convalidare , se la richiesta sta restituendo un oggetto Codice di successo (200) o meno.
In parole povere, si tratta di testare un'API di esempio per vedere se viene eseguita con successo o meno.
Nota: Prendiamo un'API di esempio che è disponibile per i test. Si può scegliere qualsiasi PATH o fare riferimento alla propria API.
Clicca qui per la fonte.
#5) Il prossimo passo sarà quello di creare un oggetto .caratteristica file.
Come discusso nella sezione introduttiva, il file .feature è la proprietà ereditata da Cucumber. In questo file, scriveremo gli scenari di test che devono essere eseguiti per eseguire il test delle API.
- Vai alla cartella src/test/java nel vostro progetto.
- Fare clic con il pulsante destro del mouse su di esso e creare un nuovo file. userDetails.feature. Quindi fare clic sul pulsante Fine.
Ora si vedrà il seguente file sotto la cartella src/test/java
Il Icona di colore verde assomiglia al .caratteristica fi in Cucumber che abbiamo appena creato.
- Una volta creato il file, ora scriveremo i nostri scenari di test, che verranno discussi nella sezione seguente.
#6) Dal momento che abbiamo lo scenario e il vuoto . caratteristica Il file è pronto, ora iniziamo con il nostro primo script. Iniziamo a codificare
Scrivete la seguente riga di codice nel file userDetails.feature che abbiamo creato al passo #5:
Caratteristica: recuperare i dettagli dell'utente Scenario: testare la chiamata get per i dettagli dell'utente Dato l'url '//reqres.in/api/users/2' Quando il metodo GET Poi lo stato 200
Cerchiamo di capire i componenti che sono scritti nel file di cui sopra:
- Caratteristica: La parola chiave spiega il nome della funzione che stiamo testando.
- Contesto: Si tratta di una sezione opzionale che viene trattata come una sezione di prerequisiti. Può essere utilizzata per definire tutto ciò che è necessario per testare l'API. Contiene HEADER, URL & PARAM opzioni.
- Scenario: Ogni file di caratteristiche che verrà visualizzato conterrà almeno una caratteristica (anche se può dare multiplo scenari). È la descrizione del caso di test.
- Dato: È il passo che deve essere eseguito prima di qualsiasi altro passo del test. È un'azione obbligatoria da eseguire.
- Quando: Specifica la condizione che deve essere soddisfatta per eseguire la fase di test successiva.
- Allora: Ci dice che cosa dovrebbe accadere nel caso in cui la condizione menzionata nella Quando è soddisfatta.
Nota: Tutte le parole chiave citate provengono dal linguaggio Gherkins, che rappresenta il modo standard di scrivere gli script di test con Cucumber.
Altre parole utilizzate nel file delle caratteristiche sono:
- 200: È il codice di stato/risposta che ci aspettiamo (fare clic qui per l'elenco dei codici di stato).
- GET: È il metodo API come POST, PUT, ecc.
Ci auguriamo che questa spiegazione sia stata di facile comprensione e che ora possiate fare riferimento a ciò che è scritto esattamente nel file di cui sopra.
Ora è necessario creare un file TestRunner.java
Come spiegato nella sezione precedente, Cucumber ha bisogno di un file Runner che sia necessario per eseguire il file .caratteristica che contiene gli scenari di test.
- Vai alla cartella src/test/java nel vostro progetto
- Fate clic con il pulsante destro del mouse e create un nuovo file Java: TestRunner.java
- Una volta creato il file, inserire le seguenti righe di codice sotto di essa:
import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { } - Test Runner è il file che verrà eseguito per realizzare lo scenario desiderato, scritto al punto 5.
#7) Ora siamo pronti con entrambi i file TestRunner.Java e utenteDeatils.feature. L'unico compito che ci resta è quello di Correre la sceneggiatura.
- Andate al file TestRunner.java e fate clic con il pulsante destro del mouse sul file, come mostrato nell'immagine seguente.
- Scegliere Esegui con nome -> Test di Junit
- Una volta selezionato, si noterà che il caso di test è stato avviato.
- Attendere l'esecuzione dello script di test. Una volta terminato, nella finestra si osserverà qualcosa di simile a quanto mostrato nell'immagine seguente.
- Infine, possiamo dire di aver creato con successo la nostra prima base Script di prova utilizzando il Struttura del karate.
#8) Infine, il framework Karate fornisce anche un report HTML di presentazione dell'esecuzione eseguita.
- Andare alla cartella Target -> surefire-reports-> Qui verrà visualizzato il report HTML che è possibile aprire.
** Suggeriamo inoltre di aprire la pagina utilizzando il browser Chrome per ottenere un aspetto migliore.
- Verrà visualizzato il seguente rapporto HTML che illustra Scenari e test che è stato eseguito per lo scenario citato:
Conclusione
In questo tutorial abbiamo parlato del testing delle API, dei diversi strumenti di testing disponibili sul mercato e di come Karate Framework sia un'opzione migliore rispetto alle sue controparti.
Per creare il nostro primo script di test di base, abbiamo seguito un approccio graduale. Abbiamo iniziato con la creazione di uno script di base Progetto Maven in Eclipse IDE per creare un file .feature, che contiene tutto lo scenario di test e un file Runner per eseguire il caso di test menzionato nel file .feature.
Al termine delle varie fasi, è possibile visualizzare il rapporto di esecuzione dei risultati del test.
Ci auguriamo che questo tutorial sia stato utile ai principianti per imparare a costruire il loro primo script di test utilizzando il Karate Framework e a eseguire i test delle API. Questo approccio dettagliato passo-passo è un modo meraviglioso per eseguire i vari test sulle API.
AVANTI