Geekly articles weekly

Keakraban dengan pengujian dalam Python. Bagian 1

Hari baik untuk semua!

Dari tabel kami hingga milik Anda ... Yaitu, dari "Pengembang Python" kami, meskipun Tahun Baru yang semakin dekat, kami telah menyiapkan terjemahan yang menarik untuk Anda tentang berbagai metode pengujian dengan Python.

Panduan ini adalah untuk mereka yang telah menulis aplikasi Python keren tetapi belum menulis untuk
mereka menguji.

Pengujian dengan Python adalah topik yang luas dengan banyak seluk-beluk, tetapi tidak perlu menyulitkan banyak hal. Dalam beberapa langkah sederhana, Anda dapat membuat tes sederhana untuk aplikasi tersebut, secara bertahap meningkatkan kompleksitas berdasarkan pada mereka.

Dalam panduan ini, Anda akan belajar cara membuat tes dasar, menjalankannya, dan menemukan semua bug sebelum pengguna melakukannya! Anda akan belajar tentang alat yang tersedia untuk menulis dan menjalankan tes, memeriksa kinerja aplikasi, dan bahkan melihat masalah keamanan.



Pengujian Kode

Anda dapat menguji kode dengan berbagai cara. Dalam panduan ini, Anda akan belajar tentang metode dari yang paling sederhana hingga yang paling canggih.

Otomatis vs. Pengujian Manual

Kabar baik! Kemungkinan besar Anda sudah melakukan tes, tetapi belum menyadarinya. Ingat bagaimana Anda pertama kali memulai aplikasi dan menggunakannya? Sudahkah Anda menguji fungsi dan bereksperimen dengannya? Proses ini disebut pengujian eksplorasi, dan ini adalah bentuk pengujian manual.

Pengujian penelitian - pengujian yang dilakukan tanpa rencana. Selama pengujian penelitian, Anda meneliti aplikasi.

Untuk membuat daftar lengkap tes manual, cukup membuat daftar semua fungsi aplikasi, berbagai jenis input yang diperlukan, dan hasil yang diharapkan. Sekarang, setiap kali Anda mengubah sesuatu dalam kode, Anda perlu memeriksa kembali setiap elemen dalam daftar ini.

Kedengarannya suram, kan?

Oleh karena itu, tes otomatis diperlukan. Pengujian otomatis - pelaksanaan rencana pengujian (bagian dari aplikasi yang memerlukan pengujian, urutan pengujian dan hasil yang diharapkan) menggunakan skrip, dan bukan oleh tangan manusia. Python sudah memiliki seperangkat alat dan pustaka untuk membantu Anda membuat tes otomatis untuk aplikasi Anda. Mari kita lihat alat dan pustaka ini di tutorial kita.

Unit Tes VS. Tes Integrasi

Dunia pengujian penuh dengan persyaratan, dan sekarang, mengetahui perbedaan antara pengujian manual dan otomatis, kita akan turun ke level yang lebih dalam.

Pikirkan bagaimana Anda bisa menguji lampu mobil? Anda menyalakan lampu depan (sebut saja ini langkah pengujian), keluar dari mobil sendiri atau minta teman untuk memeriksa bahwa lampu depan menyala (dan ini merupakan proposisi uji). Pengujian beberapa komponen disebut pengujian integrasi.

Pikirkan semua hal yang harus bekerja dengan benar sehingga tugas sederhana menghasilkan hasil yang benar. Komponen-komponen ini mirip dengan bagian aplikasi Anda: semua kelas, fungsi, modul yang Anda tulis.

Kesulitan utama pengujian integrasi muncul ketika tes integrasi tidak memberikan hasil yang benar. Sulit untuk menilai masalahnya, tidak dapat mengisolasi bagian yang rusak dari sistem. Jika lampu depan tidak menyala, bohlam mungkin rusak. Atau mungkin baterainya rendah? Atau mungkin masalahnya ada di generator? Atau bahkan crash di komputer mesin?

Mobil modern sendiri akan memberi tahu Anda tentang bohlam yang rusak. Ini ditentukan menggunakan unit test.

Uji unit (unit test) adalah tes kecil yang memeriksa operasi yang benar dari masing-masing komponen. Tes unit membantu mengisolasi kerusakan dan memperbaikinya lebih cepat.

