RestAssured API Testi ve RestAssured İçin Önemli Kılavuz

Bu kapsamlı Dinlenme Güvencesi eğitiminde şunları öğreneceğiz: Modülerleştirilmiş bir yaklaşımla Rest Assured ile birlikte derinlemesine API Testi, API Test Otomasyonu

RestAssured nedir ve kullanımı

Rest Assured, REST API Otomasyon Testi için çok yaygın olarak kullanılan bir açık kaynak teknolojisidir, bu java tabanlı kitaplığa dayanmaktadır.

Rest Assured, Rest API ile başsız bir istemci modunda etkileşime girer, isteği oluşturmak için farklı katmanlar ekleyerek aynı isteği geliştirebilir ve sunucuya farklı HTTPS fiilleri aracılığıyla HTTP isteği oluşturabiliriz.

Rest Assured yerleşik kitaplığı, durum mesajı, durum kodu ve yanıt gövdesi gibi sunucudan alınan yanıtın doğrulanmasını gerçekleştirmek için muazzam yöntemler ve araçlar sağlar.

REST API Otomasyon Testi için Rest Assured Eğitiminin bu eksiksiz serisi aşağıdaki konulardan oluşur:

RestAssured -Güvenilir eğitim api testi
İçiniz rahat olsun API Otomasyonu

Başlarken: Build aracıyla restAssured yapılandırması, yani Maven/gradle

ADIM 1: maven ile çalışıyorsanız, pom.xml'e aşağıdaki bağımlılığı eklemeniz yeterlidir (başka herhangi bir sürümü de seçebilirsiniz):

REST Assured'ı kullanmaya başlamak için bağımlılığı projenize eklemeniz yeterlidir. 


    io.kesinlikle
    emin olabilirsiniz
    4.3.0
    Ölçek

Gradle ile çalışıyorsanız, build.gradle dosyasına aşağıdakini eklemeniz yeterlidir (yine başka bir sürümü de seçebilirsiniz):

testCompile grubu: 'io.rest-assured', ad: 'güvenceli', sürüm: '4.3.0'

ADIM 2: REST Assured, Testng,JUnit gibi mevcut birim test çerçeveleriyle çok kolay bir şekilde entegre edilebilir ve kullanılabilir

Burada, Birim Test Çerçevesi ile ilgili olarak testNg kullanıyoruz.

Rest Assured kitaplıkları içe aktarıldığında, test sınıflarımıza aşağıdaki statik içe aktarmaları eklememiz gerekir:

statik içe aktar io.restassured.RestAssured.*;

statik org.hamcrest.Matchers'ı içe aktarın.*;

NOT: Yaklaşan bu öğrenme amacı için Ergast Developer API'sini test edeceğiz, hangi burada bulabilirsiniz. Bu API, Formula 1 yarışları, sürücüler, pistler vb. ile ilgili geçmiş verileri sağlar.

Sözdizimine aşinalık:

Rest Assured, BDD formatını destekler(kornişon sözdizimi) test komut dosyalarını, yani Verilen/Ne Zaman/Sonra/Ve biçiminde yazmak için, BDD/gherkin sözdizimini anladığınızı varsayıyoruz, değilse, BDD'nin ne olduğunu anlamak için 30 dakika ayırmanızı öneririz(kornişon sözdizimi) ve nasıl çalışır ve çok temeldir .

T-01 : Bu API'yi kullanarak 1'de F1'deki devre sayısını temel olarak doğrulayan 2017. betiğimiz (http://ergast.com/api/f1/2017/circuits.json)

@Test(description = "2017 Sezonunda Devre Sayısı 20 Olmalıdır") 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 yanıt doğrulaması :

1. API isteğinin JSON yanıtını yakalar.

2. “MRData.CircuitTable.Circuits.circuitId” GPath ifadesini kullanarak devre kimliği sorguları

3. CircuitId öğeleri koleksiyonunun 20 boyutunda olduğunu doğrular

İşte kullanıyoruz hamcrest eşleştiriciler gibi çeşitli doğrulamalar için

Belirli doğrulamayı gerçekleştirmek için yararlı olan çeşitli başka yöntemler vardır.

Ayrıca, eşleştiricilerin ve yöntemlerin tam listesi için Hamcrest kitaplığı belgelerine bakabilirsiniz.

