Usando aplicativos para testar com sua sessão do Appium Como usar o endpoint Appium

Interagindo com o dispositivo usando o Appium

Depois de criar uma sessão de acesso remoto, o dispositivo estará disponível para testes do Appium. Durante toda a sessão de acesso remoto, você pode executar quantas sessões do Appium quiser no dispositivo, sem limites de quais clientes você usa. Por exemplo, você pode começar executando um teste usando o código Appium local do seu IDE e, em seguida, passar a usar o Appium Inspector para solucionar quaisquer problemas encontrados. A sessão pode durar até 150 minutos, no entanto, se não houver atividade por mais de 5 minutos (por meio do console interativo ou do endpoint Appium), a sessão expirará.

Usando aplicativos para testar com sua sessão do Appium

O Device Farm permite que você use seus aplicativos como parte da solicitação de criação da sessão de acesso remoto ou instale aplicativos durante a própria sessão de acesso remoto. Esses aplicativos são instalados automaticamente no dispositivo em teste e são injetados como recursos padrão para qualquer solicitação de sessão do Appium. Ao criar uma sessão de acesso remoto, você tem a opção de passar um ARN do aplicativo, que será usado por padrão como o appium:app recurso para todas as sessões subsequentes do Appium, bem como o aplicativo auxiliar ARNs, que será usado como o recurso. appium:otherApps

Por exemplo, se você criar uma sessão de acesso remoto usando um aplicativo com.aws.devicefarm.sample como seu aplicativo e com.aws.devicefarm.other.sample como um de seus aplicativos auxiliares, ao criar uma sessão do Appium, ela terá recursos semelhantes aos seguintes:


{
    "value":
    {
        "sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
        "capabilities":
        {
            "app": "/tmp/com.aws.devicefarm.sample.apk",
            "otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
            ...
        }
    }
}

Durante sua sessão, você pode instalar aplicativos adicionais (no console ou usando a InstallToRemoteAccessSessionAPI). Eles substituirão todos os aplicativos existentes usados anteriormente como appium:app recurso. Se esses aplicativos usados anteriormente tiverem um nome de pacote distinto, eles permanecerão no dispositivo e serão usados como parte do appium:otherApps recurso.

Por exemplo, se você usar inicialmente um aplicativo com.aws.devicefarm.sample ao criar sua sessão de acesso remoto, mas depois instalar um novo aplicativo chamado com.aws.devicefarm.other.sample durante a sessão, suas sessões do Appium terão recursos semelhantes aos seguintes:


{
    "value":
    {
        "sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
        "capabilities":
        {
            "app": "/tmp/com.aws.devicefarm.other.sample.apk",
            "otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
            ...
        }
    }
}

Se preferir, você pode especificar explicitamente os recursos do seu aplicativo usando o nome do aplicativo (usando os appium:bundleId recursos appium:appPackage ou para Android e iOS, respectivamente).

Se você estiver testando um aplicativo web, especifique a browserName capacidade da sua solicitação de criação de sessão do Appium. O Chrome navegador está disponível em todos os dispositivos Android e o Safari navegador está disponível em todos os dispositivos iOS.

O Device Farm não suporta a transmissão de uma URL remota ou um caminho do sistema de arquivos local appium:app durante uma sessão de acesso remoto. Faça upload de aplicativos para o Device Farm e, em vez disso, inclua-os na sessão.

nota

Para obter mais informações sobre o upload automático de aplicativos como parte de sua sessão de acesso remoto, consulte Como automatizar o upload de aplicativos.

Como usar o endpoint Appium

Aqui estão as etapas para acessar o endpoint Appium da sessão a partir do console AWS CLI, do e. AWS SDKs Essas etapas incluem como começar a executar testes usando várias estruturas de teste de clientes da Appium:

Console

Abra sua página de sessão de acesso remoto em seu navegador da web:
Para executar uma sessão usando o Appium Inspector, faça o seguinte:
1. Clique no botão Configurar sessão do Appium
2. Siga as instruções na página sobre como iniciar uma sessão usando o Appium Inspector.
Para executar um teste Appium a partir do seu IDE local, faça o seguinte:
1. Clique no ícone “copiar” ao lado do texto URL do endpoint Appium
2. Cole esse URL em seu código Appium local onde quer que você especifique atualmente seu endereço remoto ou executor de comando. Para exemplos específicos do idioma, clique em uma das guias nesta janela de exemplo para o idioma de sua escolha.

AWS CLI

Primeiro, verifique se sua versão da AWS CLI é baixando e up-to-date instalando a versão mais recente.

Importante

O campo de endpoint do Appium não está disponível em versões mais antigas da AWS CLI.

Quando sua sessão estiver em execução, o URL do endpoint do Appium estará disponível por meio de um campo nomeado remoteDriverEndpoint na resposta a uma chamada para a API: GetRemoteAccessSession


$ aws devicefarm get-remote-access-session \
    --arn "arn:aws:devicefarm:us-west-2:123456789876:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"

Isso mostrará uma saída como a seguinte:


