PyUnit - Documentação

O que é?

O PyUnit é uma biblioteca para realização de testes unitários em Python, baseada na arquitetura xUnit.

Teste unitário é uma metodologia de testes automatizados que leva em consideração a menor unidade do software, ou seja, ao invés de testar dentro do código fonte e executar o código manualmente para imprimir o resultado na tela, o programador cria uma aplicação de teste, espelhando a original, que testa cada trecho de código individualmente em um ambiente controlado utilizando a linha de comando.

Por que testar é importante?

Um teste é feito para garantir qe o código sendo testado funciona. Seja com uma metodologia de testes automatizados ou de forma mais informal, todo código é testado porém, com criar um modelo de teste automatizados garante que o código continua funcionado, já que a cada alteração feita ele testará o código inteiro e destacará qualquer erro que poderia passar despercebido em um teste manual.

Implementação

O PyUnit é presente por padrão no Python desde a versão 2.1, podendo ser implementado através da importação do módulo unittest, como demonstrado abaixo:

import unittest

Ou importando especificamente algum recurso:

from unittest import <recurso a ser usado>

Utilização

Para criar testes com PyUnit é necessário criar uma Classe de Testes que deve extender a classe TestCase presente no módulo unittest.

O PyUnit localiza os métodos de teste pelo prefixo test em seu nome. Por fim é necessário chamar a função main do módulo unittest dentro da expressão if __name__ == "__main__": do módulo para executar os testes criados, como ilustrado abaixo:

import unittest

class TestClass(unittest.TestCase):

    def test_meu_metodo(self):
        self.assertEqual(valor_esperado , valor_real, "mensagem caso o teste falhe")

if __name__ == "__main__":
    unittest.main()

Na linha 6 é chamado o método assertEqual é um método assert da classe TestCase. Os métodos assert (do inglês afirmar) são responsáveis por verificar se o resultado gerado durante o teste é igual ao esperado, caso contrário o teste resultará em uma falha e exibirá a mensagem, caso definida.

Por exemplo, considere que queremos testar isoladamente o seguinte método frete_gratis da classe Compra:

class Compra:
    def frete_gratis(self, valor):
        return valor >= 150

Criamos então a classe CompraTest dentro da pasta tests, como o método test_frete_gratis, de acordo com o código abaixo.

import unittest
from compra import Compra

class CompraTeste(unittest.TestCase):
    def test_frete_gratis(self):
        nova_compra = Compra()
        self.assertTrue(nova_compra.frete_gratis(200))

if __name__ == "__main__":
    unittest.main()

O método assertTrue define que o retorno de nova_compra.frete_gratis(200) deve ser True caso contrário o teste falha.

Executando testes

Para executar os testes basta rodar o arquivo no terminal com o comando python

python test_module.py

Teste de Exceção

Em certas situações é necessário saber se uma unidade irá gerar um erro, ou Exception. Para esse tipo de situação, o PyUnit possui um método específico chamado assertRaises() que determina se o código sendo testado deve disparar uma exceção e qual tipo de exceção deve ser disparada. O método assertRaises possui a seguinte sintaxe:

|assertRaise(tipo_erro, codigo_testado [, parâmetros, caso, existam)]| |---| |Verifica se a unidade informada gera uma exceção do tipo informado|

Na prática sua utilização é muito simples: ele é declarado como um assert comum porém em seu primeiro parâmetro é informado o tipo do erro, em seguida o nome da função que será testada (sem os () de chamada) e por fim serão declarados os parâmetros, caso existam, que devem ser atribuídos à função sendo testada pelo assertRaises.

Exemplo:

    def test_frete_gratis_exception(self):
        nova_compra = Compra()
        self.assertRaises(TypeError, nova_compra.frete_gratis, "duzentos")

Se a unidade testada com assertRaises não disparar uma exceção o teste resultará em uma falha.

A declaração assert

É uma declaração nativa do Python que verifica se a expressão declarada a seguir tem um valor passável como True em um if. Caso não seja irá disparrar um AssertionError e exibir uma mensagem de erro, caso definida.

