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 uma nova execução.

5. Na página Escolher aplicação, escolha Aplicação móvel ou Aplicação Web.

   

6. Faça upload do arquivo do aplicativo. Você também pode arrastar e soltar o arquivo ou escolher um upload recente. Se você estiver fazendo upload de um aplicativo iOS, certifique-se de escolher iOS device (Dispositivo iOS), e não um simulador.

7. (Opcional) Em Run name (Nome da execução), insira um nome. Por padrão, o Device Farm usa o nome do arquivo da aplicação.

8. Escolha Próximo.

9. Na página Configurar, escolha um dos pacotes de testes disponíveis.

   nota

   Se não tiver testes disponíveis, escolha Integrado: fuzzing para executar um pacote integrado padrão de testes. Se escolher Integrado: fuzzing e as caixas Contagem de eventos, Limite de eventos e Propagação aleatória forem exibidas, você poderá alterar ou manter os valores.

   Para obter mais informações sobre pacotes de testes, consulte Trabalhando com tipos de teste no AWS Device Farm.

10. Se você não tiver escolhido Integrado: fuzzing, selecione Escolher arquivo e, em seguida, navegue até o arquivo que contém os testes e escolha-o.

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.

12. Se você estiver usando o ambiente de teste padrão, vá para a etapa 13. Se você estiver usando um ambiente de teste personalizado com o YAML arquivo de especificação de teste padrão, vá para a etapa 13.

    1. Se você quiser editar a especificação de teste padrão em um ambiente de teste personalizado, escolha Editar para atualizar a YAML especificação padrão.

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

13. Se você quiser configurar as opções de captura de dados de desempenho ou gravação de vídeo, escolha Configuração avançada.

    1. Selecione Habilitar a gravação de vídeo para gravar vídeos durante o teste.

    2. Selecione Habilitar a captura de dados de performance da aplicação para capturar dados de desempenho do dispositivo.

    nota

    Se você tiver dispositivos privados, Configuração específica para dispositivos privados também será exibida.

14. Escolha Próximo.

15. Na página Selecionar dispositivos, execute uma das seguintes ações:

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

    Para obter mais informações, consulte Suporte a dispositivos no AWS Device Farm.

16. Escolha Próximo.

17. Na página Specify device state (Especificar estado do dispositivo):

    • 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 o Wi-FiGPS, Bluetooth ou NFC está ativado durante a execução, ao lado de 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.

18. Escolha Próximo.

19. Na página Analisar e iniciar a execução, você pode especificar o tempo limite de execução do seu teste. Se você estiver usando um número ilimitado de slots de testes, confirme se Executar em slots não medidos está selecionado.

20. Insira um valor ou use a barra deslizante para alterar o tempo limite de execução. Para obter mais informações, consulte Defina o tempo limite de execução para execuções de teste no AWS Device Farm.

21. Escolha Confirmar e iniciar 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 para associar à sua execução de teste e anote o nome de recurso da Amazon (ARN).

1. Para visualizar seus pools de dispositivos, executelist-device-pools, especificando seu projetoARN.

   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 pool de dispositivos e anote seuARN.

   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 upload do seu aplicativo ARN e um arquivo pré-assinadoURL.

   {
       "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 upload do aplicativo ARN e o pré-assinadoURL.

3. Faça upload do arquivo do seu aplicativo usando o Amazon S3 pré-assinado. URL 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 no Guia do usuário do Amazon Simple Storage Service.

4. Para verificar o status do upload do seu aplicativo, execute get-upload e especifique o ARN do 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 upload pré-assinado do Amazon S3URL, 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 upload do seu pacote de teste ARN e um pacote pré-assinadoURL.

   {
       "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 upload ARN do pacote de teste e o pré-assinadoURL.

3. Faça upload do arquivo do pacote de scripts de teste usando o Amazon S3 pré-assinado. URL 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 upload ARN do pacote de teste na 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 upload ARN para sua especificação de teste padrão, execute list-uploads e especifique seu projetoARN.

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

3. Para baixar sua especificação de teste padrão, execute get-upload e especifique o uploadARN.

   Exemplo:

   aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN

   A resposta contém um pré-assinado URL onde você pode baixar sua 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 sua especificação de teste personalizada, executecreate-upload, especificando o nome da especificação de teste, o tipo da especificação de teste e o projeto. ARN

   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 upload ARN e a URL pré-assinatura da especificação de teste:

   {
       "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 para o upload da especificação de teste e a URL pré-assinada.

8. Faça o upload do seu arquivo de especificação de teste usando o Amazon URL S3 pré-assinado. Este exemplo é usado curl para fazer upload de 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"

9. Para verificar o status do upload da especificação de teste, execute get-upload e especifique o uploadARN.

   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 sua especificação de teste personalizada, executeupdate-upload, especificando o upload ARN 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

• Executeschedule-run, especificando as informações do projetoARN, do pool de dispositivosARN, do upload ARN do aplicativo e do pacote de teste.

  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 uma execução ARN que você pode usar para verificar o status da execução do 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 get-run comando e especifique a execuçãoARN:

  aws devicefarm get-run --arn arn:aws:devicefarm:us-west-2:111122223333:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE