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á.
# 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).