Belangrike gids vir Rest API-toetsing en RestAssured

In hierdie volledige Rest Assured-tutoriaal gaan ons die Rus API-toets in diepte, API-toetsoutomatisering saam met Rest Assured in gemodulariseerde benadering

Wat is RestAssured en die gebruik daarvan

Rest Assured is 'n baie wyd gebruikte oopbrontegnologie vir REST API-outomatiseringstoetsing, dit is gebaseer op Java-gebaseerde biblioteek.

Rest Assured interaksie met Rest API in 'n koplose kliëntmodus, ons kan dieselfde versoek verbeter deur verskillende lae by te voeg om die versoek te vorm en HTTP-versoek via verskillende HTTPS-werkwoorde na die bediener te skep.

Rest Assured ingeboude biblioteek bied enorme metodes en nutsprogramme om die validering van die antwoord wat vanaf die bediener ontvang is uit te voer, soos statusboodskap, statuskode en antwoordliggaam.

Hierdie volledige reeks gerusstudie vir REST API-outomatiseringstoetse bestaan ​​uit die volgende onderwerpe:

RestAssured - Die gerus tutoriaal-api-toetsing
Wees gerus API-outomatisering

Aan die gang: Konfigurasie van rus verseker met die Build-instrument, dws Maven / gradle

STAP 1: As u met maven werk, voeg net die volgende afhanklikheid in pom.xml by (u kan ook enige ander weergawe kies):

Om aan die gang te kom met REST Assured, voeg net die afhanklikheid by u projek by. 


    io.rus-versekerd
    wees gerus
    4.3.0
    toets

As u met gradle werk, voeg net die volgende by in build.gradle (u kan ook weer enige ander weergawe kies):

testCompile groep: 'io.rust-assured', naam: 'rest-assured', weergawe: '4.3.0'

STAP 2: RUS verseker kan baie maklik geïntegreer en gebruik word in die bestaande eenheidstoetsraamwerke, dws Testng, JUnit

Hier gebruik ons ​​testNg volgens die eenheidstoetsraamwerk.

Sodra die biblioteke van Rest Assured ingevoer is, moet ons die volgende statiese invoer by ons toetsklasse voeg:

invoer statiese io.restassured.RestAssured. *;

invoer statiese org.hamcrest.Matchers. *;

NOTA: Vir hierdie komende leerdoel gaan ons die Ergast Developer API toets, wat hier gevind kan word. Hierdie API bied historiese data wat verband hou met Formule 1-wedlope, jaers, bane, ens.

Vertroudheid met die sintaksis:

Wees gerus ondersteun BDD-formaat (Gherkin Sintaksis) om die toetsskrifte in die gegewe / wanneer / dan / en-formaat te skryf, ons neem aan dat u begrip het vir BDD / agurk-sintaksis, indien nie, sou ons voorstel om 30 minute tyd te spandeer om te verstaan ​​wat BDD is (Gherkin Sintaksis) en hoe dit werk en die basiese werking daarvan.

T-01: Ons eerste script wat basies die aantal stroombane in F1 in 1 met behulp van hierdie API valideer (http://ergast.com/api/f1/2017/circuits.json)

@Test(beskrywing = "Aantal stroombane in 2017-seisoen moet 20 wees") publieke leemte validatingNumberOfCircuits() { given().when().get("http://ergast.com/api/f1/2017/circuits. json"). then().assertThat().body("MRData.CircuitTable.Circuits.circuitId", hasSize(20)); }

Val API-reaksie-reaksie :

1. Vang die JSON-reaksie van die API-versoek op.

2. Navrae vir circuitId met behulp van GPath-uitdrukking “MRData.CircuitTable.Circuits.circuitId”

3. Verifieer dat die stroombaan-ID-elementversameling die grootte van 20 het

Hier gebruik ons Hamcrest-wedstryders vir verskeie validering soos

Daar is verskeie ander metodes wat nuttig is om sekere validering uit te voer.

U kan ook die dokumentasie van die Hamcrest-biblioteek raadpleeg vir 'n volledige lys van pasmaats en metodes.

Validering van antwoordkode:

gegee (). wanneer (). kry ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). statusCode (200);

Validasie van tipe inhoud

