Menu

Test API REST con Spring RestTemplate e TestNG

rest api testing with spring resttemplate

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial approfondito spiega come iniziare con il test dell'API REST con Spring RestTemplate e TestNG con semplici esempi:

In questo articolo vedremo come iniziare con il test dell'API REST con RestTemplate e il framework TestNG.

Prima di esplorare il test delle API REST con RestTemplate e il framework TestNG, comprendiamo alcuni dei concetti di base coinvolti.

Iniziamo!!

Test API REST con Spring e TestNG

Cosa imparerai:

Cos'è REST?

Al giorno d'oggi, REST è diventata una scelta molto popolare per la creazione di servizi Web. Per esempio , Google ha più servizi REST come Calendar, API mappa , eccetera.

RIPOSO cioè Trasferimento di stato rappresentativo è uno stile architettonico del software. In questo stile, viene definita una serie di vincoli e sono necessari servizi Web creati per soddisfare questi vincoli. Tali servizi Web conformi allo stile architettonico REST sono noti come servizi Web RESTful.

Il termine 'trasferimento statale rappresentativo' è stato proposto per la prima volta da Roy Fielding nel suo dottorato di ricerca dissertazione nel 2000. L'idea di base di REST è trattare gli oggetti lato server come risorse che possono essere create o eliminate.

Cos'è JSON?

JSON cioè Notazione degli oggetti JavaScript è una sintassi molto comunemente utilizzata nei servizi REST per l'archiviazione e lo scambio di dati tra il browser e il server.

Il vantaggio principale di JSON è la sua leggerezza e, in secondo luogo, anche il suo formato leggibile. I dati vengono archiviati nel formato chiave: coppia valore. Per esempio, è possibile memorizzare i dati dei dipendenti in formato JSON in questo modo: {'name': 'Emp1 ″,' stary ':' 3000 ″, 'age': '23 ″,' id ':' 52686 ″}.

Che cos'è il test API REST?

Quando diciamo test dell'API REST, si tratta fondamentalmente di testare l'API eseguendo azioni di creazione, modifica, lettura ed eliminazione sulla risorsa con 4 metodi principali, ad esempio POST, GET, PUT e DELETE rispettivamente

Cos'è TestNG?

TestNG è un framework di test ispirato a JUnit e NUnit. È per il linguaggio di programmazione Java. TestNG copre una gamma più ampia di categorie di test come unità, funzionale, end-to-end, integrazione, ecc.

È un framework open source che rientra nella licenza Apache. Fornisce un ricco set di annotazioni che accelerano lo sviluppo dello script di test.

Cos'è il modello Spring REST?

La classe Spring RestTemplate è una parte di spring-web che è stata introdotta nella primavera 3

La classe RestTemplate fornisce un modo molto conveniente per testare i servizi web riposanti basati su HTTP fornendo metodi sovraccaricati per metodi HTTP come GET, POST, PUT, DELETE, ecc. Anche il framework Spring è open-source.

Passaggi di test dell'API REST

Cerchiamo di capire i passaggi che di solito vengono seguiti nei test API REST con alcuni esempi per ottenere una chiara comprensione.

In questo articolo, ho considerato un esempio di servizio per i dipendenti dell'API REST di questa fonte.

Inizialmente, seguiamo i passaggi manualmente utilizzando lo strumento POSTMAN.

# 1) Innanzitutto, conosci l'endpoint dell'API a cui desideri accedere.

Per esempio, http://dummy.restapiexample.com/api/v1/create per creare una nuova risorsa dipendente

#Due) Impostare intestazioni e corpo se richiesto per il metodo HTTP.

Nel nostro esempio, mentre stiamo cercando di creare una nuova risorsa utilizzando POST. Per POST, è richiesto un corpo della richiesta.

Quindi imposteremo il corpo come segue:

'Nome': 'zozo100 ″,' stipendio ':' 123 ″, 'età': '23'

Accettare : applicazione / JSON e Tipo di contenuto : applicazione / JSON.

bubble sort c ++ esempio

# 3) Impostare il metodo HTTP appropriato, ad esempio POST in questo caso.

# 4) Invia una richiesta al server del servizio Rest.

# 5) Ricevi una risposta dal server.

Chiamata API REST utilizzando lo strumento POSTMAN

CREA dipendente

# 6) Verificare la risposta come previsto con l'aiuto del codice di risposta Per esempio. 200 OK come un successo.

# 7) Verificare l'organismo di risposta come previsto, se necessario, confrontandolo con il file di benchmark.

Ora dobbiamo automatizzare gli stessi passaggi per la nostra suite di automazione del test. Cominciamo con la configurazione richiesta per l'automazione.

Configurazione di TestNG Test Framework su Windows

# 1) Installazione

  • Utilizzeremo Java per lo sviluppo di script di test. Quindi, primo download Programma di installazione JDK per Windows e installa Java sulla tua macchina.
  • IDE (Integrated Development Environment) : Ho utilizzato Eclipse come IDE per lo sviluppo della mia suite di test di automazione. Clic Qui per scaricarlo.
  • Ottieni il plug-in Eclipse per TestNG: Si noti che Java 1.7+ è richiesto per eseguire TestNG per il plug-in Eclipse. È richiesto Eclipse 4.2 e versioni successive. (Riferimento: TestNG ). Segui i passaggi seguenti in Eclipse:
    • Seleziona Aiuto / Installa nuovo software.
    • Fare clic su Aggiungi -> Immettere http://beust.com/eclipse/
    • Seleziona la casella di controllo accanto all'URL e fai clic sul pulsante Avanti.

Installazione di TestNG

TestNG

    • Continua a fare clic sul pulsante Avanti fino a raggiungere la schermata successiva.

Schermata finale dell'installazione di TestNG

Installazione di TestNG Schermata finale

Infine, accetta il contratto di licenza Apache e fai clic sul pulsante Fine per completare l'installazione.

Riavvia Eclipse per rendere effettiva l'installazione del plug-in.

  • Barattoli primaverili: Ora un'ultima cosa, useremo la classe RestTemplate dal framework spring. Puoi scarica i vasi primaverili e salvalo in una cartella locale, Per esempio ,C: / projectJar
  • JSON-Simple Jars: Dobbiamo eseguire l'analisi JSON. Per questo, useremo un'API semplice Json leggera. Quindi, scarica Json-simple-1.1.jar in C: / projectJar

Ora abbiamo completato le installazioni necessarie. Quindi, creiamo il nostro progetto di automazione del test.

# 2) Configurazione del progetto

  • Crea file -> Nuovo -> Progetto Java -> Denominalo come ' EmployeeTestSuite '.
  • Ora, crea un nuovo pacchetto java com.demo :
  • Configura percorso build:
    • Come hai visto nella sezione precedente, abbiamo installato TestNG, primavera scaricata e JSON-simple jar. Quindi, ora dobbiamo aggiungere il percorso di compilazione nel nostro progetto per consumarli. Per questo, crea un file lib cartella in EmployeeTestSuite cartella e ora copia tutti i jar da C: / projectJar a lib cartella.
    • Fare clic con il pulsante destro del mouse su ' EmployeeTestSuite ' -> Build Path -> Configura Build Path.
    • Clicca sul lib tab.
    • Clicca sul Aggiungi libreria pulsante -> Seleziona TestNG. Questo aggiungerà TestNG al percorso di compilazione.
    • Clicca su Aggiungi i barattoli pulsante -> Seleziona tutti i vasi da lib. Questo aggiungerà tutti i barattoli di primavera e il vaso semplice JSON al percorso di compilazione del progetto.

Percorso build Java

Percorso build Java

La struttura del progetto verrà visualizzata come segue in Eclipse Package Explorer ora.

Struttura del pacchetto

Struttura del pacchetto

# 3) Classe di prova

Dobbiamo creare una classe Test che possa coprire le operazioni CRUD (Create-Read-Update-Delete).

Crea un nuovo file di classe -> Nuovo -> Classe TestNG e chiamalo TestCRUD.java

# 4) Metodo di prova

Creiamo metodi di test separati:

  1. addEmployee (): Metodo di prova per testare Crea API utilizzando il metodo HTTP POST.
  2. getEmployee (): Metodo di prova per testare l'API di lettura utilizzando il metodo HTTP GET.
  3. updateEmployee (): Metodo di prova per testare l'API di aggiornamento utilizzando il metodo HTTP PUT.
  4. deleteEmployee (): Metodo di prova per testare l'API di eliminazione utilizzando il metodo DELETE HTTP.

È possibile creare un metodo di test come qualsiasi metodo java solo con l'annotazione @Test di TestNG per farlo identificare come metodo di test dal framework TestNG

Per esempio,il seguente è il metodo di test addEmployee.

@Test public void addEmployee () {}

Nel nostro esempio, ho usato un file servizio REST di esempio.

Ora automatizziamo la chiamata POST. Per questo, dobbiamo mappare il nostro codice con i passaggi che abbiamo seguito manualmente nella sezione 'Passaggi del test dell'API REST' uno per uno.

