Appium: compreenda e aplique testes de interface

Iniciando o projeto - Introdução

Bem-vindo ao nosso curso de Appium aqui na Alura. A gente vai usar nesse curso essa ferramenta que é o Appium que serve para automação de testes para testar nosso Alura esporte, nosso aplicativo da Alura esporte. A gente vai testar essa tela, esse fluxo de cadastro do usuário.

É um fluxo muito comum em vários aplicativos e vamos usar aqui como exemplo. Para testar ele então a gente vai vir aqui e vai colocar o nome, a senha, e vamos colocar, por exemplo, uma senha que não confere para tentar cadastrar. A gente vai ver que não conseguimos cadastrar dessa maneira. Na hora que coloco uma senha que confere, se eu puser a mesma senha que tinha colocado antes vou cadastrar meu fluxo de cadastro que está completo.

A gente vai fazer esses dois testes no nosso aplicativo, só que ao invés de fazer de maneira manual como fiz aqui a gente vai fazer de maneira automatizada. Para isso vou usar o Java para fazer nossa automatização de testes.

Nossa automatização de testes vai utilizar o Appium para rodar a aplicação. Tenho todo esse log aqui porque meu servidor já estava rodando, mas se eu vier aqui, tirar ele e limpar, na hora que eu abro um servidor do Appium ele vai estar só ouvindo chamadas, porque ele faz um servidor rest para começar a chamar.

É esse servidor, essa aplicação que está rodando no meu terminal que no final vai se comunicar com o emulador. Vamos ver isso rodando?

Vou vir aqui, estou com o IntelliJ, e vou pedir para ele rodar minha feature de teste, os testes da minha feature de testes. A gente pode ver que ele começou a rodar, nossa aplicação está rodando e meu emulador vai começar a receber as informações, os comandos, e vai executar os testes de forma automatizada, preenchendo a interface, clicando nos botões, fazendo navegação entre telas e várias coisas que a gente consegue fazer junto com o Appium.

A gente vai chegar nesse projeto no final, onde tenho dois testes que passaram. Para isso, a gente vai fazer esse projeto em Java, usando Java client do Appium.

O Appium pode fazer esse client em várias linguagens, você não precisa fazer em Java junto comigo, porque a API dele, a interface que ele usa é muito parecida para todas as linguagens. A maneira de escrever muda dependendo da linguagem, mas a interface, o jeito de pensar é muito similar, muito parecido. Você não precisa usar em Java assim como vou fazer no curso.

Mas nesse curso também, além de fazer esses dois testes que a gente está fazendo, a gente vai ter nosso page objects. A gente vai ver esse padrão de objetos de page objects, que é um objeto que representa uma tela na nossa aplicação.

Tenho meu page object de cadastro, por exemplo, onde tenho todas as ações que posso fazer na hora da minha tela de cadastro. Vou cadastrar, pegar a mensagem de erro quando tiver mensagem de erro, vou preencher o formulário e buscar os elementos da tela visualmente.

A gente vai fazer tudo isso durante esse curso, entendendo como o Appium funciona e quais são as vantagens e desvantagens de fazer de uma certa forma, de uma maneira ou de outra, para a gente ter sempre o comparativo e tomar as melhores decisões quando estivermos usando essa ferramenta.

Outra coisa que a gente vai ver nesse curso é como fazer esperas, como esperar um elemento dentro da tela, já que na hora que a gente vai buscar o elemento tenho que garantir que ele já foi desenhado, que ele está aqui no meu emulador, para a gente conseguir buscar ele. A gente vai ver como a gente vai fazer esperas dentro desse curso.

Espero você no nosso curso, e meu nome é Ricardo Lugano, vou ser seu instrutor.

Iniciando o projeto - Preparando o ambiente

A gente vai começar aqui nosso curso de Appium na Alura. A primeira coisa que a gente precisa fazer é instalar o Appium, fazer toda a preparação de ambiente para você conseguir seguir esse curso, fazer o projeto junto comigo durante o curso.

