Pengujian Rest API || Panduan Cepat untuk tutorial RestAssured 2020

Pengujian Rest Assured API untuk otomatisasi Pengujian Rest API

RestAssured -Pastikan pengujian api tutorial
Otomatisasi API yang Terjamin

Dalam tutorial lengkap Rest Assured ini kita akan mempelajari Rest API Testing secara mendalam, API Test Automation bersama Rest Assured dalam pendekatan modularised

Apa itu RestAssured dan penggunaannya

Rest Assured adalah teknologi open source yang sangat banyak digunakan untuk Pengujian Otomasi REST API, ini didasarkan pada perpustakaan berbasis java.

Rest Assured berinteraksi dengan Rest API dalam mode klien tanpa kepala, kita dapat meningkatkan permintaan yang sama dengan menambahkan lapisan yang berbeda untuk membentuk permintaan dan membuat permintaan HTTP melalui kata kerja HTTPS yang berbeda ke server.

Perpustakaan bawaan Rest Assured menyediakan metode dan utilitas yang sangat besar untuk melakukan validasi respons yang diterima dari server seperti pesan status, kode status, dan isi respons.

Seri lengkap Rest Assured Tutorial untuk Pengujian Otomasi REST API terdiri dari topik-topik berikut:

Memulai: Konfigurasi restAssured dengan Build tool yaitu Maven / gradle

LANGKAH 1: Jika Anda bekerja dengan maven cukup tambahkan dependensi berikut di pom.xml (Anda juga dapat memilih versi lain):

Untuk memulai REST Assured, cukup tambahkan dependensi ke project Anda. 


    i. yakinlah
    yakinlah
    4.3.0
    uji

Jika Anda bekerja dengan gradle, cukup tambahkan yang berikut ini di build.gradle (sekali lagi Anda dapat memilih versi lain juga):

grup testCompile: 'io.rest -ured', nama: 'rest -ured', versi: '4.3.0'

LANGKAH 2: REST Dijamin dapat diintegrasikan dan digunakan dengan sangat mudah dengan kerangka kerja pengujian unit yang ada yaitu Testng, JUnit

Di sini kami menggunakan testNg sesuai Unit Test Framework yang bersangkutan.

Setelah pustaka Rest Assured diimpor maka kita perlu menambahkan impor statis berikut ke kelas pengujian kita:

impor statis io.restassured.RestAssured. *;

impor org.hamcrest.Matchers statis. *;

CATATAN: Untuk tujuan pembelajaran yang akan datang ini, kami akan menguji API Pengembang Ergast, yang dapat ditemukan di sini. API ini menyediakan data historis terkait balapan Formula 1, pembalap, sirkuit, dll.

Keakraban dengan Sintaks:

Rest Assured mendukung format BDD (Sintaks Gherkin) untuk menulis skrip tes yaitu dalam format Diberikan / Kapan / Kemudian / Dan, Kami berasumsi bahwa Anda telah memahami sintaks BDD / gherkin, jika tidak maka kami sarankan untuk meluangkan waktu 30 menit untuk memahami apa itu BDD (Sintaks Gherkin) dan bagaimana cara kerjanya dan dasarnya.