gegee (). wanneer (). kry ("http://ergast.com/api/f1/2017/circuits.json") .dan (). assertThat (). contentType (ContentType.JSON);

Bevestig koptekst “Inhoudlengte”

gegee (). wanneer (). kry ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header (" Content-Length ", gelyk aan (" 4551 "));

Meervoudige validering in een of ander toetse as (met behulp van en () metodes):

@Test (beskrywing = "Aantal stroombane in 2017 se seisoen moet 20 wees")
    openbare nietigheid validatingNumberOfCircuits () {
        gegee (). wanneer (). kry ("http://ergast.com/api/f1/2017/circuits.json") .dan (). assertThat (). kop ("Inhoudlengte", gelyk aan (" 4551 ")). En (). StatusCode (200);
    }

Validerende reaksie-element / eienskap:

Ons kan JsonPath gebruik om die waarde van die json-eienskappe te haal en bewering te stel met behulp van TestNg

@Test (beskrywing = "Validasie van reeksnaam wat f1 is")
    openbare nietigheid validatingSeriesName () {
        // Skakel ResponseBody na String
        String responseBody = gegee (). Wanneer (). Kry ("http://ergast.com/api/f1/2017/circuits.json") .getBody (). AsString ();
        // Skep JsonPath-voorwerp deur die antwoordliggaam as 'n string deur te gee
        JsonPath resJson = nuwe JsonPath (responseBody);
        // Haal die kenmerkwaardereeks onder MRData
        String seriesName = resJson.getString ("MRData.series");
        // GebruikerstestNg-bewering
        Assert.assertEquals ("f1", reeksnaam);
    }

Op dieselfde manier kan ons die waarde kry van XML-reaksie met behulp van XMLPath. Hier word met JSON gewerk, daarom het ons hier JSonPath gebruik

RESTful API's ondersteun slegs twee soorte parameters:

A. Navraagparameters: Hier word parameters aan die einde van die API-eindpunt gevoeg en kan deur die vraagteken geïdentifiseer word en vorm 'n sleutelwaardepaar soos 

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

Hier in die bogenoemde API is 'q' die parameter en 'https://www.wikipedia.org/' is die waarde van die parameter, as ons soek 'IETS_ELSE_TEXT'ons kan die waarde van die parameter vervang 'q' met "IETS_ELSE_TEXT'in plaas van https://www.wikipedia.org/.

B. Padparameters: Dit is die deel van die RESTful API-eindpunt. 

bv. eindpunt wat ons vroeër gebruik het: http://ergast.com/api/f1/2017/circuits.json, hier is '2017' 'n padparameterwaarde.

Om 'n uitslag vir die jaar te kry 2016 kan ons 2017 vervang deur 2016 dan sal die API die reaksie-instansie vir 2016 gee.

Toetse met Path Params vir RestAssured

@Test (beskrywing = "Validasie van aantal stroombane met Path Params")
    openbare nietigheidstoetsWithPathParams () {
        String seasonNumber = "2017";
       String responseBody = gegewe (). PathParam ("season", seasonNumber) .when (). Get ("http://ergast.com/api/f1/{season}/circuits.json") .getBody (). AsString ();
        // Skep JsonPath-voorwerp deur die antwoordliggaam as 'n string deur te gee
        JsonPath resJson = nuwe JsonPath (responseBody);
        // Haal die kenmerkwaardereeks onder MRData
        String seriesName = resJson.getString ("MRData.series");
        // GebruikerstestNg-bewering
        Assert.assertEquals ("f1", reeksnaam);
    }

Toetse met behulp van Query Params vir RestAssured

@Test (beskrywing = "Validasie van Google-soektog met behulp van Query Params")
    openbare nietigheidstoetsWithPathParams () {
        String searchItem = "https://www.wikipedia.org/";
  gegee (). queryParam ("q", searchItem) .when (). get ("https://www.google.com/search") .then (). assertThat (). statusCode (200);
    }

Parameteriserende toetse:

Ons kan datagedrewe toetsing doen (dws dieselfde toetsskrif sal verskeie kere met verskillende stelle invoergegewens uitgevoer word en verskillende uitsetdata verskaf) met behulp van gerus 

STAP 1: 'n Toets-dataverskaffer gemaak

STAP 2: verbruik die dataverskaffer in die toetsskrif.