Estou aqui no site do Appium, Appium.io, e vou na parte de getting started, onde ele tem as instruções para fazer a instalação. A instalação do Appium é através do npm, como a gente pode ver aqui.

A gente pode fazer na verdade duas instalações, através do npm ou usando o Appium desktop. Para esse curso a gente vai usar sempre o terminal, então vou instalar via o npm.

É um pacote, o gerenciador de pacotes do node js. Então, o Appium na verdade servidor que a gente vai instalar aqui é um pacote lá do node js. A gente precisa do node instalado na nossa máquina para conseguir rodar.

Inclusive, o npm a gente só consegue instalar quando a gente instala o node na nossa máquina. Inclusive a gente fala aqui que você precisa do node js e do npm na sua máquina para poder instalar.

Aqui ele dá uma sugestão de você usar o npm que é um gerenciador de versões do node, ou dar um brew install node, se você estiver usando brew, ou você pode vir aqui também no node js, abrir a página dele e baixar a versão lts, que é mais estável, é a versão que está oficialmente em produção, que é melhor para você usar. E aí a gente só precisa do node para executar esse script, então a versão de teste é suficiente para a gente.

Você pode vir aqui e baixar a versão 12, por exemplo. Já tenho ela baixada na minha máquina, então não vou baixar de novo. Inclusive, eu vou abrir o power shell. A gente pode ver que tenho a versão no node 12 também. A lts é a 12.18, então estou próximo o suficiente ali. E está tudo certo, a gente pode continuar.

Eu vou limpar meu terminal, vou deixar em tela cheia, e aqui ele fala que para você instalar o Appium você vai usar esse comando npm install -g. Como eu já tenho o npm, se eu digitar aqui na minha máquina ou no meu terminal ele vai dar as opções que tenho para usar o npm, já que tenho o node. Vou então npm install -g. O -g vai estar globalmente na máquina, ou seja, ele não vai estar associado a um projeto específico, mas posso usar o Appium em qualquer momento, em qualquer lugar na minha máquina, e aí -g Appium.

Vou dar um enter e ele vai começar a fazer a execução do script. Ele vai começar a baixar tudo que a gente tem da internet em relação ao Appium e fazer a instalação na minha máquina.

Aqui foi super rápido porque eu já tinha o Appium instalado, mas para você pode ser que ele comece a baixar uma série de coisas e demore um pouco mais. Instalei o Appium na minha máquina, trouxe esse script do npm, posso testar então digitando Appium se ele está realmente rodando na minha máquina.

Na hora que faço isso, aqui vou ter um erro. Esse erro específico é uma coisa do power shell que é o terminal que estou usando. Pode ser que você não tenha esse tipo de erro, mas o power shell tem essas requisitions polices, que são políticas de segurança para a execução de scripts.

Então, ele não vai deixar você rodar qualquer script na sua máquina. Se eu vier aqui e copiar a url que ele dá para mim e navegar até a documentação, com essa url https go Microsoft e o link para essa documentação, você consegue ler um pouco mais sobre as políticas de execução, de script do power shell e você pode ver o nível de segurança que você gostaria. Já são verificações de segurança.

Por padrão, quando você instala o power shell ele vem com a política de segurança default, que é restritiva. Ela só vai deixar alguns scripts que são confiáveis, que são assinados, como eles falam, rodar na sua máquina.

O Appium não é um script assinado. Ele não é considerado confiável pelo power shell, então o que eu preciso fazer é mudar minha política de execução para um by pass. Ou seja, não quero que ele faça nenhuma verificação, só quero que ele execute o que pedi. Tenho que garantir que eu vou fazer essas verificações e vou saber o que estou rodando na minha máquina. É um jeito de usar aqui com power shell, mas temos que tomar um pouco de cuidado.

Para fazer essa mudança, vou ter que vir aqui, fechar meu power shell, porque já que é uma política de segurança vou precisar alterar ela via administrador, vou vir no power shell como administrador. Vou pedir que sim, já estou aqui, e o que vou fazer é dar um set execution policy.

