Coverage de Exceptions | Python e TDD: explorando testes unitários

Boa tarde, acabo de finalizar o curso, mas me restaram algumas dúvidas. No processo de coverage do meu projeto, obtive alguns missings: Insira aqui a descrição dessa imagem para ajudar na acessibilidade O que me desperta dúvidas é que a Exception de addition.py foi coberta pelos testes:

addition.py

def addition(tuple):
    """addition

    Args:
        tuple (tuple)

    Returns:
        float: result of addition between tuples first and second element
    """
    try:
        result = float(tuple[0] + tuple[1])
        return result
    except Exception as err:
        print(f'[ADDITION] Something is wrong: [{err}]')`

test_addition.py

from src.addition import addition
from .conftest import valid_numbers, invalid_numbers, invalid_first_number, invalid_second_number
import pytest
from pytest import mark


@mark.addition
def test_addition_valid_numbers(valid_numbers):
    """test_addition
    """
    # When
    result = addition(valid_numbers)

    # Then
    assert result == (valid_numbers[0] + valid_numbers[1])


@mark.addition
def test_addition_invalid_numbers(invalid_numbers):
    """test_addition
    """

    # When
    with pytest.raises(Exception):
        result = addition(invalid_numbers)

        # Then
        assert result


@mark.addition
def test_addition_invalid_first_number(invalid_first_number):

    # When
    with pytest.raises(Exception):
        result = addition(invalid_first_number)

        # Then
        assert result


@mark.addition
def test_addition_invalid_second_number(invalid_second_number):

    # When
    with pytest.raises(Exception):
        result = addition(invalid_second_number)

        # Then
        assert result

Já sobre as Exceptions do meu código de multiplicação, a primeira Exception foi coberta, mas a segunda não:

multiplication.py

def multiplication(tuple):
    """multiplication

    Args:
        tuple (tuple)

    Returns:
        float: result of multiplication between tuples first and second element
    """
    try:
        result = float(tuple[0] * tuple[1])
        return result
    except TypeError as err:
        print(
            f'[MULTIPLICATION] Impossible multiplicate this values: [{err}]')
    except Exception as err:
        print(f'[MULTIPLICATION] Something is wrong: [{err}]')

test_multiplication.py

from src.multiplication import multiplication
from .conftest import valid_numbers, invalid_numbers, invalid_first_number, invalid_second_number
import pytest
from pytest import mark


@mark.multiplication
def test_multiplication_valid_numbers(valid_numbers):
    """test_multiplication
    """
    # When
    result = multiplication(valid_numbers)

    # Then
    assert result == (valid_numbers[0] * valid_numbers[1])


@mark.multiplication
def test_multiplication_invalid_numbers(invalid_numbers):
    """test_multiplication
    """

    # When
    with pytest.raises(Exception):
        result = multiplication(invalid_numbers)

        # Then
        assert result


@mark.multiplication
def test_multiplication_invalid_first_number(invalid_first_number):
    """test_multiplication
    """

    # When
    with pytest.raises(Exception):
        result = multiplication(invalid_numbers)

        # Then
        assert result


@mark.multiplication
def test_multiplication_invalid_second_number(invalid_second_number):
    """test_multiplication
    """

    # When
    with pytest.raises(Exception):
        result = multiplication(invalid_numbers)

        # Then
        assert result

Entendo que eu poderia desprezar essas linhas de código no .coveragerc, mas a minha dúvida é exatamente essa: Em caso de Exceptions, é interessante que sejam cobertos por testes, ou faz mais sentido desprezá-las? E em caso de cobrir com testes as Exceptions, como posso fazer isso?

Vou deixar o link do meu projeto, caso seja necessário: https://github.com/macdjoao/tdd-pytest.git

Desde já, agradeço a atenção.

Olá João, tudo bem com você?

Peço desculpas pela demora em lhe responder.

É importante que as exceções sejam cobertas por testes para garantir que o código está lidando com elas de maneira adequada e para identificar possíveis erros ou comportamentos inesperados. Desprezar as exceções pode levar a problemas na execução do código e a bugs difíceis de serem identificados.

No código apresentado, a exceção do arquivo addition.py está sendo coberta pelo teste test_addition_invalid_numbers que utiliza o contexto pytest.raises para tratar a exceção. Já em relação à exceção do arquivo multiplication.py, apenas a exceção Exception está sendo tratada pelo teste test_multiplication_invalid_numbers. Para cobrir a primeira exceção (TypeError), podemos criar um novo teste no arquivo test_multiplication.py, utilizando o mesmo contexto pytest.raises, como no exemplo abaixo:

def test_multiplication_with_wrong_input():
    with pytest.raises(TypeError):
        multiplication(123)

Nesse teste, estamos usando a função pytest.raises para verificar se a exceção TypeError é lançada quando chamamos a função multiplication com um argumento que não é uma tupla (no caso, o número inteiro 123). Se a exceção for lançada, o teste passa, caso contrário, o teste falha.

Além disso, é importante garantir que todas as exceções estejam sendo tratadas corretamente e que o código está lidando com elas da maneira esperada. Você pode adicionar mais testes para cobrir diferentes cenários de exceções e garantir que o código esteja se comportando corretamente em cada um deles.

Espero ter lhe ajudado. Em caso de dúvidas estou à disposição.

Não hesite em voltar ao fórum para continuar aprendendo e interagindo com a comunidade.

Abraços e bons estudos!

Caso este post tenha lhe ajudado, por favor, marcar como solucionado ✓. Bons Estudos!