Kerangka UnitTest - Panduan Cepat

Pengujian unit adalah metode pengujian perangkat lunak di mana unit individu dari kode sumber, seperti fungsi, metode, dan kelas diuji untuk menentukan apakah cocok untuk digunakan. Secara intuitif, seseorang dapat melihat sebuah unit sebagai bagian terkecil dari sebuah aplikasi yang dapat diuji. Tes unit adalah potongan kode pendek yang dibuat oleh pemrogram selama proses pengembangan. Ini membentuk dasar untuk pengujian komponen.

Pengujian unit dapat dilakukan dengan dua cara berikut -

Pengujian Manual	Pengujian Otomatis
Menjalankan kasus uji secara manual tanpa dukungan alat apa pun yang dikenal sebagai pengujian manual. Karena kasus uji dijalankan oleh sumber daya manusia jadi itu sangat time consuming and tedious. Karena kasus pengujian perlu dijalankan secara manual, maka lebih banyak penguji diperlukan dalam pengujian manual. Ini kurang dapat diandalkan karena pengujian mungkin tidak dilakukan dengan tepat setiap kali karena kesalahan manusia. Tidak ada pemrograman yang dapat dilakukan untuk menulis tes canggih yang mengambil informasi tersembunyi.	Mengambil dukungan alat dan menjalankan kasus uji dengan menggunakan alat otomatisasi dikenal sebagai pengujian otomatisasi. Otomatisasi Cepat menjalankan kasus uji secara signifikan lebih cepat daripada sumber daya manusia. Itu investment over human resources is less karena kasus uji dijalankan dengan menggunakan alat otomatisasi. Pengujian otomasi melakukan operasi yang persis sama setiap kali dijalankan dan are more reliable. Penguji can program sophisticated tests untuk mengeluarkan informasi tersembunyi.

JUnit adalah kerangka pengujian unit untuk bahasa pemrograman Java. JUnit berperan penting dalam pengembangan pengembangan yang digerakkan oleh pengujian, dan merupakan salah satu keluarga kerangka pengujian unit yang secara kolektif dikenal sebagai xUnit yang berasal dari JUnit. Anda dapat mengetahui Tutorial JUnit di sini.

Kerangka pengujian unit Python, kadang-kadang disebut sebagai "PyUnit," adalah JUnit versi bahasa Python yang dikembangkan oleh Kent Beck dan Erich Gamma. PyUnit merupakan bagian dari Python Standard Library sejak Python versi 2.1.

Kerangka pengujian unit Python mendukung otomatisasi pengujian, berbagi penyiapan dan kode penonaktifan untuk pengujian, agregasi pengujian ke dalam koleksi, dan independensi pengujian dari kerangka pelaporan. Modul unittest menyediakan kelas yang memudahkan untuk mendukung kualitas ini untuk serangkaian pengujian.

Tutorial ini telah disiapkan untuk pemula untuk membantu mereka memahami fungsionalitas dasar kerangka pengujian Python. Setelah menyelesaikan tutorial ini, Anda akan menemukan diri Anda pada tingkat keahlian sedang dalam menggunakan kerangka pengujian Python dari mana Anda dapat membawa diri Anda ke tingkat berikutnya.

Anda harus memiliki keahlian yang wajar dalam pengembangan perangkat lunak menggunakan bahasa Python. Tutorial Python kami adalah tempat yang baik untuk mulai belajar Python. Pengetahuan tentang dasar-dasar pengujian perangkat lunak juga diinginkan.

Pengaturan Lingkungan

Kelas-kelas yang diperlukan untuk menulis pengujian dapat ditemukan di modul 'unittest'. Jika Anda menggunakan Python versi lama (sebelum Python 2.1), modul dapat diunduh darihttp://pyunit.sourceforge.net/. Namun, modul unittest sekarang menjadi bagian dari distribusi Python standar; oleh karena itu tidak memerlukan instalasi terpisah.

'unittest' mendukung otomatisasi pengujian, berbagi pengaturan dan kode shutdown untuk pengujian, agregasi pengujian ke dalam koleksi, dan independensi pengujian dari kerangka pelaporan.

Modul unittest menyediakan kelas yang memudahkan untuk mendukung kualitas ini untuk serangkaian pengujian.

Untuk mencapai ini, unittest mendukung konsep penting berikut -

test fixture- Ini mewakili persiapan yang diperlukan untuk melakukan satu atau lebih tes, dan tindakan pembersihan asosiasi. Ini mungkin melibatkan, misalnya, membuat database sementara atau proxy, direktori, atau memulai proses server.
test case- Ini adalah unit pengujian terkecil. Ini memeriksa respons tertentu untuk serangkaian input tertentu. unittest menyediakan kelas dasar,TestCase, yang dapat digunakan untuk membuat kasus uji baru.
test suite- Ini adalah kumpulan kasus uji, rangkaian uji, atau keduanya. Ini digunakan untuk menggabungkan pengujian yang harus dijalankan bersama. Rangkaian pengujian diimplementasikan oleh kelas TestSuite.
test runner- Ini adalah komponen yang mengatur pelaksanaan tes dan memberikan hasilnya kepada pengguna. Pelari dapat menggunakan antarmuka grafis, antarmuka tekstual, atau mengembalikan nilai khusus untuk menunjukkan hasil pelaksanaan tes.

Membuat Tes Unit

Langkah-langkah berikut terlibat dalam menulis tes unit sederhana -

Step 1 - Impor modul unittest dalam program Anda.

Step 2- Tentukan fungsi yang akan diuji. Dalam contoh berikut, fungsi add () harus diuji.

Step 3 - Buat testcase dengan membuat subclass unittest.TestCase.

Step 4- Tentukan tes sebagai metode di dalam kelas. Nama metode harus dimulai dengan 'test'.

Step 5- Setiap panggilan tes menegaskan fungsi kelas TestCase. Ada banyak jenis asserts. Contoh berikut memanggil fungsi assertEquals ().

Step 6 - Fungsi assertEquals () membandingkan hasil fungsi add () dengan argumen arg2 dan menampilkan assertionError jika perbandingan gagal.

Step 7 - Terakhir, panggil metode main () dari modul unittest.

import unittest
def add(x,y):
   return x + y
   
class SimpleTest(unittest.TestCase):
   def testadd1(self):
      self.assertEquals(add(4,5),9)
      
if __name__ == '__main__':
   unittest.main()

Step 8 - Jalankan skrip di atas dari baris perintah.

C:\Python27>python SimpleTest.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK

Step 9 - Tiga hal berikut ini bisa menjadi hasil yang mungkin dari sebuah tes -

Sr Tidak	Pesan & Deskripsi
1	OK Tes berhasil. 'A' ditampilkan di konsol.
2	FAIL Tes tidak lulus, dan memunculkan pengecualian AssertionError. 'F' ditampilkan di konsol.
3	ERROR Tes ini memunculkan pengecualian selain AssertionError. 'E' ditampilkan di konsol.

Hasil ini masing-masing ditampilkan di konsol oleh '.', 'F' dan 'E'.

Antarmuka Baris Perintah

Modul unittest dapat digunakan dari baris perintah untuk menjalankan satu atau beberapa tes.

python -m unittest test1
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

unittest mendukung opsi baris perintah berikut. Untuk daftar semua opsi baris perintah, gunakan perintah berikut -

Python –m unittest -h

Sr Tidak	Opsi & Deskripsi
1	-h, --help Tunjukkan pesan ini
2	v, --verbose Keluaran panjang
3	-q, --quiet Output minimal
4	-f, --failfast Berhenti pada kegagalan pertama
5	-c, --catch Tangkap Control-C dan tampilkan hasil
6	-b, --buffer Buffer stdout dan stderr selama pengujian berjalan

Bab ini membahas kelas dan metode yang ditentukan dalam modul unittest. Ada lima kelas utama dalam modul ini.

Kelas TestCase

