Gerência e Qualidade de Software - Aula 08 - Teste de unidade

[Música] olá eu sou fábio siqueira e nessa aula vou falar sobre teste de unidade então hoje em dia o que se faz é tentar automatizar o máximo possível os testes então a idéia é que a gente consiga fazer sem intervenção de um ser humano de apresentar um teste automaticamente mas nem tudo dá pra automatizado em alguns tipos de teste que a gente não consegue automatizar por alguns problemas por exemplo taxas usabilidade se de um ser humano então você tem uma pessoa pra ver se elas a qualidade está boa ou ruim por mais que tem algumas

formas a gente automatize alguns tipos de testes de habilidade outra opção no ser humano tem testes também que envolvem processamento paralelo que são muito difícil você testar porque você precisa ter uma condição muito específica para aquilo funcionar então nem sempre a gente consegue automatizar às vezes ainda vai precisar de ser humano e um outro detalhe importante sob teste automatizado aqui tentam tem um curso todo automatizar um teste tem um custo e às vezes não vale a pena um custa tão grande é tão difícil fazer o teste automatizado ou demora tanto tempo executar ele automaticamente é

mais fácil pegar uma pessoa para fazer isso daí mas porque a gente automatiza teste qualquer importância disso qual é o valor disso a primeira coisa que facilita a atividade de teste se você já executou um teste manualmente para vencer já executou a você sabe quando demorado é executar vários testes então se tiver que prestar uma coisa só tudo bem é rápido mas se tiver vários testes e executar é bastante demorado então se você tiver todos os testes automático é fácil é só apertar um botão e pronto tá executado uma outra vantagem é que você consegue

executar com mais freqüência o seu software então você pode executar rapidamente porque não precisa ter um testador não tem uma pessoa para olhar aquilo simplesmente executa você mesmo desenvolvedor pode executar todos os testes se for razoável se detém e com isso você encontra mais defeitos então quanto mais freqüente você executa os testes mais defeitos e tem chance de encontrar e uma outra vantagem é que você pode usar os testes com uma especificação tão você pode pegar os testes e entendeu como funciona o seu software então os testes no final das contas a mim como um

exemplo de funcionamento após esse método aqui tem que passar esse parâmetro tem essa seqüência aqui de chamada para fazer alguma coisa então taxa pode servir como exemplo e acima de tudo uma grande vantagem é que dá confiança aos desenvolvedores desenvolvedores pega um código acórdão os testes não estão com confiança de que o que eles fizeram não tem tanto de feito assim obviamente a gente não garante que não tem defeito mas dá mais confiança do que ele fez não vai quebrar o software e quando a gente automatize os testes em alguns princípios que a gente se

considerar então o primeiro princípio é projetar o código pra ele ser testado então a gente precisa de alguma forma a fazer com que o código que a gente está testando uma classe um método seja adequado para testar isso não quer dizer que a gente vai fazer uma um projeto completamente diferente daquela classe ou estranho não é isso é a gente tem que fazer com que dê pra testar seja fácil de testar se for difícil de testassem às vezes nem consegue testar uma outra um outro princípio é tornar claro o nome do teste é você conseguir

identificar claramente o que aquele teste faz então a intenção do texto em que declara não pode ser um nome de teste que você não sabe o que quer dizer que não ajuda muito você não consegue saber porque se o defeito aconteceu você não consegue identificar qual é a situação que levou aquele defeito pode demorar para encontrar um outro princípio é não alterar o código pra que é para que você consiga testar então tem alguns desenvolvedores fala puxa pra testar aqui pra testar está difícil a uma forma simples a vola altero manualmente ou alterar aquele valor

a eu consigo texto fácil depois que eu testei ou eu volto valor do valor original isso é uma péssima forma de você testar porque se você esquecer de voltar o valor bom se introduzir um defeito no software e hotéis deixou de ser automático porque sempre precisa de uma intervenção sua para voltar o valor colocar o valor então isso atrapalha a atividade de testes e podem produzir efeitos a outro princípio básico é fazer com que os testes sejam independentes são um teste não pode depender do outro porque se um teste falhar o que depende dele também

