Android com Espresso parte 2: testes de fluxos complexos

Aplicando ações nos testes - Introdução

Eu sou o Alex Felipe, instrutor aqui da Alura e vou apresentar para vocês a segunda parte do curso de testes no Android com Espresso, isso significa que se você não fez a primeira parte eu recomendo que você pare o vídeo nesse momento, assista o primeiro curso, conclua todo o conteúdo e depois você volte para esse.

Porque eu vou assumir que você tenha todo o conteúdo ensinado no primeiro curso, porque dessa forma nós acabamos avançando no conteúdo e conhecendo as novidades que vai ter agora, então vamos lá.

O que que nós vamos aprender de novo durante esse curso? Como nós vimos, é uma continuação, por tanto nós vimos que no curso anterior nós partimos do principio de dois testes que foram implementados que foi justamente o teste no qual nós garantimos que aparece um leilão quando nós carregamos lá da API apenas um único leilão.

E para poder reforçar um pouquinho mais o conhecimento, nós fizemos um outro teste no qual nós carregamos dois leilões da API e garantiu que eles também apareciam.

É claro, nós utilizamos técnicas bem similares, que foi justamente com base no ViewMatchers, que nós pegamos ali a view e também o ViewMatchers para fazermos a checagem, para verificar, por exemplo, se ela está aparecendo, nós aprendemos a criar ViewMatchers personalizados que foi justamente para resolver peculiaridades do nosso RecyclerView.

Nós acabamos aprendendo mais esse conceito básico, então nesse curso, além desse conceito básico, nós vamos um pouquinho além, nós vamos implementar novos testes, então, ao invés de só 2 testes, agora nós temos sete, então serão mais cinco testes que nós vamos acabar implementando aqui durante esse curso.

Para começar o que que nós vamos fazer? Nós vamos adicionar mais um teste que vai ser exatamente aqui na nossa classe para testar a lista de leilão.

Aqui nesse teste, o que que nós fazemos? Nós garantimos que aparece um último leilão quando nós carregamos, por exemplo, dez leilões e nós vamos ver que quando nós fazemos essa abordagem, existe uma peculiaridade que nós ainda não sabemos como podemos estar lidando.

Como é o caso de nós termos ali diversos elementos, que eles ultrapassam ali o tamanho da nossa tela e nós precisamos fazer ali o Matcher para verificar se está aparecendo, nós vamos aprender isso utilizando ações durante o teste.

Então nós vamos começar com essa abordagem, inclusive nós podemos ver um pouquinho da implementação e nós vamos ver como que nós podemos estar usando esse perform que faz exatamente isso que eu acabei de comentar.

Quando nós fizermos esse primeiro teste aqui, que nós fizermos essa primeira ação aqui do nosso teste, nós vamos um pouquinho além, nós vamos começar a implementar um teste que tem um fluxo um pouquinho maior.

E como nós sabemos, o nosso aplicativo, ele vai muito além do que a lista de leilão, ele consegue, por exemplo, cadastrar usuários, ele consegue propor lances e assim por diante, então nós vamos tentar garantir esses comportamentos essenciais do nosso aplicativo, a partir desses testes de tela.

Novamente, nós vamos conseguir agora colocar um novo teste, que vai ser, por exemplo, para a nossa tela de lista de usuários.

Nesse teste o que que nós vamos fazer? Nós vamos garantir que aparece ali um usuário, da lista de usuários, toda vez que nós cadastramos, então nós vamos aprender colocar esse teste, inclusive, nós vamos até usar uma técnica aqui do Android Studio para fazer esse teste a princípio, para nós vermos como que ele faz e então nós aprendermos quais são os passos necessários que vai ser justamente o gravador de teste.

Nós vamos aprender a usar ele, que é o Record Espresso Test, nós vamos utilizar ele para conseguir gravar o teste, nós vamos ver como que ele é fácil e como que ele pode nos ajudar quando nós não temos tanta ideia de como podemos estar implementando aqui um teste que tem um fluxo um pouquinho maior.

Depois que nós tivermos esse primeiro contato, nós vamos focar na última tela, que é justamente na tela que propõe lances, então nela o que que nós vamos acabar implementando? Nós vamos implementar aqui os testes que garante a atualização dos nossos lances, então, por exemplo, quando nós recebemos ali três lances, ou então quando nós recebemos um lance, ou de repente quando nós recebemos um lance muito alto.