|assert expressao [, "mensagem"] | |---| |Dispara um AssertionError caso a expresão seja falsa e exibe a mensagem (opicional)|

Quando usada em um método de testes a declaração assert se comporta de maneira similar com os métodos assert, como demonstrado abaixo:

import unittest
from compra import Compra

class CompraTeste(unittest.TestCase):
    def test_frete_gratis(self):
        nova_compra = Compra()
        assert nova_compra.frete_gratis(100), "erro em Compra.frete_gratis"

if __name__ == "__main__":
    unittest.main()

Ambiente

O ambiente de testes consiste dos objetos utilizados nos testes.

O PyUnit possui as seguintes ferramentas para a montagem e desmontagem de ambientes de teste:

• setUp:

  É o método da superclasse TestCase que é executado antes de cada teste
  na mesma classe, ideal para instanciar objetos com valores predefinidos.

• tearDown

  É o método da superclasse TestCase que é executado após cada teste na mesma
  classe, ideal para fechar conexões ao banco de dados, arquivos, etc.

Veja no exemplo:

import unittest

from funcionario import Funcionario
from helpers import Connection

class FuncionarioTest(unittest.TestCase):
    def setUp(self):
        self.funcionario = Funcionario(3000, "José", 1, 171.9)
        self.conexao = Connection()
        self.conexao.open()

    def tearDown(self):
        self.conexao.close()

Os métodos setUp e tearDown são sintaticamente iguais.

Objetos Mock

Um mock é um objeto falso construído a partir de uma classe. Geralmente criamos esse objeto para utilizá-lo em lugar de uma dependência do cenário a ser testado. Assim, tornamos o código de teste isento a erros indiretamente relacionados ao objetivo principal em um determinado contexto de teste.

Por exemplo, considerando que desejamos validar um modelo a ser persistido, podemos usar um dublê para substituir a classe de persistência, que nesse caso é necessária para a completude da ação, mas ainda assim indiretamente importante. Dessa forma, podemos nos concentrar na validação e isentar o código de teste de erros de conexão, entre outros.

Como exemplo, considere que queremos testar o seguinte método da classe FolhaPagamento:

from api.helpers.currency import Currency

class FolhaPagamento:

    def pagamento_moeda_estrangeira(self, tipo_moeda, valor, currency: Currency):
        if (tipo_moeda == "dolar"):
            return valor * currency.get_dolar()
        elif(tipo_moeda == "euro"):
            return valor * currency.get_euro()
        elif(tipo_moeda == "libra"):
            return valor * currency.get_libra()
        else:
            raise ValueError("moeda não disponível")
            return 0

Para um primeiro teste vamos criar um mock da classe Currency e definir que seu método get_dolar vai ter um retorno igual a 3.

import unittest
from unittest.mock import Mock, patch

from folha_pagamento import FolhaPagamento

class FolhaPagamentoTeste(unittest.TestCase):

    @patch('helpers.Currency')
    def test_pagamento_dolar(self, fake_currency):
        folha = FolhaPagamento()
        fake_currency.get_dolar = Mock(return_value=3)
        resultado = folha.pagamento_moeda_estrangeira("dolar", 3000, fake_currency)
        assert resultado == 9000, "valor incorreto"

MagicMock é uma subclasse de Mock com todos os métodos mágicos pre-criados e pronto para ser usado. Também há variantes que não podem ser chamadas, úteis para uso de objetos não-chamáveis: NonCallabelMock e NonCallableMagicMock.

O decorator patch facilita criar classes ou objetos mock no módulo sob teste. O atributo em questão (exceto o self de um método) será substituído por um mock durante o teste e restaurado após o término do teste.

A classe Mock

Mock é um objeto flexível planejado para substituir o uso de esboços e dublês de teste em seu código. Um Mock pode ser chamado e criar atributos como novos mocks quando acessados. Acessar os mesmo atributos vão sempre retornar os mesmos mocks. Mocks registram como são usados, permitindo que assertions sejam feitos sobre a interação com seu código.

class unittest.mock.Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)

