Ebben a kimerítő Rest Assured oktatóanyagban megtanuljuk a Rest API mélyreható tesztelés, API-tesztautomatizálás és Rest Assured moduláris megközelítésben
Mi az a RestAssured és használata
A Rest Assured egy nagyon széles körben használt nyílt forráskódú technológia a REST API Automation Testing számára, ez java alapú könyvtáron alapul.
A Rest Assured fej nélküli kliens módban kölcsönhatásba lép a Rest API-val, ugyanazt a kérést javíthatjuk úgy, hogy különböző rétegeket adunk hozzá a kérés kialakításához, és HTTP-kéréseket hozunk létre különböző HTTPS-igéken keresztül a szerver felé.
A Rest Assured beépített könyvtára hatalmas módszereket és segédprogramokat kínál a szervertől kapott válaszok, például az állapotüzenet, az állapotkód és a választörzs ellenőrzéséhez.
A Rest Assured Tutorial for REST API Automation Testing teljes sorozata a következő témakörökből áll:
Kezdő lépések: A restAssured konfigurálása Build eszközzel, azaz Maven/gradle segítségével
1. LÉPÉS: Ha a maven-nel dolgozik, csak adja hozzá a következő függőséget a pom.xml-hez (bármilyen más verziót is választhat):
A REST Assured használatának megkezdéséhez egyszerűen adja hozzá a függőséget a projekthez.
io.megnyugodhat megnyugodva 4.3.0 teszt
Ha gradle-lel dolgozik, csak adja hozzá a következőt a build.gradle fájlhoz (ismét választhat bármilyen más verziót is):
testCompile csoport: 'io.rest-assured', név: 'rest-assured', verzió: '4.3.0'
2. LÉPÉS: A REST Assured nagyon egyszerűen integrálható és használható a meglévő egységteszt-keretrendszerekkel, pl. a Testng, JUnit
Itt a testNg-t használjuk a Unit Test Framework szerint.
Miután a Rest Assured könyvtárait importáltuk, a következő statikus importokat kell hozzáadnunk tesztosztályainkhoz:
statikus import io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
JEGYZET : Ebből a közelgő tanulási célból teszteljük az Ergast Developer API-t, ami itt található. Ez az API előzményadatokat biztosít a Forma-1-es versenyekkel, versenyzőkkel, pályákkal stb.
A szintaxis ismerete:
Biztos lehet benne, hogy támogatja a BDD formátumot (Uborka szintaxis) megírni a tesztszkripteket pl. Adott/Akkor/Akkor/És formátumban. Feltételezzük, hogy érti a BDD/uborka szintaxist, ha nem, akkor azt javasoljuk, hogy szánjon 30 percet a BDD(Uborka szintaxis) és hogyan működik, és nagyon alapvető.
T-01: Az első szkriptünk, amely alapvetően az áramkörök számát érvényesíti az F1-ben 1-ben ezzel az API-val (http://ergast.com/api/f1/2017/circuits.json)
@Test(description = "Az áramkörök száma a 2017-es szezonban 20 legyen") public void validatingNumberOfCircuits() { given().when().get("http://ergast.com/api/f1/2017/circuits. json"). then().assertThat().body("MRData.CircuitTable.Circuits.circuitId", hasSize(20)); }
Rest API válasz érvényesítése :
1. Rögzíti az API-kérés JSON-válaszát.
2. Az áramkörazonosító lekérdezése az „MRData.CircuitTable.Circuits.circuitId” GPath kifejezés használatával
3. Ellenőrzi, hogy a circuitId elemgyűjtemény mérete 20
Itt használjuk Hamcrest matchers különféle érvényesítésekhez, mint pl
Számos más módszer is használható bizonyos érvényesítés végrehajtására.
Ezenkívül a Hamcrest könyvtár dokumentációjában találja az illesztők és módszerek teljes listáját.
Válaszkód érvényesítése:
adott().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().statusCode(200);
Tartalomtípus érvényesítése
adott().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().contentType(ContentType.JSON);
„Content-Length” fejléc érvényesítése
adott().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("Content-Length",equalTo("4551"));
Többszöri érvényesítés egyetlen tesztben, mint (és() módszerekkel):
@Test(description = "Az áramkörök száma a 2017-es szezonban 20 legyen")
public void validatingNumberOfCircuits() {
given().when().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("Content-Length",equalTo(" 4551")).és().statusCode(200);
}
A választörzs elem/attribútum érvényesítése:
A JsonPath segítségével lekérhetjük a json attribútumok értékét, és a TestNg segítségével állíthatunk be.
@Test(description = "A sorozatnév érvényesítése, amely f1")
public void validatingSeriesName() {
//A ResponseBody konvertálása karakterláncra
String responseBody=given().when().get("http://ergast.com/api/f1/2017/circuits.json").getBody().asString();
//JsonPath objektum létrehozása a választörzs karakterláncként történő átadásával
JsonPath resJson=new JsonPath(responseBody);
//Az attribútumérték-sorozat lekérése az MRData alatt
String seriesName=resJson.getString("MRData.series");
// User TestNg Assertion
Assert.assertEquals("f1",sorozatnév);
}
Hasonló módon megkaphattuk az XML válasz értékét az XMLPath használatával. Itt JSON-nal dolgozunk, ezért itt a JSonPath-ot használjuk.
A RESTful API-k csak kétféle paramétert támogatnak:
A. Lekérdezési paraméterek: Itt a paraméterek az API végpont végéhez vannak hozzáfűzve, és kérdőjellel azonosíthatók, és kulcsértékpárt alkotnak, mint pl.
https://www.google.com/search?q=https://www.wikipedia.org/
Itt a fenti API-ban a "q" a paraméter, a "https://www.wikipedia.org/" pedig ennek a paraméternek az értéke, ha a "SOMETHING_ELSE_TEXT' helyettesíthetjük a paraméter értékét 'q' -val "SOMETHING_ELSE_TEXT" a https://www.wikipedia.org/ helyett.
B. Útvonal paraméterei: Ezek a RESTful API-végpont részei.
például. végpont, amelyet korábban használtunk: http://ergast.com/api/f1/2017/circuits.json, itt a „2017” egy elérési út paraméter értéke.
Hogy eredményt érjen el az évre 2016-ban 2017-et 2016-ra cserélhetjük akkor az API megadja a válasz törzsét 2016-ra.
Tesztek a RestAssured Path Params használatával
@Test(description = "Az áramkörök számának ellenőrzése útvonalparaméterekkel")
public void tesztWithPathParams() {
String seasonNumber = "2017";
Karakterlánc responseBody = adott().pathParam("szezon", szezonszám).when().get("http://ergast.com/api/f1/{season}/circuits.json").getBody().asString ();
//JsonPath objektum létrehozása a választörzs karakterláncként történő átadásával
JsonPath resJson = new JsonPath(responseBody);
//Az attribútumérték-sorozat lekérése az MRData alatt
String seriesName = resJson.getString("MRData.series");
// User TestNg Assertion
Assert.assertEquals("f1", sorozatnév);
}
Tesztek a Query Params for RestAssured használatával
@Test(description = "A Google keresés érvényesítése Query Params segítségével")
public void tesztWithPathParams() {
String searchItem = "https://www.wikipedia.org/";
given().queryParam("q",searchItem).when().get("https://www.google.com/search").then().assertThat().statusCode(200);
}
Paraméterezési tesztek:
A Rest Assured használatával adatvezérelt tesztelést végezhetünk (azaz ugyanazt a tesztszkriptet többször is végrehajtjuk különböző bemeneti adatokkal, és különböző kimeneti adatokat biztosítunk)
1. LÉPÉS: Létrehozott egy tesztNg adatszolgáltatót.
2. LÉPÉS: Használja fel az Adatszolgáltatót teszt szkriptben.
@DataProvider(name="seasonsAndRaceNumbers")
public Object[][] testDataFeed() {
új objektum visszaadása[][] {
{"2017",20},
{"2016",21}
};
}
@Test(description = "Az áramkörök számának ellenőrzése különböző évszakokban",dataProvider = "évszakok és versenyszámok") public void circuitNumberValidation(String seasonYear,int versenyszámok) { adott().pathParam("szezon",szezonYear).when().get("http://ergast.com/api/f1/{évszak}/circuits.json").then().assertThat().body("MRData.CircuitTable.Circuits.circuitId",hasSize(versenyszámok)); }
Többértékű paraméterek használata a RestAssured segítségével
A többértékű paraméterek azok a paraméterek, amelyek paraméternevenként egynél több értékkel rendelkeznek (azaz a paramKey-nkénti értékek listája), az alábbiak szerint kezelhetjük őket:
given().param("paramKey", "paramValue1", "paramaValue2").when().get("API URL");
Vagy készíthetünk egy listát, és átadhatjuk a listát a paramKey értékeként, például:
Lista paramValue=új új ArrayList ();
paramValue.add("paramvalue1");
paramValue.add("paramvalue2);
given().param("paramKey", paramValue).when().get("API URL");
Cookie-k használata a RestAssured szolgáltatással
given().cookie("cookieK", "cookieVal").when().get("API URL");
Or
Itt is megadhatunk egy többértékű cookie-t, például:
given().cookie("cookieK", "cookieVal1", "cookieVal2").when().get(“API URL”);
Munka fejlécekkel:
Kérelemben megadhatjuk fejléc/fejlécek használatával, például:
adott().header(“fejlécK1”,”fejlécÉrték1”).header(“fejlécK2”,”fejlécÉrték2”).when().get(“API URL”);
A contentType használata:
given().contentType("application/json").when().get(“API URL”);
Or
adott().contentType(ContentType.JSON).when().get();
Mérje meg a válaszidőt:
long timeDurationInSeconds = get(“API URL”).timeIn(MÁSODPERC);
Rest API Authentication
A REST assured különböző hitelesítési sémákat támogat, pl. OAuth, kivonat, tanúsítvány, űrlap és megelőző alap hitelesítés. Minden egyes kéréshez beállíthatunk hitelesítést
itt van egy minta kérés ugyanazzal:
given().auth().basic("uName", "pwd").when().get("URL ") ..
Másrészt hitelesítés, és az alábbi megközelítésben definiálható a HTTP-kéréseknél:
RestAssured.authentication = basic("uName", "pwd");
Alapvető hitelesítési típusok:
Az alapvető hitelesítésnek két típusa van, a „preemptív” és a „kihívott jogkivonat alapvető hitelesítés”.
Megelőző alapszintű hitelesítés:
Ez még azelőtt elküldi az alapvető hitelesítési adatokat, hogy a kiszolgáló bizonyos helyzetekben jogosulatlan választ adna a kéréssel együtt, így csökkentve a további kapcsolat létrehozásának többletköltségét. Ez jellemzően nagymértékben előforduló helyzetek, hacsak nem teszteljük a szerverek kihívást jelentő képességét.
Például.
adott().auth().preemptive().basic("uName", "pwd").when().get("URL").then().statusCode(200);
Megkérdőjelezték az alapvető hitelesítést
Másrészt a „megkérdőjelezett alaphitelesítés” A REST Assured nem adja meg a hitelesítő adatokat, kivéve, ha a szerver kifejezetten kérte, azaz a szerver nem ad engedélyt. Ezt követően a jogosulatlan válasz után a Rest-Assured újabb kérést küld a kiszolgálónak, amely az Auth.
adott().auth().basic("uName", "pwd").when().get("URL").then().statusCode(200);
Digest hitelesítés
Jelenleg csak a „kihívott kivonatalapú hitelesítést” veszik számításba. például:
adott().auth().digest("uName", "pwd").when().get("URL").then().statusCode(200);
Űrlap hitelesítés
Ezt az alkalmazástól/forgatókönyvtől függően 3 különböző megközelítéssel érhetjük el:
Az űrlaphitelesítés az egyik nagyon népszerű az interneten, amikor a felhasználó beírja a hitelesítő adatait, azaz a felhasználónevét és jelszavát egy weboldalon keresztül, majd bejelentkezik a rendszerbe. Ezt ezzel lehet megoldani.
given().auth().form("uName", "pWd").
when().get(" URL");
then().statusCode(200);
Bár lehet, hogy ez nem működik az optimálisnak megfelelően, és a weboldal összetettségétől függően átmegy vagy meghiúsul. Jobb megoldás, ha megadja ezeket az adatokat az űrlap-hitelesítés beállításakor az alábbi megközelítésben:
given().auth().form("uName", "pwd", new FormAuthConfig("/'említse meg itt az űrlapművelet nevét, amely a html oldal kódjának része az űrlapcímke alatt'", "uName", "pwd" ")).when().get("URL").then().statusCode(200);
Ebben a megközelítésben a REST Assured belsőleg nem igényel további kérést és elemzést a weboldalon.
Ha az alapértelmezett Spring Security-t használja, akkor egy előre meghatározott FormAuthConfig aktiválódik.
given().auth().form("uName", "Pwd", FormAuthConfig.springSecurity()).when().get("URL").then().statusCode(200);
MEGJEGYZÉS: Ha további bemeneti adatokat szeretnénk küldeni az űrlap hitelesítésével együtt, akkor a következőket írhatjuk:
given().auth().form("uName", "pwd", formAuthConfig().withAdditionalFields("firstInputField", "secondInputField"). ..
CSRF:
A CSRF a Cross-site request forgery rövidítése.
Manapság nagyon gyakori, hogy a szerver egy CSRF tokent ad választ a CSRF biztonsági támadások elkerülésére. A REST Assured ezt támogatja az automatikus értelmező használatával és a CSRF token biztosításával.
Ennek elérése érdekében a REST Assured-nek további kérést kell benyújtania, és elemeznie kell a webhelyet (néhány pozíció).
A CSRF támogatást az alábbi kód beírásával tudjuk engedélyezni:
given().auth().form("uName", "pwd", formAuthConfig().withAutoDetectionOfCsrf()).when().get("URL").then().statusCode(200);
A REST Assured támogatása és az elemzés kifogástalanabbá és robusztusabbá tétele mellett megadhatjuk a CSRF mező nevét (itt feltételezzük, hogy Spring Security alapértelmezett értékeit használjuk, és használhatunk előre meghatározott springSecurity FormAuthConfig-ot):
given().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf")).when().get("URL").then().statusCode(200);
Alapértelmezés szerint a CSRF értéket űrlapparaméterként adjuk át a kéréssel, de beállíthatjuk, hogy fejlécként küldjük el, ha szükség van rá, mint az alábbiakban:
given().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf").sendCsrfTokenAsHeader()).when().get("URL").then().statusCode (200);
OAuth 1:
Az OAuth 1 megköveteli, hogy a Scribe az osztályútvonalon legyen. Az oAuth 1 hitelesítés használatához a következőket tehetjük:
adott().auth().oauth(..).when(). ..
OAuth 2:
adott().auth().oauth2(accessToken).when(). ..
A fenti megközelítésben az OAuth2 accessToken fejlécben lesz figyelembe véve. A pontosítás érdekében a következőket is megtehetjük:
adott().auth().preemptive().oauth2(accessToken).when(). ..
Fájl, bájttömb, beviteli adatfolyam vagy szöveg átadása a kérelemben:
Amikor nagy mennyiségű adatot küldenek a szerverre, általában elterjedt a többrészes űrlapos adattechnika használata. A Rest Assured a multiPart nevű metódusokat kínálja, amelyek lehetővé teszik a feltöltendő fájl, bájttömb, beviteli adatfolyam vagy szöveg megadását.
adott().multiPart(new File("/Fájl_útvonal")).when().post("/feltöltés");
POST-kérés létrehozása nyugodt szívvel
A POST és PUT kérésekkel adatokat küldünk a Szervernek és annak alapvetően az erőforrások létrehozását/erőforrások frissítését, ezt tekintheti írási vagy frissítési műveletnek.
A POST kérésben a szervernek küldött adatok a HTTP kérés/API hívás törzsében kerülnek elküldésre.
Az elküldött tartalom vagy adat típusa az API-tól függően eltérő formátumú lehet, azaz az XML, JSON vagy más formátumot a Content-Type fejléc határozza meg.
Ha a POST törzs a JSON-adatokból áll, akkor a Content-Type fejléc application/json lesz. Hasonlóan, egy XML-ből álló POST-kérés esetén a Content-Type fejléc application/xml típusú lesz.
Íme az alábbi kódrészlet ugyanerről:
given().contentType("application/json").param("pk","pv").when().body("JsonPAyloadString").post("url").then().assertThat(). állapotKód(200);
MEGJEGYZÉS: Különböző módokon adhatjuk át a hasznos terhelést/kérelem törzset a „body” metóduson belül, például String (amint a fenti részletben látható), JsonObject, fájlként stb.,
PUT kérés megnyugodva:
given().contentType("application/json").param("pk","pv").when().body("JsonPAyloadString").put("url").then().assertThat(). állapotKód(200);
Kérelem törlése a Megnyugvással:
adott().contentType("application/json").param("pk","pv").when().delete("url").then().assertThat().statusCode(200);
És így különböző Rest API-hívásokat hozhatunk létre a különböző API igékhez (GET/POST/PUT/DELETE stb.)
Sorozatosítás és deszerializálás Java nyelven:
A szerializálás alapvetően az objektum állapotának feldolgozása vagy konvertálása bájtfolyammá. Másrészt a Java deserializációja a bájtfolyamot feldolgozza vagy konvertálja tényleges Java objektummá a memóriában. Ezt a mechanizmust az objektum perzisztenciájában használják.
Az alábbiakban ugyanennek a blokkdiagramja látható
A sorozatosítás előnyei
V. Egy objektum állapotának elmentése/fenntartása.
B. Egy objektum hálózaton keresztüli áramlása.
Sorozatosítás elérése JAVA-val
Ahhoz, hogy egy Java objektum szerializálható legyen, meg kell valósítanunk a java.io.Serializable felületet.
Az ObjectOutputStream osztály, amely tartalmazza az objektumok sorosításáért felelős writeObject() metódust.
Az ObjectInputStream osztály egy másik, readObject() nevű metódust is tartalmaz, amely egy objektum deszerializálásáért felelős.
osztályok, amelyek a java.io.Serializable felületet valósítják meg, ott az objektum csak szerializálható.
A Serializable csak egy marker interfész, és más piaci interfészekhez hasonlóan nincs hozzá társítva adattag vagy metódus.amely a java osztályok „megjelölésére” szolgál, hogy ezen osztályok objektumai bizonyos képességeket kapjanak. Mint néhány más jelölő interfész: - Klónozható és távoli stb.
Megjegyzések:
1. Ha egy szülő osztály Serializálható interfészt valósított meg, akkor a gyermekosztálynak nem kell ugyanezt megvalósítania, de fordítva nem alkalmazható.
2. Csak a nem statikus adattagok kerülnek tárolásra a szerializálási folyamat során.
3. A statikus adattagokat és a tranziens adattagokat sem a sorosítás nem tárolja. Tehát, ha nem kell tárolnunk a nem statikus adattag értékét, akkor tranzienssé tehetjük.
4. A konstruktort soha nem hívják meg, amikor egy objektumot deszerializálnak.
1. LÉPÉS: Az első lépés alapvetően egy osztály létrehozása, amely megvalósítja a Serializable interfészt:
import java.io.Serializable;
public class Dummy implements Serializálható {
privát int i;
privát String adatok;
public Dummy(int i, Karakterlánc adatok)
{
this.i = i;
this.data = adat;
}
}
2. LÉPÉS: Hozzon létre egy osztályt a sorozatosításhoz:
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class Serialize {
public static void Serialization(Object classObject, String fileName) {
próbáld ki {
FileOutputStream fileStream = new FileOutputStream(fájlnév);
ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);
objectStream.writeObject(classObject);
objectStream.close();
fileStream.close();
} catch (FileNotFoundException e) {
// TODO Automatikusan generált fogási blokk
e.printStackTrace();
} catch (IOException e) {
// TODO Automatikusan generált fogási blokk
e.printStackTrace();
}
}
public static void main (String [] érvel) {
Dummy dummyObj = new Dummy(10, "Lambda-geeks");
Serialization(dummyObj, "DummSerialized");
}
}
3. LÉPÉS: A 2. lépés sikeres befejezése után látni fogja, hogy egy fájl létrejött néhány adattal, ezek az adatok alapvetően az objektum tagok soros adatai.
Deszerializálás java segítségével:
Íme az alábbi kódrészlet:
nyilvános statikus objektum sorosítása (karakterlánc fájlnév)
{
próbáld ki {
FileInputStream fileStream = new FileInputStream(new File(fileName));
ObjectInputStream objectStream = new ObjectInputStream(fileStream);
Object deserializeObject = objectStream.readObject();
objectStream.close();
fileStream.close();
return deserializeObject;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} fogás (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
Az illesztőprogram kódja így megy:
public static void main (String [] érvel) {
/* Dummy dummyObj = new Dummy(10, "Lambda-geeks");
Serialization(dummyObj, "DummSerialized");
System.out.println("-------------------------------------------- -------------------------------");
*/
Dummy deSerializedRect = (Dummy) DeSerialize("DummSerialized");
System.out.println("Adatok soros objektumból " + deSerializedRect.print());
System.out.println("-------------------------------------------- -------------------------------");
}
JSONPATH További szintaxis/lekérdezés:
Tegyük fel, hogy egy JSON-t az alábbiak szerint:
{
"OrganizationDetails": "A szervezet hamis adatai",
"Régió": "Ázsia",
"Emp-Details": [
{
"Org": "lambda-Geeks",
"Információ": {
"Ph": 1234567890,
"Hozzáadás": "XYZ",
"Kor": 45
}
},
{
"Org": "lambda-Geeks-2",
"Információ": {
"Ph": 2134561230,
"Hozzáadás": "ABC",
"Kor": 35
}
}
]
}
a fenti JSON-ban a OrganizationDetails & Region okot Leaf csomópontnak nevezik, mivel nem rendelkeznek további gyermek csomópontokkal/elemekkel, de másrészt az Emp-Detailsnek van gyermekcsomópontja, ezért nem Leaf csomópontnak nevezik.
Itt, ha megpróbáljuk megszerezni a OrganizationDetails értékét, akkor a következőt kell használnunk:
$.OrganizationDetails Ennek eredménye lesz: [ "A szervezet hamis adatai" ]
Mint a Wise, hogy megkapjuk a régió adatait, a következőt kell írnunk:
$.Régió
Ha meg akarjuk találni az 1. alkalmazott életkor értékét, akkor a következőt írhatjuk:
$.Emp-Details[0].Information.Age Ennek eredménye lesz: [ 45 ]
A 2. alkalmazott korához írhatnánk így
$.Emp-Details[1].Information.Age Ennek eredménye a következő lesz: [35]
Így kitalálhatjuk a JsonPath kifejezést/lekérdezést a JSON megfelelő mezőihez tartozó adatok lekéréséhez.
