Bem vindo de volta.
Vamos fazer um pequeno exercício divertido revisitando um trecho de código que escrevemos antes, lembre-se
do jogo aleatório sem adivinhação em que tínhamos que adivinhar um número entre um e dez se eu rodasse este arquivo, está vendo?
Ele me pediu para adivinhar.
Então, digamos um, dois, três, quatro, cinco, seis, sete, oito, nove.
E finalmente consegui o número.
Você é um gênio.
O número era nove.
Então, como podemos testar este código agora?
Uma coisa que você notará aqui é que não temos realmente uma função.
Lembro-me de quando falei sobre programação funcional e como é bom dividir nosso código
em pequenos pedaços de funções que fazem uma coisa e outra muito bem, especialmente funções puras.
Bem, um dos grandes benefícios dessa mentalidade é que você cria um código que é muito, muito fácil de
testar.
Em vez de termos uma lógica realmente complicada em nossos testes, podemos simplesmente dar a nossas funções uma entrada
e esperar uma saída e é por isso que temos o teste de unidade.
E a ideia de um teste de unidade é testar cada peça da unidade.
Esses testes de unidade são pequenos pedaços que testam essas funções simples.
Portanto, meu desafio para você é usar esse código e tentar dividi-lo em funções simples.
Agora.
Em nosso caso, quero apenas testar esta parte do código, que é a parte de adivinhação onde recebemos uma
entrada.
Qual será o palpite e, em seguida, teste contra alguma resposta aleatória que temos e devemos esperar algum tipo
de saída.
Então, ou inserimos um No.
Tem que ser de 1 a 10, e se acertarmos, temos que pegar a string.
Mas a chave aqui é que provavelmente queremos mover isso para uma função que possamos testar, podemos ignorar
o mundo exterior.
E divida isso em sua própria pequena função.
Então, pause o vídeo aqui.
Dê uma chance.
Você terá que superar alguns obstáculos, mas isso realmente testará sua compreensão dos
testes.
Haha.
Engraçado, isso foi demais.
Então passe o vídeo, experimente, senão vou continuar com a resposta.
A primeira coisa que quero fazer é configurar meu teste novamente, vou importar o teste de unidade e vou
criar o teste de classe principal.
Ou vamos chamar um script de teste desta vez ou um jogo de teste.
Eu direi caso de teste de ponto de teste de unidade.
Este vai ser o nosso caso de teste e então aqui vou criar, digamos, apenas um teste simples, digamos.
Jogo ou entrada de teste?
Receba a si mesmo.
E, por enquanto, vou apenas passar isso porque não estamos realmente fazendo nada.
Finalmente, direi se.
Nome, porque para mim, em seguida, execute o teste de unidade.
Dot main.
Portanto, esta é apenas nossa configuração simples.
Portanto, se executarmos isso agora, digamos Python três.
Teste por.
Você vê que executamos um teste.
Tudo bem, então esta é a nossa próxima configuração, o que eu quero fazer é realmente tirar isso para que eu
possa usá-lo em meu arquivo de teste, extraindo-o em uma função.
Então, vou apenas dizer no topo aqui.
Vou definir nosso palpite.
Ganhe ou vamos chamá-lo de Ron.
Acho.
Isso vai receber uma contribuição.
Ou, digamos, um palpite e, em seguida, ele executará esse código, então vamos fazer isso.
Vou tirar.
Este pedaço de código.
Assim.
E simplesmente cole aqui.
Agora, a suposição errada também precisará da variável de resposta, então vou dar a ela uma segunda resposta de
parâmetro.
Assim, para que agora eu possa simplesmente entrar aqui.
Execute esta função com os convidados e responda.
Bem desse jeito.
Então, vamos salvá-lo aqui e executar este teste ou apenas executar o arquivo real para ter certeza de que ainda está
funcionando.
E obtivemos um pequeno recuo aí, então temos que nos certificar de que nosso recuo está correto porque lembre-se
que em Python, isso significa algo.
Tudo bem, agora temos um problema, temos uma quebra fora do loop porque enquanto estamos usando
a quebra, palavra-chave e enquanto estamos fora de um loop agora.
Então, uma coisa que podemos fazer é dizer volte aqui.
Então, vamos executar de novo.
E continue tentando adivinhar um nome.
Ou um número e pronto.
Ainda está funcionando, estou conseguindo usar return aqui porque este poço vai rodar e voltar, mas agora ainda estamos
dentro do jogo.
Então, talvez possamos simplesmente voltar.
Verdade.
E diga, se.
Tente adivinhar.
É verdade, vamos sair dessa.
Novamente, vamos começar nosso jogo.
Vou apenas limpar isso e executar o jogo novamente.
Um dois três quatro.
E aí está.
Digitei um não, sou um gênio, acabamos de terminar o jogo.
Vamos diminuir um pouco o tamanho, para que você possa ver.
Portanto, temos nosso palpite de que modifiquei um pouco o código.
Mas o principal é que extraí uma unidade de funcionalidade para poder testar algo como executar
suposição.
Parece que modifiquei nosso código, mas o código ainda está funcionando.
Portanto, agora vamos começar a testar nossa função mais errada.
Vamos aqui.
E comece a importar nosso script.
E aqui, faça algumas coisas primeiro, quero a resposta, digamos, igual a cinco.
E a estimativa será igual a cinco, então queremos ter certeza de que se os convidados
e a resposta corresponderem, bem, os convidados errados passam pela instrução if e imprimem, você é um gênio ou, no nosso
caso, retorna verdadeiro .
Então, digamos afirmação autodidata.
Igual.
Esse script ou, na verdade, na primeira vez, vamos executá-lo, então vamos ter um resultado igual
ao script DOT.
O que foi, Rodrguez?
Execute adivinhar e dê a resposta e adivinhe.
E esperamos que o resultado também.
Retorne verdadeiro, então podemos apenas dizer afirmar que é verdade.
O resultado é verdadeiro se eu executar isso agora.
Oh, nós realmente iniciamos o jogo, então como podemos consertar isso?
Bem, podemos fechar isso e adicionar o nome if main.
Aqui.
Então aqui embaixo.
Diremos, ei, execute isto apenas se este for o arquivo principal sendo executado assim.
Se eu voltar a testar aqui e executar novamente.
Tudo bem, agora está funcionando, mas recebo um objeto de jogo de teste de ar de asserção sem atributo assert true
porque, bem, eu.
Erro de ortografia.
Vamos tentar de novo.
Tudo bem, parece que um teste foi executado e está tudo bem.
Também vemos que imprimiu que você é um gênio, muito, muito bom.
A propósito, estou mostrando essa forma de teste porque é assim que se parece um cenário da vida real.
Você continua quebrando coisas, continua cometendo erros e então tenta consertá-los e corrigir seu código.
E você pode ver que nosso código já está cada vez melhor apenas executando esses testes.
OK, o que mais podemos fazer, digamos, aqui?
Que vamos copiar isso para que as coisas fiquem mais curtas, vou apenas inserir os parâmetros
diretamente aqui.
Bem desse jeito.
Digamos que você experimente, digamos incorreto.
Ou.
Palpite errado.
Então, digamos que a resposta seja cinco e eu acho que zero.
Portanto, queremos afirmar que isso será igual a falso.
Então, se eu executar isso, dois testes estão passando, isso é incrível.
O que mais podemos testar aqui?
Tudo bem, bem, queremos testar se a estimativa não está entre zero e 10 ou entre um e 10, nesse caso,
queremos ter uma impressão de, ei, bozo, eu disse um a dez.
Então, mais uma vez, posso testar.
Isso se meu palpite estiver errado.
Não.
Digamos que a resposta seja cinco, mas eu dê 11.
Queremos afirmar.
Bem, no momento, estamos imprimindo e não fazendo nada, então talvez devêssemos retornar false apenas para ter alguma
consistência aqui.
De novo, se eu fizer isso e correr.
Ai está.
Três testes estão passando, isso é ótimo, e há muitos, muitos mais testes que podemos escrever.
Talvez façamos mais um teste, que é testar.
E se a entrada for uma string?
Se eu executar isso.
E certifique-se de que está errado.
Digite aqui, certifique-se de que os nomes sejam diferentes.
E tenho quatro testes em execução.
Porque isso não vai passar e vai retornar falso.
Agora, há muito mais coisas que podemos fazer aqui, mas você pode ver o poder do teste agora mesmo se tiver um
teste diferente do meu.
Tudo bem, pessoal.
Os casos de teste são diferentes.
O objetivo do teste é simplesmente.
Olhe nosso código e veja como podemos melhorá-lo, como podemos quebrar nosso código, como podemos simplificar nosso
código dividindo-o em unidades menores, unidades menores que podem ser testadas e consertar alguns erros que talvez não tivéssemos
pensado cerca de.
Agora, há muito mais coisas que podemos fazer.
Mas você percebe aqui como a ideia era trabalhar em uma peça pequena por vez testada.
E então, talvez mais adiante, podemos olhar para esta parte do código ou talvez tentar e aceitar parte do
código.
E aqui está o problema, quando você está trabalhando para uma empresa, argumento que há um número infinito de testes que você
pode fazer.
Você pode ter centenas de linhas aqui para testar seu código em bits.
Mas só porque você está testando tantas vezes quanto possível, isso realmente não torna seus testes bons.
Como eu disse, há um número infinito de testes que você pode escrever.
A ideia é escrever testes de boa qualidade que cubram a maioria dos seus casos, mas eventualmente você terá
retornos decrescentes onde terá que ter uma escolha entre escrever código e escrever testes.
E às vezes, dependendo do que o trabalho exige, você pode ter que se concentrar mais nos testes e
menos no código.
Ou às vezes talvez você precise se mover rápido e não tenha tempo para escrever testes.
E, novamente, dependendo das necessidades do negócio, pode ser esse o caso também.
Mas com esta seção, espero que você entenda alguns dos princípios que seguem os testes no desenvolvimento de software.
Ou seja, bugs sempre surgirão em nosso código.
E podemos usar o Lintang para nos ajudar com isso, mas uma das melhores maneiras de ter certeza de que nosso código
está funcionando corretamente é testando.
E quanto mais testes normalmente temos, mais estável é o nosso código.
Vou ver no próximo, tchau tchau.