/** * Copyright 2019 Google LLC * * 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 { GaxiosPromise } from 'gaxios'; import { Compute, JWT, OAuth2Client, UserRefreshClient } from 'google-auth-library'; import { BodyResponseCallback, GlobalOptions, GoogleConfigurable, MethodOptions } from 'googleapis-common'; export declare namespace testing_v1 { interface Options extends GlobalOptions { version: 'v1'; } interface StandardParameters { /** * V1 error format. */ '$.xgafv'?: string; /** * OAuth access token. */ access_token?: string; /** * Data format for response. */ alt?: string; /** * JSONP */ callback?: string; /** * Selector specifying which fields to include in a partial response. */ fields?: string; /** * API key. Your API key identifies your project and provides you with API * access, quota, and reports. Required unless you provide an OAuth 2.0 * token. */ key?: string; /** * OAuth 2.0 token for the current user. */ oauth_token?: string; /** * Returns response with indentations and line breaks. */ prettyPrint?: boolean; /** * Available to use for quota purposes for server-side applications. Can be * any arbitrary string assigned to a user, but should not exceed 40 * characters. */ quotaUser?: string; /** * Legacy upload protocol for media (e.g. "media", "multipart"). */ uploadType?: string; /** * Upload protocol for media (e.g. "raw", "multipart"). */ upload_protocol?: string; } /** * 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 */ class Testing { applicationDetailService: Resource$Applicationdetailservice; projects: Resource$Projects; testEnvironmentCatalog: Resource$Testenvironmentcatalog; constructor(options: GlobalOptions, google?: GoogleConfigurable); } /** * Identifies an account and how to log into it. */ interface Schema$Account { /** * An automatic google login account. */ googleAuto?: Schema$GoogleAuto; } /** * A single Android device. */ interface Schema$AndroidDevice { /** * Required. The id of the Android device to be used. Use the * EnvironmentDiscoveryService to get supported options. */ androidModelId?: string; /** * Required. The id of the Android OS version to be used. Use the * EnvironmentDiscoveryService to get supported options. */ androidVersionId?: string; /** * Required. The locale the test device used for testing. Use the * EnvironmentDiscoveryService to get supported options. */ locale?: string; /** * Required. How the device is oriented during the test. Use the * EnvironmentDiscoveryService to get supported options. */ orientation?: string; } /** * The currently supported Android devices. */ interface Schema$AndroidDeviceCatalog { /** * The set of supported Android device models. */ models?: Schema$AndroidModel[]; /** * The set of supported runtime configurations. */ runtimeConfiguration?: Schema$AndroidRuntimeConfiguration; /** * The set of supported Android OS versions. */ versions?: Schema$AndroidVersion[]; } /** * A list of Android device configurations in which the test is to be * executed. */ interface Schema$AndroidDeviceList { /** * Required. A list of Android devices. */ 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. */ interface Schema$AndroidInstrumentationTest { /** * The APK for the application under test. */ appApk?: Schema$FileReference; /** * A multi-apk app bundle for the application under test. */ appBundle?: Schema$AppBundle; /** * The java package for the application under test. The default value 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. If not set, the * test will be run without the orchestrator. */ orchestratorOption?: string; /** * Required. The APK containing the test code to be executed. */ testApk?: Schema$FileReference; /** * The java package for the test to be executed. The default value is * determined by examining the application's manifest. */ testPackageId?: string; /** * The InstrumentationTestRunner class. The default value 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" 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. */ interface Schema$AndroidMatrix { /** * Required. The ids of the set of Android device to be used. Use the * EnvironmentDiscoveryService to get supported options. */ androidModelIds?: string[]; /** * Required. The ids of the set of Android OS version to be used. Use the * EnvironmentDiscoveryService to get supported options. */ androidVersionIds?: string[]; /** * Required. The set of locales the test device will enable for testing. Use * the EnvironmentDiscoveryService to get supported options. */ locales?: string[]; /** * Required. The set of orientations to test with. Use the * EnvironmentDiscoveryService to get supported options. */ orientations?: string[]; } /** * A description of an Android device tests may be run on. */ interface Schema$AndroidModel { /** * The company that this device is branded with. Example: * "Google", "Samsung". */ brand?: string; /** * The name of the industrial design. This corresponds to * android.os.Build.DEVICE. */ codename?: string; /** * Whether this device is virtual or physical. */ form?: string; /** * Whether this device is a phone, tablet, wearable, etc. */ formFactor?: string; /** * The unique opaque id for this model. Use this for invoking the * TestExecutionService. */ id?: string; /** * True if and only if tests with this model are recorded by stitching * together screenshots. See use_low_spec_video_recording in device config. */ lowFpsVideoRecording?: boolean; /** * The manufacturer of this device. */ manufacturer?: string; /** * The human-readable marketing name for this device model. Examples: * "Nexus 5", "Galaxy S5". */ name?: string; /** * Screen density in DPI. This corresponds to ro.sf.lcd_density */ screenDensity?: number; /** * Screen size in the horizontal (X) dimension measured in pixels. */ screenX?: number; /** * Screen size in the vertical (Y) dimension measured in pixels. */ 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. */ supportedAbis?: string[]; /** * The set of Android versions this device supports. */ supportedVersionIds?: string[]; /** * Tags for this dimension. Examples: "default", * "preview", "deprecated". */ tags?: string[]; } /** * A test of an android application that explores the application on a virtual * or physical Android Device, finding culprits and crashes as it goes. */ interface Schema$AndroidRoboTest { /** * The APK for the application under test. */ appApk?: Schema$FileReference; /** * A multi-apk app bundle for the application under test. */ appBundle?: Schema$AppBundle; /** * The initial activity that should be used to start the app. */ appInitialActivity?: string; /** * The java package for the application under test. The default value 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. */ maxDepth?: number; /** * The max number of steps Robo can execute. Default is no limit. */ 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. */ roboDirectives?: Schema$RoboDirective[]; /** * A JSON file with a sequence of actions Robo should perform as a prologue * for the crawl. */ 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[]; } /** * Android configuration that can be selected at the time a test is run. */ interface Schema$AndroidRuntimeConfiguration { /** * The set of available locales. */ locales?: Schema$Locale[]; /** * The set of available orientations. */ 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. */ interface Schema$AndroidTestLoop { /** * The APK for the application under test. */ appApk?: Schema$FileReference; /** * A multi-apk app bundle for the application under test. */ appBundle?: Schema$AppBundle; /** * The java package for the application under test. The 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. Scenarios can also be specified in the scenarios field. */ scenarioLabels?: string[]; /** * The list of scenarios that should be run during the test. The default is * all test loops, derived from the application's manifest. */ scenarios?: number[]; } /** * A version of the Android OS. */ interface Schema$AndroidVersion { /** * The API level for this Android version. Examples: 18, 19. */ apiLevel?: number; /** * The code name for this Android version. Examples: "JellyBean", * "KitKat". */ codeName?: string; /** * Market share for this version. */ distribution?: Schema$Distribution; /** * An opaque id for this Android version. Use this id to invoke the * TestExecutionService. */ id?: string; /** * The date this Android version became available in the market. */ 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". */ versionString?: string; } /** * An Android package file to install. */ interface Schema$Apk { /** * The path to an APK to be installed on the device before the test begins. */ location?: Schema$FileReference; /** * The java package for the APK to be installed. Value is determined by * examining the application's manifest. */ packageName?: string; } /** * Android application details based on application manifest and apk archive * contents. */ interface Schema$ApkDetail { apkManifest?: Schema$ApkManifest; } /** * An Android app manifest. See * http://developer.android.com/guide/topics/manifest/manifest-intro.html */ 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; } /** * An Android App Bundle file format, containing a BundleConfig.pb file, a * base module directory, zero or more dynamic feature module directories. * <p>See https://developer.android.com/guide/app-bundle/build for * guidance on building App Bundles. */ interface Schema$AppBundle { /** * .aab file representing the app bundle under test. */ bundleLocation?: Schema$FileReference; } /** * Response containing the current state of the specified test matrix. */ 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. */ interface Schema$ClientInfo { /** * The list of detailed information about client. */ clientInfoDetails?: Schema$ClientInfoDetail[]; /** * Required. Client name, such as gcloud. */ name?: string; } /** * Key-value pair of detailed information about the client which invoked the * test. Examples: {'Version', '1.0'}, {'Release * Track', 'BETA'}. */ interface Schema$ClientInfoDetail { /** * Required. The key of detailed client information. */ key?: string; /** * Required. The value of detailed client information. */ value?: string; } /** * Represents a whole or partial calendar date, e.g. a birthday. The time of * day and time zone are either specified elsewhere or are not significant. * The date is relative to the Proleptic Gregorian Calendar. This can * represent: * A full date, with non-zero year, month and day values * A * month and day value, with a zero year, e.g. an anniversary * A year on its * own, with zero month and day values * A year and month value, with a zero * day, e.g. a credit card expiration date Related types are * google.type.TimeOfDay and `google.protobuf.Timestamp`. */ 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 by itself or a year and month where the day is not * significant. */ day?: number; /** * Month of year. Must be from 1 to 12, or 0 if specifying a year without a * month and day. */ 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. */ 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. */ interface Schema$Distribution { /** * Output only. The estimated fraction (0-1) of the total market with this * configuration. */ marketShare?: number; /** * Output only. The time this distribution was measured. */ measurementTime?: string; } /** * The environment in which the test is run. */ interface Schema$Environment { /** * An Android device which must be used with an Android test. */ androidDevice?: Schema$AndroidDevice; /** * An iOS device which must be used with an iOS test. */ iosDevice?: Schema$IosDevice; } /** * The matrix of environments in which the test is to be executed. */ 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 list of iOS devices. */ iosDeviceList?: Schema$IosDeviceList; } /** * A key-value pair passed as an environment variable to the test. */ 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. */ 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. */ 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. */ interface Schema$GoogleAuto { } /** * A storage location within Google cloud storage (GCS). */ interface Schema$GoogleCloudStorage { /** * Required. 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. */ gcsPath?: string; } /** * The <intent-filter> section of an <activity> tag. * https://developer.android.com/guide/topics/manifest/intent-filter-element.html */ 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; } /** * A single iOS device. */ interface Schema$IosDevice { /** * Required. The id of the iOS device to be used. Use the * EnvironmentDiscoveryService to get supported options. */ iosModelId?: string; /** * Required. The id of the iOS major software version to be used. Use the * EnvironmentDiscoveryService to get supported options. */ iosVersionId?: string; /** * Required. The locale the test device used for testing. Use the * EnvironmentDiscoveryService to get supported options. */ locale?: string; /** * Required. How the device is oriented during the test. Use the * EnvironmentDiscoveryService to get supported options. */ orientation?: string; } /** * The currently supported iOS devices. */ interface Schema$IosDeviceCatalog { /** * The set of supported iOS device models. */ models?: Schema$IosModel[]; /** * The set of supported runtime configurations. */ runtimeConfiguration?: Schema$IosRuntimeConfiguration; /** * The set of supported iOS software versions. */ versions?: Schema$IosVersion[]; /** * The set of supported Xcode versions. */ xcodeVersions?: Schema$XcodeVersion[]; } /** * A list of iOS device configurations in which the test is to be executed. */ interface Schema$IosDeviceList { /** * Required. A list of iOS devices. */ iosDevices?: Schema$IosDevice[]; } /** * A description of an iOS device tests may be run on. */ interface Schema$IosModel { /** * Device capabilities. Copied from * https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/DeviceCompatibilityMatrix/DeviceCompatibilityMatrix.html */ deviceCapabilities?: string[]; /** * Whether this device is a phone, tablet, wearable, etc. */ formFactor?: string; /** * The unique opaque id for this model. Use this for invoking the * TestExecutionService. */ id?: string; /** * The human-readable name for this device model. Examples: "iPhone * 4s", "iPad Mini 2". */ name?: string; /** * The set of iOS major software versions this device supports. */ supportedVersionIds?: string[]; /** * Tags for this dimension. Examples: "default", * "preview", "deprecated". */ tags?: string[]; } /** * iOS configuration that can be selected at the time a test is run. */ interface Schema$IosRuntimeConfiguration { /** * The set of available locales. */ locales?: Schema$Locale[]; /** * The set of available orientations. */ orientations?: Schema$Orientation[]; } /** * A description of how to set up an iOS device prior to a test. */ interface Schema$IosTestSetup { /** * The network traffic profile used for running the test. Available network * profiles can be queried by using the NETWORK_CONFIGURATION environment * type when calling * TestEnvironmentDiscoveryService.GetTestEnvironmentCatalog. */ networkProfile?: string; } /** * An iOS version. */ interface Schema$IosVersion { /** * An opaque id for this iOS version. Use this id to invoke the * TestExecutionService. */ id?: string; /** * An integer representing the major iOS version. Examples: "8", * "9". */ majorVersion?: number; /** * An integer representing the minor iOS version. Examples: "1", * "2". */ minorVersion?: number; /** * The available Xcode versions for this version. */ supportedXcodeVersionIds?: string[]; /** * Tags for this dimension. Examples: "default", * "preview", "deprecated". */ tags?: string[]; } /** * A test of an iOS application that uses the XCTest framework. Xcode supports * the option to "build for testing", which generates an .xctestrun * file that contains a test specification (arguments, test methods, etc). * This test type accepts a zip file containing the .xctestrun file and the * corresponding contents of the Build/Products directory that contains all * the binaries needed to run the tests. */ interface Schema$IosXcTest { /** * Output only. The bundle id for the application under test. */ appBundleId?: string; /** * Required. The .zip containing the .xctestrun file and the contents of the * DerivedData/Build/Products directory. The .xctestrun file in this zip is * ignored if the xctestrun field is specified. */ testsZip?: Schema$FileReference; /** * The Xcode version that should be used for the test. Use the * EnvironmentDiscoveryService to get supported options. Defaults to the * latest Xcode version Firebase Test Lab supports. */ xcodeVersion?: string; /** * An .xctestrun file that will override the .xctestrun file in the tests * zip. Because the .xctestrun file contains environment variables along * with test methods to run and/or ignore, this can be useful for sharding * tests. Default is taken from the tests zip. */ xctestrun?: Schema$FileReference; } /** * Specifies an intent that starts the main launcher activity. */ interface Schema$LauncherActivityIntent { } /** * A location/region designation for language. */ interface Schema$Locale { /** * The id for this locale. Example: "en_US". */ id?: string; /** * A human-friendly name for this language/locale. Example: * "English". */ name?: string; /** * A human-friendly string representing the region for this locale. Example: * "United States". Not present for every locale. */ region?: string; /** * Tags for this dimension. Example: "default". */ tags?: string[]; } interface Schema$NetworkConfiguration { /** * The emulation rule applying to the download traffic. */ downRule?: Schema$TrafficRule; /** * The unique opaque id for this network traffic configuration. */ id?: string; /** * The emulation rule applying to the upload traffic. */ upRule?: Schema$TrafficRule; } interface Schema$NetworkConfigurationCatalog { configurations?: Schema$NetworkConfiguration[]; } /** * An opaque binary blob file to install on the device before the test starts. */ interface Schema$ObbFile { /** * Required. Opaque Binary Blob (OBB) file(s) to install on the device. */ obb?: Schema$FileReference; /** * Required. 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. */ obbFileName?: string; } /** * Screen orientation of the device. */ interface Schema$Orientation { /** * The id for this orientation. Example: "portrait". */ id?: string; /** * A human-friendly name for this orientation. Example: * "portrait". */ name?: string; /** * Tags for this dimension. Example: "default". */ tags?: string[]; } /** * The currently provided software environment on the devices under test. */ interface Schema$ProvidedSoftwareCatalog { /** * A string representing the current version of Android Test Orchestrator * that is provided by TestExecutionService. Example: "1.0.2 * beta". */ orchestratorVersion?: string; } /** * A file or directory to install on the device before the test starts. */ interface Schema$RegularFile { /** * Required. The source file. */ content?: Schema$FileReference; /** * Required. 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. */ devicePath?: string; } /** * Locations where the results of running the test are stored. */ interface Schema$ResultStorage { /** * Required. */ googleCloudStorage?: Schema$GoogleCloudStorage; /** * Output only. The tool results execution that results are written to. */ toolResultsExecution?: Schema$ToolResultsExecution; /** * The tool results history that contains the tool results execution that * results are written to. 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. */ interface Schema$RoboDirective { /** * Required. The type of action that Robo should perform on the specified * element. */ 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. */ inputText?: string; /** * Required. 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 */ resourceName?: string; } /** * Message for specifying the start activities to crawl. */ interface Schema$RoboStartingIntent { launcherActivity?: Schema$LauncherActivityIntent; startActivity?: Schema$StartActivityIntent; /** * Timeout in seconds for each intent. */ timeout?: string; } /** * A starting intent specified by an action, uri, and categories. */ interface Schema$StartActivityIntent { /** * Action name. Required for START_ACTIVITY. */ action?: string; /** * Intent categories to set on the intent. */ categories?: string[]; /** * URI for the action. */ uri?: string; } /** * Additional details about the progress of the running test. */ interface Schema$TestDetails { /** * Output only. If the TestState is ERROR, then this string will contain * human-readable details about the error. */ errorMessage?: string; /** * Output only. 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. */ progressMessages?: string[]; } /** * A description of a test environment. */ interface Schema$TestEnvironmentCatalog { /** * Supported Android devices. */ androidDeviceCatalog?: Schema$AndroidDeviceCatalog; /** * Supported iOS devices. */ iosDeviceCatalog?: Schema$IosDeviceCatalog; /** * Supported network configurations. */ networkConfigurationCatalog?: Schema$NetworkConfigurationCatalog; /** * The software test environment provided by TestExecutionService. */ softwareCatalog?: Schema$ProvidedSoftwareCatalog; } /** * Specifies a single test to be executed in a single environment. */ interface Schema$TestExecution { /** * Output only. How the host machine(s) are configured. */ environment?: Schema$Environment; /** * Output only. Unique id set by the backend. */ id?: string; /** * Output only. Id of the containing TestMatrix. */ matrixId?: string; /** * Output only. The cloud project that owns the test execution. */ projectId?: string; /** * Output only. Indicates the current progress of the test execution (e.g., * FINISHED). */ state?: string; /** * Output only. Additional details about the running test. */ testDetails?: Schema$TestDetails; /** * Output only. How to run the test. */ testSpecification?: Schema$TestSpecification; /** * Output only. The time this test execution was initially created. */ timestamp?: string; /** * Output only. Where the results for this execution are written. */ toolResultsStep?: Schema$ToolResultsStep; } /** * A group of one or more TestExecutions, built by taking a product of values * over a pre-defined set of axes. */ interface Schema$TestMatrix { /** * Information about the client which invoked the test. */ clientInfo?: Schema$ClientInfo; /** * Required. How the host machine(s) are configured. */ environmentMatrix?: Schema$EnvironmentMatrix; /** * The number of times a TestExecution should be re-attempted if one or more * of its test cases fail for any reason. The maximum number of reruns * allowed is 10. Default is 0, which implies no reruns. */ flakyTestAttempts?: number; /** * Output only. Describes why the matrix is considered invalid. Only useful * for matrices in the INVALID state. */ invalidMatrixDetails?: string; /** * The cloud project that owns the test matrix. */ projectId?: string; /** * Required. Where the results for the matrix are written. */ resultStorage?: Schema$ResultStorage; /** * Output only. Indicates the current progress of the test matrix (e.g., * FINISHED). */ state?: string; /** * Output only. The list of test executions that the service creates for * this matrix. */ testExecutions?: Schema$TestExecution[]; /** * Output only. Unique id set by the service. */ testMatrixId?: string; /** * Required. How to run the test. */ testSpecification?: Schema$TestSpecification; /** * Output only. The time this test matrix was initially created. */ timestamp?: string; } /** * A description of how to set up the Android device prior to running the * test. */ interface Schema$TestSetup { /** * The device will be logged in on this account for the duration of the * test. */ account?: Schema$Account; /** * APKs to install in addition to those being directly tested. Currently * capped at 100. */ 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. */ 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. */ filesToPush?: Schema$DeviceFile[]; /** * The network traffic profile used for running the test. Available network * profiles can be queried by using the NETWORK_CONFIGURATION environment * type when calling * TestEnvironmentDiscoveryService.GetTestEnvironmentCatalog. */ networkProfile?: string; } /** * A description of how to run the test. */ 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. */ 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 iOS. */ iosTestSetup?: Schema$IosTestSetup; /** * An iOS XCTest, via an .xctestrun file. */ iosXcTest?: Schema$IosXcTest; /** * Test setup requirements for Android e.g. files to install, bootstrap * scripts. */ testSetup?: Schema$TestSetup; /** * Max time a test execution is allowed to run before it is automatically * cancelled. The default value is 5 min. */ testTimeout?: string; } /** * Represents a tool results execution resource. This has the results of a * TestMatrix. */ interface Schema$ToolResultsExecution { /** * Output only. A tool results execution ID. */ executionId?: string; /** * Output only. A tool results history ID. */ historyId?: string; /** * Output only. The cloud project that owns the tool results execution. */ projectId?: string; } /** * Represents a tool results history resource. */ interface Schema$ToolResultsHistory { /** * Required. A tool results history ID. */ historyId?: string; /** * Required. The cloud project that owns the tool results history. */ projectId?: string; } /** * Represents a tool results step resource. This has the results of a * TestExecution. */ interface Schema$ToolResultsStep { /** * Output only. A tool results execution ID. */ executionId?: string; /** * Output only. A tool results history ID. */ historyId?: string; /** * Output only. The cloud project that owns the tool results step. */ projectId?: string; /** * Output only. A tool results step ID. */ stepId?: string; } /** * Network emulation parameters. */ 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; } /** * An Xcode version that an iOS version is compatible with. */ interface Schema$XcodeVersion { /** * Tags for this Xcode version. Example: "default". */ tags?: string[]; /** * The id for this version. Example: "9.2". */ version?: string; } class Resource$Applicationdetailservice { constructor(); /** * testing.applicationDetailService.getApkDetails * @desc Gets 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?: Params$Resource$Applicationdetailservice$Getapkdetails, options?: MethodOptions): GaxiosPromise; getApkDetails(params: Params$Resource$Applicationdetailservice$Getapkdetails, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void; getApkDetails(params: Params$Resource$Applicationdetailservice$Getapkdetails, callback: BodyResponseCallback): void; getApkDetails(callback: BodyResponseCallback): void; } interface Params$Resource$Applicationdetailservice$Getapkdetails extends StandardParameters { /** * Auth client or API Key for the request */ auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient; /** * Request body metadata */ requestBody?: Schema$FileReference; } class Resource$Projects { testMatrices: Resource$Projects$Testmatrices; constructor(); } class Resource$Projects$Testmatrices { constructor(); /** * 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?: Params$Resource$Projects$Testmatrices$Cancel, options?: MethodOptions): GaxiosPromise; cancel(params: Params$Resource$Projects$Testmatrices$Cancel, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void; cancel(params: Params$Resource$Projects$Testmatrices$Cancel, callback: BodyResponseCallback): void; cancel(callback: BodyResponseCallback): void; /** * testing.projects.testMatrices.create * @desc Creates and runs 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?: Params$Resource$Projects$Testmatrices$Create, options?: MethodOptions): GaxiosPromise; create(params: Params$Resource$Projects$Testmatrices$Create, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void; create(params: Params$Resource$Projects$Testmatrices$Create, callback: BodyResponseCallback): void; create(callback: BodyResponseCallback): void; /** * testing.projects.testMatrices.get * @desc Checks 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?: Params$Resource$Projects$Testmatrices$Get, options?: MethodOptions): GaxiosPromise; get(params: Params$Resource$Projects$Testmatrices$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void; get(params: Params$Resource$Projects$Testmatrices$Get, callback: BodyResponseCallback): void; get(callback: BodyResponseCallback): void; } interface Params$Resource$Projects$Testmatrices$Cancel extends StandardParameters { /** * Auth client or API Key for the request */ auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient; /** * Cloud project that owns the test. */ projectId?: string; /** * Test matrix that will be canceled. */ testMatrixId?: string; } interface Params$Resource$Projects$Testmatrices$Create extends StandardParameters { /** * Auth client or API Key for the request */ auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient; /** * The GCE project under which this job will run. */ projectId?: string; /** * 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. */ requestId?: string; /** * Request body metadata */ requestBody?: Schema$TestMatrix; } interface Params$Resource$Projects$Testmatrices$Get extends StandardParameters { /** * Auth client or API Key for the request */ auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient; /** * Cloud project that owns the test matrix. */ projectId?: string; /** * Unique test matrix id which was assigned by the service. */ testMatrixId?: string; } class Resource$Testenvironmentcatalog { constructor(); /** * testing.testEnvironmentCatalog.get * @desc Gets 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 Required. The type of environment that should be listed. * @param {string=} params.projectId For authorization, the cloud project requesting the TestEnvironmentCatalog. * @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?: Params$Resource$Testenvironmentcatalog$Get, options?: MethodOptions): GaxiosPromise; get(params: Params$Resource$Testenvironmentcatalog$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void; get(params: Params$Resource$Testenvironmentcatalog$Get, callback: BodyResponseCallback): void; get(callback: BodyResponseCallback): void; } interface Params$Resource$Testenvironmentcatalog$Get extends StandardParameters { /** * Auth client or API Key for the request */ auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient; /** * Required. The type of environment that should be listed. */ environmentType?: string; /** * For authorization, the cloud project requesting the * TestEnvironmentCatalog. */ projectId?: string; } }