Alternatif Penulis Drama untuk Ujian API

Jika anda seorang SDET yang telah menggunakan Playwright untuk ujian API, anda mungkin terlalu biasa dengan kekecewaan menangani kebergantungan pangkalan data, pengurusan data dan keperluan pembersihan yang tidak berkesudahan. Mari kita hadapi itu - Penulis drama, walaupun hebat untuk ujian UI, boleh menyusahkan apabila melibatkan ujian API. Tetapi bagaimana jika ada cara yang lebih baik untuk menangani perkara ini?

Dalam siaran ini, saya akan menunjukkan kepada anda cara menukar kepada Keploy, alat ujian API sumber terbuka dan alternatif penulis drama terbaik apabila ia berkaitan dengan Pengujian API dan API Mock. Jika anda ingin menyelaraskan proses ujian anda dan menghapuskan sakit kepala pangkalan data, teruskan. Penghijrahan ini boleh menjadi penukar permainan yang anda tunggu-tunggu.

Gambaran Keseluruhan Penulis Drama untuk Ujian API

Ujian Penulis Drama dicipta khusus untuk menampung keperluan ujian hujung ke hujung. Ia popular untuk mengautomasikan interaksi penyemak imbas dan telah memperluaskan keupayaannya kepada ujian API. Ciri ujian API Playwright membolehkan anda membuat permintaan HTTP, mengesahkan respons dan juga titik akhir mengejek. Tetapi apabila anda bergantung pada Playwright untuk ujian API dalam persekitaran yang kompleks, cabaran akan bertambah dengan cepat.

Walaupun Penulis Drama adalah alat yang kukuh, ini adalah beberapa sebab saya menghadapi masalah:

• Persediaan Mock Manual: Dengan Penulis Drama, anda perlu mentakrifkan respons olok-olok secara manual untuk setiap interaksi API. Ini melibatkan penyediaan laluan dengan page.route() atau memintas permintaan rangkaian menggunakan lekapan, yang boleh menjadi berulang dan terdedah kepada ralat. Untuk aplikasi besar dengan banyak titik akhir, ini membawa kepada sejumlah besar kod yang mesti diurus dan diselenggara.

• Liputan Mungkin Tidak Komprehensif: Memandangkan Playwright memfokuskan pada ujian hujung ke hujung dan mensimulasikan interaksi pengguna, ada kemungkinan hanya kod UI sedang diuji dan logik asas ( Panggilan API, pemprosesan bahagian belakang) mungkin tidak dilindungi sepenuhnya.

• Ujian Persediaan Overhed: Menyediakan persekitaran ujian dalam Playwright, terutamanya apabila mengejek panggilan API, sangat memakan masa. Memandangkan persediaan ini melibatkan konfigurasi laluan, respons dan data, memerlukan masa dan usaha tambahan sebelum menjalankan ujian sebenar.

• Ujian Lambat Berjalan: Mensimulasikan respons API secara manual dalam Playwright selalunya melibatkan penyediaan sejumlah besar ejekan untuk titik akhir dan respons yang berbeza. Ini menambah masa pelaksanaan, kerana setiap ujian mesti melalui berbilang interaksi yang dipermainkan dan pengendalian sejumlah besar ejekan boleh melambatkan proses, terutamanya untuk suite ujian yang besar.

• Integrasi Terhad dengan Logik Bahagian Belakang: Penulis drama direka untuk menumpukan pada interaksi penyemak imbas, bukan pada ujian API atau bahagian pelayan. Akibatnya, jika anda menguji interaksi yang bergantung pada API atau perkhidmatan bahagian belakang, ia tidak secara semula jadi menawarkan keterlihatan sama ada kod hujung belakang anda dilindungi sepenuhnya.

• Isu Pengasingan Ujian: Ujian pengarang drama selalunya memerlukan data sebenar atau dipermainkan dan menyediakan pengasingan ujian yang betul boleh menjadi rumit, terutamanya apabila bergantung pada pangkalan data luaran, perkhidmatan atau API pihak ketiga.

Apabila masalah ini timbul, saya mula mencari penyelesaian yang boleh menjadikan ujian API lebih mudah dan lebih cekap. Di situlah Keploy muncul dalam gambar.

Mengapa Berhijrah ke Keploy?

Keploy ialah alat yang hebat untuk ujian API yang turut membantu dalam mencipta olok-olok/stub data. Tidak seperti Playwright, yang sering memerlukan persediaan yang kompleks untuk pengurusan pangkalan data dan penciptaan data ujian, Keploy mengautomasikan banyak proses ini. Inilah sebabnya untuk saya berhijrah ke Keploy masuk akal:

1. Tiada Lagi Persediaan Mock Manual

   Keploy mengeluarkan kerja keras menulis kod ujian API berulang. Daripada mentakrifkan permintaan, respons dan data olok-olok secara manual, Keploy menangkap interaksi API sebenar dan membolehkan anda memainkannya semula kemudian. Ini menghapuskan keperluan untuk kod ujian yang meluas dan secara drastik mengurangkan masa yang dihabiskan untuk membuat ujian.