Vou atribuir a política de segurança, e a política de segurança que quero é o by pass, quero que ele pule essa verificação. Então vou dar esse comando, ele vai me perguntar se tenho certeza que quero fazer essa alteração, vou dar um a para ele dar um sim para todas as perguntas, não quero ficar respondendo tudo. Vou dar um sim e beleza, agora já mudei a política de segurança.

Se eu der um Appium aqui ele deve funcionar. E aí sim ele está pensando um pouco, está subindo o servidor do Appium, já que o que a gente instalou aqui foi o Appium server, e aí a gente já tem nosso Appium rodando.

Tenho o Appium rodando, estou pronto para fazer meu projeto? Ainda não. O Appium é uma ferramenta com uma série de dependências. Como é uma ferramenta para fazer a automação de testes em mobile, ele tem uma série de dependências que a gente precisa, então no caso vamos trabalhar com Android aqui.

Para o Android, vou precisar do emulador do Android, do stk do Android, do adb, de uma série de ferramentas, do Java, de uma série de coisas que vou ter que ter na minha máquina.

Então, como são várias ferramentas que a gente precisa ter, o próprio Appium já criou outro script falando de verificar a verificação da instalação, que é esse tal de Appium doctor. Vou rodar esse Appium doctor na minha máquina e a gente vai ver as dependências que estão faltando dentro da minha máquina. Na sua máquina pode ter algumas já prontas, outras não, mas na minha máquina vai fazer essa verificação pelo Appium doctor.

No caso, se você quiser saber, como a gente está usando para Android vou usar esse UIAutomator 2, então aqui também ele tem o driver específico e a configuração inicial específica para iOS, Android, Windows, Mac e assim por diante.

No caso, vou fazer do UIAutomator. E ele também tem uma série de requisições. A gente precisa do Java 8 instalado, do Android stk e assim por diante. Para rodar aqui o Appium doctor, ele também dá a sugestão de você fazer a instalação desse script do Appium doctor.

Mas como ele é um script de verificação só das configurações iniciais, provavelmente você não vai ficar usando o tempo inteiro, é provavelmente do Appium que a gente vai realmente querer subir o servidor o tempo inteiro.

No Appium doctor vou usar uma, duas vezes no máximo. Ao invés de fazer uma instalação na minha máquina e ocupar esse espaço, vou rodar através do npx. O npx é um executador de pacotes do npm. Vou dar um npx Appium doctor e aí o que ele vai fazer é que ele vai começar a baixar o Appium doctor do npm, do gerenciador de pacotes.

Quando ele terminar de baixar, ele vai executar esse script que eu pedi, o Appium doctor, vai passar as flags para ele, as atribuições, as configurações para rodar o script, mas aqui não preciso, e depois que ele rodar esse script como está fazendo agora ele vai apagar tudo que baixou. Então não tem nada salvo na minha máquina no final.

Aqui a gente pode ver que está rodando o diagnóstico dele. Aqui ele já terminou de rodar, e se a gente for ver aqui em cima estou rodando a versão do Appium doctor 1.15 e ele está falando que essa primeira parte é um diagnóstico que é necessário para as minhas dependências.

Já tenho o node instalado, está na versão 12.17, ele já achou aqui. Tenho o Android home, que é uma variável de ambiente apontando para o meu sdk do Android. Então, a gente já tem isso configurado. Meu Java home apontando para o meu jdk do Java 1.8, que é a versão 8 do Java. Ele achou o adb, o Android e o emulador na mina pasta de sdk, ele já achou tudo isso. E ele também achou o diretório para minha Java home. Ou seja, tenho que ter duas variáveis de ambiente aqui, a minha Java home e a Java home bin, para ele também achar a pasta de binários, que é onde vão estar as ferramentas do Java.

