Takeaways Key

mengautomasikan debugging dalam git dengan ujian unit melibatkan menggunakan arahan 'bisect' untuk melintasi komitmen dan mengenal pasti yang memperkenalkan bug. Proses ini boleh automatik dengan skrip, mengurangkan keperluan untuk pelabelan manual komited sebagai 'baik' atau 'buruk'.
Ujian unit adalah penting dalam proses ini, kerana ia dijalankan untuk setiap komit untuk menentukan sama ada ia harus diberikan sebagai 'baik' atau 'buruk'. Ini boleh dilakukan dengan menggunakan arahan seperti 'git bisect run [perintah untuk menjalankan ujian]'. Sebaik sahaja ujian dijalankan untuk setiap komit, GIT dapat mengenal pasti komit yang memperkenalkan kesilapan.
Apabila asas kod meningkat saiz, ujian unit menulis untuk setiap kod menjadi perlu. Walaupun ia mungkin kelihatan memakan masa pada mulanya, ia membantu dalam debug dan menjimatkan masa dalam jangka masa panjang. Ia juga mungkin untuk membuat skrip shell tersuai dengan kod keluar tersuai untuk menggantikan ujian unit.

sebentar tadi, saya menerbitkan sebuah artikel mengenai debugging codebase dalam git menggunakan dua perintah menyalahkan dan bisect. Git menyalahkan melibatkan memeriksa pengarang setiap baris fail, sedangkan Bisect melibatkan melintasi komitmen (menggunakan carian binari) untuk mencari yang memperkenalkan pepijat. Dalam siaran ini, kita akan melihat bagaimana untuk mengautomasikan proses bisect.

untuk menyegarkan ingatan anda, git bisect melibatkan beberapa langkah, yang diringkaskan di bawah:

Mulakan wizard bisect dengan git bisect start
Pilih "Baik" dan "Bad" yang dilakukan, atau yang diketahui dilakukan di mana bug itu tidak hadir dan hadir, masing -masing
Berikan komitmen untuk diuji sebagai "baik" atau "buruk" sehingga git mengetahui komit yang memperkenalkan bug
keluar dari wizard dengan git bisect reset

Untuk mendapatkan idea keseluruhan proses, anda boleh melihat screencast ini, yang menunjukkan secara terperinci bagaimana proses debugging berfungsi.

Secara semulajadi, langkah ketiga adalah memakan masa - Git akan menunjukkan anda melakukan satu persatu dan anda harus melabelkannya sebagai "baik" atau "buruk" setelah memeriksa apakah pepijat itu hadir dalam komit itu.

Apabila kita menulis skrip untuk mengautomasikan proses debugging, kita pada dasarnya akan menjalankan langkah ketiga. Mari kita mulakan!

Mementaskan Alam Sekitar

Dalam siaran ini, saya akan menulis modul kecil dalam python yang mengandungi fungsi yang menambah dua nombor. Ini adalah tugas yang sangat mudah dan saya akan melakukan ini untuk tujuan demonstrasi sahaja. Kod ini adalah penjelasan diri, jadi saya tidak akan masuk ke dalam butiran.

Untuk mengautomasikan proses git bisect, anda perlu menulis ujian untuk kod anda. Di Python, kami akan menggunakan modul Unittest untuk menulis kes ujian kami. Inilah ujian asas seperti.

<span>#add_two_numbers.py
</span>def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + b
</span>    <span>return addition</span>

<span>#add_two_numbers.py
</span>def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + b
</span>    <span>return addition</span>

kita boleh menulis lebih banyak ujian ini, tetapi ini hanya untuk menunjukkan bagaimana untuk meneruskannya. Sebenarnya, anda pasti akan menulis lebih banyak kes ujian kerana program dan aplikasi anda akan jauh lebih kompleks daripada ini.

Untuk menjalankan ujian unit, laksanakan fail tests.py yang mengandungi kes ujian anda.

<span>#tests.py
</span><span>import unittest
</span>from add_two_numbers <span>import add_two_numbers
</span>
class TestsForAddFunction<span>(unittest.TestCase):
</span>
    def test_zeros<span>(self):