@DataProvider (name = "seasonAndRaceNumbers")
    openbare voorwerp [] [] testDataFeed () {
        stuur nuwe voorwerp [] [] {
                {"2017", 20},
                {"2016", 21}
        };
    }
@Test (beskrywing = "Aantal stroombane validering in verskillende seisoene", dataProvider = "seisoene en rasnommers") publieke void circuitNumberValidation(String seasonYear,int raceNumbers) { given().pathParam ("seisoen", seisoenjaar). wanneer (). kry ("http://ergast.com/api/f1/{seisoen}/circuits.json "). dan (). assertThat (). body (" MRData.CircuitTable.Circuits.circuitId ", hasSize (rasnommers)); }

Werk met meerwaardige parameters met RestAssured 

Multiewaardeparameters is die parameters wat meer as een waarde per parameternaam het (dws 'n lys waardes per parametriese sleutel). Ons kan dit hieronder aanspreek:

gegee (). param ("paramKey", "paramValue1", "paramaValue2"). wanneer (). get ("API URL");

Of ons kan 'n lys opstel en die lys deurgee as die waarde van die paramKey soos:

Lys paramValue=nuwe nuwe ArrayList ();
paramValue.add (“paramvalue1”);
paramValue.add (“paramvalue2);
gegee (). param ("paramKey", paramValue). wanneer (). get ("API URL");
Werk met koekie met RestAssured 
gegee (). cookie ("cookieK", "cookieVal"). wanneer (). get ("API URL");

Or 

Ons kan ook 'n multi-waarde koekie hier spesifiseer soos:

given().koekie("koekieK", "koekieVal1", "koekieVal2").wanneer().get(“API URL”);

Werk met opskrifte:

Ons kan in 'n versoek spesifiseer met behulp van koptekste / opskrifte soos:

gegewe (). header ("headerK1", "headerValue1"). header ("headerK2", "headerValue2"). wanneer (). get ("API URL");

Werk met inhoud Tipe:

gegewe (). contentType ("application / json"). wanneer (). get ("API URL");

Or 

gegewe (). contentType (ContentType.JSON). wanneer (). kry ();

Meet die reaksietyd:

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

Rest API-verifikasie

REST verseker ondersteun verskillende verifikasieskemas, bv. OAuth, digest, sertifikaat, vorm en voorkomende basiese verifikasie. Ons kan óf verifikasie vir elke versoek instel 

hier is 'n voorbeeldversoek met dieselfde:

gegee (). auth (). basic ("uName", "pwd"). wanneer (). get ("URL") ..

Aan die ander kant verifikasie en gedefinieer in die onderstaande benadering vir die HTTP-versoeke:

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

Basiese AUTH tipes:

Daar is twee tipes basiese verifikasie, "voorkomende" en "uitgedaagde token basiese verifikasie".

Voorkomende basiese outeur:

Dit sal die basiese verifikasiebewys stuur, selfs voordat die bediener in sekere situasies 'n ongemagtigde reaksie gee, tesame met die versoek wat geaktiveer word, wat die koste van die maak van 'n addisionele verbinding verminder. Dit kom meestal voor in situasies, tensy ons die bedieners se vermoë om uit te daag, toets. 

Bv.

gegee (). auth (). preemptive (). basic ("uName", "pwd"). wanneer (). get ("URL"). dan (). statusCode (200);

Uitdagende basiese verifikasie

Aan die ander kant, 'betwiste basiese verifikasie', sal REST Assured nie die referente verskaf nie, tensy die bediener dit eksplisiet gevra het, dws dat die bediener die ongemagtigde antwoord gooi. Na daardie ongemagtigde reaksie stuur Rest-Assured nog 'n versoek na die bediener wat die Auth is.

gegee (). auth (). basic ("uName", "pwd"). wanneer (). get ("URL"). dan (). statusCode (200);

Digest-verifikasie

Van nou af word slegs "uitgedaagde verifikasie-verifikasie" oorweeg. bv:

gegee (). auth (). digest ("uName", "pwd"). wanneer (). get ("URL"). dan (). statusCode (200); 

Vormverifikasie

Ons kan dit hoofsaaklik bereik in drie verskillende benaderings, afhangende van die toepassing / scenario's:

Vormstawing is een van die baie gewilde oor die internet, wat is dat 'n gebruiker sy geloofsbriewe invoer, dws gebruikersnaam en wagwoord deur 'n webblad en aanteken op die stelsel. Dit kan aangespreek word deur hierdie 

gegee (). auth (). vorm ("uName", "pWd").
wanneer (). get ("URL");
dan (). statusCode (200);

Dit sal moontlik nie werk nie aangesien dit optimaal is en afhang van die kompleksiteit van die webblad, of dit kan slaag. 'N Beter opsie is om hierdie besonderhede te verskaf wanneer u die vormverifikasie opstel in die onderstaande benadering:

gegee (). auth (). vorm ("uName", "pwd", nuwe FormAuthConfig ("/ 'noem hier die vorm van aksie naam wat deel uitmaak van die html bladsy kode onder die vorm tag'", "uName", "pwd wanneer (). kry ("URL"). dan (). statusCode (200);

In hierdie benadering sal die REST Assured intern nie vereis om bykomende versoek te aktiveer en deur die webblad te ontleed nie. 

As jy die verstek Spring Security dan gebruik 'n voorafbepaalde FormAuthConfig word geaktiveer.

gegee (). auth (). vorm ("uName", "Pwd", FormAuthConfig.springSecurity ()). wanneer (). kry ("URL"). dan (). statusCode (200);

OPMERKING: As ons addisionele toevoerdata saam met die vormverifikasie wil stuur, kan ons die volgende skryf:

gegee (). auth (). vorm ("uName", "pwd", formAuthConfig (). withAdditionalFields ("firstInputField", "secondInputField"). ..

MVO:

CSRF staan ​​vir vervalsing oor versoeke ter plaatse.

Deesdae is dit baie algemeen dat die bediener 'n CSRF-token met die reaksie verskaf om die CSRF-sekuriteitsaanvalle te vermy. REST Assured ondersteun dit deur 'n outomatiese ontleder te gebruik en CSRF-token te verskaf. 

Om dit te bereik, moet u 'n addisionele versoek en ontleding (min posisie) van die webwerf verseker.

Ons kan CSRF-ondersteuning aktiveer deur die onderstaande kode te skryf:

gegee (). auth (). vorm ("uName", "pwd", formAuthConfig (). metAutoDetectionOfCsrf ()). wanneer (). kry ("URL"). dan (). statusCode (200);

Bykomend om REST Assured te help en die ontleding foutloos en robuust te maak, kan ons die CSRF-veldnaam verskaf (hier word aanvaar dat ons die standaardwaardes van Spring Security gebruik en dat ons vooraf gedefinieerde springSecurity FormAuthConfig kan gebruik):

gegee (). auth (). vorm ("uName", "pwd", springSecurity (). metCsrfFieldName ("_ csrf")). wanneer (). kry ("URL"). dan (). statusCode (200);

Standaard word die CSRF-waarde as 'n vormparameter met die versoek oorgedra, maar ons kan instel om dit as 'n koptekst te stuur, indien dit nodig is soos hieronder:

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

OAuth 1:

OAuth 1 vereis dat Scribe in die klaspad moet wees. Om oAuth 1-verifikasie te gebruik, kan ons dit doen:

gegee (). auth (). oauth (..). wanneer (). ..

OAuth 2:

gegee (). auth (). oauth2 (accessToken) .when (). ..

In die bogenoemde benadering sal die OAuth2 accessToken in 'n kopskrif oorweeg word. Om meer eksplisiet te wees kan ons ook doen:

gegee (). auth (). voorkomend (). oauth2 (accessToken) .when (). ..

Bestuur van lêer, byte-skikking, invoerstroom of teks in versoek:

Wanneer u groot hoeveelhede data na die bediener stuur, is dit gewoonlik 'n algemene benadering om die meerdelige vormstegniek te gebruik. Wees gerus en voorsien metodes genaamd multiPart waarmee ons 'n lêer, byte-skikking, invoerstroom of teks kan spesifiseer om op te laai. 

gegewe (). multiPart (nuwe lêer ("/ File_Path")). wanneer (). post ("/ upload");

POST Skepping met gerusstelling

Met POST- en PUT-versoeke stuur ons data na die bediener en dit is basies die skep van bronne / opdatering van bronne, u kan dit as 'n skryf- of opdateringsbewerking beskou.

Die data wat in 'n POST-versoek na die bediener gestuur word, word in die liggaam van HTTP-versoek / API-oproep gestuur. 

Die tipe inhoud of data wat gestuur word, kan van verskillende formaat wees, afhangende van die API, dws XML, JSON of 'n ander formaat, word deur die inhoudsoortopskrif gedefinieer. 

As POST-liggaam uit die JSON-data bestaan, sal die opskrif Content-Type application/json wees. Net so sal die opskrif Content-Type vir 'n POST-versoek wat uit 'n XML bestaan, van toepassing/xml-tipe wees.

Hier is die onderstaande kode vir dieselfde:

gegewe (). contentType ("application / json"). param ("pk", "pv"). wanneer (). body ("JsonPAyloadString"). post ("url"). dan (). assertThat (). statusKode (200);

LET WEL: Daar is verskillende maniere waarop ons die loonvrag-/versoekliggaam binne die metode "liggaam" kan deurgee soos String (soos getoon in die brokkie hierbo), JsonObject, as 'n lêer, ens, ens.

PUT-versoek met gerusstelling:

gegewe (). contentType ("application / json"). param ("pk", "pv"). wanneer (). body ("JsonPAyloadString"). sit ("url"). dan (). assertThat (). statusKode (200);

Skrap versoek met Rest-Assured:

gegewe (). contentType ("application / json"). param ("pk", "pv"). wanneer (). delete ("url"). dan (). assertThat (). statusCode (200);

En op die manier kan ons verskillende Rest API-oproepe skep vir verskillende API-werkwoorde (GET / POST / PUT / DELETE, ens.)

Serialisering en deserialisering in Java:

Serialisering is 'n basies verwerking of omskakeling van die voorwerptoestand na 'n greepstroom. Aan die ander kant is die deserialisering in Java die verwerking of omskakeling van die greepstroom na werklike Java-objek binne geheue. Hierdie meganisme word gebruik in volharding van voorwerp.

Hieronder is die blokdiagram vir dieselfde 

Voordele van die serialisasie

A. Om die toestand van 'n voorwerp te stoor / aan te hou.

B. Om 'n voorwerp oor 'n netwerk te laat vloei.

Bereik serialisasie met JAVA

Om 'n Java-voorwerp te reeks wat benodig word, moet ons die java.io.Serialiseerbare koppelvlak implementeer.

Die ObjectOutputStream-klas wat die writeObject () -metode bevat wat verantwoordelik is vir die reeks van 'n voorwerp.

Die klas ObjectInputStream bevat ook 'n ander metode genaamd readObject () wat verantwoordelik is vir die deserialisering van 'n voorwerp.

klasse wat java.io.Serialiseerbare koppelvlak implementeer, kan die voorwerp slegs in serie aangebied word.

Serializable is net 'n merker-koppelvlak en soos ander markkoppelvlakke het dit geen data-lid of metode wat daarmee geassosieer word nie. wat gebruik word om java-klasse te "merk" sodat voorwerpe van hierdie klasse sekere vermoëns sal kry. Soos min ander merker-koppelvlakke is: - Kloonbaar en Remote ens.

OPMERKINGS:

1. As 'n ouerklas 'n koppelvlak wat in aanmerking geneem kan word, geïmplementeer het, is dit nie nodig dat die kinderklas dieselfde implementeer nie, maar omgekeerd is dit nie van toepassing nie.

2. Slegs nie-statiese datalede word met die serialiseringsproses gestoor.

3. Statiese data-lede en ook die verbygaande data-lede word nie deur die serialisering gestoor nie. Dus, as ons nie die nie-statiese data-lid se waarde hoef te stoor nie, kan ons dit verbygaande maak.

4. Konstrukteur word nooit geroep as 'n voorwerp gedeserialiseer word nie.

STAP 1: Die eerste stap is basies die skepping van 'n klas wat die Serializable-koppelvlak implementeer:

invoer java.io.Serialiseerbaar;
openbare klas Dummy-implemente Serialiseerbaar {
    privaat int i;
    private String data;
    openbare Dummy (int i, String data)
    {
        hierdie.i = i;
        hierdie data = data;
    }
}

STAP 2: Skep 'n klas om dit te reeks:

invoer java.io.FileNotFoundException;
invoer java.io.FileOutputStream;
invoer java.io.IOException;
invoer java.io.ObjectOutputStream;
publieke klas Serialiseer {
    openbare statiese nietige serialisasie (Object classObject, String fileName) {
        probeer {
            FileOutputStream fileStream = nuwe FileOutputStream (lêernaam);
            ObjectOutputStream objectStream = nuwe ObjectOutputStream (fileStream);
            objectStream.writeObject (classObject);
            objectStream.close ();
            fileStream.close ();
        } vang (FileNotFoundException e) {
            // TODO Outomatiese gegenereerde vangsblok
            e.printStackTrace ();
        } vang (IOException e) {
            // TODO Outomatiese gegenereerde vangsblok
            e.printStackTrace ();
        }
    }
    openbare statiese nietige hoof (String [] argumenteer) {
        Dummy dummyObj = nuwe Dummy (10, "Lambda-geeks");
        Serialisering (dummyObj, "DummSerialized");
    }
}

STAP 3: Sodra Stap2 suksesvol afgehandel is, kan u sien dat 'n lêer gemaak is met enkele data daarin; die gegewens is basies die seriële data van die Object-lede.

  Deserialisering met Java:

Hier is die onderstaande kode:

 openbare statiese voorwerp DeSerialize (string lêernaam)
    {
        probeer {
            FileInputStream fileStream = nuwe FileInputStream (nuwe lêer (lêernaam));
            ObjectInputStream objectStream = nuwe ObjectInputStream (fileStream);
            Object deserializeObject = objectStream.readObject ();
            objectStream.close ();
            fileStream.close ();
            terugkeer deserializeObject;
        } vang (FileNotFoundException e) {
            e.printStackTrace ();
        } vang (IOException e) {
            e.printStackTrace ();
        } vang (ClassNotFoundException e) {
            e.printStackTrace ();
        }
        terugkeer nul;
    }

Driver Code gaan soos volg:

 openbare statiese nietige hoof (String [] argumenteer) {
      /* Dummy dummyObj = new Dummy(10, "Lambda-geeks");
        Serialisering (dummyObj, "DummSerialized");
        System.out.println ("------------------------------------------- ------------------------------- ");
      */
        Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
        System.out.println ("Gegevens van geserialiseerde voorwerp" + deSerializedRect.print ());
        System.out.println ("------------------------------------------- ------------------------------- ");
    }

JSONPATH Meer sintaksis / navraag:

Kom ons aanvaar 'n JSON soos hieronder:

{
  "OrganizationDetails": "Dummy besonderhede van die organisasie",
  "Streek": "Asië",
  "Emp-besonderhede": [
    {
      "Org": "lambda-Geeks",
      "Inligting": {
        "Ph": 1234567890,
        "Voeg by": "XYZ",
        "Ouderdom": 45
      }
    },
    {
      "Org": "lambda-Geeks-2",
      "Inligting": {
        "Ph": 2134561230,
        "Voeg by": "ABC",
        "Ouderdom": 35
      }
    }
  ]
}

in die bogenoemde JSON, word die OrganisationDetails & Region genoem as Blaarknoop-rede omdat hulle geen verdere kindernodusse/elemente het nie, maar soos aan die ander kant die Emp-Details met kindernode , daarom word dit nie Blaarnodus genoem nie.

Hier as ons probeer om die waarde van OrganisationDetails te kry, moet ons gebruik:

$ .OrganizationDetails 
Dit sal lei tot:
 [
  "Dummy besonderhede van die organisasie"
]

Soos Wise om die data vir die streek te kry, moet ons skryf:

$ .Streek 

As ons die waarde van Ouderdom vir die 1ste Werknemer wil vind, kan ons skryf:

$ .Emp-besonderhede [0] .Inligting.Oudheid
Dit sal lei tot:
[
  45
]

Vir die Ouderdom van die 2de Werknemer kon ons skryf soos

$ .Emp-besonderhede [1] .Inligting.Oudheid
Dit sal lei tot : [ 35 ]

Op hierdie manier kan ons die JsonPath-uitdrukking / -navraag uitvind om die data vir die onderskeie velde in die JSON te gaan haal.

Scroll na bo