Olá a todos, hoje vim apresentar a vocês uma nova biblioteca de testes unitários chamada Sheepy, mas primeiro vamos falar sobre a importância dos testes unitários. Esta biblioteca não é para iniciantes, para fazer testes unitários com ela você precisará prestar um pouco mais de atenção. Possui afirmações apenas para testes de API com módulos de verificação de erros de endpoint e http.

Link do GitHub:github
Link PyPi: pypi

Todo software maduro e que se preze em produção possui testes unitários, seja para ter uma noção se o que já estava no código continua funcionando, para evitar bugs que já foram relatados e corrigidos antes ou para testar novos recursos, é é um bom indicativo de que as coisas estão avançando e não acumulando dívida técnica. Vamos usar o navegador Firefox como exemplo, todo diretório possui um subdiretório de testes, com testes específicos para bugs que já foram reportados, dessa forma garantem que bugs corrigidos não aparecerão novamente do nada, bugs que já foram corrigidos aparecem do nada novamente. Chama-se jogar dinheiro fora. Com o tempo, você perde tempo, dinheiro, eficiência e participação de mercado para um concorrente que está se saindo melhor do que você com menos recursos.

Todo mundo que se sente incapaz de fazer algo tenta difamar essa coisa, e os testes unitários não são diferentes. Criar testes unitários melhores que cubram cada caso de uso leva tempo, como tudo na vida, seu backend duvido que você tenha lido apenas um tutorial e tenha saído fazendo api's perfeitas, a mesma coisa para seu front end, duvido que você assistiu um curso e veio tornando as interfaces perfeitas. Então não pense que com testes unitários será diferente!

Métodos de afirmação

 ----------------------- ------------------------------------------------------- 
| Assertion Method       | Description                                           |
 ----------------------- ------------------------------------------------------- 
| assertEqual(a, b)      | Checks if two values are equal.                       |
| assertNotEqual(a, b)   | Checks if two values are not equal.                   |
| assertTrue(expr)       | Verifies that the expression is True.                 |
| assertFalse(expr)      | Verifies that the expression is False.                |
| assertRaises(exc, fn)  | Asserts that a function raises a specific exception.  |
| assertStatusCode(resp) | Verifies if the response has the expected status code.|
| assertJsonResponse(resp)| Confirms the response is in JSON format.             |
| assertResponseContains(resp, key) | Ensures the response contains a given key. |
 ----------------------- ------------------------------------------------------- 

Instalação

Para instalar é muito simples, basta abrir um terminal de sua preferência, com o pip instalado e digitar pip install sheepy

Exemplo de uso

from sheepy.sheeptest import SheepyTestCase

class ExampleTest(SheepyTestCase):
    def test_success(self):
        self.assertTrue(True)

    def test_failure(self):
        self.assertEqual(1, 2)

    def test_error(self):
        raise Exception("Forced error")

    @SheepyTestCase.skip("Reason to ignore")
    def test_skipped(self):
        pass

    @SheepyTestCase.expectedFailure
    def test_expected_failure(self):
        self.assertEqual(1, 2)

A classe SheepyTestCase fornece diversas funcionalidades para criação e execução de testes unitários, incluindo métodos de assertividade e mecanismos para configuração de comportamentos especiais, como pular testes ou tratar falhas esperadas.

Dentro da classe ExampleTest, cinco métodos de teste são definidos:

test_success: Este teste verifica se a expressão passada para o método assertTrue é verdadeira. Como o valor True é passado explicitamente, este teste será bem-sucedido.

test_failure: Este teste verifica a igualdade entre dois valores usando o método assertEqual. Porém, os valores comparados, 1 e 2, são diferentes, o que resulta em falha no teste. Isso demonstra um caso de falha esperada, onde o teste deve detectar a inconsistência.

test_error: Este método gera uma exceção proposital com a mensagem "Erro forçado". O objetivo é testar o comportamento do sistema ao lidar com erros que ocorrem durante a execução do teste. Como o método lança uma exceção sem tratá-la, o resultado será um erro no teste.