Objek kelas ini mewakili unit terkecil yang dapat diuji. Ini menahan rutinitas pengujian dan menyediakan kait untuk mempersiapkan setiap rutinitas dan untuk pembersihan setelahnya.

Metode berikut ditentukan di kelas TestCase -

Sr Tidak	Metode & Deskripsi
1	setUp() Metode dipanggil untuk mempersiapkan perlengkapan tes. Ini dipanggil segera sebelum memanggil metode pengujian
2	tearDown() Metode dipanggil segera setelah metode pengujian dipanggil dan hasilnya dicatat. Ini dipanggil meskipun metode pengujian memunculkan pengecualian,
3	setUpClass() Metode kelas yang dipanggil sebelum pengujian dalam menjalankan kelas individu.
4	tearDownClass() Metode kelas yang dipanggil setelah pengujian di kelas individu telah berjalan.
5	run(result = None) Jalankan tes, kumpulkan hasilnya ke dalam objek hasil tes yang lulus sebagai hasil .
6	skipTest(reason) Memanggil ini selama metode pengujian atau setUp () melompati pengujian saat ini.
7	debug() Jalankan tes tanpa mengumpulkan hasilnya.
8	shortDescription() Mengembalikan deskripsi tes satu baris.

Perlengkapan

Ada banyak tes yang ditulis di dalam kelas TestCase. Metode pengujian ini mungkin memerlukan koneksi database, file sementara atau sumber daya lain untuk diinisialisasi. Ini disebut perlengkapan. TestCase menyertakan pengait khusus untuk mengonfigurasi dan membersihkan semua perlengkapan yang diperlukan oleh pengujian Anda. Untuk mengonfigurasi perlengkapan, timpa setUp (). Untuk membersihkan, ganti tearDown ().

Dalam contoh berikut, dua pengujian ditulis di dalam kelas TestCase. Mereka menguji hasil penjumlahan dan pengurangan dua nilai. Metode setup () menginisialisasi argumen berdasarkan shortDescription () dari setiap pengujian. metode teardown () akan dijalankan di akhir setiap pengujian.

import unittest

