Android parte 1: testes automatizados e TDD

Implementando primeiras features - Introdução

Oi, pessoal, beleza? Eu sou o Alex Felipe, instrutor da Alura e vou apresentar para vocês a primeira parte do curso de teste automatizado e TDD aqui no Android.

O que vamos aprender durante este curso? À princípio, vamos adicionar novas features para essa app de leilão, que tem o objetivo de listar os leilões com sua descrição e seus lances e também mostrar alguns detalhes de cada um.

Quando a gente clica no console, por exemplo, ele mostra o maior lance, o menor lance e os maiores lances que foram dados para o leilão do console. Da mesma maneira, quando vamos no nosso carro, que é um outro leilão, ele mostra o maior lance, que é 17 mil, o menor lance, que é 10 mil, e os maiores lances, que ficam entre 17, 15 e 10 mil.

Essas são algumas features que vamos acabar implementando durante o curso. Porém, diferentemente da maneira como estamos acostumados a implementar nossas features, vamos utilizar uma abordagem um pouco diferente que visa uma melhor qualidade do nosso código.

Nesse momento você pode estar se perguntando, “poxa, Alex, mas da maneira como implemento atualmente, sem essa técnica que você está falando, tudo funciona da maneira como espero.”. Realmente, pode até funcionar, porém tende a dar problemas que a gente não espera, como por exemplo situações que a gente não testou do nosso software, como é o caso de criar leilões que têm ordem decrescente de lances ou crescente, e acabamos não testando. Quando a gente vê que alguém fez isso, apresentou um bug.

Isso é muito comum no nosso dia a dia. E são os testes automatizados que acabam evitando esse tipo de situação. Ou melhor, casos que a gente não espera que nosso software comporte, que são nossos famosos bugs. Quem nunca escreveu um código que tem bug? Todo mundo escreve código que tem bug, a ideia é fazer com que esses códigos sejam evitados o máximo possível, e para isso vamos usar essa abordagem que eu comentei com vocês.

Da parte técnica, o que vamos acabar aprendendo com os testes automatizados? A gente vai aprender como podemos colocar nossos testes automatizados em projetos Android, utilizando, por exemplo, a ferramenta do JUnit, que é uma ferramenta bem famosa no mundo Java, que pode ser utilizada no nosso projeto também.

Veremos como podemos criar classes de teste, quais são os padrões para dar nome de classe de teste, quais são os padrões para criar métodos de teste, vamos acabar aprendendo durante o curso. Como a gente pode montar um cenário, como podemos executar uma ação e um teste da maneira esperada, de uma maneira que atenda a nossa necessidade como esperamos que seja atendida.

Vamos ver também outras técnicas que podem ser utilizadas aqui, como é o caso do TDD que comentei com você, que faz justamente a ideia do test drive development, desenvolvimento orientado a testes. A gente vai ver que essa técnica é bem beneficente quando a gente considera testes automatizados no nosso projeto. Vamos acabar aprendendo isso também.

Outro fator que é bem importante é que durante a implementação das features vamos ver que a ideia é fazer com que ela funcione da maneira esperada com o mínimo de código possível, e quando funcionar fazemos a refatoração. Nesse momento vamos ver que os testes automatizados garantem bastante coisa para nós. Fazem com que tenhamos bastante segurança nesse tipo de abordagem quando a gente faz modificação no código. E é claro, a parte mais importante, temos um feedback muito mais rápido do que implementamos.

Diferentemente de ter que ficar abrindo emulador, navegando toda a app para ver se tudo funciona, os testes automatizados fazem uma execução muito mais rápida e vamos ver como eles fazem isso.

Eu espero que você esteja bem animado com esse conteúdo que acabei apresentando para vocês. Se você visa um conteúdo que você quer colocar qualidade no seu código, esse é um curso ideal para você. Se for isso que você está procurando, vamos começar com o projeto que a gente vai ver como podemos fazer tudo isso.

Implementando primeiras features - Conhecendo o projeto

Vamos começar então. Como primeiro passo, vamos abrir o Android Studio. Venho no menu iniciar, escrevo Android e ele aparece Android Studio, dei enter e vamos aguardar ele abrir a tela inicial.

Perceba que está carregando. Já vai finalizar. Como primeira informação é importante verificar a versão que estamos utilizando durante o curso, que neste caso é 3.1.3. Isso significa que se você estiver usando uma versão anterior, eu recomendo que você atualize para essa mesma versão ou uma versão mais recente, para que a gente mantenha os mesmos aspectos visuais durante o curso.

