Python unittest - trái ngược với assertRaises?

Tôi muốn viết một bài kiểm tra để xác định rằng Ngoại lệ không được nêu ra trong một hoàn cảnh nhất định.

Thật đơn giản để kiểm tra nếu Ngoại lệ được đưa ra ...

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

... nhưng làm thế nào bạn có thể làm điều ngược lại .

Một cái gì đó như thế này tôi là những gì tôi sau ...

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

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

Xin chào - Tôi muốn viết một bài kiểm tra để xác định rằng Ngoại lệ không được nêu ra trong một hoàn cảnh nhất định.

Đó là giả định mặc định - ngoại lệ không được nêu ra.

Nếu bạn không nói gì khác, đó là giả định trong mỗi bài kiểm tra.

Bạn không cần phải thực sự viết bất kỳ khẳng định nào cho việc đó.

Chỉ cần gọi hàm. Nếu nó đưa ra một ngoại lệ, khung kiểm tra đơn vị sẽ đánh dấu lỗi này là lỗi. Bạn có thể muốn thêm một bình luận, ví dụ:

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

Tôi là người đăng ban đầu và tôi đã chấp nhận câu trả lời trên của DGH mà không phải sử dụng nó lần đầu tiên trong mã.

Khi tôi đã sử dụng, tôi nhận ra rằng cần một chút tinh chỉnh để thực sự làm những gì tôi cần (để công bằng với DGH, anh ấy / cô ấy đã nói "hoặc một cái gì đó tương tự"!).

Tôi nghĩ rằng nó đáng để đăng các tinh chỉnh ở đây vì lợi ích của người khác:

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

Những gì tôi đã cố gắng làm ở đây là để đảm bảo rằng nếu một nỗ lực được thực hiện để khởi tạo một đối tượng Ứng dụng với một đối số không gian thứ hai thì pySourceAidExceptions.PathIsNotAValidOne sẽ được nêu ra.

Tôi tin rằng việc sử dụng đoạn mã trên (dựa nhiều vào câu trả lời của DGH) sẽ làm được điều đó.

Bạn có thể xác định assertNotRaisesbằng cách sử dụng lại khoảng 90% việc thực hiện ban đầu assertRaisestrong unittestmô-đun. Với phương pháp này, bạn kết thúc với một assertNotRaisesphương pháp, ngoài điều kiện thất bại đảo ngược của nó, hành xử giống hệt nhau assertRaises.

TLDR và ​​bản demo trực tiếp

Hóa ra thật dễ dàng để thêm một assertNotRaisesphương thức vào unittest.TestCase(tôi mất khoảng 4 lần thời gian để viết câu trả lời này giống như đã làm mã). Đây là bản demo trực tiếp của assertNotRaisesphương thức đang hoạt động . Giống nhưassertRaises , bạn có thể chuyển một cuộc gọi và tranh luận assertNotRaiseshoặc bạn có thể sử dụng nó trong một withtuyên bố. Bản demo trực tiếp bao gồm một trường hợp thử nghiệm chứng minh rằng assertNotRaiseshoạt động như dự định.

Chi tiết

Việc thực hiện assertRaisestrong unittestkhá phức tạp, nhưng với một chút phân lớp thông minh, bạn có thể ghi đè và đảo ngược tình trạng lỗi của nó.

assertRaiseslà một phương thức ngắn về cơ bản chỉ tạo một thể hiện của unittest.case._AssertRaisesContextlớp và trả về nó (xem định nghĩa của nó trong unittest.casemô-đun). Bạn có thể định nghĩa _AssertNotRaisesContextlớp của riêng mình bằng cách phân lớp _AssertRaisesContextvà ghi đè __exit__phương thức của nó :

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

Thông thường bạn định nghĩa các lớp trường hợp kiểm tra bằng cách chúng kế thừa từ TestCase. Nếu bạn thay vì kế thừa từ một lớp con 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ất cả các trường hợp thử nghiệm của bạn bây giờ sẽ có assertNotRaisesphương thức có sẵn cho họ.

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

có thể được sửa đổi nếu bạn cần chấp nhận tham số.

gọi như

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

Tôi đã tìm thấy nó hữu ích để vá khỉ unittestnhư sau:

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

Điều này làm rõ ý định khi kiểm tra sự vắng mặt của một ngoại lệ:

self.assertMayRaise(None, does_not_raise)

Điều này cũng đơn giản hóa việc kiểm tra trong một vòng lặp, điều mà tôi thường thấy mình đang làm:

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

Nếu bạn chuyển một lớp Exception cho assertRaises(), một trình quản lý bối cảnh được cung cấp. Điều này có thể cải thiện khả năng đọc các bài kiểm tra của bạn:

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

Điều này cho phép bạn kiểm tra các trường hợp lỗi trong mã của bạn.

Trong trường hợp này, bạn đang kiểm tra mức PathIsNotAValidOnetăng khi bạn chuyển các tham số không hợp lệ cho hàm tạo Ứng dụng.

bạn có thể thử như thế thử: self.assertRaises (Không có, hàm, arg1, arg2) ngoại trừ: vượt qua nếu bạn không đặt mã bên trong khối thử, nó sẽ thông qua ngoại lệ 'AssertsError: Không được nêu ra "và trường hợp thử nghiệm sẽ thất bại. nếu đặt bên trong khối thử đó là hành vi dự kiến.

Một cách đơn giản để đảm bảo đối tượng được khởi tạo mà không có bất kỳ lỗi nào là kiểm tra thể hiện loại của đối tượng.

Đây là một ví dụ :

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