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)

То, что я пытался сделать здесь, состояло в том, чтобы гарантировать, что, если была сделана попытка создать экземпляр объекта Application со вторым аргументом пробелов, pySourceAidExceptions.PathIsNotAValidOne будет вызван.

Я полагаю, что использование приведенного выше кода (в значительной степени основанного на ответе DGH) сделает это.

Вы можете определить assertNotRaises, повторно используя около 90% первоначальной реализации assertRaisesв unittestмодуле. При таком подходе вы в конечном итоге получаете assertNotRaisesметод, который, помимо своего условия обратного сбоя, ведет себя идентично assertRaises.

TLDR и живая демонстрация

Оказалось, что добавить assertNotRaisesметод к удивительно легко unittest.TestCase(у меня ушло примерно в 4 раза больше времени, чтобы написать этот ответ, чем при написании кода). Вот живая демонстрация assertNotRaisesметода в действии . Точно так жеassertRaises , вы можете либо передать вызываемый объект и аргументы assertNotRaises, либо использовать его в withвыражении. Демонстрационная версия включает тестовые примеры, которые демонстрируют, что assertNotRaisesработает как задумано.

подробности

Реализация assertRaisesin unittestдовольно сложна, но с небольшим количеством умных подклассов вы можете переопределить и отменить условие сбоя.

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когда вы передаете неверные параметры конструктору приложения.

Вы можете попробовать так. try: self.assertRaises (None, function, arg1, arg2) кроме: pass, если вы не поместите код в блок try, это произойдет через исключение «AssertionError: None not воспитано», и тестовый случай будет пройден. Тестовый пример будет пройден если положить внутрь, попробуйте блок, который ожидается поведение.

Один прямой способ убедиться, что объект инициализируется без каких-либо ошибок, - это проверить экземпляр типа объекта.

Вот пример:

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