Meu setup aqui está pronto, porque eu já tinha baixado esse monte de coisas que ele precisa. Mas se você não tem o sdk do Android, minha sugestão é que você venha no Android studio e você baixe o Android studio, porque ele já vai trazer o sdk, o emulador, uma série de ferramentas para você. Ele facilita muito a instalação do sdk, a parte de dependências para o Android.

Então, Android studio é legal de você baixar. Ele demora um pouco, então eu não vou fazer a instalação porque todas essas dependências que ele baixa são muito pesadas, então ele demora para instalar. Mas é um jeito de você instalar o sdk do Android e o emulador de maneira bem fácil.

O Java é a instalação do Java padrão, tem que ir lá no site do open Java, da Oracle, e baixar a versão do Java, do jdk para você conseguir fazer a instalação. E aí você vai ter que configurar essas variáveis de ambiente. Android home, Java home e Java home bin.

Se eu vier no meu computador, e vier na parte de propriedades, a gente pode vir em configurações avançadas de sistema, variáveis de ambiente, e aí aqui eu tenho meu Android home, ele já está configurado. Tenho meu Java home apontado para o meu jdk do Java e na minha path tenho aquela Java home bin, que é a última variável de ambiente que a gente precisa.

Aqui no Windows eu consigo fazer isso visualmente. No Linux e no Mac você tem que fazer isso via terminal para alterar as variáveis de ambiente. Tendo tudo isso pronto, você tem o Appium podendo rodar. Você vai ter todo o seu ambiente preparado para conseguir rodar.

E para rodar o Appium o que a gente faz é limpar isso aqui e ele vai dar no Appium. É só escrever Appium no terminal, ele vai começar a subir o Appium. E aí já tenho a ferramenta funcionando. E essa ferramenta vai falar com meu emulador.

Outra coisa que a gente vai precisar fazer já que a gente vai precisar de um emulador é abrir o Android studio. Vou abrir o Android studio para abrir meus emuladores. A gente vai criar um emulador para esse projeto.

Estou aqui com meu emulador aberto, vou vir aqui em cima, nesse ícone de avd manager. É onde a gente tem a parte de emuladores do Android studio. Clicando nele, já tenho um emulador criado, que eu estava usando antes, mas vou criar um novo virtual device, como ele chama, para a gente usar nesse curso.

Vou vir aqui, create new virtual device aqui embaixo. Ele vai me dar todas as opções de simuladores de aparelho que eu tenho. Tenho desde o pixel Excel, pixel 3, pixel 2, nexus 4 e assim por diante. Tenho vários aqui que posso usar e vai depender um pouco do aparelho que você está usando, se você tem um target, um aparelho alvo específico que você quer testar ou se você tem um máquina mais forte ou mais fraca.

Se você tiver uma máquina mais forte, você pode pegar os que tem maior resolução e não é tanto problema. Se você tem uma máquina mais fraca talvez valha a pena pegar um mais fraquinho, alguma coisa com menos resolução para ele não puxar tanto o processamento da sua máquina.

Aqui nesse caso vou usar o Nexus 4, vou dar um next, ele está perguntando qual é o nível da API do Android que estou usando, então vou usar o Android pai, que é nível de API 28, vou dar um next também. Aqui ele só faz uma verificação, é isso aqui que você quer criar, e o que vou mudar é esse nome.

Aqui vou chamar de Appium tester. Meu Appium tester vai ser o nome do emulador. Esse nome do emulador a gente vai precisar dele mais tarde, na hora que a gente for configurar nosso client do app.

Vou dar um nome aqui que eu quiser para ele que eu vou usar de referência para o meu Appium se conectar com esse emulador específico. Mudei meu nome, conferi tudo aqui, o Nexus, o Android 9, quero na vertical mesmo, vamos dar um finish e ele vai criar meu emulador.

Uma vez que ele criou meu emulador posso clicar na setinha para dar um launch. Quero iniciar meu emulador. Ele vai começar a fazer o Boot do emulador, vai fazer o Boot do Android, e a gente já tem nosso emulador rodando para conseguir fazer os testes do aplicativo.

