Kerangka UnitTest - API

Bab ini membahas class 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 memegang rutinitas pengujian dan menyediakan kait untuk mempersiapkan setiap rutinitas dan untuk pembersihan setelahnya.

Metode berikut ditentukan di kelas TestCase -

Sr.No.	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 bahkan jika 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 perlengkapan yang diperlukan oleh pengujian Anda. Untuk mengonfigurasi perlengkapan, ganti setUp (). Untuk membersihkan, timpa 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 individual di dalam kelas TestCase. Demikian pula, metode tearDownClass () akan dijalankan setelah semua pengujian di kelas. Kedua metode tersebut adalah metode kelas. Oleh karena itu, 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.No.	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. Namun, instance eksplisit memungkinkan penyesuaian properti tertentu.

Dalam kode berikut, tes 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 -

Sr Tidak	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.No.	Atribut & Deskripsi
1	Errors Daftar yang berisi 2-tupel instance TestCase dan string yang menyimpan traceback yang telah diformat. Setiap tupel merepresentasikan pengujian yang memunculkan pengecualian yang tidak terduga.
2	Failures Daftar yang berisi 2-tupel instance TestCase dan string yang menyimpan traceback yang telah diformat. Setiap tupel merepresentasikan 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.stderrakan 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