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á. # Frameworks de teste e testes integrados no AWS Device Farm Esta seção descreve o suporte do Device Farm para estruturas de teste e tipos de teste incorporados. O Device Farm executa testes automatizados fazendo com que você faça o upload do seu aplicativo e dos testes em um bucket seguro do Amazon S3 gerenciado pelo serviço. Depois de carregado, ele ativa a infraestrutura subjacente, incluindo [hosts de teste](custom-test-environments-hosts.md) gerenciados por serviços, e executa os testes paralelamente em vários dispositivos. Os resultados do teste são armazenados em um bucket S3 gerenciado pelo serviço. Essa arquitetura é chamada de **execução do lado do serviço e é uma maneira rápida e eficiente de executar testes em hosts que estão fisicamente próximos ao dispositivo, sem precisar gerenciar você mesmo** a infraestrutura do host de teste. Essa abordagem se adapta bem para testes em vários dispositivos de forma independente, bem como para testes a partir do contexto de um CI/CD pipeline. Para acessar mais informações sobre testes de execução do Device Farm, consulte [Ambientes de teste no AWS Device Farm](test-environments.md). **nota** Para testadores do Appium, talvez você prefira executar seus testes do Appium em seu ambiente local. Com uma [sessão de acesso remoto](remote-access.md), você pode executar testes Appium **do lado do cliente**. Para obter mais informações, consulte o teste [Appium do lado do cliente](appium-endpoint.md). ## Testar estruturas O Device Farm é compatível com essas estruturas de teste de automação móvel: ### Estruturas de teste de aplicações Android + [Testes automáticos de appiumIntegrar a testes do Appium](test-types-appium.md) + [Instrumentação](test-types-android-instrumentation.md) ### Estruturas de teste de aplicações iOS + [Testes automáticos de appiumIntegrar a testes do Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest UI](test-types-ios-xctest-ui.md) ### Estruturas de teste de aplicações web Aplicativos Web são compatíveis usando o Appium. Para obter mais informações sobre como trazer seus testes para o Appium, consulte [Execute testes Appium automaticamente no Device FarmIntegrar testes do Appium com o Device Farm](test-types-appium.md). ### Estruturas em um ambiente de teste personalizado O Device Farm não fornece suporte para personalizar o ambiente de teste da XCTest estrutura. Para obter mais informações, consulte [Ambiente de teste personalizado no AWS Device Farm.](custom-test-environments.md). ### Suporte da versão do Appium Para testes executados em um ambiente personalizado, o Device Farm é compatível com o Appium versão 1. Para obter mais informações, consulte [Ambientes de teste no AWS Device Farm](test-environments.md). ## Tipos de teste integrado Com os testes integrados, você pode testar a aplicação em vários dispositivos sem precisar escrever e manter scripts de automação de testes. O Device Farm oferece um tipo de teste integrado: + [Integrado: Fuzz (Android e iOS)](test-types-built-in-fuzz.md) # 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. # Testes do Android no AWS Device Farm O Device Farm oferece suporte a vários tipos de testes de automação para dispositivos Android e dois testes integrados. Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). ## Estruturas de teste de aplicações Android Os testes personalizados estão disponíveis para dispositivos Android. + [Testes automáticos de appiumIntegrar a testes do Appium](test-types-appium.md) + [Instrumentação](test-types-android-instrumentation.md) ## Tipos de teste incorporados para Android Há um tipo de teste integrado disponível para dispositivos Android. + [Integrado: Fuzz (Android e iOS)](test-types-built-in-fuzz.md) # Instrumentação para Android e AWS Device Farm O Device Farm fornece suporte para Instrumentação (JUnit, Espresso, Robotium ou qualquer teste baseado em instrumentação) para Android. O Device Farm também fornece uma aplicação Android de amostra e links para testes funcionais em três estruturas de automação do Android, incluindo Instrumentation (Espresso). O [aplicativo de amostra Device Farm para Android](https://github.com/awslabs/aws-device-farm-sample-app-for-android) está disponível para download em GitHub. Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). **Topics** + [ ## O que é instrumentação? ](#test-types-android-instrumentation-what-is) + [ ## Considerações sobre testes de instrumentação do Android ](#test-types-android-instrumentation-settings) + [ ## Análise de teste em modo padrão ](#test-types-android-standard-mode-test-parse) + [ # Integrar a instrumentação do Android ao Device Farm ](test-types-android-instrumentation-integrate.md) ## O que é instrumentação? A instrumentação do Android possibilita chamar métodos de retorno de chamada no código de teste, de maneira que você possa percorrer o ciclo de vida de um componente passo a passo, como se estivesse depurando o componente. Para obter mais informações, consulte [Instrumented tests](https://developer.android.com/studio/test/test-in-android-studio#test_types_and_locations) na seção *Test types and locations* da documentação de *Android Developer Tools*. ## Considerações sobre testes de instrumentação do Android Ao usar a instrumentação do Android, pense nas recomendações e observações a seguir. **Conferir a compatibilidade do sistema operacional Android** Confira a [documentação do Android](https://developer.android.com/jetpack/androidx/releases/test#orchestrator-1.5.0) para garantir que a instrumentação seja compatível com sua versão do sistema operacional Android. **Executar pela linha de comando** Para executar testes de instrumentação na linha de comando, siga a [documentação do Android](https://developer.android.com/training/testing/instrumented-tests/androidx-test-libraries/runner#enable-command). **Animações de sistema** De acordo com a [Android documentation for Espresso testing](https://developer.android.com/training/testing/espresso), recomenda-se que as animações do sistema sejam desativadas ao testar em dispositivos reais. O Device Farm desativa automaticamente as configurações **Window Animation Scale**, **Transition Animation Scale** e **Animator Duration Scale** quando executado com o executor de testes de instrumentação [JUnitandroid.support.test.runner.Android](http://developer.android.com/reference/android/support/test/runner/AndroidJUnitRunner.html) Runner. **Gravadores de teste** O Device Farm oferece suporte a estruturas, como Robotium, que têm record-and-playback ferramentas de script. ## Análise de teste em modo padrão No modo padrão de uma execução, o Device Farm analisa sua suíte de testes e identifica as classes e métodos de teste exclusivos que ela executará. Isso é feito por meio de uma ferramenta chamada [Dex Test Parser](https://github.com/linkedin/dex-test-parser). Quando recebe um arquivo.apk de instrumentação do Android como entrada, o analisador retorna os nomes dos métodos totalmente qualificados dos testes que correspondem às convenções JUnit 3 e 4. JUnit Para testar isso em um ambiente local: 1. Faça download do binário [https://github.com/linkedin/dex-test-parser](https://github.com/linkedin/dex-test-parser). 1. Execute o comando a seguir para obter a lista de métodos de teste que serão executados no Device Farm: ``` java -jar parser.jar path/to/apk path/for/output ``` # Integrar a instrumentação do Android ao Device Farm **nota** Use as instruções a seguir para integrar os testes de instrumentação do Android ao AWS Device Farm. Para acessar mais informações sobre o uso de testes de instrumentação no Device Farm, consulte [Instrumentação para Android e AWS Device Farm](test-types-android-instrumentation.md). ## Upload dos testes de instrumentação para Android Use 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. Na lista de projetos, escolha o projeto para o qual deseja carregar seus testes. **dica** Você pode usar a barra de pesquisa para filtrar a lista de projetos por nome. Para criar um projeto, siga as instruções em [Criar um projeto no AWS Device Farm](how-to-create-project.md). 1. Selecione **Criar execução**. 1. Em **Selecionar aplicação**, na seção **Opções de seleção de aplicação**, escolha **Fazer upload da própria aplicação**. 1. Procure e escolha o arquivo de seu aplicativo Android. O arquivo deve ser .apk. 1. Na página **Configurar teste**, na seção **Selecionar framework de teste**, escolha **Instrumentação** e, depois, selecione **Escolher arquivo**. 1. Procure e escolha o arquivo .apk que contém os testes. 1. Conclua as instruções restantes para selecionar dispositivos e iniciar a execução. ## (Opcional) Fazer captura de telas em testes de instrumentação do Android Você pode fazer capturas de tela como parte dos testes de instrumentação para Android. Para fazer a captura de telas, chame um dos seguintes métodos: + Para Robotium, chame o método `takeScreenShot` (por exemplo, `solo.takeScreenShot();`). + Para Spoon, chame o método `screenshot`; por exemplo: ``` Spoon.screenshot(activity, "initial_state"); /* Normal test code... */ Spoon.screenshot(activity, "after_login"); ``` Durante uma execução de teste, o Device Farm obtém capturas de tela dos seguintes locais nos dispositivos, se existirem, e as adiciona aos relatórios de teste: + `/sdcard/robotium-screenshots` + `/sdcard/test-screenshots` + `/sdcard/Download/spoon-screenshots/test-class-name/test-method-name` + `/data/data/application-package-name/app_spoon-screenshots/test-class-name/test-method-name` # Testes de iOS no AWS Device Farm O Device Farm oferece suporte a vários tipos de testes de automação para dispositivos iOS e um teste incorporado. Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). ## Estruturas de teste de aplicações iOS Os testes a seguir estão disponíveis para dispositivos iOS. + [Testes automáticos de appiumIntegrar a testes do Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest UI](test-types-ios-xctest-ui.md) ## Tipos de teste integrados para iOS No momento, existe apenas um tipo de teste integrado disponível para dispositivos iOS. + [Integrado: Fuzz (Android e iOS)](test-types-built-in-fuzz.md) # Integrando o Device Farm com XCTest o iOS Com o Device Farm, você pode usar a XCTest estrutura para testar seu aplicativo em dispositivos reais. Para obter mais informações sobre XCTest, consulte [Noções básicas](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/03-testing_basics.html) sobre *testes com o Xcode*. Para executar um teste, você cria os pacotes para a execução do teste e faz o upload desses pacotes para o Device Farm. Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). **Topics** + [ ## Crie os pacotes para sua XCTest corrida ](#test-types-ios-xctest-create-packages) + [ ## Faça o upload dos pacotes para sua XCTest execução no Device Farm ](#test-types-ios-xctest-upload) ## Crie os pacotes para sua XCTest corrida Para testar seu aplicativo usando a XCTest estrutura, o Device Farm exige o seguinte: + Que seu pacote de aplicativos seja um arquivo `.ipa`. + Seu XCTest pacote como um `.zip` arquivo. Que você crie esses pacotes usando a saída da compilação gerada pelo Xcode. Conclua as etapas a seguir para criar os pacotes para que você possa carregá-los no Device Farm. **Para gerar a saída da compilação para seu aplicativo** 1. Abra o projeto do aplicativo em Xcode. 1. No menu suspenso do esquema na barra de ferramentas do Xcode, escolha **Dispositivo iOS genérico** como destino. 1. No menu **Produto**, selecione **Compilar para** e depois selecione **Teste**. **Para criar o pacote de aplicativos** 1. No navegador de projeto no Xcode, em **Produtos**, abra o menu contextual do arquivo chamado `app-project-name.app`. Escolha **Mostrar no Finder**. O Finder abrirá uma pasta chamada `Debug-iphoneos`, que contém a saída gerada pelo Xcode para sua compilação de teste. Essa pasta inclui o arquivo `.app` . 1. No Finder, crie uma nova pasta e nomeie-a `Payload`. 1. Copie o arquivo `app-project-name.app` e cole-o na pasta `Payload`. 1. Abra o menu contextual da pasta `Payload` e escolha **Compactar "Payload"**. Um arquivo chamado `Payload.zip` será criado. 1. Altere o nome do arquivo e a extensão de `Payload.zip` para `app-project-name.ipa`. Em uma etapa posterior, você fornecerá esse arquivo ao Device Farm. Para facilitar a localização do arquivo, você pode movê-lo para outro local, como sua área de trabalho. 1. Opcionalmente, você pode excluir a pasta `Payload` e o arquivo `.app` que está nela. **Para criar o XCTest pacote** 1. No Finder, no diretório `Debug-iphoneos`, abra o menu contextual do arquivo `app-project-name.app`. Escolha **Mostrar conteúdo do pacote**. 1. No conteúdo do pacote, abra a pasta `Plugins`. Essa pasta contém um arquivo chamado `app-project-name.xctest`. 1. Abra o menu contextual desse arquivo e escolha **Compactar "`app-project-name.xctest`"**. Um arquivo chamado `app-project-name.xctest.zip` será criado. Em uma etapa posterior, você fornecerá esse arquivo ao Device Farm. Para facilitar a localização do arquivo, você pode movê-lo para outro local, como sua área de trabalho. ## Faça o upload dos pacotes para sua XCTest execução no Device Farm Use o console do Device Farm para carregar os pacotes do seu teste. 1. Faça login no console do Device Farm em [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm) 1. Se você ainda não tiver um projeto, crie um. Para obter as etapas para criar um projeto, consulte [Criar um projeto no AWS Device Farm](how-to-create-project.md). Caso contrário, no painel de navegação do Device Farm, escolha **Teste para dispositivos móveis** e escolha **Projetos**. 1. Escolha o projeto que você deseja usar para executar o teste. 1. Escolha **Criar execução**. 1. Em **Configurações de execução**, na seção **Tipo de execução**, escolha **Aplicação iOS**. 1. Em **Selecionar aplicação**, na seção **Opções de seleção de aplicação**, escolha **Fazer upload da própria aplicação**. Depois, selecione **Escolher arquivo** em **Fazer upload de aplicação**. 1. Procure o arquivo `.ipa` para seu aplicativo e faça o upload dele. **nota** Seu pacote `.ipa` deve ser compilado para testes. 1. Em **Configurar teste**, na seção **Selecionar estrutura de teste**, escolha **XCTest**. Depois, selecione **Escolher arquivo** em **Fazer upload de aplicação**. 1. Navegue até o `.zip` arquivo que contém o XCTest pacote do seu aplicativo e faça o upload dele. 1. Conclua as etapas restantes no processo de criação do projeto. Selecione os dispositivos que deseja testar e especifique o estado do dispositivo. 1. Escolha **Criar execução**. O Device Farm executa o teste e mostra os resultados no console. # Integrando a XCTest interface do usuário para iOS com o Device Farm O Device Farm fornece suporte para a estrutura de teste de XCTest interface do usuário. [Especificamente, o Device Farm suporta testes de XCTest interface de usuário escritos em Objective-C e Swift.](https://developer.apple.com/swift/) A estrutura de XCTest interface do usuário permite o teste de interface do usuário no desenvolvimento para iOS, construído sobre XCTest o. Para obter mais informações, consulte [Teste da interface do usuário](https://developer.apple.com/library/prerelease/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/09-ui_testing.html#//apple_ref/doc/uid/TP40014132-CH13-SW1) na biblioteca de desenvolvedor do iOS. Para acessar informações gerais sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). Use as instruções a seguir para integrar o Device Farm à estrutura de teste de XCTest interface do usuário para iOS. **Topics** + [ ## Prepare seus testes de XCTest interface do iOS ](#test-types-ios-xctest-ui-prepare) + [ ## Opção 1: criar um pacote XCTest UI .ipa ](#how-to-use-create-XCTestUI-ipa-package) + [ ## Opção 2: criar um pacote XCTest UI .zip ](#how-to-use-create-XCTestUI-zip-package) + [ ## Carregue seus testes de XCTest interface do iOS ](#test-types-ios-xctest-ui-upload) ## Prepare seus testes de XCTest interface do iOS Você pode fazer upload de um arquivo `.ipa` ou `.zip` para seu pacote de testes XCTEST\$1UI. Arquivo `.ipa` é um arquivo de aplicação que contém a aplicação iOS Runner em formato de pacote. *Arquivos adicionais não podem ser incluídos no arquivo `.ipa`.* Se você fizer upload de um arquivo `.zip`, ele poderá conter diretamente a aplicação iOS Runner ou um arquivo `.ipa`. Você também poderá incluir outros arquivos no arquivo `.zip` se quiser usá-los durante os testes. Por exemplo, é possível incluir arquivos, como `.xctestrun`, `.xcworkspace` ou `.xcodeproj` em um arquivo `.zip` para executar planos de teste XCUI no farm de dispositivos. Instruções detalhadas sobre como executar planos de teste estão disponíveis no arquivo de especificação de teste padrão para o tipo de teste XCUI. ## Opção 1: criar um pacote XCTest UI .ipa O pacote *yourAppName*UITest-runner.app é produzido pelo Xcode quando você cria seu projeto para teste. Ele pode ser encontrado no diretório Products do projeto. Para criar um arquivo .ipa: 1. Crie um diretório denominado *Payload*. 1. Adicione o diretório da sua aplicação ao diretório da carga útil. 1. Arquive o diretório Carga útil em um arquivo `.zip` e mude a extensão do arquivo para `.ipa`. A estrutura de pastas a seguir mostra como um aplicativo de exemplo chamado *my-project-nameUITest-Runner.app* seria empacotado como um `.ipa` arquivo: ``` . └── my-project-nameUITest.ipa └── Payload (directory) └── my-project-nameUITest-Runner.app ``` ## Opção 2: criar um pacote XCTest UI .zip O Device Farm gera automaticamente um `.xctestrun` arquivo para você executar seu conjunto completo de testes de XCTest interface do usuário. Se quiser usar seu próprio arquivo `.xctestrun` no Device Farm, compacte seus arquivos `.xctestrun` e o diretório da aplicação em um arquivo `.zip`. Se você já tem um `.ipa` arquivo para seu pacote de teste, você pode incluí-lo aqui em vez de*\$1-Runner.app*. ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── SampleTestPlan_2.xctestrun ├── SampleTestPlan_1.xctestrun └── (any other files) ``` Se você quiser executar um plano de teste do Xcode para seus testes XCUI no Device Farm, você pode criar um zip contendo seu arquivo *my-project-nameUITest-runner.app *my-project-nameUITestou.ipa** e os arquivos de código-fonte do xcode necessários para executar o XCTEST\$1UI com planos de teste, incluindo um arquivo **ou**. `.xcworkspace` `.xcodeproj` Aqui está um exemplo de zip usando um arquivo `.xcodeproj`: ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── (any directory) └── SampleXcodeProject.xcodeproj ├── Testplan_1.xctestplan ├── Testplan_2.xctestplan └── (any other source code files created by xcode with .xcodeproj) ``` Aqui está um exemplo de zip usando um arquivo `.xcworkspace`: ``` . └──swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa └── (any directory) │ ├── SampleXcodeProject.xcodeproj │ ├── Testplan_1.xctestplan │ ├── Testplan_2.xctestplan | └── (any other source code files created by xcode with .xcodeproj) └── SampleWorkspace.xcworkspace └── contents.xcworkspacedata ``` **nota** Certifique-se de que você não tenha um diretório chamado “Payload” dentro do seu pacote XCTest UI .zip. ## Carregue seus testes de XCTest interface do iOS Use 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. Na lista de projetos, escolha o projeto para o qual deseja carregar seus testes. **dica** Você pode usar a barra de pesquisa para filtrar a lista de projetos por nome. Para criar um projeto, siga as instruções em [Criar um projeto no AWS Device Farm](how-to-create-project.md). 1. Escolha **Criar execução**. 1. Em **Configurações de execução**, na seção **Tipo de execução**, escolha **Aplicação iOS**. 1. Em **Selecionar aplicação**, na seção **Opções de seleção de aplicação**, escolha **Fazer upload da própria aplicação**. Depois, selecione **Escolher arquivo** em **Fazer upload de aplicação**. 1. Procure e escolha o arquivo de seu aplicativo iOS. O arquivo deve ser .ipa. **nota** Confirme se o arquivo .ipa foi desenvolvido para um dispositivo iOS e não para um simulador. 1. Em **Configurar teste**, na seção **Selecionar estrutura de teste**, escolha **XCTest UI**. Depois, selecione **Escolher arquivo** em **Fazer upload de aplicação**. 1. Procure e escolha o arquivo.ipa ou.zip que contém seu executor de teste de XCTest interface do iOS. 1. Conclua as etapas restantes no processo de criação do projeto. Você selecionará os dispositivos em que deseja testar e, opcionalmente, especificar uma configuração adicional. 1. Escolha **Criar execução**. O Device Farm executa o teste e mostra os resultados no console. # Testes de aplicações web no AWS Device Farm O Device Farm fornece testes com o Appium para aplicações Web. Para obter mais informações sobre como configurar testes do Appium no Device Farm, consulte [Execute testes Appium automaticamente no Device Farm](test-types-appium.md). Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). ## Regras para dispositivos de acesso limitado e ilimitado A medição refere-se à cobrança dos dispositivos. Por padrão, os dispositivos do Device Farm são medidos e você é cobrado por minuto depois que os minutos da avaliação gratuita são usados. Você também pode optar por comprar dispositivos de acesso ilimitado, que permite um número ilimitado de testes mediante o pagamento de uma taxa mensal fixa. Para obter mais informações sobre preços, consulte [Definição de preço do AWS Device Farm](https://aws.amazon.com/device-farm/). Se você optar por iniciar uma execução com um grupo de dispositivos que contém dispositivos iOS e Android, há regras para dispositivos de acesso limitado e ilimitado. Por exemplo, se você tiver cinco dispositivos Android de acesso ilimitado e cinco dispositivos iOS de acesso ilimitado, as execuções de testes web usarão os dispositivos de acesso ilimitado. Veja outro exemplo: suponhamos que você tenha cinco dispositivos Android de acesso ilimitado e 0 dispositivo iOS de acesso ilimitado. Se selecionar apenas dispositivos Android para a execução web, seus dispositivos de acesso ilimitado serão usados. Se selecionar dispositivos Android e iOS para a execução web, o método de cobrança será monitorado e seus dispositivos de acesso ilimitado não serão usados. # Testes integrados no AWS Device Farm O Device Farm oferece suporte a tipos de teste incorporados para dispositivos Android e iOS. Com os testes integrados, você pode testar a aplicação em vários dispositivos sem precisar escrever e manter scripts de automação de testes. Isso pode economizar tempo e esforço, principalmente quando você está começando a usar o Device Farm. O Device Farm oferece o seguinte tipo de teste integrado: + [Integrado: Fuzz (Android e iOS)](test-types-built-in-fuzz.md): o teste fuzz envia aleatoriamente eventos de interface de usuário aos dispositivos e, depois relata os resultados. Para acessar mais informações sobre testes e frameworks de testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). # Executar o teste fuzz incorporado do Device Farm (Android e iOS) O teste integrado fuzz do Device Farm envia aleatoriamente eventos de interface do usuário aos dispositivos e, depois, relata os resultados. Para acessar mais informações sobre testes no Device Farm, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md). **Como executar o teste fuzz incorporado** 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. Na lista de projetos, escolha o projeto em que você deseja executar o teste fuzz incorporado. **dica** Você pode usar a barra de pesquisa para filtrar a lista de projetos por nome. Para criar um projeto, siga as instruções em [Criar um projeto no AWS Device Farm](how-to-create-project.md). 1. Escolha **Criar execução**. 1. Em **Configurações de execução**, selecione o tipo de execução na seção **Tipo de execução**. Selecione **Aplicação Android** se você não tiver uma aplicação pronta para teste ou se estiver testando uma aplicação Android (.apk). Selecione **Aplicação iOS** se estiver testando uma aplicação iOS (.ipa). 1. Em **Selecionar aplicação**, escolha **Selecionar aplicação de exemplo fornecida pelo Device Farm** se você não tiver uma aplicação disponível para teste. Se você estiver trazendo sua própria aplicação, selecione **Fazer upload da própria aplicação** e escolha o arquivo da sua aplicação. 1. Em **Configurar teste**, na seção **Selecionar framework de teste**, escolha **Incorporado: fuzz**. 1. Se qualquer uma das configurações a seguir forem exibidas, você poderá aceitar os valores padrão ou especificar seu próprio: + **Contagem de eventos**: especifique um número entre 1 e 10.000, que representa o número de eventos de interface de usuário que o teste Fuzz deve executar. + **Restrição de eventos**: especifique um número entre 0 e 1.000, que representa o número de milissegundos que o teste de fuzz deve aguardar para realizar o próximo evento de interface de usuário. + **Propagação aleatória**: especifique um número para o teste de fuzz usar para randomizar eventos de interface de usuário. A especificação de um mesmo número de testes Fuzz subsequentes garante sequências de eventos idênticas. 1. Conclua as instruções restantes para selecionar dispositivos e iniciar a execução.