googleapis
Version:
Google APIs Client Library for Node.js
1,227 lines (1,226 loc) • 211 kB
TypeScript
/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace toolresults_v1beta3 {
export interface Options extends GlobalOptions {
version: 'v1beta3';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* 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 Tool Results API
*
* API to publish and access results from developer tools.
*
* @example
* ```js
* const {google} = require('googleapis');
* const toolresults = google.toolresults('v1beta3');
* ```
*/
export class Toolresults {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Android app information.
*/
export interface Schema$AndroidAppInfo {
/**
* The name of the app. Optional
*/
name?: string | null;
/**
* The package name of the app. Required.
*/
packageName?: string | null;
/**
* The internal version code of the app. Optional.
*/
versionCode?: string | null;
/**
* The version name of the app. Optional.
*/
versionName?: string | null;
}
/**
* A test of an Android application that can control an Android component independently of its normal lifecycle. See for more information on types of Android tests.
*/
export interface Schema$AndroidInstrumentationTest {
/**
* The java package for the test to be executed. Required
*/
testPackageId?: string | null;
/**
* The InstrumentationTestRunner class. Required
*/
testRunnerClass?: string | null;
/**
* 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[] | null;
/**
* The flag indicates whether Android Test Orchestrator will be used to run test or not.
*/
useOrchestrator?: boolean | null;
}
/**
* 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 initial activity that should be used to start the app. Optional
*/
appInitialActivity?: string | null;
/**
* The java package for the bootstrap. Optional
*/
bootstrapPackageId?: string | null;
/**
* The runner class for the bootstrap. Optional
*/
bootstrapRunnerClass?: string | null;
/**
* The max depth of the traversal stack Robo can explore. Optional
*/
maxDepth?: number | null;
/**
* The max number of steps/actions Robo can execute. Default is no limit (0). Optional
*/
maxSteps?: number | null;
}
/**
* An Android mobile test specification.
*/
export interface Schema$AndroidTest {
/**
* Information about the application under test.
*/
androidAppInfo?: Schema$AndroidAppInfo;
/**
* An Android instrumentation test.
*/
androidInstrumentationTest?: Schema$AndroidInstrumentationTest;
/**
* An Android robo test.
*/
androidRoboTest?: Schema$AndroidRoboTest;
/**
* An Android test loop.
*/
androidTestLoop?: Schema$AndroidTestLoop;
/**
* Max time a test is allowed to run before it is automatically cancelled.
*/
testTimeout?: Schema$Duration;
}
/**
* Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent.
*/
export interface Schema$AndroidTestLoop {
}
/**
* Additional details for an ANR crash.
*/
export interface Schema$ANR {
/**
* The stack trace of the ANR crash. Optional.
*/
stackTrace?: Schema$StackTrace;
}
/**
* `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... \} Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); \} Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...\} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{\} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... \} The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; \} { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": \} If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" \}
*/
export interface Schema$Any {
/**
* A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
*/
typeUrl?: string | null;
/**
* Must be a valid serialized protocol buffer of the above specified type.
*/
value?: string | null;
}
export interface Schema$AppStartTime {
/**
* Optional. The time from app start to reaching the developer-reported "fully drawn" time. This is only stored if the app includes a call to Activity.reportFullyDrawn(). See https://developer.android.com/topic/performance/launch-time.html#time-full
*/
fullyDrawnTime?: Schema$Duration;
/**
* The time from app start to the first displayed activity being drawn, as reported in Logcat. See https://developer.android.com/topic/performance/launch-time.html#time-initial
*/
initialDisplayTime?: Schema$Duration;
}
/**
* A suggestion to use deep links for a Robo run.
*/
export interface Schema$AvailableDeepLinks {
}
/**
* Encapsulates the metadata for basic sample series represented by a line chart
*/
export interface Schema$BasicPerfSampleSeries {
perfMetricType?: string | null;
perfUnit?: string | null;
sampleSeriesLabel?: string | null;
}
/**
* The request must provide up to a maximum of 5000 samples to be created; a larger sample size will cause an INVALID_ARGUMENT error
*/
export interface Schema$BatchCreatePerfSamplesRequest {
/**
* The set of PerfSamples to create should not include existing timestamps
*/
perfSamples?: Schema$PerfSample[];
}
export interface Schema$BatchCreatePerfSamplesResponse {
perfSamples?: Schema$PerfSample[];
}
/**
* A warning that Robo encountered a screen that was mostly blank; this may indicate a problem with the app.
*/
export interface Schema$BlankScreen {
/**
* The screen id of the element
*/
screenId?: string | null;
}
export interface Schema$CPUInfo {
/**
* description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A'
*/
cpuProcessor?: string | null;
/**
* the CPU clock speed in GHz
*/
cpuSpeedInGhz?: number | null;
/**
* the number of CPU cores
*/
numberOfCores?: number | null;
}
/**
* Crash dialog was detected during the test execution
*/
export interface Schema$CrashDialogError {
/**
* The name of the package that caused the dialog.
*/
crashPackage?: string | null;
}
/**
* A warning that device ran out of memory
*/
export interface Schema$DeviceOutOfMemory {
}
/**
* A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years.
*/
export interface Schema$Duration {
/**
* Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
*/
nanos?: number | null;
/**
* Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
*/
seconds?: string | null;
}
/**
* Additional details about encountered login screens.
*/
export interface Schema$EncounteredLoginScreen {
/**
* Number of encountered distinct login screens.
*/
distinctScreens?: number | null;
/**
* Subset of login screens.
*/
screenIds?: string[] | null;
}
/**
* Additional details about encountered screens with elements that are not Android UI widgets.
*/
export interface Schema$EncounteredNonAndroidUiWidgetScreen {
/**
* Number of encountered distinct screens with non Android UI widgets.
*/
distinctScreens?: number | null;
/**
* Subset of screens which contain non Android UI widgets.
*/
screenIds?: string[] | null;
}
/**
* An Environment represents the set of test runs (Steps) from the parent Execution that are configured with the same set of dimensions (Model, Version, Locale, and Orientation). Multiple such runs occur particularly because of features like sharding (splitting up a test suite to run in parallel across devices) and reruns (running a test multiple times to check for different outcomes).
*/
export interface Schema$Environment {
/**
* Output only. The time when the Environment status was set to complete. This value will be set automatically when state transitions to COMPLETE.
*/
completionTime?: Schema$Timestamp;
/**
* Output only. The time when the Environment was created.
*/
creationTime?: Schema$Timestamp;
/**
* Dimension values describing the environment. Dimension values always consist of "Model", "Version", "Locale", and "Orientation". - In response: always set - In create request: always set - In update request: never set
*/
dimensionValue?: Schema$EnvironmentDimensionValueEntry[];
/**
* A short human-readable name to display in the UI. Maximum of 100 characters. For example: Nexus 5, API 27.
*/
displayName?: string | null;
/**
* Output only. An Environment id.
*/
environmentId?: string | null;
/**
* Merged result of the environment.
*/
environmentResult?: Schema$MergedResult;
/**
* Output only. An Execution id.
*/
executionId?: string | null;
/**
* Output only. A History id.
*/
historyId?: string | null;
/**
* Output only. A Project id.
*/
projectId?: string | null;
/**
* The location where output files are stored in the user bucket.
*/
resultsStorage?: Schema$ResultsStorage;
/**
* Output only. Summaries of shards. Only one shard will present unless sharding feature is enabled in TestExecutionService.
*/
shardSummaries?: Schema$ShardSummary[];
}
export interface Schema$EnvironmentDimensionValueEntry {
key?: string | null;
value?: string | null;
}
/**
* An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step The maximum size of an execution message is 1 MiB. An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
*/
export interface Schema$Execution {
/**
* The time when the Execution status transitioned to COMPLETE. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
*/
completionTime?: Schema$Timestamp;
/**
* The time when the Execution was created. This value will be set automatically when CreateExecution is called. - In response: always set - In create/update request: never set
*/
creationTime?: Schema$Timestamp;
/**
* The dimensions along which different steps in this execution may vary. This must remain fixed over the life of the execution. Returns INVALID_ARGUMENT if this field is set in an update request. Returns INVALID_ARGUMENT if the same name occurs in more than one dimension_definition. Returns INVALID_ARGUMENT if the size of the list is over 100. - In response: present if set by create - In create request: optional - In update request: never set
*/
dimensionDefinitions?: Schema$MatrixDimensionDefinition[];
/**
* A unique identifier within a History for this Execution. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response always set - In create/update request: never set
*/
executionId?: string | null;
/**
* Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
*/
outcome?: Schema$Outcome;
/**
* Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
*/
specification?: Schema$Specification;
/**
* The initial state is IN_PROGRESS. The only legal state transitions is from IN_PROGRESS to COMPLETE. A PRECONDITION_FAILED will be returned if an invalid transition is requested. The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. - In response always set - In create/update request: optional
*/
state?: string | null;
/**
* TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
*/
testExecutionMatrixId?: string | null;
}
/**
* Failed to install the APK.
*/
export interface Schema$FailedToInstall {
}
/**
* Details for an outcome with a FAILURE outcome summary.
*/
export interface Schema$FailureDetail {
/**
* If the failure was severe because the system (app) under test crashed.
*/
crashed?: boolean | null;
/**
* If the device ran out of memory during a test, causing the test to crash.
*/
deviceOutOfMemory?: boolean | null;
/**
* If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
*/
failedRoboscript?: boolean | null;
/**
* If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
*/
notInstalled?: boolean | null;
/**
* If a native process (including any other than the app) crashed.
*/
otherNativeCrash?: boolean | null;
/**
* If the test overran some time limit, and that is why it failed.
*/
timedOut?: boolean | null;
/**
* If the robo was unable to crawl the app; perhaps because the app did not start.
*/
unableToCrawl?: boolean | null;
}
/**
* Additional details for a fatal exception.
*/
export interface Schema$FatalException {
/**
* The stack trace of the fatal exception. Optional.
*/
stackTrace?: Schema$StackTrace;
}
/**
* A reference to a file.
*/
export interface Schema$FileReference {
/**
* The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
*/
fileUri?: string | null;
}
/**
* Graphics statistics for the App. The information is collected from 'adb shell dumpsys graphicsstats'. For more info see: https://developer.android.com/training/testing/performance.html Statistics will only be present for API 23+.
*/
export interface Schema$GraphicsStats {
/**
* Histogram of frame render times. There should be 154 buckets ranging from [5ms, 6ms) to [4950ms, infinity)
*/
buckets?: Schema$GraphicsStatsBucket[];
/**
* Total "high input latency" events.
*/
highInputLatencyCount?: string | null;
/**
* Total frames with slow render time. Should be <= total_frames.
*/
jankyFrames?: string | null;
/**
* Total "missed vsync" events.
*/
missedVsyncCount?: string | null;
/**
* 50th percentile frame render time in milliseconds.
*/
p50Millis?: string | null;
/**
* 90th percentile frame render time in milliseconds.
*/
p90Millis?: string | null;
/**
* 95th percentile frame render time in milliseconds.
*/
p95Millis?: string | null;
/**
* 99th percentile frame render time in milliseconds.
*/
p99Millis?: string | null;
/**
* Total "slow bitmap upload" events.
*/
slowBitmapUploadCount?: string | null;
/**
* Total "slow draw" events.
*/
slowDrawCount?: string | null;
/**
* Total "slow UI thread" events.
*/
slowUiThreadCount?: string | null;
/**
* Total frames rendered by package.
*/
totalFrames?: string | null;
}
export interface Schema$GraphicsStatsBucket {
/**
* Number of frames in the bucket.
*/
frameCount?: string | null;
/**
* Lower bound of render time in milliseconds.
*/
renderMillis?: string | null;
}
/**
* A History represents a sorted list of Executions ordered by the start_timestamp_millis field (descending). It can be used to group all the Executions of a continuous build. Note that the ordering only operates on one-dimension. If a repository has multiple branches, it means that multiple histories will need to be used in order to order Executions per branch.
*/
export interface Schema$History {
/**
* A short human-readable (plain text) name to display in the UI. Maximum of 100 characters. - In response: present if set during create. - In create request: optional
*/
displayName?: string | null;
/**
* A unique identifier within a project for this History. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response always set - In create request: never set
*/
historyId?: string | null;
/**
* A name to uniquely identify a history within a project. Maximum of 200 characters. - In response always set - In create request: always set
*/
name?: string | null;
/**
* The platform of the test history. - In response: always set. Returns the platform of the last execution if unknown.
*/
testPlatform?: string | null;
}
/**
* An image, with a link to the main image and a thumbnail.
*/
export interface Schema$Image {
/**
* An error explaining why the thumbnail could not be rendered.
*/
error?: Schema$Status;
/**
* A reference to the full-size, original image. This is the same as the tool_outputs entry for the image under its Step. Always set.
*/
sourceImage?: Schema$ToolOutputReference;
/**
* The step to which the image is attached. Always set.
*/
stepId?: string | null;
/**
* The thumbnail.
*/
thumbnail?: Schema$Thumbnail;
}
/**
* Additional details of in-app purchases encountered during the crawl.
*/
export interface Schema$InAppPurchasesFound {
/**
* The total number of in-app purchases flows explored: how many times the robo tries to buy a SKU.
*/
inAppPurchasesFlowsExplored?: number | null;
/**
* The total number of in-app purchases flows started.
*/
inAppPurchasesFlowsStarted?: number | null;
}
/**
* Details for an outcome with an INCONCLUSIVE outcome summary.
*/
export interface Schema$InconclusiveDetail {
/**
* If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
*/
abortedByUser?: boolean | null;
/**
* If results are being provided to the user in certain cases of infrastructure failures
*/
hasErrorLogs?: boolean | null;
/**
* If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
*/
infrastructureFailure?: boolean | null;
}
/**
* Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
*/
export interface Schema$IndividualOutcome {
/**
* Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
*/
multistepNumber?: number | null;
outcomeSummary?: string | null;
/**
* How long it took for this step to run.
*/
runDuration?: Schema$Duration;
stepId?: string | null;
}
/**
* A warning that Robo did not crawl potentially important parts of the app.
*/
export interface Schema$InsufficientCoverage {
}
/**
* Additional details for an iOS app crash.
*/
export interface Schema$IosAppCrashed {
/**
* The stack trace, if one is available. Optional.
*/
stackTrace?: Schema$StackTrace;
}
/**
* iOS app information
*/
export interface Schema$IosAppInfo {
/**
* The name of the app. Required
*/
name?: string | null;
}
/**
* A Robo test for an iOS application.
*/
export interface Schema$IosRoboTest {
}
/**
* A iOS mobile test specification
*/
export interface Schema$IosTest {
/**
* Information about the application under test.
*/
iosAppInfo?: Schema$IosAppInfo;
/**
* An iOS Robo test.
*/
iosRoboTest?: Schema$IosRoboTest;
/**
* An iOS test loop.
*/
iosTestLoop?: Schema$IosTestLoop;
/**
* An iOS XCTest.
*/
iosXcTest?: Schema$IosXcTest;
/**
* Max time a test is allowed to run before it is automatically cancelled.
*/
testTimeout?: Schema$Duration;
}
/**
* A game loop test of an iOS application.
*/
export interface Schema$IosTestLoop {
/**
* Bundle ID of the app.
*/
bundleId?: string | null;
}
/**
* A test of an iOS application that uses the XCTest framework.
*/
export interface Schema$IosXcTest {
/**
* Bundle ID of the app.
*/
bundleId?: string | null;
/**
* Xcode version that the test was run with.
*/
xcodeVersion?: string | null;
}
/**
* Failed to find the launcher activity of an app.
*/
export interface Schema$LauncherActivityNotFound {
}
/**
* Response message for EnvironmentService.ListEnvironments.
*/
export interface Schema$ListEnvironmentsResponse {
/**
* Environments. Always set.
*/
environments?: Schema$Environment[];
/**
* A Execution id Always set.
*/
executionId?: string | null;
/**
* A History id. Always set.
*/
historyId?: string | null;
/**
* A continuation token to resume the query at the next item. Will only be set if there are more Environments to fetch.
*/
nextPageToken?: string | null;
/**
* A Project id. Always set.
*/
projectId?: string | null;
}
export interface Schema$ListExecutionsResponse {
/**
* Executions. Always set.
*/
executions?: Schema$Execution[];
/**
* A continuation token to resume the query at the next item. Will only be set if there are more Executions to fetch.
*/
nextPageToken?: string | null;
}
/**
* Response message for HistoryService.List
*/
export interface Schema$ListHistoriesResponse {
/**
* Histories.
*/
histories?: Schema$History[];
/**
* A continuation token to resume the query at the next item. Will only be set if there are more histories to fetch. Tokens are valid for up to one hour from the time of the first list request. For instance, if you make a list request at 1PM and use the token from this first request 10 minutes later, the token from this second response will only be valid for 50 minutes.
*/
nextPageToken?: string | null;
}
export interface Schema$ListPerfSampleSeriesResponse {
/**
* The resulting PerfSampleSeries sorted by id
*/
perfSampleSeries?: Schema$PerfSampleSeries[];
}
export interface Schema$ListPerfSamplesResponse {
/**
* Optional, returned if result size exceeds the page size specified in the request (or the default page size, 500, if unspecified). It indicates the last sample timestamp to be used as page_token in subsequent request
*/
nextPageToken?: string | null;
perfSamples?: Schema$PerfSample[];
}
export interface Schema$ListScreenshotClustersResponse {
/**
* The set of clusters associated with an execution Always set
*/
clusters?: Schema$ScreenshotCluster[];
}
/**
* Response message for AccessibilityService.ListStepAccessibilityClusters.
*/
export interface Schema$ListStepAccessibilityClustersResponse {
/**
* A sequence of accessibility suggestions, grouped into clusters. Within the sequence, clusters that belong to the same SuggestionCategory should be adjacent. Within each category, clusters should be ordered by their SuggestionPriority (ERRORs first). The categories should be ordered by their highest priority cluster.
*/
clusters?: Schema$SuggestionClusterProto[];
/**
* A full resource name of the step. For example, projects/my-project/histories/bh.1234567890abcdef/executions/ 1234567890123456789/steps/bs.1234567890abcdef Always presents.
*/
name?: string | null;
}
/**
* Response message for StepService.List.
*/
export interface Schema$ListStepsResponse {
/**
* A continuation token to resume the query at the next item. If set, indicates that there are more steps to read, by calling list again with this value in the page_token field.
*/
nextPageToken?: string | null;
/**
* Steps.
*/
steps?: Schema$Step[];
}
/**
* A response containing the thumbnails in a step.
*/
export interface Schema$ListStepThumbnailsResponse {
/**
* A continuation token to resume the query at the next item. If set, indicates that there are more thumbnails to read, by calling list again with this value in the page_token field.
*/
nextPageToken?: string | null;
/**
* A list of image data. Images are returned in a deterministic order; they are ordered by these factors, in order of importance: * First, by their associated test case. Images without a test case are considered greater than images with one. * Second, by their creation time. Images without a creation time are greater than images with one. * Third, by the order in which they were added to the step (by calls to CreateStep or UpdateStep).
*/
thumbnails?: Schema$Image[];
}
/**
* Response message for StepService.ListTestCases.
*/
export interface Schema$ListTestCasesResponse {
nextPageToken?: string | null;
/**
* List of test cases.
*/
testCases?: Schema$TestCase[];
}
/**
* A warning that there were issues in logcat collection.
*/
export interface Schema$LogcatCollectionError {
}
/**
* One dimension of the matrix of different runs of a step.
*/
export interface Schema$MatrixDimensionDefinition {
}
export interface Schema$MemoryInfo {
/**
* Maximum memory that can be allocated to the process in KiB
*/
memoryCapInKibibyte?: string | null;
/**
* Total memory available on the device in KiB
*/
memoryTotalInKibibyte?: string | null;
}
/**
* Merged test result for environment. If the environment has only one step (no reruns or shards), then the merged result is the same as the step result. If the environment has multiple shards and/or reruns, then the results of shards and reruns that belong to the same environment are merged into one environment result.
*/
export interface Schema$MergedResult {
/**
* Outcome of the resource
*/
outcome?: Schema$Outcome;
/**
* State of the resource
*/
state?: string | null;
/**
* The combined and rolled-up result of each test suite that was run as part of this environment. Combining: When the test cases from a suite are run in different steps (sharding), the results are added back together in one overview. (e.g., if shard1 has 2 failures and shard2 has 1 failure than the overview failure_count = 3). Rollup: When test cases from the same suite are run multiple times (flaky), the results are combined (e.g., if testcase1.run1 fails, testcase1.run2 passes, and both testcase2.run1 and testcase2.run2 fail then the overview flaky_count = 1 and failure_count = 1).
*/
testSuiteOverviews?: Schema$TestSuiteOverview[];
}
/**
* Details when multiple steps are run with the same configuration as a group.
*/
export interface Schema$MultiStep {
/**
* Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
*/
multistepNumber?: number | null;
/**
* Present if it is a primary (original) step.
*/
primaryStep?: Schema$PrimaryStep;
/**
* Step Id of the primary (original) step, which might be this step.
*/
primaryStepId?: string | null;
}
/**
* Additional details for a native crash.
*/
export interface Schema$NativeCrash {
/**
* The stack trace of the native crash. Optional.
*/
stackTrace?: Schema$StackTrace;
}
/**
* A non-sdk API and examples of it being called along with other metadata See https://developer.android.com/distribute/best-practices/develop/restrictions-non-sdk-interfaces
*/
export interface Schema$NonSdkApi {
/**
* The signature of the Non-SDK API
*/
apiSignature?: string | null;
/**
* Example stack traces of this API being called.
*/
exampleStackTraces?: string[] | null;
/**
* Optional debugging insights for non-SDK API violations.
*/
insights?: Schema$NonSdkApiInsight[];
/**
* The total number of times this API was observed to have been called.
*/
invocationCount?: number | null;
/**
* Which list this API appears on
*/
list?: string | null;
}
/**
* Non-SDK API insights (to address debugging solutions).
*/
export interface Schema$NonSdkApiInsight {
/**
* Optional sample stack traces, for which this insight applies (there should be at least one).
*/
exampleTraceMessages?: string[] | null;
/**
* A unique ID, to be used for determining the effectiveness of this particular insight in the context of a matcher. (required)
*/
matcherId?: string | null;
/**
* An insight indicating that the hidden API usage originates from a Google-provided library.
*/
pendingGoogleUpdateInsight?: Schema$PendingGoogleUpdateInsight;
/**
* An insight indicating that the hidden API usage originates from the use of a library that needs to be upgraded.
*/
upgradeInsight?: Schema$UpgradeInsight;
}
/**
* Additional details for a non-sdk API usage violation.
*/
export interface Schema$NonSdkApiUsageViolation {
/**
* Signatures of a subset of those hidden API's.
*/
apiSignatures?: string[] | null;
/**
* Total number of unique hidden API's accessed.
*/
uniqueApis?: number | null;
}
/**
* Contains a summary and examples of non-sdk API usage violations.
*/
export interface Schema$NonSdkApiUsageViolationReport {
/**
* Examples of the detected API usages.
*/
exampleApis?: Schema$NonSdkApi[];
/**
* Minimum API level required for the application to run.
*/
minSdkVersion?: number | null;
/**
* Specifies the API Level on which the application is designed to run.
*/
targetSdkVersion?: number | null;
/**
* Total number of unique Non-SDK API's accessed.
*/
uniqueApis?: number | null;
}
/**
* Interprets a result so that humans and machines can act on it.
*/
export interface Schema$Outcome {
/**
* More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
*/
failureDetail?: Schema$FailureDetail;
/**
* More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
*/
inconclusiveDetail?: Schema$InconclusiveDetail;
/**
* More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
*/
skippedDetail?: Schema$SkippedDetail;
/**
* More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
*/
successDetail?: Schema$SuccessDetail;
/**
* The simplest way to interpret a result. Required
*/
summary?: string | null;
}
/**
* A warning that Robo encountered a screen that has overlapping clickable elements; this may indicate a potential UI issue.
*/
export interface Schema$OverlappingUIElements {
/**
* Resource names of the overlapping screen elements
*/
resourceName?: string[] | null;
/**
* The screen id of the elements
*/
screenId?: string | null;
}
/**
* This insight indicates that the hidden API usage originates from a Google-provided library. Users need not take any action.
*/
export interface Schema$PendingGoogleUpdateInsight {
/**
* The name of the Google-provided library with the non-SDK API dependency.
*/
nameOfGoogleLibrary?: string | null;
}
/**
* Encapsulates performance environment info
*/
export interface Schema$PerfEnvironment {
/**
* CPU related environment info
*/
cpuInfo?: Schema$CPUInfo;
/**
* Memory related environment info
*/
memoryInfo?: Schema$MemoryInfo;
}
/**
* A summary of perf metrics collected and performance environment info
*/
export interface Schema$PerfMetricsSummary {
appStartTime?: Schema$AppStartTime;
/**
* A tool results execution ID. @OutputOnly
*/
executionId?: string | null;
/**
* Graphics statistics for the entire run. Statistics are reset at the beginning of the run and collected at the end of the run.
*/
graphicsStats?: Schema$GraphicsStats;
/**
* A tool results history ID. @OutputOnly
*/
historyId?: string | null;
/**
* Describes the environment in which the performance metrics were collected
*/
perfEnvironment?: Schema$PerfEnvironment;
/**
* Set of resource collected
*/
perfMetrics?: string[] | null;
/**
* The cloud project @OutputOnly
*/
projectId?: string | null;
/**
* A tool results step ID. @OutputOnly
*/
stepId?: string | null;
}
/**
* A notification that Robo signed in with Google.
*/
export interface Schema$PerformedGoogleLogin {
}
/**
* A notification that Robo performed some monkey actions.
*/
export interface Schema$PerformedMonkeyActions {
/**
* The total number of monkey actions performed during the crawl.
*/
totalActions?: number | null;
}
/**
* Resource representing a single performance measure or data point
*/
export interface Schema$PerfSample {
/**
* Timestamp of collection.
*/
sampleTime?: Schema$Timestamp;
/**
* Value observed
*/
value?: number | null;
}
/**
* Resource representing a collection of performance samples (or data points)
*/
export interface Schema$PerfSampleSeries {
/**
* Basic series represented by a line chart
*/
basicPerfSampleSeries?: Schema$BasicPerfSampleSeries;
/**
* A tool results execution ID. @OutputOnly
*/
executionId?: string | null;
/**
* A tool results history ID. @OutputOnly
*/
historyId?: string | null;
/**
* The cloud project @OutputOnly
*/
projectId?: string | null;
/**
* A sample series id @OutputOnly
*/
sampleSeriesId?: string | null;
/**
* A tool results step ID. @OutputOnly
*/
stepId?: string | null;
}
/**
* Stores rollup test status of multiple steps that were run as a group and outcome of each individual step.
*/
export interface Schema$PrimaryStep {
/**
* Step Id and outcome of each individual step.
*/
individualOutcome?: Schema$IndividualOutcome[];
/**
* Rollup test status of multiple steps that were run with the same configuration as a group.
*/
rollUp?: string | null;
}
/**
* Per-project settings for the Tool Results service.
*/
export interface Schema$ProjectSettings {
/**
* The name of the Google Cloud Storage bucket to which results are written. By default, this is unset. In update request: optional In response: optional
*/
defaultBucket?: string | null;
/**
* The name of the project's settings. Always of the form: projects/{project-id\}/settings In update request: never set In response: always set
*/
name?: string | null;
}
/**
* Request message for StepService.PublishXunitXmlFiles.
*/
export interface Schema$PublishXunitXmlFilesRequest {
/**
* URI of the Xunit XML files to publish. The maximum size of the file this reference is pointing to is 50MB. Required.
*/
xunitXmlFiles?: Schema$FileReference[];
}
/**
* A rectangular region.
*/
export interface Schema$RegionProto {
/**
* The height, in pixels. Always set.
*/
heightPx?: number | null;
/**
* The left side of the rectangle, in pixels. Always set.
*/
leftPx?: number | null;
/**
* The top of the rectangle, in pixels. Always set.
*/
topPx?: number | null;
/**
* The width, in pixels. Always set.
*/
widthPx?: number | null;
}
/**
* The storage for test results.
*/
export interface Schema$ResultsStorage {
/**
* The root directory for test results.
*/
resultsStoragePath?: Schema$FileReference;
/**
* The path to the Xunit XML file.
*/
xunitXmlFile?: Schema$FileReference;
}
/**
* Execution stats for a user-provided Robo script.
*/
export interface Schema$RoboScriptExecution {
/**
* The number of Robo script actions executed successfully.
*/
successfulActions?: number | null;
/**
* The total number of actions in the Robo script.
*/
totalActions?: number | null;
}
/**
* IMPORTANT: It is unsafe to accept this message from an untrusted source, since it's trivial for an attacker to forge serialized messages that don't fulfill the type's safety contract -- for example, it could contain attacker controlled script. A system which receives a SafeHtmlProto implicitly trusts the producer of the SafeHtmlProto. So, it's generally safe to return this message in RPC responses, but generally unsafe to accept it in RPC requests.
*/
export interface Schema$SafeHtmlProto {
/**
* IMPORTANT: Never set or read this field, even from tests, it is private. See documentation at the top of .proto file for programming language packages with which to create or read this message.
*/
privateDoNotAccessOrElseSafeHtmlWrappedValue?: string | null;
}
export interface Schema$Screen {
/**
* File reference of the png file. Required.
*/
fileReference?: string | null;
/**
* Locale of the device that the screenshot was taken on. Required.
*/
locale?: string | null;
/**
* Model of the device that the screenshot was taken on. Required.
*/
model?: string | null;
/**
* OS version of the device that the screenshot was taken on. Required.
*/
version?: string | null;
}
export interface Schema$ScreenshotCluster {
/**
* A string that describes the activity of every screen in the cluster.
*/
activity?: string | null;
/**
* A unique identifier for the cluster. @OutputOnly
*/
clusterId?: string | null;
/**
* A singular screen that represents the cluster as a whole. This screen will act as the "cover" of the entire cluster. When users look at the clusters, only the key screen from each cluster will be shown. Which screen is the key screen is determined by the ClusteringAlgorithm
*/
keyScreen?: Schema$Screen;
/**
* Full list of screens.
*/
screens?: Schema$Screen[];
}
/**
* Result summary for a shard in an environment.
*/
export interface Schema$ShardSummary {
/**
* Summaries of the steps belonging to the shard. With flaky_test_attempts enabled from TestExecutionService, more than one run (Step) can present. And the runs will be sorted by multistep_number.
*/
runs?: Schema$StepSummary[];
/**
* Merged result of the shard.
*/