vai falhar a gente não precisa disso a gente não quer isso a gente quer que cada teste seja isolado então imagine quer aquele problema de compiladores compilador aqueles computadores que dão um monte de defeitos um atrás do outro para um computador de ser mais mais descer e dar um monte de efeito em seguida do outro a si nem consegue olhar atento de efeito e por que um defeito aconteceu puxa é tudo aconteceu por causa de um ponto e vírgula causou 20 e outros defeitos fica difícil você identificar o que está qual foi o problema por

causa da acne então a gente deve isolar cada teste deve ser uma parte separada e outro princípio é cada unidade tem que ser isolado a gente vai testar uma parte ela tem que ser isolado de todas as outras porque isso porque se uma unidade que a gente está testando depende de outra e essa outra unidade tem um defeito poxa o defeito propaga para essa unidade então eu vou chamar um método de uma classe esse método tá com defeito há a minha classe acaba recebendo um valor incorreto e ela acaba gerando um valor incorreto também mas

a culpa não é dela o código dava para estar correto então que a gente deve fazer sempre a isolar eu não devo depender dos outros das outras unidades pensando em baixa unidade outro princípio é minar minimizar a sua posição então a gente deve evitar sobreposição de teste porque se você está sobrepondo testes e está executando o teste repetido você podia não executar aquele teste é sobreposto poxa ela está fazendo duas vezes a mesma coisa além de aumentar o tempo pra você executar os testes a você está fazendo algo desnecessário e outro princípio é fazer com

que o código de teste não vá para a produção tão código de proteção ao código que vai pra o usuário que o usuário mexe então você não faz sentido você colocar deixar os testes disponíveis lá no software que está em produção que usuários estão mexendo porque eles não tinham de teste o usuário vai testar nada está executando e se você deixar o teste lá você pode até abrir uma brecha pode ter uma situação ali que o usuário pode aproveitar uma brecha por causa do teste ou executar o teste em alguma situação e fazer um comportamento

inesperado no seu software e por fim há o que a gente deve testar é sempre uma condição por testes e não deve fazer vários testes de uma vez testa um uma condição por vez então nessa aula a gente vai ver o teste unidade como automatizar teste de unidade e quando o que a gente queria ter essa unidade existem duas alternativas e pode criar a taxa unidade antes de criar o seu software que é o chamado de teste a priori ou como método de teste e de desenvolvimento dirigido por teste teste vai levar mas a então

você pode fazer o teste antes de você fazer o seu código é uma prática bem interessante mas tem gente que tem dificuldade de usar essa prática é uma outra forma é depois que você já fez o seu software então ser feito à unidade que quer testar e aí você cria os testes a partir daí a escolha sua em geral que se recomenda usar o td td a teoricamente traz mais vantagens e o que a gente testa então pensando em taji unidade a gente tem algumas alternativas então o que a nossa unidade é a classe ou

é um método tem alguns autores que defendem que a classe que puxa a classe ao é um ela que tem uns metros o comportamento tudo é baseado nela há algumas pessoas pensam que é um método poxa a parte isolada menor elemento que eu tenho no software é um método é ele que eu executo a classe ela vai agrupar esses vários métodos não tem esses dois pontos de vista a na prática o que qual a diferença disso a prática é que você tem de dependendo de como você escolheu a unidade alguns testes podem ser de unidade

outro podem ser de integração então o teste dentro do método que é o táchira método ele sempre vai ser de unidade não tem como escapar agora você pegar um teste internet todos ou seja você tem um método para chamar outro método então está envolvendo 26 se a unidade foi um método você está fazendo um teste entre diferentes unidades importante vai ser um teste integração agora se a unidade foi a classe tudo bem é teste unidade ainda o teste entre a classe o que ele é é quando você faz várias chamadas chamadas em sequência de vários

métodos da sua classe ainda dentro da classe mas são vários métodos chamados em seqüência se a unidade for a classe então ainda se ainda sem um teste unidade estou testando dentro da classe agora a unidade foi um método é teste integração eu estou testando unidades diferentes então por fim o último tipo de teste a com classe básico de classe é o teste interclasse que vai trabalhar com várias classes são uma classe chama um método de uma outra classe isso sempre vai ser taxa de integração então não tem jeito então dependendo de como você define a