Argumentos

• spec:

  Define quais atributos serão usados durante o teste. Aceita uma lista de string ou um objeto. Qualquer atributo do mock que for chamado deve ser declarado em spec ou um AtributeError será disparado, porém permite atribuição\criação de novos atributos. Caso um objeto seja passando em spec, o método mágico __class__ retornará a classe do spec, isso permite que mocks passem em testes de isinstance().

• spec_set

  É uma versão mais rigorosa de spec. Impede qualquer referência a um atributo que não seja declarado em spec_set

• side_effect

  Pode ser tanto uma função a ser executada quando o mock for chamado, um iterável ou uma exceção (classe ou instância) as ser disparada.

  Caso seja passada uma função ela será chamada com os mesmo argumentos que o mock e, a menos que a função tenha o retorno padrão do mock, o valor de retorno da função será o utilizado.

  Alternativamente, side_effect pode ser uma classe ou instância de exceção. Nese caso uma exception será disparada quando o mock for chamado.

  Caso side_effect seja um iterável então cada chamada resultará no próximo valor do iterável.

  side_effect pode ser setado como None para esvaziá-lo.

• return_value

  Declara o valor de retorno quando o mock é executado. Por padrão é um novo mock.

• unsafe

  Por padrão, se algum atributo do mock começar com assert ou assret um AttributeError será disparado. Passar unsafe=True faz permitir o uso de atributos com esses nomes.

• wraps

  Adiciona um objeto para ser envolto pelo mock, isto é, se wraps não for None fazer uma chamado para o mock será o mesmo que chamar o objeto que foi definido. Acessar um atributo nesse mock retornará um mock que envolve o atributo correspondente do objeto que foi originalmente definido em wraps. (Acessar um atributo inexistente vai disparar um AtributeError)

• name

  Define um nome para o mock que será usado como seu __repr__. O nome se propaga em mocks filhos.

Métodos de Mock

• assert_called(args, *kwargs)

  Assegura que o mock foi chamado pelo menos uma vez

  ```s

falso = Mock() falso.qualquermetodo() falso.qualquermetodo.assert_called() ```

• assertcalledonce(args, *kwargs)

  Assegura que o mock foi chamado exatamente uma vez

  ```s

falso = Mock() falso.qualquermetodo() falso.qualquermetodo.assertcalledonce() falso.qualquermetodo() falso.qualquermetodo.assertcalledonce() Traceback (most recent call last): ... AssertionError: Expected 'qualquer_metodo' to have been called once. Called 2 times. ```

• assertcalledwith(args, *kwargs)

  Assegura que o mock foi chamado com parâmetros definidos em sua chamada mais recente

  ```s

falso = Mock() falso.qualquermetodo(1, 2, 3, "testando") also.qualquermetodo.assertcalledwith(1, 2, 3, "testando") Traceback (most recent call last): ... AssertionError: Expected 'qualquer_metodo' to have been called once. Called 2 times. ```

• assertcalledonce_with(args, *kwargs)

  Assegura que o mock foi chamado exatamente uma vez com parâmetros definidos definidos em sua chamada mais recente

  ```s

falso = Mock() falso.qualquermetodo(1, 2, 3, "testando") also.qualquermetodo.assertcalledoncewith(1, 2, 3, "testando") falso.qualquermetodo("testando", 3, 2, 1) also.qualquermetodo.assertcalledoncewith(1, 2, 3, "testando") Traceback (most recent call last): ... AssertionError: Expected 'qualquer_metodo' to have been called once. Called 2 times.
```

• assertanycall(args, *kwargs)

  Assegura que o mock foi chamado a qualquer momento com os parâmetros definidos

  ```s

falso = Mock() falso(1, 2, "três") falso("um", 2, 3) falso.assertanycall(1, 2, "três") ```

• asserthascalls(calls, any_order=False) Assegura que o mock foi chamado com ao menos alguma call específica.

  Enquanto any_order for False (por padrão) as calls precisarão ser sequenciais.

  ```s

falso = Mock(returnvalue=None) falso(1) falso(2) falso(3) falso(4) calls = [call(2), call(3)] falso.asserthascalls(calls) calls = [call(4), call(2), call(3)] falso.asserthascalls(calls, anyorder=True) ```