Kami berbicara tentang dua jenis tes:

  1. Tes integrasi yang memeriksa komponen sistem dan interaksinya satu sama lain;
  2. Tes unit yang menguji satu komponen aplikasi.
  3. Anda bisa membuat kedua tes dengan Python. Untuk menulis tes untuk fungsi sum () bawaan, Anda perlu membandingkan output dari jumlah () dengan nilai yang diketahui.

Misalnya, dengan cara ini Anda dapat memeriksa bahwa jumlah angka (1, 2, 3) adalah 6:

>>> assert sum([1, 2, 3]) == 6, "Should be 6"

Nilai-nilai sudah benar, jadi tidak akan ada output untuk REPL. Jika hasil dari sum() benar, sebuah AssertionError akan AssertionError dengan pesan "Harus 6". Periksa pernyataan pernyataan lagi, tetapi sekarang dengan nilai yang tidak valid untuk mendapatkan AssertionError :

 >>> assert sum([1, 1, 1]) == 6, "Should be 6" Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError: Should be 6

Di REPL, Anda akan melihat AssertionError karena nilai sum() bukan 6.

Alih-alih REPL, masukkan ini dalam file Python baru yang disebut test_sum.py dan jalankan lagi:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" if __name__ == "__main__": test_sum() print("Everything passed")

Sekarang Anda memiliki test case tertulis (test case), pernyataan dan titik masuk (command line). Sekarang ini dapat dilakukan pada baris perintah:

 $ python test_sum.py Everything passed

Anda melihat hasil yang sukses, "Semuanya berlalu".

sum() dengan Python menerima setiap iterable sebagai argumen pertama. Anda telah memeriksa daftar. Mari kita coba tupelnya. Buat file baru bernama test_sum_2.py dengan kode berikut:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6" if __name__ == "__main__": test_sum() test_sum_tuple() print("Everything passed")

test_sum_2.py , skrip akan test_sum_2.py kesalahan, karena s um() (1, 2, 2) harus 5, bukan 6. Akibatnya, skrip memberikan pesan kesalahan, baris kode dan traceback:

 $ python test_sum_2.py Traceback (most recent call last): File "test_sum_2.py", line 9, in <module> test_sum_tuple() File "test_sum_2.py", line 5, in test_sum_tuple assert sum((1, 2, 2)) == 6, "Should be 6" AssertionError: Should be 6

Anda dapat melihat bagaimana kesalahan dalam kode menyebabkan kesalahan di konsol dengan informasi tentang di mana itu terjadi dan apa hasil yang diharapkan.

Tes semacam itu cocok untuk verifikasi sederhana, tetapi bagaimana jika ada lebih banyak kesalahan daripada satu? Pelari ujian datang untuk menyelamatkan. Pelaksana Tes adalah aplikasi khusus yang dirancang untuk melakukan tes, memverifikasi data keluaran dan menyediakan alat untuk debugging dan mendiagnosis tes dan aplikasi.

Memilih Pelaksana Tes

Ada banyak pelari ujian yang tersedia untuk Python. Misalnya, unittest dibangun ke dalam pustaka standar Python. Dalam panduan ini, kami akan menggunakan uji kasus dan pelaksana uji unittest. Prinsip operasi unittest mudah disesuaikan dengan kerangka kerja lain. Kami membuat daftar pelaksana ujian paling populer:

  • unittest;
  • hidung atau hidung2;
  • pytest.

Penting untuk memilih kontraktor pengujian yang memenuhi persyaratan dan pengalaman Anda.

unittest

unittest telah diintegrasikan ke dalam pustaka standar Python sejak versi 2.1. Anda mungkin akan menemukannya di aplikasi Python komersial dan proyek open source.
Unittest memiliki kerangka uji dan pelari ujian. Saat menulis dan menjalankan tes, Anda harus mengikuti beberapa persyaratan penting.

unittest membutuhkan:

  • Masukkan tes di kelas sebagai metode;
  • Gunakan metode persetujuan khusus. Kelas TestCase alih-alih ekspresi inert yang biasa.


Untuk mengubah contoh yang ditulis sebelumnya menjadi test case yang paling bebas, Anda harus:

  1. Impor unittest dari perpustakaan standar;
  2. Buat kelas yang disebut TestSum yang akan mewarisi kelas TestCase ;
  3. Konversikan fungsi pengujian menjadi metode dengan menambahkan self sebagai argumen pertama;
  4. Ubah pernyataan dengan menambahkan penggunaan metode self.assertEqual() di kelas TestCase ;
  5. Ubah titik entri pada baris perintah untuk memanggil unittest.main() .