Agora que sabemos sobre a versão que temos que utilizar, precisamos focar na parte do projeto que a gente vai trabalhar. Como estamos acostumados, geralmente criamos um projeto durante os cursos. Só que nesse caso vamos fazer uma abordagem um pouco diferente, que é abrir um projeto que vou fornecer para vocês.

É esse passo que vamos fazer agora. Inicialmente, no seu computador, vou fornecer um projeto por meio dessa extensão zip. Ele vai estar dentro de um zip e a gente vai precisar fazer algumas operações que vamos fazer agora. A primeira delas é dezipar o projeto que está dentro do zip, tirar de dentro daqui.

Para fazer isso no Windows, por exemplo, a gente clica no zip, botão direito, extrair tudo. Ele fala onde a gente quer deixar esse arquivo e o nome que pretendemos deixar. Nesse caso vamos fazer o seguinte. Vamos deixar essa mesma sugestão que ele deixou e colocar no extrair.

Ele vai fazer esse processo e vai abrir o arquivo que foi extraído. Nesse caso, é teste-android-projeto-inicial. O que recomendo para vocês? Nesse caso, é o projeto que vou fornecer para vocês, portanto faz todo o sentido colocar o nome do projeto que a gente vai trabalhar, que nesse caso é o projeto de leilão.

Vou renomear para Leilão. Recomendo que você também faça isso durante esse processo. Agora que a gente fez a renomeação, podemos abrir no nosso Android Studio.

Aqui no Android Studio, como vamos fazer? Temos essa segunda opção, que é open an existing Android Studio project. Ele vai abrir um projeto que já é do Android Studio, no caso o arquivo que mandei para vocês.

Vou clicar nessa opção e ele vai abrir o explorer. Dentro dele, podemos fazer uma técnica, que é clicar, segurar, vir no explorer e soltar. Ele já vai no caminho certo para nós.

Temos o projeto e basta dar um ok. Durante esse processo ele vai fazer o load do projeto que eu forneci para vocês. Por exemplo, ele vai verificar o arquivo de build, vai baixar dependências se for necessário, entre outros passos que são comuns em um projeto Android, da mesma maneira como a gente cria ele está abrindo um que já existe.

Agora é só uma questão de esperar. Pode demorar um pouco para você, não precisa ficar frustrado, porque como falei ele tem dependências aqui, então pode ser que demore um pouco. Nesse caso até abriu rápido, ele só está executando scripts do Gradle e já vai finalizar. Assim que finalizar a gente dá continuidade e explora um pouco como funciona o projeto.

Perceba que ele finalizou. Agora sim podemos explorar um pouco. Como primeiro passo vou executar o projeto para que tenhamos o feedback o quanto antes do que é esse projeto, o que vamos ter de visual, e depois exploro um pouco do que tem de arquivos aqui. Dessa maneira vamos ter certa familiaridade do que temos.

Para executar, como sabemos, utilizamos o atalho “Alt + Shift + F10”, ele apresenta as opções. Vamos escolher a app. Ele está escolhendo as opções para poder colocar no emulador ou algum dispositivo. Nesse caso já tenho o emulador, que é o Pixel, da API 27. Recomendo também que você utilize essa mesma versão para que mantenhamos os mesmos aspectos visuais. Vou dar um ok.

Esse processo às vezes demora um pouco porque ele está abrindo o emulador. E agora é só uma questão de aguardar. Assim que ele finalizar voltamos aqui.

O Android Studio conseguiu carregar nosso projeto. Ele apareceu a tela inicial. Como primeiro passo vou aumentar o emulador para que fique mais visível para vocês. Ele apareceu essa primeira tela mostrando um console e uma imagem. Isso significa que esse primeiro item é um leilão, e é o leilão de um console.

Se a gente clicar nele, aparecem informações do leilão. Mostra a descrição, que é o console, duas labels de maior e menor lance, e a última label de maiores lances. Vamos entender no decorrer do curso como funciona cada uma dessas features. O importante agora é ver qual o comportamento esperado para o setup inicial.

Basicamente é esse. Quando você importar o projeto ou executar, se tiver esse mesmo aspecto visual, está tudo certo, não precisa se preocupar. Como comentei, vamos explorar um pouco dos arquivos que temos no projeto para que tenhamos certa familiaridade.

Vou deixar de lado o emulador e vou entrar no projeto. Como a gente vê, o primeiro passo que faz todo sentido observar é justamente o build gradle que é do módulo app, para vermos, por exemplo, quais são as versões de SDK que estamos utilizando e algumas dependências.