Nós vamos ver todas essas peculiaridades que esses testes vão conseguir colocar aqui para nós, nós vamos ver, por exemplo, que esse de três lances, ele é um teste que ele tende a ficar bem grande no código está vendo? Ele é um teste bem grandão.

Nós vamos ver que esses testes eles tendem a ficar grandes mesmo, nós vamos aprender também técnicas para tentar deixar o código mais enxuto possível, porque na primeira abordagem nós vamos sempre deixar ali o código grande para poder chegar o mais rápido possível ao que nós esperamos e depois nós vamos aprender a refatorar o código.

Perceba que nós vamos aprender bastante coisa aqui durante esse curso, desde a parte do Espresso em específico, das suas peculiaridades, dos probleminhas comuns que nós acabamos enfrentando no nosso dia a dia, como também as técnicas comuns para nós tentarmos deixar o nosso código de teste o mais simples possível.

É claro, nós vamos aprender também outras peculiaridades que envolve questões técnicas ali para poder rodar o Espresso redondo, como por exemplo, desabilitar animações e transições, nós vamos acabar aprendendo tudo isso.

Inclusive, eu até fiz aqui de propósito essa execução de todos os testes e perceba que, olha o tempo que demorou para executar todos esses testes, 50 segundos, então pensa só como é que vai ser agora esses novos testes que são os testes grandes que nós aprendemos no curso anterior.

Inclusive, eu posso até rodar aqui para vocês verem mais ou menos o que que nós vamos ver durante o curso, então vamos lá.

Eu vou executar o nosso teste aqui, nessa execução eu estou executando todo o pacote que envolve o ui e o activity que é onde está aqui os nossos testes de tela e agora nós vamos ver mais ou menos como é que vai funcionar.

Perceba que são esses testes que eu acabei de mostrar para vocês e agora nós vamos ver a execução, então percebe que aqui está sendo exatamente aquele que atualiza os lances quando recebe um lance muito alto, ele começa a fazer todas as interações.

Nós vamos aprender a fazer todas essas interações que está sendo apresentado aqui durante o teste, seja num momento de clique, seja num momento de preencher um formulário, de selecionar o elemento do Spinner.

Nós vamos aprender todo esse fluxo, apertar o botão de back, então percebe que é realmente ali um teste de fluxo, para garantir todo o fluxo do nosso aplicativo, para ver se realmente ele funciona como é esperado.

E nós vamos ver que tem diversos desafios além daqueles que nós vimos no primeiro curso, inclusive nós vamos usar bastante coisa daquele curso anterior, principalmente na parte de preparar o ambiente.

Então nós vamos ver que novamente nós vamos entrar naquele mesmo conceito de que nós precisamos de um ambiente de teste também, por exemplo, para fazer o teste ali de usuários, então percebe que realmente, o que nós aprendemos no primeiro curso ele vai ser muito válido aqui nesse segundo curso, e novamente, veja que o teste realmente, ele pega bastante tempo para ser executado, agora já chegou ali no 51 segundos.

Basicamente vai ser isso que nós vamos ver aqui durante o curso, eu espero que você esteja animado aqui para aprender todo o conteúdo, animado para fazer esse projeto que é bem bacana, que é garantir todo o fluxo da nossa aplicação que é importante e eu conto com você e até já.

Aplicando ações nos testes - Implementando novo teste

Por mais que nós tenhamos feito toda a configuração necessária para criar testes com Espressos que envolve a integração do Android framework e a nossa API, existem novos cenários aqui que faz todo o sentido nós implementarmos.

Porque até o momento, o que nós garantimos é o seguinte, nós garantimos em um primeiro teste que aparece um leilão quando nós carregamos esse único leilão lá da nossa API e da mesma maneira aparecem dois leilões quando nós carregamos dois leilões da API.

Perceba que são poucos os cenários que nós estamos cobrindo aqui e como nós sabemos, já que nós estamos tratando nesses casos mais visuais, que é justamente o que o nosso usuário final vai ter na nossa aplicação faz todo o sentido nós aumentarmos aqui essa gama.

Qual que seria o próximo caso de uso que seria bacana de nós testarmos? Um outro caso seria o seguinte, nós poderíamos garantir se aparece, por exemplo, o último leilão quando nós carregamos muitos leilões.