• assertnotcalled()

  Assegura que o mock nunca foi chamado.

  ```s

falso = Mock() falso.metodo.assertnotcalled() m = falso.metodo() falso.metodo.assertnotcalled() Traceback (most recent call last): ... AssertionError: Expected 'metodo' to not have been called. Called 1 times.
```

• resetmock(returnvalue=False, side_effect=False)

  Reseta todas as chamadas em um mock. Caso return_value e/ou side_effect sejam True, esses atributos do mock também serão resetados.

  ```s

falso = Mock() falso("chamada") falso.called True falso.reset_mock falso.called False ```

• mockaddspec(spec, spec_set=False)

  Adiciona um spec ao mock. spec pode ser um objeto ou uma lista de strings. Caso spec_set seja True apenas atributos que já estavam previamente no spec do mock serão setados.

• attach_mock(mock, atributo) Vincula outro mock como seu próprio atributo, substituindo seu nome e objeto pai

• configure_mock(kwargs) Configura atributos do **mock através de um dicionário com chaves predefinidas.

  ```s

falso = Mock() attrs = {'metodo.returnvalue': 3, 'outro.sideeffect': KeyError} falso.configure_mock(attrs) falso.metodo() 3 falso.outro() Traceback (most recent call last): ... KeyError ```

• dir()

  Objetos mock limitam o método mágico _dir_ para resultados relevantes. Para mocks com uma spec isso inclui os atributos permitidos.

Atributos

- called

Um boolean que representa se o mock foi chamado ou não

• call_count

  Um inteiro que retorna quantas vezes o mock foi chamado

• return_value

  Declara o valor de retorno quando o mock é executado. Por padrão é um novo mock.

• side_effect

  Pode ser tanto uma função a ser executada quando o mock for chamado, um iterável ou uma exceção (classe ou instância) as ser disparada.

  Caso seja passada uma função ela será chamada com os mesmo argumentos que o mock e, a menos que a função tenha o retorno padrão do mock, o valor de retorno da função será o utilizado.

  Alternativamente, side_effect pode ser uma classe ou instância de exceção. Nese caso uma exception será disparada quando o mock for chamado.

  Caso side_effect seja um iterável então cada chamada resultará no próximo valor do iterável.

  side_effect pode ser setado como None para esvaziá-lo.

• call_args

  Retorna uma tupla com os argumentos da última chamada o mock ou None caso o mock não tenha sido chamado.

• callargslist

  Retorna uma lista com todas as chamadas que o mock fez como tuplas dentro da lista. Retorna uma lista vazia caso o mock não tenha nenhuma chamada.

• method_calls

  Retorna as chamadas de métodos e atributos do mock bem como as do próprio mock.

• mock_calls

  Retorna todas as chamadas do mock, de seus métodos, atributos, métodos mágicos e valores de retorno.

• class

  Para um objeto mock com um speco método mágico __class__ retornará a classe do spec, isso permite que mocks passem em testes de isinstance(). __class__ pode receber valores, isso permite que o mock passe em testes isinstance() sem a necessidade de usar um spec.

  ```s

falso = Mock() falso.class = list isinstance(falso, list) True ```

MagicMock e suporte a métodos mágicos

Mock permite a mockagem dos métodos de protocolo do Python, também conhecidos como "métodos mágicos". Isso permite que objetos mock substituam contenders ou outros objetos que implementam protocolos Python. Como métodos mágicos são vistos de forma diferente dos demais métodos essa funcionalidade foi implementada especificamente. Portanto, não são todos os métodos mágicos suportados, apesar da lista incluir a maioria deles.

Podemos mockar métodos mágicos definindo o método desejado para uma função ou objeto mock. Caso seja uma função então o primeiro argumento precisa ser self.

```s

def str(self): ... return "primeiro exemplo" ... falso = Mock() mock.str = str falso() "primeiro exemplo" ```

