Python unittest - o oposto de assertRaises?

Quero escrever um teste para estabelecer que uma exceção não é gerada em uma determinada circunstância.

É simples testar se uma exceção é gerada ...

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

... mas como você pode fazer o oposto .

Algo assim, o que eu estou procurando ...

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

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

Oi - Quero escrever um teste para estabelecer que uma exceção não é gerada em uma determinada circunstância.

Essa é a suposição padrão - exceções não são levantadas.

Se você não disser mais nada, isso é assumido em todos os testes.

Você não precisa escrever uma afirmação para isso.

Basta chamar a função. Se houver uma exceção, a estrutura de teste da unidade sinalizará isso como um erro. Você pode adicionar um comentário, por exemplo:

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

Sou o pôster original e aceitei a resposta acima pela DGH sem antes usá-la no código.

Uma vez que eu usei, percebi que precisava de alguns ajustes para realmente fazer o que eu precisava (para ser justo com a DGH, ele / ela disse "ou algo semelhante"!).

Eu pensei que valia a pena postar o tweak aqui para o benefício de outros:

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

O que eu estava tentando fazer aqui era garantir que, se fosse feita uma tentativa de instanciar um objeto Application com um segundo argumento de espaços, o pySourceAidExceptions.PathIsNotAValidOne seria gerado.

Acredito que o uso do código acima (baseado fortemente na resposta da DGH) fará isso.

Você pode definir assertNotRaisesreutilizando cerca de 90% da implementação original assertRaisesno unittestmódulo. Com essa abordagem, você acaba com um assertNotRaisesmétodo que, além da condição de falha reversa, se comporta de maneira idêntica assertRaises.

TLDR e demonstração ao vivo

É surpreendentemente fácil adicionar um assertNotRaisesmétodo unittest.TestCase(levei cerca de 4 vezes mais tempo para escrever essa resposta do que o código). Aqui está uma demonstração ao vivo do assertNotRaisesmétodo em ação . Assim comoassertRaises , você pode passar um call e args para assertNotRaises, ou você pode usá-lo em uma withdeclaração. A demonstração ao vivo inclui casos de teste que demonstram que assertNotRaisesfuncionam conforme o esperado.

Detalhes

A implementação de assertRaisesin unittesté bastante complicada, mas com uma subclasse inteligente, você pode substituir e reverter sua condição de falha.

assertRaisesé um método curto que basicamente apenas cria uma instância da unittest.case._AssertRaisesContextclasse e a retorna (veja sua definição no unittest.casemódulo). Você pode definir sua própria _AssertNotRaisesContextclasse subclassificando _AssertRaisesContexte substituindo seu __exit__método:

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

Normalmente você define classes de caso de teste, herdando-as de TestCase. Se você herdar de uma subclasse 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

todos os seus casos de teste agora terão o assertNotRaisesmétodo disponível para eles.

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

pode ser modificado se você precisar aceitar parâmetros.

ligue como

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

Eu achei útil fazer o patch do macaco da unittestseguinte maneira:

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

Isso esclarece a intenção ao testar a ausência de uma exceção:

self.assertMayRaise(None, does_not_raise)

Isso também simplifica o teste em um loop, o que muitas vezes me vejo fazendo:

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

Se você passar uma classe Exception assertRaises(), é fornecido um gerenciador de contexto. Isso pode melhorar a legibilidade de seus testes:

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

Isso permite testar casos de erro no seu código.

Nesse caso, você está testando o PathIsNotAValidOneaumento quando passa parâmetros inválidos para o construtor de aplicativos.

você pode tentar assim. try: self.assertRaises (None, function, arg1, arg2), exceto: pass se você não colocar o código dentro do bloco try, ele passará pela exceção 'AssertionError: None not raise' e o caso de teste falhará. O caso de teste será aprovado se colocado dentro do bloco try, que é o comportamento esperado.

Uma maneira direta de garantir que o objeto seja inicializado sem nenhum erro é testar a instância de tipo do objeto.

Aqui está um exemplo :

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