Como podemos ver, a versão de compilação do SDK é a 27 aqui. É essa versão que vamos utilizar. Como versão mínima a gente vai utilizar a versão 15, e a target também, a 27, que é a versão máxima que estamos dando suporte.

Mais abaixo, temos as dependências. As dependências que temos de diferente são as seguintes. A de constraint layout, que vou utilizar a versão 1.1. Não se preocupe caso você não tenha aprendido as novas features da 1.1, estou utilizando as versões da 1.0, porque caso você precise implementar ou aprender sobre o constraint layout a gente tem um curso específico ensinando o constraint layout na versão 1.0. Eu utilizei a versão 1.1 porque no momento que coloquei a implementação do constraint layout no Android Studio ele já baixou a última versão, foi por isso que utilizou essa versão.

Aqui embaixo, estou utilizando o recycler view, que é uma API para poder criar listas, caso você nunca tenha visto ele. Dessa maneira recomendo que você estude nosso curso de recycler view para que você entenda sobre essa API, caso você queira aprender como ela funciona, entre outras peculiaridades.

Durante o curso não vou exigir que você saiba sobre essa API. Vou usar o mínimo do mínimo de conhecimento para que você não tenha dificuldades durante o curso, mas é bem recomendável que você aprenda, porque é uma boa prática utilizar o recycler view para criar listas.

Agora que estamos familiarizados com as dependências e a configuração de build, vamos ver um pouco dos arquivos do código. Se a gente vier no projeto, app, vamos ter Java e nosso pacote raiz, que é o br.com.alura.leilao.

Aqui já forneço para vocês esse model e esse UI. Vamos entrar no model. A gente tem a classe de lance, que é justamente uma classe que vai permitir dar lances para os leilões, ela tem usuário e valor. A gente tem a classe leilão, que vai ser justamente a que vai apresentar cada item que vimos no recycler view. Nela temos uma descrição e os lances. E por fim temos a de usuário, para identificar quem deu o lance para o leilão.

São essas três classes bases que vamos utilizar como modelo. Agora nessa parte de UI, temos activity, que está composto por duas activities. Temos a LancesLeilaoActivity. Essa LancesLeilao representa as informações detalhadas de um leilão. Essa tela que a gente viu representa por meio dessa LancesLeilaoActivity. A gente vai trabalhar no decorrer do curso nessa tela.

Também temos a ListaLeilaoActivity, que é a primeira tela que a gente viu. Ela trata justamente dessa primeira tela que a gente está vendo aqui. Por fim, no código, temos o adapter do recycler view. Se a gente vier no ListaLeilaoAdapter, temos o adapter do recycler view, e temos toda a implementação que a gente fez. É uma implementação bem trivial, dado que você conheça o recycler view, mas não se preocupe caso você não conheça. Recomendo que você faça o curso, mas não vou exigir que você saiba sobre tudo que acontece no recycler view. Vou deixar bem passo a passo para que não seja dificultoso.

Agora que vimos essa parte do código, vamos finalizar vendo a parte dos recursos que a gente tem. No resources, tenho a parte de layout, e no layout tenho o layout para os lances de leilão, que é dessa tela que a gente vê dos detalhes, já tenho o layout pronto para a gente. Temos a tela implementada.

Como eu comentei, foi com o constraint layout que a gente fez essa implementação, caso você não saiba também recomendo que você faça o curso novamente, e a gente tem outros resources, como é o caso do ListaLeilao, para poder mostrar a lista. Também ela foi feita com constraint layout, e por fim temos nosso item_leilao, que representa cada item da lista. A gente tem nosso layout.

Basicamente, esse vai ser o projeto que vamos trabalhar em cima durante esse curso. Esse foi nosso setup inicial. Caso você tenha algum tipo de problema, alguma dúvida, recomendo que você entre em contato no fórum com a gente. E agora que fizemos toda essa parte, no próximo vídeo vamos dar continuidade ao projeto.

Implementando primeiras features - Implementando a primeira feature

Agora que conhecemos o projeto, a gente pode começar com a implementação das features. Mas o que a gente vai implementar durante esse curso? Para isso, fiz o seguinte. Criei um documento onde listei todas as features que a gente vai explorar durante o curso, dessa maneira vamos seguindo essa sequência que vai funcionando conforme a demanda.

