Python unittest - kebalikan dari assertRaises?

Saya ingin menulis tes untuk memastikan bahwa Pengecualian tidak dimunculkan dalam keadaan tertentu.

Ini mudah untuk menguji apakah sebuah Exception adalah mengangkat ...

sInvalidPath=AlwaysSuppliesAnInvalidPath()
self.assertRaises(PathIsNotAValidOne, MyObject, sInvalidPath) 

... tapi bagaimana Anda bisa melakukan yang sebaliknya .

Sesuatu seperti ini saya apa yang saya cari ...

sValidPath=AlwaysSuppliesAValidPath()
self.assertNotRaises(PathIsNotAValidOne, MyObject, sValidPath) 

def run_test(self):
    try:
        myFunc()
    except ExceptionType:
        self.fail("myFunc() raised ExceptionType unexpectedly!")

Hai - Saya ingin menulis tes untuk memastikan bahwa Pengecualian tidak dimunculkan dalam keadaan tertentu.

Itu asumsi default - pengecualian tidak dimunculkan.

Jika Anda tidak mengatakan apa-apa lagi, itu dianggap dalam setiap tes.

Anda tidak harus benar-benar menulis pernyataan apa pun untuk itu.

Panggil saja fungsinya. Jika memunculkan pengecualian, kerangka kerja unit test akan menandai ini sebagai kesalahan. Anda mungkin ingin menambahkan komentar, misalnya:

sValidPath=AlwaysSuppliesAValidPath()
# Check PathIsNotAValidOne not thrown
MyObject(sValidPath)

Saya poster asli dan saya menerima jawaban di atas oleh DGH tanpa terlebih dahulu menggunakannya dalam kode.

Setelah saya menggunakan saya menyadari bahwa perlu sedikit penyesuaian untuk benar-benar melakukan apa yang saya butuhkan (untuk bersikap adil kepada DJBM, dia memang mengatakan "atau sesuatu yang serupa"!).

Saya pikir layak memposting tweak di sini untuk kepentingan orang lain:

    try:
        a = Application("abcdef", "")
    except pySourceAidExceptions.PathIsNotAValidOne:
        pass
    except:
        self.assertTrue(False)

Apa yang saya coba lakukan di sini adalah untuk memastikan bahwa jika upaya dilakukan untuk membuat instance objek Aplikasi dengan argumen spasi kedua, pySourceAidExceptions.PathIsNotAValidOne akan dimunculkan.

Saya percaya bahwa menggunakan kode di atas (sangat bergantung pada jawaban DJBM) akan melakukannya.

Anda dapat mendefinisikan assertNotRaisesdengan menggunakan kembali sekitar 90% dari implementasi asli assertRaisesdalam unittestmodul. Dengan pendekatan ini, Anda berakhir dengan assertNotRaisesmetode yang, selain dari kondisi kegagalannya yang terbalik, juga berperilaku identik assertRaises.

TLDR dan demo langsung

Ternyata sangat mudah untuk menambahkan assertNotRaisesmetode unittest.TestCase(butuh saya sekitar 4 kali lebih lama untuk menulis jawaban ini seperti halnya kode). Berikut ini demo langsung dari assertNotRaisesmetode yang digunakan . Sama sepertiassertRaises , Anda bisa menyampaikan callable dan args ke assertNotRaises, atau Anda dapat menggunakannya dalam sebuah withpernyataan. Demo langsung mencakup uji kasus yang menunjukkan bahwa assertNotRaisesberfungsi sebagaimana dimaksud.

Detail

Implementasi assertRaisesdalam unittestcukup rumit, tetapi dengan sedikit subclass pintar Anda dapat menimpa dan membalikkan kondisi kegagalannya.

assertRaisesadalah metode singkat yang pada dasarnya hanya membuat instance dari unittest.case._AssertRaisesContextkelas dan mengembalikannya (lihat definisi dalam unittest.casemodul). Anda dapat mendefinisikan _AssertNotRaisesContextkelas Anda sendiri dengan mensubclassing _AssertRaisesContextdan menimpa __exit__metodenya:

import traceback
from unittest.case import _AssertRaisesContext

class _AssertNotRaisesContext(_AssertRaisesContext):
    def __exit__(self, exc_type, exc_value, tb):
        if exc_type is not None:
            self.exception = exc_value.with_traceback(None)

            try:
                exc_name = self.expected.__name__
            except AttributeError:
                exc_name = str(self.expected)

            if self.obj_name:
                self._raiseFailure("{} raised by {}".format(exc_name,
                    self.obj_name))
            else:
                self._raiseFailure("{} raised".format(exc_name))

        else:
            traceback.clear_frames(tb)

        return True

Biasanya Anda mendefinisikan kelas kasus uji dengan meminta mereka mewarisi dari TestCase. Jika Anda sebaliknya mewarisi dari subkelas MyTestCase:

class MyTestCase(unittest.TestCase):
    def assertNotRaises(self, expected_exception, *args, **kwargs):
        context = _AssertNotRaisesContext(expected_exception, self)
        try:
            return context.handle('assertNotRaises', args, kwargs)
        finally:
            context = None

semua kasus uji Anda sekarang akan memiliki assertNotRaisesmetode yang tersedia untuk mereka.

def _assertNotRaises(self, exception, obj, attr):                                                                                                                              
     try:                                                                                                                                                                       
         result = getattr(obj, attr)                                                                                                                                            
         if hasattr(result, '__call__'):                                                                                                                                        
             result()                                                                                                                                                           
     except Exception as e:                                                                                                                                                     
         if isinstance(e, exception):                                                                                                                                           
            raise AssertionError('{}.{} raises {}.'.format(obj, attr, exception)) 

dapat dimodifikasi jika Anda perlu menerima parameter.

panggilan seperti

self._assertNotRaises(IndexError, array, 'sort')

Saya merasa bermanfaat untuk menambal monyet unittestsebagai berikut:

def assertMayRaise(self, exception, expr):
  if exception is None:
    try:
      expr()
    except:
      info = sys.exc_info()
      self.fail('%s raised' % repr(info[0]))
  else:
    self.assertRaises(exception, expr)

unittest.TestCase.assertMayRaise = assertMayRaise

Ini mengklarifikasi maksud saat menguji untuk tidak adanya pengecualian:

self.assertMayRaise(None, does_not_raise)

Ini juga menyederhanakan pengujian dalam satu lingkaran, yang sering saya lakukan:

# ValueError is raised only for op(x,x), op(y,y) and op(z,z).
for i,(a,b) in enumerate(itertools.product([x,y,z], [x,y,z])):
  self.assertMayRaise(None if i%4 else ValueError, lambda: op(a, b))

Jika Anda lulus kelas Pengecualian assertRaises(), manajer konteks disediakan. Ini dapat meningkatkan keterbacaan tes Anda:

# raise exception if Application created with bad data
with self.assertRaises(pySourceAidExceptions.PathIsNotAValidOne):
    application = Application("abcdef", "")

Ini memungkinkan Anda untuk menguji kasus kesalahan dalam kode Anda.

Dalam hal ini, Anda menguji PathIsNotAValidOnedinaikkan ketika Anda melewati parameter yang tidak valid ke konstruktor Aplikasi.

Anda bisa coba seperti itu. coba: self.assertRaises (Tidak ada, fungsi, arg1, arg2) kecuali: lulus jika Anda tidak memasukkan kode di dalam blok coba itu akan melalui pengecualian 'AssertionError: Tidak ada yang mengangkat "dan test case akan gagal. Test case akan lulus. Test case akan lulus jika diletakkan di dalam blok coba yang merupakan perilaku yang diharapkan.

Salah satu cara lurus ke depan untuk memastikan objek diinisialisasi tanpa kesalahan adalah dengan menguji instance tipe objek.

Berikut ini sebuah contoh:

p = SomeClass(param1=_param1_value)
self.assertTrue(isinstance(p, SomeClass))