class simpleTest2(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      if name == "Add":
         self.a = 10
         self.b = 20
         print name, self.a, self.b
      if name == "sub":
         self.a = 50
         self.b = 60
         print name, self.a, self.b
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
if __name__ == '__main__':
   unittest.main()

Jalankan kode di atas dari baris perintah. Ini memberikan hasil sebagai berikut -

C:\Python27>python test2.py
Add 10 20
F
end of test Add
sub 50 60
end of test sub
.
================================================================
FAIL: testadd (__main__.simpleTest2)
Add
----------------------------------------------------------------------
Traceback (most recent call last):
   File "test2.py", line 21, in testadd
      self.assertTrue(result == 100)
AssertionError: False is not true
----------------------------------------------------------------------
Ran 2 tests in 0.015s

FAILED (failures = 1)

Perlengkapan Kelas

Kelas TestCase memiliki metode setUpClass () yang dapat diganti untuk dieksekusi sebelum eksekusi pengujian individu di dalam kelas TestCase. Demikian pula, metode tearDownClass () akan dijalankan setelah semua pengujian di kelas. Kedua metode tersebut adalah metode kelas. Karenanya, mereka harus didekorasi dengan direktif @classmethod.

Contoh berikut menunjukkan penggunaan metode kelas ini -

import unittest

class TestFixtures(unittest.TestCase):

   @classmethod
   def setUpClass(cls):
      print 'called once before any tests in class'

   @classmethod
   def tearDownClass(cls):
      print '\ncalled once after all tests in class'

   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      print '\n',name
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def test1(self):
      """One"""
      result = self.a+self.b
      self.assertTrue(True)
   def test2(self):
      """Two"""
      result = self.a-self.b
      self.assertTrue(False)
      
if __name__ == '__main__':
unittest.main()

Kelas TestSuite

Kerangka pengujian Python menyediakan mekanisme yang berguna di mana contoh kasus uji dapat dikelompokkan bersama sesuai dengan fitur yang mereka uji. Mekanisme ini disediakan oleh kelas TestSuite dalam modul unittest.

Langkah-langkah berikut terlibat dalam membuat dan menjalankan rangkaian pengujian.

Step 1 - Buat instance kelas TestSuite.

suite = unittest.TestSuite()

Step 2 - Tambahkan tes di dalam kelas TestCase di suite.

suite.addTest(testcase class)

Step 3 - Anda juga bisa menggunakan metode makeSuite () untuk menambahkan tes dari kelas

suite = unittest.makeSuite(test case class)

Step 4 - Tes individual juga dapat ditambahkan di suite.

suite.addTest(testcaseclass(""testmethod")

Step 5 - Buat objek dari kelas TestTestRunner.

runner = unittest.TextTestRunner()

Step 6 - Panggil metode run () untuk menjalankan semua pengujian di suite

runner.run (suite)

Metode berikut ditentukan di kelas TestSuite -

Sr Tidak	Metode & Deskripsi
1	addTest() Menambahkan metode pengujian di rangkaian pengujian.
2	addTests() Menambahkan tes dari beberapa kelas TestCase.
3	run() Menjalankan pengujian yang terkait dengan rangkaian ini, mengumpulkan hasil ke dalam objek hasil pengujian
4	debug() Menjalankan pengujian yang terkait dengan rangkaian ini tanpa mengumpulkan hasilnya.
5	countTestCases() Mengembalikan jumlah tes yang diwakili oleh objek tes ini

Contoh berikut menunjukkan cara menggunakan kelas TestSuite -

import unittest
class suiteTest(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      
   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
def suite():
   suite = unittest.TestSuite()
##   suite.addTest (simpleTest3("testadd"))
##   suite.addTest (simpleTest3("testsub"))
   suite.addTest(unittest.makeSuite(simpleTest3))
   return suite
   
if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   runner.run (test_suite)

Anda bisa bereksperimen dengan metode addTest () dengan menghapus komentar pada baris dan pernyataan komentar yang memiliki metode makeSuite ().

Kelas TestLoader

Paket unittest memiliki kelas TestLoader yang digunakan untuk membuat rangkaian pengujian dari kelas dan modul. Secara default, instance unittest.defaultTestLoader dibuat secara otomatis ketika unittest.main (metode 0 dipanggil. Suatu instance eksplisit, namun memungkinkan penyesuaian properti tertentu.

Dalam kode berikut, pengujian dari dua kelas dikumpulkan dalam Daftar dengan menggunakan objek TestLoader.

import unittest
testList = [Test1, Test2]
testLoad = unittest.TestLoader()

TestList = []
for testCase in testList:
   testSuite = testLoad.loadTestsFromTestCase(testCase)
   TestList.append(testSuite)
   
newSuite = unittest.TestSuite(TestList)
runner = unittest.TextTestRunner()
runner.run(newSuite)

Tabel berikut menunjukkan daftar metode di kelas TestLoader -

S.No	Metode & Deskripsi
1	loadTestsFromTestCase() Kembalikan rangkaian dari semua kasus pengujian yang terdapat dalam kelas TestCase
2	loadTestsFromModule() Kembalikan rangkaian dari semua kasus pengujian yang terdapat dalam modul yang diberikan.
3	loadTestsFromName() Kembalikan rangkaian dari semua kasus pengujian yang diberi penentu string.
4	discover() Temukan semua modul pengujian dengan mengulang ke subdirektori dari direktori awal yang ditentukan, dan mengembalikan objek TestSuite

Kelas TestResult

Kelas ini digunakan untuk mengumpulkan informasi tentang tes yang berhasil dan tes yang gagal. Objek TestResult menyimpan hasil dari serangkaian pengujian. Instance TestResult dikembalikan oleh metode TestRunner.run ().

Instance TestResult memiliki atribut berikut -

Sr Tidak	Atribut & Deskripsi
1	Errors Daftar yang berisi 2-tupel instance TestCase dan string yang menyimpan traceback berformat. Setiap tupel merepresentasikan pengujian yang memunculkan pengecualian yang tidak terduga.
2	Failures Daftar yang berisi 2-tupel instance TestCase dan string yang menyimpan traceback berformat. Setiap tuple mewakili pengujian di mana kegagalan secara eksplisit ditandai menggunakan metode TestCase.assert * ().
3	Skipped Daftar yang berisi 2-tupel instance TestCase dan string yang berisi alasan melewatkan pengujian.
4	wasSuccessful() Kembalikan True jika semua pengujian yang dijalankan sejauh ini telah lulus, jika tidak, kembalikan False.
5	stop() Metode ini dapat dipanggil untuk memberi sinyal bahwa rangkaian pengujian yang sedang dijalankan harus dibatalkan.
6	startTestRun() Dipanggil sekali sebelum pengujian apa pun dijalankan.
7	stopTestRun() Dipanggil sekali setelah semua tes dijalankan.
8	testsRun Jumlah total pengujian yang dijalankan sejauh ini.
9	Buffer Jika disetel ke true, sys.stdout dan sys.stderr akan di-buffer di antara startTest () dan stopTest () dipanggil.

Kode berikut menjalankan rangkaian pengujian -

if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   result = runner.run (test_suite)
   
   print "---- START OF TEST RESULTS"
   print result

   print "result::errors"
   print result.errors

   print "result::failures"
   print result.failures

   print "result::skipped"
   print result.skipped

   print "result::successful"
   print result.wasSuccessful()
   
   print "result::test-run"
   print result.testsRun
   print "---- END OF TEST RESULTS"

Kode saat dijalankan menampilkan output berikut -

---- START OF TEST RESULTS
<unittest.runner.TextTestResult run = 2 errors = 0 failures = 1>
result::errors
[]
result::failures
[(<__main__.suiteTest testMethod = testadd>, 'Traceback (most recent call last):\n
   File "test3.py", line 10, in testadd\n 
   self.assertTrue(result == 100)\nAssert
   ionError: False is not true\n')]
result::skipped
[]
result::successful
False
result::test-run
2
---- END OF TEST RESULTS

Kerangka pengujian Python menggunakan fungsi assert () bawaan Python yang menguji kondisi tertentu. Jika pernyataan gagal, AssertionError akan dimunculkan. Kerangka pengujian kemudian akan mengidentifikasi pengujian sebagai Kegagalan. Pengecualian lain diperlakukan sebagai Error.

Tiga set fungsi pernyataan berikut didefinisikan dalam modul unittest -

Boolean Asserts Dasar
Comparative Asserts
Ditegaskan untuk Koleksi

Fungsi pernyataan dasar mengevaluasi apakah hasil operasi True atau False. Semua metode assert menerima amsg argumen yang, jika ditentukan, digunakan sebagai pesan kesalahan tentang kegagalan.

Sr Tidak	Metode & Deskripsi
1	assertEqual(arg1, arg2, msg = None) Uji apakah arg1 dan arg2 sama. Jika nilainya tidak sama, pengujian akan gagal.
2	assertNotEqual(arg1, arg2, msg = None) Uji bahwa arg1 dan arg2 tidak sama. Jika nilainya sama, pengujian akan gagal.
3	assertTrue(expr, msg = None) Uji bahwa expr benar. Jika salah, pengujian gagal
4	assertFalse(expr, msg = None) Uji bahwa expr salah. Jika benar, pengujian gagal
5	assertIs(arg1, arg2, msg = None) Uji apakah arg1 dan arg2 mengevaluasi ke objek yang sama.
6	assertIsNot(arg1, arg2, msg = None) Uji bahwa arg1 dan arg2 tidak mengevaluasi objek yang sama.
7	assertIsNone(expr, msg = None) Uji bahwa expr adalah None. Jika tidak ada, pengujian gagal
8	assertIsNotNone(expr, msg = None) Uji bahwa expr bukan Tidak ada. Jika Tidak Ada, pengujian gagal
9	assertIn(arg1, arg2, msg = None) Uji apakah arg1 ada dalam arg2 .
10	assertNotIn(arg1, arg2, msg = None) Uji bahwa arg1 tidak ada dalam arg2 .
11	assertIsInstance(obj, cls, msg = None) Uji bahwa obj adalah turunan dari cls
12	assertNotIsInstance(obj, cls, msg = None) Uji bahwa obj bukan merupakan turunan dari cls

Beberapa fungsi pernyataan di atas diimplementasikan dalam kode berikut -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertEqual(4 + 5,9)
   def test2(self):
      self.assertNotEqual(5 * 2,10)
   def test3(self):
      self.assertTrue(4 + 5 == 9,"The result is False")
   def test4(self):
      self.assertTrue(4 + 5 == 10,"assertion fails")
   def test5(self):
      self.assertIn(3,[1,2,3])
   def test6(self):
      self.assertNotIn(3, range(5))

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

Ketika skrip di atas dijalankan, test2, test4 dan test6 akan menunjukkan kegagalan dan lainnya berjalan dengan sukses.

FAIL: test2 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 9, in test2
      self.assertNotEqual(5*2,10)
AssertionError: 10 == 10

FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 13, in test4
      self.assertTrue(4+5==10,"assertion fails")
AssertionError: assertion fails

FAIL: test6 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 17, in test6
      self.assertNotIn(3, range(5))
AssertionError: 3 unexpectedly found in [0, 1, 2, 3, 4]

----------------------------------------------------------------------            
Ran 6 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 3)

Kumpulan fungsi pernyataan kedua adalah comparative asserts −

assertAlmostEqual (pertama, kedua, tempat = 7, msg = Tidak ada, delta = Tidak ada)

Uji bahwa pertama dan kedua kira-kira (atau tidak kira-kira) sama dengan menghitung selisihnya, membulatkan ke jumlah tempat desimal yang ditentukan (default 7),
assertNotAlmostEqual (pertama, kedua, tempat, pesan, delta)

Ujilah bahwa pertama dan kedua tidak kira-kira sama dengan menghitung selisihnya, membulatkan ke jumlah tempat desimal tertentu (default 7), dan membandingkannya dengan nol.

Dalam kedua fungsi di atas, jika delta disuplai dan bukan tempat, maka perbedaan antara pertama dan kedua harus kurang atau sama dengan (atau lebih besar dari) delta.

Memasok delta dan tempat memunculkan TypeError.
assertGreater (pertama, kedua, msg = Tidak Ada)

Uji yang pertama lebih besar dari yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal.
assertGreaterEqual (pertama, kedua, msg = Tidak Ada)

Uji yang pertama lebih besar dari atau sama dengan kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal
assertLess (pertama, kedua, msg = Tidak Ada)

Uji yang pertama kurang dari yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal
assertLessEqual (pertama, kedua, msg = Tidak Ada)

Uji yang pertama kurang dari atau sama dengan yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal.
assertRegexpMatches (teks, ekspresi reguler, msg = Tidak Ada)

Uji apakah pencarian regexp cocok dengan teks. Jika terjadi kegagalan, pesan kesalahan akan menyertakan pola dan teks. regexp dapat berupa objek ekspresi reguler atau string yang berisi ekspresi reguler yang cocok untuk digunakan olehre.search().
assertNotRegexpMatches (teks, ekspresi reguler, msg = Tidak Ada)

Memverifikasi bahwa pencarian regexp tidak cocok dengan teks . Gagal dengan pesan kesalahan termasuk pola dan bagian teks yang cocok. regexp dapat berupa objek ekspresi reguler atau string yang berisi ekspresi reguler yang cocok untuk digunakan olehre.search().

Fungsi pernyataan diimplementasikan dalam contoh berikut -

import unittest
import math
import re

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertAlmostEqual(22.0/7,3.14)
   def test2(self):
      self.assertNotAlmostEqual(10.0/3,3)
   def test3(self):
      self.assertGreater(math.pi,3)
   def test4(self):
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")

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

Skrip di atas melaporkan test1 dan test4 sebagai Kegagalan. Dalam test1, pembagian 22/7 tidak berada dalam 7 tempat desimal 3,14. Demikian pula, karena argumen kedua cocok dengan teks dalam argumen pertama, test4 menghasilkan AssertionError.

=====================================================FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 7, in test1
      self.assertAlmostEqual(22.0/7,3.14)
AssertionError: 3.142857142857143 != 3.14 within 7 places
================================================================
FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 13, in test4
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")
AssertionError: Regexp matched: 'Point' matches 'Point' in 'Tutorials Point (I)
Private Limited'
----------------------------------------------------------------------

Ran 4 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)

Tegaskan untuk Koleksi

Kumpulan fungsi assert ini dimaksudkan untuk digunakan dengan tipe data kumpulan di Python, seperti List, Tuple, Dictionary dan Set.

Sr Tidak	Metode & Deskripsi
1	assertListEqual (list1, list2, msg = None) Menguji bahwa dua daftar sama. Jika tidak, pesan kesalahan dibuat yang hanya menunjukkan perbedaan antara keduanya.
2	assertTupleEqual (tuple1, tuple2, msg = None) Menguji bahwa dua tupel sama. Jika tidak, pesan kesalahan dibuat yang hanya menunjukkan perbedaan antara keduanya.
3	assertSetEqual (set1, set2, msg = None) Menguji bahwa dua set sama. Jika tidak, pesan kesalahan dibuat yang mencantumkan perbedaan antara set.
4	assertDictEqual (expected, actual, msg = None) Ujilah bahwa dua kamus itu sama. Jika tidak, pesan kesalahan akan dibuat yang menunjukkan perbedaan dalam kamus.

Contoh berikut mengimplementasikan metode di atas -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertListEqual([2,3,4], [1,2,3,4,5])
   def test2(self):
      self.assertTupleEqual((1*2,2*2,3*2), (2,4,6))
   def test3(self):
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})

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

Dalam contoh di atas, test1 dan test3 menampilkan AssertionError. Pesan kesalahan menampilkan perbedaan dalam objek Daftar dan Kamus.

FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 5, in test1
      self.assertListEqual([2,3,4], [1,2,3,4,5])
AssertionError: Lists differ: [2, 3, 4] != [1, 2, 3, 4, 5]

First differing element 0:
2
1

Second list contains 2 additional elements.
First extra element 3:
4

- [2, 3, 4]
+ [1, 2, 3, 4, 5]
? +++       +++

FAIL: test3 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 9, in test3
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})
AssertionError: {1: 11, 2: 22} != {1: 11, 2: 22, 3: 33}
- {1: 11, 2: 22}
+ {1: 11, 2: 22, 3: 33}
?              +++++++
                                                                                  
----------------------------------------------------------------------            
Ran 3 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)

