Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Test di Appium in AWS Device Farm
Durante una sessione di accesso remoto, puoi eseguire test Appium dal tuo ambiente locale, indirizzando il dispositivo della sessione utilizzando un endpoint Appium gestito. Con un endpoint Appium, sei in grado di sviluppare, testare ed eseguire codice Appium con feedback rapidi e iterazioni rapide. Questo approccio ai test **lato client** offre la flessibilità necessaria per connettersi a un dispositivo Device Farm da qualsiasi ambiente client Appium di vostra scelta.
A complemento dei test lato client, Device Farm supporta anche l'esecuzione di test sull'infrastruttura gestita dal servizio, denominati esecuzione lato **server**. [Con questo approccio, puoi caricare l'app e i test sul servizio, quindi eseguire i test in parallelo su più dispositivi utilizzando host di test gestiti dal servizio.](custom-test-environments-hosts.md) Questo approccio si adatta bene ai test su molti dispositivi in modo indipendente, nonché ai test nel contesto di una pipeline. CI/CD
Per ulteriori informazioni sull'esecuzione lato server, consulta. [Framework di test e test integrati in AWS Device Farm](test-types.md)
**Topics**
+ [Cos'è un endpoint Appium?](#appium-endpoint-what-is)
+ [Guida introduttiva ai test di Appium](appium-endpoint-getting-started.md)
+ [Interazione con il dispositivo tramite Appium](appium-endpoint-interaction.md)
+ [Revisione dei log del server Appium](appium-endpoint-server-logs.md)
+ [Funzionalità e comandi Appium supportati](appium-endpoint-supported-caps-and-commands.md)
## Cos'è un endpoint Appium?
[Appium](https://appium.io/) è un popolare framework di test software open source per testare applicazioni Web native, ibride e mobili su diversi dispositivi, inclusi telefoni cellulari e tablet, sia per iOS che per Android. Consente agli sviluppatori e agli ingegneri del QA (Quality Assurance) di scrivere script in grado di controllare in remoto un dispositivo, simulare le interazioni degli utenti e verificare che l'applicazione in test si comporti come previsto. Appium interagisce con le app dal punto di vista dell'utente finale, consentendo ai tester di sviluppare test che simulano il modo in cui gli utenti reali utilizzeranno l'app per i loro test.
Appium è basato sul modello client-server, in cui un client locale richiede a un server Appium (locale o remoto) di comandare un dispositivo per proprio conto. Il server Appium gestisce un driver per la comunicazione con il dispositivo, ad esempio il [UIAutomator2 driver](https://github.com/appium/appium-uiautomator2-driver/) per Android o il driver [XCUITest per](https://appium.github.io/appium-xcuitest-driver/9.10/) iOS. Tutti i comandi seguono gli WebDriver standard [W3C](https://www.w3.org/TR/webdriver2/) per il controllo di un dispositivo.
L'endpoint Appium di Device Farm espone un URL del server Appium per il dispositivo nella sessione di accesso remoto. L'URL dell'endpoint Appium sarà specifico per quel dispositivo in quella sessione e rimarrà valido per tutta la durata della sessione, consentendoti di eseguire iterazioni sullo stesso dispositivo senza tempi di configurazione aggiuntivi. Per ulteriori informazioni sull'accesso remoto, consulta. [Accesso remoto in AWS Device Farm](remote-access.md)
# Guida introduttiva ai test di Appium
Per la maggior parte degli utenti di Appium, l'utilizzo di Device Farm per i test di Appium richiede solo piccole modifiche alla configurazione di test esistente.
Ad alto livello, ci sono tre passaggi per utilizzare Device Farm per i test Appium lato client:
1. Innanzitutto, è necessario [creare una sessione di accesso remoto](how-to-create-session.md) per testare un dispositivo Device Farm. Puoi includere le app come parte della richiesta di accesso remoto o installare le app dopo l'inizio della sessione.
1. Una volta che la sessione è in esecuzione, puoi [copiare l'URL dell'endpoint Appium](appium-endpoint-interaction.md) e utilizzarlo tramite uno strumento autonomo (come Appium [Inspector](https://github.com/appium/appium-inspector)) o dal codice di test Appium nel tuo IDE. L'URL sarà valido per tutta la durata della sessione di accesso remoto.
1. Infine, una volta avviato il test Appium, puoi [rivedere i log del server Appium in tempo reale durante l'esecuzione del test insieme al flusso video del tuo](appium-endpoint-server-logs.md) dispositivo.
# Interazione con il dispositivo tramite Appium
Dopo aver [creato una sessione di accesso remoto](how-to-create-session.md), 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](limits.md#service-limits), 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'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html)API). 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](api-ref.md#upload-example).
## 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 ]
1. Apri la pagina della sessione di accesso remoto nel tuo browser web:
![\[\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint.png)
1. Per eseguire una sessione utilizzando Appium Inspector, procedi come segue:
1. **Fai clic sul pulsante Setup Appium session**
1. Segui le istruzioni sulla pagina per iniziare una sessione utilizzando Appium Inspector.
1. Per eseguire un test Appium dal tuo IDE locale, procedi come segue:
1. Fai clic sull'icona «copia» accanto al testo **Appium** endpoint URL
1. 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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
$ 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](https://curl.se/) 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 ]
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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# 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.*
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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// 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\$1 utilizzando Node 18\$1.*
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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// 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\$1 ]
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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// 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 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 ]
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: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# 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
```
------
# Revisione dei log del server Appium
Dopo aver [avviato una sessione Appium](appium-endpoint-interaction.md), puoi visualizzare i log del server Appium in tempo reale nella console Device Farm o scaricarli al termine della sessione di accesso remoto. Ecco le istruzioni per farlo:
------
#### [ Console ]
1. Nella console Device Farm, apri la sessione di accesso remoto per il tuo dispositivo.
1. Avvia una sessione di endpoint Appium con il dispositivo dall'IDE locale o da Appium Inspector
1. Quindi, il registro del server Appium verrà visualizzato accanto al dispositivo nella pagina della sessione di accesso remoto, con le «informazioni sulla sessione» disponibili nella parte inferiore della pagina sotto il dispositivo:
![\[\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint-logs.gif)
------
#### [ AWS CLI ]
*Nota: questo esempio utilizza lo [strumento da riga di comando `curl`](https://curl.se/) per estrarre il registro da Device Farm.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per scaricare il log del server Appium.
```
$ aws devicefarm list-artifacts \
--type FILE \
--arn arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000
```
Questo mostrerà un output come il seguente durante la sessione:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "AppiumServerLogOutput",
"type": "APPIUM_SERVER_LOG_OUTPUT",
"extension": "",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
E quanto segue al termine della sessione:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "Appium Server Output",
"type": "APPIUM_SERVER_OUTPUT",
"extension": "log",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
```
$ curl "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1',
info Appium allowInsecure:
info Appium [ 'execute_driver_script',
info Appium 'session_discovery',
info Appium 'perf_record',
info Appium 'adb_shell',
info Appium 'chromedriver_autodownload',
info Appium 'get_server_logs' ],
info Appium keepAliveTimeout: 0,
info Appium logNoColors: true,
info Appium logTimestamp: true,
info Appium longStacktrace: true,
info Appium sessionOverride: true,
info Appium strictCaps: true,
info Appium useDrivers: [ 'uiautomator' ] }
```
------
#### [ Python ]
*Nota: questo esempio utilizza il `requests` pacchetto di terze parti per scaricare il registro, oltre all' AWS SDK per Python`boto3`.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per recuperare l'URL del registro del server Appium, quindi scaricarlo.
```
import pathlib
import requests
import boto3
def download_appium_log():
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
client = boto3.client("devicefarm", region_name="us-west-2")
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = None
while True:
kwargs = {"arn": session_arn, "type": "FILE"}
if token:
kwargs["nextToken"] = token
resp = client.list_artifacts(**kwargs)
artifacts.extend(resp.get("artifacts", []))
token = resp.get("nextToken")
if not token:
break
if not artifacts:
raise RuntimeError("No artifacts found in this session")
# Filter strictly to Appium server logs
allowed = {"APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"}
filtered = [a for a in artifacts if a.get("type") in allowed]
if not filtered:
raise RuntimeError("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)")
# Prefer the final 'OUTPUT' log, else the live 'LOG_OUTPUT'
chosen = (next((a for a in filtered if a.get("type") == "APPIUM_SERVER_OUTPUT"), None)
or next((a for a in filtered if a.get("type") == "APPIUM_SERVER_LOG_OUTPUT"), None))
url = chosen["url"]
ext = chosen.get("extension") or "log"
out = pathlib.Path(f"./appium_server_log.{ext}")
# 2) Download the artifact
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(out, "wb") as fh:
for chunk in r.iter_content(chunk_size=1024 * 1024):
if chunk:
fh.write(chunk)
print(f"Saved Appium server log to: {out.resolve()}")
download_appium_log()
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ Java ]
*Nota: questo esempio utilizza l' AWS SDK for Java v2 `HttpClient` e per scaricare il registro ed è compatibile con le versioni JDK 11 e successive.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per recuperare l'URL del registro del server Appium e scaricarlo.
```
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.Artifact;
import software.amazon.awssdk.services.devicefarm.model.ArtifactCategory;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsRequest;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsResponse;
public class AppiumLogDownloader {
public static void main(String[] args) throws Exception {
String sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.build()) {
// 1) List artifacts for the session (FILE artifacts) with pagination
List all = new ArrayList<>();
String token = null;
do {
ListArtifactsRequest.Builder b = ListArtifactsRequest.builder()
.arn(sessionArn)
.type(ArtifactCategory.FILE);
if (token != null) b.nextToken(token);
ListArtifactsResponse page = client.listArtifacts(b.build());
all.addAll(page.artifacts());
token = page.nextToken();
} while (token != null && !token.isBlank());
// Filter strictly to Appium logs
List filtered = all.stream()
.filter(a -> {
String t = a.typeAsString();
return "APPIUM_SERVER_OUTPUT".equals(t) || "APPIUM_SERVER_LOG_OUTPUT".equals(t);
})
.toList();
if (filtered.isEmpty()) {
throw new RuntimeException("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
Artifact chosen = filtered.stream()
.filter(a -> "APPIUM_SERVER_OUTPUT".equals(a.typeAsString()))
.findFirst()
.orElseGet(() -> filtered.stream()
.filter(a -> "APPIUM_SERVER_LOG_OUTPUT".equals(a.typeAsString()))
.findFirst()
.get());
String url = chosen.url();
String ext = (chosen.extension() == null || chosen.extension().isBlank()) ? "log" : chosen.extension();
Path out = Path.of("appium_server_log." + ext);
// 2) Download the artifact with HttpClient
HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.build();
HttpRequest get = HttpRequest.newBuilder(URI.create(url))
.timeout(Duration.ofMinutes(5))
.GET()
.build();
HttpResponse resp = http.send(get, HttpResponse.BodyHandlers.ofFile(out));
if (resp.statusCode() / 100 != 2) {
throw new IOException("Failed to download log, HTTP " + resp.statusCode());
}
System.out.println("Saved Appium server log to: " + out.toAbsolutePath());
}
}
}
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ JavaScript ]
*Nota: questo esempio utilizza AWS SDK for JavaScript (v3) e Node 18\$1 `fetch` per scaricare il registro.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per recuperare l'URL del registro del server Appium e scaricarlo.
```
import { DeviceFarmClient, ListArtifactsCommand } from "@aws-sdk/client-device-farm";
import { createWriteStream } from "fs";
import { pipeline } from "stream";
import { promisify } from "util";
const pipe = promisify(pipeline);
const client = new DeviceFarmClient({ region: "us-west-2" });
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
// 1) List artifacts for the session (FILE artifacts), handling pagination
const artifacts = [];
let nextToken;
do {
const page = await client.send(new ListArtifactsCommand({
arn: sessionArn,
type: "FILE",
nextToken
}));
artifacts.push(...(page.artifacts ?? []));
nextToken = page.nextToken;
} while (nextToken);
if (!artifacts.length) throw new Error("No artifacts found");
// Strict filter to Appium logs
const filtered = (artifacts ?? []).filter(a =>
a.type === "APPIUM_SERVER_OUTPUT" || a.type === "APPIUM_SERVER_LOG_OUTPUT"
);
if (!filtered.length) {
throw new Error("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
const chosen =
filtered.find(a => a.type === "APPIUM_SERVER_OUTPUT") ??
filtered.find(a => a.type === "APPIUM_SERVER_LOG_OUTPUT");
const url = chosen.url;
const ext = chosen.extension || "log";
const outPath = `./appium_server_log.${ext}`;
// 2) Download the artifact
const resp = await fetch(url);
if (!resp.ok) {
throw new Error(`Failed to download log: ${resp.status} ${await resp.text().catch(()=>"")}`);
}
await pipe(resp.body, createWriteStream(outPath));
console.log("Saved Appium server log to:", outPath);
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ C\$1 ]
*Nota: questo esempio utilizza l' AWS SDK for .NET `HttpClient` e per scaricare il registro.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per recuperare l'URL del registro del server Appium e scaricarlo.
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using System.Linq;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
class AppiumLogDownloader
{
static async Task Main()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
using var client = new AmazonDeviceFarmClient(RegionEndpoint.USWest2);
// 1) List artifacts for the session (FILE artifacts), handling pagination
var all = new List();
string? token = null;
do
{
var page = await client.ListArtifactsAsync(new ListArtifactsRequest
{
Arn = sessionArn,
Type = ArtifactCategory.FILE,
NextToken = token
});
if (page.Artifacts != null) all.AddRange(page.Artifacts);
token = page.NextToken;
} while (!string.IsNullOrEmpty(token));
if (all.Count == 0)
throw new Exception("No artifacts found");
// Strict filter to Appium logs
var filtered = all.Where(a =>
a.Type == "APPIUM_SERVER_OUTPUT" || a.Type == "APPIUM_SERVER_LOG_OUTPUT").ToList();
if (filtered.Count == 0)
throw new Exception("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
// Prefer OUTPUT; else LOG_OUTPUT
var chosen = filtered.FirstOrDefault(a => a.Type == "APPIUM_SERVER_OUTPUT")
?? filtered.First(a => a.Type == "APPIUM_SERVER_LOG_OUTPUT");
var url = chosen.Url;
var ext = string.IsNullOrWhiteSpace(chosen.Extension) ? "log" : chosen.Extension;
var outPath = $"./appium_server_log.{ext}";
// 2) Download the artifact
using var http = new HttpClient();
using var resp = await http.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
resp.EnsureSuccessStatusCode();
await using (var fs = File.Create(outPath))
{
await resp.Content.CopyToAsync(fs);
}
Console.WriteLine($"Saved Appium server log to: {Path.GetFullPath(outPath)}");
}
}
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ Ruby ]
*Nota: questo esempio utilizza l' AWS SDK for `Net::HTTP` Ruby e per scaricare il registro.*
Durante o dopo la sessione, puoi utilizzare l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API di Device Farm per recuperare l'URL del registro del server Appium e scaricarlo.
```
require "aws-sdk-devicefarm"
require "net/http"
require "uri"
client = Aws::DeviceFarm::Client.new(region: "us-west-2")
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = nil
loop do
page = client.list_artifacts(arn: session_arn, type: "FILE", next_token: token)
artifacts.concat(page.artifacts || [])
token = page.next_token
break if token.nil? || token.empty?
end
raise "No artifacts found" if artifacts.empty?
# Strict filter to Appium logs
filtered = (artifacts || []).select { |a| ["APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"].include?(a.type) }
raise "No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)." if filtered.empty?
# Prefer OUTPUT; else LOG_OUTPUT
chosen = filtered.find { |a| a.type == "APPIUM_SERVER_OUTPUT" } ||
filtered.find { |a| a.type == "APPIUM_SERVER_LOG_OUTPUT" }
url = chosen.url
ext = (chosen.extension && !chosen.extension.empty?) ? chosen.extension : "log"
out_path = "./appium_server_log.#{ext}"
# 2) Download the artifact
uri = URI.parse(url)
Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https")) do |http|
req = Net::HTTP::Get.new(uri)
http.request(req) do |resp|
raise "Failed GET: #{resp.code} #{resp.body}" unless resp.code.to_i / 100 == 2
File.open(out_path, "wb") { |f| resp.read_body { |chunk| f.write(chunk) } }
end
end
puts "Saved Appium server log to: #{File.expand_path(out_path)}"
```
Questo mostrerà un output come il seguente:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
# Funzionalità e comandi Appium supportati
L'endpoint Appium di Device Farm supporta la maggior parte degli stessi comandi e delle funzionalità desiderate che usi sui dispositivi locali, con alcune eccezioni. Gli elenchi seguenti mostrano quali funzionalità e comandi non sono attualmente supportati. Se i test non riescono a essere eseguiti come previsto a causa di una funzionalità limitata, apri una richiesta di assistenza per ulteriori informazioni.
## Funzionalità supportate
Quando crei una sessione Appium su Device Farm, ti consigliamo di disporre di un set distinto di funzionalità che escluda qualsiasi funzionalità specifica del tuo dispositivo locale. In Device Farm, la creazione della sessione potrebbe non riuscire se sono impostate alcune funzionalità non supportate. Ciò include funzionalità specifiche del dispositivo come e. `udid` `platformVersion` Inoltre, alcune funzionalità ChromeDriver relative ad Android e WebDriverAgent iOS non sono supportate, così come le funzionalità supportate solo su emulatori e simulatori.
## Comandi supportati
La maggior parte dei comandi Appium che vengono eseguiti correttamente su dispositivi Android e iOS reali verrà eseguita come previsto su Device Farm, con le seguenti esclusioni:
### Comandi del dispositivo Appium () `/appium/device`
+ `install_app`
+ `finger_print`
+ `send_sms`
+ `gsm_call`
+ `gsm_signal`
+ `gsm_voice`
+ `power_ac`
+ `power_capacity`
+ `network_speed`
+ `shake`
### Metodi e script di esecuzione di Appium () `/execute`
+ `installApp`
+ `execEmuConsoleCommand`
+ `fingerprint`
+ `gsmCall`
+ `gsmSignal`
+ `sendSms`
+ `gsmVoice`
+ `powerAC`
+ `powerCapacity`
+ `networkSpeed`
+ `sensorSet`
+ `injectEmulatorCameraImage`
+ `isGpsEnabled`
+ `shake`
+ `clearApp`
+ `clearKeychains`
+ `configureLocalization`
+ `enrollBiometric`
+ `getPasteboard`
+ `installXCTestBundle`
+ `listXCTestBundles`
+ `listXCTestsInTestBundle`
+ `runXCTest`
+ `sendBiometricMatch`
+ `setPasteboard`
+ `setPermission`
+ `startAudioRecording`
+ `startLogsBroadcast`
+ `startRecordingScreen`
+ `startScreenStreaming`
+ `startXCTestScreenRecording`
+ `stopAudioRecording`
+ `stopLogsBroadcast`
+ `stopRecordingScreen`
+ `stopScreenStreaming`
+ `stopXCTestScreenRecording`
+ `updateSafariPreferences`