Por exemplo, vamos implementar essa primeira feature, quando finalizarmos ela nos preocupamos com a segunda, e assim sucessivamente. Vamos começar com essa primeira feature.

Estamos na nossa tela de lista de leilões e aqui estou indicando que a gente deve apresentar o maior lance para cada um dos leilões. Por exemplo, no console novo está apresentando que 500 reais é o maior lance dele. No computador usado 300 reais e no carro usado 11 mil reais. É isso que a gente tem que fazer.

Como podemos implementar essa feature? Podemos entrar no nosso projeto, explorando nosso código novamente, no Java, br.com.alura.leilao, temos nosso pacote de modelos, com nossas classes de modelo. Temos lance, leilão e usuário. Temos que definir o valor de maior lance para o leilão.

Faz todo sentido virmos na classe leilão e começar a trabalhar a partir dela. Uma técnica que podemos utilizar é a seguinte. Podemos definir, por exemplo, um atributo private double, para ser um valor de ponto flutuante, definido como maiorLance. Podemos trabalhar a partir dele, porque a partir dele vamos conseguir devolver para quem quiser o maior lance por meio de um getter.

Esse pode ser o princípio do qual podemos partir. Agora que temos o atributo que vai estar destinado a definir qual o maior lance, só precisamos calcular, usar uma estratégia que faça esse cálculo para nós.

Como podemos fazer para que dado um lance consigamos calcular ele e iniciar que é o maior lance. Precisamos adicionar esses lances. Temos que ter essa capacidade dentro do leilão. Então faz todo sentido ter a capacidade de propor lances. Podemos fazer da seguinte maneira. Podemos criar um método chamado propoe. Esse método vai receber um lance.

Agora que temos o lance, precisamos ter acesso ao valor que esse lance tem, dessa maneira vamos comparar com o valor do nosso maior lance e ver se ele é maior ou não, porque depois vamos fazendo as atribuições necessárias.

Vamos ver aqui no nosso lance o que temos acesso. Se pegamos um lance.get veja que a princípio não temos acesso a nada. Por quê? Vamos explorar a classe lance. Se a gente entrar com "Ctrl + B" veja que só temos os atributos e não temos nenhum método de acesso. Queremos acesso ao get valor, no caso ao atributo valor, então criamos um getValor.

Agora sim vamos ter acesso a ele. Agora que temos o valor do lance, valorLance, a gente pode fazer as verificações. A gente pode verificar, por exemplo, se o valorLance é maior que o maiorLance, e se isso for verdade, o que vai acontecer? Vamos concluir que agora o maiorLance pode ser representado pelo valor do lance que foi dado, dessa maneira temos a certeza que esse lance que a gente deu aqui é o maior de todos.

Apenas uma observação que é bacana. Precisamos considerar que o maior lance aqui tem que ter garantido inicialmente o menor valor de todos. E como podemos definir isso? Da seguinte maneira. Aqui no Java temos uma constante que define o menor valor possível para um double, que é a partir da classe double. A partir dessa classe double temos uma constante chamada de NEGATIVE_INFINITY.

A partir dessa NEGATIVE_INFINITY estamos atribuindo o menor valor possível, que a gente sempre garante que qualquer tipo de lance que der quando for inicial vai ser sempre maior, e ele já vai atribuir para o maior lance.

Conseguimos implementar essa primeira técnica para devolver o maior lance. Agora só precisamos apresentar essa informação. Precisamos vir na lista e colocar a informação. Vamos na ListaLeilaoActivity e o primeiro passo que vou fazer é o seguinte. Perceba que aqui estou usando esse leilões de exemplo, que é justamente uma lista de exemplo para apresentar os leilões. E não estou usando nenhum método propoe, que é o que implementamos agora.

Quando criarmos um leilão agora, vamos sempre usar o propoe para dar o primeiro lance e definir como o maior lance como a gente implementou. No console, que eu defini, vou usar o console.propoe e vou criar um lance. Vou dar um new Lance e precisamos passar os parâmetros que um lance espera, que são por exemplo usuário e valor.

Vamos fazer um new Usuario, que espera só um nome por meio de uma string, vou colocar, por exemplo, Alex, e o valor ele espera um double qualquer, vou colocar 200. Conseguimos definir o nosso lance para o console.

O que precisamos fazer agora é o seguinte. Dado que estamos trabalhando com uma lista, precisamos informar ao adapter que queremos setar essa informação do lance. Temos que vir no nosso ListaLeilaoAdapter e temos que informar essa informação.

