Bem vindo de volta.
Vamos escrever nosso primeiro teste agora, teremos apenas uma função simples que executaremos e este programa criará
em nosso arquivo DCPI principal, digamos, vamos torná-lo um pouco maior.
Diremos que temos uma função chamada do stuff.
Sim, função muito descritiva.
Agora, aqui, diremos apenas que aceitamos um número.
E vamos simplesmente retornar NUM mais cinco, uma função muito, muito simples.
Digamos que este seja o nosso código que constrói nosso aplicativo, então esta é apenas uma função, mas
hipoteticamente, temos muitas funções que queremos testar porque essas são ações que iremos executar em nosso
código.
Portanto, a forma como o teste de unidade funciona.
É como isso.
Temos nosso arquivo de teste, e depois de importar nossos testes de unidade, queremos importar enquanto o arquivo que
queremos testar em nosso caso, é o DCPI principal, então vamos apenas importar o principal.
Que está bem aqui.
Ou podemos apenas importar a função também, se quisermos.
Mas no nosso caso, hipoteticamente, temos muitas funções aqui, então podemos apenas importar, significar e usar todas
as funções disponíveis lá.
Agora, a maneira como o teste de unidade funciona é criarmos uma classe e, em seguida, nomeá-la como quiser aqui, ela terá todos
os nossos testes.
Então, vamos chamá-lo de teste principal.
E nós herdamos dentro dessa classe o que o teste de unidade nos dá, que é um teste.
Portanto, esta é apenas uma maneira padrão de trabalhar com teste de unidade, então estamos herdando quaisquer casos
de teste de unidade e agora temos essa funcionalidade disponível em nossa classe principal de teste.
Agora, aqui, podemos começar a testar e escrever código para testar.
Então, como podemos testar o principal?
Faça as coisas funcionar.
Bem, nós simplesmente dizemos, ei, vamos escrever uma função aqui ou um método, porque isso é parte de
uma classe e dizemos, ei, eu quero testar coisas para fazer.
E aqui ele receberá a si mesmo.
Agora, aqui, posso testar meu casaco para poder dizer se não aqui é igual a 10, estou apenas dando um número
aleatório, então direi que o resultado será igual ao ponto principal para fazer as coisas.
Então lembre-se, do stuff vem do Maine, que é a função que queremos testar,
então eu quero executar a função do stuff e fornecer aqui o número do parâmetro, que acabei de fornecer aqui, ou vamos
apenas chamar este teste preparação.
Portanto, neste programa de teste, executaremos o código e obteremos um resultado.
E esta última linha é a parte chave do teste de unidade, o teste de unidade nos permite dizer auto ponto, afirmar igual e
afirmar igual é algo que obtemos quando herdamos do teste de unidade e afirma igual diz, ei,
afirma.
Ou certifique-se de que esses dois parâmetros são iguais no nosso caso, quero testar se o resultado é igual
a, bem, no nosso caso, 10.
Mais cinco deve ser igual a 15.
Tudo bem, agora, finalmente aqui, acabamos de executar o teste de unidade.
E a forma como executamos a unidade, por ser apenas um teste que fiz, poderia ter feito vários
testes.
Tudo o que precisamos dizer é o teste de unidade, ponto principal.
Que irá rodar todo o arquivo de teste dentro do teste feito.
Agora, se eu executar isso agora, tudo que tenho a fazer é dizer Python três, minha linha de comando e dizer ponto de teste.
E eu fico bem, executei um teste super rápido em zero segundos, que foi bom e rápido.
Agora, digamos que eu faça outra coisa em que afirme igual que isso é igual a 10 se eu executar isso.
Eu recebo uma falha, o que falhou?
Bem, o teste para fazer a função falhou.
Na linha oito.
Então, é bem aqui que temos uma asserção e obtivemos 15, mas esperávamos 10.
Quão legal é isso?
Agora tenho uma falha, então preciso consertar meu código.
Então, algo não está certo aqui.
Agora, no meu caso, é porque eu afirmei.
A resposta é 15, mas e se criarmos outro teste aqui?
E verifique, ei, e se tivermos coisas para fazer teste também, e desta vez o programa de teste vai ser realmente um
pedaço de corda.
Então, o que queremos que a função faça?
Bem, no nosso caso, talvez nos dê um valor, então direi apenas valor.
Porque isso não deve funcionar se eu executar isso agora, vamos limpar isso, se eu executar isso agora.
Tudo bem, eu tenho que testar.
Mas eu tenho um ouvido e vejo que estou recebendo um ouvido dizendo que, ei, estou recebendo um
taip que só pode concatenar cordas, não oito.
Agora, neste caso, o que realmente falha?
É o arquivo de teste, porque o que acabamos de fazer na verdade falha em nossa função.
Mas imediatamente, vejo que tudo bem, bem, isso é algo que precisamos consertar para que eu
possa voltar ao Maine e dizer, ei, quero ter certeza de que detectaremos quaisquer erros.
Como peras tailandesas ou avaliadores de valor, então a primeira coisa que posso fazer é apenas dizer e.
Não.
E se eu disser isso para ter certeza de que converteremos algo em um inteiro e eu executar isso.
No momento, eu recebo um valor ar e valor litoral para que possa ser executado neste pedaço de corda.
OK, outra coisa que podemos fazer para melhorar nosso código é envolvê-lo em um bloco tri except.
Direito.
E então podemos pegar.
Então, digamos, exceto.
E aqui, aceite um erro de valor e digamos como ar e aqui podemos fazer o que quisermos.
Então podemos retornar se quisermos o ar ou podemos até mesmo elevar o ar no nosso caso, vamos apenas devolver o ar.
E vou te mostrar o porquê em um segundo.
Agora, se eu corresse isso.
Você vê que meu teste falha, mas agora é na verdade uma afirmação, ou seja, a afirmação está
vindo de nosso arquivo de teste aqui e estou afirmando que quero ter certeza de que o resultado e o valor
são iguais.
Agora, você vê aqui que há um pouco de incompatibilidade, temos um erro de valor aqui que não é igual ao erro
de valor de classe.
Agora, isso é um pouco de um truque porque estamos retornando um ar.
Na verdade, é uma instância da classe value er.
Portanto, precisamos fazer algo assim, precisamos dizer, ei, é uma instância.
E digamos, o que é, uma instância de guerra é um resultado, uma instância de valor er como este, mas o problema
aqui.
É que vamos aumentar um pouco mais, o problema aqui é que assert equals vai esperar
dois parâmetros, duas coisas que devem ser iguais.
Mas aqui eu só quero ter certeza de que isso retorna verdadeiro, que o resultado é uma instância de erro de valor.
Então, como posso fazer isso?
Bem, além de afirmar igual, temos alguns outros métodos que o teste de unidade nos dá.
Se eu for para a documentação do teste de unidade aqui na primeira linha, ela diz a lista de métodos de pesquisa.
Então, aqui eu vejo que esses são todos os métodos para declarar e testar nosso código.
O que provavelmente queremos é este Asatru.
Para verificar se algo é verdade.
Então, se eu afirmar.
Que isso é verdade.
E eu executei meu teste, vamos limpar isso e executar meu teste novamente.
Pronto, fiz dois testes e tudo parece estar bem, e de novo, repassando isso, por que isso?
Bem, estou fazendo meu teste enquanto.
E então vou executar o teste, fazer coisas que vão dar certo, depois faço a segunda parte em que o parâmetro de teste é
algo que não queremos realmente, que é apenas um pedaço de corda.
O resultado nos dará um erro de valor porque detectamos esse erro e agora o estamos retornando.
E então, finalmente, rodamos este pedaço de código, ei, isso é verdade, o resultado vai ser um erro de
valor?
Então você vê o que estamos fazendo aqui, o que estamos tentando fazer com nossos testes é melhorar nossa
função simplesmente tentando quebrá-la.
Então, queremos quebrar nossa função e dizer, ei, posso enganar essa função para me dar um herdeiro?
E depois que você faz isso e um teste falha, você volta a uma função e tenta consertá-la, mais ou menos como
fizemos aqui, o que é muito, muito legal.
Esta é uma prática comum com testes em que você tenta quebrar coisas até que, bem, a função se torne
perfeita.
Agora, quero que você reserve um tempo aqui e veja se podemos quebrar essa função e talvez adicionar mais
alguns testes no próximo vídeo. Vou adicionar mais alguns para tornar essa função ainda melhor.
Te vejo no próximo.