Ważny przewodnik dotyczący testowania interfejsu API Rest i RestAssured

by

W tym wyczerpującym samouczku Rest Assured nauczymy się obsługi Dogłębne testowanie API Rest, automatyzacja testów API wraz z gwarancją Rest Assured w podejściu modułowym

Co to jest RestAssured i jego zastosowanie

Rest Assured to bardzo szeroko stosowana technologia open source do testowania automatyzacji REST API, oparta na bibliotece opartej na Javie.

Rest Assured współdziała z Rest API w trybie bezgłowego klienta, możemy ulepszyć to samo żądanie, dodając różne warstwy, aby utworzyć żądanie i utworzyć żądanie HTTP za pośrednictwem różnych czasowników HTTPS do serwera.

Wbudowana biblioteka Rest Assured zapewnia ogromne metody i narzędzia do sprawdzania poprawności odpowiedzi otrzymanej z serwera, takiej jak komunikat o stanie, kod stanu i treść odpowiedzi.

Ta pełna seria samouczków Rest Assured dla testowania automatyzacji interfejsu API REST składa się z następujących tematów:

RestAssured - testowanie interfejsu API w samouczku zapewniające resztę
Niezawodna automatyzacja API

Pierwsze kroki: Konfiguracja restAssured za pomocą narzędzia Build, np. Maven / Gradle

KROK 1: Jeśli pracujesz z maven, po prostu dodaj następującą zależność w pom.xml (możesz też wybrać dowolną inną wersję):

Aby rozpocząć korzystanie z REST Assured, po prostu dodaj zależność do swojego projektu. 


    io. spokojny
    spokojny
    4.3.0
    test

Jeśli pracujesz z gradle, po prostu dodaj następujące polecenie w build.gradle (znowu możesz wybrać dowolną inną wersję):

grupa testCompile: „io.rest-assured”, nazwa: „rest-assured”, wersja: „4.3.0”

KROK 2: REST Assured można bardzo łatwo zintegrować i używać z istniejącymi strukturami testów jednostkowych, tj. Testng, JUnit

Tutaj używamy testNg zgodnie z jednostkową strukturą testów.

Po zaimportowaniu bibliotek Rest Assured musimy dodać następujące statyczne importy do naszych klas testowych:

import static io.restassured.RestAssured. *;

import static org.hamcrest.Matchers. *;

UWAGA: W tym nadchodzącym celu szkoleniowym przetestujemy Ergast Developer API, które można znaleźć tutaj. Ten interfejs API zapewnia dane historyczne związane z wyścigami Formuły 1, kierowcami, torami itp.

Znajomość składni:

Rest Assured obsługuje format BDD (Składnia korniszona), aby napisać skrypty testowe, tj. w formacie Given / When / Then / And, Zakładamy, że rozumiesz składnię BDD / gherkin, jeśli nie, sugerujemy spędzenie 30 minut czasu na zrozumienie, czym jest BDD (Składnia korniszona) i jak to działa i jak jest bardzo podstawowe.

