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á.
# Execuções de teste no AWS Device Farm
Uma execução no Device Farm representa uma compilação específica da aplicação, com um conjunto específico de testes, a ser executada em um conjunto específico de dispositivos. Uma execução produz um relatório que contém informações sobre os resultados da execução. A execução contém um ou mais trabalhos. Para obter mais informações, consulte [Execuções](test-runs.md).
Você pode usar o console do AWS Device Farm, AWS Command Line Interface (AWS CLI) ou a API do AWS Device Farm para trabalhar com execuções de teste.
**Topics**
+ [Criar uma execução de teste no Device Farm](how-to-create-test-run.md)
+ [Definir o tempo limite para execuções de teste no AWS Device Farm](how-to-set-default-timeout-for-test-runs.md)
+ [Simular conexões e condições de rede para suas execuções do AWS Device Farm](how-to-simulate-network-connections-and-conditions.md)
+ [Interromper uma execução no AWS Device Farm](how-to-stop-test-runs.md)
+ [Visualizar uma lista de execuções no AWS Device Farm](how-to-view-runs-list.md)
+ [Criar um grupo de dispositivos no AWS Device Farm](how-to-create-device-pool.md)
+ [Analisar os resultados dos testes no AWS Device Farm](analyzing-results.md)
# Criar uma execução de teste no Device Farm
Você pode usar o console Device Farm ou AWS CLI a API Device Farm para criar uma execução de teste. Você também pode usar um plug-in compatível, como os plug-ins Jenkins ou Gradle para o Device Farm. Para obter mais informações sobre plug-ins, consulte [Ferramentas e plug-ins](aws-device-farm-tools-plugins.md). Para obter informações sobre execuções, consulte [Execuções](test-runs.md).
**Topics**
+ [Pré-requisitos](#how-to-create-test-run-prerequisites)
+ [Criar uma execução de teste (console)](#how-to-create-test-run-console)
+ [Criar uma execução de teste (AWS CLI)](#how-to-create-test-run-cli)
+ [Criar uma execução de teste (API)](#how-to-create-test-run-api)
+ [Próximas etapas](#how-to-create-test-run-console-next-steps)
## Pré-requisitos
Você deve ter um projeto no Device Farm. Siga as instruções em [Criar um projeto no AWS Device Farm](how-to-create-project.md) e retorne para esta página.
## Criar uma execução de teste (console)
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, escolha **Teste para dispositivos móveis** e **Projetos**.
1. Se já tiver um projeto, você poderá fazer upload dos testes para ele. Caso contrário, selecione **Novo projeto**, insira um **Nome do projeto** e escolha **Criar**.
1. Abra o projeto e escolha **Criar execução**.
1. (Opcional) Em **Configurações de execução**, na seção **Nome da execução**, insira um nome para a execução. Se nenhum nome for fornecido, o console do Device Farm chamará sua execução de “Minha execução do Device Farm” por padrão.
1. (Opcional) Em **Configurações de execução**, na seção **Tempo limite do trabalho**, você pode especificar o tempo limite de execução para sua execução de teste. Se você estiver usando um número ilimitado de slots de testes, confirme se **Não medido** está selecionado em **Método de cobrança**.
1. Em **Configurações de execução**, na seção **Tipo de execução**, selecione seu 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). Selecione **Aplicativo web** se quiser testar aplicativos web.
1. Em **Selecionar aplicação**, na seção **Opções de seleção de aplicações**, 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. Se você estiver fazendo upload de um aplicativo iOS, certifique-se de escolher **iOS device (Dispositivo iOS)**, e não um simulador.
1. Em **Configurar teste**, escolha um dos frameworks de teste disponíveis.
**nota**
Se não tiver testes disponíveis, escolha **Integrado: fuzz** para executar um pacote integrado padrão de testes. Se você escolher **Integrado: fuzz** e as caixas **Contagem de eventos**, **Limite de eventos** e **Propagação aleatória** forem exibidas, poderá alterar ou manter os valores.
Para obter mais informações sobre pacotes de testes, consulte [Frameworks de teste e testes integrados no AWS Device Farm](test-types.md).
1. Se você não escolheu **Integrado: Fuzz**, selecione **Escolher arquivo** em **Selecionar pacote de testes**. Procure e escolha o arquivo que contém os testes.
1. Para seu ambiente de teste, escolha **Executar teste em nosso ambiente padrão** ou **Executar teste em um ambiente personalizado**. Para obter mais informações, consulte [Ambientes de teste no AWS Device Farm](test-environments.md).
1. Se você estiver usando um ambiente de teste personalizado, poderá fazer o seguinte:
+ Se você quiser editar a especificação de teste padrão em um ambiente de teste personalizado, escolha **Editar** para atualizar a especificação YAML padrão.
+ Se você fizer alterações na especificação de teste, escolha **Salvar como novo** para atualizar.
+ Você pode configurar variáveis de ambiente. As variáveis fornecidas aqui terão precedência sobre qualquer uma que possa ser configurada no projeto principal.
1. Em **Selecionar dispositivos**, siga um destes procedimentos:
+ Para escolher um pool de dispositivos incorporado para executar os testes, em **Grupo de dispositivos**, escolha **Principais dispositivos**.
+ Para criar o próprio grupo de dispositivos para executar os testes, siga as instruções em [Criar um grupo de dispositivos](how-to-create-device-pool.md) e retorne a esta página.
+ Se você tiver criado o próprio grupo de dispositivos anteriormente, em **Grupo de dispositivos**, escolha o grupo de dispositivos.
+ Escolha **Selecionar dispositivos manualmente** e selecione os dispositivos nos quais você deseja executar os testes. Essa configuração não será salva.
Para obter mais informações, consulte [Suporte de dispositivos no AWS Device FarmDispositivos](devices.md).
1. (Opcional) Para adicionar configurações adicionais, abra o menu suspenso **Configuração adicional**. Nesta seção, é possível realizar qualquer um destes procedimentos:
+ Para fornecer um ARN da função de execução ou substituir um configurado no projeto principal, use o campo ARN da função de execução.
+ Para fornecer outros dados para o Device Farm usar durante a execução, ao lado de **Adicionar dados extras**, selecione **Escolher arquivo** e, em seguida, navegue até o arquivo .zip que contém os dados e escolha-o.
+ Para instalar uma aplicação adicional para o Device Farm usar durante a execução, ao lado de **Instalar outras aplicações**, selecione **Escolher arquivo** e, em seguida, procure e escolha o arquivo .apk ou .ipa que contém a aplicação. Repita isso para outros aplicativos que você deseja instalar. Você pode alterar a ordem de instalação arrastando e soltando os aplicativos depois de fazer upload deles.
+ Para especificar se Wi-Fi, Bluetooth, GPS ou NFC estará habilitado durante a execução, ao lado de **Set radio states (Definir estados de rádio)**, selecione as caixas apropriadas.
+ Para predefinir a latitude e a longitude do dispositivo para a execução, ao lado de **Device location (Local do dispositivo)**, insira as coordenadas.
+ Para predefinir a localidade da execução, em **Localidade do dispositivo**, escolha a localidade.
+ Selecione **Habilitar a gravação de vídeo** para gravar vídeos durante o teste.
+ Selecione **Habilitar a captura de dados de performance da aplicação** para capturar dados de desempenho do dispositivo.
**nota**
A configuração do estado do rádio do dispositivo está disponível apenas para testes nativos do Android no momento.
**nota**
Se você tiver dispositivos privados, a configuração específica dos dispositivos privados também será exibida.
1. Na parte inferior da página, escolha **Criar execução** para agendar a execução.
O Device Farm inicia a execução assim que os dispositivos estão disponíveis, normalmente em poucos minutos. Durante a execução do teste, o console do Device Farm exibe um ícone pendente ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-calendar.png) na tabela de execução. Cada dispositivo na execução também começará com o ícone pendente e, em seguida, mudará para o ícone em execução ![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-progress.png) quando o teste começar. Quando cada teste é concluído, um ícone de resultado do teste é exibido ao lado do nome do dispositivo. Quando todos os testes tiverem sido concluídos, o ícone pendente ao lado da execução mudará para um ícone de resultado de teste.
Se você quiser interromper a execução do teste, consulte [Interromper uma execução no AWS Device Farm](how-to-stop-test-runs.md).
## Criar uma execução de teste (AWS CLI)
Você pode usar o AWS CLI para criar uma execução de teste.
**Topics**
+ [Etapa 1: escolher um projeto](#how-to-create-test-run-cli-step1)
+ [Etapa 2: escolher um grupo de dispositivos](#how-to-create-test-run-cli-step2)
+ [Etapa 3: fazer upload do arquivo da aplicação](#how-to-create-test-run-cli-step3)
+ [Etapa 4: fazer upload do pacote de scripts de teste](#how-to-create-test-run-cli-step4)
+ [Etapa 5: (opcional) fazer upload de sua especificação de teste personalizada](#how-to-create-test-run-cli-step5)
+ [Etapa 6: programar uma execução de teste](#how-to-create-test-run-cli-step6)
### Etapa 1: escolher um projeto
Você deve associar sua execução de teste a um projeto do Device Farm.
1. Para listar seus projetos do Device Farm, execute **list-projects**. Se você não tiver um projeto, consulte [Criar um projeto no AWS Device Farm](how-to-create-project.md).
Exemplo:
```
aws devicefarm list-projects
```
A resposta inclui uma lista de seus projetos do Device Farm.
```
{
"projects": [
{
"name": "MyProject",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:project:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"created": 1503612890.057
}
]
}
```
1. Escolha um projeto a ser associado à execução de teste e anote seu nome de recurso da Amazon (ARN).
### Etapa 2: escolher um grupo de dispositivos
Você deve escolher um grupo de dispositivos a ser associado à execução de teste.
1. Para visualizar os grupos de dispositivos, execute **list-device-pools** especificando o ARN do projeto.
Exemplo:
```
aws devicefarm list-device-pools --arn arn:MyProjectARN
```
A resposta inclui os grupos de dispositivos integrados do Device Farm, como **Top Devices**, e os grupos de dispositivos criados anteriormente para esse projeto:
```
{
"devicePools": [
{
"rules": [
{
"attribute": "ARN",
"operator": "IN",
"value": "[\"arn:aws:devicefarm:us-west-2::device:example1\",\"arn:aws:devicefarm:us-west-2::device:example2\",\"arn:aws:devicefarm:us-west-2::device:example3\"]"
}
],
"type": "CURATED",
"name": "Top Devices",
"arn": "arn:aws:devicefarm:us-west-2::devicepool:example",
"description": "Top devices"
},
{
"rules": [
{
"attribute": "PLATFORM",
"operator": "EQUALS",
"value": "\"ANDROID\""
}
],
"type": "PRIVATE",
"name": "MyAndroidDevices",
"arn": "arn:aws:devicefarm:us-west-2:605403973111:devicepool:example2"
}
]
}
```
1. Escolha um grupo de dispositivos e anote o ARN.
Você também pode criar um grupo de dispositivos e retornar a essa etapa. Para obter mais informações, consulte [Criar um grupo de dispositivos (AWS CLI)](how-to-create-device-pool.md#how-to-create-device-pool-cli).
### Etapa 3: fazer upload do arquivo da aplicação
Para criar sua solicitação de upload e obter um URL de upload pré-assinado do Amazon Simple Storage Service (Amazon S3), você precisa:
+ O ARN do projeto.
+ O nome do arquivo do aplicativo.
+ O tipo do upload.
Para obter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html).
1. Para fazer upload de um arquivo, execute **create-upload** com os parâmetros `–-project-arn`, `--name` e `--type`.
Este exemplo cria um upload para um aplicativo Android:
```
aws devicefarm create-upload -–project-arn arn:MyProjectArn -–name MyAndroid.apk -–type ANDROID_APP
```
A resposta inclui o ARN de upload do aplicativo e um URL pré-assinado.
```
{
"upload": {
"status": "INITIALIZED",
"name": "MyAndroid.apk",
"created": 1535732625.964,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "ANDROID_APP",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
}
}
```
1. Anote o ARN de upload do aplicativo e o URL pré-assinado.
1. Faça o upload do arquivo da aplicação usando o URL predefinido do Amazon S3. Este exemplo usa **curl** para fazer upload de um arquivo .apk do Android:
```
curl -T MyAndroid.apk "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
```
Para obter mais informações, consulte [Carregar objetos usando presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) no Guia do *usuário do Amazon Simple Storage Service*.
1. Para verificar o status de upload do aplicativo, execute **get-upload** e especifique o ARN de upload do aplicativo.
```
aws devicefarm get-upload –-arn arn:MyAppUploadARN
```
Aguarde até o status na resposta ser **SUCCEEDED** para fazer upload do pacote de scripts de teste.
```
{
"upload": {
"status": "SUCCEEDED",
"name": "MyAndroid.apk",
"created": 1535732625.964,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "ANDROID_APP",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"metadata": "{"valid": true}"
}
}
```
### Etapa 4: fazer upload do pacote de scripts de teste
Em seguida, você faz upload do pacote de scripts de teste.
1. Para criar sua solicitação de upload e obter um URL de upload pré-assinado do Amazon S3, execute **create-upload** com os parâmetros `–-project-arn`, `--name` e `--type`.
Este exemplo cria um upload do pacote de testes do Appium Java TestNG:
```
aws devicefarm create-upload –-project-arn arn:MyProjectARN -–name MyTests.zip –-type APPIUM_JAVA_TESTNG_TEST_PACKAGE
```
A resposta inclui o ARN de upload do pacote de testes e um URL pré-assinado.
```
{
"upload": {
"status": "INITIALIZED",
"name": "MyTests.zip",
"created": 1535738627.195,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
}
}
```
1. Anote o ARN de upload do pacote de testes e o URL pré-assinado.
1. Faça upload do arquivo do pacote de scripts de teste usando o URL pré-assinado do Amazon S3. Este exemplo usa **curl** para fazer upload de um arquivo de scripts do Appium TestNG compactado:
```
curl -T MyTests.zip "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
```
1. Para verificar o status do upload do pacote de scripts de teste, execute **get-upload** e especifique o ARN de upload do pacote de testes da etapa 1.
```
aws devicefarm get-upload –-arn arn:MyTestsUploadARN
```
Aguarde o status na resposta ser **SUCCEEDED** para avançar à próxima etapa, opcional.
```
{
"upload": {
"status": "SUCCEEDED",
"name": "MyTests.zip",
"created": 1535738627.195,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"metadata": "{"valid": true}"
}
}
```
### Etapa 5: (opcional) fazer upload de sua especificação de teste personalizada
Se você estiver executando os testes em um ambiente de teste padrão, ignore esta etapa.
O Device Farm mantém um arquivo de especificações de teste padrão para cada tipo de teste compatível. Em seguida, você faz download da especificação de teste padrão e o usa para criar o upload da especificação de teste personalizada para executar os testes em um ambiente de teste personalizado. Para obter mais informações, consulte [Ambientes de teste no AWS Device Farm](test-environments.md).
1. Para encontrar o ARN de upload para a especificação de teste padrão, execute **list-uploads** e especifique o ARN do projeto.
```
aws devicefarm list-uploads --arn arn:MyProjectARN
```
A resposta contém uma entrada para cada especificação de teste padrão:
```
{
"uploads": [
{
{
"status": "SUCCEEDED",
"name": "Default TestSpec for Android Appium Java TestNG",
"created": 1529498177.474,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
}
}
]
}
```
1. Escolha a especificação de teste padrão na lista. Anote o ARN do upload.
1. Para fazer download da especificação de teste padrão, execute **get-upload** e especifique o ARN de upload.
Exemplo:
```
aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN
```
A resposta contém um URL pré-assinado em que você pode fazer download da especificação de teste padrão.
1. Este exemplo usa **curl** para fazer download da especificação de teste padrão e salvá-lo como `MyTestSpec.yml`:
```
curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyTestSpec.yml
```
1. Você pode editar a especificação de teste padrão para atender aos requisitos de teste e, em seguida, usar a especificação de teste modificada em execuções de teste futuras. Ignore esta etapa para usar a especificação de teste padrão no estado em que ela se encontra em um ambiente de teste personalizado.
1. Para criar um upload da especificação de teste personalizada, execute **create-upload** especificando o nome e o tipo da especificação de teste e o ARN do projeto.
Este exemplo cria um upload para uma especificação de teste personalizada do Appium Java TestNG:
```
aws devicefarm create-upload --name MyTestSpec.yml --type APPIUM_JAVA_TESTNG_TEST_SPEC --project-arn arn:MyProjectARN
```
A resposta inclui o ARN de upload da especificação de teste e um URL pré-assinado:
```
{
"upload": {
"status": "INITIALIZED",
"category": "PRIVATE",
"name": "MyTestSpec.yml",
"created": 1535751101.221,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
}
}
```
1. Anote o ARN do upload da especificação de teste e o URL pré-assinado.
1. Faça upload do arquivo de especificações de teste usando o URL pré-assinado do Amazon S3. Este exemplo é usado **curl** para carregar uma especificação de teste do Appium JavaTest NG:
```
curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
```
1. Para verificar o status de upload da especificação de teste, execute **get-upload** e especifique o ARN de upload.
```
aws devicefarm get-upload –-arn arn:MyTestSpecUploadARN
```
Aguarde até o status na resposta ser **SUCCEEDED** antes de programar a execução de teste.
```
{
"upload": {
"status": "SUCCEEDED",
"name": "MyTestSpec.yml",
"created": 1535732625.964,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"metadata": "{"valid": true}"
}
}
```
Para atualizar a especificação de teste personalizada, execute **update-upload** especificando o ARN de upload para a especificação de teste. Para obter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html).
### Etapa 6: programar uma execução de teste
Para agendar uma execução de teste com o AWS CLI, execute**schedule-run**, especificando:
+ O ARN do projeto da [etapa 1](#how-to-create-test-run-cli-step1).
+ O ARN do grupo de dispositivos da [etapa 2](#how-to-create-test-run-cli-step2).
+ O ARN de upload do aplicativo da [etapa 3](#how-to-create-test-run-cli-step3).
+ O ARN de upload do pacote de testes da [etapa 4](#how-to-create-test-run-cli-step4).
Se estiver executando testes em um ambiente de teste personalizado, você também precisará do ARN da especificação de teste da [etapa 5](#how-to-create-test-run-cli-step5).
**Para programar uma execução em um ambiente de teste padrão**
+ Execute **schedule-run** especificando o ARN do projeto, o ARN do grupo de dispositivos, o ARN de upload do aplicativo e as informações do pacote de testes.
Exemplo:
```
aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
```
A resposta contém um ARN de execução que você pode usar para verificar o status da execução de teste.
```
{
"run": {
"status": "SCHEDULING",
"appUpload": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345appEXAMPLE",
"name": "MyTestRun",
"radios": {
"gps": true,
"wifi": true,
"nfc": true,
"bluetooth": true
},
"created": 1535756712.946,
"totalJobs": 179,
"completedJobs": 0,
"platform": "ANDROID_APP",
"result": "PENDING",
"devicePoolArn": "arn:aws:devicefarm:us-west-2:123456789101:devicepool:5e01a8c7-c861-4c0a-b1d5-12345devicepoolEXAMPLE",
"jobTimeoutMinutes": 150,
"billingMethod": "METERED",
"type": "APPIUM_JAVA_TESTNG",
"testSpecArn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345specEXAMPLE",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 0,
"errored": 0,
"total": 0
}
}
}
```
Para obter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html).
**Para programar uma execução em um ambiente de teste personalizado**
+ As etapas são quase idênticas às do ambiente de teste padrão com um atributo `testSpecArn` adicional incluído no parâmetro `--test`.
Exemplo:
```
aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test testSpecArn=arn:MyTestSpecUploadARN,type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
```
**Para verificar o status da execução de teste**
+ Use o comando **get-run** e especifique o ARN de execução.
```
aws devicefarm get-run --arn arn:aws:devicefarm:us-west-2:111122223333:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE
```
Para obter mais informações, consulte [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html). Para obter informações sobre como usar o Device Farm com o AWS CLI, consulte[AWS CLIReferência do ](cli-ref.md).
## Criar uma execução de teste (API)
As etapas são as mesmas descritas na AWS CLI seção. Consulte [Criar uma execução de teste (AWS CLI)](#how-to-create-test-run-cli).
Você precisa dessas informações para chamar a API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html):
+ Um ARN de projeto. Consulte [Criar um projeto (API)](how-to-create-project.md#how-to-create-project-api) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html).
+ Um ARN de upload do aplicativo. Consulte [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Um ARN de upload do pacote de testes. Consulte [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ ARN de um grupos de dispositivos. Consulte [Criar um grupo de dispositivos](how-to-create-device-pool.md) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).
**nota**
Se estiver executando testes em um ambiente de teste personalizado, você também precisará do ARN de upload da especificação de teste. Para obter mais informações, consulte [Etapa 5: (opcional) fazer upload de sua especificação de teste personalizada](#how-to-create-test-run-cli-step5) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
Para obter informações sobre como usar a API do Device Farm, consulte [Automatização do Device Farm](api-ref.md).
## Próximas etapas
No console do Device Farm, o ícone de relógio ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-calendar.png) muda para um ícone de resultado, como sucesso ![\[The test succeeded.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-success.png), quando a execução é concluída. Um relatório da execução é exibido assim que os testes são concluídos. Para obter mais informações, consulte [Relatórios no AWS Device FarmRelatórios](reports.md).
Para usar o relatório, siga as instruções em [Visualizar relatórios de testes no Device Farm](how-to-use-reports.md).
# Definir o tempo limite para execuções de teste no AWS Device Farm
Você pode definir por quanto tempo um teste deve ser executado antes de interromper a execução de teste de cada dispositivo. O tempo limite de execução padrão é 150 minutos por dispositivo, mas você pode definir um valor mínimo de 5 minutos. Você pode usar o console do AWS Device Farm ou a API do AWS Device Farm para definir o tempo limite de execução. AWS CLI
**Importante**
A opção do tempo limite de execução deve ser definida como a *duração máxima* para uma execução de teste, além de algum buffer. Por exemplo, se os testes demorarem 20 minutos por dispositivo, você deverá escolher um tempo limite de 30 minutos por dispositivo.
Se a execução exceder o tempo limite, a execução nesse dispositivo será interrompida à força. Os resultados parciais estarão disponíveis, se possível. Você será cobrado pela execução até esse ponto, se estiver usando a opção de cobrança medida. Para obter mais informações sobre preços, consulte [Definição de preço do AWS Device Farm](https://aws.amazon.com/device-farm/pricing/).
Talvez você queira usar esse recurso se souber quanto tempo leva para executar um teste em cada dispositivo. Ao especificar um tempo limite de execução para um teste, você pode evitar a situação em que a execução fica impedida por algum motivo e você continua sendo cobrado por minutos de dispositivo mesmo quando nenhum teste está sendo executado. Em outras palavras, usar o recurso de tempo limite de execução permite interromper essa execução se ela estiver demorando mais do que o esperado.
Você pode definir o tempo limite de execução em dois locais: no nível do projeto e no nível de execução de teste.
## Pré-requisitos
1. Siga as etapas em [Configurar](setting-up.md).
1. Crie um projeto no Device Farm. Siga as instruções em [Criar um projeto no AWS Device Farm](how-to-create-project.md) e retorne para esta página.
## Definir o tempo limite de execução de um projeto
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ê já tiver um projeto, selecione-o na lista. Caso contrário, escolha **Novo projeto**, insira um nome para o projeto e, em seguida, selecione **Enviar**.
1. Escolha **Configurações do projeto**.
1. Na guia **Geral**, em **Tempo limite de execução**, insira um valor ou use a barra deslizante.
1. Escolha **Salvar**.
Todas as execuções de teste no projeto agora usarão o valor de tempo limite de execução que você acabou de especificar, a menos que substitua o valor do tempo limite ao programar uma execução.
## Definir o tempo limite de execução para uma execução de teste
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ê já tiver um projeto, selecione-o na lista. Caso contrário, escolha **Novo projeto**, insira um nome para o projeto e, em seguida, selecione **Enviar**.
1. Escolha **Criar uma nova execução**.
1. Siga as etapas para escolher um aplicativo, configurar o teste, selecionar os dispositivos e especificar um estado para o dispositivo.
1. Em **Analisar e iniciar a execução**, para **Definir tempo limite de execução**, insira um valor ou use a barra deslizante.
1. Escolha **Confirmar e iniciar a execução**.
# Simular conexões e condições de rede para suas execuções do AWS Device Farm
Você pode usar a modelagem de rede para simular conexões e condições de rede enquanto testa seus aplicativos Android, iOS e web no Device Farm. Por exemplo, você pode simular conectividade com a Internet intermitente ou com perdas.
Quando você cria uma execução usando as configurações de rede padrão, cada dispositivo tem uma conexão Wi-Fi completa e desimpedida com conectividade com a internet. Ao usar a modelagem de rede, você pode alterar a conexão Wi-Fi para especificar um perfil de rede, como **3G** ou **Lossy**, WiFi que controla a taxa de transferência, o atraso, a instabilidade e a perda do tráfego de entrada e saída.
**Topics**
+ [Configurar a modelagem de rede ao programar uma execução de teste](#network-shaping-how-to-choose-a-curated-profile-when-scheduling-a-test-run)
+ [Criar um perfil de rede](#network-shaping-how-to-create-a-network-profile)
+ [Alterar as condições da rede durante o teste](#change-network-conditions-during-test)
## Configurar a modelagem de rede ao programar uma execução de teste
Ao programar uma execução, você pode escolher entre qualquer um dos perfis selecionados pelo Device Farm ou criar e gerenciar o seu próprio perfil.
1. Em qualquer projeto do Device Farm, escolha **Criar uma nova execução**.
Se ainda não tiver um projeto, consulte [Criar um projeto no AWS Device Farm](how-to-create-project.md).
1. Escolha sua aplicação e, em seguida, selecione **Próximo**.
1. Configure seu teste e, em seguida, escolha **Próximo**.
1. Selecione seus dispositivos e, em seguida, escolha **Próximo**.
1. Na seção **Configurações de localização e rede**, escolha um perfil de rede ou selecione **Criar perfil de rede** para criar o seu próprio perfil.
![\[Perfil de rede para uma execução de teste\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/aws-device-farm-set-up-network-profile.png)
1. Escolha **Próximo**.
1. Analise e inicie a execução de teste.
## Criar um perfil de rede
Ao criar uma execução de teste, você pode criar um perfil de rede.
1. Escolha **Criar perfil de rede**.
![\[Criar um novo perfil de rede\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/aws-device-farm-create-a-new-network-profile.png)
1. Digite um nome e as configurações para o perfil de rede.
1. Escolha **Criar**.
1. Termine de criar a execução de teste e inicie a execução.
Depois de criar um perfil de rede, você poderá vê-lo e gerenciá-lo na página **Configurações do projeto**.
![\[Perfis de rede em configurações do projeto\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/aws-device-farm-network-profiles-in-project-settings.png)
## Alterar as condições da rede durante o teste
Você pode chamar uma API pelo host do dispositivo usando uma estrutura como Appium para simular condições de rede dinâmicas, como largura de banda reduzida durante a execução do teste. Para obter mais informações, consulte [CreateNetworkProfile](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateNetworkProfile.html).
# Interromper uma execução no AWS Device Farm
Talvez você queira interromper uma execução já iniciada. Por exemplo, se perceber um problema enquanto os testes estiverem sendo executados, convém reiniciar a execução com um script de teste atualizado.
Você pode usar o console Device Farm ou a API para interromper uma execução. AWS CLI
**Topics**
+ [Interromper uma execução (console)](#how-to-stop-run-console)
+ [Interromper uma execução (AWS CLI)](#how-to-stop-test-run-cli)
+ [Interromper uma execução (API)](#how-to-stop-test-run-api)
## Interromper uma execução (console)
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. Escolha o projeto no qual você tem uma execução de teste ativa.
1. Na página **Testes automatizados**, escolha a execução do teste.
O ícone pendente ou em execução deve aparecer à esquerda do nome do dispositivo.
![\[Device Farm – Interromper uma execução de teste\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/aws-device-farm-stop-run.png)
1. Escolha **Interromper a execução**.
Após um breve período, um ícone com um círculo vermelho com um sinal de menos dentro aparece ao lado do nome do dispositivo. Quando a execução é interrompida, a cor do ícone muda de vermelho para preto.
**Importante**
Se um teste já tiver sido executado, o Device Farm não poderá interrompê-lo. Se um teste estiver em andamento, o Device Farm interromperá o teste. O total de minutos pelos quais você será cobrado é exibido na seção **Dispositivos**. Além disso, você também será cobrado pelo total de minutos que o Device Farm leva para executar o conjunto de configuração e o conjunto de desmontagem. Para obter mais informações, consulte [Definição de preço do Device Farm](https://aws.amazon.com/device-farm/faq/#pricing).
A imagem a seguir mostra um exemplo da seção **Dispositivos** depois que uma execução de teste foi interrompida com êxito.
![\[Device Farm – Página de detalhes de uma execução interrompida\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/aws-device-farm-stop-run-view-details.png)
## Interromper uma execução (AWS CLI)
Você pode executar o comando a seguir para interromper a execução do teste especificada, onde *myARN* está o Amazon Resource Name (ARN) da execução do teste.
```
$ aws devicefarm stop-run --arn myARN
```
Você deve ver uma saída semelhante a:
```
{
"run": {
"status": "STOPPING",
"name": "Name of your run",
"created": 1458329687.951,
"totalJobs": 7,
"completedJobs": 5,
"deviceMinutes": {
"unmetered": 0.0,
"total": 0.0,
"metered": 0.0
},
"platform": "ANDROID_APP",
"result": "PENDING",
"billingMethod": "METERED",
"type": "BUILTIN_EXPLORER",
"arn": "myARN",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 0,
"errored": 0,
"total": 0
}
}
}
```
Para obter o ARN de sua execução, use o comando `list-runs`. A saída deve ser semelhante ao seguinte:
```
{
"runs": [
{
"status": "RUNNING",
"name": "Name of your run",
"created": 1458329687.951,
"totalJobs": 7,
"completedJobs": 5,
"deviceMinutes": {
"unmetered": 0.0,
"total": 0.0,
"metered": 0.0
},
"platform": "ANDROID_APP",
"result": "PENDING",
"billingMethod": "METERED",
"type": "BUILTIN_EXPLORER",
"arn": "Your ARN will be here",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 0,
"errored": 0,
"total": 0
}
}
]
}
```
Para obter informações sobre como usar o Device Farm com o AWS CLI, consulte[AWS CLIReferência do ](cli-ref.md).
## Interromper uma execução (API)
+ Chame a [StopRun](../../latest/APIReference/API_StopRun.html)operação para a execução do teste.
Para obter informações sobre como usar a API do Device Farm, consulte [Automatização do Device Farm](api-ref.md).
# Visualizar uma lista de execuções no AWS Device Farm
Você pode usar o console ou a API do Device Farm para ver uma lista de execuções de um projeto. AWS CLI
**Topics**
+ [Visualizar uma lista de execuções (console)](#how-to-view-runs-list-console)
+ [Visualizar uma lista de execuções (AWS CLI)](#how-to-view-runs-list-cli)
+ [Visualizar uma lista de execuções (API)](#how-to-view-runs-list-api)
## Visualizar uma lista de execuções (console)
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 que corresponde à lista que você deseja visualizar.
**dica**
Você pode usar a barra de pesquisa para filtrar a lista de projetos por nome.
## Visualizar uma lista de execuções (AWS CLI)
+ Execute o comando [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html).
Para visualizar informações sobre uma única execução, execute o comando [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html).
Para obter informações sobre como usar o Device Farm com o AWS CLI, consulte[AWS CLIReferência do ](cli-ref.md).
## Visualizar uma lista de execuções (API)
+ Chame a API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html).
Para visualizar informações sobre uma única execução, chame a API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html).
Para obter informações sobre a API do Device Farm, consulte [Automatização do Device Farm](api-ref.md).
# Criar um grupo de dispositivos no AWS Device Farm
Você pode usar o console Device Farm ou a API para criar um pool de dispositivos. AWS CLI
**Topics**
+ [Pré-requisitos](#how-to-create-device-pool-prerequisites)
+ [Criar um grupo de dispositivos (console)](#how-to-create-device-pool-console)
+ [Criar um grupo de dispositivos (AWS CLI)](#how-to-create-device-pool-cli)
+ [Criar um grupo de dispositivos (API)](#how-to-create-device-pool-api)
## Pré-requisitos
+ Crie uma execução no console do Device Farm. Siga as instruções em [Criar uma execução de teste no Device Farm](how-to-create-test-run.md). Ao acessar a página **Selecionar dispositivos**, avance às instruções nesta seção.
## Criar um grupo de dispositivos (console)
1. Na página **Projetos**, escolha seu projeto. Na página **Detalhes do projeto**, escolha **Configurações do projeto**. Na guia **Grupos de dispositivos**, escolha **Criar grupo de dispositivos**.
1. Em **Nome**, insira um nome que facilite a identificação desse grupo de dispositivos.
1. Em **Descrição**, digite uma descrição que facilite a identificação desse grupo de dispositivos.
1. Se quiser usar um ou mais critérios de seleção para os dispositivos nesse grupo de dispositivos, faça o seguinte:
1. Escolha **Criar grupos dinâmicos de dispositivos**.
1. Escolha **Adicionar uma regra**.
1. Em **Campo** (primeira lista suspensa), escolha uma das seguintes opções:
+ Para incluir dispositivos pelo nome do fabricante, escolha **Fabricante do dispositivo**.
+ Para incluir dispositivos pelo fator forma (tablet ou telefone), escolha **Fator forma**.
+ Para incluir dispositivos pelo respectivo status de disponibilidade com base na carga, escolha **Disponibilidade**.
+ Para incluir somente dispositivos públicos ou privados, escolha **Tipo de frota**.
+ Para incluir dispositivos pelo sistema operacional, escolha **Plataforma**.
+ Alguns dispositivos têm uma etiqueta ou descrição adicional sobre o dispositivo. Você pode encontrar dispositivos com base no conteúdo dos rótulos escolhendo **Rótulos de instância**.
+ Para incluir dispositivos pela versão do sistema operacional, escolha **Versão do SO**.
+ Para incluir dispositivos pelo modelo, escolha **Modelo**.
1. Para **Operador** (segunda lista suspensa), escolha uma operação lógica (EQUALS, CONTAINS etc.) para incluir dispositivos com base na consulta. Por exemplo, você pode *Availability EQUALS AVAILABLE* optar por incluir dispositivos que atualmente têm o `Available` status.
1. Em **Valor** (terceira lista suspensa), insira ou selecione o valor que deseja especificar para os valores de **Campo** e **Operador**. Os valores são limitados com base na sua escolha de **Campo**. Por exemplo, se você escolher **Plataforma** para **Campo**, as únicas seleções disponíveis serão **ANDROID** e **IOS**. Da mesma forma, se você escolher **Fator forma** para **Campo**, as únicas seleções disponíveis serão **TELEFONE** e **TABLET**.
1. Para adicionar outra regra, escolha **Adicionar uma regra**.
Depois que você criar a primeira regra, na lista de dispositivos, a caixa ao lado de cada dispositivo correspondente à regra será marcada. Depois que você criar ou alterar regras existentes, na lista de dispositivos, a caixa de seleção ao lado de cada dispositivo correspondente a essas regras combinadas será marcada. Os dispositivos com caixas selecionadas são incluídos no grupo de dispositivos. Os dispositivos com caixas desmarcadas são excluídos.
1. Em **Máximo de dispositivos**, insira o número de dispositivos que você deseja usar no seu grupo de dispositivos. Se você não inserir o número máximo de dispositivos, o Device Farm escolherá todos os dispositivos da frota que correspondam às regras criadas. Para evitar cobranças adicionais, defina esse número como um valor que corresponda aos requisitos reais de execução paralela e variedade de dispositivos.
1. Para excluir uma regra, escolha **Remove regra**.
1. Se quiser incluir ou excluir manualmente dispositivos individuais, faça o seguinte:
1. Escolha **Criar grupos estáticos de dispositivos**.
1. Selecione ou desmarque a caixa ao lado de cada dispositivo. Você poderá marcar ou desmarcar as caixas somente se não houver regras especificadas.
1. Se desejar incluir ou excluir todos os dispositivos exibidos, marque ou desmarque a caixa na linha de cabeçalho de coluna da lista. Se você quiser visualizar somente instâncias de dispositivos privados, escolha **Ver somente instâncias de dispositivos privados**.
**Importante**
Embora você possa usar as caixas na linha de cabeçalho da coluna para alterar a lista de dispositivos exibidos, isso não significa que os demais dispositivos exibidos sejam os únicos incluídos ou excluídos. Para confirmar quais dispositivos são incluídos ou excluídos, não se esqueça de apagar o conteúdo de todas as caixas na linha de cabeçalho da coluna e navegue nas caixas.
1. Escolha **Criar**.
## Criar um grupo de dispositivos (AWS CLI)
**dica**
Se você não inserir o número máximo de dispositivos, o Device Farm escolherá todos os dispositivos da frota que correspondam às regras criadas. Para evitar cobranças adicionais, defina esse número como um valor que corresponda aos requisitos reais de execução paralela e variedade de dispositivos.
+ Execute o comando [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-device-pool.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-device-pool.html).
Para obter informações sobre como usar o Device Farm com o AWS CLI, consulte[AWS CLIReferência do ](cli-ref.md).
## Criar um grupo de dispositivos (API)
**dica**
Se você não inserir o número máximo de dispositivos, o Device Farm escolherá todos os dispositivos da frota que correspondam às regras criadas. Para evitar cobranças adicionais, defina esse número como um valor que corresponda aos requisitos reais de execução paralela e variedade de dispositivos.
+ Chame a API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).
Para obter informações sobre como usar a API do Device Farm, consulte [Automatização do Device Farm](api-ref.md).
# Analisar os resultados dos testes no AWS Device Farm
No ambiente de teste padrão, é possível usar o console do Device Farm para visualizar os relatórios de cada teste na execução do teste. A visualização dos relatórios ajuda você a entender quais testes foram aprovados ou falharam e fornece detalhes sobre a performance e o comportamento da sua aplicação em diferentes configurações de dispositivos.
O Device Farm também reúne outros artefatos, como arquivos, logs e imagens, que podem ser baixados quando a execução do teste for concluída. Essas informações podem ajudar você a analisar como sua aplicação está se comportando em dispositivos reais, identificar problemas ou bugs e diagnosticar problemas.
**Topics**
+ [Visualizar relatórios de testes no Device Farm](how-to-use-reports.md)
+ [Baixar artefatos no Device Farm](artifacts.md)
# Visualizar relatórios de testes no Device Farm
Use o console do Device Farm para visualizar seus relatórios de testes. Para obter mais informações, consulte [Relatórios no AWS Device FarmRelatórios](reports.md).
**Topics**
+ [Pré-requisitos](#how-to-use-reports-prerequisites)
+ [Visualizar relatórios](#how-to-use-reports-viewing-reports)
+ [Status dos resultados do teste do Device Farm](how-to-use-reports-displaying-results.md)
## Pré-requisitos
Configure uma execução de teste e verifique se ela foi concluída.
1. Para criar uma execução, consulte [Criar uma execução de teste no Device Farm](how-to-create-test-run.md) e retorne a esta página.
1. Verifique se a execução foi concluída. Durante a execução do teste, o console do Device Farm exibe um ícone pendente ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-calendar.png) para execuções que estão em andamento. Cada dispositivo na execução também começará com o ícone pendente e, em seguida, mudará para o ícone em execução ![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-progress.png) quando o teste começar. Quando cada teste é concluído, um ícone de resultado do teste é exibido ao lado do nome do dispositivo. Quando todos os testes tiverem sido concluídos, o ícone pendente ao lado da execução mudará para um ícone de resultado de teste. Para obter mais informações, consulte [Status dos resultados do teste do Device Farm](how-to-use-reports-displaying-results.md).
## Visualizar relatórios
Você pode visualizar os resultados do seu teste no console do Device Farm.
**Topics**
+ [Visualizar a página de resumo da execução de teste](#how-to-use-reports-console-summary)
+ [Visualizar relatórios de problemas exclusivos](#how-to-use-reports-console-unique-problems)
+ [Visualizar relatórios do dispositivo](#how-to-use-reports-console-by-device)
+ [Visualizar relatórios do conjunto de testes](#how-to-use-reports-console-by-suite)
+ [Visualizar relatórios de teste](#how-to-use-reports-console-by-test)
+ [Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório](#how-to-use-reports-console-log)
### Visualizar a página de resumo da execução de teste
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, escolha **Teste para dispositivos móveis** e **Projetos**.
1. Na lista de projetos, escolha o projeto para a execução.
**dica**
Para filtrar a lista de projetos por nome, use a barra de pesquisa.
1. Escolha uma execução concluída para visualizar a página de relatório resumido.
1. A página de resumo da execução de teste exibe uma visão geral dos resultados do teste.
+ A seção **Problemas exclusivos** lista avisos e falhas exclusivos. Para visualizar problemas exclusivos, siga as instruções em [Visualizar relatórios de problemas exclusivos](#how-to-use-reports-console-unique-problems).
+ A seção **Dispositivos** exibe o número total de testes, por resultado, para cada dispositivo.
![\[Device Farm device summary results.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-device-summary-results-bar.png)
Neste exemplo, há vários dispositivos. Na primeira entrada da tabela, o dispositivo Google Pixel 4 XL com Android versão 10 relata três testes bem-sucedidos que levaram 2:36 minutos para serem executados.
Para visualizar os resultados por dispositivo, siga as instruções em [Visualizar relatórios do dispositivo](#how-to-use-reports-console-by-device).
+ A seção **Capturas de tela** exibe uma lista de todas as capturas de tela que o Device Farm fez durante a execução, agrupadas por dispositivo.
+ Na seção **Resultado da análise**, você pode baixar o resultado da análise.
### Visualizar relatórios de problemas exclusivos
1. Em **Problemas exclusivos**, escolha o problema que você deseja visualizar.
1. Escolha o dispositivo. O relatório exibe informações sobre o problema.
A seção **Vídeo** exibe a gravação em vídeo do teste disponível para download.
A seção **Resultado** exibe o resultado do teste. O status é representado como um ícone de resultado. Para obter mais informações, consulte [Status de um teste individual](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
A seção **Logs** exibe todas as informações que o Device Farm registrou durante o teste. Para visualizar essas informações, siga as instruções em [Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório](#how-to-use-reports-console-log).
A guia **Arquivos** exibe uma lista de todos os arquivos associados do teste (como arquivos de log) disponíveis para download. Para fazer download de um arquivo, selecione o link do arquivo na lista.
A guia **Capturas de tela** exibe uma lista de todas as capturas de tela que o Device Farm fez durante o teste.
### Visualizar relatórios do dispositivo
+ Na seção **Dispositivos**, escolha o dispositivo.
A seção **Vídeo** exibe a gravação em vídeo do teste disponível para download.
A seção **Conjuntos** exibe uma tabela com informações sobre os conjuntos do dispositivo.
Nessa tabela, a coluna **Resultados do teste** resume o número de testes por resultado para cada um dos conjuntos de testes que foram executados no dispositivo. Esses dados também têm um componente gráfico. Para obter mais informações, consulte [Status de vários testes](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Para visualizar os resultados completos por conjunto, siga as instruções em [Visualizar relatórios do conjunto de testes](#how-to-use-reports-console-by-suite).
A seção **Logs** exibe todas as informações que o Device Farm registrou para o dispositivo durante a execução. Para visualizar essas informações, siga as instruções em [Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório](#how-to-use-reports-console-log).
A seção **Arquivos** exibe uma lista de conjuntos para o dispositivo e todos os arquivos associados (como arquivos de log) que podem ser baixados. Para fazer download de um arquivo, selecione o link do arquivo na lista.
A seção **Capturas de tela** exibe uma lista de todas as capturas de tela que o Device Farm fez durante a execução do dispositivo, agrupadas por conjunto.
### Visualizar relatórios do conjunto de testes
1. Na seção **Dispositivos**, escolha o dispositivo.
1. Na seção **Conjuntos**, escolha o conjunto na tabela.
A seção **Vídeo** exibe a gravação em vídeo do teste disponível para download.
A seção **Testes** exibe uma tabela contendo informações sobre os testes no conjunto.
Na tabela, a coluna **Resultados do teste** exibe o resultado. Esses dados também têm um componente gráfico. Para obter mais informações, consulte [Status de vários testes](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Para visualizar os resultados completos por teste, siga as instruções em [Visualizar relatórios de teste](#how-to-use-reports-console-by-test).
A seção **Logs** exibe todas as informações que o Device Farm registrou durante a execução do conjunto. Para visualizar essas informações, siga as instruções em [Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório](#how-to-use-reports-console-log).
A seção **Arquivos** exibe uma lista de testes para o conjunto e todos os arquivos associados (como arquivos de log) que podem ser baixados. Para fazer download de um arquivo, selecione o link do arquivo na lista.
A seção **Capturas de tela** exibe uma lista de todas as capturas de tela que o Device Farm fez durante a execução do conjunto, agrupadas por teste.
### Visualizar relatórios de teste
1. Na seção **Dispositivos**, escolha o dispositivo.
1. Na seção **Conjuntos**, escolha o conjunto.
1. Na seção **Testes**, escolha o teste.
1. A seção **Vídeo** exibe a gravação em vídeo do teste disponível para download.
A seção **Resultado** exibe o resultado do teste. O status é representado como um ícone de resultado. Para obter mais informações, consulte [Status de um teste individual](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
A seção **Logs** exibe todas as informações que o Device Farm registrou durante o teste. Para visualizar essas informações, siga as instruções em [Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório](#how-to-use-reports-console-log).
A guia **Arquivos** exibe uma lista de todos os arquivos associados do teste (como arquivos de log) disponíveis para download. Para fazer download de um arquivo, selecione o link do arquivo na lista.
A guia **Capturas de tela** exibe uma lista de todas as capturas de tela que o Device Farm fez durante o teste.
### Visualizar informações de log de um problema, dispositivo, conjunto ou teste em um relatório
A seção **Logs** exibe as seguintes informações:
+ **Origem** representa a origem de uma entrada de log. Os possíveis valores incluem:
+ **Harness** representa uma entrada de log que o Device Farm criou. Essas entradas de log normalmente são criadas durante os eventos de início e interrupção.
+ **Dispositivo** representa uma entrada de log que o dispositivo criou. Para Android, essas entradas de log são compatíveis com logcat. Para iOS, essas entradas de log são compatíveis com syslog.
+ **Teste** representa uma entrada de log criada por um teste ou pela estrutura de teste.
+ **Hora** representa o tempo decorrido entre a primeira entrada de log e a entrada de log em questão. A hora é expressa em *MM:SS.SSS* formato, onde *M* representa minutos e *S* representa segundos.
+ **PID** representa o identificador de processo (PID) que criou a entrada de log. Todas as entradas de log criadas por um aplicativo em um dispositivo têm o mesmo PID.
+ **Nível** representa o nível de registro relativo à entrada de log. Por exemplo, `Logger.debug("This is a message!")` registra o **Nível** de `Debug`. Estes são os valores possíveis:
+ **Alerta**
+ **Crítico**
+ **Depure**
+ **Emergência**
+ **Erro**
+ **Com erro**
+ **Com falha**
+ **Informações**
+ **Interno**
+ **Aviso**
+ **Aprovada**
+ **Skipped**
+ **Interrompido**
+ **Detalhado**
+ **Avisado**
+ **Aviso**
+ **Tag** representa metadados arbitrários relativos à entrada de log. Por exemplo, o logcat para Android pode usar esse recurso para descrever qual parte do sistema criou a entrada de log (por exemplo, `ActivityManager`).
+ **Mensagem** representa a mensagem ou os dados relativos à entrada de log. Por exemplo, `Logger.debug("Hello, World!")` registra uma **Mensagem** de `"Hello, World!"`.
Para exibir apenas uma parte das informações:
+ Para mostrar todas as entradas de log que correspondem a um valor de uma coluna específica, insira o valor na barra de pesquisa. Por exemplo, para mostrar todas as entradas de log com o valor **Origem** de `Harness`, insira **Harness** na barra de pesquisa.
+ Para remover todos os caracteres de uma caixa de cabeçalho de coluna, escolha o **X** na caixa de cabeçalho de coluna. Remover todos os caracteres de uma caixa de cabeçalho de coluna é o mesmo que inserir **\$1** nessa caixa de cabeçalho de coluna.
Para fazer download de todas as informações de registro do dispositivo, incluindo todos os conjuntos e testes executados, selecione **Baixar logs**.
# Status dos resultados do teste do Device Farm
O console do Device Farm exibe ícones que ajudam a avaliar rapidamente o estado da execução de teste concluída. Para acessar mais informações sobre testes no Device Farm, consulte [Relatórios no AWS Device FarmRelatórios](reports.md).
**Topics**
+ [Status de um teste individual](#how-to-use-reports-displaying-results-individual)
+ [Status de vários testes](#how-to-use-reports-displaying-results-summary)
## Status de um teste individual
Para relatórios que descrevem um teste individual, o Device Farm exibe um ícone que representa o status do resultado do teste:
| Description | Ícone |
| --- | --- |
| O teste bem-sucedido. | ![\[The test succeeded.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-success.png) |
| Falha no teste. | ![\[The test failed.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-failure.png) |
| O Device Farm ignorou o teste. | ![\[The test was skipped.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-skipped.png) |
| O teste foi interrompido. | ![\[The test was stopped.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-stopped.png) |
| O Device Farm retornou um aviso. | ![\[Device Farm returned a warning.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-warning.png) |
| O Device Farm retornou um erro. | ![\[Device Farm returned an error.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-run-error.png) |
## Status de vários testes
Se você escolher uma execução concluída, o Device Farm exibirá um grafo de resumo mostrando a porcentagem de testes em vários estados.
![\[Device Farm test results summary graph.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/df-summary-results-graph.png)
Por exemplo, esse grafo de resultados de execução de teste mostra que a execução teve 4 testes interrompidos, 1 teste com falha e 10 testes bem-sucedidos.
Os grafos são sempre codificados por cores e rotulados.
# Baixar artefatos no Device Farm
O Device Farm reúne artefatos como relatórios, arquivos de log e imagens para cada teste na execução.
Você pode fazer download dos artefatos criados durante a execução de teste:
**Arquivos**
Arquivos gerados durante a execução do teste, incluindo relatórios do Device Farm. Para obter mais informações, consulte [Visualizar relatórios de testes no Device Farm](how-to-use-reports.md).
**Logs**
A saída de cada teste na execução.
**Capturas de tela**
Imagens de tela gravadas para cada teste na execução.
![\[Workflow diagram showing Project, Run, Job (device), Test suite, and Test stages in Nuvem AWS.\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/hierarchy.png)
## Baixar artefatos (console)
1. Na página de execução do relatório de teste, em **Dispositivos**, escolha um dispositivo móvel.
1. Para fazer download de um arquivo, escolha um dos **Arquivos**.
1. Para fazer download os logs da execução de teste, em **Logs**, escolha **Fazer download de logs**.
1. Para fazer download de uma captura de tela, escolha uma captura de tela **Capturas de tela**.
Para obter mais informações sobre como fazer download de artefatos em um ambiente de teste personalizado, consulte [Baixar artefatos em um ambiente de teste personalizado](using-artifacts-custom.md).
## Baixar artefatos (AWS CLI)
Você pode usar o AWS CLI para listar seus artefatos de execução de teste.
**Topics**
+ [Etapa 1: obter os nomes do recurso da Amazon (ARN)](#artifacts-cli-step1)
+ [Etapa 2: listar os artefatos](#artifacts-cli-step2)
+ [Etapa 3: fazer download dos artefatos](#artifacts-cli-step3)
### Etapa 1: obter os nomes do recurso da Amazon (ARN)
Você pode listar os artefatos por execução, trabalho, conjunto de testes ou teste. Você precisa do ARN correspondente. Esta tabela mostra o ARN de entrada para cada um dos comandos da AWS CLI lista:
| AWS CLI Comando de lista | ARN obrigatório |
| --- | --- |
| list-projects | Este comando retorna todos os projetos e não exige um ARN. |
| list-runs | project |
| list-jobs | run |
| list-suites | job |
| list-tests | suite |
Por exemplo, para encontrar um ARN de teste, execute **list-tests** usando o ARN do pacote de teste como um parâmetro de entrada.
Exemplo:
```
aws devicefarm list-tests –-arn arn:MyTestSuiteARN
```
A resposta inclui um ARN de teste para cada um no pacote de testes.
```
{
"tests": [
{
"status": "COMPLETED",
"name": "Tests.FixturesTest.testExample",
"created": 1537563725.116,
"deviceMinutes": {
"unmetered": 0.0,
"total": 1.89,
"metered": 1.89
},
"result": "PASSED",
"message": "testExample passed",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:test:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 1,
"errored": 0,
"total": 1
}
}
]
}
```
### Etapa 2: listar os artefatos
O comando AWS CLI [list-artifacts](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-artifacts.html) retorna uma lista de artefatos, como arquivos, capturas de tela e registros. Cada artefato tem um URL para que você possa fazer download do arquivo.
+ Chame **list-artifacts** especificando uma execução, um trabalho, um pacote de testes ou um ARN de teste. Especifique um tipo de ARQUIVO, LOG ou CAPTURA DE TELA.
Este exemplo retorna um URL de download para cada artefato disponível para um teste individual:
```
aws devicefarm list-artifacts --arn arn:MyTestARN --type "FILE"
```
A resposta contém um URL de download de cada artefato.
```
{
"artifacts": [
{
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"extension": "txt",
"type": "APPIUM_JAVA_OUTPUT",
"name": "Appium Java Output",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:artifact:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
}
]
}
```
### Etapa 3: fazer download dos artefatos
+ Faça download do artefato usando o URL da etapa anterior. Este exemplo usa **curl** para fazer download de um arquivo de saída Android Appium Java:
```
curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyArtifactName.txt
```
## Baixar artefatos (API)
O [ListArtifacts](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)método Device Farm API retorna uma lista de artefatos, como arquivos, capturas de tela e registros. Cada artefato tem um URL para que você possa fazer download do arquivo.
# Baixar artefatos em um ambiente de teste personalizado
Em um ambiente de teste personalizado, o Device Farm reúne artefatos como relatórios personalizados, arquivos de log e imagens. Esses artefatos estão disponíveis para cada dispositivo na execução de teste.
Você pode fazer download esses artefatos criados durante a execução de teste:
**Saída da especificação de teste**
A saída da execução dos comandos no arquivo YAML da especificação de teste.
**Artefatos do cliente**
Um arquivo compactado que contém os artefatos da execução de teste. Ele está pré-configurado na seção **artifacts:** do arquivo YAML da especificação de teste.
**Script de shell da especificação de teste**
Um arquivo de script de shell intermediário criado pelo arquivo YAML. Como é usado na execução de teste, o arquivo de script de shell pode ser usado para depurar o arquivo YAML.
**Arquivo de especificação de teste**
O arquivo YAML usado na execução de teste.
Para obter mais informações, consulte [Baixar artefatos no Device Farm](artifacts.md).
![\[Hierarquia de operações do Device Farm em um ambiente de teste personalizado\]](http://docs.aws.amazon.com/pt_br/devicefarm/latest/developerguide/images/hierarchy.png)