Ikuti langkah-langkah ini, buat file test_sum_unittest.py baru dengan kode ini:

 import unittest class TestSum(unittest.TestCase): def test_sum(self): self.assertEqual(sum([1, 2, 3]), 6, "Should be 6") def test_sum_tuple(self): self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") if __name__ == '__main__': unittest.main()

Dengan melakukan ini pada baris perintah, Anda akan mendapatkan satu penyelesaian yang berhasil (ditunjukkan oleh.) Dan satu yang tidak berhasil (ditunjukkan oleh F):

 $ python test_sum_unittest.py .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

Dengan demikian, Anda melakukan dua tes menggunakan pelari tes unittest.

Catatan: Jika Anda menulis kasus uji untuk Python 2 dan 3, berhati-hatilah. Dalam versi Python 2.7 dan di bawah, unittest disebut unittest 2. Ketika Anda mengimpor dari unittest, Anda akan mendapatkan versi berbeda dengan fungsi berbeda di Python 2 dan Python 3.

Untuk mempelajari lebih lanjut tentang unittest, baca dokumentasi unittest .

hidung

Seiring waktu, setelah menulis ratusan atau bahkan ribuan tes untuk suatu aplikasi, menjadi semakin sulit untuk memahami dan menggunakan data keluaran yang paling tidak kompatibel.

Hidung kompatibel dengan semua tes yang ditulis dengan kerangka kerja yang paling bebas, dan dapat menggantikan pelaksana tesnya. Perkembangan hidung, sebagai aplikasi open source, mulai melambat, dan nose2 dibuat. Jika Anda memulai dari awal, Anda disarankan untuk menggunakan nose2.

