Python unittest ตรงข้ามกับ assertRaises

ฉันต้องการเขียนการทดสอบเพื่อพิสูจน์ว่าข้อยกเว้นไม่ได้เกิดขึ้นในสถานการณ์ที่กำหนด

มันตรงไปตรงมาทดสอบว่ายกเว้นถูกยก ...

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

... แต่คุณจะทำสิ่งตรงกันข้ามได้อย่างไร

อย่างนี้ฉันคือสิ่งที่ฉันหลังจาก ...

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

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

สวัสดี - ฉันต้องการเขียนแบบทดสอบเพื่อพิสูจน์ว่าข้อยกเว้นไม่ได้เกิดขึ้นในสถานการณ์ที่กำหนด

นั่นคือสมมติฐานเริ่มต้น - ข้อยกเว้นจะไม่เพิ่มขึ้น

หากคุณไม่พูดอะไรเลยนั่นจะถือว่าเป็นการทดสอบทุกครั้ง

คุณไม่จำเป็นต้องเขียนคำยืนยันใด ๆ

เพียงแค่เรียกฟังก์ชั่น ถ้ามันยกข้อยกเว้นกรอบการทดสอบหน่วยจะตั้งค่าสถานะนี้เป็นข้อผิดพลาด คุณอาจต้องการเพิ่มความคิดเห็นเช่น:

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

ฉันเป็นโปสเตอร์ดั้งเดิมและฉันยอมรับคำตอบข้างต้นโดย DGH โดยไม่ต้องใช้มันเป็นครั้งแรกในรหัส

เมื่อฉันใช้ฉันรู้ว่ามันจำเป็นต้องมีการปรับแต่งเล็กน้อยเพื่อทำสิ่งที่ฉันต้องการ (เพื่อให้เกิดความยุติธรรมกับ DGH เขา / เธอพูดว่า "หรืออะไรทำนองนั้น"!)

ฉันคิดว่ามันคุ้มค่าที่จะโพสต์บิดที่นี่เพื่อประโยชน์ของผู้อื่น:

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

สิ่งที่ฉันพยายามทำที่นี่คือเพื่อให้แน่ใจว่าหากมีความพยายามในการสร้างอินสแตนซ์ของแอปพลิเคชันวัตถุด้วยอาร์กิวเมนต์ที่สองของช่องว่าง pySourceAidExceptions.PathIsNotAValidOne จะยกขึ้น

ฉันเชื่อว่าการใช้รหัสด้านบน (ตามคำตอบของ DGH อย่างมาก) จะทำเช่นนั้น

คุณสามารถกำหนดassertNotRaisesโดยการนำประมาณ 90% ของการดำเนินงานเดิมของassertRaisesในunittestโมดูล ด้วยวิธีนี้คุณท้ายด้วยวิธีการที่นอกเหนือจากสภาพความล้มเหลวกลับมีพฤติกรรมเหมือนกันกับassertNotRaisesassertRaises

TLDR และการสาธิตสด

มันกลับกลายเป็นassertNotRaisesวิธีที่ง่ายอย่างน่าประหลาดใจในการเพิ่มวิธีการunittest.TestCase(ใช้เวลาประมาณ 4 ครั้งในการเขียนคำตอบนี้ตามที่ใช้รหัส) นี่คือการสาธิตสดของassertNotRaisesวิธีการในการดำเนินการ เพียงเช่นassertRaisesคุณสามารถผ่าน callable และ args ไปassertNotRaisesหรือคุณสามารถใช้มันในwithคำสั่ง การสาธิตสดรวมถึงกรณีทดสอบที่แสดงให้เห็นว่าassertNotRaisesทำงานได้ตามที่ต้องการ

รายละเอียด

การนำไปใช้assertRaisesในunittestค่อนข้างซับซ้อน แต่ด้วย subclassing เล็กน้อยคุณสามารถแทนที่และย้อนกลับเงื่อนไขความล้มเหลว

assertRaisesเป็นวิธีสั้น ๆ ที่โดยทั่วไปแล้วสร้างอินสแตนซ์ของunittest.case._AssertRaisesContextคลาสและส่งคืนมัน (ดูคำจำกัดความของมันในunittest.caseโมดูล) คุณสามารถกำหนด_AssertNotRaisesContextคลาสของคุณเองโดยการแบ่งคลาสย่อย_AssertRaisesContextและแทนที่__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

TestCaseปกติคุณกำหนดชั้นเรียนกรณีทดสอบโดยมีพวกเขาสืบทอดมาจาก หากคุณได้รับมรดกจากคลาสย่อยแทน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

กรณีทดสอบทั้งหมดของคุณตอนนี้จะมีassertNotRaisesวิธีการที่ใช้ได้

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

สามารถแก้ไขได้หากคุณต้องยอมรับพารามิเตอร์

โทรเหมือน

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

ฉันคิดว่ามันมีประโยชน์กับ Monkey-patch unittestดังนี้:

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

สิ่งนี้จะอธิบายถึงเจตนาเมื่อทำการทดสอบโดยไม่มีข้อยกเว้น:

self.assertMayRaise(None, does_not_raise)

สิ่งนี้ช่วยลดความยุ่งยากในการทดสอบในวงซึ่งฉันมักจะพบว่าตัวเองกำลังทำ:

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

หากคุณผ่านคลาส Exception ไปที่จะassertRaises()มีการจัดการบริบท สิ่งนี้สามารถปรับปรุงความสามารถในการอ่านของการทดสอบของคุณ:

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

สิ่งนี้ช่วยให้คุณสามารถทดสอบกรณีข้อผิดพลาดในรหัสของคุณ

ในกรณีนี้คุณกำลังทดสอบการPathIsNotAValidOneยกเมื่อคุณส่งพารามิเตอร์ที่ไม่ถูกต้องไปที่ตัวสร้างแอปพลิเคชัน

คุณสามารถลองเช่นนั้น ลอง: self.assertRaises (ไม่มี, ฟังก์ชั่น, arg1, arg2) ยกเว้น: ส่งถ้าคุณไม่ใส่รหัสในลองบล็อกมันจะผ่านข้อยกเว้น 'AssertionError: ไม่มีไม่ยก "และกรณีทดสอบจะล้มเหลวกรณีทดสอบจะผ่าน ถ้าใส่ในบล็อกลองซึ่งเป็นพฤติกรรมที่คาดหวัง

ทางตรงไปข้างหน้าวิธีหนึ่งเพื่อให้แน่ใจว่าวัตถุนั้นได้รับการเริ่มต้นโดยไม่มีข้อผิดพลาดใด ๆ คือการทดสอบอินสแตนซ์ชนิดของวัตถุ

นี่คือตัวอย่าง:

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