Configure CodePipeline para usar seus testes do Device Farm

Tutorial: crie um pipeline que crie e teste seu aplicativo Android com AWS Device Farm

Você pode usar AWS CodePipeline para configurar um fluxo de integração contínua no qual seu aplicativo é criado e testado sempre que uma confirmação é enviada. Este tutorial mostra como criar e configurar um pipeline para criar e testar seu aplicativo Android com o código-fonte em um GitHub repositório. O pipeline detecta a chegada de um novo GitHub commit e, em seguida, o usa CodeBuildpara criar o aplicativo e o Device Farm para testá-lo.

Importante

Muitas das ações que você adiciona ao pipeline nesse procedimento envolvem AWS recursos que você precisa criar antes de criar o pipeline. AWS os recursos para suas ações de origem sempre devem ser criados na mesma AWS região em que você cria seu pipeline. Por exemplo, se você criar seu pipeline na região Leste dos EUA (Ohio), seu CodeCommit repositório deverá estar na região Leste dos EUA (Ohio).

Você pode adicionar ações entre regiões ao criar seu pipeline. AWS os recursos para ações entre regiões devem estar na mesma AWS região em que você planeja executar a ação. Para ter mais informações, consulte Adicionar uma ação entre regiões no CodePipeline.

É possível experimentar isso usando a aplicação Android e as definições de teste existentes ou usar a aplicação de exemplo e as definições de teste fornecidas pelo Device Farm.

nota

Antes de começar

Entre no AWS Device Farm console e escolha Criar um novo projeto.
Selecione o projeto. No navegador, copie o URL do novo projeto. O URL contém o ID do projeto.
Copie e retenha esse ID de projeto. Você pode usá-lo ao criar o pipeline no CodePipeline.

Este é um exemplo de URL para um projeto. Para extrair o ID do projeto, copie o valor depois de projects/. Neste exemplo, o ID do produto é eec4905f-98f8-40aa-9afc-4c1cfexample.
```
https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
```

Configure CodePipeline para usar seus testes do Device Farm

Adicione e confirme um arquivo chamado buildspec.ymlna raiz do código do seu aplicativo e envie-o para o seu repositório. CodeBuild usa esse arquivo para executar comandos e acessar os artefatos necessários para criar seu aplicativo.
```
version: 0.2

phases:
  build:
    commands:
      - chmod +x ./gradlew
      - ./gradlew assembleDebug
artifacts:
  files:
     - './android/app/build/outputs/**/*.apk'
  discard-paths: yes
```
(Opcional) Se você usa o Calabash ou o Appium para testar seu aplicativo, adicione o arquivo de definição de teste ao seu repositório. Em uma etapa posterior, será possível configurar o Device Farm para usar as definições na execução do pacote de teste.

Se você usar os testes integrados do Device Farm, poderá ignorar esta etapa.
Para criar seu pipeline e adicionar um estágio de origem, faça o seguinte:
1. Faça login no AWS Management Console e abra o CodePipeline console em https://console.aws.amazon.com/codepipeline/.
2. Selecione Criar pipeline. Na página Step 1: Choose pipeline settings (Etapa 1: selecionar configurações do pipeline), em Pipeline name (Nome do pipeline), insira o nome do seu pipeline.
3. Em Tipo de pipeline, selecione V1 para os fins deste tutorial. Também é possível selecionar V2; no entanto, observe que os tipos de pipeline diferem em características e preços. Para ter mais informações, consulte Tipos de Pipeline.
4. Em Service role (Função de serviço), deixe New service role (Nova função de serviço) selecionado e não altere Role name (Nome da função). Você também pode optar por usar uma função de serviço existente se tiver criado uma.
  nota
  Se você usa uma função CodePipeline de serviço criada antes de julho de 2018, precisa adicionar permissões para o Device Farm. Para fazer isso, abra o console do IAM, localize o perfil e, depois, adicione as seguintes permissões à política do perfil. Para ter mais informações, consulte Adicionar permissões à função de serviço do CodePipeline.
```
{
     "Effect": "Allow",
     "Action": [
        "devicefarm:ListProjects",
        "devicefarm:ListDevicePools",
        "devicefarm:GetRun",
        "devicefarm:GetUpload",
        "devicefarm:CreateUpload",
        "devicefarm:ScheduleRun"
     ],
     "Resource": "*"
}
```
5. Deixe as configurações em Advanced settings (Configurações avançadas) como padrão e escolha Next (Próximo).
6. Na página Etapa 2: Adicionar estágio de origem, em Provedor de origem, escolha GitHub.
7. Em Conexão, escolha uma conexão existente ou crie uma nova. Para criar ou gerenciar uma conexão para sua ação GitHub de origem, consulteGitHub conexões.
8. Em Repository (Repositório), selecione o repositório de origem.
9. Em Branch (Ramificação), selecione a ramificação que você deseja usar.
10. Deixe os padrões restantes para a ação de origem. Escolha Próximo.
Em Add build stage (Adicionar estágio de compilação), adicione um estágio de compilação:
1. Em Build provider (Provedor de compilação), escolha AWS CodeBuild. Permita que Region (Região) seja definida para a região do pipeline.
2. Escolha Criar projeto.
3. Em Project name (Nome do projeto), insira um nome para esse projeto de compilação.
4. Em Environment image (Imagem do ambiente), escolha Managed image (Imagem gerenciada). Para Operating system, selecione Ubuntu.
5. Em Runtime (Tempo de execução), selecione Standard (Padrão). Em Imagem, selecione aws/codebuild/standard:5.0.
  
  CodeBuild usa essa imagem do sistema operacional, que tem o Android Studio instalado, para criar seu aplicativo.
