Weitere AWS SDK-Beispiele sind im GitHub Repo [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) verfügbar.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Codebeispiele für Device Farm mit AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie es AWS Device Farm mit einem AWS Software Development Kit (SDK) verwenden.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
*Szenarien* sind Codebeispiele, die Ihnen zeigen, wie Sie bestimmte Aufgaben ausführen, indem Sie mehrere Funktionen innerhalb eines Service aufrufen oder mit anderen AWS-Services kombinieren.
**Weitere -Quellen**
+ **[Device-Farm-Entwicklerhandbuch](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html)** – Weitere Informationen zu Device Farm.
+ **[API-Referenz für Device Farm](https://docs.aws.amazon.com/devicefarm/latest/APIReference/Welcome.html)** – Details zu allen verfügbaren Device-Farm-Aktionen.
+ **[AWS Developer Center](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-product=product%23device-farm)** — Codebeispiele, die Sie nach Kategorie oder Volltextsuche filtern können.
+ **[AWS SDK-Beispiele](https://github.com/awsdocs/aws-doc-sdk-examples)** — GitHub Repo mit vollständigem Code in bevorzugten Sprachen. Enthält Anleitungen zum Einrichten und Ausführen des Codes.
**Contents**
+ [Grundlagen](device-farm_code_examples_basics.md)
+ [Aktionen](device-farm_code_examples_actions.md)
+ [`CreateUpload`](device-farm_example_device-farm_CreateUpload_section.md)
+ [Szenarien](device-farm_code_examples_scenarios.md)
+ [Ausführen von Browsertests und Erstellen von Screenshots](device-farm_example_device-farm_Scenario_BrowserTesting_section.md)
+ [Hochladen und Testen von Gerätepaketen](device-farm_example_device-farm_Scenario_DeviceTesting_section.md)
# Grundlegende Beispiele für die Verwendung von Device Farm AWS SDKs
Die folgenden Codebeispiele zeigen, wie die Grundlagen von AWS Device Farm with verwendet AWS SDKs werden.
**Contents**
+ [Aktionen](device-farm_code_examples_actions.md)
+ [`CreateUpload`](device-farm_example_device-farm_CreateUpload_section.md)
# Aktionen für die Verwendung von Device Farm AWS SDKs
Die folgenden Codebeispiele zeigen, wie einzelne Device Farm Farm-Aktionen mit ausgeführt AWS SDKs werden. Jedes Beispiel enthält einen Link zu GitHub, wo Sie Anweisungen zum Einrichten und Ausführen des Codes finden.
Diese Auszüge rufen die Device-Farm-API auf und sind Codeauszüge aus größeren Programmen, die im Kontext ausgeführt werden müssen. Sie können Aktionen im Kontext unter [Szenarien für die Verwendung von Device Farm AWS SDKs](device-farm_code_examples_scenarios.md) anzeigen.
Die folgenden Beispiele enthalten nur die am häufigsten verwendeten Aktionen. Eine vollständige Liste finden Sie in der [AWS Device Farm -API-Referenz](https://docs.aws.amazon.com/devicefarm/latest/APIReference/Welcome.html).
**Topics**
+ [`CreateUpload`](device-farm_example_device-farm_CreateUpload_section.md)
# Verwendung von `CreateUpload` mit einer CLI
Die folgenden Code-Beispiele zeigen, wie `CreateUpload` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Hochladen und Testen von Gerätepaketen](device-farm_example_device-farm_Scenario_DeviceTesting_section.md)
------
#### [ CLI ]
**AWS CLI**
**So erstellen Sie einen Upload**
Der folgende Befehl erstellt einen Upload für eine Android-App:
```
aws devicefarm create-upload --project-arn "arn:aws:devicefarm:us-west-2:123456789012:project:070fc3ca-7ec1-4741-9c1f-d3e044efc506" --name app.apk --type ANDROID_APP
```
Sie können den Projekt-ARN aus der Ausgabe von create-project oder list-projects abrufen.
Ausgabe:
```
{
"upload": {
"status": "INITIALIZED",
"name": "app.apk",
"created": 1503614408.769,
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/arn%3Aaws%3Adevicefarm%3Aus-west-2%3A123456789012%3Aproject%3A070fc3ca-c7e1-4471-91cf-d3e4efc50604/uploads/arn%3Aaws%3Adevicefarm%3Aus-west-2%3A123456789012%3Aupload%3A070fc3ca-7ec1-4741-9c1f-d3e044efc506/dd72723a-ae9e-4087-09e6-f4cea3599514/app.apk?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20170824T224008Z&X-Amz-SignedHeaders=host&X-Amz-Expires=86400&X-Amz-Credential=AKIAEXAMPLEPBUMBC3GA%2F20170824%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Signature=05050370c38894ef5bd09f5d009f36fc8f96fa4bb04e1bba9aca71b8dbe49a0f",
"type": "ANDROID_APP",
"arn": "arn:aws:devicefarm:us-west-2:123456789012:upload:070fc3ca-7ec1-4741-9c1f-d3e044efc506/dd72723a-ae9e-4087-09e6-f4cea3599514"
}
}
```
Verwenden Sie die signierte URL in der Ausgabe, um eine Datei auf Device Farm hochzuladen:
```
curl -T app.apk "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/arn%3Aaws%3Adevicefarm%3Aus-west-2%3A123456789012%3Aproject%3A070fc3ca-c7e1-4471-91cf-d3e4efc50604/uploads/arn%3Aaws%3Adevicefarm%3Aus-west-2%3A123456789012%3Aupload%3A070fc3ca-7ec1-4741-9c1f-d3e044efc506/dd72723a-ae9e-4087-09e6-f4cea3599514/app.apk?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20170824T224008Z&X-Amz-SignedHeaders=host&X-Amz-Expires=86400&X-Amz-Credential=AKIAEXAMPLEPBUMBC3GA%2F20170824%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Signature=05050370c38894ef5bd09f5d009f36fc8f96fa4bb04e1bba9aca71b8dbe49a0f"
```
+ Einzelheiten zur API finden Sie [CreateUpload](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/devicefarm/create-upload.html)in der *AWS CLI Befehlsreferenz*.
------
#### [ PowerShell ]
**Tools für PowerShell V4**
**Beispiel 1: In diesem Beispiel wird ein AWS Device Farm Farm-Upload für eine Android-App erstellt. Sie können den Projekt-ARN aus der Ausgabe von New- DFProject oder Get- DFProject List abrufen. Verwenden Sie die signierte URL in der DFUpload Ausgabe New-, um eine Datei auf Device Farm hochzuladen.**
```
New-DFUpload -ContentType "application/octet-stream" -ProjectArn "arn:aws:devicefarm:us-west-2:123456789012:project:EXAMPLEa-7ec1-4741-9c1f-d3e04EXAMPLE" -Name "app.apk" -Type ANDROID_APP
```
+ Einzelheiten zur API finden Sie unter [CreateUpload AWS -Tools für PowerShell](https://docs.aws.amazon.com/powershell/v4/reference)*Cmdlet-Referenz (V4).*
**Tools für V5 PowerShell **
**Beispiel 1: In diesem Beispiel wird ein AWS Device Farm Farm-Upload für eine Android-App erstellt. Sie können den Projekt-ARN aus der Ausgabe von New- DFProject oder Get- DFProject List abrufen. Verwenden Sie die signierte URL in der DFUpload Ausgabe New-, um eine Datei auf Device Farm hochzuladen.**
```
New-DFUpload -ContentType "application/octet-stream" -ProjectArn "arn:aws:devicefarm:us-west-2:123456789012:project:EXAMPLEa-7ec1-4741-9c1f-d3e04EXAMPLE" -Name "app.apk" -Type ANDROID_APP
```
+ Einzelheiten zur API finden Sie unter [CreateUpload AWS -Tools für PowerShell](https://docs.aws.amazon.com/powershell/v5/reference)*Cmdlet-Referenz (V5*).
------
# Szenarien für die Verwendung von Device Farm AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie allgemeine Szenarien in Device Farm mit implementieren AWS SDKs. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben durch den Aufruf mehrerer Funktionen innerhalb von Device Farm oder in Kombination mit anderen AWS-Services ausführen können. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Ausführen von Browsertests und Erstellen von Screenshots](device-farm_example_device-farm_Scenario_BrowserTesting_section.md)
+ [Hochladen und Testen von Gerätepaketen](device-farm_example_device-farm_Scenario_DeviceTesting_section.md)
# Führen Sie Browsertests mit Device Farm durch und machen Sie Screenshots mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie Sie mit Device-Farm-Browsertests durchführen und Screenshots erstellen können.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/devicefarm/browser_testing#code-examples) einrichten und ausführen.
Verwenden Sie PyTest und Selenium, um bestimmte Websites aufzurufen, Screenshots zu machen und den tatsächlichen Inhalt der Website mit dem erwarteten Inhalt zu vergleichen.
```
import datetime
import os
import subprocess
import boto3
import pytest
from selenium import webdriver
from selenium.webdriver import DesiredCapabilities
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.wait import WebDriverWait
def get_git_hash():
"""
Get the short Git hash of the current commit of the repository
"""
try:
return (
subprocess.check_output(["git", "rev-parse", "--short", "HEAD"])
.decode("utf-8")
.strip()
)
except:
return "norepo"
class TestHelloSuite:
"""
Our test suite.
This style of test suite allows us to use setup_method and teardown_method.
"""
def save_screenshot(self, name):
self.driver.save_screenshot(os.path.join(self.screenshot_path, name))
def setup_method(self, method):
"""
Set up a test.
This makes sure that the session for an individual test is ready.
The AWS credentials are read from the default ~/.aws/credentials or from the
command line by setting the AWS_ACCESS_KEY_ID and AWS_SECRET_KEY environment
variables.
The project Amazon Resource Name (ARN) is determined by the PROJECT_ARN
environment variable.
"""
devicefarm_client = boto3.client("devicefarm")
project_arn = os.environ.get("PROJECT_ARN", None)
if project_arn is None:
raise ValueError("Must set PROJECT_ARN")
# Request a driver hub URL for the Selenium client
testgrid_url_response = devicefarm_client.create_test_grid_url(
projectArn=project_arn, expiresInSeconds=300
)
# We want a directory to save our files into. We're going to make a directory
# in the current directory that holds our results.
self.screenshot_path = os.path.join(
".", "results", get_git_hash() + "-" + (datetime.date.today().isoformat())
)
if not os.path.exists(self.screenshot_path):
os.makedirs(self.screenshot_path, exist_ok=True)
# We want a Firefox instance on Windows
desired_cap = DesiredCapabilities.FIREFOX
desired_cap["platform"] = "windows"
desired_cap["BrowserVersion"] = "latest"
# Configure the webdriver with the appropriate remote endpoint.
self.driver = webdriver.Remote(testgrid_url_response["url"], desired_cap)
#
# Auto-Tagging
#
# In order to get the Session ARN, we need to look up the session by the
# Project ARN and session ID (from the driver).
testgrid_session_arn_response = devicefarm_client.get_test_grid_session(
projectArn=project_arn, sessionId=self.driver.session_id
)
# Save the session's ARN so we can tag the session.
self.session_arn = testgrid_session_arn_response["testGridSession"]["arn"]
# In order to tag it, we're going to use the resourcegroupstaggingapi client to
# add a tag to the session ARN that we just got.
tag_client = boto3.client("resourcegroupstaggingapi")
tag_client.tag_resources(
ResourceARNList=[self.session_arn],
Tags={"TestSuite": f"testsuite {method.__name__}", "GitId": get_git_hash()},
)
def teardown_method(self, method):
"""
Clean up resources used by each method.
"""
# End the Selenium session so we're off the clock.
self.driver.quit()
@pytest.mark.parametrize(
"query,leading",
[
pytest.param(
"Seattle",
"Seattle (/siˈætəl/ (listen) see-AT-əl) is a seaport city on the West Coast of the United States.",
),
pytest.param(
"Selenium",
"Selenium is a chemical element with the symbol Se and atomic number 34.",
),
pytest.param(
"Amazon Locker",
"Amazon Locker is a self-service package delivery service offered by online retailer Amazon.",
),
pytest.param(
"Kootenai Falls",
"Kootenai Falls is a waterfall on the Kootenay River located in Lincoln County, Montana, just off U.S. Route 2.",
),
pytest.param(
"Dorayaki",
"Dorayaki (どら焼き, どらやき, 銅鑼焼き, ドラ焼き) is a type of Japanese confection.",
),
pytest.param("Robot Face", "<|°_°|> (also known as Robot Face or Robot)"),
],
)
def test_first_paragraph_text(self, query, leading):
"""
This test looks at the first paragraph of a page on Wikipedia, comparing it to
a known leading sentence.
If the leading sentence matches, the test passes. A screenshot is taken before
the final assertion is made, letting us debug if something isn't right.
"""
# Open the main page of Wikipedia
self.driver.get("https://en.wikipedia.org/wiki/Main_Page")
# Find the search box, enter a query, and press enter
search_input = self.driver.find_element(By.ID, "searchInput")
search_input.click()
search_input.send_keys(query)
search_input.send_keys(Keys.ENTER)
# Wait for the search box to go stale -- This means we've navigated fully.
WebDriverWait(self.driver, 5).until(
expected_conditions.staleness_of(search_input)
)
# Get the leading paragraph of the article.
lead = leading.lower()
# Find the element...
lead_para = self.driver.find_element(
By.XPATH, "//div[@class='mw-parser-output']//p[not(@class)]"
)
# ... and copy out its text.
our_text = lead_para.text.lower()
our_text = our_text[: len(lead)]
# Take a screenshot and compare the strings.
self.save_screenshot(f"leadingpara_{query}.png")
assert our_text.startswith(lead)
@pytest.mark.parametrize(
"query,expected",
[
pytest.param("Automation Testing", "Test Automation"),
pytest.param("DevOps", "DevOps"),
pytest.param("Jackdaws Love My Big Sphinx Of Quartz", "Pangram"),
pytest.param("EarthBound", "EarthBound"),
pytest.param("Covered Bridges Today", "Covered Bridges Today"),
pytest.param("Kurt Godel", "Kurt Gödel"),
pytest.param("N//ng language", "Nǁng language"),
pytest.param(
"Who the Frick Is Jackson Pollock?", "Who the $&% Is Jackson Pollock?"
),
],
)
def test_redirect_titles(self, query, expected):
"""
A test comparing pages we expect to (or not to) redirect on Wikipedia.
This test checks to see that the page ("query") redirects (or doesn't) to the
"expected" page title. Several of these are common synonyms ("Jackdaws...")
while others are because of characters untypable by most keyboards ("Nǁng language")
A screenshot is taken just before the final assertion is made to aid in
debugging and verification.
"""
# Open the main page of Wikipedia
self.driver.get("https://en.wikipedia.org/wiki/Main_Page")
# Find the search box, enter some text into it, and send an enter key.
search_input = self.driver.find_element(By.ID, "searchInput")
search_input.click()
search_input.send_keys(query)
search_input.send_keys(Keys.ENTER)
# wait until the page has rolled over -- once the search input handle is stale,
# the browser has navigated.
WebDriverWait(self.driver, 5).until(
expected_conditions.staleness_of(search_input)
)
# Get the first heading & take a screenshot
our_text = self.driver.find_element(By.ID, "firstHeading").text.lower()
self.save_screenshot(f"redirect_{query}.png")
# did it match?
assert our_text == expected.lower()
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für Python (Boto3)*.
+ [CreateTestGridUrl](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/CreateTestGridUrl)
+ [GetTestGridSession](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/GetTestGridSession)
------
# Laden Sie Pakete für mobile Geräte mit Device Farm mithilfe eines AWS SDK hoch und testen Sie sie
Das folgende Codebeispiel zeigt, wie Sie Pakete für mobile Geräte mit Device Farm hochladen und testen können.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/devicefarm/device_testing#code-examples) einrichten und ausführen.
Laden Sie die kompilierte Android-Anwendung und die Testpakete auf Device Farm hoch, starten Sie einen Test, warten Sie auf den Abschluss des Tests und melden Sie die Ergebnisse.
```
import boto3
import os
import requests
import string
import random
import datetime
import time
# Update this dict with your own values before you run the example:
config = {
# This is our app under test.
"appFilePath": "app-debug.apk",
"projectArn": "arn:aws:devicefarm:us-west-2:111222333444:project:581f5703-e040-4ac9-b7ae-0ba007bfb8e6",
# Since we care about the most popular devices, we'll use a curated pool.
"testSpecArn": "arn:aws:devicefarm:us-west-2::upload:20fcf771-eae3-4137-aa76-92e17fb3131b",
"poolArn": "arn:aws:devicefarm:us-west-2::devicepool:4a869d91-6f17-491f-9a95-0a601aee2406",
"namePrefix": "MyAppTest",
# This is our test package. This tutorial won't go into how to make these.
"testPackage": "tests.zip",
}
client = boto3.client("devicefarm")
unique = (
config["namePrefix"]
+ "-"
+ (datetime.date.today().isoformat())
+ ("".join(random.sample(string.ascii_letters, 8)))
)
print(
f"The unique identifier for this run is '{unique}'. All uploads will be prefixed "
f"with this."
)
def upload_df_file(filename, type_, mime="application/octet-stream"):
upload_response = client.create_upload(
projectArn=config["projectArn"],
name=unique + "_" + os.path.basename(filename),
type=type_,
contentType=mime,
)
upload_arn = upload_response["upload"]["arn"]
# Extract the URL of the upload and use Requests to upload it.
upload_url = upload_response["upload"]["url"]
with open(filename, "rb") as file_stream:
print(
f"Uploading {filename} to Device Farm as "
f"{upload_response['upload']['name']}... ",
end="",
)
put_req = requests.put(
upload_url, data=file_stream, headers={"content-type": mime}
)
print(" done")
if not put_req.ok:
raise Exception(f"Couldn't upload. Requests says: {put_req.reason}")
started = datetime.datetime.now()
while True:
print(
f"Upload of {filename} in state {upload_response['upload']['status']} "
f"after " + str(datetime.datetime.now() - started)
)
if upload_response["upload"]["status"] == "FAILED":
raise Exception(
f"The upload failed processing. Device Farm says the reason is: \n"
f"{+upload_response['upload']['message']}"
)
if upload_response["upload"]["status"] == "SUCCEEDED":
break
time.sleep(5)
upload_response = client.get_upload(arn=upload_arn)
print("")
return upload_arn
our_upload_arn = upload_df_file(config["appFilePath"], "ANDROID_APP")
our_test_package_arn = upload_df_file(
config["testPackage"], "APPIUM_PYTHON_TEST_PACKAGE"
)
print(our_upload_arn, our_test_package_arn)
response = client.schedule_run(
projectArn=config["projectArn"],
appArn=our_upload_arn,
devicePoolArn=config["poolArn"],
name=unique,
test={
"type": "APPIUM_PYTHON",
"testSpecArn": config["testSpecArn"],
"testPackageArn": our_test_package_arn,
},
)
run_arn = response["run"]["arn"]
start_time = datetime.datetime.now()
print(f"Run {unique} is scheduled as arn {run_arn} ")
state = "UNKNOWN"
try:
while True:
response = client.get_run(arn=run_arn)
state = response["run"]["status"]
if state == "COMPLETED" or state == "ERRORED":
break
else:
print(
f" Run {unique} in state {state}, total "
f"time {datetime.datetime.now() - start_time}"
)
time.sleep(10)
except:
client.stop_run(arn=run_arn)
exit(1)
print(f"Tests finished in state {state} after {datetime.datetime.now() - start_time}")
# Pull all the logs.
jobs_response = client.list_jobs(arn=run_arn)
# Save the output somewhere, using the unique value.
save_path = os.path.join(os.getcwd(), "results", unique)
os.mkdir(save_path)
# Save the last run information.
for job in jobs_response["jobs"]:
job_name = job["name"]
os.makedirs(os.path.join(save_path, job_name), exist_ok=True)
# Get each suite within the job.
suites = client.list_suites(arn=job["arn"])["suites"]
for suite in suites:
for test in client.list_tests(arn=suite["arn"])["tests"]:
# Get the artifacts.
for artifact_type in ["FILE", "SCREENSHOT", "LOG"]:
artifacts = client.list_artifacts(type=artifact_type, arn=test["arn"])[
"artifacts"
]
for artifact in artifacts:
# Replace `:` because it has a special meaning in Windows & macOS.
path_to = os.path.join(
save_path,
job_name,
suite["name"],
test["name"].replace(":", "_"),
)
os.makedirs(path_to, exist_ok=True)
filename = (
artifact["type"]
+ "_"
+ artifact["name"]
+ "."
+ artifact["extension"]
)
artifact_save_path = os.path.join(path_to, filename)
print(f"Downloading {artifact_save_path}")
with open(artifact_save_path, "wb") as fn:
with requests.get(
artifact["url"], allow_redirects=True
) as request:
fn.write(request.content)
print("Finished")
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für Python (Boto3)*.
+ [CreateUpload](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/CreateUpload)
+ [GetRun](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/GetRun)
+ [GetUpload](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/GetUpload)
+ [ListArtifacts](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/ListArtifacts)
+ [ListJobs](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/ListJobs)
+ [ListSuites](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/ListSuites)
+ [ListTests](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/ListTests)
+ [ScheduleRun](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/ScheduleRun)
+ [StopRun](https://docs.aws.amazon.com/goto/boto3/devicefarm-2015-06-23/StopRun)
------