test_skipped: Este teste foi decorado com o método skip da classe SheepyTestCase, o que significa que ele será ignorado durante a execução dos testes. O motivo para pular o teste foi informado como “Motivo para ignorar”, e essa justificativa pode ser exibida no relatório final do teste.

test_expected_failure: Este método usa o decorador esperadoFailure, indicando que uma falha é esperada. Dentro do método existe uma verificação de igualdade entre 1 e 2, o que normalmente resultaria em falha, mas como o decorador foi aplicado, o framework considera essa falha como parte do comportamento esperado e não será tratada como um erro, mas sim como uma "falha esperada".

Saída

Resultados do teste:
ExemploTest.test_error: FAIL - Erro forçado
ExemploTest.test_expected_failure: FALHA ESPERADA
ExemploTest.test_failure: FALHA - 1!= 2
ExemploTest.test_skipped: SKIPPED -
ExemploTest.test_success: OK

Caso de teste da API

O teste de API no Sheepy Test Framework foi projetado para ser simples, mas poderoso, permitindo que os testadores interajam com APIs usando métodos HTTP comuns, como GET, POST, PUT e DELETE. A estrutura fornece uma classe dedicada, ApiRequests, para simplificar o envio de solicitações e o tratamento de respostas, com gerenciamento de erros integrado por meio da classe de exceção HttpError.

Ao testar uma API, a classe de teste herda de SheepyTestCase, que é equipada com vários métodos de asserção para verificar o comportamento da API. Isso inclui assertStatusCode para validar códigos de status HTTP, assertJsonResponse para garantir que a resposta esteja no formato JSON e assertResponseContains para verificar se existem chaves específicas no corpo da resposta.

Por exemplo, a estrutura permite enviar uma solicitação POST para uma API, verificar se o código de status corresponde ao valor esperado e afirmar que a resposta JSON contém os dados corretos. As solicitações de API são tratadas por meio da classe ApiRequests, que se encarrega de construir e enviar as solicitações, enquanto o tratamento de erros é simplificado, gerando erros específicos de HTTP quando o servidor retorna códigos de status inesperados.

Ao fornecer asserções integradas e tratamento de erros, a estrutura automatiza muitas das tarefas repetitivas em testes de API, garantindo correção e simplicidade na escrita de testes. Este sistema permite que os desenvolvedores se concentrem na verificação do comportamento e da lógica da API, tornando-o uma ferramenta eficiente para garantir a confiabilidade das interações da API.

from sheepy.sheeptest import SheepyTestCase  

class TestHttpBinApi(SheepyTestCase):
    def __init__(self):

        super().__init__(base_url="https://httpbin.org")

    def test_get_status(self):

        response = self.api.get("/status/200")
        self.assertStatusCode(response, 200)  

    def test_get_json(self):

        response = self.api.get("/json")
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "slideshow")  

    def test_post_data(self):

        payload = {"name": "SheepyTest", "framework": "unittest"}
        response = self.api.post("/post", json=payload)
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "json") 
        self.assertEqual(response.json()["json"], payload)  

    def test_put_data(self):

        payload = {"key": "value"}
        response = self.api.put("/put", json=payload)
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  
        self.assertResponseContains(response, "json")  
        self.assertEqual(response.json()["json"], payload)  

    def test_delete_resource(self):

        response = self.api.delete("/delete")
        self.assertStatusCode(response, 200)  
        self.assertJsonResponse(response)  

Exemplo de saída

Test Results:
TestHttpBinApi.test_delete_resource: OK
TestHttpBinApi.test_get_json: OK
TestHttpBinApi.test_get_status: OK
TestHttpBinApi.test_post_data: OK
TestHttpBinApi.test_put_data: OK

Resumo:

A nova biblioteca Sheepy é uma biblioteca incrível de testes unitários, que possui vários métodos de acesso de testes, inclusive um módulo apenas para testes de API, na minha opinião, não é uma biblioteca para iniciantes, requer conhecimentos básicos de programação orientada a objetos como métodos, classes e herança.