6. Em Função de serviço, escolha sua função CodeBuild de serviço existente ou crie uma nova.
7. Para Build specifications (Especificações da compilação), escolha Use a buildspec file (Usar um arquivo buildspec).
8. Escolha Continuar para CodePipeline. Isso retorna ao CodePipeline console e cria um CodeBuild projeto que usa o buildspec.yml em seu repositório para configuração. O projeto de criação usa um perfil de serviço para gerenciar permissões de AWS service (Serviço da AWS) . Essa etapa pode levar alguns minutos.
9. Escolha Próximo.
Na página Step 4: Add deploy stage (Etapa 4: adicionar estágio de implantação), escolha Skip deploy stage (Ignorar estágio de implantação) e aceite a mensagem de aviso ao clicar novamente em Skip (Ignorar). Escolha Próximo.
Em Step 5: Review (Etapa 5: revisar), escolha Create pipeline (Criar pipeline). Você deve ver um diagrama que mostra a origem e os estágios de compilação.
Adicione uma ação de teste do Device Farm ao pipeline:
1. No canto superior direito, escolha Edit (Editar).
2. Na parte inferior do diagrama, escolha + Add stage (+ Adicionar estágio). Em Nome do estágio, insira um nome, como Test.
3. Escolha + Add action group (Adicionar grupo de ação).
4. Em Nome da ação, insira um nome.
5. Em Provedor de ação, selecione AWS Device Farm. Permita que Region (Região) seja definida para a região do pipeline.
6. Em Input artifacts (Artefatos de entrada), selecione o artefato de entrada que corresponde ao artefato de saída do estágio que vem antes do estágio de teste, como BuildArtifact.
  
  No AWS CodePipeline console, você pode encontrar o nome do artefato de saída para cada estágio passando o mouse sobre o ícone de informações no diagrama do pipeline. Se seu pipeline testar seu aplicativo diretamente do estágio de origem, escolha SourceArtifact. Se o pipeline incluir um estágio de construção, escolha BuildArtifact.
7. Em ProjectId, insira o ID do projeto do Device Farm. Use as etapas no início deste tutorial para recuperar o ID do projeto.
8. Em DevicePoolArn, insira o ARN do pool de dispositivos. Para obter os ARNs do pool de dispositivos disponíveis para o projeto, incluindo o ARN dos principais dispositivos, use a AWS CLI para inserir o seguinte comando:
```
aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
```
9. Em AppType, insira Android.
  
  Veja a seguir uma lista de valores válidos para AppType:
  - iOS
  - Android
  - Web
10. Em App (Aplicativo), insira o caminho do pacote do aplicativo compilado. O caminho é relativo à raiz do artefato de entrada do estágio de teste. Normalmente, esse caminho é semelhante a app-release.apk.
11. Em TestType, insira seu tipo de teste e, em Teste, insira o caminho do arquivo de definição do teste. O caminho é relativo à raiz do artefato de entrada para o teste.
  
  Veja a seguir uma lista de valores válidos para TestType:
  - APPIUM_JAVA_JUNIT
  - APPIUM_JAVA_TESTING
  - APPIUM_NODE
  - APPIUM_RUBY
  - APPIUM_PYTHON
  - APPIUM_WEB_JAVA_JUNIT
  - APPIUM_WEB_JAVA_TESTING
  - APPIUM_WEB_NODE
  - APPIUM_WEB_RUBY
  - APPIUM_WEB_PYTHON
  - BUILTIN_FUZZ
  - INSTRUMENTATION
  - XCTEST
  - XCTEST_UI
  nota
  Os nós de ambiente personalizados não são compatíveis.
12. Nos campos restantes, forneça a configuração que seja apropriada para seu teste e tipo de aplicativo.
13. (Opcional) Em Advanced (Avançado), forneça informações de configuração para a execução do teste.
14. Escolha Salvar.
15. No estágio que está editando, escolha Done (Concluído). No painel do AWS CodePipeline , escolha Save (Salvar) e selecione Save (Salvar) na mensagem de aviso.
16. Para enviar suas alterações e iniciar uma compilação do pipeline, selecione Liberar alteração e, depois, Liberar.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutorial: Configurar uma regra do para receber notificações de e-mail de alterações de estado do pipeline

Tutorial: Testar uma aplicação iOS com AWS Device Farm