Perceba que estamos trabalhando com o recycler view a partir do view holder, que é uma classe, caso você nunca tenha visto, que vai representar a view que estamos colocando na nossa lista. É a partir dela que vamos conseguir setar as informações. Veja que conseguimos setar descrição, e agora temos que setar nosso maior lance.

O primeiro passo que vamos fazer é dentro do view holder colocar um private final, porque não vamos mudar esse valor, TextView maiorLance. Dado que agora nosso view holder tem acesso ao TextView, só temos que fazer a inicialização da mesma maneira como fizemos na descrição.

Como fazemos a inicialização no nosso view holder? Pegamos o maiorLance, que é a referência que a gente quer inicializar e o atributo itemView, que é a view que representa cada um dos elementos. Aqui fazemos um findViewById.

Aqui a gente só busca nosso elemento que queremos na nossa view, que é o item_leilao_maior_lance e pronto, fizemos a inicialização. Agora temos apenas que colocar o valor, da mesma maneira como colocamos na descrição.

Como fazemos isso? Estamos usando o método vincula. A partir desse método vincula estamos colocando a descrição, e agora vamos colocar o maior lance. Então, setText, vamos pegar o leilao.getMaiorLance.

Perceba que ele não compila porque estamos devolvendo um double, sendo que ele espera um char sequence ou uma string. Podemos fazer uma conversão de string bem fácil. Colocamos uma string e pegamos o valueOf, que é aquele método estático que já converte para nós.

Dessa maneira já conseguimos testar nossa primeira feature. Vamos ver se está funcionando. Vou executar nosso emulador, executar a app, escolher o emulador da API 27, e agora coloco o emulador para vermos rodando. Vamos aguardar enquanto ele roda para nós.

O Android Studio rodou e apareceu para nós o nosso valor de maior lance. A princípio, o que implementamos está funcionando. Podemos prosseguir para a próxima feature.

Pegando nosso documento novamente, vou descer a página, temos nossa próxima feature que está relacionada à nossa outra tela, que é a tela que indica os lances de um leilão. O que temos que colocar aqui? Vamos explorar essa primeira feature, que é o de maior e menor lance.

Vamos colocar essas informações. Dado que já temos o maior lance, a primeira coisa que vamos fazer é simplesmente setar esse valor. Vou entrar no nosso projeto e na activity. "Ctrl + N”, é a LancesLeilaoActivity. Vou pegar aquela view que representa o maior lance. Vou pegar o textView, o maiorLance, e vou buscar a view dele, ‘findViewById(R.id.lances_leilao_maior_lance)’. Ponto e vírgula aqui e a partir do nosso textView podemos setar a informação do nosso leilão.

Da mesma maneira como fizemos antes, vou até já fazer um passo antes, que é converter para string, como a gente sabe, dado que devolvemos um double. A partir do ‘string.valueOf(leilão.getMaiorLance())’.

Conseguimos colocar o maior lance. Vamos testar novamente e ver se está funcionando. “Alt + Shift + F10”, coloquei o emulador. Vamos abrir para ver se ele executa. O Android Studio executou sem nenhum problema. Vamos agora para a tela de lances do leilão.

Clicando aqui, temos nosso leilão e ele está mostrando o maior lance sem nenhum problema. Novamente nossa feature funcionou. Agora vamos partir para essa próxima, que é apresentar o menor lance. Vamos fazer da seguinte maneira. Vamos entrar novamente no nosso leilão. "Ctrl + N” leilão e vamos colocar o novo atributo que vai representar o menor lance.

Da mesma maneira, vamos falar que ‘private double menorLance’ e vamos definir como o valor máximo, dado que fizemos a mesma estratégia para o maior lance, vamos usar uma estratégia contrária para o menor lance, porque sempre consideramos que é o maior valor que tem e o valor que a gente comparar com certeza vai ser menor. Então, ‘Double.POSITIVE_INFINITY’.

O POSITIVE_INFINITY é o maior valor de todos comparado ao tipo double. E agora o que podemos fazer é quando tivermos esse if que atribui para o menor lance, queremos pegar a condição falsa, a condição que vamos ter certeza, por exemplo, ‘else if (valorLance < menorLance)’. Dado que isso é verdade, que ele é menor do que o maior lance, significa que é o menor de todos, podemos colocar ‘menorLance = valorLance’. É dessa maneira que implementamos nosso código.