Um valor específico seria um valor 10 que já é um valor, por exemplo, que ele cobre aqui toda a nossa telinha da nossa aplicação, então nós temos aqui um único leilão, então os 10 cobririam essa nova telinha aqui e nós queríamos ver se está aparecendo o último e nós vamos ver como nós podemos estar fazendo isso com Espresso, então vamos implementar esse teste e vamos ver os desafios que nós temos.

Vamos lá, então perceba que para criar um novo teste, nós sabemos que nós colocamos aqui um “@Test” e criamos aqui o teste logo abaixo, então “public void deve_AparecerUltimoLeilao_QuandoAarregarDezLeiloesDaApi”, é isso que nós queremos garantir.

Para poder estar criando esse teste nós vamos fazer a mesma técnica que nós fizemos nos outros testes, que é justamente primeiro tentar salvar ali os leilões na nossa APi que é por meio desse método aqui, eu vou até copiar ele e colar aqui embaixo, então "Control + C" "Control + V" e já tenho dois leilões, é só colocar os 8 demais.

Ele está reclamando porque ele precisa, ou tratar a exceção ou então lançá-la e eu vou lançar porque nós não vamos tratar, se caso rolar essa exceção, nós queremos que quebre o teste mesmo.

E agora nós vamos adicionar os próximos leilões, então vamos lá, então deixa eu colocar mais um leilão aqui, que vai ser, por exemplo, de uma TV, em seguida eu vou colocar um outro leilão, então “new Leilao” e eu vou colocar de um “Notebook” e eu vou colocar um outro leilão aqui que vai ser de um console, então “new Leilao”, vou colocar um “Console”.

Aqui já tem cinco, vamos colocar mais cinco aqui, então “new Leilao”, esse outro aqui ele vai ser um jogo, um jogo de video game, um jogo qualquer, vai ser um “Jogo”, então aqui nós temos um sexto, agora vou colocar mais um aqui que vai ser o “new Leilao”, eu vou deixar uma “Estante”.

Agora deixa eu ver aqui, nós temos sete, vou colocar mais três, então “new Leilao”, vou colocar de um “Quadro”, um quadro qualquer, e mais aqui, falta mais dois, agora “new Leilao”, algo que está na moda que são os smartphones, então vai ter um “Smartphone” aqui no leilão e por fim eu vou deixar aquele leilão que nós temos em produção, que é uma casa, então nós vamos colocar aqui um “new Leilao”, uma “Casa”.

Eu já consegui colocar aqui todos os leilões que nós vamos utilizar durante o teste que são os dez leilões, agora nós temos que fazer o próximo passo que é garantir se aparece ali para nós, mas nós sabemos que nós precisamos primeiro inicializar aqui nossa activity, como nós estamos vendo, para depois estar verificando isso.

Nós vamos inicializar a nossa “activity”, então “LaunchActivity”, nós mandando aqui uma instancia de “intente”, pode ser uma instancia sem nada e é isso, nós estamos inicializando.

Agora nós só precisamos verificar se aparece o conteúdo com base no que nós fizemos nos outros testes, que é utilizando aqui o nosso Matcher personalizado, então por isso pessoal, nós podemos estar utilizando aqui a mesma técnica, não vai ter uma diferença.

Nós colocamos aqui o Matcher, que ele vai ser uma View que nós já estamos pegando que é a nossa RecyclerView e ele vai verificar se aparece o leilão em uma posição específica, a posição que nós queremos verificar agora é a décima, que é a última, então nesse caso, já que esse índice começa com zero, nós vamos colocar aqui o valor nove.

Em seguida o que nós vamos fazer? Nós vamos colocar aqui o valor esperado, que é justamente a nossa casa, e aqui a parte do maior lance esperado também, nós já sabemos que é o zero zero. é a mesma coisa porque nós não modificamos nenhum dos lances durante esse teste, então vamos rodar esse teste específico e vamos ver o que acontece aqui durante o resultado dele.

Para isso eu vou até mostrar também a execução aqui no emulador para nós vermos o que acontece e nós termos também um feedback do que está acontecendo aqui e o que nós vamos ter de resultado, então vamos só aguardar aqui o Android Studio começar, assim que ele começar nós verificamos aqui o que acontece, então até já.