# 1) Innanzitutto, conosci l'endpoint dell'API a cui desideri accedere.

String addURI = 'http://dummy.restapiexample.com/api/v1/create';

#Due) Imposta le intestazioni per il metodo HTTP.

HttpHeaders headers = new HttpHeaders();

// Aggiungi intestazioni

headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json');

Imposta corpo per il metodo HTTP.

String jsonBody = '{'name':'zozo100','salary':'123','age':'23'}';

// Crea un oggetto HttpEntity impostando il corpo e le intestazioni.

HttpEntity entity = new HttpEntity(jsonBody, headers);

Avremo i seguenti passaggi automatizzati in una dichiarazione.

# 3) Impostare il metodo HTTP appropriato, ad esempio POST in questo caso.

# 4) Invia una richiesta al server del servizio RESTful.

# 5) Ricevi una risposta dal server.

RestTemplate restTemplate = new RestTemplate(); ResponseEntity response =restTemplate.postForEntity(addURI, entity, String.class);

Stiamo usando postForEntity per inviare il metodo POST al server. Riceviamo la risposta dall'oggetto ResponseEntity del server.

# 6) Verificare la risposta come previsto con l'aiuto del codice di risposta.

Assert.assertEquals(response.getStatusCode(), HttpStatus.OK);

Qui, stiamo usando la classe dello strumento Assert di TestNG per verificare il metodo assertEquals del codice di stato che confronta il valore effettivo, ad esempio response.getStatusCode (), con il valore atteso HttpStatus.OK.

Ma qui, stiamo effettuando un'ulteriore verifica, ovvero verificare se il dipendente aggiunto è presente o meno nel corpo della risposta.

Assert.assertTrue(responseBody.contains(employeeId));

Come abbiamo ottenuto l'ID dipendente?

Per questo, stiamo utilizzando l'aiuto dell'API parser JSON, ovvero Json-simple.

Stiamo utilizzando il parser JSON, poiché il formato JSON viene utilizzato per archiviare e scambiare i dati tra il client e il nostro server nel nostro servizio REST dei dipendenti. Come accennato in precedenza, i dati JSON vengono archiviati in chiave: valore formato. Qui, vogliamo ottenere il file 'Id' valore.

Lo otterremo analizzando il corpo della risposta come segue:

JSONParser parser = new JSONParser(); // Instantiate JSONParser object JSONObject jsonResponseObject = new (JSONObject) parser.parse(jsonString); //Parse jsonString i.e. Response body string in json format to JSON object String employeeId = jsonResponseObject.get('id').toString(); // Get id attribute

Quindi, questo è tutto sul test del metodo Create.

Metodi di aggiornamento, recupero ed eliminazione

  • Creare metodi di test separati e impostare le intestazioni come applicabile.
  • Anche la verifica del codice di stato viene eseguita in modo simile.
  • La differenza principale sono i metodi per inviare una richiesta ai server.

Puoi usare i seguenti metodi:

# 1) Aggiorna dipendente : È la richiesta HTTP PUT. Il metodo PUT RestTemplate che puoi utilizzare è:

public void put(String url,Object request, Object... urlVariables) throws RestClientException

# 2) Ottieni un dipendente: È la richiesta HTTP GET. Il metodo RestTemplate GET che puoi utilizzare è il seguente:

public ResponseEntity getForEntity(String url, Class responseType, Object... urlVariables) throws RestClientException

# 3) Elimina risorsa dipendente: È la richiesta HTTP DELETE. Il metodo RestTemplate DELETE che puoi utilizzare è:

public void delete(String url, Object... urlVariables) throws RestClientException

Oltre a questi metodi, ci sono metodi utili exchange () ed execute ().

Per esempio, se noti, il metodo Elimina è nullo. Ma se vuoi verificare il corpo della risposta, avrai bisogno di una risposta dall'esecuzione del metodo. A tale scopo, è possibile utilizzare il metodo exchange () che restituisce ResponseEntity. Fare riferimento a Quadro di primavera per ulteriori dettagli.

# 5) Esecuzione dei test

Ora, abbiamo completato la nostra attività di sviluppo dello script di test, quindi eseguiamo i nostri test. Basta fare clic destro su TestCRUD.java e seleziona l'opzione 'Esegui come testNG Test' .

Questo mostrerà i risultati dell'esecuzione del test come segue.

Uscita console

Uscita console

Nota: Puoi definire la tua suite di test in testng.xml file pure. Nel nostro esempio, è solo uno script di test. Ma nello scenario reale, è sempre una raccolta di più script.

