Python unittest - assertRaises karşısında mı?

Belirli bir durumda bir İstisna oluşturulmadığını tespit etmek için bir test yazmak istiyorum.

İstisna eğer testine basittir edilir kaldırdı ...

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

... ancak bunu nasıl tersini .

Böyle bir şey peşindeyim ben ...

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

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

Merhaba - Belirli bir durumda bir İstisna oluşturulmadığını tespit etmek için bir test yazmak istiyorum.

Bu varsayılan varsayımdır - istisnalar artırılmaz.

Başka bir şey söylemezseniz, bu her testte varsayılır.

Bunun için herhangi bir iddiada bulunmak zorunda değilsiniz.

Sadece fonksiyonu çağırınız. Bir istisna ortaya çıkarsa, birim test çerçevesi bunu bir hata olarak işaretler. Yorum eklemek isteyebilirsiniz, örneğin:

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

Ben orijinal posteriyim ve yukarıdaki cevabı ilk olarak kodda kullanmadan DGH tarafından kabul ettim.

Bir kez kullandım ben aslında ne yapmak için ne yapmak için biraz tweaking gerektiğini fark (o "ya da benzer bir şey" dedi DGH adil olmak!).

Ben burada başkalarının yararına tweak göndermeye değer olduğunu düşündüm:

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

Burada yapmaya çalıştığım şey, ikinci bir argüman alanı olan bir Application nesnesini başlatmak için bir girişimde bulunulması halinde pySourceAidExceptions.PathIsNotAValidOne öğesinin yükseltilmesini sağlamaktı.

Yukarıdaki kodu (ağırlıklı olarak DGH'nin cevabına dayanarak) kullanmanın bunu yapacağına inanıyorum.

Sen tanımlayabilirsiniz assertNotRaisesorijinal uygulanması% 90 yaklaşık yeniden kullanarak assertRaisesiçinde unittestmodül. Bu yaklaşımla, assertNotRaisesters başarısızlık durumunun yanı sıra aynı şekilde davranan bir yöntem elde edersiniz assertRaises.

TLDR ve canlı demo

Bir assertNotRaisesyöntem eklemek şaşırtıcı derecede kolay çıkıyor unittest.TestCase(bu yanıtı kod yazarken yazmak yaklaşık 4 kat sürdü). İşte metodun canlı bir demosuassertNotRaises . Sadece gibiassertRaises , ya bir çağrılabilir ve args geçebilir assertNotRaisesveya bir onu kullanabilirsiniz withaçıklamada. Canlı demo, assertNotRaisesamaçlandığı gibi çalıştığını gösteren bir test örneği içerir .

ayrıntılar

Uygulanması assertRaiseshalinde unittestoldukça karmaşık, fakat zeki subclassing birazcık ile geçersiz kılmak ve başarısızlık durumunu tersine çevirebilir.

assertRaisestemel olarak unittest.case._AssertRaisesContextsınıfın bir örneğini oluşturan ve onu döndüren kısa bir yöntemdir ( unittest.casemodülün tanımına bakın ). Kendi _AssertNotRaisesContextsınıfınızı yöntemini alt sınıflandırarak _AssertRaisesContextve geçersiz kılarak tanımlayabilirsiniz __exit__:

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

Normalde, test senaryosu sınıflarını devralmalarını sağlayarak tanımlarsınız TestCase. Bunun yerine bir alt sınıftan miras alırsanız 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

tüm test senaryolarınızda artık bu assertNotRaisesyöntemlerin kullanabileceği bir yöntem bulunacaktır .

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)) 

parametreleri kabul etmeniz gerekirse değiştirilebilir.

gibi ara

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

Maymun yamasını unittestaşağıdaki gibi yararlı buldum :

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

Bu, bir istisna olmadığında test yaparken niyeti açıklar:

self.assertMayRaise(None, does_not_raise)

Bu aynı zamanda sık sık kendimi yaparken bulduğum bir döngüde testi basitleştirir:

# 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))

Bir Exception sınıfını iletirseniz assertRaises(), bir bağlam yöneticisi sağlanır. Bu, testlerinizin okunabilirliğini artırabilir:

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

Bu, kodunuzdaki hata durumlarını test etmenizi sağlar.

Bu durumda, PathIsNotAValidOneUygulama yapıcısına geçersiz parametreler ilettiğinizde yükseltildiğini test edersiniz.

böyle deneyebilirsiniz. try: self.assertRaises (Yok, işlev, arg1, arg2) hariç: kodu kodun içine koymazsanız deneyin 'AssertionError: Hiçbiri yükseltilmez' istisnasıyla geçer ve test durumu başarısız olur. içine koymak eğer beklenen davranış olan blok deneyin.

Nesnenin hatasız olarak başlatılmasını sağlamanın düz bir yolu, nesnenin tür örneğini sınamaktır.

İşte bir örnek :

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