Agora sim tenho o emulador rodando, o Appium rodando, meu Appium server rodando no terminal, e agora posso começar a fazer meu projeto.

Iniciando o projeto - Iniciando o Client

Estou com meu Appium rodando, como a gente terminou nosso setup inicial, só que como eu falei, esse script do Appium que a gente tem aqui vai ter que se comunicar com nosso emulador, só que como que vou dar instruções para esse servidor que ele criou aqui para fazer o que eu quero no nosso emulador? Por exemplo, como ele sabe qual é o apk que vai ter que instalar lá dentro para conseguir fazer os testes?

Para isso a gente vai precisar de um client do Appium. Não posso só ter meu servidor. O servidor do Appium que a gente instalou aqui através do node é uma parte do Appium. A outra parte é nosso client. Então vou vir aqui no Appium e a parte de Appium clients. No Appium clients eu posso ver a client list, tenho outro link para a client list. Você pode ver que temos clientes desse Appium, dessas libs que ele disponibiliza para a gente em várias linguagens. Ruby, Python, Java, PHP, e assim por diante.

Nesse curso a gente vai usar o Java, mas se você quiser usar qualquer outra linguagem que você está mais acostumado, que seu projeto já está feito nessa linguagem e assim por diante, você fica à vontade para usar. As funcionalidades são basicamente as mesmas e a maneira de trabalhar é basicamente a mesma.

A gente vai usar o Java. Aqui tenho o git hub do Java client, mas a gente vai começar um projeto no Maven, então não vou usar o git hub aqui. Para isso, vou abrir meu IntelliJ, e a gente vai procurar nosso login para o Appium.

Vou digitar Maven Appium e ele vai trazer para a gente no Maven Repository, o repositório de dependências de código do Maven, assim como a gente tem o NPM para o Node temos aqui um repositório muito parecido para o Maven, e vou baixar a versão 7.3 do meu Java client para Appium no Maven.

Clicando nele, já traz o xml que a gente vai ter que copiar para o nosso xml no projeto Maven. Mas antes disso, vamos criar nosso projeto. Meu IntelliJ abriu aqui, vou dar um create project, criar um novo projeto, ele está abrindo as opções. Tenho meu projeto no Maven. Ele está falando meu Java 11, porque está reconhecendo que tenho esse Java 11 baixado, mas na verdade quero usar o Java 8, então vou mudar para Java 8, e vou criar um projeto no Maven a partir de um arquétipo, de um padrão de projeto, uma estrutura de pastas base que já vem com algumas coisas para a gente.

Esse padrão é o nosso quick start. Vou clicar embaixo, começar a digitar para ele buscar para mim, e está aqui quick start. Eu vou baixar, começar a criar meu projeto no Maven através do quick start.

Aqui estou fazendo pelo IntelliJ porque ele traz essa ferramenta mais fácil de usar, porque é uma ferramenta visual, mas a gente tem um curso de Maven aqui na plataforma que te ensina a fazer tudo pela linha de comando pelo terminal se você tiver interesse. Ou se você não tiver o IntelliJ, por exemplo.

Vou colocar na minha pasta, vou dar o nome de Alura Appium, e aí a única coisa que vou mudar é aqui embaixo o meu group id para ser com.alura.appium. Vamos mudar nosso group id que vai ser o nome do nosso pacote.

Vou dar um next. Aqui é uma tela para rever se está tudo certo. Vou dar um finish e ele vai criar esse projeto para mim. Uma vez que ele criou o projeto, a gente vai ter aquele xml que é nosso arquivo de configuração do projeto no Maven e é nesse arquivo de configuração que vou copiar essa dependência para o nosso Appium client.

Vamos fechar essa lateral, esse terminal aqui embaixo, e nesse xml vou tirar essa url, porque nosso projeto não tem url, tenho as propriedades, ele está na versão 7 do Java, vou mudar para a versão 8, e já veio com a dependência do JUnit.

