Criar uma execução de teste no Device Farm

1. Faça login no console do Device Farm em https://console.aws.amazon.com/devicefarm.

2. No painel de navegação, escolha Teste para dispositivos móveis e Projetos.

3. 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.

4. Abra o projeto e escolha Criar execução.

5. (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.

6. (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.

7. 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.

8. 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.

9. 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.

10. 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.

11. 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.

12. Se você estiver usando um ambiente de teste personalizado, poderá fazer o seguinte:

    1. 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.

    2. Se você fizer alterações na especificação de teste, escolha Salvar como novo para atualizar.

13. 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 seu próprio grupo de dispositivos para executar os testes, siga as instruções em Criar um grupo de dispositivos e retorne para 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 Farm.

14. (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 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.

15. Na parte inferior da página, escolha Criar execução para agendar a execução.

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.

   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
           }
       ]
   }

2. Escolha um projeto a ser associado à execução de teste e anote seu nome de recurso da Amazon (ARN).

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"
           }
       ]
   }

2. 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).

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"
       }
   }

2. Anote o ARN de upload do aplicativo e o URL pré-assinado.

3. 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 Uploading objects using presigned URLs no Guia do Usuário do Amazon Simple Storage Service.

4. 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}"
       }
   }

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"
       }    
   }

2. Anote o ARN de upload do pacote de testes e o URL pré-assinado.

3. 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"

4. 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}"
       }
   }

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"
               }
           }
       ]
   }

2. Escolha a especificação de teste padrão na lista. Anote o ARN do upload.

3. 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.

4. 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

5. 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.

6. 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"
       }
   }

7. Anote o ARN do upload da especificação de teste e o URL pré-assinado.

8. Faça upload do arquivo de especificações de teste usando o URL pré-assinado do Amazon S3. Este exemplo usa curl para fazer upload de uma especificação de teste do Appium Java TestNG:

   curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"

9. 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 update-upload.

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 schedule-run.

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