Kelas TestLoader memiliki fungsi discover (). Kerangka pengujian Python menggunakan ini untuk penemuan pengujian sederhana. Agar kompatibel, modul dan paket yang berisi pengujian harus dapat diimpor dari direktori tingkat atas.

Berikut ini adalah penggunaan baris perintah dasar dari penemuan pengujian -

Python –m unittest discover

Interpreter mencoba memuat semua modul yang berisi pengujian dari direktori saat ini dan direktori dalam secara rekursif. Opsi baris perintah lainnya adalah -

Sr Tidak	Opsi & Deskripsi
1	-v, --verbose Keluaran panjang
2	-s, --start-directory direktori Direktori untuk memulai penemuan (. default)
3	-p, --pattern Pola pola untuk mencocokkan file uji (uji * .py default)
4	-t, --top-level-directory direktori Direktori tingkat atas proyek (default untuk memulai direktori)

Misalnya, untuk menemukan tes dalam modul yang namanya dimulai dengan 'assert' di direktori 'tes', baris perintah berikut digunakan -

C:\python27>python –m unittest –v –s "c:\test" –p "assert*.py"

Test discovery memuat pengujian dengan mengimpornya. Setelah penemuan pengujian menemukan semua file pengujian dari direktori awal yang Anda tentukan, ini mengubah jalur menjadi nama paket untuk diimpor.

Jika Anda menyediakan direktori awal sebagai nama paket daripada jalur ke direktori, maka penemuan mengasumsikan bahwa lokasi mana pun yang diimpornya adalah lokasi yang Anda inginkan, jadi Anda tidak akan mendapatkan peringatan.

Dukungan untuk melewatkan tes telah ditambahkan sejak Python 2.7. Dimungkinkan untuk melewati metode pengujian individu atau kelas TestCase, baik bersyarat maupun tanpa syarat. Kerangka kerja ini memungkinkan pengujian tertentu untuk ditandai sebagai 'kegagalan yang diharapkan'. Tes ini akan 'gagal' tetapi tidak akan dihitung sebagai gagal di TestResult.

Untuk melewati metode tanpa syarat, metode kelas unittest.skip () berikut dapat digunakan -

import unittest

   def add(x,y):
      return x+y

class SimpleTest(unittest.TestCase):
   @unittest.skip("demonstrating skipping")
   def testadd1(self):
      self.assertEquals(add(4,5),9)

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

Karena skip () adalah metode kelas, ini diawali dengan @ token. Metode ini mengambil satu argumen: pesan log yang menjelaskan alasan lewati.

Ketika skrip di atas dijalankan, hasil berikut ditampilkan di konsol -

C:\Python27>python skiptest.py
s
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK (skipped = 1)

Karakter 's' menunjukkan bahwa tes telah dilewati.

Sintaks alternatif untuk melewatkan pengujian menggunakan metode instance skipTest () di dalam fungsi pengujian.

def testadd2(self):
   self.skipTest("another method for skipping")
   self.assertTrue(add(4 + 5) == 10)

Dekorator berikut menerapkan pengabaian pengujian dan kemungkinan kegagalan -

Sr Tidak	Metode & Deskripsi
1	unittest.skip(reason) Lewati tes yang didekorasi tanpa syarat. alasan harus menjelaskan mengapa tes dilewati.
2	unittest.skipIf(condition, reason) Lewati tes yang didekorasi jika kondisinya benar.
3	unittest.skipUnless(condition, reason) Lewati tes yang didekorasi kecuali kondisinya benar.
4	unittest.expectedFailure() Tandai tes sebagai kegagalan yang diharapkan. Jika pengujian gagal saat dijalankan, pengujian tersebut tidak dihitung sebagai kegagalan.

Contoh berikut menunjukkan penggunaan lompatan bersyarat dan kegagalan yang diharapkan.

import unittest

class suiteTest(unittest.TestCase):
   a = 50
   b = 40
   
   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertEqual(result,100)

   @unittest.skipIf(a>b, "Skip over this routine")
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
   
   @unittest.skipUnless(b == 0, "Skip over this routine")
   def testdiv(self):
      """div"""
      result = self.a/self.b
      self.assertTrue(result == 1)

   @unittest.expectedFailure
   def testmul(self):
      """mul"""
      result = self.a*self.b
      self.assertEqual(result == 0)

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

Dalam contoh di atas, testub () dan testdiv () akan dilewati. Dalam kasus pertama a> b benar, sedangkan pada kasus kedua b == 0 tidak benar. Di sisi lain, testmul () telah ditandai sebagai kegagalan yang diharapkan.

Ketika skrip di atas dijalankan, dua tes yang dilewati menunjukkan 's' dan kegagalan yang diharapkan ditampilkan sebagai 'x'.

C:\Python27>python skiptest.py
Fsxs
================================================================
FAIL: testadd (__main__.suiteTest)
Add
----------------------------------------------------------------------
Traceback (most recent call last):
   File "skiptest.py", line 9, in testadd
      self.assertEqual(result,100)
AssertionError: 90 != 100

----------------------------------------------------------------------
Ran 4 tests in 0.000s

FAILED (failures = 1, skipped = 2, expected failures = 1)

Framework pengujian Python menyediakan metode pernyataan berikut untuk memeriksa apakah pengecualian dimunculkan.

assertRaises (pengecualian, dapat dipanggil, * args, ** kwds)