Como nosso curso vai ser um curso de testes, vou deixar o JUnit aqui porque a gente vai usar ele. Aqui embaixo, assim que ele fecha a dependência do JUnit, vou pular uma linha e vou colar minha dependência do Appium. Colei ela aqui e a gente já tem nossa dependência configurada no projeto.

O que vai acontecer é que no seu caso você pode não ter baixado ainda o Appium para a sua máquina através do Maven então ele não vai reconhecer, vai ficar tudo vermelho na hora que você copia essa dependência. O que você precisa fazer nesse momento é ou vir na parte do projeto, abrir o xml com o botão direito e em Maven criar um reload project, ele vai recarregar, escanear esse projeto e ver o xml, ver todas as dependências que você não tem para baixar da internet.

Ou você pode vir aqui através do terminal, no terminal estou usando o integrado do IntelliJ, mas o power shell funcionaria, é só você navegar até a pasta onde está seu projeto, e vou dar um mvn dependency resolve. Vou pedir para ele resolver todas as dependências que ele tiver.

Ele vai fazer a mesma coisa que aquele reload, ele vai começar a escanear seu projeto, vai ver as dependências que você tem, que você pediu que você quer usar, mas você não baixou elas ainda, e vai baixar elas. Dessa maneira você consegue pedir para o Maven baixar todo o repositório, tudo que você precisar, aquele repositório de dependências dele.

A parte de build que ele trouxe para mim, ele trouxe uma série de coisas, vou apagar tudo isso, porque não vou fazer build nesse projeto. A gente não vai gerar um pacote. Não vou gerar um jar nesse projeto. Meu projeto é de testes, então não vou fazer build.

Nosso xml já está configurado com nossa dependência do Appium. O que ele criou para mim na hora que criei um projeto Maven? Ele criou a estrutura de passos padrão do Maven. Tenho meu source, minha main, com a pasta Java e a pasta do meu pacote com o nome com.alura.appium, e o meu app. Então meu app por enquanto só faz o Hello world.

Vamos tirar comentários que a gente não vai usar e esse Hello world vou pular uma linha e vamos começar a editar eles. Além disso, vem a parte de testes para mim. Tenho o Java, parte de testes e ele já vem um teste super simples, uma amostra de true igual a true, então ele é um teste que sempre vai funcionar, mas já tenho aqui um início de estrutura.

Essa é a estrutura inicial que ele trouxe e o que quero fazer agora é como vou trazer meu apk para dentro do meu emulador? Como vou comunicar com o Appium, já que já tenho a lib do Java client para comunicar com o emulador.

A primeira coisa que vou fazer é saber qual a apk que quero instalar. No caso, tenho um apk que baixei aqui, que vai ser o Alura esportes apk, ele foi gerado a partir de um projeto que eu tinha aqui, vou deixar o link para você baixar esse apk exatamente que estou usando no exercício logo abaixo desse vídeo, e o que quero fazer é trazer esse apk para dentro do meu projeto, porque é ele que vou usar.

Vou vir aqui na pasta main. Vou criar um novo, botão direito, novo diretório e vou criar um novo diretório padrão no Maven, que é o diretório de resources, que é tudo que não for código e que eu for usar no meu código, fontes, imagens, no caso do nosso apk, e vou deixar nessa pasta de resources.

Ele já até traz aqui uma sugestão por causa do padrão do Maven, vou clicar aqui e aceitar essa sugestão dele. Criei a pasta de resources e vou clicar e arrastar nesse caso o meu apk para dentro dessa pasta de resources.

Vou pedir para ele refatorar e agora sim meu apk está dentro na minha pasta de resources. Eu já sei qual o apk que vou usar, ele já está aqui dentro. Como faço então para a Java client que está aqui, meu Appium client do meu Java falar com meu servidor, que está rodando no meu terminal, para ele instalar esse apk com meu emulador.

