Lógica da aula

Olá Gustavo, tudo bem com você?

Peço desculpas pela demora em lhe responder.

No Python temos a cláusula try (em português: tente) e a cláusula except (em português: exceto). Essas cláusulas trabalham em conjunto, onde será feita a tentativa (try) de execução de um bloco de código exceto (except) quando uma condição for atingida, na atividade da aula, o bloco de código presente no try será executado exceto quando for levantado o erro de valor (ValueError).

Recapitulando o conteúdo do arquivo dominio.py, nele temos a validação da proposta do usuário, essa validação está na classe leilao, método propoe; onde, caso um usuário tente dar dois lances seguidos será levantado (raise) o erro de valor (ValueError).

Método propoe

def propoe(self, lance: Lance):
    if not self.__lances or self.__lances[-1].usuario != lance.usuario
        if lance.valor > self.maior_lance:
            self.maior_lance = lance.valor
        if lance.valor < self.menor_lance:
            self.menor_lance = lance.valor
        self.__lances.append(lance)
    else:
        raise ValueError('Erro ao propor lance')

Em nosso arquivo de teste test_leilao.py temos o teste que verifica se um mesmo usuário deu dois lances seguidos, nesse teste fazemos o uso das cláusulas try e except, onde irá realizar a tentativa de propor dois lances seguidos pelo mesmo usuário, essa tentativa deve ser feita exceto quando for levantado o erro de valor (ValueError).

Teste

def test_nao_deve_permitir_propor_lace_caso_o_usuario_seja_o_mesmo(self):
    lance_do_gui200 = Lance(self.gui, 200.0)

    try:
        self.leilao.propoe(self.lance_do_gui)
        self.leilao.propoe(lance_do_gui200)
    except ValueError:
        quantidade_de_lances_recebido = len(self.leilao.lances)
        self.assertEqual(1, quantidade_de_lances_recebido)

Note que no teste acima estamos fazendo duas propostas com o mesmo usuário no bloco de código try. Em nossa classe Leilao foi implementado no método propoe o impeditivo de propostas seguidas pelo mesmo usuário, assim será levantado o erro de valor, levando a execução do teste para o bloco except, onde será verificado se a quantidade de lance salvo é um (1), no nosso exemplo será, já que o segundo lance não será aceito por ser do mesmo usuário, assim o teste passará.

Os códigos acima foram utilizados até o minuto 8 da aula, após esse tempo é realizado uma refatoração do código, onde é realizado a mudança do código do teste mantendo seu objetivo, verificar se é levantado o erro de valor (ValueError).

Código do teste após refatoração

    def test_nao_deve_permitir_propor_lace_caso_o_usuario_seja_o_mesmo(self):
        lance_do_gui200 = Lance(self.gui, 200.0)

        with self.assertRaises(ValueError):
            self.leilao.propoe(self.lance_do_gui)
            self.leilao.propoe(lance_do_gui200)

No código de teste acima é utilizado a cláusula with (em português: com) para informar as propostas dos usuários, usando essa cláusula é informado que o bloco deverá ser executado com (with) o módulo self.assertRaises herdado da classe TestCase, usando esse módulo podemos informar qual erro esperamos que seja levantado, nesse exemplo deverá esperar que seja levantado o erro de valor.

Em resumo temos:

• Antes da refatoração do código, nosso teste espera que seja levantado um erro de valor (ValueError), após o erro ser levantado é realizado uma verificação através exceção (except), verificando assim se o comprimento da lista é igual a 1, caso seja o teste passará.

• No segundo momento após nossa refatoração do código, o teste realizará apenas a verificação se é levantado o erro de valor, essa verificação ocorre com o uso do método self.assertRaises, quando é feita a tentativa de propostas iguais.

• Nossos testes apresentaram falhas quando o erro não for levantado, seja por informarmos usuários diferentes ou por não ter sido implementado o levantamento do erro, algo que o professor simula no minuto 5:50 da aula.

Fico à disposição em caso de dúvidas.

Abraços e bons estudos.