Utilizzo delle app per i test con la sessione Appium Come usare l'endpoint Appium

Interazione con il dispositivo tramite Appium

Dopo aver creato una sessione di accesso remoto, il dispositivo sarà disponibile per i test di Appium. Per l'intera durata della sessione di accesso remoto, puoi eseguire tutte le sessioni Appium che desideri sul dispositivo, senza limiti ai client che utilizzi. Ad esempio, puoi iniziare eseguendo un test utilizzando il codice Appium locale dal tuo IDE, quindi passare all'utilizzo di Appium Inspector per risolvere eventuali problemi riscontrati. La sessione può durare fino a 150 minuti, tuttavia, se non vi è alcuna attività per più di 5 minuti (tramite la console interattiva o tramite l'endpoint Appium), la sessione scadrà.

Utilizzo delle app per i test con la sessione Appium

Device Farm ti consente di utilizzare le tue app come parte della richiesta di creazione di una sessione di accesso remoto o di installare app durante la sessione di accesso remoto stessa. Queste app vengono installate automaticamente sul dispositivo in esame e vengono inserite come funzionalità predefinite per qualsiasi richiesta di sessione Appium. Quando crei una sessione di accesso remoto, hai la possibilità di passare un'app ARN, che verrà utilizzata di default come appium:app funzionalità per tutte le sessioni Appium successive, nonché un'app ausiliaria ARNs, che verrà utilizzata come funzionalità. appium:otherApps

Ad esempio, se crei una sessione di accesso remoto utilizzando un'app com.aws.devicefarm.sample come app e com.aws.devicefarm.other.sample come una delle tue app ausiliarie, quando vai a creare una sessione Appium, avrà funzionalità simili alle seguenti:


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

Durante la sessione, puoi installare app aggiuntive (all'interno della console o utilizzando l'InstallToRemoteAccessSessionAPI). Queste sostituiranno tutte le app esistenti utilizzate in precedenza come appium:app funzionalità. Se le app utilizzate in precedenza hanno un nome di pacchetto distinto, rimarranno sul dispositivo e verranno utilizzate come parte della appium:otherApps funzionalità.

Ad esempio, se inizialmente utilizzi un'app com.aws.devicefarm.sample durante la creazione della sessione di accesso remoto, ma poi installi una nuova app denominata com.aws.devicefarm.other.sample durante la sessione, le sessioni di Appium avranno funzionalità simili alle seguenti:


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

Se preferisci, puoi specificare in modo esplicito le funzionalità della tua app utilizzando il nome dell'app (utilizzando le appium:bundleId funzionalità appium:appPackage o rispettivamente per Android e iOS).

Se stai testando un'app web, specifica la browserName funzionalità per la tua richiesta di creazione di sessioni Appium. Il Chrome browser è disponibile su tutti i dispositivi Android e il Safari browser è disponibile su tutti i dispositivi iOS.

Device Farm non supporta il passaggio di un URL remoto o di un percorso di file system locale appium:app durante una sessione di accesso remoto. Carica le app su Device Farm e includile invece nella sessione.

Nota

Per ulteriori informazioni sul caricamento automatico delle app come parte della sessione di accesso remoto, consulta la sezione Automatizzazione dei caricamenti delle app.

Come usare l'endpoint Appium

Ecco i passaggi per accedere all'endpoint Appium della sessione dalla console, dal e dal. AWS CLI AWS SDKs Questi passaggi includono come iniziare a eseguire i test utilizzando vari framework di test dei client Appium:

Console

Apri la pagina della sessione di accesso remoto nel tuo browser web:
Per eseguire una sessione utilizzando Appium Inspector, procedi come segue:
1. Fai clic sul pulsante Setup Appium session
2. Segui le istruzioni sulla pagina per iniziare una sessione utilizzando Appium Inspector.
Per eseguire un test Appium dal tuo IDE locale, procedi come segue:
1. Fai clic sull'icona «copia» accanto al testo Appium endpoint URL
2. Incolla questo URL nel codice Appium locale ovunque tu specifichi attualmente il tuo indirizzo remoto o l'esecutore di comandi. Per esempi specifici della lingua, fai clic su una delle schede in questa finestra di esempio per la lingua che preferisci.

AWS CLI

Innanzitutto, verifica che la tua versione CLI di AWS sia disponibile up-to-date scaricando e installando la versione più recente.

Importante

Il campo endpoint Appium non è disponibile nelle versioni precedenti dell'interfaccia a riga di comando di AWS.

Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato remoteDriverEndpoint nella risposta a una chiamata all'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"

Questo mostrerà un output come il seguente:


{
    "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...",
        ...
}

È possibile utilizzare questo URL nel codice Appium locale ovunque si specifichi attualmente l'indirizzo remoto o l'esecutore di comandi. Per esempi specifici della lingua, fai clic su una delle schede in questa finestra di esempio per la lingua che preferisci.

Per un esempio di come interagire con l'endpoint direttamente dalla riga di comando, puoi usare lo strumento da riga di comando curl per chiamare direttamente un endpoint: WebDriver


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

Questo mostrerà un output come il seguente:


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

Nota: questo esempio utilizza l' AWS SDK for Java v2 ed è compatibile con le versioni JDK 11 e successive.


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

Nota: questo esempio utilizza AWS SDK per JavaScript v3 e WebDriveRio v8+ utilizzando Node 18+.

Una volta che la sessione sarà attiva e funzionante, l'URL dell'endpoint Appium sarà disponibile tramite un campo denominato nella risposta a una chiamata remoteDriverEndpoint all'API: GetRemoteAccessSession


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Iniziare con i test di Appium

Revisione dei log del server Appium