Olha só, o Android Studio ele começou aqui com o nosso teste, então ele está começando a rodar aqui bonitinho, olha só que bacana, ele abriu aqui a nossa aplicação, ele deixou ali os 10 e agora ele falhou.

Por que que ele falhou? Vamos dar uma olhada aqui o que que ele fala, subindo um pouquinho mais, nós percebemos que ele mandou aquele erro que até o nosso erro, que é justamente o “IndexOutofBoundException” e ele fala que a View do ViewHolder na posição 9 não foi encontrada.

Mas por que que isso acontece? Vocês viram que quando ele pegou aqui e abriu a nossa aplicação, ele chegou aqui na nossa aplicação e ele colocou todos os leilões e depois ele sumiu, e nos vimos que não apareceram todos os leilões, e se nós pegarmos a base do RecyclerView, nós lembramos que o RecyclerView ele cria ViewHolders o suficiente para mostrar aqui nas Views.

Então se não chegou o momento de aparecer o último leilão, ele realmente não criou esse ViewHolder, então ele não tinha ali esse ViewHolder criado, dado que nós não mexemos ali na nossa lista, ele só criou o suficiente e foi justamente por isso que ele deu esse erro aqui para nós.

Mas então como que nós poderíamos estar fazendo para aparecer aqui no nosso teste, fazer os nossos testes funcionar, percebe que ele apareceu até o leilão jogos, então se nós viermos aqui no nosso leilão jogos, vamos ver qual é a posição dele, ele apareceu aqui justamente nesse carinha aqui, que é o sexto leilão.

Nós percebemos que ele conseguiu preencher uns seis leilões e já que ele só cria o suficiente mais um pouquinho ali de ViewHolders para poder estar utilizando e fazendo a otimização necessário, o último leilão que nós poderíamos estar testando aqui, só para nós vermos esse feedback seria aqui a estante, então nós poderíamos estar verificando aqui essa estante que ela acabou aparecendo um pedacinho ali embaixo, foi rápido mas ela acabou aparecendo.

Vamos fazer o seguinte, vamos só modificar e ver se resolve esse erro aqui, mostrando que está visível ali para nós.

Então vamos lá, a estante aqui, se nós dermos uma olhada, ela acaba sendo o sétimo, então vamos colocar aqui que vai ser a posição seis e vamos colocar que vai ser uma estante, só para ver se o nosso teste passa.

Executando novamente o nosso teste, vamos ver primeiro se ele passa, para nós coletarmos esse feedback e ver se realmente nós conseguimos fazer com que o nosso teste passe da maneira esperada, para depois nós vermos o que que nós podemos estar fazendo para poder abordar a situação anterior, percebe que os jogos ali ele foi, está aparecendo ali todo bonitinho e aparentemente o nosso teste ele passou.

Perceba que o nosso teste passou, só que agora tem mais um detalhe, eu vou até executar de novo para nós vermos esse detalhe acontecendo que é o que eu quero discutir com vocês, que era esse ponto que eu queria chegar com vocês.

Vamos lá, ele está executando aqui novamente, ele abriu aqui a nossa activity e perceba o seguinte, olha a nossa estante onde está, ele está aparecendo realmente para o nosso usuário? Ele não está aparecendo.

Perceba que o nosso teste, por mais que ele tenha passado, ele teve ali um falso positivo, então ele está falando que está aparecendo para o nosso usuário mas na verdade não e nós também vamos entender o que que está acontecendo.

Além desse problema do falso positivo, nós também vimos que nós tínhamos ali o problema de não conseguir rodar o nosso teste para o último elemento, então perceba que nós temos duas situações aqui que são bem comuns quando nós estamos lidando com testes que envolve tela utilizando o expresso, e a seguir nós vamos ver como nós podemos estar resolvendo isso, então até já.

Aplicando ações nos testes - Ajustando o matcher personalizado

Tivemos dois problemas no nosso último teste, o primeiro deles foi quando nós tentamos garantir a aparição do último leilão, quando nós temos os dez leilões e o outro foi o falso positivo que nós tivemos quando nós testamos aqui a nossa estante, que era o elemento que aparecia parcialmente era só um pedacinho dele que aparecia, e o nosso teste falou que ele passou.

Perceba que são duas situações que faz todo o sentido, nós tomarmos atenção e também tomar uma ação para evitar esse tipo de problema.