T-01: Skrip pertama kami yang pada dasarnya memvalidasi jumlah sirkuit di F1 pada tahun 1 menggunakan API ini (http://ergast.com/api/f1/2017/circuits.json)

@Test (description = "Jumlah Sirkuit Pada Musim 2017 Seharusnya 20") public void validatingNumberOfCircuits () {given (). When (). Get ("http://ergast.com/api/f1/2017/circuits. json "). kemudian (). assertThat (). body ("MRData.CircuitTable.Circuits.circuitId", hasSize (20)); }

Validasi respons rest API :

1. Menangkap respons JSON dari permintaan API.

2. Kueri untuk circuitId menggunakan ekspresi GPath "MRData.CircuitTable.Circuits.circuitId"

3. Memverifikasi bahwa kumpulan elemen circuitId memiliki ukuran 20

Di sini kami menggunakan Pencocok Hamcrest untuk berbagai validasi seperti

  • equalTo () memvalidasi kesetaraan
  • lessThan () dan lebih besarThan () metode untuk validasi komparatif,
  • Metode hasItem () digunakan untuk memvalidasi keberadaan elemen dari kumpulan elemen.

Ada berbagai metode lain yang berguna untuk melakukan validasi tertentu.

Anda selanjutnya dapat merujuk ke dokumentasi pustaka Hamcrest untuk daftar lengkap matcher dan metode.

Memvalidasi Kode Tanggapan:

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

Validasi Jenis Konten

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

Memvalidasi tajuk "Panjang Konten"

diberikan (). when (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header (" Content-Length ", equalTo (" 4551 "));

Beberapa Validasi dalam satu Pengujian sebagai (Dengan menggunakan dan () metode):

@Test (description = "Jumlah Sirkuit Pada Musim 2017 Seharusnya 20")
    public void validatingNumberOfCircuits () {
        diberikan (). when (). get ("http://ergast.com/api/f1/2017/circuits.json") .then (). assertThat (). header ("Content-Length", equalTo (" 4551 ")). Dan (). StatusCode (200);
    }

Memvalidasi elemen / atribut Badan Respons:

Kita dapat menggunakan JsonPath untuk mengambil nilai atribut json dan memberikan pernyataan menggunakan TestNg

@Test (description = "Validasi nama seri yaitu f1")
    public void validatingSeriesName () {
        // Ubah ResponseBody menjadi String
        String responseBody = given (). When (). Get ("http://ergast.com/api/f1/2017/circuits.json") .getBody (). AsString ();
        // Buat Objek JsonPath dengan Meneruskan Badan Respons sebagai string
        JsonPath resJson = JsonPath baru (responseBody);
        // Ambil rangkaian nilai atribut di bawah MRData
        String seriesName = resJson.getString ("MRData.series");
        // Pernyataan TestNg Pengguna
        Assert.assertEquals ("f1", seriesName);
    }

Dengan cara yang sama kita bisa mendapatkan nilai respon XML menggunakan XMLPath. Di sini kita bekerja dengan JSON maka kita menggunakan JSonPath.

RESTful API hanya mendukung dua jenis parameter:

A. Parameter kueri: Di sini parameter ditambahkan di akhir titik akhir API dan dapat diidentifikasi dengan tanda tanya dan membentuk pasangan nilai kunci seperti 

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

Di sini, di API di atas 'q' adalah parameter dan 'https://www.wikipedia.org/' adalah nilai parameter itu, jika kita mencari 'SOMETHING_ELSE_TEXT'kita bisa mengganti nilai parameter 'q' dengan 'SOMETHING_ELSE_TEXT'menggantikan https://www.wikipedia.org/.

B. Parameter jalur: Ini adalah bagian dari titik akhir RESTful API. 

misalnya. endpoint yang kita gunakan sebelumnya: http://ergast.com/api/f1/2017/circuits.json, di sini "2017" adalah nilai parameter jalur.

Untuk mendapatkan hasil tahun ini 2016 bisa kita ganti 2017 dengan 2016 maka API akan memberikan badan respons untuk 2016.

Pengujian menggunakan Path Params for RestAssured

@Test (description = "Validasi jumlah Sirkuit menggunakan Parameter Jalur")
    public void testWithPathParams () {
        String seasonNumber = "2017";
       String responseBody = given (). PathParam ("season", seasonNumber) .when (). Get ("http://ergast.com/api/f1/{season}/circuits.json") .getBody (). AsString ();
        // Buat Objek JsonPath dengan Meneruskan Badan Respons sebagai string
        JsonPath resJson = JsonPath baru (responseBody);
        // Ambil rangkaian nilai atribut di bawah MRData
        String seriesName = resJson.getString ("MRData.series");
        // Pernyataan TestNg Pengguna
        Assert.assertEquals ("f1", seriesName);
    }

Menguji menggunakan Parameter Kueri untuk RestAssured

@Test (description = "Validasi pencarian Google menggunakan Query Params")
    public void testWithPathParams () {
        String searchItem = "https://www.wikipedia.org/";
  diberikan (). queryParam ("q", searchItem) .when (). get ("https://www.google.com/search") .then (). assertThat (). statusCode (200);
    }

Tes parameterisasi:

Kita dapat melakukan pengujian berdasarkan data (yaitu skrip pengujian yang sama akan dijalankan beberapa kali dengan set data input yang berbeda dan memberikan data keluaran yang berbeda) menggunakan Rest Assured 

LANGKAH 1: Membuat Penyedia Data testNg.

LANGKAH 2: Gunakan Penyedia Data dalam skrip Uji.

@DataProvider (name = "seasonAndRaceNumbers")
    Objek publik [] [] testDataFeed () {
        kembalikan Objek baru [] [] {
                {"2017", 20},
                {"2016", 21}
        };
    }
@Test (description = "Validasi Jumlah Sirkuit di Musim yang berbeda", dataProvider = "seasonAndRaceNumbers") public void circuitNumberValidation (String seasonYear, int raceNumbers) {given ().pathParam ("season", seasonYear) .when (). get ("http://ergast.com/api/f1/{musim}/circuits.json "). lalu (). assertThat (). body (" MRData.CircuitTable.Circuits.circuitId ", hasSize (nomor balapan)); }

Bekerja dengan parameter Multi -valued dengan RestAssured 

Parameter multi-nilai adalah parameter yang memiliki lebih dari satu nilai per nama parameter (yaitu daftar nilai per paramKey), kita dapat mengatasinya seperti di bawah ini:

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

Atau kita bisa menyiapkan daftar dan meneruskan daftar sebagai nilai paramKey seperti:

Daftar paramValue = ArrayList baru ();
paramValue.add (“paramvalue1”);
paramValue.add (“paramvalue2);
diberikan (). param ("paramKey", paramValue) .when (). get (“URL API“);
Bekerja dengan cookie dengan RestAssured 
diberikan (). cookie ("cookieK", "cookieVal"). when (). get ("API URL");

Or 

Kami juga dapat menentukan cookie multi-nilai di sini seperti:

diberikan (). cookie ("cookieK", "cookieVal1", "cookieVal2"). when (). get (“URL API”);

Bekerja dengan Header:

Kami dapat menentukan dalam permintaan menggunakan header / header seperti:

diberikan (). header ("headerK1", "headerValue1"). header ("headerK2", "headerValue2"). when (). get ("API URL");

Bekerja dengan contentType:

diberikan (). contentType ("application / json"). when (). get ("API URL");

Or 

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

Ukur Waktu Respons:

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

Istirahatkan Otentikasi API

REST terjamin mendukung berbagai skema autentikasi, misalnya OAuth, intisari, sertifikat, formulir, dan autentikasi dasar preemptive. Kami juga dapat mengatur otentikasi untuk setiap permintaan 

berikut ini contoh permintaan menggunakan yang sama:

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

Di sisi lain otentikasi dan didefinisikan dalam pendekatan di bawah ini untuk permintaan HTTP:

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

Jenis AUTH Dasar:

Ada dua jenis autentikasi dasar, "preemptive" dan "challenge basic authentication".

Otorisasi Dasar Preemptif:

Ini akan mengirimkan kredensial otentikasi dasar bahkan sebelum server memberikan respons yang tidak sah dalam situasi tertentu bersama dengan permintaan yang dipicu, sehingga mengurangi overhead pembuatan koneksi tambahan. Ini biasanya terjadi dalam situasi besar kecuali kami sedang menguji kemampuan server untuk menantang. 

Misalnya.

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

Otentikasi Dasar Tertantang

Di sisi lain "otentikasi dasar yang ditantang" REST Assured tidak akan memberikan kredensial kecuali server telah secara eksplisit memintanya, yaitu server melemparkan Tanggapan Tidak Sah. Setelah respons UnAuthorized Rest-Assured mengirimkan permintaan lain ke server yang merupakan Auth.

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

Otentikasi Intisari

Saat ini hanya "otentikasi intisari yang ditantang" yang sedang dipertimbangkan. misalnya:

given (). auth (). digest ("uName", "pwd"). when (). get ("URL"). then (). statusCode (200); 

Formulir Otentikasi

Kami dapat mencapai ini sebagian besar dalam 3 pendekatan berbeda tergantung pada Aplikasi / Skenario:

Otentikasi formulir adalah salah satu yang sangat populer melalui internet di mana pengguna memasukkan kredensial yaitu nama pengguna & kata sandi melalui halaman web dan masuk ke sistem. Ini bisa diatasi dengan menggunakan ini 

diberikan (). auth (). form ("uName", "pWd").
when (). get ("URL");
kemudian (). statusCode (200);

Meskipun ini mungkin tidak berfungsi karena optimal dan mungkin berhasil atau gagal tergantung pada kompleksitas halaman web. Pilihan yang lebih baik adalah memberikan detail ini saat menyiapkan otentikasi formulir dengan pendekatan di bawah ini:

given (). auth (). form ("uName", "pwd", new FormAuthConfig ("/ 'sebutkan di sini nama tindakan formulir yang merupakan bagian dari kode halaman html di bawah tag formulir'", "uName", "pwd ")). when (). get (" URL "). then (). statusCode (200);

Dalam pendekatan ini, REST Assured secara internal tidak perlu memicu permintaan tambahan dan mengurai melalui halaman web. 

Jika seandainya Anda menggunakan Keamanan Musim Semi default maka FormAuthConfig yang telah ditentukan dipicu.

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

CATATAN: Jika kita ingin mengirimkan data input tambahan beserta form auth maka kita dapat menulis di bawah ini:

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

CSRF:

CSRF adalah singkatan dari pemalsuan permintaan lintas situs.

Saat ini sangat umum bagi server untuk memberikan token CSRF dengan respons untuk menghindari serangan keamanan CSRF. REST Assured mendukung ini dengan menggunakan dan parser otomatis serta menyediakan token CSRF. 

Untuk mencapai REST Assured ini perlu membuat permintaan tambahan dan mengurai (beberapa posisi) dari situs web.

Kami dapat mengaktifkan dukungan CSRF dengan menulis kode di bawah ini:

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

Selain membantu REST Assured dan membuat penguraian lebih sempurna dan kuat, kami dapat menyediakan nama bidang CSRF (di sini kami mengasumsikan bahwa kami menggunakan nilai default Keamanan Musim Semi dan kami dapat menggunakan springSecurity FormAuthConfig yang telah ditentukan):

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

Secara default nilai CSRF dikirimkan sebagai parameter formulir dengan permintaan tetapi kita dapat mengkonfigurasi untuk mengirimkannya sebagai header jika diperlukan seperti di bawah ini:

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

OAuth 1:

OAuth 1 mengharuskan Scribe berada di classpath. Untuk menggunakan otentikasi oAuth 1 kita dapat melakukan:

diberikan (). auth (). oauth (..). when (). ..

OAuth 2:

diberikan (). auth (). oauth2 (accessToken) .when (). ..

Dalam pendekatan di atas, accessToken OAuth2 akan dipertimbangkan di header. Agar lebih eksplisit kita juga bisa melakukan:

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

Meneruskan File, byte-array, input stream atau teks dalam Request:

Saat mengirim data dalam jumlah besar ke server, umumnya pendekatan umum untuk menggunakan teknik data formulir multi bagian. Rest Assured menyediakan metode yang disebut multiPart yang memungkinkan kita menentukan file, byte-array, input stream, atau teks yang akan diunggah. 

given (). multiPart (File baru ("/ File_Path")). when (). post ("/ upload");

Pembuatan Permintaan POST dengan Rest Assured

Dengan permintaan POST dan PUT, kami mengirim Data ke Server dan pada dasarnya pembuatan sumber daya / pembaruan sumber daya, Anda dapat menganggap ini sebagai operasi tulis atau pembaruan.

Data yang dikirim ke server dalam permintaan POST dikirim di badan permintaan HTTP / panggilan API. 

Jenis konten atau data yang sedang dikirim dapat dalam format yang berbeda tergantung pada API, misalnya XML, JSON atau beberapa format lain yang ditentukan oleh header Jenis Konten. 

Jika badan POST terdiri dari data JSON maka header Jenis Konten akan menjadi application / json. Demikian pula, untuk permintaan POST yang terdiri dari XML maka header Jenis Konten akan menjadi jenis aplikasi / xml.

Berikut adalah potongan kode di bawah ini untuk hal yang sama:

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

CATATAN: Ada beberapa cara berbeda untuk mengirimkan payload / request body di dalam metode "body" seperti String (seperti yang ditunjukkan di cuplikan di atas), JsonObject, sebagai File, dll.,

Permintaan PUT dengan Jaminan Istirahat:

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

Hapus permintaan dengan Rest-Assured:

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

Dan dengan cara itu kita dapat membuat panggilan Rest API yang berbeda untuk kata kerja API yang berbeda (GET / POST / PUT / DELETE dll)

Serialisasi dan Deserialisasi di Jawa:

Serialisasi pada dasarnya adalah memproses atau mengubah keadaan objek menjadi aliran byte. Di sisi lain, Deserialization di Java sedang memproses atau mengubah aliran byte menjadi objek Java yang sebenarnya di dalam memori. Mekanisme ini digunakan dalam persistensi Object.

Di bawah ini adalah diagram blok untuk hal yang sama 

Pengujian Rest API || Panduan Cepat untuk tutorial RestAssured 2020

Keuntungan dari Serialisasi

A. Untuk menyimpan / mempertahankan status suatu objek.

B. Untuk mengalirkan suatu objek melintasi jaringan.

Mencapai Serialisasi dengan JAVA

Untuk mencapai objek Java serializable kita perlu mengimplementasikan antarmuka java.io.Serializable.

Kelas ObjectOutputStream yang berisi metode writeObject () yang bertanggung jawab untuk membuat serial Object.

Kelas ObjectInputStream juga berisi metode lain yang disebut readObject () yang bertanggung jawab untuk deserialisasi objek.

kelas yang mengimplementasikan antarmuka java.io.Serializable, di sana objek hanya dapat diserialkan.

Serializable hanyalah antarmuka penanda dan seperti antarmuka pasar lainnya, ia tidak memiliki anggota data atau metode yang terkait dengannya. Yang digunakan untuk "menandai" kelas java sehingga objek dari kelas ini akan mendapatkan kemampuan tertentu. Seperti beberapa antarmuka penanda lainnya adalah: - Dapat Dikloning dan Jauh, dll.

CATATAN:

1. Jika kelas induk telah mengimplementasikan antarmuka Serializable maka kelas anak tidak diperlukan untuk mengimplementasikan yang sama tetapi sebaliknya tidak berlaku.

2. Hanya anggota data non-statis yang disimpan dengan proses Serialisasi.

3. Data statik member dan juga anggota data transient tidak disimpan oleh Serialisasi. Jadi, jika kita tidak perlu menyimpan data non-statik member value maka kita bisa membuatnya transient.

4. Pembuat tidak pernah dipanggil jika suatu objek dideserialisasi.

LANGKAH 1: Langkah pertama pada dasarnya adalah pembuatan kelas yang mengimplementasikan antarmuka Serializable:

impor java.io.Serializable;
public class Dummy mengimplementasikan Serializable {
    int pribadi saya;
    data String pribadi;
    public Dummy (int i, String data)
    {
        ini.i = i;
        this.data = data;
    }
}

LANGKAH 2: Buat kelas untuk membuat serialnya:

impor java.io.FileNotFoundException;
impor java.io.FileOutputStream;
impor java.io.IOException;
impor java.io.ObjectOutputStream;
public class Serialize {
    public static void Serialization (Object classObject, String fileName) {
        coba {
            FileOutputStream fileStream = FileOutputStream baru (fileName);
            ObjectOutputStream objectStream = baru ObjectOutputStream (fileStream);
            objectStream.writeObject (classObject);
            objectStream.close ();
            fileStream.close ();
        } menangkap (FileNotFoundException e) {
            // TODO Blok tangkapan yang dibuat secara otomatis
            e.printStackTrace ();
        } tangkap (IOException e) {
            // TODO Blok tangkapan yang dibuat secara otomatis
            e.printStackTrace ();
        }
    }
    public static void main (String [] args) {
        Dummy dummyObj = Dummy baru (10, "Lambda-geeks");
        Serialisasi (dummyObj, "DummSerialized");
    }
}

LANGKAH 3: Setelah Langkah2 berhasil diselesaikan maka Anda akan melihat file dibuat dengan beberapa data di dalamnya, data tersebut pada dasarnya adalah data serial dari anggota Objek.

  Deserialisasi dengan java:

Berikut adalah potongan kode di bawah ini:

 DeSerialize Objek statis publik (String nama file)
    {
        coba {
            FileInputStream fileStream = FileInputStream baru (File baru (fileName));
            ObjectInputStream objectStream = baru ObjectInputStream (fileStream);
            Objek deserializeObject = objectStream.readObject ();
            objectStream.close ();
            fileStream.close ();
            kembali deserializeObject;
        } menangkap (FileNotFoundException e) {
            e.printStackTrace ();
        } tangkap (IOException e) {
            e.printStackTrace ();
        } menangkap (ClassNotFoundException e) {
            e.printStackTrace ();
        }
        kembali nol;
    }

Kode Pengemudi seperti ini:

 public static void main (String [] args) {
      / * Dummy dummyObj = Dummy baru (10, "Lambda-geeks");
        Serialisasi (dummyObj, "DummSerialized");
        System.out.println ("------------------------------------------- ------------------------------- ");
      */
        Dummy deSerializedRect = (Dummy) DeSerialize ("DummSerialized");
        System.out.println ("Data Dari Objek Serial" + deSerializedRect.print ());
        System.out.println ("------------------------------------------- ------------------------------- ");
    }

JSONPATH Lebih Banyak Sintaks / Query:

Mari Asumsikan JSON seperti di bawah ini:

{
  "OrganizationDetails": "Dummy Details of the Organization",
  "Wilayah": "Asia",
  "Emp-Details": [
    {
      "Org": "lambda-Geeks",
      "Informasi": {
        "Ph": 1234567890,
        "Tambahkan": "XYZ",
        "Umur": 45
      }
    },
    {
      "Org": "lambda-Geeks-2",
      "Informasi": {
        "Ph": 2134561230,
        "Tambahkan": "ABC",
        "Umur": 35
      }
    }
  ]
}

di JSON di atas, OrganizationDetails & Region disebut sebagai node Leaf karena mereka tidak memiliki node / elemen turunan lebih lanjut tetapi seperti di sisi lain Emp-Details memiliki node turunan, oleh karena itu tidak disebut node Leaf.

Di sini jika kita mencoba mendapatkan nilai OrganizationDetails maka kita perlu menggunakan:

$ .OrganizationDetails 
Ini akan menghasilkan:
 [
  "Detail Dummy Organisasi"
]

Seperti Wise untuk mendapatkan data untuk wilayah yang perlu kita tulis:

$ .Region 

Jika kita ingin mencari nilai Age for the 1st Employee maka kita bisa menulis:

$ .Emp-Details [0] .Information.Age
Ini akan menghasilkan:
[
  45
]

Untuk Age of the 2nd Employee kita bisa menulis seperti

$ .Emp-Details [1] .Information.Age
Ini akan menghasilkan: [35]

Dengan cara ini kita dapat mengetahui ekspresi / kueri JsonPath untuk mengambil data untuk masing-masing bidang di JSON.

Tentang Debarghya

Pengujian Rest API || Panduan Cepat untuk tutorial RestAssured 2020Saya sendiri Debarghya Roy, saya seorang Engineering ARCHITECT yang bekerja dengan perusahaan fortune 5 dan kontributor open source, memiliki sekitar 12 tahun pengalaman / keahlian dalam berbagai tumpukan Teknologi.
Saya telah bekerja dengan berbagai teknologi seperti Java, C #, Python, Groovy, UI Automation (Selenium), Mobile Automation (Appium), API / Backend Automation, Performance Engineering (JMeter, Locust), Security Automation (MobSF, OwAsp, Kali Linux , Astra, ZAP dll), RPA, Otomasi Rekayasa Proses, Otomasi Mainframe, Pengembangan Back End dengan SpringBoot, Kafka, Redis, RabitMQ, ELK stack, GrayLog, Jenkins dan juga memiliki pengalaman dalam Cloud Technologies, DevOps dll.
Saya tinggal di Bangalore, India bersama istri saya dan memiliki hasrat terhadap Blogging, musik, bermain gitar dan Filosofi hidup saya adalah Pendidikan untuk Semua yang melahirkan LambdaGeeks. Mari terhubung melalui linked-in - https://www.linkedin.com/in/debarghya-roy/

en English
X