Agora só precisamos fazer com que nosso leilão de exemplo tenha mais de um lance, porque dessa maneira conseguimos testar para ver se realmente está funcionando. Pegamos, por exemplo, uma lista de leilão e definimos mais um lance. Vamos definir da seguinte maneira. Vamos pegar o nosso console, por exemplo, e vou colocar um propoe. Então, ‘console.propoe(new Lance(new Usuario(nome “Fran”), valor: 300.0))’.

Ele tem valor de 300 e o outro de 200. Vamos ver como funciona no nosso código. Mais um detalhe. Percebe que tivemos que colocar, por exemplo, o textView para o maior lance, então temos que colocar também para o menor lance. Vamos colocar antes de testar e ver que não vai aparecer, ‘TextView menorLance = findViewById(R.id.lances_leilao_menor_lance)’.

Fazemos o mesmo procedimento. Agora pegamos o ‘menorLance.setText (String.valueOf (leilão.get))’. Não definimos o get menorLance, só temos que fazer isso agora. A partir do nosso leilão pegamos o get menorLance. Agora que temos acesso podemos buscar ele no ‘menorLance.setText (String.valueOf (leilão.getMenorLance))’.

Conseguimos fazer nossa implementação. Vamos testar. “Alt + Shift + F10”, vou executar nossa app, vamos aguardar enquanto o Android Studio executa. Vou abrir o emulador.

O Android Studio conseguiu executar nossa app. Vamos testar. Clicamos no console, que é nosso leilão, e vamos ver o que acontece. Ele está aparecendo o maior lance, e nosso menor lance. O que implementamos está funcionando, certo? Mas será que está funcionando mesmo?

Vamos fazer outro teste. Vai ser o seguinte. Vamos pegar aquele leilão que criamos e vamos mudar a ordem dos lances. Dessa maneira vamos ver se, por exemplo, ele funciona caso o primeiro lance seja menor e o segundo maior. Vamos fazer dessa maneira.

Inverti as ordens, vou executar novamente e ver o que acontece. “Alt + Shift + F10”, dei enter, vamos ver o que acontece. Veja que o Android Studio conseguiu executar. Vou abrir o emulador, vou clicar no console. Ele está apresentando o maior lance e o menor lance, mas o valor que ele está apresentando não é o esperado. O que a gente esperava aqui era justamente o valor de 200. Por que será que isso aconteceu?

Se voltarmos no código do leilão, olha o que acontece. Estamos fazendo o cálculo do maior lance, que é justamente verificar se o lance que recebemos é maior do que o maior lance de todos, e só calculamos o menor lance caso essa condição seja falsa.

O que está acontecendo é que se, por exemplo, recebermos o primeiro lance como um valor menor, por exemplo o caso do 200 que vimos aqui, ele só vai fazer o cálculo do maior lance e vai ignorar totalmente o menor lance. Dessa maneira, sempre vamos considerar que o menor lance não seja calculado caso o maior lance seja preenchido.

Por exemplo, vamos receber 200 e na próxima vez que recebermos 300 ele só vai calcular o maior lance, porque ele só calcula o menor lance na condição falsa. Isso significa que não precisamos desse else para funcionar nosso código. Vamos ver se realmente funciona.

“Alt + Shift + F10”, vou executar novamente, veja que o Android Studio conseguiu executar, vou abrir o emulador, vou clicar no nosso leilão, e ele volta a funcionar. Conseguimos consertar esse bug que apareceu para a gente. Mas percebe o tanto de passos que tivemos que executar? O tanto de tempo que tivemos que perder para poder verificar se realmente nosso código funcionava como o esperado? E mais, tivemos sorte de, por exemplo, mudar a ordem dos parâmetros para verificar se realmente era o comportamento esperado. Isso às vezes não acontece no nosso dia a dia como desenvolvedor.

Considerando toda essa demora que tivemos para implementar, toda essa resposta do feedback de ter que executar o emulador para verificar se funciona, de ter que verificar entrando na tela, saindo da tela, entre outras tarefas que a gente fez tudo para poder verificar se tudo funcionava da maneira esperada dadas as features que eu tinha apresentado, a seguir vamos ver uma técnica que podemos utilizar para melhorar essa nossa experiência como desenvolvedor. A seguir vamos ver ela.

Sobre o curso Android parte 1: testes automatizados e TDD

O curso Android parte 1: testes automatizados e TDD possui 155 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de Android em Mobile, ou leia nossos artigos de Mobile.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Implementando primeiras features
• Introdução aos testes automatizados
• Mais testes com boas práticas
• Refatorando e reutilizando código nos testes
• Implementando features com TDD
• Cobrindo mais casos de uso