Yanıt Kodu doğrulanıyor:

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

İçerik Türü Doğrulaması

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

“Content-Length” başlığı doğrulanıyor

verilen().When().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("İçerik Uzunluğu",equalTo("4551"));

Tek bir Testte Çoklu Doğrulama (And() yöntemlerini kullanarak):

@Test(description = "2017 Sezonunda Devre Sayısı 20 Olmalıdır")
    genel geçersiz doğrulamaNumberOfCircuits() {
        Given().When().get("http://ergast.com/api/f1/2017/circuits.json").then().assertThat().header("İçerik Uzunluğu",equalTo(" 4551")).and().statusCode(200);
    }

Yanıt Gövdesi öğesinin/özelliğinin doğrulanması:

Json niteliklerinin değerini almak ve TestNg kullanarak iddia koymak için JsonPath'i kullanabiliriz.

@Test(description = "f1 olan seri Adının doğrulanması")
    genel geçersiz validatingSeriesName() {
        // ResponseBody'yi String'e Dönüştür
        String yanıtıBody=given().When().get("http://ergast.com/api/f1/2017/circuits.json").getBody().asString();
        //Yanıt Gövdesini bir dize olarak ileterek JsonPath Nesnesi oluşturun
        JsonPath resJson=yeni JsonPath(responseBody);
        // MRData altında öznitelik değer serisini getir
        String seriesName=resJson.getString("MRData.series");
        // Kullanıcı Testi Onaylaması
        Assert.assertEquals("f1",seriesName);
    }

Benzer şekilde, XMLPath kullanarak XML yanıtının değerini elde edebiliriz. Burada JSON ile çalışıyoruz, dolayısıyla burada JSonPath'i kullandık.

RESTful API'ler yalnızca iki tür parametreyi destekler:

A. Sorgu parametreleri: Burada parametreler API bitiş noktasının sonuna eklenir ve soru işaretiyle tanımlanabilir ve aşağıdaki gibi bir anahtar değer çifti oluşturur: 

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

Burada yukarıdaki API'de 'q' parametredir ve 'https://www.wikipedia.org/', arama yaparsak bu parametrenin değeridir.SOMETHING_ELSE_TEXT' parametrenin değerini değiştirebiliriz 'q' ile 'SOMETHING_ELSE_TEXT' https://www.wikipedia.org/ yerine.

B. Yol parametreleri: Bunlar, RESTful API bitiş noktasının bir parçasıdır. 

Örneğin. daha önce kullandığımız uç nokta: http://ergast.com/api/f1/2017/circuits.json, burada "2017" bir yol parametre değeridir.

Yıl için bir sonuç almak için 2016, 2017'yi 2016 ile değiştirebiliriz daha sonra API, 2016 için yanıt gövdesini verecektir.

RestAssured için Yol Paramlarını kullanan testler

@Test(description = "Yol Paramlarını Kullanarak Devre Sayısının Doğrulanması")
    genel geçersiz testWithPathParams() {
        string sezonNumber = "2017";
       Dize yanıtıBody = verilen().pathParam("sezon", sezonNumber).When().get("http://ergast.com/api/f1/{sezon}/circuits.json").getBody().asString ();
        //Yanıt Gövdesini bir dize olarak ileterek JsonPath Nesnesi oluşturun
        JsonPath resJson = yeni JsonPath(responseBody);
        // MRData altında öznitelik değer serisini getir
        String seriesName = resJson.getString("MRData.series");
        // Kullanıcı Testi Onaylaması
        Assert.assertEquals("f1", seriesName);
    }

RestAssured için Sorgu Parametrelerini kullanan testler

@Test(description = "Sorgu Paramlarını kullanarak Google aramasının doğrulanması")
    genel geçersiz testWithPathParams() {
        String searchItem = "https://www.wikipedia.org/";
  verilen().queryParam("q",searchItem).When().get("https://www.google.com/search").then().assertThat().statusCode(200);
    }

Parametrelendirme testleri:

Rest Assured'ı kullanarak veriye dayalı testler yapabiliriz (yani aynı test komut dosyası, farklı girdi verileri setleriyle birden çok kez yürütülür ve farklı çıktı verileri sağlar) 