unidade você pode falar poxa esse teste de integração portanto quem cuida da integração é o responsável por fazer na prática os desenvolvedores ou quem está programando a classe acaba fazendo todos os testes dentro da classe então ele acaba fazendo os testes entre a classe intermédia todo em tratamento então na prática essa essa distinção não é muito não faz muita diferença então vamos pegar como exemplo uma classe calculadora ela tem a classe bem simples é uma calculadora que tem a somar e dividir só coloquei dois métodos a para somar e dividir e ela tem um atributo

resultado e ela tem aqui um método para pegar o último resultado é bem simples então como é que a gente testa isso existem vários frameworks de teste unitário em java especificamente existe um framework que é o mais famoso é o mais usado é quase um padrão que é o johnny e ele tem vários similares para outras linguagens de programação que eles são chamados genericamente de accionistas estão a setembro dot net você tem pra ser mais mais e tem pra outras linguagens frangos muito parecidos com o diante e ele já está integrado como ele é quase

um padrão ele já está integrado pra árias vários dvds a o que a gente vai ver nessa aula é o dia 24 apesar de já existir cinco mas alguns idéias ainda não trabalham com cinco então como exemplo aqui a gente vai trabalhar com 4 nos exercícios também vocês vão trabalhar com quatro é os testes quando a gente usa o diu gente ele sempre fica uma outra classe a gente coloca uma classe separada que no final das contas é para seguir aquele princípio de não colocar os testes junto com o código produção então você coloca uma

classe separada e para separar mais ainda é a gente acaba colocando em um pacote completamente diferente então você coloca um pacote diferente perdão uma pasta diferente mas no mesmo pacote pode parecer estranho mas os ds permitem então você coloca uma pasta diferente mas segue a mesma estrutura de pacotes e o interessante disso é porque como o teste está no mesmo pacote apesar do impasse é diferente ele pode usar as informações dos métodos de atributos que são com o escopo de pacote o franklin já então um teste o formato básico de um teste no the unit

é esse daqui então você tem alguns importa se vai ter que fazer naturalmente não tem como escapar disso há o importe diferente é e se importe stantic significa que a gente está importando alguma coisa e eu não quero ficar colocando sempre em nome da classe o estético é pra isso o plano eu não te colocar o nome da classe toda vez que eu posso simplesmente usar um método trabalhar com método diretamente próximo slide eu mostro como ou quais são os métodos que a gente chama diretamente sem colocar o nome da classe e tem outros importa

é que a gente vai ter que fazer pra conseguir usar as anotações que o dia e onde trabalha então onde é baseado em anotações tem várias anotações para informar várias coisas e aqui tem uma classe de teste de exemplo e quando a gente quer executar alguma coisa sempre antes de qualquer teste a gente criou um método e anota ele com before então se eu falar olha se esse método vai ser sempre executado antes de cada teste você coloca um comportamento em geral uma inicialização que ser feito a gente coloca nesse método aqui e cada teste

vai ser em um método separado que a gente anota com um teste então ao notar isso daí vira um teste de junho e sabe que é um teste e executa isoladamente então antes de executar ele sempre executou o método tem before executa o teste e dá o resultado esses métodos eles sempre são vod não tem retorno e se falhar a gente vai mostrar o próximo slide mostro como fazer isso daí como mostrar como verificar alguma coisa e você pode ter vários métodos de teste você pode ter vários metros da classe a nota ele como bateste

e pronto virou um teste com isso a gente acaba isolando os testes cada teste e ficar separado não é um teste junto com o outro cada método é um texto separado e um detalhe importante é um dono do método como a gente já com comunicar o teste que está sendo feito o nome do método é muito importante no nome do método tem que ser bastante sugestivo para que a gente consiga facilmente saber qual é o teste está sendo feito com aquele método há aqui estão os métodos que a gente acaba usando pra fazer as sessões

para a gente fazer a verificação então o os métodos mais usados normais são esses aqui há certo que você coloca uma condição e você verifica se a condição é verdadeira ou não se a condição for falsa o teste acaba não termino teste falhando ele falhou porque a seleção que era pra ser verdadeira acabou sendo falso você coloca uma condição aqui assim como tem um acerto você tem um acerto fauci que aconteceu é o caso oposto a gente está esperando alguma coisa falsa se não deu falso tão taxa de falha a tem também o feio que

