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.
# 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.
## Utiliser des applications pour tester avec votre session Appium
Il existe plusieurs manières de fournir une application à utiliser avec votre session Appium :
+ Téléchargez une application sur Device Farm et installez-la dans la session.
+ Spécifiez une URL HTTPS ou une URI Amazon S3 comme `appium:app` fonctionnalité.
+ Référencez une application déjà installée par son nom de package (`appium:appPackage`sous Android ou `appium:bundleId` iOS).
+ Testez une application Web en spécifiant `browserName` sa fonctionnalité (`Chrome`sur Android, `Safari` sur iOS).
Les [limites de taille standard des applications](limits.md#file-limits) (4 Go) s'appliquent à toutes les sources d'applications.
**Note**
Device Farm ne prend pas en charge la transmission d'un chemin de système de fichiers local `appium:app` lors d'une session d'accès à distance.
### Téléchargement, installation et utilisation d'applications
Pour utiliser une application téléchargée avec votre session Appium, procédez comme suit :
1.
**Téléchargez et installez votre application**
Il existe deux manières de télécharger et d'installer une application sur l'appareil testé :
+ Incluez l'ARN de l'application dans votre [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateRemoteAccessSession.html)demande. L'application est automatiquement installée sur l'appareil au démarrage de la session. Vous pouvez également inclure une application auxiliaire ARNs, qui sera installée en même temps que l'application principale.
+ Installez l'application pendant une session active à 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 ou en la téléchargeant via la console Device Farm. Cela vous permet de modifier l'application en cours de test sans créer de nouvelle session.
1.
**Utiliser l'application installée**
Une fois installée, l'application est automatiquement injectée en tant que `appium:app` fonctionnalité par défaut pour toutes les sessions Appium suivantes. Si vous avez inclus des applications auxiliaires, elles sont définies comme `appium:otherApps` fonctionnalité.
Par exemple, si vous créez une session d'accès à distance en utilisant `com.aws.devicefarm.sample` comme application et `com.aws.devicefarm.other.sample` comme l'une de vos applications auxiliaires, 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\"]",
...
}
}
}
```
Si vous installez une nouvelle application pendant la session, elle remplace la `appium:app` fonctionnalité actuelle. Si l'application précédemment installée possède un nom de package distinct, elle reste sur l'appareil et passe à la `appium:otherApps` fonctionnalité.
Par exemple, si vous l'utilisez initialement `com.aws.devicefarm.sample` lors de la création de votre session d'accès à distance, puis que vous l'installez `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\"]",
...
}
}
}
```
**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).
### Utilisation d'une URL HTTPS
Vous pouvez spécifier une URL HTTPS accessible au public comme fonctionnalité `appium:app` souhaitée lors de la création d'une session Appium. L'URL doit pointer directement vers un fichier d'application téléchargeable (par exemple, un `.ipa` fichier `.apk` or). Device Farm télécharge l'application à partir de l'URL spécifiée et l'installe sur l'appareil testé.
**Important**
Seul le protocole HTTPS URLs est pris en charge. Les protocoles HTTP simples URLs sont rejetés.
Par exemple, la demande de création de session Appium suivante télécharge une application à partir d'une URL HTTPS :
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "https://example.com/path/to/MyApp.apk"
}
]
}
}
```
### Utilisation d'un URI Amazon S3
Vous pouvez spécifier un URI Amazon S3 (par exemple,`s3://my-bucket/path/to/MyApp.ipa`) comme fonctionnalité `appium:app` souhaitée lors de la création d'une session Appium. Device Farm télécharge l'application depuis l'emplacement S3 spécifié et l'installe sur l'appareil testé.
Pour utiliser un URI S3, les conditions suivantes doivent être remplies :
+ La session d'accès à distance doit être démarrée à partir d'un projet pour lequel un [rôle d'exécution IAM](custom-test-environments-iam-roles.md) est configuré.
+ Le rôle d'exécution IAM doit avoir une durée de session maximale d'au moins 150 minutes, car le rôle est assumé pendant la durée de la session d'accès à distance.
+ Le rôle d'exécution IAM doit être autorisé à appeler `s3:GetObject` l'objet S3 spécifié dans l'URI. Nous recommandons également d'accorder une `s3:HeadObject` autorisation sur le même objet, afin de permettre à Device Farm de valider l'existence de l'objet avant de tenter le téléchargement.
Par exemple, la demande de création de session Appium suivante télécharge une application à partir d'un URI S3 :
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:app": "s3://my-test-bucket/apps/MyApp.ipa"
}
]
}
}
```
Voici un exemple de politique d'autorisation IAM qui accorde l'accès recommandé pour le téléchargement d'une application depuis Amazon S3, y compris l'`s3:HeadObject`autorisation facultative. Pour plus d'informations sur la configuration des rôles d'exécution IAM, consultez[Accédez aux ressources AWS à l'aide d'un rôle d'exécution IAM](custom-test-environments-iam-roles.md).
**Example**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:HeadObject"
],
"Resource": "arn:aws:s3:::my-test-bucket/apps/*"
}
]
}
```
### Utilisation d'une application déjà installée
Si l'application que vous souhaitez tester est déjà installée sur l'appareil, vous pouvez la référencer directement par son nom de package au lieu de la télécharger. Utilisez les `appium:appActivity` fonctionnalités `appium:appPackage` et sur Android ou sur iOS. `appium:bundleId`
Par exemple, la demande de création de session Appium suivante lance une application Android déjà installée :
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:appPackage": "com.example.myapp",
"appium:appActivity": "com.example.myapp.MainActivity"
}
]
}
}
```
Sur iOS, utilisez `appium:bundleId` plutôt :
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"appium:bundleId": "com.example.myapp"
}
]
}
}
```
### Tester une application Web
Pour tester une application Web, spécifiez la `browserName` fonctionnalité dans votre demande de création de session Appium. `Chrome`À utiliser sur les appareils Android ou `Safari` iOS.
Par exemple, la requête suivante ouvre Chrome sur un appareil Android :
```
{
"capabilities":
{
"alwaysMatch": {},
"firstMatch":
[
{
"browserName": "Chrome"
}
]
}
}
```
## 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 :
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\+ à l'aide de Node 18\+.*
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\# ]
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
```
------