Olok-olok, apa itu?

Teks ini adalah yang pertama dalam siri teks tentang ujian dalam aplikasi pemprosesan data yang akan saya bawa ke sini dan di blog peribadi saya.

Apabila saya membuat peralihan kerjaya saya daripada jurutera perisian kepada jurutera data, saya mula berbual dengan orang di kawasan data yang tidak mempunyai latar belakang dalam kejuruteraan perisian. Dalam perbualan ini, soalan timbul berulang kali: bagaimana untuk menulis ujian?

Ujian menulis, sebenarnya, kelihatan seperti tugas yang rumit bagi mereka yang tidak biasa, kerana ia memerlukan perubahan dalam cara menulis kod. Hakikatnya adalah bahawa tidak ada misteri, tetapi lebih kepada soal latihan dan pengulangan. Objektif utama saya dalam artikel ini adalah untuk membimbing anda, yang baru bermula, dalam proses yang menunjukkan cara kami boleh membuat ujian untuk aplikasi yang memproses data, memastikan kualiti dan kebolehpercayaan dalam kod.

Teks ini adalah sebahagian daripada siri yang akan saya bawa dalam beberapa minggu akan datang di mana saya berkongsi cara menulis ujian automatik dalam kod yang bertujuan untuk kejuruteraan data. Dalam artikel hari ini saya ingin meneroka sedikit tentang olok-olok. Dalam beberapa senario kod, saluran paip data akan membuat sambungan, panggilan API, penyepaduan dengan perkhidmatan Cloud, dsb., yang boleh menyebabkan kekeliruan dalam cara kami boleh menguji aplikasi ini. Hari ini kita akan meneroka beberapa perpustakaan menarik untuk ujian penulisan yang memfokuskan pada penggunaan olok-olok.

Lagipun, apa itu Mocks?

Mock ialah objek olok-olok yang digunakan dalam ujian untuk meniru tingkah laku kebergantungan luaran atau komponen yang bukan fokus ujian. Mereka membenarkan anda mengasingkan unit kod yang sedang diuji, memastikan bahawa ujian lebih terkawal dan ramalan. Penggunaan mock adalah amalan biasa dalam ujian unit dan ujian integrasi.

Dan kita harus menggunakan ejekan apabila:

• Pergantungan tidak relevan dengan ujian;
• Pergantungan tidak tersedia;
• Kami ingin menguji gelagat istimewa, simulasi ralat atau respons khusus.

Dalam saluran paip data, Mocking membolehkan anda membuat perwakilan komponen luaran – seperti pangkalan data, perkhidmatan pemesejan atau API – tanpa bergantung pada infrastruktur sebenar mereka. Ini amat berguna dalam persekitaran pemprosesan data, yang menyepadukan berbilang teknologi, seperti PySpark untuk pemprosesan teragih, Kafka untuk pemesejan serta perkhidmatan awan seperti AWS dan GCP.

Dalam senario di mana kami mempunyai saluran data ini, Mocking memudahkan pelaksanaan ujian terpencil dan pantas, meminimumkan kos dan masa pelaksanaan. Ia membolehkan setiap bahagian saluran paip disahkan dengan tepat, tanpa kegagalan terputus-putus disebabkan oleh sambungan sebenar atau infrastruktur luaran, dan dengan keyakinan bahawa setiap penyepaduan berfungsi seperti yang diharapkan.

Dalam setiap bahasa pengaturcaraan, kita boleh mencari modul dalaman yang sudah menyediakan fungsi Mock untuk dilaksanakan. Dalam Python, perpustakaan unittest.mock asli ialah alat utama untuk mencipta olok-olok, membolehkan anda mensimulasikan objek dan fungsi dengan mudah dan terkawal. Dalam Go, proses Mocking biasanya disokong oleh pakej luaran, seperti ejekan, kerana bahasa itu tidak mempunyai pustaka Mock asli; ejekan amat berguna untuk menghasilkan olok-olok daripada antara muka, ciri asli Go Di Java, Mockito menonjol sebagai perpustakaan yang popular dan berkuasa untuk mencipta olok-olok, menyepadukan dengan JUnit untuk memudahkan ujian unit yang mantap. Perpustakaan ini menyediakan asas penting untuk menguji komponen terpencil, terutamanya dalam saluran paip data dan sistem teragih yang mana simulasi sumber data luaran dan API adalah kritikal.

Melaksanakan Olok-olok

Mari kita mulakan dengan contoh asas bagaimana kita boleh menggunakan Mocks. Andaikan kita mempunyai fungsi yang membuat panggilan API dan kita perlu menulis ujian unit untuk fungsi ini:

def get_data_from_api(url):
    import requests
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        return None

Untuk mendekati senario ujian dengan betul, kita perlu memahami situasi mana yang harus dilindungi. Memandangkan fungsi kami membuat panggilan REST, ujian mesti mempertimbangkan sekurang-kurangnya dua senario utama: satu di mana permintaan berjaya dan satu lagi di mana respons tidak seperti yang diharapkan. Kami boleh menjalankan kod dengan URL sebenar untuk memerhatikan tingkah laku, tetapi pendekatan ini mempunyai kelemahan, kerana kami tidak akan mempunyai kawalan ke atas pelbagai jenis respons, selain meninggalkan ujian terdedah kepada perubahan dalam respons URL atau ketiadaannya yang akhirnya. . Untuk mengelakkan ketidakkonsistenan ini, kami akan menggunakan Mocks.