2. Tiada Ketergantungan Pangkalan Data
   
   Keploy merekodkan interaksi API sebenar dan memainkannya semula untuk ujian masa hadapan, bermakna anda tidak lagi memerlukan pangkalan data langsung untuk melaksanakan ujian. Ini menghapuskan overhed untuk mengekalkan pangkalan data yang sedang berjalan dan membersihkannya selepas setiap ujian.

3. Fa*steri Pelaksanaan Ujian*

   Memandangkan Keploy tidak memerlukan menyediakan atau merobohkan pangkalan data, pelaksanaan ujian menjadi lebih pantas. Dengan ujian yang telah direkodkan, keperluan untuk menyediakan data ujian atau berinteraksi dengan pangkalan data adalah perkara yang sudah berlalu.

4. Integrasi Mudah dengan CI/CD

   Keploy berintegrasi dengan lancar dengan saluran paip CI/CD, memberikan maklum balas yang lebih pantas dan meningkatkan produktiviti keseluruhan. Anda boleh menjalankan ujian API yang direkodkan dengan mudah sebagai sebahagian daripada proses penyepaduan berterusan anda tanpa perlu risau tentang keadaan pangkalan data atau persediaan ujian manual.

5. Liputan Ujian Komprehensif

   Memandangkan Keploy merekodkan interaksi API dunia sebenar, anda boleh mencapai liputan ujian yang lebih tepat dan lengkap. Dengan memainkan semula interaksi yang dirakam ini, Keploy boleh mensimulasikan kes kelebihan dunia sebenar yang mungkin tidak dapat ditangkap sepenuhnya dengan ujian bertulis secara manual.

Langkah-langkah untuk Berhijrah daripada Penulis Drama ke Keploy

Kami akan menjalankan aplikasi pengurusan pengguna yang mudah dalam NextJS dengan Postgres sebagai pangkalan data untuk panduan ini.

Langkah 1: Menilai Persediaan Ujian API Semasa Anda

Sebelum menyelami migrasi, saya terlebih dahulu menilai ujian API sedia ada yang telah saya tulis dalam Playwright. Ini termasuk:

• Menyemak semua permintaan dan respons API yang saya uji.

• Mendokumentasikan persediaan yang diperlukan untuk setiap ujian (seperti keadaan pangkalan data dan data palsu).

• Menjalankan suite ujian penuh untuk menyemak sebarang isu sedia ada dan mengumpulkan data liputan ujian.

Ujian penulis drama untuk aplikasi saya terdapat dalam app.spec.ts di bawah folder ujian.

import { test, expect } from '@playwright/test';

const apiUrl = 'http://localhost:3000/api/users';  // Application is running on port 3000

test.describe('User API Tests', () => {

    // Test GET request (Fetch all users)
    test('GET /api/users should return a list of all users', async ({ request }) => {
        const response = await request.get(apiUrl);
        expect(response.status()).toBe(200);  // Ensure status code is 200
        const body = await response.json();
        expect(body.users).toBeInstanceOf(Array);
    });    
});

Setelah saya memahami dengan jelas situasi ujian semasa saya, tiba masanya untuk bergerak.

Langkah 2: Pasang Keploy dan Sediakan Persekitaran

Langkah seterusnya ialah memasang Keploy dalam persekitaran ujian saya. Proses pemasangan Keploy adalah mudah dan mudah, dengan arahan terperinci tersedia dalam repositori Keploy GitHub. Selepas pemasangan, kami boleh mengesahkan persediaan dengan menjalankan semakan pantas di terminal:

Ini mengesahkan bahawa Keploy telah dipasang dengan betul dan sedia untuk digunakan.

Langkah 3: Rekod Interaksi API dengan Keploy

Keploy berfungsi dengan merekodkan interaksi API sebenar yang berlaku semasa pelaksanaan ujian. Untuk menangkap interaksi ini, kita perlu menjalankan ujian Playwright saya seperti biasa, tetapi kali ini dengan Keploy dalam mod rakaman. Begini cara saya menyediakannya:

1. Mulakan aplikasi dan pangkalan data anda menggunakan Docker Compose atau persediaan lain.

2. Jalankan Keploy dalam mod rekod untuk menangkap interaksi API sebenar:
   

keploy record -c "npm run dev"

Arahan ini mengarahkan Keploy untuk menangkap semua permintaan dan respons HTTP yang dijana oleh ujian Playwright.

Jom jalankan testsuite penulis drama kami -

Kami dapat melihat keploy merekodkan setiap kes ujian yang merupakan sebahagian daripada testsuite sedia ada yang ditulis dalam pengarang drama.

Setiap kes ujian yang dijana oleh Keploy ialah kes ujian Playwrigth: –