Uji apakah pengecualian (argumen pertama) dimunculkan ketika sebuah fungsi dipanggil dengan argumen posisi atau kata kunci apa pun. Tes lulus jika pengecualian yang diharapkan dimunculkan, merupakan kesalahan jika pengecualian lain dimunculkan, atau gagal jika tidak ada pengecualian yang dimunculkan. Untuk menangkap salah satu grup pengecualian, tupel yang berisi kelas pengecualian dapat dilewatkan sebagai pengecualian.

Dalam contoh di bawah ini, fungsi pengujian ditentukan untuk memeriksa apakah ZeroDivisionError dimunculkan.

import unittest

def div(a,b):
   return a/b
class raiseTest(unittest.TestCase):
   def testraise(self):
      self.assertRaises(ZeroDivisionError, div, 1,0)

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

Fungsi testraise () menggunakan fungsi assertRaises () untuk melihat apakah pembagian dengan nol terjadi saat fungsi div () dipanggil. Kode di atas akan memunculkan pengecualian. Tetapi mengubah argumen menjadi fungsi div () sebagai berikut -

self.assertRaises(ZeroDivisionError, div, 1,1)

Ketika kode dijalankan dengan perubahan ini, pengujian gagal karena ZeroDivisionError tidak terjadi.

F
================================================================
FAIL: testraise (__main__.raiseTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "raisetest.py", line 7, in testraise
      self.assertRaises(ZeroDivisionError, div, 1,1)
AssertionError: ZeroDivisionError not raised

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures = 1)

assertRaisesRegexp (pengecualian, regexp, callable, * args, ** kwds)

Menguji apakah regexp cocok dengan representasi string dari pengecualian yang dimunculkan. regexp dapat berupa objek ekspresi reguler atau string yang berisi ekspresi reguler yang cocok untuk digunakan oleh re.search ().

Contoh berikut menunjukkan bagaimana assertRaisesRegexp () digunakan -

import unittest
import re

class raiseTest(unittest.TestCase):
   def testraiseRegex(self):
      self.assertRaisesRegexp(TypeError, "invalid", reg,"Point","TutorialsPoint")
      
if __name__ == '__main__':
   unittest.main()

Di sini, testraseRegex () test tidak gagal sebagai argumen pertama. "Point" ditemukan di string argumen kedua.