Untuk memulai dengan nose2 Anda harus menginstalnya dari PyPl dan menjalankannya di baris perintah. nose2 akan mencoba menemukan semua skrip uji dengan test*.py dalam nama dan semua test case diwarisi dari unittest.TestCase di direktori Anda saat ini:

 $ pip install nose2 $ python -m nose2 .F ====================================================================== FAIL: test_sum_tuple (__main__.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test_sum_unittest.py", line 9, in test_sum_tuple self.assertEqual(sum((1, 2, 2)), 6, "Should be 6") AssertionError: Should be 6 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

Ini adalah bagaimana tes yang dibuat di test_sum_unittest.py dari pelari tes nose2. nose2 menyediakan banyak flag baris perintah untuk menyaring tes yang dapat dieksekusi. Untuk informasi lebih lanjut, lihat dokumentasi Hidung 2 .

pytest

pytest mendukung uji kasus yang belum dikirim. Tetapi keuntungan nyata dari pytest adalah test case-nya. Kasus uji pytest adalah serangkaian fungsi dalam file Python dengan test_ di awal nama.

Ada fitur berguna lainnya di dalamnya:

  • Dukungan untuk ekspresi tegas bawaan alih-alih menggunakan metode self.assert * () khusus;
  • Dukungan untuk kasus uji penyaringan;
  • Kemampuan untuk memulai kembali dari tes gagal terakhir;
  • Ekosistem ratusan plugin yang memperluas fungsionalitas.

Contoh testSum test case untuk pytest akan terlihat seperti ini:

 def test_sum(): assert sum([1, 2, 3]) == 6, "Should be 6" def test_sum_tuple(): assert sum((1, 2, 2)) == 6, "Should be 6"

Anda menyingkirkan TestCase, menggunakan kelas dan titik entri baris perintah.
Informasi lebih lanjut dapat ditemukan di Situs Dokumentasi Pytest .

Menulis Tes Pertama

Gabungkan semua yang telah kami pelajari, dan alih-alih fungsi sum() bawaan, kami menguji implementasi sederhana dengan persyaratan yang sama.

Buat folder baru untuk proyek, di dalamnya buat folder baru bernama my_sum. Di dalam my_sum, buat file kosong bernama _init_.py . Kehadiran file ini berarti bahwa folder my_sum dapat diimpor sebagai modul dari direktori induk.

Struktur folder akan terlihat seperti ini:

project/
│
└── my_sum/
└── __init__.py

Buka my_sum/__init__.py dan buat fungsi baru bernama sum() , yang mengambil input my_sum/__init__.py (daftar, tuple, set) dan tambahkan nilainya.

 def sum(arg): total = 0 for val in arg: total += val return total

Contoh ini membuat variabel yang disebut total , iterates atas semua nilai dalam arg dan menambah total . Kemudian, setelah menyelesaikan iterasi, hasilnya dikembalikan.

Tempat Menulis Tes

Anda dapat mulai menulis tes dengan membuat file test.py yang akan berisi test case pertama Anda. Untuk pengujian, file harus dapat mengimpor aplikasi Anda, jadi letakkan test.py di folder di atas paket. Pohon direktori akan terlihat seperti ini:

project/
│
├── my_sum/
│ └── __init__.py
|
└── test.py

Anda akan melihat bahwa ketika Anda menambahkan tes baru, file Anda menjadi lebih rumit dan sulit untuk dipertahankan, jadi kami sarankan untuk membuat folder tests/ dan membagi tes menjadi beberapa file. Pastikan nama semua file dimulai dengan test_ , sehingga test_ uji mengerti bahwa file Python berisi tes yang perlu dijalankan. Pada proyek besar, pengujian dibagi menjadi beberapa direktori, tergantung pada tujuan atau penggunaannya.

Catatan: Dan apakah aplikasi Anda adalah satu skrip?
Anda dapat mengimpor atribut skrip apa pun: kelas, fungsi atau variabel, menggunakan fungsi __import__() . Alih-alih dari from my_sum import sum tulis yang berikut ini:

 target = __import__("my_sum.py") sum = target.sum

Saat menggunakan __import__() Anda tidak perlu mengubah folder proyek menjadi sebuah paket, dan Anda dapat menentukan nama file. Ini berguna jika nama file bertentangan dengan nama pustaka paket standar. Misalnya, jika math.py bertentangan dengan modul matematika.

Cara Menyusun Tes Sederhana

Sebelum menulis tes, Anda perlu menyelesaikan beberapa pertanyaan:

  1. Apa yang ingin Anda uji?
  2. Apakah Anda menulis tes unit atau tes integrasi?

Anda sedang menguji sum() . Anda dapat menguji berbagai perilaku untuknya, misalnya:

  • Apakah mungkin untuk merangkum daftar bilangan bulat?
  • Apakah mungkin untuk meringkas tuple atau satu set?
  • Dapatkah saya meringkas daftar angka floating point?
  • Apa yang terjadi jika Anda memberikan nilai buruk pada input: integer tunggal atau string?
  • Apa yang terjadi jika salah satu nilai negatif?

Cara termudah untuk menguji adalah daftar bilangan bulat. Buat file test.py dengan kode berikut:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) if __name__ == '__main__': unittest.main()

Kode dalam contoh ini:

  • Mengimpor sum() dari paket my_sum() yang Anda buat;
  • Menentukan kelas kasus uji baru yang disebut TestSum yang mewarisi unittest.TestCase ;
  • Menentukan metode test .test_list_int() untuk menguji daftar integer. Metode .test_list_int() akan melakukan hal berikut
:
  1. Menyatakan variabel data dengan daftar nilai (1, 2, 3) ;
  2. my_sum.sum(data) nilai my_sum.sum(data) result variabel;
  3. Menentukan bahwa nilai hasil adalah 6 menggunakan metode .assertEqual() pada kelas unittest.TestCase .

  • Menentukan titik entri baris perintah yang meluncurkan pelari uji .main() .

Jika Anda tidak tahu apa itu diri, atau bagaimana .assertEqual() didefinisikan, maka Anda bisa menyegarkan pengetahuan Anda tentang pemrograman berorientasi objek dengan Pemrograman Berorientasi Objek Python 3 .

Cara Menulis Pernyataan

Langkah terakhir dalam menulis tes adalah untuk memverifikasi bahwa output cocok dengan nilai yang diketahui. Ini disebut pernyataan. Ada beberapa pedoman umum untuk menulis pernyataan:

  • Verifikasi bahwa tes dapat diulang dan jalankan beberapa kali untuk memastikan bahwa mereka memberikan hasil yang sama setiap kali;
  • Periksa dan konfirmasikan hasil yang berlaku untuk input Anda - verifikasi bahwa hasilnya benar-benar jumlah nilai dalam contoh sum() .