from unittest import mock

@mock.patch('requests.get')
    def test_get_data_from_api_success(mock_get):
        # Configura o mock para retornar uma resposta simulada
        mock_get.return_value.status_code = 200
        mock_get.return_value.json.return_value = {"key": "value"}

        # Chama a função com o mock ativo
        result = get_data_from_api("http://fakeurl.com")

        # Verifica se o mock foi chamado corretamente e o resultado é o esperado
        mock_get.assert_called_once_with("http://fakeurl.com")
        self.assertEqual(result, {"key": "value"})

Dengan hiasan @mock.patch daripada perpustakaan Python unittest, kita boleh menggantikan requests.get call dengan olok-olok, "objek palsu" yang mensimulasikan gelagat fungsi get dalam konteks ujian, menghapuskan pergantungan luaran

Dengan mentakrifkan nilai untuk return_value olok-olok, kami boleh menentukan dengan tepat apa yang kami jangkakan objek itu akan dikembalikan apabila dipanggil dalam fungsi yang kami uji. Adalah penting bahawa struktur return_value mengikut sama seperti objek sebenar yang kami gantikan. Sebagai contoh, objek respons daripada modul permintaan mempunyai atribut seperti status_code dan kaedah seperti json(). Oleh itu, untuk mensimulasikan respons daripada fungsi requests.get, kita boleh menetapkan nilai yang dijangkakan kepada atribut dan kaedah ini terus dalam mock.

def get_data_from_api(url):
    import requests
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        return None

Dalam kes khusus ini, tumpuan adalah untuk mensimulasikan respons permintaan, iaitu, untuk menguji kelakuan fungsi dengan hasil yang dijangkakan berbeza tanpa bergantung pada URL luaran dan tanpa kesan pada persekitaran ujian kami.

from unittest import mock

@mock.patch('requests.get')
    def test_get_data_from_api_success(mock_get):
        # Configura o mock para retornar uma resposta simulada
        mock_get.return_value.status_code = 200
        mock_get.return_value.json.return_value = {"key": "value"}

        # Chama a função com o mock ativo
        result = get_data_from_api("http://fakeurl.com")

        # Verifica se o mock foi chamado corretamente e o resultado é o esperado
        mock_get.assert_called_once_with("http://fakeurl.com")
        self.assertEqual(result, {"key": "value"})

Dengan mensimulasikan respons ralat API dalam ujian, kami boleh melampaui asas dan menyemak gelagat aplikasi terhadap jenis kod status HTTP yang berbeza seperti 404, 401, 500 dan 503. Ini menyediakan liputan yang lebih luas dan memastikan aplikasi itu berurusan dengan sewajarnya dengan setiap jenis kegagalan, saya faham bagaimana variasi dalam panggilan ini boleh memberi kesan kepada pemprosesan aplikasi/data kami. Dalam panggilan kaedah POST, kami boleh menambah lapisan tambahan pengesahan, menyemak bukan sahaja status_kod dan fungsi asas panggilan, tetapi juga skema respons penghantaran dan diterima, memastikan data yang dikembalikan mengikut format yang diharapkan. Pendekatan ujian yang lebih terperinci ini membantu mengelakkan masalah masa hadapan dengan memastikan aplikasi bersedia untuk mengendalikan pelbagai senario ralat dan data yang diterima sentiasa selaras dengan apa yang direka.

Melaksanakan Olok-olok dengan PySpark

Sekarang kita telah melihat kes mudah menggunakan Mocks dalam kod Python tulen, mari kita kembangkan kes kita kepada coretan kod yang menggunakan Pyspark.

Untuk menguji fungsi PySpark, terutamanya operasi DataFrame seperti penapis, groupBy dan sertai, menggunakan olok-olok ialah pendekatan berkesan yang menghapuskan keperluan untuk menjalankan Spark sebenar, mengurangkan masa ujian dan memudahkan persekitaran pembangunan. Pustaka unittest.mock Python membolehkan anda mensimulasikan gelagat kaedah ini, membolehkan anda mengesahkan aliran kod dan logik tanpa bergantung pada infrastruktur Spark.

Mari kita lihat, memandangkan fungsi berikut di mana kita mempunyai transformasi yang melakukan penapisan, groupBy dan operasi gabungan pada bingkai data dalam Spark.

def get_data_from_api(url):
    import requests
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        return None

Untuk menjalankan ujian PySpark, kami memerlukan konfigurasi Spark untuk dilakukan secara setempat. Konfigurasi ini dilakukan dalam kaedah setUpClass, yang mencipta contoh Spark yang akan digunakan dalam semua ujian kelas. Ini membolehkan kami menjalankan PySpark secara berasingan, menjadikannya mungkin untuk melaksanakan operasi transformasi sebenar tanpa bergantung pada kluster penuh. Selepas ujian selesai, kaedah tearDownClass bertanggungjawab untuk menamatkan sesi Spark, memastikan semua sumber dikeluarkan dengan betul dan persekitaran ujian adalah bersih.