é simplesmente pra você falhar automaticamente então chegou no freio para o teste termina o teste com falha e caso você queira testar valores ponto flutuante você não deve usar igual igual ao que eu devo ter esse problema e precisam então que a gente vai fazer é usar esse método há céticos que ele vai comparar dois de ambos e considerou uma um determinado o erro é um determinado épsilon então é um desvio que a gente vai dar um ataque a um determinado delta q é a gente está considerando então no exemplo da calculadora ataque alguns testes

que eu fiz então para inicializar sempre eu quero criar uma compradora quer usar uma calculadora calculadora nova para que um teste o resultado de um teste não influencia o outro então imagine que executem um teste e o resultado dele deixou na calculadora um determinado valor que atrapalha o próximo teste eu não quero ter isso então cada vez que eu vou testar eu quero ter uma quadra nova e aí eu tenho os métodos de 12 testes aqui soma com valores positivos e soma com valores negativos o interessante é notar que eu coloco direto os valores aqui

eu estou testando somar com um e ver se resulta de dois é um teste bem simples ea gente vai fazer para cada teste a gente faz algo desse tipo então tá usando aqui ao certo se isso daqui sem essa condição for verdadeira taxa passou se a condição for falso vai falhar um problema que a gente tem normalmente continuidade à questão da dependência então é muito usual que uma classe dependa de alguma outra classe então ela ela trabalha com outras classes mas pra testar um dos princípios é para automatizar o teste uns princípios é que a

gente se isolar a parte a ser testada então de alguma forma ele precisou essa classe das outras classes como que a gente só lá vão pegar aqui um exemplo então eu tenho agora a calculadora que ela tem memória então como que ela tem memória existe uma outra classe memória então essa classe memória vai aguardar as informações da calculadora ea calculadora simplesmente é faz operações de adicionar um valor e fazer a soma total o exemplo da classe calculadora comemora precisava que eu tenho uma memória interna é um atributo mel e todos os métodos acabam usando memória

então aqui eu uso a memória quito usando memória é puxa todo lugar estou usando memória eu tenho que isolar de alguma forma como eu deveria isolar qualquer um a forma de isolar uma forma é você trocar a classe em vez de usar a classe a real a gente usa um dublê ou seja uma classe que é parecida que ela tem a mesma estrutura nem têm as mesmas assinaturas é só que ela funciona de um jeito diferente que a gente é do jeito que a gente quer existem várias formas de fazer dublê a gente vai usar

nessa nessa aula só uma dessas formas então gente quer trocar a classe eu não quero usar a classe real não quer usar a classe memória eu quero usar um dublê da memória se eu quero usar um dublê da memória de alguma forma preciso trocar essa classe aqui poxa mas do jeito que essa classe tá eu não consigo trocar a única forma de trocar seria vir no código e alterar que o nome da classe em vez de memória para alguma outra isso não é bom porque eu estou fazendo com que meu código tem que ter alguma

alteração para eu conseguir testar e depois tem que voltar o valor é uma forma de fazer com que a eu consiga trocar essa classe é melhorar o projeto na classe minha classe agora precisa ser projetada para que eu consiga testar uma técnica bastante simples para fazer isso é você usar a injeção de independência então a gente altera essa classe para que ela receba no consultor a memória então agora eu tenho o consultor da minha classe recebendo objeto memória e eu posso ter vários tipos de objetos memória o meu dublê na verdade ele vai ser um

tipo de memória então eu faço uma classe filha da classe memória ou se foram interface memória eu realize essa interface e aí eu consigo em injetar diferentes memórias aqui e aí eu consigo testar de uma forma isolada então que eu vou mostrar nessa aula é uma forma de dublê que é o estande o estande é simplesmente uma classe que ela dá resposta programada do jeito que a gente quer dar uma resposta que a gente espera que seja a resposta a que a outra classe deveria dar então aqui no exemplo da calculadora comemora teste da calculadora