================================================================
FAIL: testraiseRegex (__main__.raiseTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:/Python27/raiseTest.py", line 11, in testraiseRegex
      self.assertRaisesRegexp(TypeError, "invalid", reg,"Point","TutorialsPoint")
AssertionError: TypeError not raised
----------------------------------------------------------------------

Namun, perubahannya seperti yang ditunjukkan di bawah ini -

self.assertRaisesRegexp(TypeError, "invalid", reg,123,"TutorialsPoint")

Pengecualian TypeError akan dilempar. Karenanya, hasil berikut akan ditampilkan -

================================================================
FAIL: testraiseRegex (__main__.raiseTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "raisetest.py", line 11, in testraiseRegex
      self.assertRaisesRegexp(TypeError, "invalid", reg,123,"TutorialsPoint")
AssertionError: "invalid" does not match 
   "first argument must be string or compiled pattern"
----------------------------------------------------------------------

Junit, kerangka pengujian unit Java (Pyunit adalah implementasi JUnit) memiliki opsi waktu tunggu yang praktis. Jika tes memakan waktu lebih dari waktu yang ditentukan, itu akan ditandai sebagai gagal.

Kerangka pengujian Python tidak mendukung waktu habis. Namun, modul bagian ketiga yang disebut dekorator batas waktu dapat melakukan pekerjaan itu.

Unduh dan instal modul dari -

https://pypi.python.org/packages/source/t/timeout-decorator/timeout-decorator-0.3.2.tar.gz

Impor timeout_decorator ke dalam kode
Letakkan dekorator batas waktu sebelum ujian
@timeout_decorator.timeout(10)

Jika metode pengujian di bawah garis ini membutuhkan lebih dari waktu tunggu yang disebutkan (10 menit) di sini, TimeOutError akan dimunculkan. Misalnya -

import time
import timeout_decorator

class timeoutTest(unittest.TestCase):

   @timeout_decorator.timeout(5)
   def testtimeout(self):
      print "Start"
   for i in range(1,10):
      time.sleep(1)
      print "%d seconds have passed" % i
      
if __name__ == '__main__':
   unittest.main()

unittest2 adalah backport dari fitur tambahan yang ditambahkan ke framework pengujian Python di Python 2.7 dan seterusnya. Ini diuji untuk dijalankan pada Python 2.6, 2.7, dan 3. *. Versi terbaru dapat diunduh darihttps://pypi.python.org/pypi/unittest2

Untuk menggunakan unittest2 dan bukan unittest, cukup ganti import unittest dengan import unittest2.

Kelas di unittest2 berasal dari kelas yang sesuai di unittest, jadi harus memungkinkan untuk menggunakan infrastruktur pengujian unittest2 yang berjalan tanpa harus mengalihkan semua pengujian Anda ke menggunakan unittest2 dengan segera. Jika Anda berniat untuk mengimplementasikan fitur baru, buat subkelas testcase Anda dariunittest2.TestCase alih-alih unittest.TestCase

Berikut ini adalah fitur-fitur baru unittest2 -

addCleanups untuk manajemen sumber daya yang lebih baik
Berisi banyak metode pernyataan baru
assertRaises sebagai pengelola konteks, dengan akses ke pengecualian setelahnya
Memiliki perlengkapan tingkat modul seperti setUpModule dan tearDownModule
Termasuk load_tests protokol untuk memuat tes dari modul atau paket
startTestRun dan stopTestRun metode di TestResult

Di Python 2.7, Anda menjalankan fitur baris perintah yang paling lengkap (termasuk uji temukan) dengan python -m unittest <args>.

Sebagai gantinya, unittest2 hadir dengan unit skrip2.

unit2 discover
unit2 -v test_module

Penanganan control-C yang lebih efisien selama uji coba disediakan oleh opsi baris perintah -c / - catch ke unittest, bersama dengan catchbreakparameter. Dengan mengaktifkan perilaku catch break, control-C akan memungkinkan pengujian yang sedang berjalan untuk diselesaikan, dan pengujian yang dijalankan kemudian akan berakhir dan melaporkan semua hasil sejauh ini. Kontrol kedua-c akan memunculkan KeyboardInterrupt dengan cara biasa.

Jika penangan unittest dipanggil tetapi penangan signal.SIGINT belum diinstal, maka ia akan memanggil penangan default. Ini biasanya akan menjadi perilaku yang diharapkan oleh kode yang menggantikan penangan yang diinstal dan mendelegasikannya. Untuk pengujian individual yang memerlukan penanganan control-c unittest dinonaktifkan, dekorator removeHandler () dapat digunakan.

Fungsi utilitas berikut memungkinkan fungsionalitas penanganan kontrol-c dalam kerangka kerja pengujian -

unittest.installHandler ()

Pasang pengendali control-c. Ketika sebuahsignal.SIGINT diterima semua hasil terdaftar memiliki TestResult.stop () yang dipanggil.

unittest.registerResult (hasil)

Daftar a TestResultobjek untuk penanganan control-c. Mendaftarkan hasil menyimpan referensi yang lemah ke sana, sehingga tidak mencegah hasil dikumpulkan dari sampah.

unittest.removeResult (hasil)

Hapus hasil terdaftar. Setelah hasil dihapus maka TestResult.stop () tidak akan lagi dipanggil pada objek hasil tersebut sebagai respons terhadap control-c.

unittest.removeHandler (function = None)

Saat dipanggil tanpa argumen, fungsi ini menghapus pengendali control-c jika sudah diinstal. Fungsi ini juga dapat digunakan sebagai penghias tes untuk sementara menghapus penangan saat tes sedang dijalankan.

Pelari Uji GUI

Modul unittest diinstal untuk menemukan dan menjalankan pengujian secara interaktif. Utilitas ini, skrip Python 'inittestgui.py' menggunakan modul Tkinter yang merupakan port Python untuk kit alat grafis TK. Ini memberikan GUI yang mudah digunakan untuk menemukan dan menjalankan tes.

Python unittestgui.py

Klik tombol 'Temukan Tes'. Kotak dialog kecil muncul di mana Anda dapat memilih direktori dan modul dari mana pengujian akan dijalankan.

Terakhir, klik tombol start. Tes akan ditemukan dari jalur yang dipilih dan nama modul, dan panel hasil akan menampilkan hasilnya.

Untuk melihat rincian tes individu, pilih dan klik tes di kotak hasil -

Jika Anda tidak menemukan utilitas ini di instalasi Python, Anda bisa mendapatkannya dari halaman proyek http://pyunit.sourceforge.net/.

Serupa, utilitas berdasarkan toolkit wxpython juga tersedia di sana.

Distribusi standar Python berisi modul 'Doctest'. Fungsionalitas modul ini memungkinkan untuk mencari potongan teks yang terlihat seperti sesi Python interaktif, dan menjalankan sesi ini untuk melihat apakah mereka bekerja persis seperti yang ditunjukkan.

Doctest bisa sangat berguna dalam skenario berikut -

Untuk memeriksa apakah docstrings modul adalah yang terbaru dengan memverifikasi bahwa semua contoh interaktif masih berfungsi seperti yang didokumentasikan.
Untuk melakukan pengujian regresi dengan memverifikasi bahwa contoh interaktif dari file pengujian atau objek pengujian berfungsi seperti yang diharapkan.
Untuk menulis dokumentasi tutorial untuk sebuah paket, diilustrasikan secara bebas dengan contoh input-output

Dalam Python, 'docstring' adalah literal string yang muncul sebagai ekspresi pertama dalam kelas, fungsi, atau modul. Ini diabaikan ketika suite dijalankan, tetapi dikenali oleh kompilator dan dimasukkan ke dalam__doc__atribut dari kelas, fungsi atau modul yang melampirkan. Karena tersedia melalui introspeksi, ini adalah tempat kanonik untuk dokumentasi objek.

Ini adalah praktik biasa untuk menempatkan contoh penggunaan berbagai bagian kode Python di dalam docstring. Modul doctest memungkinkan untuk memverifikasi bahwa docstrings ini adalah yang terbaru dengan revisi berkala dalam kode.

Dalam kode berikut, fungsi faktorial didefinisikan diselingi dengan contoh penggunaan. Untuk memverifikasi apakah penggunaan contoh benar, panggil fungsi testmod () dalam modul doctest.

"""
This is the "example" module.

The example module supplies one function, factorial(). For example,

>>> factorial(5)
120
"""

def factorial(x):
   """Return the factorial of n, an exact integer >= 0.
   >>> factorial(-1)
   Traceback (most recent call last):
      ...
   ValueError: x must be >= 0
   """
   
   if not x >= 0:
      raise ValueError("x must be >= 0")
   f = 1
   for i in range(1,x+1):
      f = f*i
   return f
   
if __name__ == "__main__":
   import doctest
   doctest.testmod()

Masukkan dan simpan skrip di atas sebagai FactDocTest.py dan coba jalankan skrip ini dari baris perintah.

Python FactDocTest.py

Tidak ada keluaran yang akan ditampilkan kecuali contoh gagal. Sekarang, ubah baris perintah menjadi berikut -

Python FactDocTest.py –v

Konsol sekarang akan menampilkan keluaran berikut -

C:\Python27>python FactDocTest.py -v
Trying:
   factorial(5)
Expecting:
   120
ok
Trying:
   factorial(-1)
Expecting:
   Traceback (most recent call last):
      ...
   ValueError: x must be >= 0
ok
2 items passed all tests:
   1 tests in __main__
   1 tests in __main__.factorial
2 tests in 2 items.
2 passed and 0 failed.
Test passed.

Sebaliknya, jika kode fungsi factorial () tidak memberikan hasil yang diharapkan dalam docstring, maka hasil kegagalan akan ditampilkan. Misalnya, ubah f = 2 menggantikan f = 1 pada skrip di atas dan jalankan doctest lagi. Hasilnya adalah sebagai berikut -

Trying:
   factorial(5)
Expecting:
   120
**********************************************************************
File "docfacttest.py", line 6, in __main__
Failed example:
factorial(5)
Expected:
   120
Got:
   240
Trying:
   factorial(-1)
Expecting:
   Traceback (most recent call last):
      ...
   ValueError: x must be >= 0
ok
1 items passed all tests:
   1 tests in __main__.factorial
**********************************************************************
1 items had failures:
   1 of 1 in __main__
2 tests in 2 items.
1 passed and 1 failed.
***Test Failed*** 1 failures.

Doctest: Memeriksa Contoh di File Teks

Aplikasi doctest sederhana lainnya adalah menguji contoh-contoh interaktif dalam file teks. Ini bisa dilakukan dengan fungsi testfile ().

Teks berikut disimpan dalam file teks bernama 'example.txt'.

Using ''factorial''
-------------------
This is an example text file in reStructuredText format. First import
''factorial'' from the ''example'' module:
   >>> from example import factorial
Now use it:
   >>> factorial(5)
   120

Isi file diperlakukan sebagai docstring. Untuk memverifikasi contoh dalam file teks, gunakan fungsi testfile () modul doctest.

def factorial(x):
   if not x >= 0:
      raise ValueError("x must be >= 0")
   f = 1
   for i in range(1,x+1):
      f = f*i
   return f
   
if __name__ == "__main__":
   import doctest
   doctest.testfile("example.txt")

Seperti testmod (), testfile () tidak akan menampilkan apa pun kecuali sebuah contoh gagal. Jika sebuah contoh gagal, maka contoh yang gagal dan penyebab kegagalan dicetak ke konsol, menggunakan format yang sama seperti testmod ().
Dalam kebanyakan kasus, salin dan tempel sesi konsol interaktif berfungsi dengan baik, tetapi doctest tidak mencoba melakukan emulasi yang tepat dari shell Python tertentu.
Setiap keluaran yang diharapkan harus segera mengikuti baris '>>>' atau '...' terakhir yang berisi kode, dan keluaran yang diharapkan (jika ada) meluas ke baris '>>>' atau semua spasi kosong berikutnya.
Keluaran yang diharapkan tidak boleh berisi baris spasi kosong, karena baris tersebut diambil sebagai sinyal akhir dari keluaran yang diharapkan. Jika keluaran yang diharapkan memang berisi baris kosong, letakkan <BLANKLINE> dalam contoh doctest Anda di setiap tempat yang diharapkan baris kosong.

API doctest berkisar pada dua kelas kontainer berikut yang digunakan untuk menyimpan contoh interaktif dari docstrings -

Example - Pernyataan Python tunggal, dipasangkan dengan keluaran yang diharapkan.
DocTest - Kumpulan Contoh, biasanya diekstrak dari satu file docstring atau teks.

Kelas pemrosesan tambahan berikut ditentukan untuk menemukan, mengurai, dan menjalankan, dan memeriksa contoh doctest -

DocTestFinder - Menemukan semua docstring dalam modul tertentu, dan menggunakan DocTestParser untuk membuat DocTest dari setiap docstring yang berisi contoh interaktif.
DocTestParser - Membuat objek doctest dari string (seperti docstring objek).
DocTestRunner - Menjalankan contoh dalam doctest, dan menggunakan OutputChecker untuk memverifikasi keluarannya.
OutputChecker - Membandingkan keluaran aktual dari contoh doctest dengan keluaran yang diharapkan, dan memutuskan apakah keluaran tersebut cocok.

Kelas DocTestFinder

Ini adalah kelas pemrosesan yang digunakan untuk mengekstrak doctests yang relevan dengan objek tertentu, dari docstringnya dan docstring dari objek yang ada di dalamnya. Doctests saat ini dapat diekstrak dari jenis objek berikut - modul, fungsi, kelas, metode, metode statis, metode kelas, dan properti.

Kelas ini mendefinisikan metode find (). Ia mengembalikan daftar doctests yang didefinisikan oleh objek docstring, atau oleh salah docstrings benda yang terkandung.

DocTestParser Class

Ini adalah kelas pemrosesan yang digunakan untuk mengekstrak contoh interaktif dari string, dan menggunakannya untuk membuat objek DocTest. Kelas ini mendefinisikan metode berikut -

get_doctest() - Ekstrak semua contoh doctest dari string yang diberikan, dan kumpulkan menjadi file DocTest obyek.
get_examples(string[, name]) - Ekstrak semua contoh doctest dari string yang diberikan, dan kembalikan sebagai daftar Examplebenda. Nomor baris berbasis 0. Nama argumen opsional adalah nama yang mengidentifikasi string ini, dan hanya digunakan untuk pesan kesalahan.
parse(string[, name]) - Bagi string yang diberikan menjadi contoh dan teks intervensi, dan kembalikan sebagai daftar bolak-balik Examplesdan string. Nomor baris untukExamplesberbasis 0. Nama argumen opsional adalah nama yang mengidentifikasi string ini, dan hanya digunakan untuk pesan kesalahan.

Kelas DocTestRunner

Ini adalah kelas pemrosesan yang digunakan untuk menjalankan dan memverifikasi contoh interaktif di DocTest. Metode berikut ditentukan di dalamnya -

report_start ()

Laporkan bahwa runner pengujian akan memproses contoh yang diberikan. Metode ini disediakan untuk mengizinkan subclass dariDocTestRunneruntuk menyesuaikan keluaran mereka; itu tidak harus dipanggil secara langsung

report_success ()

Laporkan bahwa contoh yang diberikan berhasil dijalankan. Metode ini disediakan untuk memungkinkan subclass DocTestRunner menyesuaikan keluarannya; itu tidak harus dipanggil secara langsung.

report_failure ()

Laporkan bahwa contoh yang diberikan gagal. Metode ini disediakan untuk mengizinkan subclass dariDocTestRunneruntuk menyesuaikan keluaran mereka; itu tidak harus dipanggil secara langsung.

report_unexpected_exception ()

Laporkan bahwa contoh yang diberikan memunculkan pengecualian yang tidak terduga. Metode ini disediakan untuk memungkinkan subclass DocTestRunner menyesuaikan keluarannya; itu tidak harus dipanggil secara langsung.

jalankan (uji)

Jalankan contoh dalam pengujian (objek DocTest), dan tampilkan hasilnya menggunakan fungsi penulis keluar .

meringkas ([verbose])

Cetak ringkasan semua kasus uji yang telah dijalankan oleh DocTestRunner ini, dan kembalikan tuple TestResults bernama (gagal, dicoba). Argumen verbose opsional mengontrol seberapa detail ringkasannya. Jika verbositas tidak ditentukan, maka verbositas DocTestRunner digunakan.

Kelas OutputChecker

Kelas ini digunakan untuk memeriksa apakah keluaran aktual dari contoh doctest cocok dengan keluaran yang diharapkan.

Metode berikut ditentukan di kelas ini -

check_output ()

Kembali Truejika keluaran aktual dari sebuah contoh ( mendapat ) cocok dengan keluaran yang diharapkan ( inginkan ). String ini selalu dianggap cocok jika identik; tetapi bergantung pada tanda opsi apa yang digunakan runner pengujian, beberapa jenis pencocokan tidak tepat juga dimungkinkan. Lihat bagian Option Flags and Directive untuk informasi lebih lanjut tentang option flags.

output_difference ()

Kembalikan string yang menjelaskan perbedaan antara output yang diharapkan untuk contoh yang diberikan ( contoh ) dan output aktual ( dapatkan ).

Integrasi DocTest dengan Unittest

Modul doctest menyediakan dua fungsi yang dapat digunakan untuk membuat rangkaian pengujian yang paling lengkap dari modul dan file teks yang berisi doctests. Untuk mengintegrasikan dengan penemuan pengujian yang tidak terkalahkan, sertakan fungsi load_tests () dalam modul pengujian Anda -

import unittest
import doctest
import doctestexample

def load_tests(loader, tests, ignore):
   tests.addTests(doctest.DocTestSuite(doctestexample))
   return tests

TestSuite gabungan dari pengujian dari unittest serta doctest akan dibentuk dan sekarang dapat dijalankan dengan metode main () modul atau run ().

Berikut ini adalah dua fungsi utama untuk membuat unittest.TestSuite contoh dari file teks dan modul dengan doctests -

doctest.DocFileSuite ()

Ini digunakan untuk mengubah tes doctest dari satu atau lebih file teks ke file unittest.TestSuite. Unittest.TestSuite yang dikembalikan harus dijalankan oleh kerangka kerja unittest dan menjalankan contoh interaktif di setiap file. Jika salah satu contoh dalam file gagal, maka pengujian unit yang disintesis gagal, dan afailureException Exception dimunculkan dengan menampilkan nama file yang berisi tes dan nomor baris (terkadang perkiraan).

doctest.DocTestSuite ()

Ini digunakan untuk mengubah tes doctest untuk modul menjadi unittest.TestSuite.

Unittest.TestSuite yang dikembalikan harus dijalankan oleh kerangka kerja unittest dan menjalankan setiap doctest dalam modul. Jika salah satu doctests gagal, maka unit test yang disintesis gagal, dan afailureException Exception dimunculkan dengan menampilkan nama file yang berisi tes dan nomor baris (terkadang perkiraan)

Di bawah sampulnya, DocTestSuite () membuat file unittest.TestSuite dari instance doctest.DocTestCase, dan DocTestCase adalah subkelas dari unittest.TestCase.

Demikian pula, DocFileSuite () membuat unittest.TestSuite dari instance doctest.DocFileCase, dan DocFileCase adalah subkelas dari DocTestCase.

Jadi, kedua cara membuat unittest.TestSuite menjalankan instance DocTestCase. Saat Anda menjalankan fungsi doctest sendiri, Anda bisa mengontrol opsi doctest yang digunakan secara langsung, dengan meneruskan flag opsi ke fungsi doctest.

Namun, jika Anda menulis kerangka kerja yang paling kecil, pada akhirnya unittest mengontrol kapan dan bagaimana pengujian dijalankan. Penulis kerangka biasanya ingin mengontrol opsi pelaporan doctest (mungkin, misalnya, ditentukan oleh opsi baris perintah), tetapi tidak ada cara untuk meneruskan opsi melalui unittest ke runner pengujian doctest.

Pada tahun 2004 Holger Krekel mengganti namanya stdpaket, yang namanya sering disalahartikan dengan nama Pustaka Standar yang dikirimkan bersama Python, dengan nama (hanya sedikit kurang membingungkan) 'py.' Meskipun paket tersebut berisi beberapa sub-paket, sekarang hampir seluruhnya dikenal untuk kerangka py.test-nya.

Kerangka py.test telah menyiapkan standar baru untuk pengujian Python, dan telah menjadi sangat populer dengan banyak pengembang saat ini. Idiom elegan dan Pythonic yang diperkenalkan untuk penulisan tes memungkinkan rangkaian tes untuk ditulis dalam gaya yang jauh lebih ringkas.

py.test adalah alternatif tanpa boilerplate untuk modul unittest standar Python. Meskipun merupakan alat uji berfitur lengkap dan dapat diperluas, ia menawarkan sintaksis sederhana. Membuat rangkaian pengujian semudah menulis modul dengan beberapa fungsi.

py.test berjalan di semua sistem operasi POSIX dan WINDOWS (XP / 7/8) dengan Python versi 2.6 ke atas.

Instalasi

Gunakan kode berikut untuk memuat modul pytest dalam distribusi Python saat ini serta utilitas py.test.exe. Tes dapat dijalankan menggunakan keduanya.

pip install pytest

Pemakaian

Anda cukup menggunakan pernyataan assert untuk menegaskan ekspektasi pengujian. Introspeksi assert pytest akan secara cerdas melaporkan nilai antara ekspresi assert yang membebaskan Anda dari kebutuhan untuk mempelajari banyak namaJUnit legacy methods.

# content of test_sample.py
def func(x):
   return x + 1
   
def test_answer():
   assert func(3) == 5

Gunakan baris perintah berikut untuk menjalankan tes di atas. Setelah tes dijalankan, hasil berikut ditampilkan di konsol -

C:\Python27>scripts\py.test -v test_sample.py
============================= test session starts =====================
platform win32 -- Python 2.7.9, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- C:\Pyth
on27\python.exe
cachedir: .cache
rootdir: C:\Python27, inifile:
collected 1 items
test_sample.py::test_answer FAILED
================================== FAILURES =====================
_________________________________ test_answer _________________________________
   def test_answer():
>  assert func(3) == 5
E     assert 4 == 5
E     + where 4 = func(3)
test_sample.py:7: AssertionError
========================== 1 failed in 0.05 seconds ====================

Tes ini juga dapat dijalankan dari baris perintah dengan memasukkan modul pytest menggunakan saklar –m.

python -m pytest test_sample.py

Mengelompokkan Beberapa Tes di Kelas

Setelah Anda mulai memiliki lebih dari beberapa pengujian, sering kali masuk akal untuk mengelompokkan pengujian secara logis, dalam kelas dan modul. Mari menulis kelas yang berisi dua tes -

class TestClass:
   def test_one(self):
      x = "this"
      assert 'h' in x
   def test_two(self):
      x = "hello"
      assert hasattr(x, 'check')

Hasil tes berikut akan ditampilkan -

C:\Python27>scripts\py.test -v test_class.py
============================= test session starts =====================
platform win32 -- Python 2.7.9, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- C:\Pyt
on27\python.exe
cachedir: .cache
rootdir: C:\Python27, inifile:
collected 2 items
test_class.py::TestClass::test_one PASSED
test_class.py::TestClass::test_two FAILED
================================== FAILURES =====================
_____________________________ TestClass.test_two ______________________________
self = <test_class.TestClass instance at 0x01309DA0>

   def test_two(self):
      x = "hello"
>  assert hasattr(x, 'check')
E     assert hasattr('hello', 'check')

test_class.py:7: AssertionError
===================== 1 failed, 1 passed in 0.06 seconds ======================

Proyek hidung dirilis pada 2005, setahun setelahnya py.testmenerima kedok modernnya. Itu ditulis oleh Jason Pellerin untuk mendukung idiom pengujian yang sama yang telah dirintis oleh py.test, tetapi dalam sebuah paket yang lebih mudah dipasang dan dipelihara.

Itu nose modul dapat dipasang dengan bantuan utilitas pip

pip install nose

Ini akan menginstal modul nose dalam distribusi Python saat ini serta nosetest.exe, yang berarti pengujian dapat dijalankan menggunakan utilitas ini serta menggunakan sakelar –m.

C:\python>nosetests –v test_sample.py
Or
C:\python>python –m nose test_sample.py

nose mengumpulkan tes dari unittest.TestCasesubclass, tentu saja. Kita juga dapat menulis fungsi pengujian sederhana, serta kelas pengujian yang bukan merupakan subkelas dari unittest.TestCase. nose juga menyediakan sejumlah fungsi bermanfaat untuk menulis tes berwaktu, pengujian pengecualian, dan kasus penggunaan umum lainnya.

nosemengumpulkan tes secara otomatis. Tidak perlu mengumpulkan kasus pengujian secara manual ke dalam rangkaian pengujian. Menjalankan tes responsif, sejaknose mulai menjalankan pengujian segera setelah modul pengujian pertama dimuat.

Seperti modul unittest, nose mendukung perlengkapan di tingkat paket, modul, kelas, dan kasus uji, sehingga inisialisasi yang mahal dapat dilakukan sesering mungkin.

Penggunaan Dasar

Mari kita anggap nosetest.py mirip dengan skrip yang digunakan sebelumnya -

# content of nosetest.py
def func(x):
   return x + 1
   
def test_answer():
   assert func(3) == 5

Untuk menjalankan tes di atas, gunakan sintaks baris perintah berikut -

C:\python>nosetests –v nosetest.py

Output yang ditampilkan di konsol adalah sebagai berikut -

nosetest.test_answer ... FAIL
================================================================
FAIL: nosetest.test_answer
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python34\lib\site-packages\nose\case.py", line 198, in runTest
      self.test(*self.arg)
   File "C:\Python34\nosetest.py", line 6, in test_answer
      assert func(3) == 5
AssertionError
----------------------------------------------------------------------
Ran 1 test in 0.000s
FAILED (failures = 1)

nose dapat diintegrasikan dengan DocTest dengan menggunakan with-doctest pilihan di baris perintah di atas.

\nosetests --with-doctest -v nosetest.py

Anda dapat menggunakan nose dalam skrip uji -

import nose
nose.main()

Jika Anda tidak ingin skrip pengujian keluar dengan 0 jika berhasil dan 1 jika gagal (seperti unittest.main), gunakan nose.run () -

import nose
result = nose.run()

Hasilnya akan menjadi benar jika uji coba berhasil, atau salah jika gagal atau memunculkan pengecualian yang tidak tertangkap.

nosemendukung perlengkapan (metode penyiapan dan pembongkaran) di tingkat paket, modul, kelas, dan pengujian. Seperti halnya perlengkapan py.test atau unittest, penyiapan selalu berjalan sebelum pengujian apa pun (atau kumpulan pengujian untuk paket dan modul pengujian); pembongkaran berjalan jika penyetelan telah berhasil diselesaikan, apa pun status uji coba.

Modul nose.tools menyediakan sejumlah alat bantu pengujian yang mungkin berguna bagi Anda, termasuk dekorator untuk membatasi waktu eksekusi pengujian dan pengujian pengecualian, dan semua metode assertX yang sama yang ditemukan di unittest.TestCase.

nose.tools.ok_(expr, msg = None) - Singkatan untuk menegaskan.
nose.tools.eq_(a, b, msg = None) - Singkatan dari 'assert a == b, “% r! =% R”% (a, b)
nose.tools.make_decorator(func) - Membungkus dekorator uji untuk mereplikasi metadata dari fungsi dekorasi dengan benar, termasuk hal-hal tambahan hidung (yaitu, penyiapan dan pembongkaran).
nose.tools.raises(*exceptions) - Tes harus meningkatkan salah satu pengecualian yang diharapkan agar lulus.
nose.tools.timed(limit) - Tes harus selesai dalam batas waktu yang ditentukan untuk lulus
nose.tools.istest(func) - Dekorator untuk menandai suatu fungsi atau metode sebagai ujian
nose.tools.nottest(func) - Dekorator untuk menandai fungsi atau metode sebagai bukan ujian

Pengujian Parameter

Kerangka pengujian Python, unittest, tidak memiliki cara sederhana untuk menjalankan kasus uji parametrized. Dengan kata lain, Anda tidak dapat dengan mudah memasukkan argumen ke fileunittest.TestCase dari luar.

Namun, port modul pytest menguji parametrization dalam beberapa cara yang terintegrasi dengan baik -

pytest.fixture() memungkinkan Anda untuk menentukan parametrization pada tingkat fungsi perlengkapan.
@pytest.mark.parametrizememungkinkan untuk mendefinisikan parametrization pada fungsi atau tingkat kelas. Ini menyediakan beberapa set argumen / perlengkapan untuk fungsi atau kelas pengujian tertentu.
pytest_generate_tests mengaktifkan penerapan skema atau ekstensi parametrik dinamis kustom Anda sendiri.

Modul pihak ketiga 'nose-parameterized' memungkinkan pengujian Parameterized dengan framework uji Python apa pun. Itu dapat diunduh dari tautan ini -https://github.com/wolever/nose-parameterized