Unittest memiliki banyak metode untuk mengonfirmasi nilai, tipe, dan keberadaan variabel. Berikut adalah beberapa metode yang paling umum digunakan:

MetodeSetara
.assertEqual (a, b)a == b
.assertTrue (x)bool (x) Benar
.assertFalse (x)bool (x) adalah False
.assertIs (a, b)a adalah b
.assertIsNone (x)x adalah Tidak Ada
.assertIn (a, b)a dalam b
.assertIsInstance (a, b)isinstance (a, b)


.assertIs() , .assertIsNone() , .assertIn() , dan .assertIsInstance() memiliki metode yang berlawanan yang disebut .assertIsNot() dan seterusnya.

Efek samping

Tes menulis lebih sulit daripada hanya melihat nilai balik suatu fungsi. Seringkali, eksekusi kode mengubah bagian lain dari lingkungan: atribut kelas, file sistem file, nilai-nilai dalam database. Ini adalah bagian penting dari pengujian yang disebut efek samping. Putuskan apakah Anda menguji efek samping sebelum memasukkannya dalam daftar klaim Anda.

Jika Anda menemukan bahwa ada banyak efek samping dalam blok kode yang ingin Anda uji, maka Anda melanggar Prinsip Tanggung Jawab Tunggal . Melanggar prinsip tanggung jawab tunggal berarti sepotong kode melakukan terlalu banyak hal dan memerlukan refactoring. Mengikuti prinsip tanggung jawab tunggal adalah cara terbaik untuk merancang kode yang tidak akan sulit untuk menulis tes unit yang sederhana dan berulang, dan, pada akhirnya, membuat aplikasi yang andal.

Peluncuran Tes Pertama

Anda membuat tes pertama dan sekarang Anda perlu mencoba menjalankannya. Jelas bahwa itu akan berlalu, tetapi sebelum membuat tes yang lebih kompleks, Anda perlu memastikan bahwa bahkan tes tersebut berhasil.

Menjalankan Pelaksana Tes

Test Executor - Aplikasi Python yang menjalankan kode uji, memvalidasi pernyataan, dan menampilkan hasil tes di konsol. Di akhir test.py tambahkan sepotong kecil kode ini:

 if __name__ == '__main__': unittest.main()

Ini adalah titik masuk baris perintah. Jika Anda menjalankan skrip ini dengan menjalankan python test.py pada baris perintah, ia akan memanggil unittest.main() . Ini memulai unittest.TestCase uji unittest.TestCase mendeteksi semua kelas dalam file ini yang mewarisi dari unittest.TestCase .

Ini adalah salah satu dari banyak cara untuk menjalankan test runner yang paling bebas. Jika Anda memiliki file uji tunggal bernama test.py , memanggil python test.py adalah cara yang bagus untuk memulai.

Cara lain adalah dengan menggunakan baris perintah yang paling bebas. Mari kita coba:

 $ python -m unittest test

Ini akan menjalankan modul uji yang sama (disebut test ) melalui baris perintah. Anda dapat menambahkan parameter tambahan untuk mengubah output. Salah satunya adalah -v untuk verbose. Mari kita coba yang berikut ini:

 $ python -m unittest -v test test_list_int (test.TestSum) ... ok ---------------------------------------------------------------------- Ran 1 tests in 0.000s

Kami menjalankan satu tes dari test.py dan mengeluarkan hasilnya ke konsol. Mode Verbose mendaftar nama-nama tes yang dilakukan dan hasil masing-masing.

Alih-alih memberikan nama modul yang berisi tes, Anda dapat meminta penemuan otomatis menggunakan yang berikut:

 $ python -m unittest discover

Perintah ini akan mencari di direktori saat ini untuk file dengan test*.py pada nama untuk mengujinya.

Jika Anda memiliki beberapa file pengujian dan Anda mengikuti pola penamaan test*.py , Anda dapat meneruskan nama direktori menggunakan flag -s dan nama folder.

 $ python -m unittest discover -s tests

unittest akan menjalankan semua tes dalam satu rencana tes dan menghasilkan hasilnya.
Terakhir, jika kode sumber Anda tidak ada di direktori root, tetapi di subdirektori, misalnya, di folder bernama src /, Anda bisa memberi tahu unittest di mana harus menjalankan tes menggunakan flag -t untuk mengimpor modul dengan benar:

 $ python -m unittest discover -s tests -t src