test('POST /api/users should create a new user', async ({ request }) => {
        const newUser = {
            name: 'John Do',
            email: 'johndoee@xyz.com'
        };

        const response = await request.post(apiUrl, {
            data: newUser
        });

        expect(response.status()).toBe(200);  // Ensure status code is 200
        const body = await response.json();
        expect(body.users[0]).toHaveProperty('id');  // Check if the first user in the array has an ID
        expect(body.users[0].name).toBe(newUser.name);
        expect(body.users[0].email).toBe(newUser.email);
    });


    // Test PUT request (Update an existing user)
    test('PUT /api/users should update an existing user', async ({ request }) => {
        // First, create a new user to update
        const newUser = {
            name: 'Jane Doe',
            email: 'janedoe@example.com'
        };

        let response = await request.post(apiUrl, {
            data: newUser
        });

        // Check if the POST request was successful
        expect(response.status()).toBe(200); // Ensure status code is 200
        const createdUser = await response.json();
        expect(createdUser.users).toHaveLength(1);
        const userId = createdUser.users[0].id;

        // Prepare the updated user data
        const updatedUser = {
            id: userId,
            name: 'John Deo',
            email: 'updated@example.com'
        };

        // Make the PUT request to update the user
        response = await request.put(apiUrl, {
            data: updatedUser
        });

        // Check if the PUT request was successful
        expect(response.status()).toBe(200);
        const body = await response.json();

        // Check if the updated fields match the new values
        expect(body.users[0].name).toBe(updatedUser.name);
        expect(body.users[0].email).toBe(updatedUser.email);
    });    

    // Test DELETE request (Delete a user)
    test('DELETE /api/users should delete a user', async ({ request }) => {
        // First, create a user to delete
        const newUser = {
            name: 'Mark Doe',
            email: 'markdoe@example.com'
        };

        let response = await request.post(apiUrl, {
            data: newUser
        });

        // Check if the response body is empty or invalid
        if (!response.ok()) {
            console.error('Failed to create user', await response.text());
            expect(response.ok()).toBe(true);  // Fail the test if the response is not OK
        }

        const createdUser = await response.json();
        if (!createdUser || !createdUser.users || createdUser.users.length === 0) {
            console.error('Invalid response format:', createdUser);
            throw new Error('Created user response format is invalid');
        }

        const userId = createdUser.users[0].id;  // Accessing the ID of the newly created user

        // Delete the created user
        response = await request.delete(apiUrl, {
            data: { id: userId }  // Sending the ID of the user to be deleted
        });

        // Check if the delete response is valid
        expect(response.status()).toBe(200);  // Ensure status code is 200
        const body = await response.json();
        expect(body.users[0].id).toBe(userId);  // Ensure the correct user is deleted
    });

Langkah 4: Main Semula Interaksi yang Dirakam sebagai Ujian

Setelah interaksi direkodkan, Keploy menjana kes ujian yang sepadan secara automatik. Di bawah ialah salah satu kes ujian keploy tersebut: –

Ujian ini boleh dijalankan secara bebas tanpa memerlukan sebarang kebergantungan luaran seperti pangkalan data langsung. Apa yang saya perlu lakukan ialah menjalankan suite ujian Keploy:

import { test, expect } from '@playwright/test';

const apiUrl = 'http://localhost:3000/api/users';  // Application is running on port 3000

test.describe('User API Tests', () => {

    // Test GET request (Fetch all users)
    test('GET /api/users should return a list of all users', async ({ request }) => {
        const response = await request.get(apiUrl);
        expect(response.status()).toBe(200);  // Ensure status code is 200
        const body = await response.json();
        expect(body.users).toBeInstanceOf(Array);
    });    
});

Arahan ini mencetuskan main balik interaksi yang dirakam, menguji API tanpa memerlukan pangkalan data sebenar.

Kesimpulan

Perpindahan daripada Playwright ke Keploy merupakan pengubah permainan untuk proses ujian API saya. Berikut ialah imbasan ringkas mengapa Keploy lebih sesuai untuk ujian API moden:

• Tiada Lagi Kerumitan Pangkalan Data: Keploy menghapuskan keperluan untuk pangkalan data langsung, menjadikan ujian anda lebih pantas dan lebih mudah untuk diurus.

• Pengujian Kod Sifar: Tiada lagi kod ujian berulang—Keploy mengautomasikan segala-galanya daripada mengejek data kepada penjanaan ujian.

• Integrasi CI/CD yang lancar: Keploy sangat sesuai dengan saluran paip CI/CD sedia ada, mempercepatkan kitaran maklum balas anda dan meningkatkan produktiviti.

• Liputan Ujian Realistik: Keploy menangkap interaksi API sebenar, memastikan liputan ujian yang komprehensif dan keputusan yang boleh dipercayai.

Jika anda bergelut dengan kerumitan Playwright untuk ujian API, saya amat mengesyorkan anda mencuba Keploy. Ini adalah cara yang mudah, berkuasa dan cekap untuk mengautomasikan ujian API anda, membolehkan anda menumpukan pada membina perisian berkualiti tinggi dan bukannya bergelut dengan persediaan infrastruktur dan pengurusan data.

Atas ialah kandungan terperinci Alternatif Penulis Drama untuk Ujian API. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!