O que eu vou fazer aqui é eu vou no meu app e vou mudar, ao invés de dar só o Hello world, o que vou precisar fazer é começar a instanciar as classes do Appium, e o Appium traz para a gente, tem uma estrutura muito parecida com o Celenium, ele usa o Celenium por trás do pano, e o Celenium se você já viu o curso que a gente tem, assim como Appium, usa uma série de drivers para criar, para fazer a comunicação entre nosso projeto e o emulador, através daquele servidor que a gente criou.

Então, vou precisar de um driver aqui, fazer a configuração do driver do Appium para que esse driver se comunique com meu emulador. O driver que a gente usa para fazer isso é nosso Appium driver. Vou precisar aqui de um Appium driver, ele já até dá a sugestão para mim. Esse Appium driver vai ser um novo Appium driver, vou chamar de driver, ele vai ser um novo Appium driver.

Ele é um genérico, então tenho que colocar aqui generics, apesar de que não vou colocar nada dentro desse generics, porque quem vai falar para mim qual o tipo de Appium driver que vou usar, se vai ser um de Android, um de desktop e assim por diante, vai ser uma série de configurações a mais que a gente coloca um parâmetro aqui como segundo parâmetro.

A primeira coisa que ele pede aqui é minha url de conexão, porque nosso cliente vai ter que se comunicar com nosso servidor. Preciso falar com ele qual o endereço ip e a porta que tem que se conectar com esse servidor.

No nosso caso, esse servidor, que é um servidor em rest está no local host, então 0.0.0.0:4723. Preciso passar essa regra de conexão para o meu driver. Então vou criar essa variável, vou precisar de uma url. Vamos usar o Java para isso, então url alt enter para ele importar para mim, url conexão, vai ser igual a uma nova url, e essa url vou precisar passar para ele qual o caminho.

Então, http://, vou colocar o protocolo que ele está usando. O local host a gente põe como 127.0.0.1, isso é local host. Se eu puser 0.0.0 aqui ele não vai entender, e dois pontos a porta. A porta que eu quero que ele se conecte é a 4723. Peguei essa do finalzinho.

Se no seu caso tiver um erro de conexão pode ser que a porta venha diferente, mas por padrão ele vai vir na 4723. Só que isso aqui é só o endereço do servidor. É só o começo da url. Mas eu preciso passar a rota que ele vai se conectar.

A rota que ele vai se conectar é a wd/hub. Essa é a rota que ele vai se conectar para passar informações lá para o nosso emulador, para o nosso servidor, e aí sim nosso servidor conectar com nosso emulador.

Essa url de conexão já está aqui, vou dar um ponto e vírgula no final. A outra coisa que a gente precisa colocar aqui são as configurações a mais. Então, vou precisar de algumas configurações, que vou chamar aqui. Essas configurações são o que eu quero que esse Appium driver tenha de capacidade.

Eu chamei de configurações aqui, mas o Appium na documentação dele chama de desired capabilities. As minhas capacidades desejadas. Eu chamei de configurações. É um termo um pouco mais genérico.

Isso é um objeto porque posso passar uma série de configurações para o meu Appium e a gente vai começar a colocar elas. Vou pular algumas linhas, fechar essa parte de projeto que não estou usando agora, e minha desired capabilities vou colocar primeiro qual o apk que quero que ele use.

Para o meu apk vou colocar um configurações set capabilities, quero configurar uma nova capability. Quero uma capability para um dispositivo mobile, então vou colocar uma mobile capability type, porque tenho várias capabilties para mobile.

Tenho o tipo de capability que quero usar e quero no caso o nosso app, porque quero o caminho que ele vai usar para esse app. Vou usar um app. E aí vou ter uma variável que vou criar aqui e que vai ser meu apk. E aí esse apk, como a gente está trabalhando com arquivos do Java, ele vai ser um novo tipo de arquivo. Ele vai ser uma variável do tipo arquivo. Então, arquivo em inglês é file. File apk vai ser igual a new file do Java io.