</span>        result <span>= add_two_numbers(0, 0)
</span>        self.assertEqual<span>(0, result)
</span>
<span>if __name__ == '__main__':
</span>    unittest.main<span>()</span>

Jika ujian lulus, anda perlu mendapatkan output berikut.

mari kita memperkenalkan ralat dalam fungsi kami dan melakukan kod.

python tests.py

Untuk mengesahkan bahawa ujian gagal, marilah kita menjalankannya lagi.

mari kita tambahkan beberapa lagi komited supaya komit yang memperkenalkan ralat bukan yang terakhir.

Mulakan proses bisect

Untuk wizard bisect git, kami akan memilih komit terkini sebagai buruk (B60FE2CF35) dan yang pertama sebagai baik (98D9DF03B6).

def add_two_numbers<span>(a, b):
</span>    <span>'''
</span>        Function to <span>add two numbers
</span>    <span>'''
</span>    addition <span>= a + 0
</span>    <span>return addition</span>

Pada ketika ini, Git menunjuk kami untuk komit dan bertanya kepada kami sama ada ia adalah komitmen yang baik atau buruk. Ini adalah ketika kami memberitahu Git untuk menjalankan ujian untuk kami. Perintah untuknya adalah seperti berikut.

<span>git bisect start b60fe2cf35 98d9df03b6</span>

Dalam kes kita, ia akan menjadi yang berikut.

<span>git bisect run [command to run tests]</span>

Apabila kami memberikan arahan untuk menjalankan ujian itu sendiri, dan bukannya bertanya kepada kami, Git menjalankan ujian ini untuk setiap semakan dan memutuskan sama ada komit harus diberikan baik atau buruk.

sekali git selesai menjalankan ujian untuk setiap komit, ia memaparkan yang komit memperkenalkan kesilapan, seperti sihir!

Sebaik sahaja anda telah menemui komit anda, jangan lupa untuk menetapkan semula wizard dengan reset bisect git.

Di tempat ujian unit anda, anda juga boleh membuat skrip shell tersuai dengan kod keluar tersuai. Secara umumnya kod keluar 0 dianggap sebagai kejayaan, segala -galanya adalah kegagalan.

Pemikiran Akhir

Oleh kerana saiz asas kod anda meningkat, ujian unit menulis untuk setiap kod kecil yang anda tulis menjadi perlu. Ujian menulis mungkin kelihatan memakan masa, tetapi seperti yang anda lihat dalam kes ini, mereka membantu anda dalam debug dan menjimatkan masa anda dalam jangka masa panjang.

Bagaimanakah kesilapan debug pasukan anda dalam kod? Beritahu kami dalam komen di bawah.

Soalan Lazim (Soalan Lazim) Mengenai Mengaut Mengotor Debug dengan Ujian Unit Git

Bagaimana saya boleh menyediakan debugging automatik dengan ujian unit git?

