Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Lingkungan pengujian khusus di AWS Device Farm
AWS Device Farm memungkinkan mengonfigurasi lingkungan khusus untuk pengujian otomatis (mode kustom), yang merupakan pendekatan yang disarankan untuk semua pengguna Device Farm. Untuk mempelajari lebih lanjut tentang lingkungan di Device Farm, lihat [Lingkungan pengujian](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-environments.html).
Manfaat Mode Kustom sebagai lawan dari Mode Standar meliputi:
+ **Eksekusi end-to-end pengujian lebih cepat**: Paket pengujian tidak diuraikan untuk mendeteksi setiap pengujian di suite, menghindari preprocessing/postprocessing overhead.
+ **Log langsung dan streaming video**: Log pengujian sisi klien dan video Anda disiarkan langsung saat menggunakan Mode Kustom. Fitur ini tidak tersedia dalam mode standar.
+ **Menangkap semua artefak**: Pada host dan perangkat, Mode Kustom memungkinkan Anda untuk menangkap semua artefak pengujian. Ini mungkin tidak dimungkinkan dalam mode standar.
+ **Lingkungan lokal yang lebih konsisten dan dapat direplikasi**: Ketika dalam Mode Standar, artefak akan disediakan untuk setiap pengujian individu secara terpisah, yang dapat bermanfaat dalam keadaan tertentu. Namun, lingkungan pengujian lokal Anda mungkin menyimpang dari konfigurasi asli karena Device Farm menangani setiap pengujian yang dijalankan secara berbeda.
Sebaliknya, Mode Kustom memungkinkan Anda membuat lingkungan eksekusi pengujian Device Farm secara konsisten sesuai dengan lingkungan pengujian lokal Anda.
Lingkungan khusus dikonfigurasi menggunakan file spesifikasi pengujian (spesifikasi pengujian) yang diformat YAML. Device Farm menyediakan file spesifikasi pengujian default untuk setiap jenis pengujian yang didukung yang dapat digunakan sebagaimana adanya atau disesuaikan; kustomisasi seperti filter pengujian atau file konfigurasi dapat ditambahkan ke spesifikasi pengujian. Spesifikasi pengujian yang diedit dapat disimpan untuk uji coba di masa mendatang.
Untuk informasi selengkapnya, lihat [Mengunggah Spesifikasi Uji Kustom Menggunakan dan. AWS CLI](https://docs.aws.amazon.com/devicefarm/latest/developerguide/how-to-create-test-run.html#how-to-create-test-run-cli-step5) [Membuat uji coba di Device Farm](how-to-create-test-run.md)
**Topics**
+ [Uji referensi spesifikasi dan sintaks](custom-test-environment-test-spec.md)
+ [Host untuk lingkungan pengujian khusus](custom-test-environments-hosts.md)
+ [Akses sumber daya AWS menggunakan Peran Eksekusi IAM](custom-test-environments-iam-roles.md)
+ [Variabel lingkungan untuk lingkungan pengujian khusus](custom-test-environment-variables.md)
+ [Praktik terbaik untuk eksekusi lingkungan pengujian kustom](custom-test-environments-best-practices.md)
+ [Memigrasi pengujian dari lingkungan pengujian standar ke kustom](custom-test-environment-migration.md)
+ [Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md)
# Uji referensi spesifikasi dan sintaks
Spesifikasi pengujian (spesifikasi pengujian) adalah file yang Anda gunakan untuk menentukan lingkungan pengujian kustom di Device Farm.
## Alur kerja spesifikasi uji
Spesifikasi pengujian Device Farm mengeksekusi fase dan perintahnya dalam urutan yang telah ditentukan sebelumnya, memungkinkan Anda menyesuaikan cara lingkungan Anda disiapkan dan dijalankan. Ketika setiap fase dijalankan, perintahnya dijalankan dalam urutan yang tercantum dalam file spesifikasi pengujian. Fase dieksekusi dalam urutan berikut
1. `install`- Di sinilah tindakan seperti mengunduh, menginstal, dan menyiapkan perkakas harus ditentukan.
1. `pre_test`- Di sinilah tindakan pra-tes seperti memulai proses latar belakang harus didefinisikan.
1. `test`- Di sinilah perintah yang memanggil pengujian Anda harus didefinisikan.
1. `post_test`- Di sinilah tugas akhir apa pun yang perlu dijalankan setelah pengujian Anda selesai harus ditentukan, seperti pembuatan laporan pengujian dan agregasi file artefak.
## Sintaks spesifikasi uji
Berikut ini adalah skema YAMAL untuk file spesifikasi pengujian
```
version: 0.1
android_test_host: "string"
ios_test_host: "string"
phases:
install:
commands:
- "string"
- "string"
pre_test:
commands:
- "string"
- "string"
test:
commands:
- "string"
- "string"
post_test:
commands:
- "string"
- "string"
artifacts:
- "string"
- "string"
```
** `version` **
*(Diperlukan, nomor)*
Mencerminkan versi spesifikasi pengujian yang didukung Device Farm. Nomor versi saat ini adalah` 0.1`.
** `android_test_host` **
*(Opsional, string)*
Host pengujian yang akan dipilih untuk uji coba dilakukan di perangkat Android. Bidang ini diperlukan untuk pengujian yang dijalankan di perangkat Android. Untuk informasi selengkapnya, lihat [Host uji yang tersedia untuk lingkungan pengujian khusus](custom-test-environments-hosts.md#custom-test-environments-hosts-available).
** `ios_test_host` **
*(Opsional, string)*
Host uji yang akan dipilih untuk uji coba dilakukan pada perangkat iOS. Bidang ini diperlukan untuk uji coba pada perangkat iOS dengan versi utama lebih besar dari 26. Untuk informasi selengkapnya, lihat [Host uji yang tersedia untuk lingkungan pengujian khusus](custom-test-environments-hosts.md#custom-test-environments-hosts-available).
** `phases` **
Bagian ini berisi kelompok perintah yang dijalankan selama uji coba, di mana setiap fase adalah opsional Nama fase uji yang diizinkan adalah:`install`,`pre_test`,`test`, dan`post_test`.
+ `install`- Dependensi default untuk kerangka pengujian yang didukung oleh Device Farm sudah diinstal. Fase ini berisi perintah tambahan, jika ada, bahwa Device Farm berjalan selama instalasi.
+ `pre_test`- Perintah, jika ada, dijalankan sebelum pengujian otomatis Anda.
+ `test`- Perintah dijalankan selama uji coba otomatis Anda dijalankan. Jika ada perintah dalam fase pengujian gagal (artinya mengembalikan kode keluar bukan nol), pengujian ditandai sebagai gagal
+ `post_test`- Perintah, jika ada, dijalankan setelah uji coba otomatis Anda dijalankan. Ini akan dieksekusi apakah tes Anda dalam `test` fase berhasil atau gagal.
** `commands` **
*(Opsional, Daftar [string])*
Daftar string untuk dieksekusi sebagai perintah shell selama fase.
** `artifacts` **
*(Opsional, Daftar [string])*
Device Farm mengumpulkan artefak seperti laporan kustom, file log, dan gambar dari lokasi yang ditentukan di sini. Karakter wildcard tidak didukung sebagai bagian dari lokasi artefak, jadi Anda harus menentukan jalur yang valid untuk setiap lokasi.
Artefak pengujian ini tersedia untuk setiap perangkat dalam uji coba Anda. Untuk informasi tentang mengambil artefak pengujian Anda, lihat. [Mengunduh artefak di lingkungan pengujian khusus](using-artifacts-custom.md)
**penting**
Spesifikasi pengujian harus diformat sebagai file YAMM yang valid. Jika indentasi atau spasi dalam spesifikasi pengujian Anda tidak valid, uji coba Anda bisa gagal. Tab tidak diizinkan dalam file YAMM. Anda dapat menggunakan validator YAMM untuk menguji apakah spesifikasi pengujian Anda adalah file YAMM yang valid. Untuk informasi selengkapnya, lihat situs [web YAMM](http://yaml.org/spec/1.2/spec.html).
## Contoh spesifikasi uji
Contoh berikut menunjukkan spesifikasi pengujian yang dapat dijalankan di Device Farm.
------
#### [ Simple Demo ]
Berikut ini adalah contoh file spesifikasi pengujian yang hanya log `Hello world!` sebagai artefak uji coba.
```
version: 0.1
android_test_host: amazon_linux_2
ios_test_host: macos_sequoia
phases:
install:
commands:
# Setup your environment by installing and/or validating software
- devicefarm-cli use python 3.11
- python --version
pre_test:
commands:
# Setup your tests by starting background tasks or setting up
# additional environment variables.
- OUTPUT_FILE="/tmp/hello.log"
test:
commands:
# Run your tests within this phase.
- python -c 'print("Hello world!")' &> $OUTPUT_FILE
post_test:
commands:
# Perform any remaining tasks within this phase, such as copying
# artifacts to the DEVICEFARM_LOG_DIR for upload
- cp $OUTPUT_FILE $DEVICEFARM_LOG_DIR
artifacts:
# By default, Device Farm will collect your artifacts from the $DEVICEFARM_LOG_DIR directory.
- $DEVICEFARM_LOG_DIR
```
------
#### [ Appium Android ]
Berikut ini adalah contoh file spesifikasi pengujian yang mengonfigurasi pengujian Appium Java TestNG yang dijalankan di Android..
```
version: 0.1
# The following fields(s) allow you to select which Device Farm test host is used for your test run.
android_test_host: amazon_linux_2
phases:
# The install phase contains commands for installing dependencies to run your tests.
# Certain frequently used dependencies are preinstalled on the test host to accelerate and
# simplify your test setup. To find these dependencies, versions supported and additional
# software installation please see:
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environments-hosts-software.html
install:
commands:
# The Appium server is written using Node.js. In order to run your desired version of Appium,
# you first need to set up a Node.js environment that is compatible with your version of Appium.
- devicefarm-cli use node 20
- node --version
# Use the devicefarm-cli to select a preinstalled major version of Appium.
- devicefarm-cli use appium 2
- appium --version
# The Device Farm service periodically updates the preinstalled Appium versions over time to
# incorporate the latest minor and patch versions for each major version. If you wish to
# select a specific version of Appium, you can use NPM to install it.
# - npm install -g appium@2.19.0
# When running Android tests with Appium version 2, the uiautomator2 driver is preinstalled using driver
# version 2.44.1 for Appium 2.5.1 If you want to install a different version of the driver,
# you can use the Appium extension CLI to uninstall the existing uiautomator2 driver
# and install your desired version:
# - |-
# if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "Android" ];
# then
# appium driver uninstall uiautomator2;
# appium driver install uiautomator2@2.34.0;
# fi;
# Based on Appium framework's recommendation, we recommend setting the Appium server's
# base path explicitly for accepting commands. If you prefer the legacy base path of /wd/hub,
# please set it here.
- export APPIUM_BASE_PATH=
# Use the devicefarm-cli to setup a Java environment, with which you can run your test suite.
- devicefarm-cli use java 17
- java -version
# The pre-test phase contains commands for setting up your test environment.
pre_test:
commands:
# Setup the CLASSPATH so that Java knows where to find your test classes.
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/*
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/dependency-jars/*
# We recommend starting the Appium server process in the background using the command below.
# The Appium server log will be written to the $DEVICEFARM_LOG_DIR directory.
# The environment variables passed as capabilities to the server will be automatically assigned
# during your test run based on your test's specific device.
# For more information about which environment variables are set and how they're set, please see
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environment-variables.html
- |-
appium --base-path=$APPIUM_BASE_PATH --log-timestamp \
--log-no-colors --relaxed-security --default-capabilities \
"{\"appium:deviceName\": \"$DEVICEFARM_DEVICE_NAME\", \
\"platformName\": \"$DEVICEFARM_DEVICE_PLATFORM_NAME\", \
\"appium:udid\":\"$DEVICEFARM_DEVICE_UDID\", \
\"appium:platformVersion\": \"$DEVICEFARM_DEVICE_OS_VERSION\", \
\"appium:chromedriverExecutableDir\": \"$DEVICEFARM_CHROMEDRIVER_EXECUTABLE_DIR\", \
\"appium:automationName\": \"UiAutomator2\"}" \
>> $DEVICEFARM_LOG_DIR/appium.log 2>&1 &;
# This code snippet is to wait until the Appium server starts.
- |-
appium_initialization_time=0;
until curl --silent --fail "http://0.0.0.0:4723${APPIUM_BASE_PATH}/status"; do
if [[ $appium_initialization_time -gt 30 ]]; then
echo "Appium did not start within 30 seconds. Exiting...";
exit 1;
fi;
appium_initialization_time=$((appium_initialization_time + 1));
echo "Waiting for Appium to start on port 4723...";
sleep 1;
done;
# The test phase contains commands for running your tests.
test:
commands:
# Your test package is downloaded and unpackaged into the $DEVICEFARM_TEST_PACKAGE_PATH directory.
- echo "Navigate to test package directory"
- cd $DEVICEFARM_TEST_PACKAGE_PATH
- echo "Starting the Appium TestNG test"
# The following command runs your Appium Java TestNG test.
# For more information, please see TestNG's documentation here:
# https://testng.org/#_running_testng
- |-
java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
-d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# To run your tests with a testng.xml file that is a part of your test package,
# use the following commands instead:
# - echo "Unzipping the tests JAR file"
# - unzip *-tests.jar
# - |-
# java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
# testng.xml -d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# The post-test phase contains commands that are run after your tests have completed.
# If you need to run any commands to generating logs and reports on how your test performed,
# we recommend adding them to this section.
post_test:
commands:
# Artifacts are a list of paths on the filesystem where you can store test output and reports.
# All files in these paths will be collected by Device Farm, with certain limits (see limit details
# here: https://docs.aws.amazon.com/devicefarm/latest/developerguide/limits.html#file-limits).
# These files will be available through the ListArtifacts API as your "Customer Artifacts".
artifacts:
# By default, Device Farm will collect your artifacts from the $DEVICEFARM_LOG_DIR directory.
- $DEVICEFARM_LOG_DIR
```
------
#### [ Appium iOS ]
Berikut ini adalah contoh file spesifikasi pengujian yang mengkonfigurasi uji Appium Java TestNG yang dijalankan di iOS.
```
version: 0.1
# The following fields(s) allow you to select which Device Farm test host is used for your test run.
ios_test_host: macos_sequoia
phases:
# The install phase contains commands for installing dependencies to run your tests.
# Certain frequently used dependencies are preinstalled on the test host to accelerate and
# simplify your test setup. To find these dependencies, versions supported and additional
# software installation please see:
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environments-hosts-software.html
install:
commands:
# The Appium server is written using Node.js. In order to run your desired version of Appium,
# you first need to set up a Node.js environment that is compatible with your version of Appium.
- devicefarm-cli use node 20
- node --version
# Use the devicefarm-cli to select a preinstalled major version of Appium.
- devicefarm-cli use appium 2
- appium --version
# The Device Farm service periodically updates the preinstalled Appium versions over time to
# incorporate the latest minor and patch versions for each major version. If you wish to
# select a specific version of Appium, you can use NPM to install it.
# - npm install -g appium@2.19.0
# When running iOS tests with Appium version 2, the XCUITest driver is preinstalled using driver
# version 9.10.5 for Appium 2.5.4. If you want to install a different version of the driver,
# you can use the Appium extension CLI to uninstall the existing XCUITest driver
# and install your desired version:
# - |-
# if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "iOS" ];
# then
# appium driver uninstall xcuitest;
# appium driver install xcuitest@10.0.0;
# fi;
# Based on Appium framework's recommendation, we recommend setting the Appium server's
# base path explicitly for accepting commands. If you prefer the legacy base path of /wd/hub,
# please set it here.
- export APPIUM_BASE_PATH=
# Use the devicefarm-cli to setup a Java environment, with which you can run your test suite.
- devicefarm-cli use java 17
- java -version
# The pre-test phase contains commands for setting up your test environment.
pre_test:
commands:
# Setup the CLASSPATH so that Java knows where to find your test classes.
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/*
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/dependency-jars/*
# Device Farm provides multiple pre-built versions of WebDriverAgent (WDA), a required
# Appium dependency for iOS, where each version corresponds to the XCUITest driver version selected.
# If Device Farm cannot find a corresponding version of WDA for your XCUITest driver,
# the latest available version is selected by default.
- |-
APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1);
CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}")
if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then
echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver";
DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2)
else
LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1)
echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION";
DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2)
fi;
# For iOS versions 16 and below only, the device unique identifier (UDID) needs to modified for Appium tests
# on Device Farm to remove the hypens.
- |-
if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "iOS" ]; then
DEVICEFARM_DEVICE_UDID_FOR_APPIUM=$DEVICEFARM_DEVICE_UDID;
if [ $(echo $DEVICEFARM_DEVICE_OS_VERSION | cut -d "." -f 1) -le 16 ]; then
DEVICEFARM_DEVICE_UDID_FOR_APPIUM=$(echo $DEVICEFARM_DEVICE_UDID | tr -d "-");
fi;
fi;
# We recommend starting the Appium server process in the background using the command below.
# The Appium server log will be written to the $DEVICEFARM_LOG_DIR directory.
# The environment variables passed as capabilities to the server will be automatically assigned
# during your test run based on your test's specific device.
# For more information about which environment variables are set and how they're set, please see
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environment-variables.html
- |-
appium --base-path=$APPIUM_BASE_PATH --log-timestamp \
--log-no-colors --relaxed-security --default-capabilities \
"{\"appium:deviceName\": \"$DEVICEFARM_DEVICE_NAME\", \
\"platformName\": \"$DEVICEFARM_DEVICE_PLATFORM_NAME\", \
\"appium:app\": \"$DEVICEFARM_APP_PATH\", \
\"appium:udid\":\"$DEVICEFARM_DEVICE_UDID_FOR_APPIUM\", \
\"appium:platformVersion\": \"$DEVICEFARM_DEVICE_OS_VERSION\", \
\"appium:derivedDataPath\": \"$DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH\", \
\"appium:usePrebuiltWDA\": true, \
\"appium:automationName\": \"XCUITest\"}" \
>> $DEVICEFARM_LOG_DIR/appium.log 2>&1 &
# This code snippet is to wait until the Appium server starts.
- |-
appium_initialization_time=0;
until curl --silent --fail "http://0.0.0.0:4723${APPIUM_BASE_PATH}/status"; do
if [[ $appium_initialization_time -gt 30 ]]; then
echo "Appium did not start within 30 seconds. Exiting...";
exit 1;
fi;
appium_initialization_time=$((appium_initialization_time + 1));
echo "Waiting for Appium to start on port 4723...";
sleep 1;
done;
# The test phase contains commands for running your tests.
test:
commands:
# Your test package is downloaded and unpackaged into the $DEVICEFARM_TEST_PACKAGE_PATH directory.
- echo "Navigate to test package directory"
- cd $DEVICEFARM_TEST_PACKAGE_PATH
- echo "Starting the Appium TestNG test"
# The following command runs your Appium Java TestNG test.
# For more information, please see TestNG's documentation here:
# https://testng.org/#_running_testng
- |-
java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
-d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# To run your tests with a testng.xml file that is a part of your test package,
# use the following commands instead:
# - echo "Unzipping the tests JAR file"
# - unzip *-tests.jar
# - |-
# java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
# testng.xml -d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# The post-test phase contains commands that are run after your tests have completed.
# If you need to run any commands to generating logs and reports on how your test performed,
# we recommend adding them to this section.
post_test:
commands:
# Artifacts are a list of paths on the filesystem where you can store test output and reports.
# All files in these paths will be collected by Device Farm, with certain limits (see limit details
# here: https://docs.aws.amazon.com/devicefarm/latest/developerguide/limits.html#file-limits).
# These files will be available through the ListArtifacts API as your "Customer Artifacts".
artifacts:
# By default, Device Farm will collect your artifacts from the $DEVICEFARM_LOG_DIR directory.
- $DEVICEFARM_LOG_DIR
```
------
#### [ Appium (Both Platforms) ]
Berikut ini adalah contoh file spesifikasi pengujian yang mengonfigurasi pengujian Appium Java TestNG yang dijalankan di Android dan iOS.
```
version: 0.1
# The following fields(s) allow you to select which Device Farm test host is used for your test run.
android_test_host: amazon_linux_2
ios_test_host: macos_sequoia
phases:
# The install phase contains commands for installing dependencies to run your tests.
# Certain frequently used dependencies are preinstalled on the test host to accelerate and
# simplify your test setup. To find these dependencies, versions supported and additional
# software installation please see:
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environments-hosts-software.html
install:
commands:
# The Appium server is written using Node.js. In order to run your desired version of Appium,
# you first need to set up a Node.js environment that is compatible with your version of Appium.
- devicefarm-cli use node 20
- node --version
# Use the devicefarm-cli to select a preinstalled major version of Appium.
- devicefarm-cli use appium 2
- appium --version
# The Device Farm service periodically updates the preinstalled Appium versions over time to
# incorporate the latest minor and patch versions for each major version. If you wish to
# select a specific version of Appium, you can use NPM to install it.
# - npm install -g appium@2.19.0
# When running Android tests with Appium version 2, the uiautomator2 driver is preinstalled using driver
# version 2.44.1 for Appium 2.5.1 If you want to install a different version of the driver,
# you can use the Appium extension CLI to uninstall the existing uiautomator2 driver
# and install your desired version:
# - |-
# if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "Android" ];
# then
# appium driver uninstall uiautomator2;
# appium driver install uiautomator2@2.34.0;
# fi;
# When running iOS tests with Appium version 2, the XCUITest driver is preinstalled using driver
# version 9.10.5 for Appium 2.5.4. If you want to install a different version of the driver,
# you can use the Appium extension CLI to uninstall the existing XCUITest driver
# and install your desired version:
# - |-
# if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "iOS" ];
# then
# appium driver uninstall xcuitest;
# appium driver install xcuitest@10.0.0;
# fi;
# Based on Appium framework's recommendation, we recommend setting the Appium server's
# base path explicitly for accepting commands. If you prefer the legacy base path of /wd/hub,
# please set it here.
- export APPIUM_BASE_PATH=
# Use the devicefarm-cli to setup a Java environment, with which you can run your test suite.
- devicefarm-cli use java 17
- java -version
# The pre-test phase contains commands for setting up your test environment.
pre_test:
commands:
# Setup the CLASSPATH so that Java knows where to find your test classes.
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/*
- export CLASSPATH=$CLASSPATH:$DEVICEFARM_TEST_PACKAGE_PATH/dependency-jars/*
# Device Farm provides multiple pre-built versions of WebDriverAgent (WDA), a required
# Appium dependency for iOS, where each version corresponds to the XCUITest driver version selected.
# If Device Farm cannot find a corresponding version of WDA for your XCUITest driver,
# the latest available version is selected by default.
- |-
if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "iOS" ]; then
APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1);
CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}")
if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then
echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver";
DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2)
else
LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1)
echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION";
DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2)
fi;
fi;
# For iOS versions 16 and below only, the device unique identifier (UDID) needs to modified for Appium tests
# on Device Farm to remove the hypens.
- |-
if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "iOS" ]; then
DEVICEFARM_DEVICE_UDID_FOR_APPIUM=$DEVICEFARM_DEVICE_UDID;
if [ $(echo $DEVICEFARM_DEVICE_OS_VERSION | cut -d "." -f 1) -le 16 ]; then
DEVICEFARM_DEVICE_UDID_FOR_APPIUM=$(echo $DEVICEFARM_DEVICE_UDID | tr -d "-");
fi;
fi;
# We recommend starting the Appium server process in the background using the command below.
# The Appium server log will be written to the $DEVICEFARM_LOG_DIR directory.
# The environment variables passed as capabilities to the server will be automatically assigned
# during your test run based on your test's specific device.
# For more information about which environment variables are set and how they're set, please see
# https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environment-variables.html
- |-
if [ $DEVICEFARM_DEVICE_PLATFORM_NAME = "Android" ]; then
appium --base-path=$APPIUM_BASE_PATH --log-timestamp \
--log-no-colors --relaxed-security --default-capabilities \
"{\"appium:deviceName\": \"$DEVICEFARM_DEVICE_NAME\", \
\"platformName\": \"$DEVICEFARM_DEVICE_PLATFORM_NAME\", \
\"appium:udid\":\"$DEVICEFARM_DEVICE_UDID\", \
\"appium:platformVersion\": \"$DEVICEFARM_DEVICE_OS_VERSION\", \
\"appium:chromedriverExecutableDir\": \"$DEVICEFARM_CHROMEDRIVER_EXECUTABLE_DIR\", \
\"appium:automationName\": \"UiAutomator2\"}" \
>> $DEVICEFARM_LOG_DIR/appium.log 2>&1 &
else
appium --base-path=$APPIUM_BASE_PATH --log-timestamp \
--log-no-colors --relaxed-security --default-capabilities \
"{\"appium:deviceName\": \"$DEVICEFARM_DEVICE_NAME\", \
\"platformName\": \"$DEVICEFARM_DEVICE_PLATFORM_NAME\", \
\"appium:udid\":\"$DEVICEFARM_DEVICE_UDID_FOR_APPIUM\", \
\"appium:platformVersion\": \"$DEVICEFARM_DEVICE_OS_VERSION\", \
\"appium:derivedDataPath\": \"$DEVICEFARM_WDA_DERIVED_DATA_PATH\", \
\"appium:usePrebuiltWDA\": true, \
\"appium:automationName\": \"XCUITest\"}" \
>> $DEVICEFARM_LOG_DIR/appium.log 2>&1 &
fi;
# This code snippet is to wait until the Appium server starts.
- |-
appium_initialization_time=0;
until curl --silent --fail "http://0.0.0.0:4723${APPIUM_BASE_PATH}/status"; do
if [[ $appium_initialization_time -gt 30 ]]; then
echo "Appium did not start within 30 seconds. Exiting...";
exit 1;
fi;
appium_initialization_time=$((appium_initialization_time + 1));
echo "Waiting for Appium to start on port 4723...";
sleep 1;
done;
# The test phase contains commands for running your tests.
test:
commands:
# Your test package is downloaded and unpackaged into the $DEVICEFARM_TEST_PACKAGE_PATH directory.
- echo "Navigate to test package directory"
- cd $DEVICEFARM_TEST_PACKAGE_PATH
- echo "Starting the Appium TestNG test"
# The following command runs your Appium Java TestNG test.
# For more information, please see TestNG's documentation here:
# https://testng.org/#_running_testng
- |-
java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
-d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# To run your tests with a testng.xml file that is a part of your test package,
# use the following commands instead:
# - echo "Unzipping the tests JAR file"
# - unzip *-tests.jar
# - |-
# java -Dappium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar \
# testng.xml -d $DEVICEFARM_LOG_DIR/test-output -verbose 10
# The post-test phase contains commands that are run after your tests have completed.
# If you need to run any commands to generating logs and reports on how your test performed,
# we recommend adding them to this section.
post_test:
commands:
# Artifacts are a list of paths on the filesystem where you can store test output and reports.
# All files in these paths will be collected by Device Farm, with certain limits (see limit details
# here: https://docs.aws.amazon.com/devicefarm/latest/developerguide/limits.html#file-limits).
# These files will be available through the ListArtifacts API as your "Customer Artifacts".
artifacts:
# By default, Device Farm will collect your artifacts from the $DEVICEFARM_LOG_DIR directory.
- $DEVICEFARM_LOG_DIR
```
------
# Host untuk lingkungan pengujian khusus
Device Farm mendukung satu set sistem operasi dengan perangkat lunak pra-konfigurasi melalui penggunaan lingkungan host uji. Selama eksekusi pengujian, Device Farm menggunakan instance (host) yang dikelola Amazon yang terhubung secara dinamis ke perangkat yang dipilih yang sedang diuji. Instance ini sepenuhnya dibersihkan dan tidak digunakan kembali di antara proses, dan diakhiri dengan artefak yang dihasilkan setelah uji coba selesai.
**Topics**
+ [Host uji yang tersedia untuk lingkungan pengujian khusus](#custom-test-environments-hosts-available)
+ [Memilih host uji untuk lingkungan pengujian khusus](#test-host-selection)
+ [Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md)
+ [Lingkungan uji untuk perangkat Android](custom-test-environments-hosts-android.md)
+ [Lingkungan uji untuk perangkat iOS](custom-test-environments-hosts-ios.md)
## Host uji yang tersedia untuk lingkungan pengujian khusus
Host uji sepenuhnya dikelola oleh Device Farm. Tabel berikut mencantumkan host uji Device Farm yang saat ini tersedia dan didukung untuk lingkungan pengujian kustom.
| Platform Perangkat | Tuan Rumah Uji | Sistem Operasi | Arsitektur | Perangkat yang Didukung |
| --- | --- | --- | --- | --- |
| Android | amazon\$1linux\$12 | Amazon Linux 2 | x86\$164 | Android6 dan di atas |
| iOS | macos\$1sequoia | macOS Sequoia(versi 15) | arm64 | iOS15 hingga 26 |
**catatan**
Secara berkala, Device Farm menambahkan host uji baru untuk platform perangkat untuk mendukung versi OS perangkat yang lebih baru dan dependensinya. Ketika ini terjadi, host uji yang lebih lama untuk platform perangkat masing-masing tunduk pada akhir dukungan.
### Versi Sistem Operasi
Setiap host uji yang tersedia menggunakan versi tertentu dari sistem operasi yang didukung di Device Farm pada saat itu. Meskipun kami mencoba menggunakan versi OS terbaru, ini mungkin bukan versi terbaru yang didistribusikan secara publik yang tersedia. Device Farm akan memperbarui sistem operasi secara berkala dengan pembaruan versi minor dan patch keamanan.
Untuk mengetahui versi tertentu (termasuk versi minor) dari sistem operasi yang digunakan selama uji coba, Anda dapat menambahkan cuplikan kode berikut ke fase file spesifikasi pengujian Anda.
**Example**
```
phases:
install:
commands:
# The following example prints the instance's operating system version details
- |-
if [[ "Darwin" == "$(uname)" ]]; then
echo "$(sw_vers --productName) $(sw_vers --productVersion) ($(sw_vers --buildVersion))";
else
echo "$(. /etc/os-release && echo $PRETTY_NAME) ($(uname -r))";
fi
```
## Memilih host uji untuk lingkungan pengujian khusus
Anda dapat menentukan host pengujian Android dan iOS dalam variabel yang sesuai `android_test_host` dan `ios_test_host` variabel [file spesifikasi pengujian](custom-test-environment-test-spec.md#custom-test-environment-test-spec-syntax) Anda.
Jika Anda tidak menentukan pilihan host pengujian untuk platform perangkat yang diberikan, pengujian akan dijalankan pada host pengujian yang telah ditetapkan Device Farm sebagai default untuk perangkat dan konfigurasi pengujian yang ditentukan.
**penting**
Saat menguji di iOS 18 dan di bawahnya, host uji lama akan digunakan saat host tidak dipilih. Untuk informasi lebih lanjut, lihat topik di[Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host).
Sebagai contoh, tinjau cuplikan kode berikut:
**Example**
```
version: 0.1
android_test_host: amazon_linux_2
ios_test_host: macos_sequoia
phases:
# ...
```
# Perangkat lunak yang didukung dalam lingkungan pengujian khusus
Device Farm menggunakan mesin host yang sudah diinstal sebelumnya dengan banyak pustaka perangkat lunak yang diperlukan untuk menjalankan kerangka kerja pengujian yang didukung pada layanan kami, menyediakan lingkungan pengujian siap saat diluncurkan. Device Farm mendukung berbagai bahasa melalui penggunaan mekanisme pemilihan perangkat lunak kami, dan akan memperbarui versi bahasa yang disertakan dalam lingkungan secara berkala.
Untuk perangkat lunak lain yang diperlukan, Anda dapat memodifikasi file spesifikasi pengujian untuk diinstal dari paket pengujian Anda, mengunduh dari internet, atau mengakses sumber pribadi dalam VPC Anda (lihat [VPC](https://docs.aws.amazon.com//devicefarm/latest/developerguide/vpc-eni.html) ENI untuk informasi lebih lanjut). Untuk informasi selengkapnya, lihat [Contoh spesifikasi uji](custom-test-environment-test-spec.md#custom-test-environment-test-spec-example).
## Perangkat lunak pra-konfigurasi
Untuk memfasilitasi pengujian perangkat pada setiap platform, perkakas berikut disediakan pada host uji:
| Alat | Platform Perangkat |
| --- | --- |
| Android SDK Build-Tools | Android |
| Android SDK Platform-Tools(termasuk`adb`) | Android |
| Xcode | iOS |
## Perangkat lunak yang dapat dipilih
Selain perangkat lunak pra-konfigurasi pada host, Device Farm menawarkan cara untuk memilih versi tertentu dari perangkat lunak yang didukung melalui `devicefarm-cli` perkakas.
Tabel berikut berisi perangkat lunak yang dapat dipilih dan host uji yang berisi mereka.
| Perangkat Lunak/Alat | Host yang mendukung perangkat lunak ini | Perintah untuk digunakan dalam spesifikasi pengujian Anda |
| --- | --- | --- |
| Java 17 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use java 17` |
| Java 11 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use java 11` |
| Java 8 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use java 8` |
| Node.js 20 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use node 20` |
| Node.js 18 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use node 18` |
| Node.js 16 | amazon\$1linux\$12 | `devicefarm-cli use node 16` |
| Python 3.11 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use python 3.11` |
| Python 3.10 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use python 3.10` |
| Python 3.9 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use python 3.9` |
| Python 3.8 | amazon\$1linux\$12 | `devicefarm-cli use python 3.8` |
| Ruby 3.2 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use ruby 3.2` |
| Ruby 2.7 | amazon\$1linux\$12 | `devicefarm-cli use ruby 2.7` |
| Appium 3 | amazon\$1linux\$12 | `devicefarm-cli use appium 3` |
| Appium 2 | amazon\$1linux\$12 macos\$1sequoia | `devicefarm-cli use appium 2` |
| Appium 1 | amazon\$1linux\$12 | `devicefarm-cli use appium 1` |
| Xcode 26 | macos\$1sequoia | `devicefarm-cli use xcode 26` |
| Xcode 16 | macos\$1sequoia | `devicefarm-cli use xcode 16` |
Host pengujian juga mencakup alat pendukung yang umum digunakan untuk setiap versi perangkat lunak, seperti manajer `npm` paket `pip` dan (disertakan dengan Python dan Node.js masing-masing) dan dependensi (seperti UIAutomator2 Driver Appium) untuk alat seperti Appium. Ini memastikan Anda memiliki alat yang diperlukan untuk bekerja dengan kerangka kerja pengujian yang didukung.
# Menggunakan alat devicefarm-cli di lingkungan pengujian khusus
Host uji menggunakan alat manajemen versi standar yang dipanggil ` devicefarm-cli` untuk memilih versi perangkat lunak. Alat ini terpisah dari AWS CLI dan hanya tersedia di host uji Device Farm. Dengan`devicefarm-cli`, Anda dapat beralih ke versi perangkat lunak yang sudah diinstal sebelumnya pada host uji. Ini memberikan cara mudah untuk memelihara file spesifikasi pengujian Device Farm Anda dari waktu ke waktu dan memberi Anda mekanisme yang dapat diprediksi untuk meningkatkan versi perangkat lunak di masa mendatang.
**penting**
Alat baris perintah ini tidak tersedia di host iOS lama. Untuk informasi lebih lanjut, lihat topik di[Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host).
Cuplikan di bawah ini menunjukkan `help` halaman: `devicefarm-cli`
```
$ devicefarm-cli help
Usage: devicefarm-cli COMMAND [ARGS]
Commands:
help Prints this usage message.
list Lists all versions of software configurable
via this CLI.
use Configures the software for usage within the
current shell's environment.
```
Mari kita tinjau beberapa contoh menggunakan`devicefarm-cli`. Untuk menggunakan alat untuk mengubah versi Python dari *3.10* ke *3.9* dalam file spesifikasi pengujian Anda, jalankan perintah berikut:
```
$ python --version
Python 3.10.12
$ devicefarm-cli use python 3.9
$ python --version
Python 3.9.17
```
Untuk mengubah versi Appium dari *1* menjadi: *2*
```
$ appium --version
1.22.3
$ devicefarm-cli use appium 2
$ appium --version
2.1.2
```
**Tip**
Perhatikan bahwa ketika Anda memilih versi perangkat lunak, `devicefarm-cli` juga beralih alat pendukung untuk bahasa-bahasa tersebut, seperti `pip` untuk Python dan `npm` NodeJS.
Untuk informasi selengkapnya tentang perangkat lunak prainstal pada host uji, lihat[Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md).
# Lingkungan uji untuk perangkat Android
AWS Device Farm menggunakan mesin host Amazon Elastic Compute Cloud (EC2) Amazon Elastic Compute Cloud (EC2) yang menjalankan Amazon Linux 2 untuk menjalankan pengujian Android. Saat Anda menjadwalkan uji coba, Device Farm mengalokasikan host khusus untuk setiap perangkat untuk menjalankan pengujian secara independen. Mesin host berakhir setelah pengujian dijalankan bersama dengan artefak yang dihasilkan.
Host Amazon Linux 2 memberikan beberapa keuntungan:
+ **Pengujian yang lebih cepat dan lebih andal**: Dibandingkan dengan host lama, host uji baru secara signifikan meningkatkan kecepatan pengujian, terutama mengurangi waktu mulai pengujian. Host Amazon Linux 2 juga menunjukkan stabilitas dan keandalan yang lebih besar selama pengujian.
+ **Akses Jarak Jauh yang Ditingkatkan untuk pengujian manual**: Peningkatan ke host pengujian terbaru dan peningkatan menghasilkan latensi yang lebih rendah dan kinerja video yang lebih baik untuk pengujian manual Android.
+ **Pemilihan versi perangkat lunak standar**: Device Farm sekarang menstandarisasi dukungan bahasa pemrograman utama pada host uji serta versi kerangka Appium. Untuk bahasa yang didukung (saat ini Java, Python, Node.js, dan Ruby) dan Appium, host uji baru menyediakan rilis stabil jangka panjang segera setelah peluncuran. Manajemen versi terpusat melalui `devicefarm-cli` alat ini memungkinkan pengembangan file spesifikasi pengujian dengan pengalaman yang konsisten di seluruh kerangka kerja.
**Topics**
+ [Rentang IP yang didukung untuk lingkungan pengujian Amazon Linux 2 di Device Farm](amazon-linux-2-ip-ranges.md)
# Rentang IP yang didukung untuk lingkungan pengujian Amazon Linux 2 di Device Farm
Pelanggan sering perlu mengetahui rentang IP dari mana lalu lintas Device Farm berasal, terutama untuk mengonfigurasi firewall dan pengaturan keamanan mereka. Untuk host uji Amazon EC2, rentang IP mencakup seluruh wilayah. `us-west-2` Untuk host uji Amazon Linux 2, yang merupakan opsi default untuk menjalankan Android baru, rentangnya telah dibatasi. Lalu lintas sekarang berasal dari satu set gateway NAT tertentu, membatasi rentang IP ke alamat berikut:
****
| Rentang IP |
| --- |
| **44.236.137.143** |
| **52.13.151.244** |
| **52.35.189.191** |
| **54.201.250.26** |
Untuk informasi selengkapnya tentang lingkungan pengujian Android di Device Farm, lihat[Lingkungan uji untuk perangkat Android](custom-test-environments-hosts-android.md).
# Lingkungan uji untuk perangkat iOS
Device Farm menggunakan instance (host) macOS yang dikelola Amazon yang terhubung secara dinamis ke perangkat iOS selama pengujian dijalankan. Setiap host sudah dikonfigurasi sebelumnya dengan perangkat lunak yang memungkinkan pengujian perangkat pada berbagai platform pengujian populer, seperti XCTest UI dan Appium.
Iterasi host uji iOS saat ini telah meningkatkan pengalaman pengujian jika dibandingkan dengan versi sebelumnya, termasuk:
+ **Pengalaman OS dan perkakas host yang konsisten untuk iOS 15 hingga iOS 26** Sebelumnya, host pengujian ditentukan oleh perangkat yang digunakan, yang mengarah ke lingkungan perangkat lunak yang terfragmentasi saat dijalankan di beberapa versi iOS. Pengalaman saat ini memungkinkan pemilihan host sederhana untuk memungkinkan lingkungan yang konsisten di seluruh perangkat. Ini akan memungkinkan versi dan perkakas macOS yang sama (seperti Xcode) tersedia di setiap perangkat iOS.
+ **Peningkatan kinerja untuk pengujian iOS 15 dan 16** Menggunakan infrastruktur yang diperbarui, waktu penyiapan telah meningkat secara substansif untuk pengujian iOS 15 dan 16.
+ **Versi perangkat lunak yang dapat dipilih standar untuk dependensi yang didukung** Kami sekarang memiliki sistem pemilihan `devicefarm-cli` perangkat lunak di host uji iOS dan Android, memungkinkan Anda memilih versi pilihan dari dependensi kami yang didukung. Untuk dependensi yang didukung (seperti Java, Python, Node.js, Ruby, dan Appium), versi akan dipilih melalui spesifikasi pengujian. Untuk gambaran tentang cara kerja fitur ini, silakan lihat topik di[Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md).
**penting**
Jika dijalankan di iOS 18 dan di bawahnya, pengujian Anda akan dijalankan pada host uji lama secara default. Lihat topik di bawah tentang cara bermigrasi dari host lama.
## Host uji iOS lama
Untuk pengujian yang ada di iOS 18 dan di bawahnya, host uji lama dipilih secara default untuk lingkungan pengujian khusus. Tabel berikut berisi versi host uji yang dijalankan dengan versi perangkat iOS.
| Sistem Operasi | Arsitektur | Default untuk Perangkat |
| --- | --- | --- |
| macOS Sonoma(versi 14) | arm64 | iOS 18 |
| macOS Ventura(versi 13) | arm64 | iOS 17 |
| macOS Monterey(versi 12) | x86\$164 | iOS 16dan di bawah |
Untuk memilih host uji yang lebih baru, lihat topik terkait[Memigrasi lingkungan pengujian kustom Anda ke host uji iOS baru](ios-host-migration.md).
## Perangkat lunak yang didukung untuk perangkat iOS
Untuk mendukung pengujian perangkat iOS, host uji Device Farm untuk perangkat iOS telah dikonfigurasi sebelumnya dengan Xcode dan perkakas baris perintah terkait. Untuk perangkat lunak lain yang tersedia, silakan tinjau topik terkait[Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md).
# Memigrasi lingkungan pengujian kustom Anda ke host uji iOS baru
Untuk memigrasikan pengujian yang ada dari host lama ke host pengujian macOS baru, Anda perlu mengembangkan file spesifikasi pengujian baru berdasarkan yang sudah ada sebelumnya.
Pendekatan yang disarankan adalah memulai dengan contoh file spesifikasi pengujian untuk jenis pengujian yang Anda inginkan, lalu memigrasikan perintah yang relevan dari file spesifikasi pengujian lama Anda ke yang baru. Ini memungkinkan Anda memanfaatkan fitur baru dan pengoptimalan contoh spesifikasi pengujian untuk host baru saat menggunakan kembali cuplikan kode Anda yang ada.
**Topics**
+ [Tutorial: Memigrasi file spesifikasi pengujian iOS dengan konsol](#ios-host-migration-console-tutorial)
+ [Perbedaan antara host uji baru dan lama](#ios-host-migration-differences)
## Tutorial: Memigrasi file spesifikasi pengujian iOS dengan konsol
Dalam contoh ini, konsol Device Farm akan digunakan untuk onboard spesifikasi pengujian perangkat iOS yang ada untuk menggunakan host pengujian baru.
### Langkah 1: Membuat file spesifikasi pengujian baru dengan konsol
1. Masuk ke [konsol AWS Device Farm](https://console.aws.amazon.com/devicefarm).
1. Arahkan ke proyek Device Farm yang berisi pengujian otomatisasi Anda.
1. Unduh salinan spesifikasi pengujian yang ada yang ingin Anda ikuti.
1. Klik opsi “Pengaturan Proyek” dan arahkan ke tab **Unggahan**.
1. Arahkan ke file spesifikasi pengujian yang ingin Anda gunakan.
1. Klik tombol **Unduh** untuk membuat salinan lokal file ini.
1. Arahkan kembali ke halaman Project dan klik **Create run**.
1. Isi opsi pada wizard seolah-olah Anda akan memulai proses baru, tetapi berhenti di opsi **Pilih spesifikasi pengujian**.
1. Menggunakan spesifikasi pengujian iOS yang dipilih secara default, klik tombol **Buat spesifikasi pengujian**.
1. Ubah spesifikasi pengujian yang dipilih *secara default* di editor teks.
1. Jika belum ada, ubah file spesifikasi pengujian untuk memilih host baru menggunakan:
```
ios_test_host: macos_sequoia
```
1. Dari salinan spesifikasi pengujian Anda yang diunduh pada langkah sebelumnya, tinjau masing-masing` phase`.
1. Salin perintah dari fase spesifikasi pengujian lama ke setiap fase masing-masing dalam spesifikasi pengujian baru, mengabaikan perintah yang terkait dengan menginstal atau memilih Java, Python, Node.js, Ruby, Appium, atau Xcode.
1. Masukkan nama file baru di kotak teks **Simpan sebagai**.
1. Klik tombol **Simpan sebagai baru** untuk menyimpan perubahan Anda.
Untuk contoh file spesifikasi pengujian yang dapat Anda gunakan sebagai referensi, lihat contoh yang disediakan di[Contoh spesifikasi uji](custom-test-environment-test-spec.md#custom-test-environment-test-spec-example).
### Langkah 2: Memilih perangkat lunak pra-instal perangkat lunak
Di host uji baru, versi perangkat lunak pra-instal dipilih menggunakan alat manajemen versi standar baru yang disebut. `devicefarm-cli` Perkakas ini sekarang merupakan pendekatan yang direkomendasikan untuk menggunakan berbagai perangkat lunak yang kami sediakan pada host uji.
Sebagai contoh, Anda akan menambahkan baris berikut untuk menggunakan JDK 17 yang berbeda lingkungan pengujian Anda:
```
- devicefarm-cli use java 17
```
Untuk informasi lebih lanjut tentang perangkat lunak yang didukung tersedia, silakan tinjau:[Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md).
### Langkah 3: Menggunakan Appium dan dependensinya melalui alat pemilihan perangkat lunak
Host uji baru hanya mendukung Appium 2.x ke atas. Harap secara eksplisit pilih versi Appium menggunakan`devicefarm-cli`, sambil menghapus alat lama seperti. ` avm` Contoh:
```
# This line using 'avm' should be removed
# - avm 2.3.1
# And the following lines should be added
- devicefarm-cli use appium 2 # Selects the version
- appium --version # Prints the version
```
Versi Appium yang dipilih `devicefarm-cli` dilengkapi dengan prainstal dengan versi driver yang kompatibel XCUITest untuk iOS.
Selain itu, Anda perlu memperbarui spesifikasi pengujian Anda untuk digunakan ` DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V9` alih-alih. ` DEVICEFARM_WDA_DERIVED_DATA_PATH` Variabel lingkungan baru menunjuk ke versi pra-bangun WebDriverAgent 9.x, yang merupakan versi terbaru yang didukung untuk pengujian Appium 2.
Untuk informasi lebih lanjut, tinjau [Memilih WebDriverAgent versi untuk pengujian iOS](test-types-appium.md#test-types-appium-select-wda) dan[Variabel lingkungan untuk tes Appium](custom-test-environment-variables.md#custom-test-environment-variables-appium).
## Perbedaan antara host uji baru dan lama
Saat mengedit file spesifikasi pengujian untuk menggunakan host uji iOS baru dan mentransisikan pengujian Anda dari host pengujian lama, perhatikan perbedaan lingkungan utama berikut:
+ **Versi Xcode:** Di lingkungan host uji lama, versi Xcode yang tersedia didasarkan pada versi iOS perangkat yang digunakan untuk pengujian. Misalnya, pengujian pada perangkat iOS 18 menggunakan Xcode 16 di host lama, sedangkan pengujian di iOS 17 menggunakan Xcode 15. Di lingkungan host baru, semua perangkat dapat mengakses versi Xcode yang sama, memungkinkan lingkungan yang konsisten untuk pengujian pada perangkat dengan versi berbeda. Untuk daftar versi Xcode yang tersedia saat ini, lihat[Perangkat lunak yang didukung](custom-test-environments-hosts-software.md).
+ **Memilih versi perangkat lunak:** Dalam banyak kasus, versi perangkat lunak default telah berubah, jadi jika Anda tidak secara eksplisit memilih versi perangkat lunak Anda di host uji lama sebelumnya, Anda mungkin ingin menentukannya sekarang di host uji baru menggunakan. [`devicefarm-cli`](custom-test-environments-hosts-software-cli.md) Dalam sebagian besar kasus penggunaan, kami menyarankan agar pelanggan secara eksplisit memilih versi perangkat lunak yang mereka gunakan. Dengan memilih versi perangkat lunak, `devicefarm-cli` Anda akan memiliki pengalaman yang dapat diprediksi dan konsisten dengannya dan menerima banyak peringatan jika Device Farm berencana untuk menghapus versi tersebut dari host pengujian.
Selain itu, alat pemilihan perangkat lunak seperti `nvm` `pyenv`` avm`,,, dan `rvm` telah dihapus demi sistem pemilihan ` devicefarm-cli` perangkat lunak baru.
+ **Versi perangkat lunak yang tersedia:** Banyak versi perangkat lunak pra-instal sebelumnya telah dihapus, dan banyak versi baru telah ditambahkan. Jadi, pastikan bahwa ketika menggunakan `devicefarm-cli` untuk memilih versi perangkat lunak Anda, Anda memilih versi yang ada dalam [daftar versi yang didukung](custom-test-environments-hosts-software.md).
+ **`libimobiledevice`Rangkaian alat telah dihapus** demi perkakas yang lebih baru/pihak pertama untuk melacak pengujian perangkat iOS saat ini dan standar industri. Untuk iOS 17 ke atas, Anda dapat memigrasikan sebagian besar perintah untuk menggunakan perkakas Xcode serupa, yang disebut. `devicectl` Untuk informasi tentang`devicectl`, Anda dapat menjalankan `xcrun devicectl help` dari mesin dengan Xcode diinstal.
+ **Jalur file yang dikodekan keras** dalam file spesifikasi pengujian host lama Anda sebagai jalur absolut kemungkinan besar tidak akan berfungsi seperti yang diharapkan di host pengujian baru, dan umumnya tidak direkomendasikan untuk penggunaan file spesifikasi pengujian. Kami menyarankan Anda menggunakan jalur relatif dan variabel lingkungan untuk semua kode file spesifikasi pengujian. Untuk informasi lebih lanjut, tinjau topik di[Praktik terbaik untuk eksekusi lingkungan pengujian kustom](custom-test-environments-best-practices.md).
+ **Versi dan arsitektur sistem operasi:** Host uji lama menggunakan berbagai versi macOS dan arsitektur CPU berdasarkan perangkat yang ditetapkan. Akibatnya, pengguna mungkin melihat beberapa perbedaan dalam pustaka sistem yang tersedia yang tersedia di lingkungan. Untuk informasi lebih lanjut tentang versi OS host sebelumnya, tinjau[Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host).
+ **Untuk pengguna Appium**, cara memilih WebDriverAgent telah berubah menjadi awalan variabel lingkungan penggunaan ` DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V` alih-alih awalan lama. ` DEVICEFARM_WDA_DERIVED_DATA_PATH_V` Untuk informasi lebih lanjut tentang variabel yang diperbarui, tinjau[Variabel lingkungan untuk tes Appium](custom-test-environment-variables.md#custom-test-environment-variables-appium).
+ **Untuk pengguna Appium Java**, host uji baru tidak berisi file JAR pra-instal di jalur kelasnya, sedangkan host sebelumnya berisi satu untuk kerangka TestNG (melalui variabel lingkungan). `$DEVICEFARM_TESTNG_JAR` Kami menyarankan agar pelanggan mengemas file JAR yang diperlukan untuk kerangka kerja pengujian mereka di dalam paket pengujian mereka dan menghapus instance `$DEVICEFARM_TESTNG_JAR` variabel dari file spesifikasi pengujian mereka.
Kami merekomendasikan untuk menghubungi tim layanan melalui kasus dukungan jika Anda memiliki umpan balik atau pertanyaan tentang perbedaan antara host uji dari perspektif perangkat lunak.
# Akses sumber daya AWS menggunakan Peran Eksekusi IAM
Device Farm mendukung penetapan peran IAM yang akan diasumsikan oleh lingkungan runtime pengujian kustom selama eksekusi pengujian. Fitur ini memungkinkan pengujian Anda mengakses sumber daya AWS dengan aman di akun Anda, seperti bucket Amazon S3, tabel DynamoDB, atau layanan AWS lainnya yang menjadi sandaran aplikasi Anda.
**Topics**
+ [Gambaran umum](#iam-execution-role-overview)
+ [Persyaratan peran IAM](#iam-role-requirements)
+ [Mengkonfigurasi peran eksekusi IAM](#configuring-iam-execution-role)
+ [Praktik terbaik](#iam-role-best-practices)
+ [Pemecahan masalah](#troubleshooting-iam-roles)
## Gambaran umum
Saat Anda menentukan peran eksekusi IAM, Device Farm akan mengasumsikan peran ini selama eksekusi pengujian, memungkinkan pengujian Anda berinteraksi dengan layanan AWS menggunakan izin yang ditentukan dalam peran tersebut.
Kasus penggunaan umum untuk peran eksekusi IAM meliputi:
+ Mengakses data uji yang disimpan di bucket Amazon S3
+ Mendorong artefak uji ke ember Amazon S3
+ Mengambil konfigurasi aplikasi dari AWS AppConfig
+ Menulis log pengujian dan metrik ke Amazon CloudWatch
+ Mengirim hasil pengujian atau pesan status ke antrian Amazon SQS
+ Memanggil fungsi AWS Lambda sebagai bagian dari alur kerja pengujian
## Persyaratan peran IAM
Untuk menggunakan peran eksekusi IAM dengan Device Farm, peran Anda harus memenuhi persyaratan berikut:
+ **Hubungan kepercayaan**: Prinsipal layanan Device Farm harus dipercaya untuk mengambil peran tersebut. Kebijakan kepercayaan harus dimasukkan `devicefarm.amazonaws.com` sebagai entitas tepercaya.
+ **Izin: Peran** harus memiliki izin yang diperlukan untuk mengakses sumber daya AWS yang diperlukan pengujian Anda.
+ **Durasi sesi: Durasi** sesi maksimum peran harus setidaknya selama pengaturan batas waktu kerja proyek Device Farm Anda. Secara default, proyek Device Farm memiliki batas waktu kerja 150 menit, sehingga peran Anda harus mendukung durasi sesi minimal 150 menit.
+ **Persyaratan akun yang sama**: Peran IAM harus berada di akun AWS yang sama dengan yang digunakan untuk memanggil Device Farm. Asumsi peran lintas akun tidak didukung.
+ **PassRole izin**: Penelepon harus diberi wewenang untuk meneruskan peran IAM dengan kebijakan yang mengizinkan `iam:PassRole` tindakan pada peran eksekusi yang ditentukan.
### Contoh kebijakan kepercayaan
Contoh berikut menunjukkan kebijakan kepercayaan yang memungkinkan Device Farm mengambil peran eksekusi Anda. Kebijakan kepercayaan ini hanya boleh dilampirkan pada peran IAM tertentu yang ingin Anda gunakan dengan Device Farm, bukan peran lain di akun Anda:
**Example**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "devicefarm.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
### Contoh kebijakan izin
Contoh berikut menunjukkan kebijakan izin yang memberikan akses ke layanan AWS umum yang digunakan dalam pengujian:
**Example**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::my-test-bucket",
"arn:aws:s3:::my-test-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"appconfig:GetConfiguration",
"appconfig:StartConfigurationSession"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:log-group:/devicefarm/test-*"
},
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage",
"sqs:GetQueueUrl"
],
"Resource": "arn:aws:sqs:*:*:test-results-*"
}
]
}
```
## Mengkonfigurasi peran eksekusi IAM
Anda dapat menentukan peran eksekusi IAM di tingkat proyek atau untuk pengujian individual. Ketika dikonfigurasi pada tingkat proyek, semua berjalan dalam proyek itu akan mewarisi peran eksekusi. Peran eksekusi yang dikonfigurasi saat menjalankan akan menggantikan apa pun yang dikonfigurasi pada proyek induknya.
Untuk petunjuk terperinci tentang mengonfigurasi peran eksekusi, lihat:
+ [Membuat proyek di AWS Device Farm](how-to-create-project.md)- untuk mengkonfigurasi peran eksekusi di tingkat proyek
+ [Membuat uji coba di Device Farm](how-to-create-test-run.md)- untuk mengonfigurasi peran eksekusi untuk proses individu
Anda juga dapat mengonfigurasi peran eksekusi menggunakan Device Farm API. Untuk informasi selengkapnya, lihat [Referensi API Device Farm](https://docs.aws.amazon.com/devicefarm/latest/APIReference/).
## Praktik terbaik
Ikuti praktik terbaik ini saat mengonfigurasi peran eksekusi IAM untuk pengujian Device Farm Anda:
+ **Prinsip hak istimewa terkecil**: Berikan hanya izin minimum yang diperlukan agar pengujian Anda berfungsi. Hindari menggunakan izin yang terlalu luas seperti `*` tindakan atau sumber daya.
+ **Gunakan izin khusus sumber daya: Jika memungkinkan, batasi izin** untuk sumber daya tertentu (misalnya, bucket S3 tertentu atau tabel DynamoDB) daripada semua sumber daya dari suatu jenis.
+ **Sumber daya pengujian dan produksi terpisah**: Gunakan sumber daya dan peran pengujian khusus untuk menghindari pengaruh sistem produksi secara tidak sengaja selama pengujian.
+ **Tinjauan peran reguler**: Tinjau dan perbarui peran eksekusi Anda secara berkala untuk memastikan peran tersebut tetap memenuhi kebutuhan pengujian Anda dan mengikuti praktik terbaik keamanan.
+ **Gunakan tombol kondisi**: Pertimbangkan untuk menggunakan kunci kondisi IAM untuk lebih membatasi kapan dan bagaimana peran dapat digunakan.
## Pemecahan masalah
Jika Anda mengalami masalah dengan peran eksekusi IAM, periksa hal berikut:
+ **Hubungan kepercayaan**: Verifikasi bahwa kebijakan kepercayaan peran termasuk `devicefarm.amazonaws.com` sebagai layanan tepercaya.
+ **Izin**: Periksa apakah peran tersebut memiliki izin yang diperlukan untuk layanan AWS yang coba diakses pengujian Anda.
+ **Log pengujian**: Tinjau log eksekusi pengujian untuk pesan kesalahan tertentu yang terkait dengan panggilan AWS API atau penolakan izin.
# Variabel lingkungan untuk lingkungan pengujian khusus
Device Farm secara dinamis mengonfigurasi beberapa variabel lingkungan untuk digunakan sebagai bagian dari lingkungan pengujian kustom yang dijalankan.
**Topics**
+ [Variabel lingkungan khusus](#custom-test-environment-variables-custom)
+ [Variabel lingkungan umum](#custom-test-environment-variables-common)
+ [Variabel lingkungan untuk tes Appium](#custom-test-environment-variables-appium)
+ [Variabel lingkungan untuk XCUITest pengujian](#custom-test-environment-variables-xcuitest)
## Variabel lingkungan khusus
Device Farm mendukung konfigurasi pasangan nilai kunci yang diterapkan sebagai variabel lingkungan pada host pengujian. Ini dapat dikonfigurasi pada proyek Device Farm atau selama pembuatan run; variabel apa pun yang dikonfigurasi saat menjalankan akan menggantikan variabel apa pun yang mungkin dikonfigurasi pada proyek induknya. Pembatasan berikut berlaku:
+ Variabel lingkungan khusus tidak didukung pada host uji iOS lama. Untuk informasi selengkapnya, lihat [Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host).
+ Nama variabel yang dimulai dengan `$DEVICEFARM_` dicadangkan untuk penggunaan layanan internal.
+ Variabel lingkungan khusus tidak dapat digunakan untuk mengonfigurasi pemilihan komputasi host pengujian dalam spesifikasi pengujian Anda.
## Variabel lingkungan umum
Bagian ini menjelaskan variabel lingkungan yang umum untuk semua pengujian di Device Farm.
** `$DEVICEFARM_DEVICE_NAME` **
Perangkat tempat pengujian Anda dijalankan. Ini mewakili pengenal perangkat unik (UDID) perangkat.
** `$DEVICEFARM_DEVICE_UDID` **
Pengidentifikasi unik perangkat.
** `$DEVICEFARM_DEVICE_PLATFORM_NAME` **
Nama platform perangkat. Itu salah satu `Android` atau`iOS`.
** `$DEVICEFARM_DEVICE_OS_VERSION` **
Versi OS perangkat.
** `$DEVICEFARM_APP_PATH` **
*(tes aplikasi seluler)*
Jalur ke aplikasi seluler di mesin host tempat pengujian dijalankan. Variabel ini tidak tersedia selama pengujian web.
** `$DEVICEFARM_LOG_DIR` **
Jalur ke direktori default tempat log pelanggan, artefak, dan file yang diinginkan lainnya akan disimpan untuk pengambilan nanti. Menggunakan [contoh spesifikasi pengujian](custom-test-environment-test-spec.md#custom-test-environment-test-spec-example), file dalam direktori ini diarsipkan dalam file ZIP dan tersedia sebagai artefak setelah pengujian Anda dijalankan.
** `$DEVICEFARM_SCREENSHOT_PATH` **
Jalur ke tangkapan layar, jika ada, ditangkap selama uji coba.
** `$DEVICEFARM_PROJECT_ARN` **
ARN dari proyek induk pekerjaan.
** `$DEVICEFARM_RUN_ARN` **
ARN dari orang tua pekerjaan dijalankan.
** `$DEVICEFARM_DEVICE_ARN` **
ARN perangkat yang diuji.
** `$DEVICEFARM_TOTAL_JOBS` **
Jumlah total pekerjaan yang terkait dengan induk Device Farm run.
** `$DEVICEFARM_JOB_NUMBER` **
Jumlah pekerjaan ini di dalamnya`$DEVICEFARM_TOTAL_JOBS`. Misalnya, sebuah run mungkin berisi 5 pekerjaan, dan masing-masing akan memiliki unik `$DEVICEFARM_JOB_NUMBER` mulai dari 0 hingga 4.
** `$AWS_REGION` **
Wilayah AWS. Layanan akan mengatur ini agar sesuai dengan wilayah di mana perangkat yang diuji berada. Hal ini dapat diganti oleh variabel lingkungan kustom jika diperlukan.
** `$ANDROID_HOME` **
*(Hanya Android)*
Jalur ke direktori instalasi Android SDK.
## Variabel lingkungan untuk tes Appium
Bagian ini menjelaskan variabel lingkungan yang digunakan oleh pengujian Appium apa pun di lingkungan pengujian kustom di Device Farm.
** `$DEVICEFARM_CHROMEDRIVER_EXECUTABLE_DIR` **
*(Hanya Android)*
Lokasi direktori yang berisi ChromeDriver executable yang diperlukan untuk digunakan dalam web Appium dan tes hybrid.
** `$DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V` **
*(Hanya iOS)*
Jalur data turunan dari versi yang WebDriverAgent dibuat untuk dijalankan di Device Farm. Penomoran pada variabel akan sesuai dengan versi utama dari. WebDriverAgent Sebagai contoh, `DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V9` akan menunjuk ke WebDriverAgent versi 9.x. Untuk informasi selengkapnya, lihat [Memilih WebDriverAgent versi untuk pengujian iOS](test-types-appium.md#test-types-appium-select-wda).
Variabel `$DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V` lingkungan hanya ada di host iOS non-warisan. Untuk informasi selengkapnya, lihat [Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host).
** `$DEVICEFARM_WDA_DERIVED_DATA_PATH_V9` **
*(Hanya iOS, tidak digunakan lagi)*
Jalur data turunan dari versi yang WebDriverAgent dibuat untuk dijalankan di Device Farm. Lihat skema `$DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V` penamaan pengganti.
## Variabel lingkungan untuk XCUITest pengujian
Bagian ini menjelaskan variabel lingkungan yang digunakan oleh XCUITest pengujian di lingkungan pengujian kustom di Device Farm.
** `$DEVICEFARM_XCUITESTRUN_FILE` **
Path ke `.xctestun` file Device Farm. Ini dihasilkan dari aplikasi dan paket pengujian Anda.
** `$DEVICEFARM_DERIVED_DATA_PATH` **
Jalur yang diharapkan dari keluaran Device Farm xcodebuild.
** `$DEVICEFARM_XCTEST_BUILD_DIRECTORY` **
Jalur ke konten yang tidak di-zip dari file paket pengujian.
# Praktik terbaik untuk eksekusi lingkungan pengujian kustom
Topik berikut mencakup praktik terbaik yang direkomendasikan untuk menggunakan eksekusi pengujian kustom dengan Device Farm.
**Jalankan konfigurasi**
+ **Andalkan perangkat lunak yang dikelola Device Farm dan fitur API untuk menjalankan konfigurasi** sedapat mungkin, sebagai lawan menerapkan konfigurasi serupa melalui perintah shell dalam file spesifikasi pengujian. Ini termasuk konfigurasi host uji dan perangkat, karena ini akan lebih berkelanjutan dan konsisten di seluruh host dan perangkat uji.
Meskipun Device Farm mendorong Anda untuk menyesuaikan file spesifikasi pengujian sebanyak yang Anda butuhkan untuk menjalankan pengujian, file spesifikasi pengujian dapat menjadi sulit dipertahankan seiring waktu karena lebih banyak perintah khusus ditambahkan ke dalamnya. Menggunakan perangkat lunak yang dikelola Device Farm (melalui alat seperti ` devicefarm-cli` dan alat default yang tersedia di`$PATH`), dan menggunakan fitur terkelola (seperti parameter [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRunConfiguration.html#devicefarm-Type-ScheduleRunConfiguration-deviceProxy](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRunConfiguration.html#devicefarm-Type-ScheduleRunConfiguration-deviceProxy)permintaan) untuk menyederhanakan file spesifikasi pengujian dengan mengalihkan tanggung jawab pemeliharaan ke Device Farm itu sendiri.
**Spesifikasi uji dan kode paket uji**
+ **Jangan gunakan jalur absolut atau mengandalkan versi minor tertentu** dalam file spesifikasi pengujian atau kode paket pengujian Anda. Device Farm menerapkan pembaruan rutin ke host pengujian yang dipilih dan versi perangkat lunak yang disertakan. Menggunakan jalur spesifik atau absolut (seperti ` /usr/local/bin/python` alih-alih`python`) atau memerlukan versi minor tertentu (seperti Node.js `20.3.1` bukan hanya` 20`) dapat menyebabkan pengujian Anda gagal menemukan file/yang dapat dieksekusi yang diperlukan.
Sebagai bagian dari eksekusi pengujian kustom, Device Farm menyiapkan berbagai variabel lingkungan dan `$PATH` variabel untuk memastikan pengujian memiliki pengalaman yang konsisten dalam lingkungan dinamis kami. Lihat [Variabel lingkungan untuk lingkungan pengujian khusus](custom-test-environment-variables.md) dan [Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md) untuk informasi lebih lanjut.
+ **Simpan file yang dihasilkan atau disalin dalam direktori temp selama uji coba.** Hari ini, kami memastikan bahwa direktori temp (`/tmp`) akan dapat diakses oleh pengguna selama eksekusi pengujian (selain direktori terkelola, seperti). `$DEVICEFARM_LOG_DIR` Direktori lain yang dapat diakses pengguna dapat berubah seiring waktu karena kebutuhan layanan atau sistem operasi yang digunakan.
+ **Simpan log eksekusi pengujian Anda ke `$DEVICEFARM_LOG_DIR`**. Ini adalah direktori artefak default yang disediakan untuk eksekusi Anda untuk menambahkan log eksekusi /artefak ke dalam. [Contoh spesifikasi pengujian](custom-test-environment-test-spec.md#custom-test-environment-test-spec-example) yang kami sediakan masing-masing menggunakan direktori ini untuk artefak secara default.
+ **Pastikan perintah Anda mengembalikan kode bukan nol pada kegagalan** selama `test` fase spesifikasi pengujian Anda. Kami menentukan apakah eksekusi Anda gagal dengan memeriksa kode keluar bukan nol dari setiap perintah shell yang dipanggil selama fase. `test` Anda harus memastikan logika atau kerangka pengujian Anda akan mengembalikan kode keluar bukan nol untuk semua skenario yang diinginkan, yang mungkin memerlukan konfigurasi tambahan.
Misalnya, kerangka kerja pengujian tertentu (seperti JUnit5) tidak menganggap nol pengujian dijalankan sebagai kegagalan, yang akan menyebabkan pengujian Anda terdeteksi telah berjalan dengan sukses meskipun tidak ada yang dieksekusi. Menggunakan JUnit5 sebagai contoh, Anda perlu menentukan opsi baris perintah `--fail-if-no-tests` untuk memastikan skenario ini keluar dengan kode keluar bukan nol.
+ **Tinjau kompatibilitas perangkat lunak** dengan versi OS perangkat dan versi host uji yang akan Anda gunakan untuk uji coba. Sebagai contoh, ada fitur tertentu dalam menguji kerangka kerja perangkat lunak (yaitu: Appium) yang mungkin tidak berfungsi sebagaimana dimaksud pada semua versi OS perangkat yang sedang diuji.
**Keamanan**
+ **Hindari menyimpan atau mencatat variabel sensitif (seperti kunci AWS) di file spesifikasi pengujian Anda.** File spesifikasi pengujian, skrip yang dihasilkan spesifikasi pengujian, dan log skrip spesifikasi pengujian semuanya disediakan sebagai artefak yang dapat diunduh di akhir eksekusi pengujian. Hal ini dapat menyebabkan pemaparan rahasia yang tidak diinginkan untuk pengguna lain di akun Anda dengan akses baca ke uji coba Anda.
# Memigrasi pengujian dari lingkungan pengujian standar ke kustom
Anda dapat beralih dari mode eksekusi pengujian standar ke mode eksekusi khusus di AWS Device Farm. Migrasi terutama melibatkan dua bentuk eksekusi yang berbeda:
1. **Mode standar: Mode** eksekusi pengujian ini terutama dibangun untuk menyediakan pelaporan terperinci dan lingkungan yang dikelola sepenuhnya kepada pelanggan.
1. **Mode kustom**: Mode eksekusi pengujian ini dibuat untuk berbagai kasus penggunaan yang memerlukan uji coba lebih cepat, kemampuan untuk mengangkat dan menggeser dan mencapai paritas dengan lingkungan lokal mereka, dan streaming video langsung.
Untuk informasi selengkapnya tentang mode standar dan kustom di Device Farm, lihat [Uji lingkungan di AWS Device Farm](test-environments.md) dan[Lingkungan pengujian khusus di AWS Device Farm](custom-test-environments.md).
## Pertimbangan saat bermigrasi
Bagian ini mencantumkan beberapa kasus penggunaan yang menonjol untuk dipertimbangkan saat bermigrasi ke mode kustom:
1. **Kecepatan**: Dalam mode eksekusi standar, Device Farm mem-parsing metadata pengujian yang telah dikemas dan diunggah menggunakan instruksi pengemasan untuk kerangka kerja khusus Anda. Parsing mendeteksi jumlah tes dalam paket Anda. Setelah itu, Device Farm menjalankan setiap pengujian secara terpisah dan menyajikan log, video, dan artefak hasil lainnya secara individual untuk setiap pengujian. Namun, ini terus menambah total waktu eksekusi end-to-end pengujian karena ada pra dan pasca pemrosesan pengujian dan artefak hasil pada akhir layanan.
Sebaliknya, mode eksekusi kustom tidak mengurai paket pengujian Anda; ini berarti tidak ada pra-pemrosesan dan pasca-pemrosesan minimal untuk pengujian atau artefak hasil. Ini menghasilkan total waktu end-to-end eksekusi dekat dengan pengaturan lokal Anda. Pengujian dijalankan dalam format yang sama seperti jika dijalankan pada mesin lokal Anda. Hasil tes sama dengan apa yang Anda dapatkan secara lokal dan tersedia untuk diunduh di akhir pelaksanaan pekerjaan.
1. **Kustomisasi atau Fleksibilitas**: Mode eksekusi standar mem-parsing paket pengujian Anda untuk mendeteksi jumlah pengujian dan kemudian menjalankan setiap pengujian secara terpisah. Perhatikan bahwa tidak ada jaminan bahwa tes akan berjalan sesuai urutan yang Anda tentukan. Akibatnya, tes yang membutuhkan urutan eksekusi tertentu mungkin tidak berfungsi seperti yang diharapkan. Selain itu, tidak ada cara untuk menyesuaikan lingkungan mesin host atau meneruskan file konfigurasi yang mungkin diperlukan untuk menjalankan pengujian Anda dengan cara tertentu.
Sebaliknya, mode kustom memungkinkan Anda mengonfigurasi lingkungan mesin host termasuk kemampuan untuk menginstal perangkat lunak tambahan, meneruskan filter ke pengujian Anda, meneruskan file konfigurasi, dan mengontrol pengaturan eksekusi pengujian. Ini mencapai ini melalui file yaml (juga disebut file testspec) yang dapat Anda modifikasi dengan menambahkan perintah shell ke dalamnya. File yaml ini akan dikonversi ke skrip shell yang dieksekusi pada mesin host uji. Anda dapat menyimpan beberapa file yaml dan memilih satu secara dinamis sesuai kebutuhan Anda saat Anda menjadwalkan proses.
1. **Video langsung dan logging**: Mode eksekusi standar dan kustom memberi Anda video dan log untuk pengujian Anda. Namun, dalam mode standar, Anda mendapatkan video dan log pengujian yang telah ditentukan sebelumnya hanya setelah pengujian Anda selesai.
Sebaliknya, mode kustom memberi Anda streaming langsung video dan log sisi klien pengujian Anda. Selain itu, Anda dapat mengunduh video dan artefak lainnya di akhir tes.
**Tip**
Jika kasus penggunaan Anda melibatkan setidaknya satu dari faktor di atas, kami sangat menyarankan untuk beralih ke mode eksekusi kustom.
## Langkah migrasi
Untuk bermigrasi dari mode standar ke mode khusus, lakukan hal berikut:
1. Masuk ke Konsol Manajemen AWS dan buka konsol Device Farm di [https://console.aws.amazon.com/devicefarm/](https://console.aws.amazon.com/devicefarm/).
1. Pilih proyek Anda dan kemudian mulai menjalankan otomatisasi baru.
1. Unggah aplikasi Anda (atau pilih`web app`), pilih jenis kerangka pengujian Anda, unggah paket pengujian Anda, lalu di bawah `Choose your execution environment` parameter, pilih opsi untuk`Run your test in a custom environment`.
1. Secara default, file spesifikasi pengujian contoh Device Farm akan muncul untuk Anda lihat dan edit. File contoh ini dapat digunakan sebagai tempat awal untuk mencoba pengujian Anda dalam [mode lingkungan khusus](https://docs.aws.amazon.com/devicefarm/latest/developerguide/custom-test-environments.html). Kemudian, setelah Anda memverifikasi bahwa pengujian Anda berfungsi dengan baik dari konsol, Anda kemudian dapat mengubah integrasi API, CLI, dan pipeline apa pun dengan Device Farm untuk menggunakan file spesifikasi pengujian ini sebagai parameter saat penjadwalan pengujian berjalan. Untuk informasi tentang cara menambahkan file spesifikasi pengujian sebagai parameter untuk proses Anda, lihat bagian `testSpecArn` parameter untuk `ScheduleRun` API di [panduan API](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html) kami.
## Kerangka Appium
Dalam lingkungan pengujian khusus, Device Farm tidak menyisipkan atau mengganti kemampuan Appium apa pun dalam pengujian kerangka kerja Appium Anda. Anda harus menentukan kemampuan Appium pengujian Anda baik dalam file YAMM spesifikasi pengujian atau kode pengujian Anda.
## Instrumentasi Android
Anda tidak perlu membuat perubahan untuk memindahkan pengujian instrumentasi Android ke lingkungan pengujian khusus.
## iOS XCUITest
Anda tidak perlu membuat perubahan untuk memindahkan XCUITest pengujian iOS Anda ke lingkungan pengujian khusus.
# Memperluas lingkungan pengujian khusus di Device Farm
AWS Device Farm memungkinkan mengonfigurasi lingkungan khusus untuk pengujian otomatis (mode kustom), yang merupakan pendekatan yang disarankan untuk semua pengguna Device Farm. Mode kustom Device Farm memungkinkan Anda menjalankan lebih dari sekadar rangkaian pengujian. Di bagian ini, Anda mempelajari cara memperluas rangkaian pengujian dan mengoptimalkan pengujian Anda.
Untuk informasi selengkapnya tentang lingkungan pengujian kustom di Device Farm, lihat[Lingkungan pengujian khusus di AWS Device Farm](custom-test-environments.md).
**Topics**
+ [Menyetel PIN perangkat saat menjalankan pengujian di Device Farm](custom-test-environments-extending-set-pin.md)
+ [Mempercepat pengujian berbasis Appium di Device Farm melalui kemampuan yang diinginkan](custom-test-environments-extending-speed.md)
+ [Menggunakan Webhook dan lainnya APIs setelah pengujian dijalankan di Device Farm](custom-test-environments-extending-webhooks.md)
+ [Menambahkan file tambahan ke paket pengujian Anda di Device Farm](custom-test-environments-extending-files.md)
# Menyetel PIN perangkat saat menjalankan pengujian di Device Farm
Beberapa aplikasi mengharuskan Anda mengatur PIN pada perangkat. Device Farm tidak mendukung pengaturan PIN pada perangkat secara native. Namun, ini dimungkinkan dengan peringatan berikut:
+ Perangkat harus menjalankan Android 8 atau lebih tinggi.
+ PIN harus dilepas setelah tes selesai.
Untuk menyetel PIN dalam pengujian Anda, gunakan `post_test` fase `pre_test` dan untuk mengatur dan menghapus PIN, seperti yang ditunjukkan berikut:
```
phases:
pre_test:
- # ... among your pre_test commands
- DEVICE_PIN_CODE="1234"
- adb shell locksettings set-pin "$DEVICE_PIN_CODE"
post_test:
- # ... Among your post_test commands
- adb shell locksettings clear --old "$DEVICE_PIN_CODE"
```
Saat rangkaian pengujian Anda dimulai, PIN 1234 disetel. Setelah rangkaian pengujian Anda keluar, PIN akan dihapus.
**Awas**
Jika Anda tidak menghapus PIN dari perangkat setelah pengujian selesai, perangkat dan akun Anda akan dikarantina.
Untuk lebih banyak cara untuk memperluas rangkaian pengujian dan mengoptimalkan pengujian, lihat[Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md).
# Mempercepat pengujian berbasis Appium di Device Farm melalui kemampuan yang diinginkan
Saat menggunakan Appium, Anda mungkin menemukan bahwa rangkaian pengujian mode standar sangat lambat. Ini karena Device Farm menerapkan pengaturan default dan tidak membuat asumsi tentang bagaimana Anda ingin menggunakan lingkungan Appium. Meskipun default ini dibangun di sekitar praktik terbaik industri, mereka mungkin tidak berlaku untuk situasi Anda. Untuk menyempurnakan parameter server Appium, Anda dapat menyesuaikan kemampuan Appium default dalam spesifikasi pengujian Anda. Misalnya, berikut ini menyetel `usePrebuildWDA` kemampuan ke `true` dalam rangkaian pengujian iOS untuk mempercepat waktu mulai awal:
```
phases:
pre_test:
- # ... Start up Appium
- >-
appium --log-timestamp
--default-capabilities "{\"usePrebuiltWDA\": true, \"derivedDataPath\":\"$DEVICEFARM_WDA_DERIVED_DATA_PATH\",
\"deviceName\": \"$DEVICEFARM_DEVICE_NAME\", \"platformName\":\"$DEVICEFARM_DEVICE_PLATFORM_NAME\", \"app\":\"$DEVICEFARM_APP_PATH\",
\"automationName\":\"XCUITest\", \"udid\":\"$DEVICEFARM_DEVICE_UDID_FOR_APPIUM\", \"platformVersion\":\"$DEVICEFARM_DEVICE_OS_VERSION\"}"
>> $DEVICEFARM_LOG_DIR/appiumlog.txt 2>&1 &
```
Kemampuan Appium harus berupa struktur JSON yang dikutip dari cangkang.
Kemampuan Appium berikut adalah sumber umum peningkatan kinerja:
`noReset` dan `fullReset`
Kedua kemampuan ini, yang saling eksklusif, menggambarkan perilaku Appium setelah setiap sesi selesai. Ketika `noReset` disetel ke`true`, server Appium tidak menghapus data dari aplikasi Anda ketika sesi Appium berakhir, secara efektif tidak melakukan pembersihan apa pun. `fullReset`menghapus instalasi dan menghapus semua data aplikasi dari perangkat setelah sesi ditutup. Untuk informasi selengkapnya, lihat [Reset Strategi](http://appium.io/docs/en/writing-running-appium/other/reset-strategies/) dalam dokumentasi Appium.
`ignoreUnimportantViews`(Hanya Android)
Menginstruksikan Appium untuk mengompres hierarki UI Android hanya ke tampilan *yang relevan* untuk pengujian, mempercepat pencarian elemen tertentu. Namun, ini dapat merusak beberapa suite pengujian XPath berbasis karena hierarki tata letak UI telah diubah.
`skipUnlock`(Hanya Android)
Menginformasikan Appium bahwa tidak ada kode PIN yang saat ini disetel, yang mempercepat pengujian setelah peristiwa layar mati atau peristiwa kunci lainnya.
`webDriverAgentUrl`(Hanya iOS)
Menginstruksikan Appium untuk menganggap bahwa ketergantungan iOS penting,`webDriverAgent`, sudah berjalan dan tersedia untuk menerima permintaan HTTP di URL yang ditentukan. Jika `webDriverAgent` belum aktif dan berjalan, Appium membutuhkan waktu beberapa saat di awal rangkaian pengujian untuk memulai. `webDriverAgent` Jika Anda memulai `webDriverAgent` sendiri dan mengatur `webDriverAgentUrl` ke `http://localhost:8100` saat memulai Appium, Anda dapat mem-boot suite pengujian Anda lebih cepat. Perhatikan bahwa kemampuan ini tidak boleh digunakan bersama `useNewWDA` kemampuan.
Anda dapat menggunakan kode berikut untuk memulai `webDriverAgent` dari file spesifikasi pengujian di port lokal perangkat`8100`, lalu meneruskannya ke port lokal host pengujian `8100` (ini memungkinkan Anda untuk menetapkan `webDriverAgentUrl` nilainya`http://localhost:8100`). Kode ini harus dijalankan selama fase penginstalan setelah kode apa pun untuk menyiapkan variabel Appium dan `webDriverAgent` lingkungan telah ditentukan:
```
# Start WebDriverAgent and iProxy
- >-
xcodebuild test-without-building -project /usr/local/avm/versions/$APPIUM_VERSION/node_modules/appium/node_modules/appium-webdriveragent/WebDriverAgent.xcodeproj
-scheme WebDriverAgentRunner -derivedDataPath $DEVICEFARM_WDA_DERIVED_DATA_PATH
-destination id=$DEVICEFARM_DEVICE_UDID_FOR_APPIUM IPHONEOS_DEPLOYMENT_TARGET=$DEVICEFARM_DEVICE_OS_VERSION
GCC_TREAT_WARNINGS_AS_ERRORS=0 COMPILER_INDEX_STORE_ENABLE=NO >> $DEVICEFARM_LOG_DIR/webdriveragent_log.txt 2>&1 &
iproxy 8100 8100 >> $DEVICEFARM_LOG_DIR/iproxy_log.txt 2>&1 &
```
Kemudian, Anda dapat menambahkan kode berikut ke file spesifikasi pengujian Anda untuk memastikannya berhasil `webDriverAgent` dimulai. Kode ini harus dijalankan pada akhir fase pra-pengujian setelah memastikan bahwa Appium berhasil dimulai:
```
# Wait for WebDriverAgent to start
- >-
start_wda_timeout=0;
while [ true ];
do
if [ $start_wda_timeout -gt 60 ];
then
echo "WebDriverAgent server never started in 60 seconds.";
exit 1;
fi;
grep -i "ServerURLHere" $DEVICEFARM_LOG_DIR/webdriveragent_log.txt >> /dev/null 2>&1;
if [ $? -eq 0 ];
then
echo "WebDriverAgent REST http interface listener started";
break;
else
echo "Waiting for WebDriverAgent server to start. Sleeping for 1 seconds";
sleep 1;
start_wda_timeout=$((start_wda_timeout+1));
fi;
done;
```
Untuk informasi selengkapnya tentang kemampuan yang didukung Appium, lihat [Kemampuan yang Diinginkan Appium](http://appium.io/docs/en/writing-running-appium/caps/) dalam dokumentasi Appium.
Untuk lebih banyak cara untuk memperluas rangkaian pengujian dan mengoptimalkan pengujian, lihat[Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md).
# Menggunakan Webhook dan lainnya APIs setelah pengujian dijalankan di Device Farm
Anda dapat meminta Device Farm memanggil webhook setelah setiap rangkaian pengujian selesai digunakan. **curl** Proses untuk melakukan ini bervariasi dengan tujuan dan pemformatan. Untuk webhook spesifik Anda, lihat dokumentasi untuk webhook tersebut. Contoh berikut memposting pesan setiap kali rangkaian pengujian selesai ke webhook Slack:
```
phases:
post_test:
- curl -X POST -H 'Content-type: application/json' --data '{"text":"Tests on '$DEVICEFARM_DEVICE_NAME' have finished!"}' https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
```
Untuk informasi selengkapnya tentang penggunaan webhook dengan Slack, lihat [Mengirim pesan Slack pertama Anda menggunakan Webhook](https://api.slack.com/tutorials/slack-apps-hello-world) di referensi Slack API.
Untuk lebih banyak cara untuk memperluas rangkaian pengujian dan mengoptimalkan pengujian, lihat[Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md).
Anda tidak terbatas pada menggunakan **curl** untuk memanggil webhooks. Paket pengujian dapat menyertakan skrip dan alat tambahan, asalkan kompatibel dengan lingkungan eksekusi Device Farm. Misalnya, paket pengujian Anda mungkin menyertakan skrip tambahan yang membuat permintaan ke yang lain APIs. Pastikan bahwa setiap paket yang diperlukan diinstal bersamaan dengan persyaratan suite pengujian Anda. Untuk menambahkan skrip yang berjalan setelah rangkaian pengujian Anda selesai, sertakan skrip dalam paket pengujian Anda dan tambahkan yang berikut ini ke spesifikasi pengujian Anda:
```
phases:
post_test:
- python post_test.py
```
**catatan**
Mempertahankan kunci API atau token otentikasi lain yang digunakan dalam paket pengujian Anda adalah tanggung jawab Anda. Kami menyarankan agar Anda menyimpan segala bentuk kredensi keamanan di luar kendali sumber, menggunakan kredensil dengan hak istimewa sesedikit mungkin, dan menggunakan token yang dapat diulang dan berumur pendek bila memungkinkan. Untuk memverifikasi persyaratan keamanan, lihat dokumentasi untuk pihak ketiga APIs yang Anda gunakan.
Jika Anda berencana menggunakan AWS layanan sebagai bagian dari rangkaian eksekusi pengujian, Anda harus menggunakan kredenal sementara IAM, yang dihasilkan di luar rangkaian pengujian dan disertakan dalam paket pengujian Anda. Kredensi ini harus memiliki izin paling sedikit yang diberikan dan umur sesingkat mungkin. *Untuk informasi selengkapnya tentang cara membuat kredensil sementara, lihat [Meminta kredensil keamanan sementara di Panduan Pengguna IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_temp_request.html).*
Untuk lebih banyak cara untuk memperluas rangkaian pengujian dan mengoptimalkan pengujian, lihat[Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md).
# Menambahkan file tambahan ke paket pengujian Anda di Device Farm
Anda mungkin ingin menggunakan file tambahan sebagai bagian dari pengujian Anda baik sebagai file konfigurasi tambahan atau data pengujian tambahan. Anda dapat menambahkan file tambahan ini ke paket pengujian sebelum mengunggahnya AWS Device Farm, lalu mengaksesnya dari mode lingkungan khusus. Pada dasarnya, semua format unggahan paket uji (ZIP, IPA, APK, JAR, dll.) Adalah format arsip paket yang mendukung operasi ZIP standar.
Anda dapat menambahkan file ke arsip pengujian sebelum mengunggahnya AWS Device Farm dengan menggunakan perintah berikut:
```
$ zip zip-with-dependencies.zip extra_file
```
Untuk direktori file tambahan:
```
$ zip -r zip-with-dependencies.zip extra_files/
```
Perintah ini berfungsi seperti yang diharapkan untuk semua format unggahan paket pengujian kecuali untuk file IPA. Untuk file IPA, terutama saat digunakan XCUITests, kami sarankan Anda meletakkan file tambahan di lokasi yang sedikit berbeda karena cara AWS Device Farm mengundurkan diri paket uji iOS. Saat membuat pengujian iOS Anda, direktori aplikasi pengujian akan berada di dalam direktori lain bernama*Payload*.
Misalnya, ini adalah bagaimana satu direktori pengujian iOS seperti itu terlihat:
```
$ tree
.
└── Payload
└── ADFiOSReferenceAppUITests-Runner.app
├── ADFiOSReferenceAppUITests-Runner
├── Frameworks
│ ├── XCTAutomationSupport.framework
│ │ ├── Info.plist
│ │ ├── XCTAutomationSupport
│ │ ├── _CodeSignature
│ │ │ └── CodeResources
│ │ └── version.plist
│ └── XCTest.framework
│ ├── Info.plist
│ ├── XCTest
│ ├── _CodeSignature
│ │ └── CodeResources
│ ├── en.lproj
│ │ └── InfoPlist.strings
│ └── version.plist
├── Info.plist
├── PkgInfo
├── PlugIns
│ ├── ADFiOSReferenceAppUITests.xctest
│ │ ├── ADFiOSReferenceAppUITests
│ │ ├── Info.plist
│ │ └── _CodeSignature
│ │ └── CodeResources
│ └── ADFiOSReferenceAppUITests.xctest.dSYM
│ └── Contents
│ ├── Info.plist
│ └── Resources
│ └── DWARF
│ └── ADFiOSReferenceAppUITests
├── _CodeSignature
│ └── CodeResources
└── embedded.mobileprovision
```
Untuk XCUITest paket-paket ini, tambahkan file tambahan ke direktori yang berakhir di *.app* dalam *Payload* direktori. Misalnya, perintah berikut menunjukkan bagaimana Anda dapat menambahkan file ke paket pengujian ini:
```
$ mv extra_file Payload/*.app/
$ zip -r my_xcui_tests.ipa Payload/
```
Saat menambahkan file ke paket pengujian, Anda dapat mengharapkan perilaku interaksi yang sedikit berbeda AWS Device Farm berdasarkan format unggahannya. Jika unggahan menggunakan ekstensi file ZIP, secara otomatis AWS Device Farm akan membuka zip unggahan sebelum pengujian Anda dan membiarkan file yang tidak di-zip di lokasi dengan variabel lingkungan. *\$1DEVICEFARM\$1TEST\$1PACKAGE\$1PATH* (Ini berarti bahwa jika Anda menambahkan file yang dipanggil *extra\$1file* ke root arsip seperti pada contoh pertama, itu akan ditempatkan di *\$1DEVICEFARM\$1TEST\$1PACKAGE\$1PATH/extra\$1file* selama pengujian).
Untuk menggunakan contoh yang lebih praktis, jika Anda adalah pengguna Appium TestNG yang ingin menyertakan *testng.xml* file dengan pengujian Anda, Anda dapat memasukkannya ke dalam arsip menggunakan perintah berikut:
```
$ zip zip-with-dependencies.zip testng.xml
```
Kemudian, Anda dapat mengubah perintah pengujian Anda dalam mode lingkungan khusus menjadi berikut:
```
java -D appium.screenshots.dir=$DEVICEFARM_SCREENSHOT_PATH org.testng.TestNG -testjar *-tests.jar -d $DEVICEFARM_LOG_DIR/test-output $DEVICEFARM_TEST_PACKAGE_PATH/testng.xml
```
Jika ekstensi unggahan paket pengujian Anda bukan ZIP (misalnya, file APK, IPA, atau JAR), file paket yang diunggah itu sendiri dapat ditemukan di. *\$1DEVICEFARM\$1TEST\$1PACKAGE\$1PATH* Karena ini masih file format arsip, Anda dapat unzip file untuk mengakses file tambahan dari dalam. Misalnya, perintah berikut akan membuka zip isi paket pengujian (untuk file APK, IPA, atau JAR) ke direktori: */tmp*
```
unzip $DEVICEFARM_TEST_PACKAGE_PATH -d /tmp
```
Dalam kasus file APK atau JAR, Anda akan menemukan file tambahan Anda dibuka ritsleting ke */tmp* direktori (misalnya,*/tmp/extra\$1file*). Dalam kasus file IPA, seperti yang dijelaskan sebelumnya, file tambahan akan berada di lokasi yang sedikit berbeda di dalam folder yang diakhiri*.app*, yang ada di dalam *Payload* direktori. Misalnya, berdasarkan contoh IPA di atas, file akan ditemukan di lokasi */tmp/Payload/ADFiOSReferenceAppUITests-Runner.app/extra\$1file* (dapat direferensikan sebagai). */tmp/Payload/\$1.app/extra\$1file*
Untuk lebih banyak cara untuk memperluas rangkaian pengujian dan mengoptimalkan pengujian, lihat[Memperluas lingkungan pengujian khusus di Device Farm](custom-test-environments-extending.md).