```s

falso = Mock() falso.str = Mock() falso.str.return_value = "segundo exemplo" str(falso) "segundo exemplo" ```

```s

falso = Mock() falso.iter = Mock(returnvalue=iter([])) list(falso) [] `` Chamadas a métodos mágicos não aparecem emmethodcallsmas aparecem em mock_calls`.

Se a palavra-chave spec foi usada na criação do Mock como argumento então definir um método mágico que não esteja na spec resultará em um erro do tipo AtributeError

Abaixo a lista completa dos métodos mágicos suportados.

• __hash__, __sizeof__, __repr__, __str__
• __dir__, __format__, __subclasses__
• __floor__, __trunc__, __ceil__
• Comparações: __lt__, __gt__, __le__, __ge__, __eq__, __ne__
• Métodos Contenders: __getitem__, __setitem__, __delitem__, __contains__, __len__, __iter__, __reversed__, __missing__
• Gerenciador de contexto: __enter__, __exit__
• Métodos numéricos unários: __neg__, __pos__, __invert__
• Os métodos numérios (incluindo mão direita, variantes no local): __add__ , __sub__, __mul__, __matmul__, __div__, __truediv__, __floordiv__, __mod__ __divmod__, __lshift__, __rshift__, __e__, __xor__, __or__ ,, __pow__
• Métodos de conversão numérica: __complex__, __int__, __float__, __index__
• Métodos descritores: __get__, __set__, __delete__
• Pickling: __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__, __setstate__

Os seguintes métodos existem porem não estão disponíveis por serem usados pelo módulo mock, são definidos dinamicamente, ou podem causar problemas

• __getattr__, __setattr__, __init__ , __new__
• __prepare__, __instancecheck__, __subclasscheck__, __del__

A classe MagicMock

Existem duas variantes de MagicMock: MagicMock e NonCallableMagicMock

class unittest.mock.MagicMock(*args, **kwargs)

MagicMock é uma subclasse de Mock com implementações da maioria dos métodos mágicos pré configuradas por padrão. Os parâmetros do construtor possuem o mesmo significado que Mock

Caso spec ou spec_set seja usado então apenas métodos mágicos definidos no spec serão criados.

class unittest.mock.NonCallableMagicMock(*args, **kwargs)

Uma versão de MagicMock que não pode ser chamada.

Os parâmetros do construtor possuem o mesmo significado que MagicMock com exceção de return_value e side_effect que não tem significado em um objeto que não pode ser chamado.

Os métodos mágicos são configurados com objetos MagicMock, portanto é possível configurá-los e usá-los da maneira usual:

```s

falso = MagicMock() falso.getitem.return_value = 42 falso[3] = "quarenta e dois" falso[3] 42 ```

Muitos métodos de protocolo retornam por padrão objetos de um tipo específico. Portanto para que possam ser usados sem que seja necessário configurar um valor de retorno, esses métodos são pré configurados com um retorno padrão. Ainda é possível configurar manualmente o valor de retorno caso o padrão não seja adequado.

Abaixo os métodos e seus retornos:

• __lt__: NotImplemented
• __gt__: NotImplemented
• __le__: NotImplemented
• __ge__: NotImplemented
• __int__: 1
• __contains__: False
• __len__: 0
• __iter__: iter([])
• __exit__: False
• __complex__: 1j
• __float__: 1.0
• __bool__: True
• __index__: 1
• __hash__: hash padrão do mock
• __str__: str padrão do mock
• __sizeof__: sizeof padrão do mock

O módulo patch

Os decorators patch são usados para "remendar" (do inglês patch) objetos no escopo da função eles decoram. Esses decorators desfazem seu próprio uso automaticamente e tratam exceções potencialmente disparadas durante esse processo. Todas essas funções podem ser usadas em um with ou como decorators de classe.