ADIM 1: Bir testNg Veri Sağlayıcısı oluşturuldu.

ADIM 2: Veri Sağlayıcıyı Test komut dosyasında kullanın.

@DataProvider(name="seasonsAndRaceNumbers")
    genel Nesne[][] testDataFeed() {
        yeni Nesne döndür[][] {
                {"2017",20},
                {"2016",21}
        };
    }
@Test(description = "Farklı Mevsimlerde Devre Sayısı doğrulaması",dataProvider = "mevsimAndYarışSayıları") public void CircuitNumberValidation(String SeasonYear,int raceNumbers) { verilen().pathParam("sezon",sezonYıl).When().get("http://ergast.com/api/f1/{mevsim}/circuits.json").then().assertThat().body("MRData.CircuitTable.Circuits.circuitId",hasSize(yarışNumaraları)); }

RestAssured ile Çok değerli parametrelerle çalışma 

Çok değerli parametreler, parametre adı başına birden fazla değere sahip olan parametrelerdir (yani, paramKey başına bir değer listesi), bunları aşağıdaki gibi ele alabiliriz:

verilen().param("paramKey", "paramValue1", "paramaValue2").When().get(“API URL'si“);

Veya bir liste hazırlayabilir ve listeyi paramKey değeri olarak şöyle iletebiliriz:

Liste paramValue=yeni yeni ArrayList ();
paramValue.add(“paramvalue1”);
paramValue.add(“paramvalue2);
verilen().param("paramKey", paramValue).When().get(“API URL'si“);
RestAssured ile çerez ile çalışma 
verilen().cookie("cookieK", "cookieVal").while().get("API URL'si");

Or 

Burada ayrıca çok değerli bir tanımlama bilgisi de belirtebiliriz:

verilen().cookie("cookieK", "cookieVal1", "cookieVal2").When().get(“API URL'si”);

Başlıklarla Çalışmak:

Aşağıdaki gibi başlık/başlıklar kullanarak bir istekte belirtebiliriz:

verilen().header(“headerK1”,”headerValue1”).header(“headerK2”,”headerValue2”).When().get(“API URL”);

contentType ile çalışma:

verilen().contentType("application/json").When().get(“API URL'si”);

Or 

verilen().contentType(ContentType.JSON).When().get();

Tepki Süresini Ölçün:

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

Dinlenme API Kimlik Doğrulaması

REST güvence, farklı kimlik doğrulama şemalarını destekler, örneğin OAuth, özet, sertifika, form ve önleyici temel kimlik doğrulama. Her istek için kimlik doğrulama ayarlayabiliriz 

aynısını kullanan örnek bir istek:

verilen().auth().basic("uName", "pwd").When().get(“URL “) ..

Öte yandan kimlik doğrulama ve HTTP istekleri için aşağıdaki yaklaşımda tanımlanmıştır:

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

Temel Yetkilendirme Türleri:

İki tür temel kimlik doğrulama vardır, "önleyici" ve "zorlu belirteç temel kimlik doğrulaması".

Önleyici Temel Yetkilendirme:

Bu, tetiklenen istekle birlikte belirli durumlarda sunucu yetkisiz bir yanıt vermeden önce bile temel kimlik doğrulama bilgilerini gönderecek ve böylece ek bir bağlantı kurma ek yükünü azaltacaktır. Sunucuların meydan okuma yeteneğini test etmediğimiz sürece, bu genellikle büyük ölçüde meydana gelen durumlardır. 

Örn.

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

Zorlanan Temel Kimlik Doğrulama

Öte yandan, "zorlu temel kimlik doğrulama" REST Assured, sunucu açıkça istemediği sürece kimlik bilgilerini sağlamayacaktır, yani sunucu Yetkisiz Yanıt atar. Bundan sonra Yetkisiz yanıt Rest-Assured, sunucuya Auth olan başka bir istek gönderir.

Given().auth().basic("uName", "pwd").while().get("URL").then().statusCode(200);

Özet Kimlik Doğrulaması

Şu anda yalnızca "zorlu özet kimlik doğrulaması" düşünülüyor. Örneğin:

verilen().auth().digest("uName", "pwd").while().get("URL").then().statusCode(200); 

Form Kimlik Doğrulaması

Bunu, Uygulamaya/Senaryolara bağlı olarak büyük ölçüde 3 farklı yaklaşımla başarabiliriz:

Form kimlik doğrulaması, bir kullanıcının bir web sayfası aracılığıyla kimlik bilgilerini, yani kullanıcı adını ve şifresini girerek sisteme giriş yaptığı internet üzerinden çok popüler olanlardan biridir. Bu, bu kullanılarak ele alınabilir. 

verilen().auth().form("uAd", "pWd").
zaman().get("URL");
o zaman().durumKodu(200);

Bu, optimal olduğu gibi çalışmayabilir ve web sayfasının karmaşıklığına bağlı olarak başarılı veya başarısız olabilir. Aşağıdaki yaklaşımda form kimlik doğrulamasını ayarlarken bu ayrıntıları sağlamak daha iyi bir seçenektir:

Given().auth().form("uName", "pwd", new FormAuthConfig("/'burada html sayfa kodunun bir parçası olan eylem adını form etiketi altında belirtin'", "uName", "pwd" ")).When().get("URL").then().statusCode(200);

Bu yaklaşımda, REST Assured dahili olarak ek isteği tetiklemeyi ve web sayfası üzerinden ayrıştırmayı gerektirmez. 

Varsayılan Spring Security kullanıyorsanız, o zaman önceden tanımlanmış bir FormAuthConfig tetiklenir.

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

NOT: Form auth ile birlikte ek girdi verileri göndermek istiyorsak, aşağıdakileri yazabiliriz:

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

CSRF:

CSRF, Siteler Arası istek sahteciliği anlamına gelir.

Günümüzde sunucunun, CSRF güvenlik saldırılarından kaçınmak için yanıtla birlikte bir CSRF belirteci sağlaması çok yaygındır. REST Assured, otomatik ayrıştırıcı kullanarak ve CSRF belirteci sağlayarak bunu destekler. 

Bunu başarmak için REST Assured'ın ek bir istekte bulunması ve web sitesini (birkaç pozisyon) ayrıştırması gerekir.

Aşağıdaki kodu yazarak CSRF desteğini etkinleştirebiliriz:

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

REST Assured'a yardımcı olmaya ve ayrıştırmayı daha kusursuz ve sağlam hale getirmeye ek olarak, CSRF alan adını sağlayabiliriz (burada Spring Security varsayılan değerlerini kullandığımızı ve önceden tanımlanmış springSecurity FormAuthConfig kullanabileceğimizi varsayıyoruz):

Given().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf")).When().get("URL").then().statusCode(200);

Varsayılan olarak CSRF değeri, istekle birlikte bir form parametresi olarak iletilir, ancak aşağıdaki gibi gerekli olması durumunda bunu bir başlık olarak göndermek üzere yapılandırabiliriz:

Given().auth().form("uName", "pwd", springSecurity().withCsrfFieldName("_csrf").sendCsrfTokenAsHeader()).When().get("URL").then().statusCode (200);

Yetkilendirme 1 :

OAuth 1, Scribe'ın sınıf yolunda olmasını gerektirir. oAuth 1 kimlik doğrulamasını kullanmak için şunları yapabiliriz:

verilen().auth().oauth(..).When(). ..

Yetkilendirme 2 :

verilen().auth().oauth2(accessToken).When(). ..

Yukarıdaki yaklaşımda, OAuth2 accessToken bir başlıkta değerlendirilecektir. Daha açık olmak gerekirse şunları da yapabiliriz:

verilen().auth().preemptive().oauth2(accessToken).When(). ..

İstekte Dosya, bayt dizisi, giriş akışı veya metin iletme:

Sunucuya büyük miktarda veri gönderirken, genellikle çok parçalı form veri tekniğini kullanmak yaygın bir yaklaşımdır. Rest Assured, yüklenecek bir dosya, bayt dizisi, giriş akışı veya metin belirlememize izin veren multiPart adı verilen yöntemler sağlar. 

verilen().multiPart(new File("/File_Path")).When().post("/upload");

Güvenle POST Talebi Oluşturma

POST ve PUT istekleri ile Verileri Sunucuya gönderiyoruz ve temelde kaynak oluşturma/kaynakların güncellenmesi bunu bir yazma veya güncelleme işlemi olarak düşünebilirsiniz.

Bir POST isteğinde sunucuya gönderilen veriler, HTTP isteği/API çağrısı gövdesinde gönderilir. 

Gönderilen içerik veya veri türü, API'ye bağlı olarak farklı formatta olabilir, yani XML, JSON veya başka bir format, Content-Type başlığı tarafından tanımlanır. 

POST gövdesi JSON verilerinden oluşuyorsa, Content-Type başlığı application/json olacaktır. Benzer şekilde, bir XML'den oluşan bir POST isteği için Content-Type başlığı application/xml türünde olacaktır.

İşte aynı için aşağıdaki kod parçası:

verilen().contentType("application/json").param("pk","pv").while().body("JsonPAyloadString").post("url").then().assertThat(). durumKodu(200);

NOT: Yükü/istek gövdesini String (yukarıdaki snippet'te gösterildiği gibi), JsonObject, Dosya vb. gibi " body " yönteminin içine geçirmenin farklı yolları vardır,

Güvende Olan PUT Talebi:

verilen().contentType("application/json").param("pk","pv").while().body("JsonPAyloadString").put("url").then().assertThat(). durumKodu(200);

Huzurlu ile isteği sil:

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

Ve bu şekilde farklı API fiilleri için farklı Rest API çağrısı oluşturabiliriz (GET/POST/PUT/DELETE vb.)

Java'da Serileştirme ve Seriyi Kaldırma:

Serileştirme, temel olarak nesne durumunu bir bayt akışına işleme veya dönüştürmedir. Öte yandan Java'daki Seriyi Kaldırma, bayt akışını bellekteki gerçek Java nesnesine işliyor veya dönüştürüyor. Bu mekanizma, Nesnenin kalıcılığında kullanılır.

Aşağıda aynı blok şeması 

Serileştirmenin Avantajları

A. Bir nesnenin durumunu kaydetmek/sürdürmek için.

B. Bir nesneyi bir ağ üzerinden akıtmak.

JAVA ile Serileştirmenin Sağlanması

Serileştirilebilir bir Java nesnesi elde etmek için Java.io.Serializable arabirimini uygulamamız gerekir.

Bir Nesneyi seri hale getirmekten sorumlu writeObject() yöntemini içeren ObjectOutputStream sınıfı.

ObjectInputStream sınıfı ayrıca, bir nesnenin serisini kaldırmaktan sorumlu olan readObject() adlı başka bir yöntem içerir.

Java.io.Serializable arabirimini uygulayan sınıflar, orada nesne yalnızca seri hale getirilebilir.

Serileştirilebilir yalnızca bir işaretleyici arabirimidir ve diğer pazar arabirimi gibi, onunla ilişkili hiçbir veri üyesi veya yöntemi yoktur. Java sınıflarını "işaretlemek" için kullanılır, böylece bu sınıfların nesneleri belirli yetenekler elde eder. Diğer birkaç işaretleyici arabirimi gibi: - Klonlanabilir ve Uzak vb.

NOTLAR:

1. Bir üst sınıf, Serileştirilebilir bir arabirim uyguladıysa, alt sınıfın aynısını uygulaması gerekmez, ancak bunun tersi geçerli değildir.

2. Serileştirme işlemiyle yalnızca statik olmayan veri üyeleri depolanır.

3. Statik veri üyeleri ve ayrıca geçici veri üyeleri Serileştirme tarafından saklanmıyor. Dolayısıyla, statik olmayan veri üyesinin değerini saklamamız gerekmiyorsa, bunu geçici hale getirebiliriz.

4. Yapıcı, bir nesnenin serisi kaldırıldığında asla çağrılmaz.

ADIM 1: İlk adım, temel olarak Serileştirilebilir arabirimi uygulayan bir sınıfın oluşturulmasıdır:

java.io.Serializable'ı içe aktarın;
public class Dummy, Serializable {
    özel int i;
    özel Dize verileri;
    public Dummy(int i, String verileri)
    {
        this.i = ben;
        this.data = veri;
    }
}

ADIM 2: Serileştirmek için bir sınıf oluşturun:

java.io.FileNotFoundException'ı içe aktarın;
java.io.FileOutputStream'i içe aktarın;
java.io.IOException'ı içe aktarın;
java.io.ObjectOutputStream'i içe aktarın;
public class Serileştirme {
    public static void Serileştirme(Object classObject, String fileName) {
        Deneyin {
            FileOutputStream fileStream = yeni FileOutputStream(fileName);
            ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);
            objectStream.writeObject(classObject);
            objectStream.close();
            fileStream.close();
        } yakalama (FileNotFoundException e) {
            // TODO Otomatik oluşturulan yakalama bloğu
            e.printStackTrace();
        } yakalama (IOException e) {
            // TODO Otomatik oluşturulan yakalama bloğu
            e.printStackTrace();
        }
    }
    public static void main (String [] args) {
        Kukla kuklaObj = new Kukla(10, "Lambda-geeks");
        Serileştirme(dummyObj, "DummSerialized");
    }
}

ADIM 3: Adım 2 başarıyla tamamlandığında, içinde bazı veriler bulunan bir dosyanın oluşturulduğunu göreceksiniz, bu veriler temelde Nesne üyelerinin serileştirilmiş verileridir.

  Java ile seri durumdan çıkarma:

İşte aşağıdaki kod parçası:

 public static Object DeSerialize(String fileName)
    {
        Deneyin {
            FileInputStream fileStream = yeni FileInputStream(yeni Dosya(dosyaAdı));
            ObjectInputStream objectStream = new ObjectInputStream(fileStream);
            Nesne deserializeObject = objectStream.readObject();
            objectStream.close();
            fileStream.close();
            deserializeObject döndür;
        } yakalama (FileNotFoundException e) {
            e.printStackTrace();
        } yakalama (IOException e) {
            e.printStackTrace();
        } yakalama (ClassNotFoundException e) {
            e.printStackTrace();
        }
        boş döndür;
    }

Sürücü Kodu şu şekildedir:

 public static void main (String [] args) {
      /* Dummy dummyObj = new Dummy(10, "Lambda-geeks");
        Serileştirme(dummyObj, "DummSerialized");
        System.out.println("------------------------------------------- ----------------------------------");
      */
        Dummy deSerializedRect = (Dummy) DeSerialize("DummSerialized");
        System.out.println("Serileştirilmiş Nesneden Veriler " + deSerializedRect.print());
        System.out.println("------------------------------------------- ----------------------------------");
    }

JSONPATH Daha Fazla Sözdizimi/Sorgu:

Aşağıdaki gibi bir JSON varsayalım:

{
  "OrganizationDetails": "Organizasyonun Sahte Ayrıntıları",
  "Bölge": "Asya",
  "Emp-Detayları": [
    {
      "Org": "lambda-Geeks",
      "Bilgi": {
        "Ph": 1234567890,
        "Ekle": "XYZ",
        "Yaş": 45
      }
    },
    {
      "Org": "lambda-Geeks-2",
      "Bilgi": {
        "Ph": 2134561230,
        "Ekle": "ABC",
        "Yaş": 35
      }
    }
  ]
}

Yukarıdaki JSON'da, OrganizationDetails & Region, daha fazla alt düğüme/elemana sahip olmamalarının nedeni olarak Yaprak düğümü olarak adlandırılır, ancak diğer yandan Emp-Details'in alt düğümü vardır, dolayısıyla Yaprak düğümü olarak anılmaz.

Burada, OrganisationDetails değerini almaya çalışırsak, o zaman şunu kullanmamız gerekir:

$.OrganizasyonAyrıntıları 
Bu, aşağıdakilerle sonuçlanacaktır:
 [
  "Organizasyonun Kukla Detayları"
]

Wise gibi bölge verilerini almak için şunu yazmamız gerekiyor:

$.Bölge 

1. Çalışan için Yaş değerini bulmak istiyorsak şunu yazabiliriz:

$.Emp-Details[0].Information.Age
Bu, aşağıdakilerle sonuçlanacaktır:
[
  45
]

2. Çalışanın Yaşı için şöyle yazabiliriz:

$.Emp-Details[1].Information.Age
Bunun sonucunda: [ 35 ]

Bu şekilde, JSON'daki ilgili alanların verilerini almak için JsonPath ifadesini/sorgusunu bulabiliriz.

En gidin