Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tests d'Appium dans AWS Device Farm
Au cours d'une session d'accès à distance, vous pouvez exécuter des tests Appium depuis votre environnement local, en ciblant l'appareil de la session à l'aide d'un point de terminaison Appium géré. Avec un point de terminaison Appium, vous pouvez développer, tester et exécuter du code Appium avec un feedback rapide et une itération rapide. Cette approche des tests **côté client** offre la flexibilité de se connecter à un appareil Device Farm depuis n'importe quel environnement client Appium de votre choix.
Pour compléter les tests côté client, Device Farm prend également en charge l'exécution de tests sur l'infrastructure gérée par le service, appelés exécution côté **serveur**. [Dans cette approche, vous pouvez télécharger votre application et vos tests sur le service, puis exécuter les tests en parallèle sur plusieurs appareils à l'aide d'hôtes de test gérés par le service.](custom-test-environments-hosts.md) Cette approche s'adapte bien aux tests indépendants sur de nombreux appareils, ainsi qu'aux tests dans le contexte d'un CI/CD pipeline.
Pour en savoir plus sur l'exécution côté serveur, consultez. [Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md)
**Topics**
+ [Qu'est-ce qu'un terminal Appium ?](#appium-endpoint-what-is)
+ [Commencer à tester Appium](appium-endpoint-getting-started.md)
+ [Interaction avec l'appareil à l'aide d'Appium](appium-endpoint-interaction.md)
+ [Consulter les journaux de votre serveur Appium](appium-endpoint-server-logs.md)
+ [Fonctionnalités et commandes Appium prises en charge](appium-endpoint-supported-caps-and-commands.md)
## Qu'est-ce qu'un terminal Appium ?
[Appium](https://appium.io/) est un framework de test de logiciels open source populaire permettant de tester des applications Web natives, hybrides et mobiles sur différents appareils, y compris les téléphones mobiles et les tablettes, pour iOS et Android. Il permet aux développeurs et aux ingénieurs QA (assurance qualité) d'écrire des scripts capables de contrôler à distance un appareil, de simuler les interactions avec les utilisateurs et de vérifier que l'application testée se comporte comme prévu. Appium interagit avec les applications du point de vue de l'utilisateur final, ce qui permet aux testeurs de développer des tests simulant la manière dont les utilisateurs réels utiliseront l'application pour leurs tests.
Appium est basé sur le modèle client-serveur, dans lequel un client local demande à un serveur Appium (local ou distant) de commander un appareil en son nom. Le serveur Appium gère un pilote pour communiquer avec l'appareil, tel que le [UIAutomator2 pilote](https://github.com/appium/appium-uiautomator2-driver/) pour Android ou le [XCUITest pilote](https://appium.github.io/appium-xcuitest-driver/9.10/) pour iOS. Toutes les commandes sont WebDriver conformes aux normes du [W3C](https://www.w3.org/TR/webdriver2/) relatives au contrôle d'un appareil.
Le point de terminaison Appium de Device Farm expose l'URL du serveur Appium pour l'appareil dans votre session d'accès à distance. L'URL du point de terminaison Appium sera spécifique à cet appareil dans cette session et restera valide pendant toute la durée de la session, ce qui vous permettra d'itérer sur le même appareil sans temps de configuration supplémentaire. Pour plus d'informations sur l'accès à distance, veuillez consulter[Accès à distance dans AWS Device Farm](remote-access.md).
# Commencer à tester Appium
Pour la plupart des utilisateurs d'Appium, l'utilisation de Device Farm pour les tests Appium ne nécessite que des modifications mineures de votre configuration de test existante.
De manière générale, l'utilisation de Device Farm pour les tests Appium côté client comporte trois étapes :
1. Tout d'abord, vous devez [créer une session d'accès à distance](how-to-create-session.md) pour tester un appareil Device Farm. Vous pouvez inclure vos applications dans le cadre de votre demande d'accès à distance ou installer des applications après le début de la session.
1. Une fois la session en cours d'exécution, vous pouvez [copier l'URL du point de terminaison Appium](appium-endpoint-interaction.md) et l'utiliser soit via un outil autonome (comme Appium [Inspector](https://github.com/appium/appium-inspector)), soit à partir de votre code de test Appium dans votre IDE. L'URL sera valide pendant toute la durée de la session d'accès à distance.
1. Enfin, une fois que votre test Appium a commencé, vous pouvez [consulter les journaux de votre serveur Appium](appium-endpoint-server-logs.md) en direct pendant l'exécution du test, parallèlement au flux vidéo de votre appareil.
# Interaction avec l'appareil à l'aide d'Appium
Une fois que vous avez [créé une session d'accès à distance](how-to-create-session.md), l'appareil sera disponible pour les tests Appium. Pendant toute la durée de la session d'accès à distance, vous pouvez exécuter autant de sessions Appium que vous le souhaitez sur l'appareil, sans aucune limite quant aux clients que vous utilisez. Par exemple, vous pouvez commencer par exécuter un test en utilisant votre code Appium local à partir de votre IDE, puis passer à l'utilisation d'Appium Inspector pour résoudre les problèmes que vous rencontrez. La session peut durer jusqu'à [150 minutes](limits.md#service-limits), mais s'il n'y a aucune activité pendant plus de 5 minutes (via la console interactive ou via le point de terminaison Appium), la session expirera.
## Utilisation d'applications pour les tests avec votre session Appium
Device Farm vous permet d'utiliser vos applications dans le cadre de votre demande de création de session d'accès à distance ou d'installer des applications pendant la session d'accès à distance elle-même. Ces applications sont automatiquement installées sur l'appareil testé et sont injectées en tant que fonctionnalités par défaut pour toute demande de session Appium. Lorsque vous créez une session d'accès à distance, vous avez la possibilité de transmettre un ARN d'application, qui sera utilisé par défaut comme `appium:app` fonctionnalité pour toutes les sessions Appium suivantes, ainsi qu'une application auxiliaire ARNs, qui sera utilisée comme fonctionnalité. `appium:otherApps`
Par exemple, si vous créez une session d'accès à distance en utilisant une application `com.aws.devicefarm.sample` `com.aws.devicefarm.other.sample` comme application et comme application auxiliaire, lorsque vous créerez une session Appium, elle disposera de fonctionnalités similaires aux suivantes :
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
...
}
}
}
```
Au cours de votre session, vous pouvez installer des applications supplémentaires (soit dans la console, soit à l'aide de l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html)API). Elles remplaceront toutes les applications existantes précédemment utilisées comme `appium:app` fonctionnalité. Si les applications précédemment utilisées ont un nom de package distinct, elles resteront sur l'appareil et seront utilisées dans le cadre de la `appium:otherApps` fonctionnalité.
Par exemple, si vous utilisez initialement une application `com.aws.devicefarm.sample` lors de la création de votre session d'accès à distance, mais que vous installez ensuite une nouvelle application nommée `com.aws.devicefarm.other.sample` pendant la session, vos sessions Appium auront des fonctionnalités similaires aux suivantes :
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.other.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
...
}
}
}
```
Si vous préférez, vous pouvez spécifier explicitement les fonctionnalités de votre application en utilisant le nom de l'application (en utilisant les `appium:bundleId` fonctionnalités `appium:appPackage` ou pour Android et iOS respectivement).
Si vous testez une application Web, spécifiez la `browserName` capacité de votre demande de création de session Appium. Le `Chrome` navigateur est disponible sur tous les appareils Android et le `Safari` navigateur est disponible sur tous les appareils iOS.
Device Farm ne prend pas en charge la transmission d'une URL distante ou d'un chemin de système de fichiers local au `appium:app` cours d'une session d'accès à distance. Téléchargez des applications sur Device Farm et incluez-les plutôt dans la session.
**Note**
Pour plus d'informations sur le téléchargement automatique d'applications dans le cadre de votre session d'accès à distance, consultez la section [Automatisation des téléchargements d'applications](api-ref.md#upload-example).
## Comment utiliser le point de terminaison Appium
Voici les étapes pour accéder au point de terminaison Appium de la session depuis la console, le AWS CLI, et le. AWS SDKs Ces étapes incluent comment commencer à exécuter des tests à l'aide de divers frameworks de test client Appium :
------
#### [ Console ]
1. Ouvrez la page de votre session d'accès à distance dans votre navigateur Web :
![\[\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint.png)
1. Pour exécuter une session à l'aide d'Appium Inspector, procédez comme suit :
1. Cliquez sur le bouton **Configurer la session Appium**
1. Suivez les instructions de la page pour savoir comment démarrer une session à l'aide d'Appium Inspector.
1. Pour exécuter un test Appium depuis votre IDE local, procédez comme suit :
1. Cliquez sur l'icône « copier » à côté du texte URL du point de **terminaison Appium**
1. Collez cette URL dans votre code Appium local là où vous spécifiez actuellement votre adresse distante ou votre exécuteur de commande. Pour des exemples spécifiques à une langue, veuillez cliquer sur l'un des onglets de cette fenêtre d'exemple correspondant à la langue de votre choix.
------
#### [ AWS CLI ]
Tout d'abord, vérifiez que votre version de l'AWS CLI est up-to-date correcte en [téléchargeant et en installant la dernière version](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Important**
Le champ de point de terminaison Appium n'est pas disponible dans les anciennes versions de l'AWS CLI.
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
$ 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"
```
Cela affichera des résultats tels que les suivants :
```
{
"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...",
...
}
```
Vous pouvez utiliser cette URL dans votre code Appium local partout où vous spécifiez actuellement votre adresse distante ou votre exécuteur de commande. Pour des exemples spécifiques à une langue, veuillez cliquer sur l'un des onglets de cette fenêtre d'exemple correspondant à la langue de votre choix.
Pour un exemple d'interaction avec le point de terminaison directement depuis la ligne de commande, vous pouvez utiliser l'[outil de ligne de commande curl](https://curl.se/) pour appeler directement un WebDriver point de terminaison :
```
$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"
```
Cela affichera des résultats tels que les suivants :
```
{
"value":
{
"ready": true,
"message": "The server is ready to accept new connections",
"build":
{
"version": "2.5.1"
}
}
}
```
------
#### [ Python ]
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
# 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 ]
*Remarque : cet exemple utilise le AWS SDK pour Java v2 et est compatible avec les versions 11 et supérieures du JDK.*
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
// 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 ]
*Remarque : cet exemple utilise le AWS SDK pour JavaScript v3 et WebDriverIO v8\$1 à l'aide de Node 18\$1.*
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
// 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 ]
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
// 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 ]
Une fois votre session ouverte, l'URL du point de terminaison Appium sera disponible via un champ nommé `remoteDriverEndpoint` dans la réponse à un appel à l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API :
```
# 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
```
------
# Consulter les journaux de votre serveur Appium
Une fois que vous avez [démarré une session Appium](appium-endpoint-interaction.md), vous pouvez consulter les journaux du serveur Appium en direct sur la console Device Farm ou les télécharger une fois la session d'accès à distance terminée. Voici les instructions pour ce faire :
------
#### [ Console ]
1. Dans la console Device Farm, ouvrez la session d'accès à distance pour votre appareil.
1. Démarrez une session de point de terminaison Appium avec l'appareil depuis votre IDE local ou Appium Inspector
1. Ensuite, le journal du serveur Appium apparaîtra à côté de l'appareil sur la page de session d'accès à distance, avec les « informations de session » disponibles au bas de la page sous l'appareil :
![\[\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint-logs.gif)
------
#### [ AWS CLI ]
*Remarque : cet exemple utilise l'[outil de ligne de commande `curl`](https://curl.se/) pour extraire le journal de Device Farm.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour télécharger le journal du serveur 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
```
Cela affichera des résultats tels que les suivants au cours de la session :
```
{
"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..."
}
]
}
```
Et ce qui suit une fois la session terminée :
```
{
"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..."
```
Cela affichera des résultats tels que les suivants :
```
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 ]
*Remarque : cet exemple utilise le `requests` package tiers pour télécharger le journal, ainsi que le AWS SDK pour Python`boto3`.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour récupérer l'URL du journal du serveur Appium, puis la télécharger.
```
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()
```
Cela affichera des résultats tels que les suivants :
```
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 ]
*Remarque : cet exemple utilise le AWS SDK pour Java v2 `HttpClient` et pour télécharger le journal. Il est compatible avec les versions 11 et supérieures du JDK.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour récupérer l'URL du journal du serveur Appium, puis la télécharger.
```
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());
}
}
}
```
Cela affichera des résultats tels que les suivants :
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ JavaScript ]
*Remarque : cet exemple utilise le AWS SDK pour JavaScript (v3) et Node 18\$1 `fetch` pour télécharger le journal.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour récupérer l'URL du journal du serveur Appium, puis la télécharger.
```
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);
```
Cela affichera des résultats tels que les suivants :
```
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 ]
*Remarque : cet exemple utilise le AWS SDK pour .NET `HttpClient` et permet de télécharger le journal.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour récupérer l'URL du journal du serveur Appium, puis la télécharger.
```
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)}");
}
}
```
Cela affichera des résultats tels que les suivants :
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ Ruby ]
*Remarque : cet exemple utilise le AWS SDK pour Ruby `Net::HTTP` et permet de télécharger le journal.*
Pendant ou après la session, vous pouvez utiliser l'[https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API de Device Farm pour récupérer l'URL du journal du serveur Appium, puis la télécharger.
```
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)}"
```
Cela affichera des résultats tels que les suivants :
```
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' ] }
```
------
# Fonctionnalités et commandes Appium prises en charge
Le point de terminaison Appium de Device Farm prend en charge la plupart des commandes et fonctionnalités souhaitées que vous utilisez sur les appareils locaux, à quelques exceptions près. Les listes suivantes indiquent les fonctionnalités et les commandes actuellement non prises en charge. Si vos tests ne peuvent pas s'exécuter comme prévu en raison d'une fonctionnalité limitée, veuillez ouvrir un dossier d'assistance pour obtenir des conseils supplémentaires.
## Fonctionnalités prises en charge
Lorsque vous créez une session Appium sur Device Farm, nous vous recommandons de disposer d'un ensemble distinct de fonctionnalités qui excluent les fonctionnalités spécifiques à votre appareil local. Sur Device Farm, la création de session peut échouer si certaines fonctionnalités non prises en charge sont définies. Cela inclut des fonctionnalités spécifiques à l'appareil telles que `udid` et. `platformVersion` En outre, certaines fonctionnalités liées à ChromeDriver Android et WebDriverAgent iOS ne sont pas prises en charge, de même que celles qui ne sont prises en charge que sur les émulateurs et les simulateurs.
## Commandes prises en charge
La plupart des commandes Appium qui s'exécutent correctement sur de vrais appareils Android et iOS s'exécuteront comme prévu sur Device Farm, avec les exclusions suivantes :
### Commandes de l'appareil Appium () `/appium/device`
+ `install_app`
+ `finger_print`
+ `send_sms`
+ `gsm_call`
+ `gsm_signal`
+ `gsm_voice`
+ `power_ac`
+ `power_capacity`
+ `network_speed`
+ `shake`
### Méthodes et scripts d'exécution 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`