unittest.mock.patch(alvo, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

@patch('modulo.Classe3')
@patch('modulo.Classe2')
@patch('modulo.Classe1')
def test(ClasseFalsa1, ClasseFalsa2, ClasseFalsa3):
    assert ClasseFalsa1 is modulo.Classe1
    assert ClasseFalsa2 is modulo.Classe2
    assert ClasseFalsa3 is modulo.Classe3

Quando mais de um decorator de patch é anotado sobre dada função com dois ou mais argumentos os mocks serão aplicados na ordem normal do python de aplicação de decorators, ou seja, começando de baixo para cima. No exemplo abaixo o mock para modulo.Classe1 será passado em ClasseFalsa1 e assim por diante. Com patch é importante mockar objetos namespace onde eles são procurados.

Além de decorator o patch também pode agir como gerenciador de contexto em uma expressão with

py with patch("modulo.Classe1") as ClasseFalsa1: assert modulo.Classe1 is ClasseFalsa1

Métodos assert

A classe TestCase possui diversos métodos que realizam os testes e notificam as falhas.

• assertEqual(fisrt, second, msg=None)

  Testa se first e second são iguais.

• assertNotEqual(first, second, msg=None)

  Testa se first e second não são iguais.

• assertTrue(expr, msg=None)

  Testa se bool(expr) é True.

  assertFalse() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertIs(first, second, msg=None)

  Testa se first e second são idênticos.

  assertIsNot() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertIsNone(expr, msg=None)

  Testa se expr é None.

  assertIsNotNone() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertIn(first, second, msg=None)

  Testa se first está contido second. assertNotIn() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertIsInstance(obj, cls, msg=None)

  Testa se obj é uma instância de cls, que pode ser uma classe ou tupla de classes. assertNotIsInstance() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertRaises(exception, callable, *args, **kwargs)

  Testa se uma exception é disparada quando callable é executada com quaisquer parâmetros posicionais ou de palavras-chave. O teste falha se uma exceção de algum outro tipo que não a informada é dispara ou se nenhuma é. Para detectar um grupo de exceções, uma tupla contendo as classes das exceções pode ser passada em exception.

• assertRaises(exception, msg=None)

  Retorna um gerenciador de contexto que vai guardar a exceção em seu atributo exception e pode ser usado para fazer verificações adicionais na exceção:

  with self.assertRaises(SomeException) as cm:
  do_something()
  the_exception = cm.exception
  self.assertEqual(the_exception.error_code, 3) 
  

• assertRaisesRegex(exception, regex, callable, *args, **kwargs)

  Faz o mesmo que assertRaises() porém também testa se a string regex combina com a string gerada pela exceção

• assertRaisesRegex(exception, regex, msg=None)

  Faz o mesmo que assertRaises() porém também testa se a string regex combina com a string gerada pela exceção

• assertWarns(warning, callable, *args, **kwargs)

  Testa se um warning é disparada quando callable é executada com quaisquer parâmetros posicionais ou de palavras-chave. O teste falha se um aviso de algum outro tipo que não a informada é dispara ou se nenhuma é. Para detectar um grupo de exceções, uma tupla contendo as classes das exceções pode ser passada em warning.

• assertWarns(warning, msg=None)

  Retorna um gerenciador de contexto que vai guardar o aviso em seu atributo warning e pode ser usado para fazer verificações adicionais no aviso:

  with self.assertWarns(SomeWarning) as cm:
  do_something()
  the_warning = cm.warning
  self.assertEqual(the_warning.error_code, 3) 
  

• assertWarnsRegex(warning, regex, callable, *args, **kwargs)

  Faz o mesmo que assertWarns() porém também testa se a string regex combina com a string gerado pelo aviso

• assertWarnsRegex(warning, regex, msg=None)

  Faz o mesmo que assertWarns() porém também testa se a string regex combina com a string gerado pelo aviso

• assertLogs(logger=None, level=None)

  Um gerenciador de contexto que testa se ao menos uma mensagem é enviada ao logger ou a um de seus filhos no dado level.

  Por padrão o logger é o root, que captura todas as mensagens. Caso informado, o logger precisa ser um objeto loggin.Logger ou uma string com o nome do logger.

  Caso definido, level precisa ser um número para o nível de loggin ou uma string equivalente (por exemplo "ERROR" ou logging.ERROR). O padrão é logging.INFO.

  O teste passa se ao menos uma mensagem emitida dentro do bloco with é compatível com as condições logger e level, caso contrário o teste falha.

  O objeto retornado pelo gerenciador de contexto é um helper de gravação que mantem observa as correspondentes mensagens de log. Possui dois atributos.

  • records

    Uma lista de objetos do tipo loggin.LogRecord das mensagens do log correspondentes

  • output

    Uma lista de objetos str com as mensagens de saída correspondentes formatadas

    Exemplo:

    with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
    self.assertEqual(cm.output, ['INFO:foo:first message',
                                'ERROR:foo.bar:second message'])
    

• assertAlmostEqual(first, second, places=7, msg=None, delta=None)

  Testa se first e second são aproximados em igualdade computando a diferença, arredondando essa diferença em um dado número de casa decimais (padrão 7) e a comparando a zero. note que esse método arredonda o número em casa decimais (como a função round()) e não dígitos significativos.

  Caso delta seja definido ao invés de places, então a diferença entre first e second precisa ser menor ou igual a delta.

  Caso ambos delta e places sejam definidos um TypeError será disparado.

  assertNotAlmostEqual() corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertGreater(first, second, msg=None)

  Testa se primeiro for maior que segundo, retorna uma falha se não for.

• assertGreaterEqual(first, second, msg=None)

  Testa se primeiro for maior ou igual ao segundo, retorna uma falha se não for.

• assertLess(first, second, msg=None)

  Testa se primeiro for menor que segundo, retorna uma falha se não for.

• assertLessEqual(first, second, msg=None)

  Testa se primeiro for menor ou igual ao segundo, retorna uma falha se não for.

• assertRegex(text, regex, msg=None)

  Testa se regex combina com alguma parte de text, retorna uma falha caso nenhuma parte combine.

  assertNotRegex corresponde ao método assert inverso e recebe os mesmos parâmetros.

• assertCountEqual(first, second, msg=None)

  Testa se a sequencia first contem o mesmo número de elementos de second independente da ordem. Caso não possua uma mensagem de erro listando as diferenças será gerada.

  Elementos duplicados não são ignorados quando comparando first e second. Verifica se cada elemento tem a mesma contagem em ambas as sequencias. Equivalente a assertEqual(Counter(list(first)), Counter(list(second))) mas funciona com sequencia de objetos unhashable.

• assertMultiLineEqual(first, second, msg=None)

  Testa se a string multilinha first é igual a string second. Quando não são a diferença entre as duas strings será destacada e incluída na mensagem de falha. Esse método é executado por padrão quando strings são passadas no assertEqual()

• assertSequenceEqual(first, second, msg=None, seq_type=None)

  Testa se sequencia first é igual a sequencia second. caso seq_type seja definido, ambos first e second precisam ser instâncias de seq_type ou o teste falhará. Se as sequências forem diferentes uma mensagem de erro será construída com a diferença entre as duas.

  Esse método não é chamado diretamente por assertEqual() mas é implementado por assertListEqual() e assertTupleEqual().

• assertListEqual(first, second, msg=None)

  Testa se a lista first é igual a second, caso não sejam uma mensagem de erro é gerada com a diferença entre as duas. Um erro será gerado caso first e second não sejam do tipo list.

• assertTupleEqual(first, second, msg=None)

  Testa se a tupla first é igual a second, caso não sejam uma mensagem de erro é gerada com a diferença entre as duas. Um erro será gerado caso first e second não sejam do tipo tuple.

• assertSetEqual(first, second, msg=None)

  Testa se o set first é igual ao second. Caso não sejam, uma mensagem de erro é gerada destacando as diferenças entre os dois sets. O teste falha se ambos first ou second não possuem o método set.difference().

• assertDictEqual(first, second, msg=None)

  Testa se o dicionário first é igual ao second. Caso não sejam, uma mensagem de erro é gerada destacando a diferença entre os dois dicionários.