{
    "remoteAccessSession": {
        "arn": "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000",
        "name": "Google Pixel 8",
        "status": "RUNNING",
        "endpoints": {
            "remoteDriverEndpoint": "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234...",
        ...
}

Você pode usar essa URL em seu código Appium local onde quer que você especifique atualmente seu endereço remoto ou executor de comando. Para exemplos específicos do idioma, clique em uma das guias nesta janela de exemplo para o idioma de sua escolha.

Para ver um exemplo de como interagir com o endpoint diretamente da linha de comando, você pode usar a ferramenta de linha de comando curl para chamar um endpoint diretamente: WebDriver


$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"

Isso mostrará uma saída como a seguinte:


{
    "value":
    {
        "ready": true,
        "message": "The server is ready to accept new connections",
        "build":
        {
            "version": "2.5.1"
        }
    }
}

Python


# To get the URL
import sys
import boto3
from botocore.exceptions import ClientError

def get_appium_endpoint() -> str:
    session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
    device_farm_client = boto3.client("devicefarm", region_name="us-west-2")

    try:
        resp = device_farm_client.get_remote_access_session(arn=session_arn)
    except ClientError as exc:
        sys.exit(f"Failed to call Device Farm: {exc}")

    remote_access_session = resp.get("remoteAccessSession", {})
    endpoints = remote_access_session.get("endpoints", {})
    endpoint = endpoints.get("remoteDriverEndpoint")

    if not endpoint:
        sys.exit("Device Farm response did not include endpoints.remoteDriverEndpoint")

    return endpoint

# To use the URL
from appium import webdriver
from appium.options.android import UiAutomator2Options

opts = UiAutomator2Options()
driver = webdriver.Remote(get_appium_endpoint(), options=opts)
# ...
driver.quit()

Java

Observação: este exemplo usa o AWS SDK for Java v2 e é compatível com as versões 11 e superiores do JDK.


// To get the URL
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;

public class AppiumEndpointBuilder {
    public static String getAppiumEndpoint() throws Exception {
        String session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";

        try (DeviceFarmClient client = DeviceFarmClient.builder()
                .region(Region.US_WEST_2)
                .credentialsProvider(DefaultCredentialsProvider.create())
                .build()) {

            GetRemoteAccessSessionResponse resp = client.getRemoteAccessSession(
                    GetRemoteAccessSessionRequest.builder().arn(session_arn).build()
            );

            String endpoint = resp.remoteAccessSession().endpoints().remoteDriverEndpoint();
            if (endpoint == null || endpoint.isEmpty()) {
                throw new IllegalStateException("remoteDriverEndpoint missing from response");
            }
            return endpoint;
        }
    }
}

// To use the URL
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;

import java.net.URL;

public class ExampleTest {
    public static void main(String[] args) throws Exception {
        String endpoint = AppiumEndpointBuilder.getAppiumEndpoint();
        UiAutomator2Options options = new UiAutomator2Options();
        AndroidDriver driver = new AndroidDriver(new URL(endpoint), options);

        try {
            // ... your test ...
        } finally {
            driver.quit();
        }
    }
}

JavaScript

Observação: este exemplo usa AWS SDK para JavaScript v3 e WebDriverIO v8+ usando o Node 18+.


// To get the URL
import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm";

export async function getAppiumEndpoint() {
  const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";

  const client = new DeviceFarmClient({ region: "us-west-2" });
  const resp = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));

  const endpoint = resp?.remoteAccessSession?.endpoints?.remoteDriverEndpoint;
  if (!endpoint) throw new Error("remoteDriverEndpoint missing from response");
  return endpoint;
}

// To use the URL with WebdriverIO
import { remote } from "webdriverio";

(async () => {
  const endpoint = await getAppiumEndpoint();
  const u = new URL(endpoint);

  const driver = await remote({
    protocol: u.protocol.replace(":", ""),
    hostname: u.hostname,
    port: u.port ? Number(u.port) : (u.protocol === "https:" ? 443 : 80),
    path: u.pathname + u.search,
    capabilities: {
      platformName: "Android",
      "appium:automationName": "UiAutomator2",
      // ...other caps...
    },
  });

  try {
    // ... your test ...
  } finally {
    await driver.deleteSession();
  }
})();

C#


// To get the URL
using System;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;

public static class AppiumEndpointBuilder
{
    public static async Task<string> GetAppiumEndpointAsync()
    {
        var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";

        var config = new AmazonDeviceFarmConfig
        {
            RegionEndpoint = RegionEndpoint.USWest2
        };
        using var client = new AmazonDeviceFarmClient(config);

        var resp = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
        var endpoint = resp?.RemoteAccessSession?.Endpoints?.RemoteDriverEndpoint;

        if (string.IsNullOrWhiteSpace(endpoint))
            throw new InvalidOperationException("RemoteDriverEndpoint missing from response");

        return endpoint;
    }
}

// To use the URL
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;

class Example
{
    static async Task Main()
    {
        var endpoint = await AppiumEndpointBuilder.GetAppiumEndpointAsync();

        var options = new AppiumOptions();
        options.PlatformName = "Android";
        options.AutomationName = "UiAutomator2";

        using var driver = new AndroidDriver(new Uri(endpoint), options);
        try
        {
            // ... your test ...
        }
        finally
        {
            driver.Quit();
        }
    }
}

Ruby


# To get the URL
require 'aws-sdk-devicefarm'

def get_appium_endpoint
  session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"

  client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
  resp = client.get_remote_access_session(arn: session_arn)
  endpoint = resp.remote_access_session.endpoints.remote_driver_endpoint
  raise "remote_driver_endpoint missing from response" if endpoint.nil? || endpoint.empty?
  endpoint
end

# To use the URL
require 'appium_lib_core'

endpoint = get_appium_endpoint
opts = {
  server_url: endpoint,
  capabilities: {
    'platformName' => 'Android',
    'appium:automationName' => 'UiAutomator2'
  }
}

driver = Appium::Core.for(opts).start_driver
begin
  # ... your test ...
ensure
  driver.quit
end

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

Começando com os testes do Appium

Revisando os registros do servidor Appium