from unittest import mock

@mock.patch('requests.get')
    def test_get_data_from_api_success(mock_get):
        # Configura o mock para retornar uma resposta simulada
        mock_get.return_value.status_code = 200
        mock_get.return_value.json.return_value = {"key": "value"}

        # Chama a função com o mock ativo
        result = get_data_from_api("http://fakeurl.com")

        # Verifica se o mock foi chamado corretamente e o resultado é o esperado
        mock_get.assert_called_once_with("http://fakeurl.com")
        self.assertEqual(result, {"key": "value"})

Dalam ujian test_transform_data, kami mulakan dengan mencipta contoh DataFrames untuk df dan df_other, yang mengandungi data yang akan digunakan dalam transformasi. Kami kemudian melaksanakan fungsi transform_data tanpa menggunakan olok-olok, membenarkan penapis, groupBy dan operasi bergabung benar-benar berlaku dan menghasilkan DataFrame baharu. Selepas pelaksanaan, kami menggunakan kaedah collect() untuk mengekstrak data daripada DataFrame yang terhasil, yang membolehkan kami membandingkan data ini dengan nilai yang dijangkakan dan, dengan itu, mengesahkan transformasi yang dijalankan dengan cara yang sebenar dan tepat.

Tetapi kita juga boleh mempunyai senario di mana kita ingin menguji hasil salah satu fungsi pyspark ini. Adalah perlu untuk mengejek bahagian lain kod yang mungkin mewakili kesesakan pada masa pelaksanaan dan itu tidak mewakili risiko kepada proses kami. Oleh itu, kita boleh menggunakan teknik mengejek fungsi/modul, seperti yang kita lihat dalam contoh sebelumnya menggunakan permintaan.

response.status_code = mock_get.return_value.status_code
response.json() = mock_get.return_value.json.return_value

Ujian Mock untuk operasi tertentu telah dijalankan dalam kaedah test_transform_data_with_mocked_join, di mana kami menggunakan mock khusus untuk kaedah penapis. Olok-olok ini menggantikan hasil operasi gabungan dengan DataFrame yang disimulasikan, membolehkan operasi sebelumnya, seperti groupBy dan join, dilaksanakan dengan cara yang sebenar. Ujian kemudian membandingkan DataFrame yang terhasil dengan nilai yang dijangkakan, memastikan mock gabungan digunakan dengan betul, tanpa mengganggu transformasi lain yang dilakukan.

Pendekatan hibrid ini membawa beberapa kelebihan. Dengan memastikan bahawa operasi PySpark sebenar seperti join dan groupBy dikekalkan, kami boleh mengesahkan logik transformasi tanpa kehilangan fleksibiliti untuk menggantikan operasi tertentu seperti penapis dengan olok-olok. Ini menghasilkan ujian yang lebih mantap dan lebih pantas, menghapuskan keperluan untuk gugusan Spark penuh, yang menjadikan pembangunan dan pengesahan kod yang berterusan lebih mudah.

Adalah penting untuk menyerlahkan bahawa strategi ini harus digunakan dengan berhati-hati dan hanya dalam senario di mana berat sebelah dalam keputusan tidak dibuat. Tujuan ujian adalah untuk memastikan bahawa pemprosesan berlaku dengan betul; Kita tidak seharusnya hanya memberikan nilai tanpa benar-benar menguji fungsi tersebut. Walaupun adalah sah untuk mengejek bahagian yang kami boleh jamin tidak akan menjejaskan proses ujian unit, adalah penting untuk diingat bahawa fungsi itu mesti dilaksanakan untuk mengesahkan kelakuan sebenarnya.

Oleh itu, pendekatan hibrid lebih masuk akal apabila kami mempunyai jenis pemprosesan lain yang ditambahkan pada fungsi ini. Strategi ini membolehkan gabungan berkesan operasi sebenar dan simulasi, memastikan ujian yang lebih mantap dan boleh dipercayai

membuat kesimpulan

Mocks ialah sekutu yang berharga dalam mencipta ujian yang berkesan, terutamanya apabila ia berkaitan dengan PySpark dan perkhidmatan awan yang lain. Pelaksanaan yang kami terokai menggunakan unittest dalam Python bukan sahaja membantu kami mensimulasikan operasi tetapi juga mengekalkan integriti data dan proses kami. Dengan fleksibiliti yang ditawarkan, kami boleh menguji saluran paip kami tanpa rasa takut mendatangkan malapetaka dalam persekitaran pengeluaran. Jadi, bersedia untuk cabaran seterusnya? Dalam teks kami yang seterusnya, kami akan menyelami dunia penyepaduan dengan perkhidmatan AWS dan GCP, menunjukkan cara untuk mengejek panggilan ini dan memastikan saluran paip anda berfungsi dengan sempurna. Sehingga kali seterusnya!

Atas ialah kandungan terperinci Olok-olok, apa itu?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!