Para esse file funcionar, preciso passar o caminho, o path name do nosso apk. Vou vir aqui no meu apk, botão direito, vou dar um copy, vou copiar o caminho absoluto dele. Copiar caminho absoluto, vou trazer para dentro das minhas aspas e vou colar.

Quando faço isso o próprio IntelliJ já coloca as barras aqui de escape para ele funcionar certinho, mas se você não fizer isso automático você pode colocar o escape para ele vir no caminho certinho.

Temos todo o caminho para o meu apk e aí crio um novo arquivo que chamei de apk. E aí criei um novo arquivo que chamei de apk. E aí, para minha configuração, para o meu set capability do meu app preciso pegar esse caminho absoluto, então preciso pegar o nosso apk que é absolute path, porque a gente vai precisar do caminho desse apk, e não o arquivo em si.

Assim o nosso cliente aqui, nosso projeto vai mandar o caminho para o meu servidor, o servidor vai pegar esse caminho, vai buscar o arquivo de fato, vai conseguir trazer esse arquivo e aí jogar isso para o emulador. Já tenho qual o apk que estou usando.

Mas preciso falar, passei um arquivo para ele, instala esse arquivo aqui no seu emulador, mas qual o emulador que você vai pegar, qual plataforma que a gente está desenvolvendo? Nas minhas configurações vou ter que também colocar o set capabiltiy. De novo para um mobile capability type, porque estou trabalhando com dispositivo mobile, e quero colocar o meu platform name, porque quero falar “você vai usar essa plataforma aqui”.

No caso, a gente vai usar o Android. Eu vou vir aqui, como segundo parâmetro, um mobile platform Android. Você pode ver que a gente tem o Firefox os, iOS, tvds, Windows, e assim por diante. Mas no caso aqui vou usar o Android. Já vou deixar como Android.

Aqui já tenho o meu apk que estou usando, tenho a plataforma que vou usar, mas preciso falar qual o automation type, ou seja, o driver de automação que vou usar, porque se eu voltar no meu Appium, na parte de drivers, a gente pode ver que tenho vários tipos de drivers possíveis. Para o Android, por exemplo, posso usar o expresso, o UiAutomator 2, o UiAutomator na primeira versão, para o iOS tenho mais uma série de outros drivers, tenho de Windows, tenho de Mac.

Tenho que falar qual desses aqui vou usar. No caso, vou pedir para ele usar UiAutomator 2. Para isso, vou ter uma nova configuração, set capability, e aí de novo mobile capability type, e aqui vou colocar meu automation name.

Nome da automação que vou usar e aqui vou colocar UiAutomator 2. Esse é nosso automation type que a gente vai usar. Nosso automation name. É esse driver que ele vai usar por trás dos panos para fazer todos os testes.

Minha url está falando que preciso de alguma coisa, porque ela vai lançar uma exceção se tiver algo formado. Então, preciso adicionar essa exceção na assinatura do meu método. Vamos tratar essa exceção se acontecer.

Dessa maneira já tenho meu apk aqui em cima, tenho as configurações do meu emulador, quero configurar meu projeto, tenho minha url de conexão, e criei um driver. Se eu vier e pedir para ele rodar isso aqui, vou clicar na lateral para ele rodar, run main app, ele vai começar a fazer o build desse projeto e vai tentar conectar com nosso emulador.

O build compilou, e se a gente for lá ele está tentando conectar no meu emulador. Meu emulador está conversando com nosso servidor e está instalando nosso apk no emulador. Uma série de coisas que eles estão conversando e trouxe nosso apk. Dessa maneira meu projeto já está configurado para conversar com meu servidor, o meu servidor já fala com nosso emulador e já instalou o apk que a gente quer usar. É esse apk que a gente vai usar durante o curso.

Sobre o curso Appium: compreenda e aplique testes de interface

O curso Appium: compreenda e aplique testes de interface possui 151 minutos de vídeos, em um total de 37 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:

• Preparando o ambiente
• Arquitetura
• Ferramentas
• Padrões de projeto
• Tipos de testes