Vamos entender como que nós podemos estar lidando com esse falso positivo primeiro, que depois nós verificamos como que nós podemos estar fazendo o nosso teste rodar para esse último elemento, que é justamente esse ponto que nós precisamos resolver aqui no nosso teste.

Vamos lá, então por que que deu esse falso positivo? Para nós entendermos esse falso positivo, nós primeiro precisamos analisar quem garante o nosso teste, quem executa, quem faz o match e quem fala se ele passa ou não.

Como nós sabemos, é justamente o matcher, que é esse matcher que fica dentro aqui do matches e esse matcher que nós estamos utilizando é um implementação nossa, nós que fizemos ele e nós precisamos estar verificando o que que ele faz para falar, olha você passou ou olha você não passou e assim nós entendemos como que nós podemos resolver ess3 tipo de situação.

Primeiro vamos entrar na implementação, "Control + B" como nós sabemos, nós fizemos uma implementação de um Bounds de matcher, que é justamente aquele matcher mais seguro, que ele só entra aqui com base na classe que nós estamos colocando no generics e nós vimos que o método responsável para você falar você passou ou não é o matchesSafely.

Nós fizemos toda uma implementação aqui, nós fizemos passo a passo para entender o que nós precisávamos garantir e o que não precisava.

Nós vimos que inicialmente nós pegávamos o ViewHolders, se ele não existia nós mandávamos aquele IndexOutofBoundsException, nós tomamos essa exception quando nós fizemos do décimo elemento, mas nós vimos que é porque justamente ele não foi criado com base que nós não mexemos no RecyclerView, então ele não criou, nós vamos resolver isso depois.

Mas o que nós precisamos verificar nesse momento pessoal, é justamente o seguinte, é essa implementação aqui mais embaixo, nós precisamos analisar ela novamente e ver se ela está fazendo sentido para o que nós precisamos garantir.

O que que nós garantimos aqui? O que que nós garantimos é o seguinte, nós primeiro garantimos se tem uma descrição esperada e se tem o maior lance e se isso aqui for verdade a única garantia a mais que nós fazemos é se a View do ViewHolders aparece.

Mas agora vem a questão, o que que é essa View do ViewHolder? Se eu executar aqui novamente o nosso teste e mostrar aqui novamente, eu consigo mostrar para vocês o que seria essa View do ViewHolder.

Perceba que ele está rolando aqui o nosso teste e a View do ViewHolder é o seguinte, é justamente cada um desses containerzinhos que nós temos aqui na nossa listinha, então está vendo esses quadradinhos? Todos aqueles quadradinhos, aqueles retângulos que representa ali cada elemento do ViewHolder ele é justamente a View do ViewHolder.

Se aparecer um pedacinho daqueles, realmente o nosso teste vai passar, sendo que na verdade, o que nós queremos garantir é partes daquela que estão dentro dela para ver se realmente elas estão visíveis, como por exemplo, a View da descrição e a View do maior lance.

Além de verificar se a View do ViewHolder aparece, faz todo o sentido nós verificarmos também se as Views internas da View do ViewHolder também aparece, que é no caso, por exemplo, os “textView”.

Ao invés de só pegar o conteúdo deles, faz todo o sentido nós incrementarmos aqui e adicionar mais um match que seria o seguinte, nós colocaríamos um and e colocaria aqui se eles aparecem também a partir do displayed, então nós colocamos o “displayed.matches” e nós colocamos o “TextView” de ambos elementos que tem dentro da ViewHolder.

Nós colocamos para o maior lance e nós colocamos aqui para a nossa descrição, então “displayed.matches” e aqui nós colocamos para “textViewDescricao”., dessa maneira nós evitamos que nós tenhamos aqueles falsos positivos, que é justamente falar, olha está aparecendo mas na verdade não está e assim por diante.

Então toda vez que nós fizermos ali um ViewMatcher, sempre lembre-se que faz todo o sentido nós garantirmos a visualização de todos os elementos desejados, que nesse caso é a descrição e o maior lance.

Tem até um detalhe que eu tinha até esquecido do outro curso, que é o seguinte, perceba que eu coloquei esse “isDisplayed” como uma inicialização para o nosso “displayed”, sendo que na verdade ele já é uma inicialização aqui feita do nosso atributo, está vendo? É o nosso atributo ele já tem aqui esse carinha, inclusive eu posso até deixar como final que antes não estava como final porque ele fez uma inicialização ali embaixo e ele até reclama.