Menyediakan debugging automatik dengan ujian unit git melibatkan beberapa langkah. Pertama, anda perlu membuat repositori git dan memulakannya. Kemudian, anda perlu menulis ujian unit anda menggunakan kerangka ujian yang serasi dengan bahasa pengaturcaraan anda. Sebaik sahaja ujian anda ditulis, anda boleh menggunakan alat Integrasi Berterusan (CI) untuk mengautomasikan menjalankan ujian ini. Alat ini boleh dikonfigurasikan untuk menjalankan ujian anda setiap kali anda menolak perubahan ke repositori git anda. Dengan cara ini, anda boleh menangkap dan memperbaiki pepijat awal dalam proses pembangunan. Ia membantu menangkap bug awal dalam proses pembangunan, yang dapat menjimatkan masa dan sumber. Ia juga memastikan bahawa semua bahagian kod anda diuji secara konsisten. Ini dapat meningkatkan kualiti keseluruhan kod anda dan menjadikannya lebih dipercayai. Di samping itu, ia boleh menjadikan proses pembangunan anda lebih cekap dengan mengurangkan jumlah ujian manual yang perlu anda lakukan. > Integrasi Berterusan (CI) adalah amalan pembangunan di mana pemaju mengintegrasikan kod ke dalam repositori bersama, biasanya beberapa kali sehari. Setiap integrasi kemudiannya disahkan oleh ujian binaan dan automatik automatik. Dalam konteks ujian unit git, CI boleh digunakan untuk mengautomasikan ujian ini setiap kali perubahan ditolak ke repositori Git. Ini membantu menangkap pepijat lebih awal dan memastikan bahawa semua bahagian kod diuji secara konsisten. . Pertama, setiap ujian harus memberi tumpuan kepada fungsi atau tingkah laku tunggal. Ini menjadikannya lebih mudah untuk mengenal pasti punca sebarang kegagalan. Kedua, ujian harus bebas dan dapat berjalan dalam apa -apa perintah. Ini memastikan bahawa hasil satu ujian tidak menjejaskan hasil yang lain. Ketiga, ujian harus berulang dan menghasilkan hasil yang sama setiap kali mereka dijalankan. Ini memastikan ujian anda boleh dipercayai dan boleh dipercayai untuk menangkap bug. dengan ujian unit git. Ini termasuk alat integrasi berterusan (CI) seperti Jenkins, Travis CI, dan CircleCi. Alat ini boleh dikonfigurasikan untuk menjalankan ujian unit anda setiap kali anda menolak perubahan ke repositori git anda. Di samping itu, anda boleh menggunakan rangka kerja ujian seperti Junit (untuk Java), Pytest (untuk Python), dan Mocha (untuk JavaScript) untuk menulis ujian unit anda.

Bagaimanakah saya dapat mengintegrasikan ujian unit git saya dengan alat integrasi berterusan (CI)? Pertama, anda perlu mengkonfigurasi alat CI anda untuk menyambung ke repositori git anda. Kemudian, anda perlu mengkonfigurasinya untuk menjalankan ujian unit anda setiap kali perubahan ditolak ke repositori. Ini biasanya melibatkan menulis fail konfigurasi yang menentukan arahan untuk menjalankan ujian dan syarat -syarat di mana untuk menjalankannya. Ujian unit gagal, langkah pertama adalah untuk mengenal pasti punca kegagalan. Ini biasanya melibatkan mengkaji output ujian dan kod yang sedang diuji. Sebaik sahaja anda telah mengenal pasti punca itu, anda boleh membuat perubahan yang diperlukan pada kod anda dan mengubah ujian. Jika ujian berlalu, anda boleh menolak perubahan anda ke repositori Git. Sekiranya mereka gagal lagi, anda mungkin perlu menyemak semula ujian atau kod anda sehingga mereka lulus. dengan ujian unit git untuk mana -mana bahasa pengaturcaraan. Walau bagaimanapun, alat dan teknik khusus yang anda gunakan mungkin berbeza -beza bergantung kepada bahasa. Kebanyakan bahasa pengaturcaraan mempunyai satu atau lebih kerangka ujian yang boleh anda gunakan untuk menulis ujian unit anda. Di samping itu, alat integrasi yang paling berterusan (CI) menyokong pelbagai bahasa dan boleh dikonfigurasikan untuk menjalankan ujian anda tanpa mengira bahasa yang ditulisnya.

Memastikan ujian unit git anda berkesan melibatkan beberapa amalan terbaik. Pertama, ujian anda harus meliputi semua bahagian kod anda, termasuk kes kelebihan. Ini memastikan ujian anda komprehensif. Kedua, ujian anda harus bebas dan dapat berjalan dalam apa -apa perintah. Ini memastikan bahawa hasil satu ujian tidak menjejaskan hasil yang lain. Ketiga, ujian anda harus berulang dan menghasilkan hasil yang sama setiap kali mereka berjalan. Ini memastikan ujian anda boleh dipercayai. Kod, bukan antara muka pengguna (UI) aplikasi anda. Walau bagaimanapun, anda boleh menggunakan jenis ujian lain, seperti ujian integrasi atau ujian akhir-ke-akhir, untuk menguji UI anda. Ujian ini juga boleh automatik dan dijalankan menggunakan alat integrasi berterusan (CI). Ini dapat membantu menangkap pepijat di UI anda pada awal proses pembangunan.

Atas ialah kandungan terperinci Automatikkan Debugging dalam Git dengan Ujian Unit. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!