unittest akan menemukan semua file test*.py di src/ direktori di dalam tests , dan kemudian jalankan.

Memahami Hasil Tes

Ini adalah contoh yang sangat sederhana di mana semuanya berjalan dengan baik, jadi mari kita coba untuk memahami hasil dari tes yang gagal.

sum() harus menerima daftar lain dari jenis numerik, misalnya pecahan.

Untuk awal kode di test.py tambahkan ekspresi untuk mengimpor tipe Fraction dari modul fractions dari perpustakaan standar.

 from fractions import Fraction

Sekarang tambahkan tes dengan pernyataan, mengharapkan nilai yang salah. Dalam kasus kami, kami berharap bahwa jumlah ¼, ¼ dan ⅖ akan sama dengan 1:

 import unittest from my_sum import sum class TestSum(unittest.TestCase): def test_list_int(self): """ Test that it can sum a list of integers """ data = [1, 2, 3] result = sum(data) self.assertEqual(result, 6) def test_list_fraction(self): """ Test that it can sum a list of fractions """ data = [Fraction(1, 4), Fraction(1, 4), Fraction(2, 5)] result = sum(data) self.assertEqual(result, 1) if __name__ == '__main__': unittest.main()

Jika Anda menjalankan tes lagi dengan python -m tes unittest, dapatkan yang berikut ini:

 $ python -m unittest test F. ====================================================================== FAIL: test_list_fraction (test.TestSum) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 21, in test_list_fraction self.assertEqual(result, 1) AssertionError: Fraction(9, 10) != 1 ---------------------------------------------------------------------- Ran 2 tests in 0.001s FAILED (failures=1)

Dalam output ini, Anda melihat yang berikut:

  • Baris pertama menunjukkan hasil semua tes: satu gagal (F), satu lulus (.);
  • GAGAL menunjukkan beberapa detail dari tes gagal:

  1. Nama metode pengujian ( test_list_fraction );
  2. Modul test ( test ) dan test case ( TestSum );
  3. String Traceback dengan kesalahan;
  4. Detail pernyataan dengan hasil yang diharapkan (1) dan hasil aktual (Fraksi (9, 10))

Ingat, Anda dapat menambahkan informasi tambahan ke output tes menggunakan flag -v ke perintah python -m unittest .

Menjalankan tes dari PyCharm

Jika Anda menggunakan PyCharm IDE, Anda dapat menjalankan unittest atau pytest dengan mengikuti langkah-langkah ini:

  1. Di jendela Alat proyek, pilih direktori tes.
  2. Di menu konteks, pilih perintah jalankan unittest. Sebagai contoh, 'Unittests in My Tests ...'.

Ini akan menjalankan unittest di jendela tes dan mengembalikan hasilnya di PyCharm:



Informasi lebih lanjut tersedia di situs web PyCharm .

Menjalankan Tes dari Visual Studio Code

Jika Anda menggunakan Microsoft Visual Studio Code IDE, dukungan untuk unittest, nose, dan pytest sudah ada di dalam plugin Python.

Jika sudah diinstal, Anda dapat mengonfigurasi konfigurasi tes dengan membuka Command Palette dengan Ctrl + Shift + P dan menulis "Python test". Anda akan melihat daftar opsi:



Pilih Debug All Unit Tests, setelah itu VSCode akan mengirim permintaan untuk mengonfigurasi kerangka uji. Klik gear untuk memilih test runner (unittest) dan direktori home (.).

Setelah menyelesaikan pengaturan, Anda akan melihat status tes di bagian bawah layar dan Anda dapat dengan cepat mengakses log uji dan memulai kembali tes dengan mengklik ikon:



Kami melihat bahwa tes sedang dilakukan, tetapi beberapa dari mereka gagal.

AKHIR

Pada bagian selanjutnya dari artikel ini, kita akan memeriksa tes untuk kerangka kerja seperti Django dan Flask.

Kami menunggu pertanyaan dan komentar Anda di sini dan, seperti biasa, Anda dapat pergi ke Stanislav pada hari terbuka .

Bagian kedua

Source: https://habr.com/ru/post/id433358/

More articles:


All Articles