Então por boa prática eu vou tirar essa inicialização desnecessária, eu coloquei um atalho errado aqui que ele entrou que foi o "Control + B" se eu não me engano e eu já tinha apagado aqui que foi o "Control + Y" e eu apertei eu acho que o "Control + B" ali sem querer e ele entrou, então pode estar apagando ali sem nenhum problema, se você já apagou não tem nenhum problema, melhor ainda.

O que nós fizemos foi o seguinte, nós agora estamos garantindo que as views desses elementos, que é justamente do nossa descrição e do maior lance estão aparecendo, inclusive, já que ele verifica isso, esses métodos internos, faz todo o sentido nós modificarmos eles também, porque eles não só verificam a descrição, eles não só verificam o maior lance, eles garantem que está aparecendo.

Ao invés de colocar “verifica”, eu vou renomear o nome deles para “apareceDescricaoEsperada” e também o “apareceMaiorLanceEsperado”.

Só com essas modificações vamos rodar o nosso teste do jeito que ele está, que é justamente aqui na posição sete, verificando a estante e vamos ver se ele passa da maneira como ele estava passando anteriormente.

Eu vou executar aqui o nosso teste, aqui bonitinho, eu vou colocar até o emulador aqui aberto para nós vermos o que está acontecendo e nós vamos verificar se nós conseguimos resolver esse primeiro detalhe.

Vamos só aguardar aqui o Android Studio finalizar aqui a execução do teste, perceba que ele abriu ali bonitinho e agora ele está começando com a execução e veja que não aparece a estante novamente e agora ele falhou.

Então vamos verificar aqui o que aconteceu, ele chegou aqui, tentou fazer aqui o teste e olha só, ele falhou aqui indicando que deu aqui aquele problema padrão do nosso matcher personalizado, que é aquela descrição que ele mostra que tentou verificar e não deu muito certo.

Perceba que agora o nosso matcher personalizado, ele já evita esse tipo de situação, mas e se nós colocarmos aqui uma view visível, será que agora ele passa? Que é o que ele tem que passar, que seria, por exemplo, o nosso jogo na sexta posição que aqui fica como cinco já que nós começamos com índice zero, então seria um jogo.

Vamos ver se ele passa para esse jogo que aparece realmente, vamos até colocar aqui o nosso emulador aqui bonitinho para ver se aparece da maneira esperada e se resolveu esse problema nós já conseguimos resolver essa primeira parte do falso positivo, vamos só verificar aqui, ele vai aparecer todos os leilões, ele apareceu ali o jogo e também apareceu o maior lance e agora sim tudo está resolvido da maneira esperada.

Perceba que quando nós temos situações nas quais nós podemos estar aparecendo uma view ou não aparecendo, nós precisamos verificar ali se o matcher personalizado ele está configurado da maneira esperada, esse é um dos maiores cuidados que você tem que tomar.

Sempre que você fizer um matcher personalizado, além de só verificar a view do ViewHolder como nós fizemos, também verifique todas as view que você quer garantir que o seu usuário está vendo.

Esse é um fator muito importante e agora que nós resolvemos esse problema, a seguir nós vamos para o próximo problema, a próxima situação e vamos ver como que nós podemos estar resolvendo.

Que é justamente essa parte aqui do últimos elemento, nós vamos ver como que nós podemos estar resolvendo ele, inclusive vou até deixar aqui ele como último elemento para testar, que vai ser o último problema, vou até rodar que ainda não passa e nós vamos partir desse princípio.

Então vamos só colocar aqui pra rodar aqui bonitinho, ele está rodando, vamos ver se ele não passa de novo, ele não tem que passar, dado que ele não aparece e nós vamos começar a agir em cima disso.

Veja que ele não apareceu, deu erro aqui bonitinho, é o mesmo erro de antes, que é aquele do ViewHolder e nós vamos estar agora lidando com esse tipo de situação, então até já.

Sobre o curso Android com Espresso parte 2: testes de fluxos complexos

O curso Android com Espresso parte 2: testes de fluxos complexos possui 198 minutos de vídeos, em um total de 43 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:

• Aplicando ações nos testes
• Gravando testes com maiores fluxos
• Implemetando testes de fluxo grande manualmente
• Realizando ações em adapter views e aplicando refatoração
• Extraindo comportamentos e testando extremos