As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Execute testes Appium automaticamente no Device Farm **nota** Esta página aborda a execução de testes do Appium no ambiente de execução gerenciado do lado do **servidor** do Device Farm. [Para executar testes do Appium em seu ambiente local do **lado do cliente** durante uma sessão de acesso remoto, consulte Teste do Appium do lado do cliente.](appium-endpoint.md) Esta seção descreve como configurar, empacotar e carregar seus testes do Appium para execução no ambiente gerenciado do lado do servidor do Device Farm. O Appium é uma ferramenta de código aberto para automatizar aplicações Web nativas e móveis. Para obter mais informações sobre o Appium, consulte [Introdução ao Appium](http://appium.io/docs/en/latest/intro) no site do Appium. Para ver um aplicativo de amostra e links para testes em funcionamento, consulte [Device Farm Sample App para Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) e [Device Farm Sample App para iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) em GitHub. Para obter mais informações sobre testes no Device Farm e como funciona o lado do servidor, consulte. [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md) ## Selecionar uma versão do Appium **nota** O suporte para versões específicas do Appium, drivers ou programação SDKs dependerá do dispositivo e do host de teste selecionados para a execução do teste. Os hosts de teste do Device Farm vêm pré-instalados com o Appium para permitir uma configuração mais rápida dos testes para casos de uso mais simples. No entanto, o uso do arquivo de especificação de teste permite que você instale versões diferentes do Appium, se necessário. ### Cenário 1: versão pré-configurada do Appium O Device Farm vem pré-configurado com diferentes versões do servidor Appium com base no host de teste. O host vem com ferramentas que habilitam a versão pré-configurada com o driver padrão da plataforma do dispositivo (UiAutomator2 para Android e XCUITest iOS). ``` phases: install: commands: - export APPIUM_VERSION=2 - devicefarm-cli use appium $APPIUM_VERSION ``` Para ver uma lista de softwares compatíveis, consulte o tópico em[Software compatível em ambientes de teste personalizados](custom-test-environments-hosts-software.md). ### Cenário 2: versão personalizada do Appium Para selecionar uma versão personalizada do Appium, use o `npm` comando para instalá-la. O exemplo a seguir mostra como instalar a versão mais recente do Appium 2. ``` phases: install: commands: - export APPIUM_VERSION=2 - npm install -g appium@$APPIUM_VERSION ``` ### Cenário 3: Appium em hosts iOS antigos No[Host de teste iOS antigo](custom-test-environments-hosts-ios.md#legacy-ios-host), você pode escolher versões específicas do Appium com. `avm` Por exemplo, para usar o `avm` comando para definir a versão do servidor Appium como`2.1.2`, adicione esses comandos ao seu arquivo YAML de especificação de teste. ``` phases: install: commands: - export APPIUM_VERSION=2.1.2 - avm $APPIUM_VERSION ``` ## Seleção de uma WebDriverAgent versão para testes do iOS Para executar testes do Appium em dispositivos iOS, WebDriverAgent é necessário o uso de. Esse aplicativo deve estar conectado para ser instalado em dispositivos iOS. O Device Farm fornece versões pré-assinadas WebDriverAgent que estão disponíveis durante a execução do ambiente de teste personalizado. O trecho de código a seguir pode ser usado para selecionar uma WebDriverAgent versão no Device Farm dentro do seu arquivo de especificação de teste que seja compatível com a versão do seu driver de XCTest interface de usuário. ``` phases: pre_test: commands: - |- APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1); CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}") if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2) else LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1) echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2) fi; ``` [Para obter mais informações sobre o WebDriverAgent, consulte a documentação da Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) # Integrar testes do Appium com o Device Farm Use as instruções a seguir para integrar os testes do Appium ao AWS Device Farm. Para acessar mais informações sobre o uso de testes do Appium no Device Farm, consulte [Execute testes Appium automaticamente no Device FarmIntegrar testes do Appium com o Device Farm](test-types-appium.md). ## Configurar o pacote de testes do Appium Use as instruções a seguir para configurar o pacote de testes. ------ #### [ Java (JUnit) ] 1. Modifique `pom.xml` para definir o empacotamento em um arquivo JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifique `pom.xml` para usar `maven-jar-plugin` a fim de criar seus testes em um arquivo JAR. O plug-in a seguir cria seu código-fonte de teste (qualquer coisa no diretório `src/test`) em um arquivo JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifique `pom.xml` para usar `maven-dependency-plugin` a fim de criar dependências como arquivos JAR. O plug-in a seguir copia suas dependências no diretório `dependency-jars`: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Salve a montagem XML a seguir em `src/main/assembly/zip.xml`. O XML a seguir é uma definição de montagem que, quando configurada, instrui o Maven a criar um arquivo .zip que contém tudo o que está na raiz do diretório de saída da compilação e no diretório `dependency-jars`: ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifique `pom.xml` para usar `maven-assembly-plugin` a fim de empacotar testes e todas as dependências em um único arquivo .zip. O plug-in a seguir usa a montagem anterior para criar um arquivo .zip denominado `zip-with-dependencies` no diretório de saída da compilação toda vez que o comando **mvn package** for executado: ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **nota** Se receber uma mensagem de erro informando que a versão 1.3 não oferece suporte a anotações, adicione o seguinte ao `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Java (TestNG) ] 1. Modifique `pom.xml` para definir o empacotamento em um arquivo JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifique `pom.xml` para usar `maven-jar-plugin` a fim de criar seus testes em um arquivo JAR. O plug-in a seguir cria seu código-fonte de teste (qualquer coisa no diretório `src/test`) em um arquivo JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifique `pom.xml` para usar `maven-dependency-plugin` a fim de criar dependências como arquivos JAR. O plug-in a seguir copia suas dependências no diretório `dependency-jars`: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Salve a montagem XML a seguir em `src/main/assembly/zip.xml`. O XML a seguir é uma definição de montagem que, quando configurada, instrui o Maven a criar um arquivo .zip que contém tudo o que está na raiz do diretório de saída da compilação e no diretório `dependency-jars`: ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifique `pom.xml` para usar `maven-assembly-plugin` a fim de empacotar testes e todas as dependências em um único arquivo .zip. O plug-in a seguir usa a montagem anterior para criar um arquivo .zip denominado `zip-with-dependencies` no diretório de saída da compilação toda vez que o comando **mvn package** for executado: ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **nota** Se receber uma mensagem de erro informando que a versão 1.3 não oferece suporte a anotações, adicione o seguinte ao `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Node.JS ] Para empacotar seus testes do Appium Node.js e carregá-los no Device Farm, você deve instalar o seguinte em seu computador local: + [Gerenciador de versão do Node (nvm)](https://github.com/nvm-sh/nvm) Use essa ferramenta ao desenvolver e empacotar seus testes para que dependências desnecessárias não sejam incluídas no pacote de testes. + Node.js + npm-bundle (instalado globalmente) 1. Verifique se o nvm está presente ``` command -v nvm ``` Você verá `nvm` como resultado. Para obter mais informações, consulte [nvm on.](https://github.com/nvm-sh/nvm) GitHub 1. Execute este comando para instalar o Node.js: ``` nvm install node ``` É possível especificar uma determinada versão do Node.js: ``` nvm install 11.4.0 ``` 1. Verifique se a versão correta do Node está em uso: ``` node -v ``` 1. Instale **npm-bundle** globalmente: ``` npm install -g npm-bundle ``` ------ #### [ Python ] 1. É altamente recomendável configurar o [virtualenv do Python](https://pypi.python.org/pypi/virtualenv) para testes de desenvolvimento e empacotamento, para que dependências desnecessárias não sejam incluídas em seu pacote de aplicativos. ``` $ virtualenv workspace $ cd workspace $ source bin/activate ``` **dica** Não crie um virtualenv do Python com a opção `--system-site-packages`, porque ele herda pacotes do diretório global de pacotes de sites. Isso pode resultar na inclusão de dependências em seu ambiente virtual que não são necessárias aos seus testes. Você também deve verificar se os testes não usam dependências que dependem de bibliotecas nativas, pois essas bibliotecas nativas podem ou não estar presentes na instância em que esses testes são executados. 1. Instale o **py.test** em seu ambiente virtual. ``` $ pip install pytest ``` 1. Instale o cliente do Appium Python em seu ambiente virtual. ``` $ pip install Appium-Python-Client ``` 1. A menos que você especifique um caminho diferente no modo personalizado, o Device Farm espera que seus testes sejam armazenados em `tests/`. É possível usar `find` para mostrar todos os arquivos dentro de uma pasta: ``` $ find tests/ ``` Confirmar se esses arquivos contêm conjuntos de testes que você deseja executar no Device Farm ``` tests/ tests/my-first-tests.py tests/my-second-tests/py ``` 1. Execute esse comando na pasta workspace de seu ambiente virtual para exibir uma lista de seus testes sem executá-los. ``` $ py.test --collect-only tests/ ``` Confirme se a saída mostra os testes que você deseja executar no Device Farm. 1. Limpe todos os arquivos em cache dos testes ou da pasta: ``` $ find . -name '__pycache__' -type d -exec rm -r {} + $ find . -name '*.pyc' -exec rm -f {} + $ find . -name '*.pyo' -exec rm -f {} + $ find . -name '*~' -exec rm -f {} + ``` 1. Execute o comando a seguir no espaço de trabalho para gerar o arquivo requirements.txt: ``` $ pip freeze > requirements.txt ``` ------ #### [ Ruby ] Para empacotar seus testes Ruby do Appium e carregá-los no Device Farm, você deve instalar o seguinte em seu computador local: + [Gerenciador de versão do Ruby (RVM)](https://rvm.io/rvm/install) Use essa ferramenta de linha de comando ao desenvolver e empacotar seus testes para que dependências desnecessárias não sejam incluídas no pacote de testes. + Ruby + Bundler (esse gem normalmente é instalado com o Ruby.) 1. Instale as chaves obrigatórias, o RVM e o Ruby. Para obter instruções, consulte [Como instalar o RVM](https://rvm.io/rvm/install) no site do RVM. Depois que a instalação for concluída, atualize o terminal. Para isso, saia e faça login novamente. **nota** O RVM é carregado como uma função apenas para o shell bash. 1. Verifique se o **rvm** está instalado corretamente ``` command -v rvm ``` Você verá `rvm` como resultado. 1. Se você quiser instalar uma versão específica do Ruby, como*2.5.3*, execute o seguinte comando: ``` rvm install ruby 2.5.3 --autolibs=0 ``` Verifique se você está na versão solicitada do Ruby: ``` ruby -v ``` 1. Configure o empacotador para compilar pacotes para as plataformas de teste desejadas: ``` bundle config specific_platform true ``` 1. Atualize seu arquivo .lock para adicionar as plataformas necessárias para executar os testes. + Se estiver compilando testes para serem executados em dispositivos Android, execute este comando para configurar o Gemfile para usar as dependências do host de teste do Android: ``` bundle lock --add-platform x86_64-linux ``` + Se estiver compilando testes para serem executados em dispositivos iOS, execute este comando para configurar o Gemfile para usar as dependências do host de teste do iOS: ``` bundle lock --add-platform x86_64-darwin ``` 1. O gem **bundler** geralmente é instalado por padrão. Se não estiver, instale-o: ``` gem install bundler -v 2.3.26 ``` ------ ## Criar um arquivo de pacote de teste compactado **Atenção** No Device Farm, a estrutura de pastas dos arquivos em seu pacote de teste compactado é importante, e algumas ferramentas de arquivamento alterarão a estrutura do seu arquivo ZIP implicitamente. Recomendamos que você siga os utilitários da linha de comando especificados abaixo, em vez de usar os utilitários de arquivamento incorporados ao gerenciador de arquivos da área de trabalho local (como o Finder ou o Windows Explorer). Agora, empacote seus testes para o Device Farm. ------ #### [ Java (JUnit) ] Crie e empacote seus testes: ``` $ mvn clean package -DskipTests=true ``` O arquivo `zip-with-dependencies.zip` será criado como resultado. Esse é o seu pacote de testes. ------ #### [ Java (TestNG) ] Crie e empacote seus testes: ``` $ mvn clean package -DskipTests=true ``` O arquivo `zip-with-dependencies.zip` será criado como resultado. Esse é o seu pacote de testes. ------ #### [ Node.JS ] 1. Confira o projeto. Verifique se você está no diretório raiz do seu projeto. Você pode ver `package.json` no diretório raiz. 1. Execute este comando para instalar suas dependências locais. ``` npm install ``` Esse comando também cria uma pasta `node_modules` dentro do seu diretório atual. **nota** Então, você poderá executar seus testes localmente. 1. Execute este comando para empacotar os arquivos da pasta atual em um arquivo \$1.tgz. O arquivo recebe um nome por meio da propriedade `name` no arquivo `package.json`. ``` npm-bundle ``` Esse arquivo tarball (.tgz) contém todos os seus códigos e dependências. 1. Execute este comando para empacotar o tarball (arquivo \$1.tgz) gerado na etapa anterior em um único arquivo compactado: ``` zip -r MyTests.zip *.tgz ``` Esse é o arquivo `MyTests.zip` que você carrega no Device Farm no procedimento a seguir. ------ #### [ Python ] Python 2 Gere um arquivamento dos pacotes do Python necessários (chamados de "wheelhouse") usando pip: ``` $ pip wheel --wheel-dir wheelhouse -r requirements.txt ``` Empacote os requisitos de pip, wheelhouse e testes em um arquivamento zip para o Device Farm: ``` $ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt ``` Python 3 Empacote os requisitos de pip e testes em um arquivo zip: ``` $ zip -r test_bundle.zip tests/ requirements.txt ``` ------ #### [ Ruby ] 1. Execute este comando para criar um ambiente virtual do Ruby: ``` # myGemset is the name of your virtual Ruby environment rvm gemset create myGemset ``` 1. Execute este comando para usar o ambiente que você acabou de criar: ``` rvm gemset use myGemset ``` 1. Confira o código-fonte. Verifique se você está no diretório raiz do seu projeto. Você pode ver `Gemfile` no diretório raiz. 1. Execute este comando para instalar suas dependências locais e todos os gems do `Gemfile`: ``` bundle install ``` **nota** Então, você poderá executar seus testes localmente. Use este comando para executar um teste localmente: ``` bundle exec $test_command ``` 1. Empacote os gems na pasta `vendor/cache`. ``` # This will copy all the .gem files needed to run your tests into the vendor/cache directory bundle package --all-platforms ``` 1. Execute o comando a seguir para empacotar seu código-fonte, junto com todas as suas dependências, em um único arquivo compactado: ``` zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files) ``` Esse é o arquivo `MyTests.zip` que você carrega no Device Farm no procedimento a seguir. ------ ## Fazer upload do pacote de testes no Device Farm Você pode usar o console do Device Farm para carregar seus testes. 1. Faça login no console do Device Farm em [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm) 1. No painel de navegação do Device Farm, escolha **Teste para dispositivos móveis** e, em seguida, **Projetos**. 1. Se você for um novo usuário, escolha **Novo projeto**, insira um nome para o projeto e escolha **Enviar**. Se você já tiver um projeto, poderá selecioná-lo para carregar seus testes nele. 1. Abra o projeto e escolha **Criar execução**. 1. Em **Configurações de execução**, dê ao teste um nome apropriado. Ele pode conter qualquer combinação de espaços ou pontuação. 1. Para testes nativos para Android e iOS Em **Configurações de execução**, escolha **Aplicação Android** se estiver testando uma aplicação Android (.apk), ou **Aplicação iOS** se estiver testando uma aplicação iOS (.ipa). Depois, em **Selecionar aplicação**, selecione **Fazer upload de sua aplicação** para fazer upload do pacote distribuível da aplicação. O arquivo deve ser um `.apk` para Android ou um `.ipa` para iOS. Aplicativos para iOS devem ser criados para dispositivos reais, não para o Simulator. Para testes de aplicativos Web para dispositivos móveis Em **Configurações de execução**, escolha **Aplicativo web**. 1. Em **Configurar teste**, na seção **Selecionar framework de teste**, escolha a estrutura Appium com a qual você testa e, depois, **faça upload de seu próprio pacote de teste**. 1. Procure e escolha o arquivo .zip que contém os testes. O arquivo .zip deve seguir o formato descrito em [Configurar o pacote de testes do Appium](#test-types-appium-prepare). 1. Siga as instruções para selecionar os dispositivos e iniciar a execução. Para obter mais informações, consulte [Criar uma execução de teste no Device Farm](how-to-create-test-run.md). **nota** O Device Farm não modifica os testes do Appium. ## Fazer capturas de tela de seus testes (opcional) Você pode fazer capturas de tela como parte dos testes. O Device Farm define a propriedade `DEVICEFARM_SCREENSHOT_PATH` para um caminho totalmente qualificado no sistema de arquivos local em que o Device Farm espera que as capturas de tela do Appium sejam salvas. O diretório específico de teste no qual as capturas de tela são armazenadas é definido no runtime. As capturas de tela são inseridas automaticamente nos relatórios do Device Farm. Para visualizar as capturas de tela, no console do Device Farm, selecione a seção **Capturas de tela**. Para obter mais informações sobre como fazer capturas de tela em testes do Appium, consulte [Fazer captura de tela](http://appium.io/docs/en/commands/session/screenshot/) na documentação da API do Appium.