googleapis
Version:
Google APIs Client Library for Node.js
1,188 lines (1,187 loc) • 40 kB
TypeScript
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
* Cloud Testing API
*
* Allows developers to run automated tests for their mobile applications on
* Google infrastructure.
*
* @example
* const google = require('googleapis');
* const testing = google.testing('v1');
*
* @namespace testing
* @type {Function}
* @version v1
* @variation v1
* @param {object=} options Options for Testing
*/
export declare class Testing {
_options: GlobalOptions;
google: GoogleApis;
root: this;
applicationDetailService: Resource$Applicationdetailservice;
projects: Resource$Projects;
testEnvironmentCatalog: Resource$Testenvironmentcatalog;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
/**
* Identifies an account and how to log into it
*/
export interface Schema$Account {
/**
* An automatic google login account
*/
googleAuto: Schema$GoogleAuto;
}
/**
* A single Android device.
*/
export interface Schema$AndroidDevice {
/**
* The id of the Android device to be used. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
androidModelId: string;
/**
* The id of the Android OS version to be used. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
androidVersionId: string;
/**
* The locale the test device used for testing. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
locale: string;
/**
* How the device is oriented during the test. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
orientation: string;
}
/**
* The currently supported Android devices.
*/
export interface Schema$AndroidDeviceCatalog {
/**
* The set of supported Android device models. @OutputOnly
*/
models: Schema$AndroidModel[];
/**
* The set of supported runtime configurations. @OutputOnly
*/
runtimeConfiguration: Schema$AndroidRuntimeConfiguration;
/**
* The set of supported Android OS versions. @OutputOnly
*/
versions: Schema$AndroidVersion[];
}
/**
* A list of Android device configurations in which the test is to be executed.
*/
export interface Schema$AndroidDeviceList {
/**
* A list of Android devices Required
*/
androidDevices: Schema$AndroidDevice[];
}
/**
* A test of an Android application that can control an Android component
* independently of its normal lifecycle. Android instrumentation tests run an
* application APK and test APK inside the same process on a virtual or physical
* AndroidDevice. They also specify a test runner class, such as
* com.google.GoogleTestRunner, which can vary on the specific instrumentation
* framework chosen. See
* <http://developer.android.com/tools/testing/testing_android.html> for
* more information on types of Android tests.
*/
export interface Schema$AndroidInstrumentationTest {
/**
* The APK for the application under test. Required
*/
appApk: Schema$FileReference;
/**
* The java package for the application under test. Optional, default is
* determined by examining the application's manifest.
*/
appPackageId: string;
/**
* The option of whether running each test within its own invocation of
* instrumentation with Android Test Orchestrator or not. ** Orchestrator is
* only compatible with AndroidJUnitRunner version 1.0 or higher! **
* Orchestrator offers the following benefits: - No shared state - Crashes
* are isolated - Logs are scoped per test See
* <https://developer.android.com/training/testing/junit-runner.html#using-android-test-orchestrator>
* for more information about Android Test Orchestrator. Optional, if empty,
* test will be run without orchestrator.
*/
orchestratorOption: string;
/**
* The APK containing the test code to be executed. Required
*/
testApk: Schema$FileReference;
/**
* The java package for the test to be executed. Optional, default is
* determined by examining the application's manifest.
*/
testPackageId: string;
/**
* The InstrumentationTestRunner class. Optional, default is determined by
* examining the application's manifest.
*/
testRunnerClass: string;
/**
* Each target must be fully qualified with the package name or class name, in
* one of these formats: - "package package_name" - "class
* package_name.class_name" - "class
* package_name.class_name#method_name" Optional, if empty, all targets
* in the module will be run.
*/
testTargets: string[];
}
/**
* A set of Android device configuration permutations is defined by the the
* cross-product of the given axes. Internally, the given AndroidMatrix will be
* expanded into a set of AndroidDevices. Only supported permutations will be
* instantiated. Invalid permutations (e.g., incompatible models/versions) are
* ignored.
*/
export interface Schema$AndroidMatrix {
/**
* The ids of the set of Android device to be used. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
androidModelIds: string[];
/**
* The ids of the set of Android OS version to be used. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
androidVersionIds: string[];
/**
* The set of locales the test device will enable for testing. Use the
* EnvironmentDiscoveryService to get supported options. Required
*/
locales: string[];
/**
* The set of orientations to test with. Use the EnvironmentDiscoveryService
* to get supported options. Required
*/
orientations: string[];
}
/**
* A description of an Android device tests may be run on.
*/
export interface Schema$AndroidModel {
/**
* The company that this device is branded with. Example: "Google",
* "Samsung" @OutputOnly
*/
brand: string;
/**
* The name of the industrial design. This corresponds to
* android.os.Build.DEVICE @OutputOnly
*/
codename: string;
/**
* Whether this device is virtual or physical. @OutputOnly
*/
form: string;
/**
* The unique opaque id for this model. Use this for invoking the
* TestExecutionService. @OutputOnly
*/
id: string;
/**
* The manufacturer of this device. @OutputOnly
*/
manufacturer: string;
/**
* The human-readable marketing name for this device model. Examples:
* "Nexus 5", "Galaxy S5" @OutputOnly
*/
name: string;
/**
* Screen density in DPI. This corresponds to ro.sf.lcd_density @OutputOnly
*/
screenDensity: number;
/**
* Screen size in the horizontal (X) dimension measured in pixels. @OutputOnly
*/
screenX: number;
/**
* Screen size in the vertical (Y) dimension measured in pixels. @OutputOnly
*/
screenY: number;
/**
* The list of supported ABIs for this device. This corresponds to either
* android.os.Build.SUPPORTED_ABIS (for API level 21 and above) or
* android.os.Build.CPU_ABI/CPU_ABI2. The most preferred ABI is the first
* element in the list. Elements are optionally prefixed by
* "version_id:" (where version_id is the id of an AndroidVersion),
* denoting an ABI that is supported only on a particular version. @OutputOnly
*/
supportedAbis: string[];
/**
* The set of Android versions this device supports. @OutputOnly
*/
supportedVersionIds: string[];
/**
* Tags for this dimension. Examples: "default",
* "preview", "deprecated"
*/
tags: string[];
/**
* True if and only if tests with this model DO NOT have video output. See
* also TestSpecification.disable_video_recording @OutputOnly
*/
videoRecordingNotSupported: boolean;
}
/**
* A test of an android application that explores the application on a virtual
* or physical Android Device, finding culprits and crashes as it goes.
*/
export interface Schema$AndroidRoboTest {
/**
* The APK for the application under test. Required
*/
appApk: Schema$FileReference;
/**
* The initial activity that should be used to start the app. Optional
*/
appInitialActivity: string;
/**
* The java package for the application under test. Optional, default is
* determined by examining the application's manifest.
*/
appPackageId: string;
/**
* The max depth of the traversal stack Robo can explore. Needs to be at least
* 2 to make Robo explore the app beyond the first activity. Default is 50.
* Optional
*/
maxDepth: number;
/**
* The max number of steps Robo can execute. Default is no limit. Optional
*/
maxSteps: number;
/**
* A set of directives Robo should apply during the crawl. This allows users
* to customize the crawl. For example, the username and password for a test
* account can be provided. Optional
*/
roboDirectives: Schema$RoboDirective[];
/**
* A JSON file with a sequence of actions Robo should perform as a prologue
* for the crawl. Optional
*/
roboScript: Schema$FileReference;
/**
* The intents used to launch the app for the crawl. If none are provided,
* then the main launcher activity is launched. If some are provided, then
* only those provided are launched (the main launcher activity must be
* provided explicitly).
*/
startingIntents: Schema$RoboStartingIntent[];
}
/**
* Configuration that can be selected at the time a test is run.
*/
export interface Schema$AndroidRuntimeConfiguration {
/**
* The set of available locales. @OutputOnly
*/
locales: Schema$Locale[];
/**
* The set of available orientations. @OutputOnly
*/
orientations: Schema$Orientation[];
}
/**
* A test of an Android Application with a Test Loop. The intent
* <intent-name> will be implicitly added, since Games is the only user of
* this api, for the time being.
*/
export interface Schema$AndroidTestLoop {
/**
* The APK for the application under test. Required
*/
appApk: Schema$FileReference;
/**
* The java package for the application under test. Optional, default is
* determined by examining the application's manifest.
*/
appPackageId: string;
/**
* The list of scenario labels that should be run during the test. The
* scenario labels should map to labels defined in the application's
* manifest. For example, player_experience and
* com.google.test.loops.player_experience add all of the loops labeled in the
* manifest with the com.google.test.loops.player_experience name to the
* execution. Optional. Scenarios can also be specified in the scenarios
* field.
*/
scenarioLabels: string[];
/**
* The list of scenarios that should be run during the test. Optional, default
* is all test loops, derived from the application's manifest.
*/
scenarios: number[];
}
/**
* A version of the Android OS
*/
export interface Schema$AndroidVersion {
/**
* The API level for this Android version. Examples: 18, 19 @OutputOnly
*/
apiLevel: number;
/**
* The code name for this Android version. Examples: "JellyBean",
* "KitKat" @OutputOnly
*/
codeName: string;
/**
* Market share for this version. @OutputOnly
*/
distribution: Schema$Distribution;
/**
* An opaque id for this Android version. Use this id to invoke the
* TestExecutionService. @OutputOnly
*/
id: string;
/**
* The date this Android version became available in the market. @OutputOnly
*/
releaseDate: Schema$Date;
/**
* Tags for this dimension. Examples: "default",
* "preview", "deprecated"
*/
tags: string[];
/**
* A string representing this version of the Android OS. Examples:
* "4.3", "4.4" @OutputOnly
*/
versionString: string;
}
/**
* An Android package file to install.
*/
export interface Schema$Apk {
/**
* The path to an APK to be installed on the device before the test begins.
* Optional
*/
location: Schema$FileReference;
/**
* The java package for the APK to be installed. Optional, value is determined
* by examining the application's manifest.
*/
packageName: string;
}
/**
* Android application details based on application manifest and apk archive
* contents
*/
export interface Schema$ApkDetail {
apkManifest: Schema$ApkManifest;
}
/**
* An Android app manifest. See
* http://developer.android.com/guide/topics/manifest/manifest-intro.html
*/
export interface Schema$ApkManifest {
/**
* User-readable name for the application.
*/
applicationLabel: string;
intentFilters: Schema$IntentFilter[];
/**
* Maximum API level on which the application is designed to run.
*/
maxSdkVersion: number;
/**
* Minimum API level required for the application to run.
*/
minSdkVersion: number;
/**
* Full Java-style package name for this application, e.g.
* "com.example.foo".
*/
packageName: string;
}
/**
* Response containing the current state of the specified test matrix.
*/
export interface Schema$CancelTestMatrixResponse {
/**
* The current rolled-up state of the test matrix. If this state is already
* final, then the cancelation request will have no effect.
*/
testState: string;
}
/**
* Information about the client which invoked the test.
*/
export interface Schema$ClientInfo {
/**
* The list of detailed information about client.
*/
clientInfoDetails: Schema$ClientInfoDetail[];
/**
* Client name, such as gcloud. Required
*/
name: string;
}
/**
* Key-value pair of detailed information about the client which invoked the
* test. For example {'Version', '1.0'}, {'Release
* Track', 'BETA'}
*/
export interface Schema$ClientInfoDetail {
/**
* The key of detailed client information. Required
*/
key: string;
/**
* The value of detailed client information. Required
*/
value: string;
}
/**
* Represents a whole calendar date, e.g. date of birth. The time of day and
* time zone are either specified elsewhere or are not significant. The date is
* relative to the Proleptic Gregorian Calendar. The day may be 0 to represent a
* year and month where the day is not significant, e.g. credit card expiration
* date. The year may be 0 to represent a month and day independent of year,
* e.g. anniversary date. Related types are google.type.TimeOfDay and
* `google.protobuf.Timestamp`.
*/
export interface Schema$Date {
/**
* Day of month. Must be from 1 to 31 and valid for the year and month, or 0
* if specifying a year/month where the day is not significant.
*/
day: number;
/**
* Month of year. Must be from 1 to 12, or 0 if specifying a date without a
* month.
*/
month: number;
/**
* Year of date. Must be from 1 to 9999, or 0 if specifying a date without a
* year.
*/
year: number;
}
/**
* A single device file description.
*/
export interface Schema$DeviceFile {
/**
* A reference to an opaque binary blob file
*/
obbFile: Schema$ObbFile;
/**
* A reference to a regular file
*/
regularFile: Schema$RegularFile;
}
/**
* Data about the relative number of devices running a given configuration of
* the Android platform.
*/
export interface Schema$Distribution {
/**
* The estimated fraction (0-1) of the total market with this configuration.
* @OutputOnly
*/
marketShare: number;
/**
* The time this distribution was measured. @OutputOnly
*/
measurementTime: string;
}
/**
* The environment in which the test is run.
*/
export interface Schema$Environment {
/**
* An Android device which must be used with an Android test.
*/
androidDevice: Schema$AndroidDevice;
}
/**
* The matrix of environments in which the test is to be executed.
*/
export interface Schema$EnvironmentMatrix {
/**
* A list of Android devices; the test will be run only on the specified
* devices.
*/
androidDeviceList: Schema$AndroidDeviceList;
/**
* A matrix of Android devices.
*/
androidMatrix: Schema$AndroidMatrix;
}
/**
* A key-value pair passed as an environment variable to the test
*/
export interface Schema$EnvironmentVariable {
/**
* Key for the environment variable
*/
key: string;
/**
* Value for the environment variable
*/
value: string;
}
/**
* A reference to a file, used for user inputs.
*/
export interface Schema$FileReference {
/**
* A path to a file in Google Cloud Storage. Example:
* gs://build-app-1414623860166/app-debug-unaligned.apk
*/
gcsPath: string;
}
/**
* Response containing the details of the specified Android application APK.
*/
export interface Schema$GetApkDetailsResponse {
/**
* Details of the Android APK.
*/
apkDetail: Schema$ApkDetail;
}
/**
* Enables automatic Google account login. If set, the service will
* automatically generate a Google test account and add it to the device, before
* executing the test. Note that test accounts might be reused. Many
* applications show their full set of functionalities when an account is
* present on the device. Logging into the device with these generated accounts
* allows testing more functionalities.
*/
export interface Schema$GoogleAuto {
}
/**
* A storage location within Google cloud storage (GCS).
*/
export interface Schema$GoogleCloudStorage {
/**
* The path to a directory in GCS that will eventually contain the results for
* this test. The requesting user must have write access on the bucket in the
* supplied path. Required
*/
gcsPath: string;
}
/**
* The <intent-filter> section of an <activity> tag.
* https://developer.android.com/guide/topics/manifest/intent-filter-element.html
*/
export interface Schema$IntentFilter {
/**
* The android:name value of the <action> tag
*/
actionNames: string[];
/**
* The android:name value of the <category> tag
*/
categoryNames: string[];
/**
* The android:mimeType value of the <data> tag
*/
mimeType: string;
}
/**
* Specifies an intent that starts the main launcher activity.
*/
export interface Schema$LauncherActivityIntent {
}
/**
* A location/region designation for language.
*/
export interface Schema$Locale {
/**
* The id for this locale. Example: "en_US" @OutputOnly
*/
id: string;
/**
* A human-friendly name for this language/locale. Example:
* "English" @OutputOnly
*/
name: string;
/**
* A human-friendly string representing the region for this locale. Example:
* "United States" Not present for every locale. @OutputOnly
*/
region: string;
/**
* Tags for this dimension. Examples: "default"
*/
tags: string[];
}
export interface Schema$NetworkConfiguration {
/**
* The emulation rule applying to the download traffic
*/
downRule: Schema$TrafficRule;
/**
* The unique opaque id for this network traffic configuration @OutputOnly
*/
id: string;
/**
* The emulation rule applying to the upload traffic
*/
upRule: Schema$TrafficRule;
}
export interface Schema$NetworkConfigurationCatalog {
configurations: Schema$NetworkConfiguration[];
}
/**
* An opaque binary blob file to install on the device before the test starts
*/
export interface Schema$ObbFile {
/**
* Opaque Binary Blob (OBB) file(s) to install on the device Required
*/
obb: Schema$FileReference;
/**
* OBB file name which must conform to the format as specified by Android e.g.
* [main|patch].0300110.com.example.android.obb which will be installed into
* <shared-storage>/Android/obb/<package-name>/ on the device
* Required
*/
obbFileName: string;
}
/**
* Screen orientation of the device.
*/
export interface Schema$Orientation {
/**
* The id for this orientation. Example: "portrait" @OutputOnly
*/
id: string;
/**
* A human-friendly name for this orientation. Example: "portrait"
* @OutputOnly
*/
name: string;
/**
* Tags for this dimension. Examples: "default"
*/
tags: string[];
}
/**
* A file or directory to install on the device before the test starts
*/
export interface Schema$RegularFile {
/**
* Required
*/
content: Schema$FileReference;
/**
* Where to put the content on the device. Must be an absolute, whitelisted
* path. If the file exists, it will be replaced. The following device-side
* directories and any of their subdirectories are whitelisted:
* <p>${EXTERNAL_STORAGE}, or /sdcard</p>
* <p>${ANDROID_DATA}/local/tmp, or /data/local/tmp</p>
* <p>Specifying a path outside of these directory trees is invalid.
* <p> The paths /sdcard and /data will be made available and treated as
* implicit path substitutions. E.g. if /sdcard on a particular device does
* not map to external storage, the system will replace it with the external
* storage path prefix for that device and copy the file there. <p> It
* is strongly advised to use the <a href=
* "http://developer.android.com/reference/android/os/Environment.html">
* Environment API</a> in app and test code to access files on the
* device in a portable way. Required
*/
devicePath: string;
}
/**
* Locations where the results of running the test are stored.
*/
export interface Schema$ResultStorage {
/**
* Required.
*/
googleCloudStorage: Schema$GoogleCloudStorage;
/**
* The tool results execution that results are written to. @OutputOnly
*/
toolResultsExecution: Schema$ToolResultsExecution;
/**
* The tool results history that contains the tool results execution that
* results are written to. Optional, if not provided the service will choose
* an appropriate value.
*/
toolResultsHistory: Schema$ToolResultsHistory;
}
/**
* Directs Robo to interact with a specific UI element if it is encountered
* during the crawl. Currently, Robo can perform text entry or element click.
*/
export interface Schema$RoboDirective {
/**
* The type of action that Robo should perform on the specified element.
* Required.
*/
actionType: string;
/**
* The text that Robo is directed to set. If left empty, the directive will be
* treated as a CLICK on the element matching the resource_name. Optional
*/
inputText: string;
/**
* The android resource name of the target UI element For example, in Java:
* R.string.foo in xml: @string/foo Only the “foo” part is needed.
* Reference doc:
* https://developer.android.com/guide/topics/resources/accessing-resources.html
* Required
*/
resourceName: string;
}
/**
* Message for specifying the start activities to crawl
*/
export interface Schema$RoboStartingIntent {
launcherActivity: Schema$LauncherActivityIntent;
startActivity: Schema$StartActivityIntent;
}
/**
* A starting intent specified by an action, uri, and categories.
*/
export interface Schema$StartActivityIntent {
/**
* Action name. Required for START_ACTIVITY.
*/
action: string;
/**
* Intent categories to set on the intent. Optional.
*/
categories: string[];
/**
* URI for the action. Optional.
*/
uri: string;
}
/**
* Additional details about the progress of the running test.
*/
export interface Schema$TestDetails {
/**
* If the TestState is ERROR, then this string will contain human-readable
* details about the error. @OutputOnly
*/
errorMessage: string;
/**
* Human-readable, detailed descriptions of the test's progress. For
* example: "Provisioning a device", "Starting Test".
* During the course of execution new data may be appended to the end of
* progress_messages. @OutputOnly
*/
progressMessages: string[];
/**
* Indicates that video will not be recorded for this execution either because
* the user chose to disable it or the device does not support it. See
* AndroidModel.video_recording_not_supported @OutputOnly
*/
videoRecordingDisabled: boolean;
}
/**
* A description of a test environment.
*/
export interface Schema$TestEnvironmentCatalog {
/**
* Android devices suitable for running Android Instrumentation Tests.
*/
androidDeviceCatalog: Schema$AndroidDeviceCatalog;
/**
* Supported network configurations
*/
networkConfigurationCatalog: Schema$NetworkConfigurationCatalog;
}
/**
* Specifies a single test to be executed in a single environment.
*/
export interface Schema$TestExecution {
/**
* How the host machine(s) are configured. @OutputOnly
*/
environment: Schema$Environment;
/**
* Unique id set by the backend. @OutputOnly
*/
id: string;
/**
* Id of the containing TestMatrix. @OutputOnly
*/
matrixId: string;
/**
* The cloud project that owns the test execution. @OutputOnly
*/
projectId: string;
/**
* Indicates the current progress of the test execution (e.g., FINISHED).
* @OutputOnly
*/
state: string;
/**
* Additional details about the running test. @OutputOnly
*/
testDetails: Schema$TestDetails;
/**
* How to run the test. @OutputOnly
*/
testSpecification: Schema$TestSpecification;
/**
* The time this test execution was initially created. @OutputOnly
*/
timestamp: string;
/**
* Where the results for this execution are written. @OutputOnly
*/
toolResultsStep: Schema$ToolResultsStep;
}
/**
* A group of one or more TestExecutions, built by taking a product of values
* over a pre-defined set of axes.
*/
export interface Schema$TestMatrix {
/**
* Information about the client which invoked the test. Optional
*/
clientInfo: Schema$ClientInfo;
/**
* How the host machine(s) are configured. Required
*/
environmentMatrix: Schema$EnvironmentMatrix;
/**
* Describes why the matrix is considered invalid. Only useful for matrices in
* the INVALID state. @OutputOnly
*/
invalidMatrixDetails: string;
/**
* The cloud project that owns the test matrix. @OutputOnly
*/
projectId: string;
/**
* Where the results for the matrix are written. Required
*/
resultStorage: Schema$ResultStorage;
/**
* Indicates the current progress of the test matrix (e.g., FINISHED)
* @OutputOnly
*/
state: string;
/**
* The list of test executions that the service creates for this matrix.
* @OutputOnly
*/
testExecutions: Schema$TestExecution[];
/**
* Unique id set by the service. @OutputOnly
*/
testMatrixId: string;
/**
* How to run the test. Required
*/
testSpecification: Schema$TestSpecification;
/**
* The time this test matrix was initially created. @OutputOnly
*/
timestamp: string;
}
/**
* A description of how to set up the Android device prior to running the test.
*/
export interface Schema$TestSetup {
/**
* The device will be logged in on this account for the duration of the test.
* Optional
*/
account: Schema$Account;
/**
* APKs to install in addition to those being directly tested. Currently
* capped at 100. Optional
*/
additionalApks: Schema$Apk[];
/**
* List of directories on the device to upload to GCS at the end of the test;
* they must be absolute paths under /sdcard or /data/local/tmp. Path names
* are restricted to characters a-z A-Z 0-9 _ - . + and / Note: The paths
* /sdcard and /data will be made available and treated as implicit path
* substitutions. E.g. if /sdcard on a particular device does not map to
* external storage, the system will replace it with the external storage path
* prefix for that device. Optional
*/
directoriesToPull: string[];
/**
* Environment variables to set for the test (only applicable for
* instrumentation tests).
*/
environmentVariables: Schema$EnvironmentVariable[];
/**
* List of files to push to the device before starting the test. Optional
*/
filesToPush: Schema$DeviceFile[];
/**
* The network traffic profile used for running the test. Optional
*/
networkProfile: string;
}
/**
* A description of how to run the test.
*/
export interface Schema$TestSpecification {
/**
* An Android instrumentation test.
*/
androidInstrumentationTest: Schema$AndroidInstrumentationTest;
/**
* An Android robo test.
*/
androidRoboTest: Schema$AndroidRoboTest;
/**
* An Android Application with a Test Loop
*/
androidTestLoop: Schema$AndroidTestLoop;
/**
* Enables automatic Google account login. If set, the service will
* automatically generate a Google test account and add it to the device,
* before executing the test. Note that test accounts might be reused. Many
* applications show their full set of functionalities when an account is
* present on the device. Logging into the device with these generated
* accounts allows testing more functionalities. Default is false. Optional
*/
autoGoogleLogin: boolean;
/**
* Disables performance metrics recording; may reduce test latency.
*/
disablePerformanceMetrics: boolean;
/**
* Disables video recording; may reduce test latency.
*/
disableVideoRecording: boolean;
/**
* Test setup requirements for Android e.g. files to install, bootstrap
* scripts. Optional
*/
testSetup: Schema$TestSetup;
/**
* Max time a test execution is allowed to run before it is automatically
* cancelled. Optional, default is 5 min.
*/
testTimeout: string;
}
/**
* Represents a tool results execution resource. This has the results of a
* TestMatrix.
*/
export interface Schema$ToolResultsExecution {
/**
* A tool results execution ID. @OutputOnly
*/
executionId: string;
/**
* A tool results history ID. @OutputOnly
*/
historyId: string;
/**
* The cloud project that owns the tool results execution. @OutputOnly
*/
projectId: string;
}
/**
* Represents a tool results history resource.
*/
export interface Schema$ToolResultsHistory {
/**
* A tool results history ID. Required
*/
historyId: string;
/**
* The cloud project that owns the tool results history. Required
*/
projectId: string;
}
/**
* Represents a tool results step resource. This has the results of a
* TestExecution.
*/
export interface Schema$ToolResultsStep {
/**
* A tool results execution ID. @OutputOnly
*/
executionId: string;
/**
* A tool results history ID. @OutputOnly
*/
historyId: string;
/**
* The cloud project that owns the tool results step. @OutputOnly
*/
projectId: string;
/**
* A tool results step ID. @OutputOnly
*/
stepId: string;
}
/**
* Network emulation parameters
*/
export interface Schema$TrafficRule {
/**
* Bandwidth in kbits/second
*/
bandwidth: number;
/**
* Burst size in kbits
*/
burst: number;
/**
* Packet delay, must be >= 0
*/
delay: string;
/**
* Packet duplication ratio (0.0 - 1.0)
*/
packetDuplicationRatio: number;
/**
* Packet loss ratio (0.0 - 1.0)
*/
packetLossRatio: number;
}
export declare class Resource$Applicationdetailservice {
root: Testing;
constructor(root: Testing);
getRoot(): Testing;
/**
* testing.applicationDetailService.getApkDetails
* @desc Request the details of an Android application APK.
* @alias testing.applicationDetailService.getApkDetails
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {().FileReference} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
getApkDetails(params?: any, options?: MethodOptions): AxiosPromise<Schema$GetApkDetailsResponse>;
getApkDetails(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$GetApkDetailsResponse>, callback?: BodyResponseCallback<Schema$GetApkDetailsResponse>): void;
}
export declare class Resource$Projects {
root: Testing;
testMatrices: Resource$Projects$Testmatrices;
constructor(root: Testing);
getRoot(): Testing;
}
export declare class Resource$Projects$Testmatrices {
root: Testing;
constructor(root: Testing);
getRoot(): Testing;
/**
* testing.projects.testMatrices.cancel
* @desc Cancels unfinished test executions in a test matrix. This call
* returns immediately and cancellation proceeds asychronously. If the matrix
* is already final, this operation will have no effect. May return any of
* the following canonical error codes: - PERMISSION_DENIED - if the user is
* not authorized to read project - INVALID_ARGUMENT - if the request is
* malformed - NOT_FOUND - if the Test Matrix does not exist
* @alias testing.projects.testMatrices.cancel
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.projectId Cloud project that owns the test.
* @param {string} params.testMatrixId Test matrix that will be canceled.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
cancel(params?: any, options?: MethodOptions): AxiosPromise<Schema$CancelTestMatrixResponse>;
cancel(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CancelTestMatrixResponse>, callback?: BodyResponseCallback<Schema$CancelTestMatrixResponse>): void;
/**
* testing.projects.testMatrices.create
* @desc Request to run a matrix of tests according to the given
* specifications. Unsupported environments will be returned in the state
* UNSUPPORTED. Matrices are limited to at most 200 supported executions. May
* return any of the following canonical error codes: - PERMISSION_DENIED -
* if the user is not authorized to write to project - INVALID_ARGUMENT - if
* the request is malformed or if the matrix expands to
* more than 200 supported executions
* @alias testing.projects.testMatrices.create
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.projectId The GCE project under which this job will run.
* @param {string=} params.requestId A string id used to detect duplicated requests. Ids are automatically scoped to a project, so users should ensure the ID is unique per-project. A UUID is recommended. Optional, but strongly recommended.
* @param {().TestMatrix} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
create(params?: any, options?: MethodOptions): AxiosPromise<Schema$TestMatrix>;
create(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$TestMatrix>, callback?: BodyResponseCallback<Schema$TestMatrix>): void;
/**
* testing.projects.testMatrices.get
* @desc Check the status of a test matrix. May return any of the following
* canonical error codes: - PERMISSION_DENIED - if the user is not authorized
* to read project - INVALID_ARGUMENT - if the request is malformed -
* NOT_FOUND - if the Test Matrix does not exist
* @alias testing.projects.testMatrices.get
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.projectId Cloud project that owns the test matrix.
* @param {string} params.testMatrixId Unique test matrix id which was assigned by the service.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
get(params?: any, options?: MethodOptions): AxiosPromise<Schema$TestMatrix>;
get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$TestMatrix>, callback?: BodyResponseCallback<Schema$TestMatrix>): void;
}
export declare class Resource$Testenvironmentcatalog {
root: Testing;
constructor(root: Testing);
getRoot(): Testing;
/**
* testing.testEnvironmentCatalog.get
* @desc Get the catalog of supported test environments. May return any of
* the following canonical error codes: - INVALID_ARGUMENT - if the request
* is malformed - NOT_FOUND - if the environment type does not exist -
* INTERNAL - if an internal error occurred
* @alias testing.testEnvironmentCatalog.get
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.environmentType The type of environment that should be listed. Required
* @param {string=} params.projectId For authorization, the cloud project requesting the TestEnvironmentCatalog. Optional
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
get(params?: any, options?: MethodOptions): AxiosPromise<Schema$TestEnvironmentCatalog>;
get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$TestEnvironmentCatalog>, callback?: BodyResponseCallback<Schema$TestEnvironmentCatalog>): void;
}