T-01: Nasz pierwszy skrypt, który zasadniczo sprawdza liczbę obwodów w F1 w 1 roku przy użyciu tego interfejsu API (http://ergast.com/api/f1/2017/circuits.json)

@Test (description = "Liczba obwodów w sezonie 2017 powinna wynosić 20") public void validatingNumberOfCircuits () {dano (). When (). Get ("http://ergast.com/api/f1/2017/circuits. json ”). then (). assertThat (). body ("MRData.CircuitTable.Circuits.circuitId", hasSize (20)); }

Reszta walidacji odpowiedzi API :

1. Przechwytuje odpowiedź JSON na żądanie API.

2. Zapytania dotyczące circuitId przy użyciu wyrażenia GPath „MRData.CircuitTable.Circuits.circuitId”

3. Sprawdza, czy kolekcja elementów circuitId ma rozmiar 20

Tutaj używamy Dopasowani do ścięgien do różnych walidacji, takich jak

Istnieje wiele innych metod przydatnych do przeprowadzania określonej walidacji.

Możesz również zapoznać się z dokumentacją biblioteki Hamcrest, aby uzyskać pełną listę dopasowań i metod.

Weryfikacja kodu odpowiedzi:

dane (). kiedy (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). statusCode (200);

Walidacja typu treści

dane (). kiedy (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). contentType (ContentType.JSON);

Weryfikacja nagłówka „Content-Length”

dane (). kiedy (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). nagłówek (" Content-Length ", equalTo (" 4551 "));

Wielokrotna walidacja w jednym teście jako (przy użyciu metod i ()):

@Test (description = "Liczba obwodów w sezonie 2017 powinna wynosić 20")
    public void validatingNumberOfCircuits () {
        dane (). when (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header ("Content-Length", equalTo (" 4551 ")). I (). StatusCode (200);
    }

Walidacja elementu / atrybutu treści odpowiedzi:

Możemy użyć JsonPath do pobrania wartości atrybutów json i umieszczenia asercji przy użyciu TestNg

@Test (description = "Walidacja nazwy serii, czyli f1")
    public void validatingSeriesName () {
        // Konwertuj ResponseBody na ciąg
        String responseBody = podana (). When (). Get ("http://ergast.com/api/f1/2017/circuits.json") .getBody (). AsString ();
        // Utwórz obiekt JsonPath, przekazując treść odpowiedzi jako ciąg
        JsonPath resJson = new JsonPath (responseBody);
        // Pobierz serię wartości atrybutu w MRData
        String seriesName = resJson.getString ("MRData.series");
        // Asercja użytkownika TestNg
        Assert.assertEquals ("f1", seriesName);
    }

W podobny sposób mogliśmy uzyskać wartość odpowiedzi XML za pomocą XMLPath. Tutaj pracujemy z JSON, stąd użyliśmy tutaj JSonPath

RESTful API obsługują tylko dwa typy parametrów:

A. Parametry zapytania: Tutaj parametry są dołączane na końcu punktu końcowego API i można je zidentyfikować za pomocą znaku zapytania i tworzą parę klucz-wartość, taką jak 

https://www.google.com/search?q=https://www.wikipedia.org/

W powyższym API „q” jest parametrem, a „https://www.wikipedia.org/” jest wartością tego parametru, jeśli mamy szukać ”COŚ_JESZCZE_TEKST„moglibyśmy zastąpić wartość parametru „q” z "COŚ_JESZCZE_TEKST'zamiast https://www.wikipedia.org/.

B. Parametry ścieżki: Są to część punktu końcowego RESTful API. 

na przykład. punkt końcowy, którego używaliśmy wcześniej: http://ergast.com/api/f1/2017/circuits.json, tutaj „2017” to wartość parametru ścieżki.

Aby uzyskać wynik za rok Rok 2016 moglibyśmy zastąpić rokiem 2017 wtedy API poda treść odpowiedzi na 2016 rok.

Testy wykorzystujące parametry ścieżki dla RestAssured

@Test (description = "Walidacja liczby obwodów przy użyciu parametrów ścieżki")
    public void testWithPathParams () {
        String seasonNumber = "2017";
       String responseBody = given (). PathParam ("season", seasonNumber) .when (). Get ("http://ergast.com/api/f1/{season}/circuits.json") .getBody (). AsString ();
        // Utwórz obiekt JsonPath, przekazując treść odpowiedzi jako ciąg
        JsonPath resJson = new JsonPath (responseBody);
        // Pobierz serię wartości atrybutu w MRData
        String seriesName = resJson.getString ("MRData.series");
        // Asercja użytkownika TestNg
        Assert.assertEquals ("f1", seriesName);
    }

Testy przy użyciu Query Params for RestAssured

@Test (description = "Walidacja wyszukiwania Google przy użyciu parametrów zapytania")
    public void testWithPathParams () {
        Ciąg searchItem = "https://www.wikipedia.org/";
  dane (). queryParam ("q", searchItem) .when (). get ("https://www.google.com/search") .then (). assertThat (). statusCode (200);
    }

Testy parametryzujące:

Możemy przeprowadzać testy oparte na danych (tj. Ten sam skrypt testowy będzie wykonywany wiele razy z różnymi zestawami danych wejściowych i zapewni różne dane wyjściowe) przy użyciu funkcji Rest Assured 

KROK 1: Utworzono dostawcę danych testNg.

KROK 2: Wykorzystaj dostawcę danych w skrypcie testowym.

@DataProvider (name = "seasonsAndRaceNumbers")
    public Object [] [] testDataFeed () {
        zwraca nowy obiekt [] [] {
                {"2017", 20},
                {"2016", 21}
        };
    }
@Test (description = "Sprawdzanie liczby obwodów w różnych sezonach", dataProvider = "SeasonsAndRaceNumbers") public void circuitNumberValidation (String seasonYear, int raceNumbers) {given ().pathParam ("sezon", rokRok) .when (). get ("http://ergast.com/api/f1/{pora roku}/circuits.json "). then (). assertThat (). body (" MRData.CircuitTable.Circuits.circuitId ", hasSize (numery wyścigów)); }

Praca z parametrami o wielu wartościach z RestAssured 

Parametry wielowartościowe to te parametry, które mają więcej niż jedną wartość na nazwę parametru (tj. Listę wartości na paramKey), możemy je zaadresować jak poniżej:

dane (). param ("paramKey", "paramValue1", "paramaValue2"). when (). get ("URL API");

Lub możemy przygotować listę i przekazać ją jako wartość parametru paramKey:

Lista paramValue = new new ArrayList ();
paramValue.add („paramvalue1”);
paramValue.add („paramvalue2);
dane (). param ("paramKey", paramValue) .when (). get ("URL API");
Praca z plikami cookie z RestAssured 
dane (). cookie ("cookieK", "cookieVal"). kiedy (). get ("URL interfejsu API");

Or 

Możemy również określić tutaj plik cookie o wielu wartościach, na przykład:

dane (). cookie („cookieK”, „cookieVal1”, „cookieVal2”). kiedy (). get („API URL”);

Praca z nagłówkami:

Możemy określić w żądaniu za pomocą nagłówków / nagłówków, takich jak:

dane (). nagłówek („nagłówekK1”, „wartość_nagłówka1”). nagłówek („nagłówekK2”, ”wartość_nagłówka2”). when (). get („URL API”);

Praca z contentType:

dane (). contentType ("aplikacja / json"). when (). get ("URL interfejsu API");

Or 

dane (). contentType (ContentType.JSON) .when (). get ();

Zmierz czas odpowiedzi:

long timeDurationInSeconds = get („URL interfejsu API”). timeIn (SECONDS);

Reszta uwierzytelniania API

REST Assured obsługuje różne schematy uwierzytelniania, np. OAuth, skrót, certyfikat, formularz i podstawowe uwierzytelnianie z wywłaszczeniem. Możemy ustawić uwierzytelnianie dla każdego żądania 

oto przykładowe żądanie używające tego samego:

dane (). auth (). basic ("uName", "pwd"). when (). get ("URL") ..

Z drugiej strony uwierzytelnianie i zdefiniowane w poniższym podejściu dla żądań HTTP:

RestAssured.authentication = basic ("uName", "pwd");

Podstawowe typy AUTH:

Istnieją dwa typy uwierzytelniania podstawowego: „wywłaszczające” i „wymagające uwierzytelnienia podstawowego tokenu”.

Uwierzytelnianie podstawowe z wywłaszczaniem:

Spowoduje to wysłanie podstawowych danych uwierzytelniających jeszcze przed udzieleniem przez serwer nieautoryzowanej odpowiedzi w pewnych sytuacjach wraz z wyzwoleniem żądania, zmniejszając w ten sposób obciążenie związane z nawiązywaniem dodatkowego połączenia. Są to zazwyczaj najczęściej występujące sytuacje, chyba że testujemy zdolność serwerów do kwestionowania. 

Na przykład.

dane (). auth (). preemptive (). basic ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200);

Zakwestionowane uwierzytelnianie podstawowe

Z drugiej strony „zakwestionowane uwierzytelnienie podstawowe” REST Assured nie dostarczy poświadczeń, chyba że serwer wyraźnie o to poprosi, tj. Serwer wyśle ​​nieautoryzowaną odpowiedź. Po tej nieautoryzowanej odpowiedzi Rest-Assured wysyła kolejne żądanie do serwera, którym jest Auth.

dane (). auth (). basic ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200);

Digest Authentication

Obecnie rozważane jest tylko „uwierzytelnienie kwestionowanego skrótu”. na przykład:

dane (). auth (). skrót ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200); 

Uwierzytelnianie formularza

Mogliśmy to osiągnąć głównie w 3 różnych podejściach, w zależności od aplikacji / scenariuszy:

Uwierzytelnianie za pomocą formularza jest bardzo popularne w Internecie i polega na tym, że użytkownik wprowadza swoje dane uwierzytelniające, tj. nazwę użytkownika i hasło, za pośrednictwem strony internetowej i loguje się do systemu. Można temu zaradzić w ten sposób 

dane (). auth (). form ("uName", "pWd").
kiedy (). get ("URL");
then (). statusCode (200);

Chociaż może to nie działać, ponieważ jest optymalne, i może zakończyć się niepowodzeniem, w zależności od złożoności strony internetowej. Lepszą opcją jest podanie tych szczegółów podczas konfigurowania uwierzytelniania formularza w następujący sposób:

podana (). auth (). form ("uName", "pwd", new FormAuthConfig ("/ 'wspomnij tutaj nazwę akcji formularza, która jest częścią kodu strony html w tagu formularza'", "uName", "pwd ")). kiedy (). get (" URL "). then (). kod_stanu (200);

W tym podejściu REST Assured wewnętrznie nie będzie wymagał wyzwalania dodatkowego żądania i analizowania strony internetowej. 

Jeśli używasz domyślnego Spring Security, to wyzwalany jest predefiniowany FormAuthConfig.

dane (). auth (). form ("uName", "Pwd", FormAuthConfig.springSecurity ()). when (). get ("URL"). then (). statusCode (200);

UWAGA: Jeśli chcemy przesłać dodatkowe dane wejściowe wraz z uwierzytelnianiem formularza, możemy napisać poniżej:

dane (). auth (). form ("uName", "pwd", formAuthConfig (). withAdditionalFields ("firstInputField", "secondInputField"). ..

CSRF:

CSRF oznacza fałszowanie żądań między lokacjami.

Obecnie bardzo często serwer dostarcza token CSRF z odpowiedzią, aby uniknąć ataków bezpieczeństwa CSRF. REST Assured obsługuje to, korzystając z automatycznego parsera i dostarczając token CSRF. 

W celu osiągnięcia tego REST Assured trzeba złożyć dodatkowe żądanie i przeanalizować (kilka pozycji) strony internetowej.

Możemy włączyć obsługę CSRF pisząc poniższy kod:

dane (). auth (). form ("uName", "pwd", formAuthConfig (). withAutoDetectionOfCsrf ()). when (). get ("URL"). then (). statusCode (200);

Oprócz pomocy REST Assured i uczynienia parsowania bardziej bezbłędnym i niezawodnym, możemy podać nazwę pola CSRF (tutaj zakładamy, że używamy domyślnych wartości Spring Security i możemy użyć predefiniowanej springSecurity FormAuthConfig):

dane (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf")). when (). get ("URL"). then (). statusCode (200);

Domyślnie wartość CSRF jest przekazywana jako parametr formularza z żądaniem, ale możemy skonfigurować wysyłanie jej jako nagłówka, jeśli jest to wymagane, jak poniżej:

dane (). auth (). form ("uName", "pwd", springSecurity (). withCsrfFieldName ("_ csrf"). sendCsrfTokenAsHeader ()). when (). get ("URL"). then (). statusCode (200);

OAuth 1:

OAuth 1 wymaga, aby Scribe znajdował się w ścieżce klas. Aby skorzystać z uwierzytelniania OAuth 1, możemy wykonać:

dane (). auth (). oauth (..). when (). ..

OAuth 2:

dane (). auth (). oauth2 (accessToken) .when (). ..

W powyższym podejściu OAuth2 accessToken zostanie uwzględniony w nagłówku. Aby być bardziej precyzyjnym, możemy również zrobić:

dane (). auth (). preemptive (). oauth2 (accessToken) .when (). ..

Przekazywanie pliku, tablicy bajtów, strumienia wejściowego lub tekstu w żądaniu:

Podczas wysyłania dużych ilości danych na serwer zazwyczaj stosuje się technikę danych wieloczęściowych. Rest Assured zapewnia metody o nazwie multiPart, które pozwalają nam określić plik, tablicę bajtów, strumień wejściowy lub tekst do przesłania. 

dane (). multiPart (nowy plik ("/ Ścieżka_pliku")). when (). post ("/ upload");

Utworzenie wniosku POST z gwarancją spokoju

W przypadku żądań POST i PUT wysyłamy dane do serwera i zasadniczo tworzenie zasobów / aktualizację zasobów, można to potraktować jako operację zapisu lub aktualizacji.

Dane, które są wysyłane do serwera w żądaniu POST, są przesyłane w treści żądania HTTP / wywołania API. 

Rodzaj przesyłanych treści lub danych może mieć różny format w zależności od API, np. XML, JSON lub inny format określa nagłówek Content-Type. 

Jeśli treść POST składa się z danych JSON, wówczas nagłówek Content-Type będzie miał postać application/json. Podobnie w przypadku żądania POST składającego się z pliku XML nagłówek Content-Type będzie typu application/xml.

Oto poniższy fragment kodu dla tego samego:

dane (). contentType ("application / json"). param ("pk", "pv"). when (). body ("JsonPAyloadString"). post ("url"). then (). assertThat (). statusCode (200);

UWAGA: Istnieją różne sposoby przekazywania treści / żądania treści wewnątrz metody „body”, takiej jak String (jak pokazano na powyższym fragmencie), JsonObject, jako plik itp.,

Żądanie PUT z zapewnionym odpoczynkiem:

dane (). contentType ("application / json"). param ("pk", "pv"). when (). body ("JsonPAyloadString"). put ("url"). then (). assertThat (). statusCode (200);

Usuń wniosek z gwarancją odpoczynku:

dane (). contentType ("application / json"). param ("pk", "pv"). when (). delete ("url"). then (). assertThat (). statusCode (200);

W ten sposób możemy stworzyć różne wywołania Rest API dla różnych czasowników API (GET / POST / PUT / DELETE itp.)

Serializacja i deserializacja w Javie:

Serializacja to zasadniczo przetwarzanie lub konwersja stanu obiektu na strumień bajtów. Z drugiej strony deserializacja w Javie polega na przetwarzaniu lub konwersji strumienia bajtów na rzeczywisty obiekt Java w pamięci. Ten mechanizm jest używany w trwałości Object.

Poniżej znajduje się schemat blokowy tego samego 

1ESLuGPTk5gUs9eA5 OXkbw KyHeRnO9TdX bg OEo3 ZD7BJ9HqLY HcOaf9saeK137JSzmDj7 TY2WmrlVogzLzkgmN1gvLvyaF6cdGb6psTcv0HVH98J45L4b1a0c3ucUvJ6p

Zalety serializacji

A. Aby zapisać / utrwalić stan obiektu.

B. Przepływ obiektu w sieci.

Osiągnięcie serializacji z JAVA

Aby uzyskać serializowalny obiekt Java, musimy zaimplementować interfejs java.io.Serializable.

Klasa ObjectOutputStream, która zawiera metodę writeObject () odpowiedzialną za serializację obiektu.

Klasa ObjectInputStream zawiera również inną metodę o nazwie readObject (), która jest odpowiedzialna za deserializację obiektu.

klasy implementujące interfejs java.io.Serializable, obiekt może być tylko serializowany.

Serializable to tylko interfejs znacznika i podobnie jak inne interfejsy rynkowe nie ma z nim powiązanego elementu członkowskiego ani metody. Która służy do „oznaczania” klas Java, aby obiekty tych klas miały określone możliwości. Podobnie jak kilka innych interfejsów znaczników to: - Cloneable i Remote itp.

UWAGI:

1. Jeśli klasa nadrzędna zaimplementowała interfejs serializowalny, klasa potomna nie jest wymagana do implementacji tego samego, ale odwrotnie nie ma zastosowania.

2. W procesie serializacji są przechowywane tylko niestatyczne elementy składowe danych.

3. Statyczne składowe danych, a także przejściowe elementy składowe danych nie są przechowywane przez serializację. Tak więc, w przypadku, gdy nie musimy przechowywać wartości niestatycznego elementu członkowskiego danych, możemy uczynić go przejściowym.

4. Konstruktor nigdy nie jest wywoływany, gdy obiekt jest deserializowany.

KROK 1: Pierwszym krokiem jest zasadniczo utworzenie klasy, która implementuje interfejs Serializable:

importuj java.io.Serializable;
public class Dummy implementuje Serializable {
    prywatne int i;
    prywatne dane String;
    public Dummy (int i, String data)
    {
        to.i = ja;
        this.data = dane;
    }
}

KROK 2: Utwórz klasę, aby ją serializować:

importuj java.io.FileNotFoundException;
importuj java.io.FileOutputStream;
import java.io.IOException;
importuj java.io.ObjectOutputStream;
public class Serialize {
    public static void Serialization (Object classObject, String fileName) {
        spróbuj {
            FileOutputStream fileStream = nowy FileOutputStream (nazwa_pliku);
            ObjectOutputStream objectStream = new ObjectOutputStream (fileStream);
            objectStream.writeObject (classObject);
            objectStream.close ();
            fileStream.close ();
        } catch (FileNotFoundException e) {
            // TODO Automatycznie wygenerowany blok catch
            e.printStackTrace ();
        } złapać (IOException e) {
            // TODO Automatycznie wygenerowany blok catch
            e.printStackTrace ();
        }
    }
    public static void main (String [] args) {
        Dummy dummyObj = new Dummy (10, "Lambda-geeks");
        Serializacja (dummyObj, "DummSerialized");
    }
}

KROK 3: Gdy krok 2 zostanie pomyślnie zakończony, zobaczysz utworzony plik z pewnymi danymi, które są w zasadzie zserializowanymi danymi członków Object.

  Deserializacja za pomocą java:

Oto poniższy fragment kodu:

 public static Object DeSerialize (String fileName)
    {
        spróbuj {
            FileInputStream fileStream = nowy FileInputStream (nowy plik (nazwa_pliku));
            ObjectInputStream objectStream = new ObjectInputStream (fileStream);
            Object deserializeObject = objectStream.readObject ();
            objectStream.close ();
            fileStream.close ();
            zwróć deserializeObject;
        } catch (FileNotFoundException e) {
            e.printStackTrace ();
        } złapać (IOException e) {
            e.printStackTrace ();
        } catch (ClassNotFoundException e) {
            e.printStackTrace ();
        }
        zwróć null;
    }

Kod kierowcy wygląda tak:

 public static void main (String [] args) {
      / * Dummy dummyObj = new Dummy (10, "Lambda-geeks");
        Serializacja (dummyObj, "DummSerialized");
        System.out.println ("------------------------------------------- ------------------------------- ”);
      */
        Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
        System.out.println ("Data From Serialized Object" + deSerializedRect.print ());
        System.out.println ("------------------------------------------- ------------------------------- ”);
    }

JSONPATH Więcej składni / zapytania:

Załóżmy, że JSON jest następujący:

{
  "OrganisationDetails": "Dummy Details of the Organization",
  „Region”: „Azja”,
  "Emp-Details": [
    {
      "Org": "lambda-Geeks",
      "Informacja": {
        „Ph”: 1234567890,
        "Dodaj": "XYZ",
        „Wiek”: 45 lat
      }
    },
    {
      "Org": "lambda-Geeks-2",
      "Informacja": {
        „Ph”: 2134561230,
        "Dodaj": "ABC",
        „Wiek”: 35 lat
      }
    }
  ]
}

w powyższym JSON, OrganizationDetails & Region są nazywane jako węzeł liścia, ponieważ nie mają żadnych dalszych węzłów / elementów potomnych, ale z drugiej strony Emp-Details ma węzeł podrzędny, stąd nie jest nazywany węzłem liścia.

Tutaj, jeśli spróbujemy uzyskać wartość OrganizationDetails, musimy użyć:

$ .OrganizationDetails 
Spowoduje to:
 [
  „Fikcyjne szczegóły organizacji”
]

Podobnie jak Wise, aby uzyskać dane dla regionu musimy napisać:

$ .Region 

Jeśli chcemy znaleźć wartość wieku dla pierwszego pracownika, możemy napisać:

$ .Emp-Details [0] .Information.Age
Spowoduje to:
[
  45
]

Dla wieku drugiego pracownika moglibyśmy pisać jak

$ .Emp-Details [1] .Information.Age
Spowoduje to: [35]

W ten sposób możemy znaleźć wyrażenie / zapytanie JsonPath, aby pobrać dane dla odpowiednich pól w formacie JSON.