comemora na hora de testar a gente cria uma memória proteste entanto criar uma classe específica que vai ser o meu stang e ela vai dar uma resposta esperada poxa eu quero que o colar dura adicione o valor 1 então eu preciso fazer com que a memória proteste ela responda adequadamente quando o método adicionar for for chamado eden aqui na hora do seu martelo só dá a resposta apropriada para que esses métodos funciona desse jeito aqui que eu tô esperando e aí eu consigo fazer o teste de uma forma isolada porque eu fiz a minha classe

memória pro teste e eu sei como ela se comporta então tá aqui o exemplo da classe memória proteste ela tem todo o conteúdo é bem simples ela é tão simples que provavelmente ela vai ter efeito a idéia do dos dublês aqueles vão ser simples o suficiente para não introduzir o efeito ea gente conseguir substituir o aquário original então aqui o salvar não faço nada não posso fazer nada e aí eu tenho as respostas esperadas por exemplo que torna um como um valor sempre que é o que eu preciso para aquele teste funcionar qual é o

problema de você usar um stang então estamos tem vários problemas o principal deles é que você não consegue verificar se nos parece um método foi chamado para começar você não sabe se o método foi chamado você estava esperando você não sabe se os parâmetros passado pela classe são os adequados então você chama memória proteste poxa se uma memória às vezes não passamos parâmetro que ela estava esperando mas como o resultado retorno é sempre fixo ele retorna o valor independente o que se passou e a seqüência de chamada também dos métodos e não sabe se é

correta a ordem pode ser uma ordem estranha que se for a memória se for objeto real da classe real vai vai dar um erro mas como a gente está simulando a ordem não faz diferença aqui é um outro problema bastante desagradável pensando no java é que você vai ter que criar uma nova classe para cada teste então como esteve sempre dava uma resposta específica bom você vai ter que fazer um stop para cada teste para cada uma das respostas que você vai querer para cada método de teste o que é bastante o uso e é

bem desagradável ano já tem a opção de você usa uma classe anônima que facilita esse isso daí evita que você tem que criar um arquivo separado mas ainda assim sem criar uma classe nova o que é trabalhoso existe uma outra forma interessante de você lidar com esse problema que ele dá aqui é trabalhar com outro tipo de dublê que a morte moc jam doble mais avançado ele tem uma verificação por comportamento nessa aula não vou apresentar mas pode procurar na internet tem bastante informação sobre mox e tem vários frames muito interessante sobre moc então por

fim algumas dicas de como criar um teste de unidade usando o diamante como que o teste eu considero o teste estrutural funcionar caixa branca ou caixa preta a recomendação é que os dois mas comece com um teste estrutural o caixa branca começa pensando nele depois você considera também os dos funcionários da caixa preta a outra dica é coloca o valor diretamente na seleção então não coloque uma um cálculo por que que acontece em geral é que o desenvolvedor acaba copiando o código que ele fez na classe dele pra o teste falar preciso tentar esse método

que tem essa forma estranha bom vou copiar essa forma estranha primeiro teste e às vezes a fórmula está com um problema então o que se recomenda que você faça o cálculo na mão e coloque valores em vez de colocar x vezes y mas é colocar o valor do querendo que o calcula retorne 17 então põem lá 17 não coloque a forma outro outra dica importante é não coloca o valor relatório valor relatório parece interessante falar poxa pode ser qualquer valor dessa parcela equivalente então colocá la toya mas isso é terrível porque se falhar o teste

você não consegue se reproduzir ele imagina que o defeito só acontece que o com um valor específico ali é daqueles é daquela classe puxa-se aleatório ele pode acontecer aleatoriamente então pode ser que não consiga reproduzir ele então o defeito acontece uma vez se não consegue identificar de novo é você pra conseguir apurar esse código é outra por fim uma última dica é não teste coisas que são triviais então método o trivial que não faz nada não tem comportamento adequado um jet set por exemplo você tem um método jet que simplesmente retorna o valor do tributo

17 que simplesmente altera o valor do tributo não testa ele não faz sentido testar ele ele não tem comportamento suficiente e tem um custo pra isso você vai perder tempo criando um teste você vai perder tempo executando esse teste e ele vai ter valor nenhum vai ter chance de defeito nenhum então a ideia dos testes a gente não consegue testar tudo a gente escolheu os testes mais interessantes jet set não é um teste interessante então evita testagens e é isso até a próxima [Música] o [Música] [Música] [Música]