close()

Close httplib2 connections.

create(projectId, historyId, body=None, requestId=None, x__xgafv=None)

Creates an Execution. The returned Execution will have the id set. 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 - NOT_FOUND - if the containing History does not exist

Args:
projectId: string, A Project id. Required. (required)
historyId: string, A History id. Required. (required)
body: object, The request body.
The object takes the form of:

{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
}

requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. Optional, but strongly recommended.
x__xgafv: string, V1 error format.
Allowed values
1 - v1 error format
2 - v2 error format

Returns:
An object of the form:

{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
}

get(projectId, historyId, executionId, x__xgafv=None)

Gets an Execution. 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 - NOT_FOUND - if the Execution does not exist

Args:
projectId: string, A Project id. Required. (required)
historyId: string, A History id. Required. (required)
executionId: string, An Execution id. Required. (required)
x__xgafv: string, V1 error format.
Allowed values
1 - v1 error format
2 - v2 error format

Returns:
An object of the form:

{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
}

list(projectId, historyId, pageSize=None, pageToken=None, x__xgafv=None)

Lists Executions for a given History. The executions are sorted by creation_time in descending order. The execution_id key will be used to order the executions with the same creation_time. 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 containing History does not exist

Args:
projectId: string, A Project id. Required. (required)
historyId: string, A History id. Required. (required)
pageSize: integer, The maximum number of Executions to fetch. Default value: 25. The server will use this default if the field is not set or has a value of 0. Optional.
pageToken: string, A continuation token to resume the query at the next item. Optional.
x__xgafv: string, V1 error format.
Allowed values
1 - v1 error format
2 - v2 error format

Returns:
An object of the form:

{
"executions": [ # Executions. Always set.
{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
},
],
"nextPageToken": "A String", # A continuation token to resume the query at the next item. Will only be set if there are more Executions to fetch.
}

list_next()

Retrieves the next page of results.

        Args:
          previous_request: The request for the previous page. (required)
          previous_response: The response from the request for the previous page. (required)

        Returns:
          A request object that you can call 'execute()' on to request the next
          page. Returns None if there are no more items in the collection.

patch(projectId, historyId, executionId, body=None, requestId=None, x__xgafv=None)

Updates an existing Execution with the supplied partial entity. 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 - FAILED_PRECONDITION - if the requested state transition is illegal - NOT_FOUND - if the containing History does not exist

Args:
projectId: string, A Project id. Required. (required)
historyId: string, Required. (required)
executionId: string, Required. (required)
body: object, The request body.
The object takes the form of:

{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
}

requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. Optional, but strongly recommended.
x__xgafv: string, V1 error format.
Allowed values
1 - v1 error format
2 - v2 error format

Returns:
An object of the form:

{ # 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.
"completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. # 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
"nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
"seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
},
"dimensionDefinitions": [ # 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
{ # One dimension of the matrix of different runs of a step.
},
],
"executionId": "A String", # 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
"outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
"failedRoboscript": True or False, # 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.
"notInstalled": True or False, # 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.
"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
},
"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
"abortedByUser": True or False, # 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.
"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
"infrastructureFailure": True or False, # 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.
},
"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
},
"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
"otherNativeCrash": True or False, # If a native process other than the app crashed.
},
"summary": "A String", # The simplest way to interpret a result. Required
},
"specification": { # The details about how to run the execution. # Lightweight information about execution request. - In response: present if set by create - In create: optional - In update: optional
"androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
"androidAppInfo": { # Android app information. # Information about the application under test.
"name": "A String", # The name of the app. Optional
"packageName": "A String", # The package name of the app. Required.
"versionCode": "A String", # The internal version code of the app. Optional.
"versionName": "A String", # The version name of the app. Optional.
},
"androidInstrumentationTest": { # 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. # An Android instrumentation test.
"testPackageId": "A String", # The java package for the test to be executed. Required
"testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
"testTargets": [ # 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.
"A String",
],
"useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
},
"androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
"appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
"bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
"bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
"maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
"maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
},
"androidTestLoop": { # Test Loops are tests that can be launched by the app itself, determining when to run by listening for an intent. # An Android test loop.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
"iosTest": { # A iOS mobile test specification # An iOS mobile test execution specification.
"iosAppInfo": { # iOS app information # Information about the application under test.
"name": "A String", # The name of the app. Required
},
"iosRoboTest": { # A Robo test for an iOS application. # An iOS Robo test.
},
"iosTestLoop": { # A game loop test of an iOS application. # An iOS test loop.
"bundleId": "A String", # Bundle ID of the app.
},
"iosXcTest": { # A test of an iOS application that uses the XCTest framework. # An iOS XCTest.
"bundleId": "A String", # Bundle ID of the app.
"xcodeVersion": "A String", # Xcode version that the test was run with.
},
"testTimeout": { # 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. # Max time a test is allowed to run before it is automatically cancelled.
"nanos": 42, # 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.
"seconds": "A String", # 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
},
},
},
"state": "A String", # 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
"testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. - In response: present if set by create - In create: optional - In update: never set
}

Cloud Tool Results API . projects . histories . executions

Instance Methods

Method Details