Quindi il tuo file testg.xml avrà il seguente aspetto:

# 6) Rapporti

Abbiamo visto il risultato sulla console. Ma TestNG fornisce i risultati dei test in un formato html più presentabile che può essere condiviso con i tuoi stakeholder. Aperto uscita di prova -> emailable-report.html nel browser.

Vedrai il rapporto di prova come segue. Nella pagina del rapporto, puoi vedere il nome del test come TestCRUD, diversi test superati, ad esempio 4, Numero di ignorati e Non riusciti che sono 0 in questo caso. Mostra anche il tempo totale richiesto per l'esecuzione di ogni metodo di prova.

Risultato del test in formato HTML

lista doppiamente collegata nel codice sorgente c ++

Risultato del test in formato Html

Completa il codice del file TestCRUD

package com.demo; import java.io.IOException; import java.text.ParseException; import org.json.simple.JSONObject; import org.json.simple.parser.JSONParser; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import org.testng.Assert; import org.testng.annotations.AfterTest; import org.testng.annotations.BeforeTest; import org.testng.annotations.Test; import org.testng.log4testng.Logger; /** * This test class has test methods for CRUD actions on REST API * REST Service http://dummy.restapiexample.com/api * * It has test methods for Create , Edit , Get and Delete Employee items * https://docs.spring.io/spring-framework/docs/current/javadoc- api/org/springframework/web/client/RestTemplate.html * https://docs.spring.io/autorepo/docs/spring/3.2.3.RELEASE/javadoc- api/org/springframework/web/client/RestTemplate.html * @author * */ public class TestCRUD { private String responseBody; public String responseBodyPOST; final static Logger logger = Logger.getLogger(TestCRUD.class); //RESTTemplate Object private RestTemplate restTemplate; //Employee ID private String employeeId; // Create Response Entity - Stores HTTPStatus Code, Response Body, etc private ResponseEntity response; @BeforeTest public void beforeTest() throws IOException, ParseException { logger.info('Setting up prerequisite for test execution'); logger.info('Creating RestTemplate object before tests'); this.restTemplate = new RestTemplate(); } /** * Test Method to add employee using HTTP POST request * * Verifies POST action Status Code * * @throws IOException * @throws ParseException */ @Test public void addEmployee() throws IOException, ParseException { String addURI = 'http://dummy.restapiexample.com/api/v1/create'; HttpHeaders headers = new HttpHeaders(); headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json'); logger.info('Add URL :'+addURI); String jsonBody = '{'name':'zozo100','salary':'123','age':'23'}'; System.out.println(' ' + jsonBody); HttpEntity entity = new HttpEntity(jsonBody, headers); //POST Method to Add New Employee response = this.restTemplate.postForEntity(addURI, entity, String.class); responseBodyPOST = response.getBody(); // Write response to file responseBody = response.getBody().toString(); System.out.println('responseBody --->' + responseBody); // Get ID from the Response object employeeId = getEmpIdFromResponse(responseBody); System.out.println('empId is :' + employeeId); // Check if the added Employee is present in the response body. Assert.assertTrue(responseBody.contains(employeeId)); // System.out.println(propertyFile.get('EmployeeAddResBody')); // Check if the status code is 201 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee is Added successfully employeeId:'+employeeId); } /** * Method to get Employee ID from REsponse body * I have used Json Simple API for Parsing the JSON object * * @param json * @return */ public static String getEmpIdFromResponse(String json) { JSONParser parser = new JSONParser(); JSONObject jsonResponseObject = new JSONObject(); Object obj = new Object(); try { obj = parser.parse(json); } catch (org.json.simple.parser.ParseException e) { e.printStackTrace(); } jsonResponseObject = (JSONObject) obj; String id = jsonResponseObject.get('id').toString(); return id; } /** * Test Method to Update employee using HTTP PUT request * * Verifies PUT action Status Code * Verifies Updated Name exists in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'addEmployee', enabled = true) public void updateEmployee() throws IOException, ParseException { String updateURI = 'http://dummy.restapiexample.com/api/v1/update/'+employeeId; logger.info('Update URL :'+updateURI); String jsonBody = responseBodyPOST; jsonBody = jsonBody.replace('zozo100', 'update_zozo100'); HttpHeaders headers = new HttpHeaders(); headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json'); HttpEntity entity = new HttpEntity(jsonBody, headers); //PUT Method to Update the existing Employee //NOTE that I have Not used restTemplate.put as it's void and we need response for verification response = restTemplate.exchange(updateURI, HttpMethod.PUT, entity, String.class); responseBody = response.getBody().toString(); System.out.println('Update Response Body :'+responseBody); // Check if the updated Employee is present in the response body. Assert.assertTrue(responseBody.contains('update_zozo100')); // Check if the status code is 200 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee Name is Updated successfully employeeId:'+employeeId); } /** * Test Method to Get employee using HTTP GET request * * Verifies GET action Status Code * Verifies Name exists in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'updateEmployee', enabled = true) void getEmployee() throws IOException, ParseException { String getURI = 'http://dummy.restapiexample.com/api/v1/employee/'+this.employeeId; logger.info('Get URL :'+getURI); HttpHeaders headers = new HttpHeaders(); HttpEntity entity = new HttpEntity(headers); //GET Method to Get existing Employee response = restTemplate.getForEntity(getURI,String.class); // Write response to file responseBody = response.getBody().toString(); //Suppressing for log diffs System.out.println('GET Response Body :'+responseBody); // Check if the added Employee ID is present in the response body. Assert.assertTrue(responseBody.contains('update_zozo100')); // Check if the status code is 200 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee is retrieved successfully employeeId:'+employeeId); } /** * Test Method to Delete employee using HTTP DELETE request * * Verifies DELETE action Status Code * Verifies Success Message Text in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'getEmployee', enabled = true) public void deleteEmployee() throws IOException, ParseException { String delURI = 'http://dummy.restapiexample.com/api/v1/delete/'+this.employeeId; HttpHeaders headers = new HttpHeaders(); HttpEntity entity = new HttpEntity(headers); //DELETE Method to Delete existing Employee response = restTemplate.exchange(delURI, HttpMethod.DELETE, entity, String.class); // Check if the status code is 204 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); responseBody = response.getBody(); Assert.assertEquals(getMessageFromResponse(responseBody), 'successfully! deleted Records'); logger.info('Employee is Deleted successfully employeeId:'+employeeId); } /** * Gets 'text' key value from Response body text for verification * I have used Json Simple API for Parsing the JSON object * * @param json * @return text string */ public static String getMessageFromResponse(String json) { String successMessageText = null; try { JSONParser parser = new JSONParser(); JSONObject jsonResponseObject = new JSONObject(); jsonResponseObject = (JSONObject) (parser.parse(json)); String successMessage = jsonResponseObject.get('success').toString(); jsonResponseObject = (JSONObject) (parser.parse(successMessage)); successMessageText = jsonResponseObject.get('text').toString(); } catch (org.json.simple.parser.ParseException e) { e.printStackTrace(); } return successMessageText; } @AfterTest public void afterTest() { logger.info('Clean up after test execution'); logger.info('Creating RestTemplate object as Null'); this.restTemplate = new RestTemplate(); } }

Conclusione

Di seguito abbiamo riassunto i risultati dell'apprendimento di questo articolo. Abbiamo visto tutti i passaggi dall'inizio per configurare un framework di automazione del test dell'API REST.

In questo abbiamo imparato quanto segue:

  • Per l'automazione dei test, abbiamo selezionato Java come linguaggio di programmazione.
  • Abbiamo scelto TestNG come framework di test per la creazione di uno script di test in cui abbiamo utilizzato le annotazioni TestNG come @Test.
  • Per inviare richieste HTTP effettive al server, abbiamo utilizzato la classe RestTemplate del framework Spring.
  • Per utilizzare queste API, abbiamo installato TestNG, scaricato i jar Spring e Json-simple jar per l'API del parser.
  • Infine, abbiamo eseguito la classe Test e abbiamo visto il risultato sulla console e in un formato HTML più presentabile e più leggibile.

In poche parole, in questo articolo abbiamo imparato come iniziare con l'automazione dei test API REST con Spring RestTemplate. Abbiamo coperto l'impostazione del nostro framework di automazione dei test partendo dall'installazione di tutto il software essenziale, dall'impostazione del progetto, dallo sviluppo dello script di test fino all'esecuzione del test e dalla visualizzazione dei report generati.

Questo è abbastanza sufficiente per qualsiasi QA dell'automazione per iniziare con il framework di automazione dei test. Tuttavia, abbiamo visto solo le parti richieste da ciascuna, ad esempio, abbiamo utilizzato l'installazione TestNG, il metodo di test utilizzando l'annotazione @Test, i report. Tuttavia, TestNG fornisce molte altre funzionalità come DataProvider per test basati sui dati, ecc.

Sei pronto per iniziare con l'automazione dei test API REST con Spring RestTemplate?

Lettura consigliata

^