Google Git
Sign in
flutter / third_party / googleapis.dart / c4dbd8eb967c66862a893df75776ba46b59185b7 / . / generated / googleapis_beta / lib / toolresults / v1beta3.dart
blob: 30aae49777a99cb92e658503c16b812ef646878a [file] [log] [blame]
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: directives_ordering
// ignore_for_file: file_names
// ignore_for_file: library_names
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_parenthesis
// ignore_for_file: unnecessary_string_interpolations
library googleapis_beta.toolresults.v1beta3;
import 'dart:core' as core;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
const userAgent = 'dart-api-client toolresults/v1beta3';
/// API to publish and access results from developer tools.
class ToolresultsApi {
/// View and manage your data across Google Cloud Platform services
static const cloudPlatformScope =
'https://www.googleapis.com/auth/cloud-platform';
final commons.ApiRequester _requester;
ProjectsResourceApi get projects => ProjectsResourceApi(_requester);
ToolresultsApi(http.Client client,
{core.String rootUrl = 'https://toolresults.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, userAgent);
}
class ProjectsResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesResourceApi get histories =>
ProjectsHistoriesResourceApi(_requester);
ProjectsResourceApi(commons.ApiRequester client) : _requester = client;
/// Gets the Tool Results settings for a project. May return any of the
/// following canonical error codes: - PERMISSION_DENIED - if the user is not
/// authorized to read from project
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProjectSettings].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProjectSettings> getSettings(
core.String projectId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/settings';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
ProjectSettings.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Creates resources for settings which have not yet been set. Currently,
/// this creates a single resource: a Google Cloud Storage bucket, to be used
/// as the default bucket for this project. The bucket is created in an
/// FTL-own storage project. Except for in rare cases, calling this method in
/// parallel from multiple clients will only create a single bucket. In order
/// to avoid unnecessary storage charges, the bucket is configured to
/// automatically delete objects older than 90 days. The bucket is created
/// with the following permissions: - Owner access for owners of central
/// storage project (FTL-owned) - Writer access for owners/editors of customer
/// project - Reader access for viewers of customer project The default ACL on
/// objects created in the bucket is: - Owner access for owners of central
/// storage project - Reader access for owners/editors/viewers of customer
/// project See Google Cloud Storage documentation for more details. If there
/// is already a default bucket set and the project can access the bucket,
/// this call does nothing. However, if the project doesn't have the
/// permission to access the bucket or the bucket is deleted, a new bucket
/// will be created. May return any canonical error codes, including the
/// following: - PERMISSION_DENIED - if the user is not authorized to write to
/// project - Any error code raised by Google Cloud Storage
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ProjectSettings].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ProjectSettings> initializeSettings(
core.String projectId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
':initializeSettings';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
ProjectSettings.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsResourceApi get executions =>
ProjectsHistoriesExecutionsResourceApi(_requester);
ProjectsHistoriesResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates a History. The returned History 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 project does not
/// exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [requestId] - A unique request ID for server to detect duplicated
/// requests. For example, a UUID. Optional, but strongly recommended.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [History].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<History> create(
History request,
core.String projectId, {
core.String requestId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (requestId != null) {
_queryParams['requestId'] = [requestId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => History.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a History. 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
/// History does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [History].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<History> get(
core.String projectId,
core.String historyId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => History.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists Histories for a given Project. The histories are sorted by
/// modification time in descending order. The history_id key will be used to
/// order the history with the same modification 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 History does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [filterByName] - If set, only return histories with the given name.
/// Optional.
///
/// [pageSize] - The maximum number of Histories to fetch. Default value: 20.
/// The server will use this default if the field is not set or has a value of
/// 0. Any value greater than 100 will be treated as 100. Optional.
///
/// [pageToken] - A continuation token to resume the query at the next item.
/// Optional.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListHistoriesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListHistoriesResponse> list(
core.String projectId, {
core.String filterByName,
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (filterByName != null) {
_queryParams['filterByName'] = [filterByName];
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListHistoriesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsClustersResourceApi get clusters =>
ProjectsHistoriesExecutionsClustersResourceApi(_requester);
ProjectsHistoriesExecutionsEnvironmentsResourceApi get environments =>
ProjectsHistoriesExecutionsEnvironmentsResourceApi(_requester);
ProjectsHistoriesExecutionsStepsResourceApi get steps =>
ProjectsHistoriesExecutionsStepsResourceApi(_requester);
ProjectsHistoriesExecutionsResourceApi(commons.ApiRequester client)
: _requester = client;
/// 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
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [requestId] - A unique request ID for server to detect duplicated
/// requests. For example, a UUID. Optional, but strongly recommended.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Execution].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Execution> create(
Execution request,
core.String projectId,
core.String historyId, {
core.String requestId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (requestId != null) {
_queryParams['requestId'] = [requestId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Execution.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// 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
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - An Execution id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Execution].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Execution> get(
core.String projectId,
core.String historyId,
core.String executionId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Execution.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// 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
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [pageSize] - 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] - A continuation token to resume the query at the next item.
/// Optional.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListExecutionsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListExecutionsResponse> list(
core.String projectId,
core.String historyId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListExecutionsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// 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
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - Required.
///
/// [executionId] - Required.
///
/// [requestId] - A unique request ID for server to detect duplicated
/// requests. For example, a UUID. Optional, but strongly recommended.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Execution].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Execution> patch(
Execution request,
core.String projectId,
core.String historyId,
core.String executionId, {
core.String requestId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (requestId != null) {
_queryParams['requestId'] = [requestId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Execution.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsClustersResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsClustersResourceApi(commons.ApiRequester client)
: _requester = client;
/// Retrieves a single screenshot cluster by its ID
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - An Execution id. Required.
///
/// [clusterId] - A Cluster id Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ScreenshotCluster].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ScreenshotCluster> get(
core.String projectId,
core.String historyId,
core.String executionId,
core.String clusterId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (clusterId == null) {
throw core.ArgumentError('Parameter clusterId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/clusters/' +
commons.Escaper.ecapeVariable('$clusterId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ScreenshotCluster.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Lists Screenshot Clusters Returns the list of screenshot clusters
/// corresponding to an execution. Screenshot clusters are created after the
/// execution is finished. Clusters are created from a set of screenshots.
/// Between any two screenshots, a matching score is calculated based off
/// their metadata that determines how similar they are. Screenshots are
/// placed in the cluster that has screens which have the highest matching
/// scores.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - An Execution id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListScreenshotClustersResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListScreenshotClustersResponse> list(
core.String projectId,
core.String historyId,
core.String executionId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/clusters';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListScreenshotClustersResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsEnvironmentsResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsEnvironmentsResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Gets an Environment. 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
/// Environment does not exist
///
/// Request parameters:
///
/// [projectId] - Required. A Project id.
///
/// [historyId] - Required. A History id.
///
/// [executionId] - Required. An Execution id.
///
/// [environmentId] - Required. An Environment id.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Environment].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Environment> get(
core.String projectId,
core.String historyId,
core.String executionId,
core.String environmentId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (environmentId == null) {
throw core.ArgumentError('Parameter environmentId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/environments/' +
commons.Escaper.ecapeVariable('$environmentId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
Environment.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists Environments for a given Execution. The Environments are sorted by
/// display name. 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 Execution does not exist
///
/// Request parameters:
///
/// [projectId] - Required. A Project id.
///
/// [historyId] - Required. A History id.
///
/// [executionId] - Required. An Execution id.
///
/// [pageSize] - The maximum number of Environments to fetch. Default value:
/// 25. The server will use this default if the field is not set or has a
/// value of 0.
///
/// [pageToken] - A continuation token to resume the query at the next item.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListEnvironmentsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListEnvironmentsResponse> list(
core.String projectId,
core.String historyId,
core.String executionId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/environments';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListEnvironmentsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsPerfMetricsSummaryResourceApi
get perfMetricsSummary =>
ProjectsHistoriesExecutionsStepsPerfMetricsSummaryResourceApi(
_requester);
ProjectsHistoriesExecutionsStepsPerfSampleSeriesResourceApi
get perfSampleSeries =>
ProjectsHistoriesExecutionsStepsPerfSampleSeriesResourceApi(
_requester);
ProjectsHistoriesExecutionsStepsTestCasesResourceApi get testCases =>
ProjectsHistoriesExecutionsStepsTestCasesResourceApi(_requester);
ProjectsHistoriesExecutionsStepsThumbnailsResourceApi get thumbnails =>
ProjectsHistoriesExecutionsStepsThumbnailsResourceApi(_requester);
ProjectsHistoriesExecutionsStepsResourceApi(commons.ApiRequester client)
: _requester = client;
/// Lists accessibility clusters for a given Step 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 - FAILED_PRECONDITION - if an argument in the request happens to
/// be invalid; e.g. if the locale format is incorrect - NOT_FOUND - if the
/// containing Step does not exist
///
/// Request parameters:
///
/// [name] - A full resource name of the step. For example,
/// projects/my-project/histories/bh.1234567890abcdef/executions/
/// 1234567890123456789/steps/bs.1234567890abcdef Required.
/// Value must have pattern
/// "^projects/[^/]+/histories/[^/]+/executions/[^/]+/steps/[^/]+$".
///
/// [locale] - The accepted format is the canonical Unicode format with hyphen
/// as a delimiter. Language must be lowercase, Language Script - Capitalized,
/// Region - UPPERCASE. See
/// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier for
/// details. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListStepAccessibilityClustersResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListStepAccessibilityClustersResponse> accessibilityClusters(
core.String name, {
core.String locale,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (locale != null) {
_queryParams['locale'] = [locale];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/' +
commons.Escaper.ecapeVariableReserved('$name') +
':accessibilityClusters';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListStepAccessibilityClustersResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Creates a Step. The returned Step 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 - FAILED_PRECONDITION - if the step is too large (more than
/// 10Mib) - NOT_FOUND - if the containing Execution does not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - Required. A Project id.
///
/// [historyId] - Required. A History id.
///
/// [executionId] - Required. An Execution id.
///
/// [requestId] - A unique request ID for server to detect duplicated
/// requests. For example, a UUID. Optional, but strongly recommended.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Step].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Step> create(
Step request,
core.String projectId,
core.String historyId,
core.String executionId, {
core.String requestId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (requestId != null) {
_queryParams['requestId'] = [requestId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Step.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a Step. 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 Step
/// does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id. Required.
///
/// [stepId] - A Step id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Step].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Step> get(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Step.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Retrieves a PerfMetricsSummary. May return any of the following error
/// code(s): - NOT_FOUND - The specified PerfMetricsSummary does not exist
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PerfMetricsSummary].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PerfMetricsSummary> getPerfMetricsSummary(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfMetricsSummary';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => PerfMetricsSummary.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Lists Steps for a given Execution. The steps are sorted by creation_time
/// in descending order. The step_id key will be used to order the steps 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 - FAILED_PRECONDITION -
/// if an argument in the request happens to be invalid; e.g. if an attempt is
/// made to list the children of a nonexistent Step - NOT_FOUND - if the
/// containing Execution does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id. Required.
///
/// [pageSize] - The maximum number of Steps 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] - A continuation token to resume the query at the next item.
/// Optional.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListStepsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListStepsResponse> list(
core.String projectId,
core.String historyId,
core.String executionId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListStepsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Updates an existing Step with the supplied partial entity. May return any
/// of the following canonical error codes: - PERMISSION_DENIED - if the user
/// is not authorized to write project - INVALID_ARGUMENT - if the request is
/// malformed - FAILED_PRECONDITION - if the requested state transition is
/// illegal (e.g try to upload a duplicate xml file), if the updated step is
/// too large (more than 10Mib) - NOT_FOUND - if the containing Execution does
/// not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id. Required.
///
/// [stepId] - A Step id. Required.
///
/// [requestId] - A unique request ID for server to detect duplicated
/// requests. For example, a UUID. Optional, but strongly recommended.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Step].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Step> patch(
Step request,
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String requestId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (requestId != null) {
_queryParams['requestId'] = [requestId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Step.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Publish xml files to an existing Step. May return any of the following
/// canonical error codes: - PERMISSION_DENIED - if the user is not authorized
/// to write project - INVALID_ARGUMENT - if the request is malformed -
/// FAILED_PRECONDITION - if the requested state transition is illegal, e.g
/// try to upload a duplicate xml file or a file too large. - NOT_FOUND - if
/// the containing Execution does not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id. Required.
///
/// [stepId] - A Step id. Note: This step must include a TestExecutionStep.
/// Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Step].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Step> publishXunitXmlFiles(
PublishXunitXmlFilesRequest request,
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
':publishXunitXmlFiles';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Step.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsPerfMetricsSummaryResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsPerfMetricsSummaryResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Creates a PerfMetricsSummary resource. Returns the existing one if it has
/// already been created. May return any of the following error code(s): -
/// NOT_FOUND - The containing Step does not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PerfMetricsSummary].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PerfMetricsSummary> create(
PerfMetricsSummary request,
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfMetricsSummary';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => PerfMetricsSummary.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsPerfSampleSeriesResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsPerfSampleSeriesSamplesResourceApi
get samples =>
ProjectsHistoriesExecutionsStepsPerfSampleSeriesSamplesResourceApi(
_requester);
ProjectsHistoriesExecutionsStepsPerfSampleSeriesResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Creates a PerfSampleSeries. May return any of the following error code(s):
/// - ALREADY_EXISTS - PerfMetricSummary already exists for the given Step -
/// NOT_FOUND - The containing Step does not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PerfSampleSeries].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PerfSampleSeries> create(
PerfSampleSeries request,
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfSampleSeries';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => PerfSampleSeries.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a PerfSampleSeries. May return any of the following error code(s): -
/// NOT_FOUND - The specified PerfSampleSeries does not exist
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [sampleSeriesId] - A sample series id
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [PerfSampleSeries].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<PerfSampleSeries> get(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId,
core.String sampleSeriesId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (sampleSeriesId == null) {
throw core.ArgumentError('Parameter sampleSeriesId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfSampleSeries/' +
commons.Escaper.ecapeVariable('$sampleSeriesId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => PerfSampleSeries.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Lists PerfSampleSeries for a given Step. The request provides an optional
/// filter which specifies one or more PerfMetricsType to include in the
/// result; if none returns all. The resulting PerfSampleSeries are sorted by
/// ids. May return any of the following canonical error codes: - NOT_FOUND -
/// The containing Step does not exist
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [filter] - Specify one or more PerfMetricType values such as CPU to filter
/// the result
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListPerfSampleSeriesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListPerfSampleSeriesResponse> list(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.List<core.String> filter,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (filter != null) {
_queryParams['filter'] = filter;
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfSampleSeries';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListPerfSampleSeriesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsPerfSampleSeriesSamplesResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsPerfSampleSeriesSamplesResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Creates a batch of PerfSamples - a client can submit multiple batches of
/// Perf Samples through repeated calls to this method in order to split up a
/// large request payload - duplicates and existing timestamp entries will be
/// ignored. - the batch operation may partially succeed - the set of elements
/// successfully inserted is returned in the response (omits items which
/// already existed in the database). May return any of the following
/// canonical error codes: - NOT_FOUND - The containing PerfSampleSeries does
/// not exist
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [sampleSeriesId] - A sample series id
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [BatchCreatePerfSamplesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<BatchCreatePerfSamplesResponse> batchCreate(
BatchCreatePerfSamplesRequest request,
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId,
core.String sampleSeriesId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (sampleSeriesId == null) {
throw core.ArgumentError('Parameter sampleSeriesId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfSampleSeries/' +
commons.Escaper.ecapeVariable('$sampleSeriesId') +
'/samples:batchCreate';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => BatchCreatePerfSamplesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Lists the Performance Samples of a given Sample Series - The list results
/// are sorted by timestamps ascending - The default page size is 500 samples;
/// and maximum size allowed 5000 - The response token indicates the last
/// returned PerfSample timestamp - When the results size exceeds the page
/// size, submit a subsequent request including the page token to return the
/// rest of the samples up to the page limit May return any of the following
/// canonical error codes: - OUT_OF_RANGE - The specified request page_token
/// is out of valid range - NOT_FOUND - The containing PerfSampleSeries does
/// not exist
///
/// Request parameters:
///
/// [projectId] - The cloud project
///
/// [historyId] - A tool results history ID.
///
/// [executionId] - A tool results execution ID.
///
/// [stepId] - A tool results step ID.
///
/// [sampleSeriesId] - A sample series id
///
/// [pageSize] - The default page size is 500 samples, and the maximum size is
/// 5000. If the page_size is greater than 5000, the effective page size will
/// be 5000
///
/// [pageToken] - Optional, the next_page_token returned in the previous
/// response
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListPerfSamplesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListPerfSamplesResponse> list(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId,
core.String sampleSeriesId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (sampleSeriesId == null) {
throw core.ArgumentError('Parameter sampleSeriesId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/perfSampleSeries/' +
commons.Escaper.ecapeVariable('$sampleSeriesId') +
'/samples';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListPerfSamplesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsTestCasesResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsTestCasesResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Gets details of a Test Case for a Step. Experimental test cases API. Still
/// in active development. 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 Test Case does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id Required.
///
/// [stepId] - A Step id. Note: This step must include a TestExecutionStep.
/// Required.
///
/// [testCaseId] - A Test Case id. Required.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestCase].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<TestCase> get(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId,
core.String testCaseId, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (testCaseId == null) {
throw core.ArgumentError('Parameter testCaseId is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/testCases/' +
commons.Escaper.ecapeVariable('$testCaseId');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => TestCase.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists Test Cases attached to a Step. Experimental test cases API. Still in
/// active development. 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 Step does not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - A Execution id Required.
///
/// [stepId] - A Step id. Note: This step must include a TestExecutionStep.
/// Required.
///
/// [pageSize] - The maximum number of TestCases to fetch. Default value: 100.
/// The server will use this default if the field is not set or has a value of
/// 0. Optional.
///
/// [pageToken] - A continuation token to resume the query at the next item.
/// Optional.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListTestCasesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListTestCasesResponse> list(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/testCases';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListTestCasesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class ProjectsHistoriesExecutionsStepsThumbnailsResourceApi {
final commons.ApiRequester _requester;
ProjectsHistoriesExecutionsStepsThumbnailsResourceApi(
commons.ApiRequester client)
: _requester = client;
/// Lists thumbnails of images attached to a step. May return any of the
/// following canonical error codes: - PERMISSION_DENIED - if the user is not
/// authorized to read from the project, or from any of the images -
/// INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the step
/// does not exist, or if any of the images do not exist
///
/// Request parameters:
///
/// [projectId] - A Project id. Required.
///
/// [historyId] - A History id. Required.
///
/// [executionId] - An Execution id. Required.
///
/// [stepId] - A Step id. Required.
///
/// [pageSize] - The maximum number of thumbnails to fetch. Default value: 50.
/// The server will use this default if the field is not set or has a value of
/// 0. Optional.
///
/// [pageToken] - A continuation token to resume the query at the next item.
/// Optional.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListStepThumbnailsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListStepThumbnailsResponse> list(
core.String projectId,
core.String historyId,
core.String executionId,
core.String stepId, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (projectId == null) {
throw core.ArgumentError('Parameter projectId is required.');
}
if (historyId == null) {
throw core.ArgumentError('Parameter historyId is required.');
}
if (executionId == null) {
throw core.ArgumentError('Parameter executionId is required.');
}
if (stepId == null) {
throw core.ArgumentError('Parameter stepId is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'toolresults/v1beta3/projects/' +
commons.Escaper.ecapeVariable('$projectId') +
'/histories/' +
commons.Escaper.ecapeVariable('$historyId') +
'/executions/' +
commons.Escaper.ecapeVariable('$executionId') +
'/steps/' +
commons.Escaper.ecapeVariable('$stepId') +
'/thumbnails';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListStepThumbnailsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
/// Additional details for an ANR crash.
class ANR {
/// The stack trace of the ANR crash. Optional.
StackTrace stackTrace;
ANR();
ANR.fromJson(core.Map _json) {
if (_json.containsKey('stackTrace')) {
stackTrace = StackTrace.fromJson(
_json['stackTrace'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (stackTrace != null) {
_json['stackTrace'] = stackTrace.toJson();
}
return _json;
}
}
/// Android app information.
class AndroidAppInfo {
/// The name of the app. Optional
core.String name;
/// The package name of the app. Required.
core.String packageName;
/// The internal version code of the app. Optional.
core.String versionCode;
/// The version name of the app. Optional.
core.String versionName;
AndroidAppInfo();
AndroidAppInfo.fromJson(core.Map _json) {
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('versionCode')) {
versionCode = _json['versionCode'] as core.String;
}
if (_json.containsKey('versionName')) {
versionName = _json['versionName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (name != null) {
_json['name'] = name;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
if (versionCode != null) {
_json['versionCode'] = versionCode;
}
if (versionName != null) {
_json['versionName'] = versionName;
}
return _json;
}
}
/// 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.
class AndroidInstrumentationTest {
/// The java package for the test to be executed. Required
core.String testPackageId;
/// The InstrumentationTestRunner class. Required
core.String testRunnerClass;
/// 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.
core.List<core.String> testTargets;
/// The flag indicates whether Android Test Orchestrator will be used to run
/// test or not.
core.bool useOrchestrator;
AndroidInstrumentationTest();
AndroidInstrumentationTest.fromJson(core.Map _json) {
if (_json.containsKey('testPackageId')) {
testPackageId = _json['testPackageId'] as core.String;
}
if (_json.containsKey('testRunnerClass')) {
testRunnerClass = _json['testRunnerClass'] as core.String;
}
if (_json.containsKey('testTargets')) {
testTargets = (_json['testTargets'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('useOrchestrator')) {
useOrchestrator = _json['useOrchestrator'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (testPackageId != null) {
_json['testPackageId'] = testPackageId;
}
if (testRunnerClass != null) {
_json['testRunnerClass'] = testRunnerClass;
}
if (testTargets != null) {
_json['testTargets'] = testTargets;
}
if (useOrchestrator != null) {
_json['useOrchestrator'] = useOrchestrator;
}
return _json;
}
}
/// A test of an android application that explores the application on a virtual
/// or physical Android device, finding culprits and crashes as it goes.
class AndroidRoboTest {
/// The initial activity that should be used to start the app. Optional
core.String appInitialActivity;
/// The java package for the bootstrap. Optional
core.String bootstrapPackageId;
/// The runner class for the bootstrap. Optional
core.String bootstrapRunnerClass;
/// The max depth of the traversal stack Robo can explore. Optional
core.int maxDepth;
/// The max number of steps/actions Robo can execute. Default is no limit (0).
/// Optional
core.int maxSteps;
AndroidRoboTest();
AndroidRoboTest.fromJson(core.Map _json) {
if (_json.containsKey('appInitialActivity')) {
appInitialActivity = _json['appInitialActivity'] as core.String;
}
if (_json.containsKey('bootstrapPackageId')) {
bootstrapPackageId = _json['bootstrapPackageId'] as core.String;
}
if (_json.containsKey('bootstrapRunnerClass')) {
bootstrapRunnerClass = _json['bootstrapRunnerClass'] as core.String;
}
if (_json.containsKey('maxDepth')) {
maxDepth = _json['maxDepth'] as core.int;
}
if (_json.containsKey('maxSteps')) {
maxSteps = _json['maxSteps'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (appInitialActivity != null) {
_json['appInitialActivity'] = appInitialActivity;
}
if (bootstrapPackageId != null) {
_json['bootstrapPackageId'] = bootstrapPackageId;
}
if (bootstrapRunnerClass != null) {
_json['bootstrapRunnerClass'] = bootstrapRunnerClass;
}
if (maxDepth != null) {
_json['maxDepth'] = maxDepth;
}
if (maxSteps != null) {
_json['maxSteps'] = maxSteps;
}
return _json;
}
}
/// An Android mobile test specification.
class AndroidTest {
/// Information about the application under test.
AndroidAppInfo androidAppInfo;
/// An Android instrumentation test.
AndroidInstrumentationTest androidInstrumentationTest;
/// An Android robo test.
AndroidRoboTest androidRoboTest;
/// An Android test loop.
AndroidTestLoop androidTestLoop;
/// Max time a test is allowed to run before it is automatically cancelled.
Duration testTimeout;
AndroidTest();
AndroidTest.fromJson(core.Map _json) {
if (_json.containsKey('androidAppInfo')) {
androidAppInfo = AndroidAppInfo.fromJson(
_json['androidAppInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('androidInstrumentationTest')) {
androidInstrumentationTest = AndroidInstrumentationTest.fromJson(
_json['androidInstrumentationTest']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('androidRoboTest')) {
androidRoboTest = AndroidRoboTest.fromJson(
_json['androidRoboTest'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('androidTestLoop')) {
androidTestLoop = AndroidTestLoop.fromJson(
_json['androidTestLoop'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('testTimeout')) {
testTimeout = Duration.fromJson(
_json['testTimeout'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (androidAppInfo != null) {
_json['androidAppInfo'] = androidAppInfo.toJson();
}
if (androidInstrumentationTest != null) {
_json['androidInstrumentationTest'] = androidInstrumentationTest.toJson();
}
if (androidRoboTest != null) {
_json['androidRoboTest'] = androidRoboTest.toJson();
}
if (androidTestLoop != null) {
_json['androidTestLoop'] = androidTestLoop.toJson();
}
if (testTimeout != null) {
_json['testTimeout'] = testTimeout.toJson();
}
return _json;
}
}
/// Test Loops are tests that can be launched by the app itself, determining
/// when to run by listening for an intent.
class AndroidTestLoop {
AndroidTestLoop();
AndroidTestLoop.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// `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" }
class 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.
core.String typeUrl;
/// Must be a valid serialized protocol buffer of the above specified type.
core.String value;
core.List<core.int> get valueAsBytes => convert.base64.decode(value);
set valueAsBytes(core.List<core.int> _bytes) {
value =
convert.base64.encode(_bytes).replaceAll('/', '_').replaceAll('+', '-');
}
Any();
Any.fromJson(core.Map _json) {
if (_json.containsKey('typeUrl')) {
typeUrl = _json['typeUrl'] as core.String;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (typeUrl != null) {
_json['typeUrl'] = typeUrl;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
class 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
Duration fullyDrawnTime;
/// 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
Duration initialDisplayTime;
AppStartTime();
AppStartTime.fromJson(core.Map _json) {
if (_json.containsKey('fullyDrawnTime')) {
fullyDrawnTime = Duration.fromJson(
_json['fullyDrawnTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('initialDisplayTime')) {
initialDisplayTime = Duration.fromJson(
_json['initialDisplayTime'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (fullyDrawnTime != null) {
_json['fullyDrawnTime'] = fullyDrawnTime.toJson();
}
if (initialDisplayTime != null) {
_json['initialDisplayTime'] = initialDisplayTime.toJson();
}
return _json;
}
}
/// A suggestion to use deep links for a Robo run.
class AvailableDeepLinks {
AvailableDeepLinks();
AvailableDeepLinks.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Encapsulates the metadata for basic sample series represented by a line
/// chart
class BasicPerfSampleSeries {
///
/// Possible string values are:
/// - "perfMetricTypeUnspecified"
/// - "memory"
/// - "cpu"
/// - "network"
/// - "graphics"
core.String perfMetricType;
///
/// Possible string values are:
/// - "perfUnitUnspecified"
/// - "kibibyte"
/// - "percent"
/// - "bytesPerSecond"
/// - "framesPerSecond"
/// - "byte"
core.String perfUnit;
///
/// Possible string values are:
/// - "sampleSeriesTypeUnspecified"
/// - "memoryRssPrivate" : Memory sample series
/// - "memoryRssShared"
/// - "memoryRssTotal"
/// - "memoryTotal"
/// - "cpuUser" : CPU sample series
/// - "cpuKernel"
/// - "cpuTotal"
/// - "ntBytesTransferred" : Network sample series
/// - "ntBytesReceived"
/// - "networkSent"
/// - "networkReceived"
/// - "graphicsFrameRate" : Graphics sample series
core.String sampleSeriesLabel;
BasicPerfSampleSeries();
BasicPerfSampleSeries.fromJson(core.Map _json) {
if (_json.containsKey('perfMetricType')) {
perfMetricType = _json['perfMetricType'] as core.String;
}
if (_json.containsKey('perfUnit')) {
perfUnit = _json['perfUnit'] as core.String;
}
if (_json.containsKey('sampleSeriesLabel')) {
sampleSeriesLabel = _json['sampleSeriesLabel'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (perfMetricType != null) {
_json['perfMetricType'] = perfMetricType;
}
if (perfUnit != null) {
_json['perfUnit'] = perfUnit;
}
if (sampleSeriesLabel != null) {
_json['sampleSeriesLabel'] = sampleSeriesLabel;
}
return _json;
}
}
/// The request must provide up to a maximum of 5000 samples to be created; a
/// larger sample size will cause an INVALID_ARGUMENT error
class BatchCreatePerfSamplesRequest {
/// The set of PerfSamples to create should not include existing timestamps
core.List<PerfSample> perfSamples;
BatchCreatePerfSamplesRequest();
BatchCreatePerfSamplesRequest.fromJson(core.Map _json) {
if (_json.containsKey('perfSamples')) {
perfSamples = (_json['perfSamples'] as core.List)
.map<PerfSample>((value) =>
PerfSample.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (perfSamples != null) {
_json['perfSamples'] =
perfSamples.map((value) => value.toJson()).toList();
}
return _json;
}
}
class BatchCreatePerfSamplesResponse {
core.List<PerfSample> perfSamples;
BatchCreatePerfSamplesResponse();
BatchCreatePerfSamplesResponse.fromJson(core.Map _json) {
if (_json.containsKey('perfSamples')) {
perfSamples = (_json['perfSamples'] as core.List)
.map<PerfSample>((value) =>
PerfSample.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (perfSamples != null) {
_json['perfSamples'] =
perfSamples.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// A warning that Robo encountered a screen that was mostly blank; this may
/// indicate a problem with the app.
class BlankScreen {
/// The screen id of the element
core.String screenId;
BlankScreen();
BlankScreen.fromJson(core.Map _json) {
if (_json.containsKey('screenId')) {
screenId = _json['screenId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (screenId != null) {
_json['screenId'] = screenId;
}
return _json;
}
}
class CPUInfo {
/// description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A'
core.String cpuProcessor;
/// the CPU clock speed in GHz
core.double cpuSpeedInGhz;
/// the number of CPU cores
core.int numberOfCores;
CPUInfo();
CPUInfo.fromJson(core.Map _json) {
if (_json.containsKey('cpuProcessor')) {
cpuProcessor = _json['cpuProcessor'] as core.String;
}
if (_json.containsKey('cpuSpeedInGhz')) {
cpuSpeedInGhz = (_json['cpuSpeedInGhz'] as core.num).toDouble();
}
if (_json.containsKey('numberOfCores')) {
numberOfCores = _json['numberOfCores'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (cpuProcessor != null) {
_json['cpuProcessor'] = cpuProcessor;
}
if (cpuSpeedInGhz != null) {
_json['cpuSpeedInGhz'] = cpuSpeedInGhz;
}
if (numberOfCores != null) {
_json['numberOfCores'] = numberOfCores;
}
return _json;
}
}
/// Crash dialog was detected during the test execution
class CrashDialogError {
/// The name of the package that caused the dialog.
core.String crashPackage;
CrashDialogError();
CrashDialogError.fromJson(core.Map _json) {
if (_json.containsKey('crashPackage')) {
crashPackage = _json['crashPackage'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (crashPackage != null) {
_json['crashPackage'] = crashPackage;
}
return _json;
}
}
/// 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.
class 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.
core.int nanos;
/// 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
core.String seconds;
Duration();
Duration.fromJson(core.Map _json) {
if (_json.containsKey('nanos')) {
nanos = _json['nanos'] as core.int;
}
if (_json.containsKey('seconds')) {
seconds = _json['seconds'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nanos != null) {
_json['nanos'] = nanos;
}
if (seconds != null) {
_json['seconds'] = seconds;
}
return _json;
}
}
/// Additional details about encountered login screens.
class EncounteredLoginScreen {
/// Number of encountered distinct login screens.
core.int distinctScreens;
/// Subset of login screens.
core.List<core.String> screenIds;
EncounteredLoginScreen();
EncounteredLoginScreen.fromJson(core.Map _json) {
if (_json.containsKey('distinctScreens')) {
distinctScreens = _json['distinctScreens'] as core.int;
}
if (_json.containsKey('screenIds')) {
screenIds = (_json['screenIds'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (distinctScreens != null) {
_json['distinctScreens'] = distinctScreens;
}
if (screenIds != null) {
_json['screenIds'] = screenIds;
}
return _json;
}
}
/// Additional details about encountered screens with elements that are not
/// Android UI widgets.
class EncounteredNonAndroidUiWidgetScreen {
/// Number of encountered distinct screens with non Android UI widgets.
core.int distinctScreens;
/// Subset of screens which contain non Android UI widgets.
core.List<core.String> screenIds;
EncounteredNonAndroidUiWidgetScreen();
EncounteredNonAndroidUiWidgetScreen.fromJson(core.Map _json) {
if (_json.containsKey('distinctScreens')) {
distinctScreens = _json['distinctScreens'] as core.int;
}
if (_json.containsKey('screenIds')) {
screenIds = (_json['screenIds'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (distinctScreens != null) {
_json['distinctScreens'] = distinctScreens;
}
if (screenIds != null) {
_json['screenIds'] = screenIds;
}
return _json;
}
}
/// 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).
class Environment {
/// Output only. The time when the Environment status was set to complete.
/// This value will be set automatically when state transitions to COMPLETE.
Timestamp completionTime;
/// Output only. The time when the Environment was created.
Timestamp creationTime;
/// 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
core.List<EnvironmentDimensionValueEntry> dimensionValue;
/// A short human-readable name to display in the UI. Maximum of 100
/// characters. For example: Nexus 5, API 27.
core.String displayName;
/// Output only. An Environment id.
core.String environmentId;
/// Merged result of the environment.
MergedResult environmentResult;
/// Output only. An Execution id.
core.String executionId;
/// Output only. A History id.
core.String historyId;
/// Output only. A Project id.
core.String projectId;
/// The location where output files are stored in the user bucket.
ResultsStorage resultsStorage;
/// Output only. Summaries of shards. Only one shard will present unless
/// sharding feature is enabled in TestExecutionService.
core.List<ShardSummary> shardSummaries;
Environment();
Environment.fromJson(core.Map _json) {
if (_json.containsKey('completionTime')) {
completionTime = Timestamp.fromJson(
_json['completionTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('creationTime')) {
creationTime = Timestamp.fromJson(
_json['creationTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('dimensionValue')) {
dimensionValue = (_json['dimensionValue'] as core.List)
.map<EnvironmentDimensionValueEntry>((value) =>
EnvironmentDimensionValueEntry.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('displayName')) {
displayName = _json['displayName'] as core.String;
}
if (_json.containsKey('environmentId')) {
environmentId = _json['environmentId'] as core.String;
}
if (_json.containsKey('environmentResult')) {
environmentResult = MergedResult.fromJson(
_json['environmentResult'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('executionId')) {
executionId = _json['executionId'] as core.String;
}
if (_json.containsKey('historyId')) {
historyId = _json['historyId'] as core.String;
}
if (_json.containsKey('projectId')) {
projectId = _json['projectId'] as core.String;
}
if (_json.containsKey('resultsStorage')) {
resultsStorage = ResultsStorage.fromJson(
_json['resultsStorage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('shardSummaries')) {
shardSummaries = (_json['shardSummaries'] as core.List)
.map<ShardSummary>((value) => ShardSummary.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (completionTime != null) {
_json['completionTime'] = completionTime.toJson();
}
if (creationTime != null) {
_json['creationTime'] = creationTime.toJson();
}
if (dimensionValue != null) {
_json['dimensionValue'] =
dimensionValue.map((value) => value.toJson()).toList();
}
if (displayName != null) {
_json['displayName'] = displayName;
}
if (environmentId != null) {
_json['environmentId'] = environmentId;
}
if (environmentResult != null) {
_json['environmentResult'] = environmentResult.toJson();
}
if (executionId != null) {
_json['executionId'] = executionId;
}
if (historyId != null) {
_json['historyId'] = historyId;
}
if (projectId != null) {
_json['projectId'] = projectId;
}
if (resultsStorage != null) {
_json['resultsStorage'] = resultsStorage.toJson();
}
if (shardSummaries != null) {
_json['shardSummaries'] =
shardSummaries.map((value) => value.toJson()).toList();
}
return _json;
}
}
class EnvironmentDimensionValueEntry {
core.String key;
core.String value;
EnvironmentDimensionValueEntry();
EnvironmentDimensionValueEntry.fromJson(core.Map _json) {
if (_json.containsKey('key')) {
key = _json['key'] as core.String;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (key != null) {
_json['key'] = key;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// 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.
class 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
Timestamp completionTime;
/// 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
Timestamp creationTime;
/// 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
core.List<MatrixDimensionDefinition> dimensionDefinitions;
/// 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
core.String executionId;
/// Classify the result, for example into SUCCESS or FAILURE - In response:
/// present if set by create/update request - In create/update request:
/// optional
Outcome outcome;
/// Lightweight information about execution request. - In response: present if
/// set by create - In create: optional - In update: optional
Specification 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
/// Possible string values are:
/// - "unknownState" : Should never be in this state. Exists for proto
/// deserialization backward compatibility.
/// - "pending" : The Execution/Step is created, ready to run, but not running
/// yet. If an Execution/Step is created without initial state, it is assumed
/// that the Execution/Step is in PENDING state.
/// - "inProgress" : The Execution/Step is in progress.
/// - "complete" : The finalized, immutable state. Steps/Executions in this
/// state cannot be modified.
core.String state;
/// TestExecution Matrix ID that the TestExecutionService uses. - In response:
/// present if set by create - In create: optional - In update: never set
core.String testExecutionMatrixId;
Execution();
Execution.fromJson(core.Map _json) {
if (_json.containsKey('completionTime')) {
completionTime = Timestamp.fromJson(
_json['completionTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('creationTime')) {
creationTime = Timestamp.fromJson(
_json['creationTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('dimensionDefinitions')) {
dimensionDefinitions = (_json['dimensionDefinitions'] as core.List)
.map<MatrixDimensionDefinition>((value) =>
MatrixDimensionDefinition.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('executionId')) {
executionId = _json['executionId'] as core.String;
}
if (_json.containsKey('outcome')) {
outcome = Outcome.fromJson(
_json['outcome'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('specification')) {
specification = Specification.fromJson(
_json['specification'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('testExecutionMatrixId')) {
testExecutionMatrixId = _json['testExecutionMatrixId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (completionTime != null) {
_json['completionTime'] = completionTime.toJson();
}
if (creationTime != null) {
_json['creationTime'] = creationTime.toJson();
}
if (dimensionDefinitions != null) {
_json['dimensionDefinitions'] =
dimensionDefinitions.map((value) => value.toJson()).toList();
}
if (executionId != null) {
_json['executionId'] = executionId;
}
if (outcome != null) {
_json['outcome'] = outcome.toJson();
}
if (specification != null) {
_json['specification'] = specification.toJson();
}
if (state != null) {
_json['state'] = state;
}
if (testExecutionMatrixId != null) {
_json['testExecutionMatrixId'] = testExecutionMatrixId;
}
return _json;
}
}
/// Failed to install the APK.
class FailedToInstall {
FailedToInstall();
FailedToInstall.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Details for an outcome with a FAILURE outcome summary.
class FailureDetail {
/// If the failure was severe because the system (app) under test crashed.
core.bool crashed;
/// If the device ran out of memory during a test, causing the test to crash.
core.bool deviceOutOfMemory;
/// 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.
core.bool failedRoboscript;
/// 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.
core.bool notInstalled;
/// If a native process (including any other than the app) crashed.
core.bool otherNativeCrash;
/// If the test overran some time limit, and that is why it failed.
core.bool timedOut;
/// If the robo was unable to crawl the app; perhaps because the app did not
/// start.
core.bool unableToCrawl;
FailureDetail();
FailureDetail.fromJson(core.Map _json) {
if (_json.containsKey('crashed')) {
crashed = _json['crashed'] as core.bool;
}
if (_json.containsKey('deviceOutOfMemory')) {
deviceOutOfMemory = _json['deviceOutOfMemory'] as core.bool;
}
if (_json.containsKey('failedRoboscript')) {
failedRoboscript = _json['failedRoboscript'] as core.bool;
}
if (_json.containsKey('notInstalled')) {
notInstalled = _json['notInstalled'] as core.bool;
}
if (_json.containsKey('otherNativeCrash')) {
otherNativeCrash = _json['otherNativeCrash'] as core.bool;
}
if (_json.containsKey('timedOut')) {
timedOut = _json['timedOut'] as core.bool;
}
if (_json.containsKey('unableToCrawl')) {
unableToCrawl = _json['unableToCrawl'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (crashed != null) {
_json['crashed'] = crashed;
}
if (deviceOutOfMemory != null) {
_json['deviceOutOfMemory'] = deviceOutOfMemory;
}
if (failedRoboscript != null) {
_json['failedRoboscript'] = failedRoboscript;
}
if (notInstalled != null) {
_json['notInstalled'] = notInstalled;
}
if (otherNativeCrash != null) {
_json['otherNativeCrash'] = otherNativeCrash;
}
if (timedOut != null) {
_json['timedOut'] = timedOut;
}
if (unableToCrawl != null) {
_json['unableToCrawl'] = unableToCrawl;
}
return _json;
}
}
/// Additional details for a fatal exception.
class FatalException {
/// The stack trace of the fatal exception. Optional.
StackTrace stackTrace;
FatalException();
FatalException.fromJson(core.Map _json) {
if (_json.containsKey('stackTrace')) {
stackTrace = StackTrace.fromJson(
_json['stackTrace'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (stackTrace != null) {
_json['stackTrace'] = stackTrace.toJson();
}
return _json;
}
}
/// A reference to a file.
class 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
core.String fileUri;
FileReference();
FileReference.fromJson(core.Map _json) {
if (_json.containsKey('fileUri')) {
fileUri = _json['fileUri'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (fileUri != null) {
_json['fileUri'] = fileUri;
}
return _json;
}
}
/// 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+.
class GraphicsStats {
/// Histogram of frame render times. There should be 154 buckets ranging from
/// [5ms, 6ms) to [4950ms, infinity)
core.List<GraphicsStatsBucket> buckets;
/// Total "high input latency" events.
core.String highInputLatencyCount;
/// Total frames with slow render time. Should be <= total_frames.
core.String jankyFrames;
/// Total "missed vsync" events.
core.String missedVsyncCount;
/// 50th percentile frame render time in milliseconds.
core.String p50Millis;
/// 90th percentile frame render time in milliseconds.
core.String p90Millis;
/// 95th percentile frame render time in milliseconds.
core.String p95Millis;
/// 99th percentile frame render time in milliseconds.
core.String p99Millis;
/// Total "slow bitmap upload" events.
core.String slowBitmapUploadCount;
/// Total "slow draw" events.
core.String slowDrawCount;
/// Total "slow UI thread" events.
core.String slowUiThreadCount;
/// Total frames rendered by package.
core.String totalFrames;
GraphicsStats();
GraphicsStats.fromJson(core.Map _json) {
if (_json.containsKey('buckets')) {
buckets = (_json['buckets'] as core.List)
.map<GraphicsStatsBucket>((value) => GraphicsStatsBucket.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('highInputLatencyCount')) {
highInputLatencyCount = _json['highInputLatencyCount'] as core.String;
}
if (_json.containsKey('jankyFrames')) {
jankyFrames = _json['jankyFrames'] as core.String;
}
if (_json.containsKey('missedVsyncCount')) {
missedVsyncCount = _json['missedVsyncCount'] as core.String;
}
if (_json.containsKey('p50Millis')) {
p50Millis = _json['p50Millis'] as core.String;
}
if (_json.containsKey('p90Millis')) {
p90Millis = _json['p90Millis'] as core.String;
}
if (_json.containsKey('p95Millis')) {
p95Millis = _json['p95Millis'] as core.String;
}
if (_json.containsKey('p99Millis')) {
p99Millis = _json['p99Millis'] as core.String;
}
if (_json.containsKey('slowBitmapUploadCount')) {
slowBitmapUploadCount = _json['slowBitmapUploadCount'] as core.String;
}
if (_json.containsKey('slowDrawCount')) {
slowDrawCount = _json['slowDrawCount'] as core.String;
}
if (_json.containsKey('slowUiThreadCount')) {
slowUiThreadCount = _json['slowUiThreadCount'] as core.String;
}
if (_json.containsKey('totalFrames')) {
totalFrames = _json['totalFrames'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (buckets != null) {
_json['buckets'] = buckets.map((value) => value.toJson()).toList();
}
if (highInputLatencyCount != null) {
_json['highInputLatencyCount'] = highInputLatencyCount;
}
if (jankyFrames != null) {
_json['jankyFrames'] = jankyFrames;
}
if (missedVsyncCount != null) {
_json['missedVsyncCount'] = missedVsyncCount;
}
if (p50Millis != null) {
_json['p50Millis'] = p50Millis;
}
if (p90Millis != null) {
_json['p90Millis'] = p90Millis;
}
if (p95Millis != null) {
_json['p95Millis'] = p95Millis;
}
if (p99Millis != null) {
_json['p99Millis'] = p99Millis;
}
if (slowBitmapUploadCount != null) {
_json['slowBitmapUploadCount'] = slowBitmapUploadCount;
}
if (slowDrawCount != null) {
_json['slowDrawCount'] = slowDrawCount;
}
if (slowUiThreadCount != null) {
_json['slowUiThreadCount'] = slowUiThreadCount;
}
if (totalFrames != null) {
_json['totalFrames'] = totalFrames;
}
return _json;
}
}
class GraphicsStatsBucket {
/// Number of frames in the bucket.
core.String frameCount;
/// Lower bound of render time in milliseconds.
core.String renderMillis;
GraphicsStatsBucket();
GraphicsStatsBucket.fromJson(core.Map _json) {
if (_json.containsKey('frameCount')) {
frameCount = _json['frameCount'] as core.String;
}
if (_json.containsKey('renderMillis')) {
renderMillis = _json['renderMillis'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (frameCount != null) {
_json['frameCount'] = frameCount;
}
if (renderMillis != null) {
_json['renderMillis'] = renderMillis;
}
return _json;
}
}
/// 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.
class 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
core.String displayName;
/// 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
core.String historyId;
/// A name to uniquely identify a history within a project. Maximum of 200
/// characters. - In response always set - In create request: always set
core.String name;
/// The platform of the test history. - In response: always set. Returns the
/// platform of the last execution if unknown.
/// Possible string values are:
/// - "unknownPlatform"
/// - "android"
/// - "ios"
core.String testPlatform;
History();
History.fromJson(core.Map _json) {
if (_json.containsKey('displayName')) {
displayName = _json['displayName'] as core.String;
}
if (_json.containsKey('historyId')) {
historyId = _json['historyId'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('testPlatform')) {
testPlatform = _json['testPlatform'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (displayName != null) {
_json['displayName'] = displayName;
}
if (historyId != null) {
_json['historyId'] = historyId;
}
if (name != null) {
_json['name'] = name;
}
if (testPlatform != null) {
_json['testPlatform'] = testPlatform;
}
return _json;
}
}
/// An image, with a link to the main image and a thumbnail.
class Image {
/// An error explaining why the thumbnail could not be rendered.
Status error;
/// 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.
ToolOutputReference sourceImage;
/// The step to which the image is attached. Always set.
core.String stepId;
/// The thumbnail.
Thumbnail thumbnail;
Image();
Image.fromJson(core.Map _json) {
if (_json.containsKey('error')) {
error = Status.fromJson(
_json['error'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('sourceImage')) {
sourceImage = ToolOutputReference.fromJson(
_json['sourceImage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('stepId')) {
stepId = _json['stepId'] as core.String;
}
if (_json.containsKey('thumbnail')) {
thumbnail = Thumbnail.fromJson(
_json['thumbnail'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (error != null) {
_json['error'] = error.toJson();
}
if (sourceImage != null) {
_json['sourceImage'] = sourceImage.toJson();
}
if (stepId != null) {
_json['stepId'] = stepId;
}
if (thumbnail != null) {
_json['thumbnail'] = thumbnail.toJson();
}
return _json;
}
}
/// Additional details of in-app purchases encountered during the crawl.
class InAppPurchasesFound {
/// The total number of in-app purchases flows explored: how many times the
/// robo tries to buy a SKU.
core.int inAppPurchasesFlowsExplored;
/// The total number of in-app purchases flows started.
core.int inAppPurchasesFlowsStarted;
InAppPurchasesFound();
InAppPurchasesFound.fromJson(core.Map _json) {
if (_json.containsKey('inAppPurchasesFlowsExplored')) {
inAppPurchasesFlowsExplored =
_json['inAppPurchasesFlowsExplored'] as core.int;
}
if (_json.containsKey('inAppPurchasesFlowsStarted')) {
inAppPurchasesFlowsStarted =
_json['inAppPurchasesFlowsStarted'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (inAppPurchasesFlowsExplored != null) {
_json['inAppPurchasesFlowsExplored'] = inAppPurchasesFlowsExplored;
}
if (inAppPurchasesFlowsStarted != null) {
_json['inAppPurchasesFlowsStarted'] = inAppPurchasesFlowsStarted;
}
return _json;
}
}
/// Details for an outcome with an INCONCLUSIVE outcome summary.
class 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.
core.bool abortedByUser;
/// If results are being provided to the user in certain cases of
/// infrastructure failures
core.bool hasErrorLogs;
/// 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.
core.bool infrastructureFailure;
InconclusiveDetail();
InconclusiveDetail.fromJson(core.Map _json) {
if (_json.containsKey('abortedByUser')) {
abortedByUser = _json['abortedByUser'] as core.bool;
}
if (_json.containsKey('hasErrorLogs')) {
hasErrorLogs = _json['hasErrorLogs'] as core.bool;
}
if (_json.containsKey('infrastructureFailure')) {
infrastructureFailure = _json['infrastructureFailure'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (abortedByUser != null) {
_json['abortedByUser'] = abortedByUser;
}
if (hasErrorLogs != null) {
_json['hasErrorLogs'] = hasErrorLogs;
}
if (infrastructureFailure != null) {
_json['infrastructureFailure'] = infrastructureFailure;
}
return _json;
}
}
/// Step Id and outcome of each individual step that was run as a group with
/// other steps with the same configuration.
class IndividualOutcome {
/// Unique int given to each step. Ranges from 0(inclusive) to total number of
/// steps(exclusive). The primary step is 0.
core.int multistepNumber;
///
/// Possible string values are:
/// - "unset" : Do not use. For proto versioning only.
/// - "success" : The test matrix run was successful, for instance: - All the
/// test cases passed. - Robo did not detect a crash of the application under
/// test.
/// - "failure" : A run failed, for instance: - One or more test case failed.
/// - A test timed out. - The application under test crashed.
/// - "inconclusive" : Something unexpected happened. The run should still be
/// considered unsuccessful but this is likely a transient problem and
/// re-running the test might be successful.
/// - "skipped" : All tests were skipped, for instance: - All device
/// configurations were incompatible.
/// - "flaky" : A group of steps that were run with the same configuration had
/// both failure and success outcomes.
core.String outcomeSummary;
/// How long it took for this step to run.
Duration runDuration;
core.String stepId;
IndividualOutcome();
IndividualOutcome.fromJson(core.Map _json) {
if (_json.containsKey('multistepNumber')) {
multistepNumber = _json['multistepNumber'] as core.int;
}
if (_json.containsKey('outcomeSummary')) {
outcomeSummary = _json['outcomeSummary'] as core.String;
}
if (_json.containsKey('runDuration')) {
runDuration = Duration.fromJson(
_json['runDuration'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('stepId')) {
stepId = _json['stepId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (multistepNumber != null) {
_json['multistepNumber'] = multistepNumber;
}
if (outcomeSummary != null) {
_json['outcomeSummary'] = outcomeSummary;
}
if (runDuration != null) {
_json['runDuration'] = runDuration.toJson();
}
if (stepId != null) {
_json['stepId'] = stepId;
}
return _json;
}
}
/// A warning that Robo did not crawl potentially important parts of the app.
class InsufficientCoverage {
InsufficientCoverage();
InsufficientCoverage.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Additional details for an iOS app crash.
class IosAppCrashed {
/// The stack trace, if one is available. Optional.
StackTrace stackTrace;
IosAppCrashed();
IosAppCrashed.fromJson(core.Map _json) {
if (_json.containsKey('stackTrace')) {
stackTrace = StackTrace.fromJson(
_json['stackTrace'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (stackTrace != null) {
_json['stackTrace'] = stackTrace.toJson();
}
return _json;
}
}
/// iOS app information
class IosAppInfo {
/// The name of the app. Required
core.String name;
IosAppInfo();
IosAppInfo.fromJson(core.Map _json) {
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (name != null) {
_json['name'] = name;
}
return _json;
}
}
/// A Robo test for an iOS application.
class IosRoboTest {
IosRoboTest();
IosRoboTest.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// A iOS mobile test specification
class IosTest {
/// Information about the application under test.
IosAppInfo iosAppInfo;
/// An iOS Robo test.
IosRoboTest iosRoboTest;
/// An iOS test loop.
IosTestLoop iosTestLoop;
/// An iOS XCTest.
IosXcTest iosXcTest;
/// Max time a test is allowed to run before it is automatically cancelled.
Duration testTimeout;
IosTest();
IosTest.fromJson(core.Map _json) {
if (_json.containsKey('iosAppInfo')) {
iosAppInfo = IosAppInfo.fromJson(
_json['iosAppInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('iosRoboTest')) {
iosRoboTest = IosRoboTest.fromJson(
_json['iosRoboTest'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('iosTestLoop')) {
iosTestLoop = IosTestLoop.fromJson(
_json['iosTestLoop'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('iosXcTest')) {
iosXcTest = IosXcTest.fromJson(
_json['iosXcTest'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('testTimeout')) {
testTimeout = Duration.fromJson(
_json['testTimeout'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (iosAppInfo != null) {
_json['iosAppInfo'] = iosAppInfo.toJson();
}
if (iosRoboTest != null) {
_json['iosRoboTest'] = iosRoboTest.toJson();
}
if (iosTestLoop != null) {
_json['iosTestLoop'] = iosTestLoop.toJson();
}
if (iosXcTest != null) {
_json['iosXcTest'] = iosXcTest.toJson();
}
if (testTimeout != null) {
_json['testTimeout'] = testTimeout.toJson();
}
return _json;
}
}
/// A game loop test of an iOS application.
class IosTestLoop {
/// Bundle ID of the app.
core.String bundleId;
IosTestLoop();
IosTestLoop.fromJson(core.Map _json) {
if (_json.containsKey('bundleId')) {
bundleId = _json['bundleId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (bundleId != null) {
_json['bundleId'] = bundleId;
}
return _json;
}
}
/// A test of an iOS application that uses the XCTest framework.
class IosXcTest {
/// Bundle ID of the app.
core.String bundleId;
/// Xcode version that the test was run with.
core.String xcodeVersion;
IosXcTest();
IosXcTest.fromJson(core.Map _json) {
if (_json.containsKey('bundleId')) {
bundleId = _json['bundleId'] as core.String;
}
if (_json.containsKey('xcodeVersion')) {
xcodeVersion = _json['xcodeVersion'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (bundleId != null) {
_json['bundleId'] = bundleId;
}
if (xcodeVersion != null) {
_json['xcodeVersion'] = xcodeVersion;
}
return _json;
}
}
/// Failed to find the launcher activity of an app.
class LauncherActivityNotFound {
LauncherActivityNotFound();
LauncherActivityNotFound.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Response message for EnvironmentService.ListEnvironments.
class ListEnvironmentsResponse {
/// Environments. Always set.
core.List<Environment> environments;
/// A Execution id Always set.
core.String executionId;
/// A History id. Always set.
core.String historyId;
/// A continuation token to resume the query at the next item. Will only be
/// set if there are more Environments to fetch.
core.String nextPageToken;
/// A Project id. Always set.
core.String projectId;
ListEnvironmentsResponse();
ListEnvironmentsResponse.fromJson(core.Map _json) {
if (_json.containsKey('environments')) {
environments = (_json['environments'] as core.List)
.map<Environment>((value) => Environment.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('executionId')) {
executionId = _json['executionId'] as core.String;
}
if (_json.containsKey('historyId')) {
historyId = _json['historyId'] as core.String;
}
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('projectId')) {
projectId = _json['projectId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (environments != null) {
_json['environments'] =
environments.map((value) => value.toJson()).toList();
}
if (executionId != null) {
_json['executionId'] = executionId;
}
if (historyId != null) {
_json['historyId'] = historyId;
}
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (projectId != null) {
_json['projectId'] = projectId;
}
return _json;
}
}
class ListExecutionsResponse {
/// Executions. Always set.
core.List<Execution> executions;
/// A continuation token to resume the query at the next item. Will only be
/// set if there are more Executions to fetch.
core.String nextPageToken;
ListExecutionsResponse();
ListExecutionsResponse.fromJson(core.Map _json) {
if (_json.containsKey('executions')) {
executions = (_json['executions'] as core.List)
.map<Execution>((value) =>
Execution.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (executions != null) {
_json['executions'] = executions.map((value) => value.toJson()).toList();
}
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
return _json;
}
}
/// Response message for HistoryService.List
class ListHistoriesResponse {
/// Histories.
core.List<History> histories;
/// 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.
core.String nextPageToken;
ListHistoriesResponse();
ListHistoriesResponse.fromJson(core.Map _json) {
if (_json.containsKey('histories')) {
histories = (_json['histories'] as core.List)
.map<History>((value) =>
History.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (histories != null) {
_json['histories'] = histories.map((value) => value.toJson()).toList();
}
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
return _json;
}
}
class ListPerfSampleSeriesResponse {
/// The resulting PerfSampleSeries sorted by id
core.List<PerfSampleSeries> perfSampleSeries;
ListPerfSampleSeriesResponse();
ListPerfSampleSeriesResponse.fromJson(core.Map _json) {
if (_json.containsKey('perfSampleSeries')) {
perfSampleSeries = (_json['perfSampleSeries'] as core.List)
.map<PerfSampleSeries>((value) => PerfSampleSeries.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (perfSampleSeries != null) {
_json['perfSampleSeries'] =
perfSampleSeries.map((value) => value.toJson()).toList();
}
return _json;
}
}
class 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
core.String nextPageToken;
core.List<PerfSample> perfSamples;
ListPerfSamplesResponse();
ListPerfSamplesResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('perfSamples')) {
perfSamples = (_json['perfSamples'] as core.List)
.map<PerfSample>((value) =>
PerfSample.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (perfSamples != null) {
_json['perfSamples'] =
perfSamples.map((value) => value.toJson()).toList();
}
return _json;
}
}
class ListScreenshotClustersResponse {
/// The set of clusters associated with an execution Always set
core.List<ScreenshotCluster> clusters;
ListScreenshotClustersResponse();
ListScreenshotClustersResponse.fromJson(core.Map _json) {
if (_json.containsKey('clusters')) {
clusters = (_json['clusters'] as core.List)
.map<ScreenshotCluster>((value) => ScreenshotCluster.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (clusters != null) {
_json['clusters'] = clusters.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Response message for AccessibilityService.ListStepAccessibilityClusters.
class 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.
core.List<SuggestionClusterProto> clusters;
/// A full resource name of the step. For example,
/// projects/my-project/histories/bh.1234567890abcdef/executions/
/// 1234567890123456789/steps/bs.1234567890abcdef Always presents.
core.String name;
ListStepAccessibilityClustersResponse();
ListStepAccessibilityClustersResponse.fromJson(core.Map _json) {
if (_json.containsKey('clusters')) {
clusters = (_json['clusters'] as core.List)
.map<SuggestionClusterProto>((value) =>
SuggestionClusterProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (clusters != null) {
_json['clusters'] = clusters.map((value) => value.toJson()).toList();
}
if (name != null) {
_json['name'] = name;
}
return _json;
}
}
/// A response containing the thumbnails in a step.
class 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.
core.String nextPageToken;
/// 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).
core.List<Image> thumbnails;
ListStepThumbnailsResponse();
ListStepThumbnailsResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('thumbnails')) {
thumbnails = (_json['thumbnails'] as core.List)
.map<Image>((value) =>
Image.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (thumbnails != null) {
_json['thumbnails'] = thumbnails.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Response message for StepService.List.
class 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.
core.String nextPageToken;
/// Steps.
core.List<Step> steps;
ListStepsResponse();
ListStepsResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('steps')) {
steps = (_json['steps'] as core.List)
.map<Step>((value) =>
Step.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (steps != null) {
_json['steps'] = steps.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Response message for StepService.ListTestCases.
class ListTestCasesResponse {
core.String nextPageToken;
/// List of test cases.
core.List<TestCase> testCases;
ListTestCasesResponse();
ListTestCasesResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('testCases')) {
testCases = (_json['testCases'] as core.List)
.map<TestCase>((value) =>
TestCase.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (testCases != null) {
_json['testCases'] = testCases.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// One dimension of the matrix of different runs of a step.
class MatrixDimensionDefinition {
MatrixDimensionDefinition();
MatrixDimensionDefinition.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
class MemoryInfo {
/// Maximum memory that can be allocated to the process in KiB
core.String memoryCapInKibibyte;
/// Total memory available on the device in KiB
core.String memoryTotalInKibibyte;
MemoryInfo();
MemoryInfo.fromJson(core.Map _json) {
if (_json.containsKey('memoryCapInKibibyte')) {
memoryCapInKibibyte = _json['memoryCapInKibibyte'] as core.String;
}
if (_json.containsKey('memoryTotalInKibibyte')) {
memoryTotalInKibibyte = _json['memoryTotalInKibibyte'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (memoryCapInKibibyte != null) {
_json['memoryCapInKibibyte'] = memoryCapInKibibyte;
}
if (memoryTotalInKibibyte != null) {
_json['memoryTotalInKibibyte'] = memoryTotalInKibibyte;
}
return _json;
}
}
/// 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.
class MergedResult {
/// Outcome of the resource
Outcome outcome;
/// State of the resource
/// Possible string values are:
/// - "unknownState" : Should never be in this state. Exists for proto
/// deserialization backward compatibility.
/// - "pending" : The Execution/Step is created, ready to run, but not running
/// yet. If an Execution/Step is created without initial state, it is assumed
/// that the Execution/Step is in PENDING state.
/// - "inProgress" : The Execution/Step is in progress.
/// - "complete" : The finalized, immutable state. Steps/Executions in this
/// state cannot be modified.
core.String state;
/// 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).
core.List<TestSuiteOverview> testSuiteOverviews;
MergedResult();
MergedResult.fromJson(core.Map _json) {
if (_json.containsKey('outcome')) {
outcome = Outcome.fromJson(
_json['outcome'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('testSuiteOverviews')) {
testSuiteOverviews = (_json['testSuiteOverviews'] as core.List)
.map<TestSuiteOverview>((value) => TestSuiteOverview.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (outcome != null) {
_json['outcome'] = outcome.toJson();
}
if (state != null) {
_json['state'] = state;
}
if (testSuiteOverviews != null) {
_json['testSuiteOverviews'] =
testSuiteOverviews.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Details when multiple steps are run with the same configuration as a group.
class MultiStep {
/// Unique int given to each step. Ranges from 0(inclusive) to total number of
/// steps(exclusive). The primary step is 0.
core.int multistepNumber;
/// Present if it is a primary (original) step.
PrimaryStep primaryStep;
/// Step Id of the primary (original) step, which might be this step.
core.String primaryStepId;
MultiStep();
MultiStep.fromJson(core.Map _json) {
if (_json.containsKey('multistepNumber')) {
multistepNumber = _json['multistepNumber'] as core.int;
}
if (_json.containsKey('primaryStep')) {
primaryStep = PrimaryStep.fromJson(
_json['primaryStep'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('primaryStepId')) {
primaryStepId = _json['primaryStepId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (multistepNumber != null) {
_json['multistepNumber'] = multistepNumber;
}
if (primaryStep != null) {
_json['primaryStep'] = primaryStep.toJson();
}
if (primaryStepId != null) {
_json['primaryStepId'] = primaryStepId;
}
return _json;
}
}
/// Additional details for a native crash.
class NativeCrash {
/// The stack trace of the native crash. Optional.
StackTrace stackTrace;
NativeCrash();
NativeCrash.fromJson(core.Map _json) {
if (_json.containsKey('stackTrace')) {
stackTrace = StackTrace.fromJson(
_json['stackTrace'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (stackTrace != null) {
_json['stackTrace'] = stackTrace.toJson();
}
return _json;
}
}
/// 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
class NonSdkApi {
/// The signature of the Non-SDK API
core.String apiSignature;
/// Example stack traces of this API being called.
core.List<core.String> exampleStackTraces;
/// Optional debugging insights for non-SDK API violations.
core.List<NonSdkApiInsight> insights;
/// The total number of times this API was observed to have been called.
core.int invocationCount;
/// Which list this API appears on
/// Possible string values are:
/// - "NONE"
/// - "WHITE"
/// - "BLACK"
/// - "GREY"
/// - "GREY_MAX_O"
/// - "GREY_MAX_P"
/// - "GREY_MAX_Q"
/// - "GREY_MAX_R"
core.String list;
NonSdkApi();
NonSdkApi.fromJson(core.Map _json) {
if (_json.containsKey('apiSignature')) {
apiSignature = _json['apiSignature'] as core.String;
}
if (_json.containsKey('exampleStackTraces')) {
exampleStackTraces = (_json['exampleStackTraces'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('insights')) {
insights = (_json['insights'] as core.List)
.map<NonSdkApiInsight>((value) => NonSdkApiInsight.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('invocationCount')) {
invocationCount = _json['invocationCount'] as core.int;
}
if (_json.containsKey('list')) {
list = _json['list'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (apiSignature != null) {
_json['apiSignature'] = apiSignature;
}
if (exampleStackTraces != null) {
_json['exampleStackTraces'] = exampleStackTraces;
}
if (insights != null) {
_json['insights'] = insights.map((value) => value.toJson()).toList();
}
if (invocationCount != null) {
_json['invocationCount'] = invocationCount;
}
if (list != null) {
_json['list'] = list;
}
return _json;
}
}
/// Non-SDK API insights (to address debugging solutions).
class NonSdkApiInsight {
/// Optional sample stack traces, for which this insight applies (there should
/// be at least one).
core.List<core.String> exampleTraceMessages;
/// A unique ID, to be used for determining the effectiveness of this
/// particular insight in the context of a matcher. (required)
core.String matcherId;
/// An insight indicating that the hidden API usage originates from a
/// Google-provided library.
PendingGoogleUpdateInsight pendingGoogleUpdateInsight;
/// An insight indicating that the hidden API usage originates from the use of
/// a library that needs to be upgraded.
UpgradeInsight upgradeInsight;
NonSdkApiInsight();
NonSdkApiInsight.fromJson(core.Map _json) {
if (_json.containsKey('exampleTraceMessages')) {
exampleTraceMessages = (_json['exampleTraceMessages'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('matcherId')) {
matcherId = _json['matcherId'] as core.String;
}
if (_json.containsKey('pendingGoogleUpdateInsight')) {
pendingGoogleUpdateInsight = PendingGoogleUpdateInsight.fromJson(
_json['pendingGoogleUpdateInsight']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('upgradeInsight')) {
upgradeInsight = UpgradeInsight.fromJson(
_json['upgradeInsight'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (exampleTraceMessages != null) {
_json['exampleTraceMessages'] = exampleTraceMessages;
}
if (matcherId != null) {
_json['matcherId'] = matcherId;
}
if (pendingGoogleUpdateInsight != null) {
_json['pendingGoogleUpdateInsight'] = pendingGoogleUpdateInsight.toJson();
}
if (upgradeInsight != null) {
_json['upgradeInsight'] = upgradeInsight.toJson();
}
return _json;
}
}
/// Additional details for a non-sdk API usage violation.
class NonSdkApiUsageViolation {
/// Signatures of a subset of those hidden API's.
core.List<core.String> apiSignatures;
/// Total number of unique hidden API's accessed.
core.int uniqueApis;
NonSdkApiUsageViolation();
NonSdkApiUsageViolation.fromJson(core.Map _json) {
if (_json.containsKey('apiSignatures')) {
apiSignatures = (_json['apiSignatures'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('uniqueApis')) {
uniqueApis = _json['uniqueApis'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (apiSignatures != null) {
_json['apiSignatures'] = apiSignatures;
}
if (uniqueApis != null) {
_json['uniqueApis'] = uniqueApis;
}
return _json;
}
}
/// Contains a summary and examples of non-sdk API usage violations.
class NonSdkApiUsageViolationReport {
/// Examples of the detected API usages.
core.List<NonSdkApi> exampleApis;
/// Minimum API level required for the application to run.
core.int minSdkVersion;
/// Specifies the API Level on which the application is designed to run.
core.int targetSdkVersion;
/// Total number of unique Non-SDK API's accessed.
core.int uniqueApis;
NonSdkApiUsageViolationReport();
NonSdkApiUsageViolationReport.fromJson(core.Map _json) {
if (_json.containsKey('exampleApis')) {
exampleApis = (_json['exampleApis'] as core.List)
.map<NonSdkApi>((value) =>
NonSdkApi.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('minSdkVersion')) {
minSdkVersion = _json['minSdkVersion'] as core.int;
}
if (_json.containsKey('targetSdkVersion')) {
targetSdkVersion = _json['targetSdkVersion'] as core.int;
}
if (_json.containsKey('uniqueApis')) {
uniqueApis = _json['uniqueApis'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (exampleApis != null) {
_json['exampleApis'] =
exampleApis.map((value) => value.toJson()).toList();
}
if (minSdkVersion != null) {
_json['minSdkVersion'] = minSdkVersion;
}
if (targetSdkVersion != null) {
_json['targetSdkVersion'] = targetSdkVersion;
}
if (uniqueApis != null) {
_json['uniqueApis'] = uniqueApis;
}
return _json;
}
}
/// Interprets a result so that humans and machines can act on it.
class Outcome {
/// More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this
/// field is set but the summary is not FAILURE. Optional
FailureDetail failureDetail;
/// More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT
/// if this field is set but the summary is not INCONCLUSIVE. Optional
InconclusiveDetail inconclusiveDetail;
/// More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this
/// field is set but the summary is not SKIPPED. Optional
SkippedDetail skippedDetail;
/// More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this
/// field is set but the summary is not SUCCESS. Optional
SuccessDetail successDetail;
/// The simplest way to interpret a result. Required
/// Possible string values are:
/// - "unset" : Do not use. For proto versioning only.
/// - "success" : The test matrix run was successful, for instance: - All the
/// test cases passed. - Robo did not detect a crash of the application under
/// test.
/// - "failure" : A run failed, for instance: - One or more test case failed.
/// - A test timed out. - The application under test crashed.
/// - "inconclusive" : Something unexpected happened. The run should still be
/// considered unsuccessful but this is likely a transient problem and
/// re-running the test might be successful.
/// - "skipped" : All tests were skipped, for instance: - All device
/// configurations were incompatible.
/// - "flaky" : A group of steps that were run with the same configuration had
/// both failure and success outcomes.
core.String summary;
Outcome();
Outcome.fromJson(core.Map _json) {
if (_json.containsKey('failureDetail')) {
failureDetail = FailureDetail.fromJson(
_json['failureDetail'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('inconclusiveDetail')) {
inconclusiveDetail = InconclusiveDetail.fromJson(
_json['inconclusiveDetail'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('skippedDetail')) {
skippedDetail = SkippedDetail.fromJson(
_json['skippedDetail'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('successDetail')) {
successDetail = SuccessDetail.fromJson(
_json['successDetail'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('summary')) {
summary = _json['summary'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (failureDetail != null) {
_json['failureDetail'] = failureDetail.toJson();
}
if (inconclusiveDetail != null) {
_json['inconclusiveDetail'] = inconclusiveDetail.toJson();
}
if (skippedDetail != null) {
_json['skippedDetail'] = skippedDetail.toJson();
}
if (successDetail != null) {
_json['successDetail'] = successDetail.toJson();
}
if (summary != null) {
_json['summary'] = summary;
}
return _json;
}
}
/// A warning that Robo encountered a screen that has overlapping clickable
/// elements; this may indicate a potential UI issue.
class OverlappingUIElements {
/// Resource names of the overlapping screen elements
core.List<core.String> resourceName;
/// The screen id of the elements
core.String screenId;
OverlappingUIElements();
OverlappingUIElements.fromJson(core.Map _json) {
if (_json.containsKey('resourceName')) {
resourceName = (_json['resourceName'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('screenId')) {
screenId = _json['screenId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (resourceName != null) {
_json['resourceName'] = resourceName;
}
if (screenId != null) {
_json['screenId'] = screenId;
}
return _json;
}
}
/// This insight indicates that the hidden API usage originates from a
/// Google-provided library. Users need not take any action.
class PendingGoogleUpdateInsight {
/// The name of the Google-provided library with the non-SDK API dependency.
core.String nameOfGoogleLibrary;
PendingGoogleUpdateInsight();
PendingGoogleUpdateInsight.fromJson(core.Map _json) {
if (_json.containsKey('nameOfGoogleLibrary')) {
nameOfGoogleLibrary = _json['nameOfGoogleLibrary'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nameOfGoogleLibrary != null) {
_json['nameOfGoogleLibrary'] = nameOfGoogleLibrary;
}
return _json;
}
}
/// Encapsulates performance environment info
class PerfEnvironment {
/// CPU related environment info
CPUInfo cpuInfo;
/// Memory related environment info
MemoryInfo memoryInfo;
PerfEnvironment();
PerfEnvironment.fromJson(core.Map _json) {
if (_json.containsKey('cpuInfo')) {
cpuInfo = CPUInfo.fromJson(
_json['cpuInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('memoryInfo')) {
memoryInfo = MemoryInfo.fromJson(
_json['memoryInfo'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (cpuInfo != null) {
_json['cpuInfo'] = cpuInfo.toJson();
}
if (memoryInfo != null) {
_json['memoryInfo'] = memoryInfo.toJson();
}
return _json;
}
}
/// A summary of perf metrics collected and performance environment info
class PerfMetricsSummary {
AppStartTime appStartTime;
/// A tool results execution ID. @OutputOnly
core.String executionId;
/// Graphics statistics for the entire run. Statistics are reset at the
/// beginning of the run and collected at the end of the run.
GraphicsStats graphicsStats;
/// A tool results history ID. @OutputOnly
core.String historyId;
/// Describes the environment in which the performance metrics were collected
PerfEnvironment perfEnvironment;
/// Set of resource collected
core.List<core.String> perfMetrics;
/// The cloud project @OutputOnly
core.String projectId;
/// A tool results step ID. @OutputOnly
core.String stepId;
PerfMetricsSummary();
PerfMetricsSummary.fromJson(core.Map _json) {
if (_json.containsKey('appStartTime')) {
appStartTime = AppStartTime.fromJson(
_json['appStartTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('executionId')) {
executionId = _json['executionId'] as core.String;
}
if (_json.containsKey('graphicsStats')) {
graphicsStats = GraphicsStats.fromJson(
_json['graphicsStats'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('historyId')) {
historyId = _json['historyId'] as core.String;
}
if (_json.containsKey('perfEnvironment')) {
perfEnvironment = PerfEnvironment.fromJson(
_json['perfEnvironment'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('perfMetrics')) {
perfMetrics = (_json['perfMetrics'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('projectId')) {
projectId = _json['projectId'] as core.String;
}
if (_json.containsKey('stepId')) {
stepId = _json['stepId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (appStartTime != null) {
_json['appStartTime'] = appStartTime.toJson();
}
if (executionId != null) {
_json['executionId'] = executionId;
}
if (graphicsStats != null) {
_json['graphicsStats'] = graphicsStats.toJson();
}
if (historyId != null) {
_json['historyId'] = historyId;
}
if (perfEnvironment != null) {
_json['perfEnvironment'] = perfEnvironment.toJson();
}
if (perfMetrics != null) {
_json['perfMetrics'] = perfMetrics;
}
if (projectId != null) {
_json['projectId'] = projectId;
}
if (stepId != null) {
_json['stepId'] = stepId;
}
return _json;
}
}
/// Resource representing a single performance measure or data point
class PerfSample {
/// Timestamp of collection.
Timestamp sampleTime;
/// Value observed
core.double value;
PerfSample();
PerfSample.fromJson(core.Map _json) {
if (_json.containsKey('sampleTime')) {
sampleTime = Timestamp.fromJson(
_json['sampleTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('value')) {
value = (_json['value'] as core.num).toDouble();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (sampleTime != null) {
_json['sampleTime'] = sampleTime.toJson();
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// Resource representing a collection of performance samples (or data points)
class PerfSampleSeries {
/// Basic series represented by a line chart
BasicPerfSampleSeries basicPerfSampleSeries;
/// A tool results execution ID. @OutputOnly
core.String executionId;
/// A tool results history ID. @OutputOnly
core.String historyId;
/// The cloud project @OutputOnly
core.String projectId;
/// A sample series id @OutputOnly
core.String sampleSeriesId;
/// A tool results step ID. @OutputOnly
core.String stepId;
PerfSampleSeries();
PerfSampleSeries.fromJson(core.Map _json) {
if (_json.containsKey('basicPerfSampleSeries')) {
basicPerfSampleSeries = BasicPerfSampleSeries.fromJson(
_json['basicPerfSampleSeries']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('executionId')) {
executionId = _json['executionId'] as core.String;
}
if (_json.containsKey('historyId')) {
historyId = _json['historyId'] as core.String;
}
if (_json.containsKey('projectId')) {
projectId = _json['projectId'] as core.String;
}
if (_json.containsKey('sampleSeriesId')) {
sampleSeriesId = _json['sampleSeriesId'] as core.String;
}
if (_json.containsKey('stepId')) {
stepId = _json['stepId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (basicPerfSampleSeries != null) {
_json['basicPerfSampleSeries'] = basicPerfSampleSeries.toJson();
}
if (executionId != null) {
_json['executionId'] = executionId;
}
if (historyId != null) {
_json['historyId'] = historyId;
}
if (projectId != null) {
_json['projectId'] = projectId;
}
if (sampleSeriesId != null) {
_json['sampleSeriesId'] = sampleSeriesId;
}
if (stepId != null) {
_json['stepId'] = stepId;
}
return _json;
}
}
/// A notification that Robo signed in with Google.
class PerformedGoogleLogin {
PerformedGoogleLogin();
PerformedGoogleLogin.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// A notification that Robo performed some monkey actions.
class PerformedMonkeyActions {
/// The total number of monkey actions performed during the crawl.
core.int totalActions;
PerformedMonkeyActions();
PerformedMonkeyActions.fromJson(core.Map _json) {
if (_json.containsKey('totalActions')) {
totalActions = _json['totalActions'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (totalActions != null) {
_json['totalActions'] = totalActions;
}
return _json;
}
}
/// Stores rollup test status of multiple steps that were run as a group and
/// outcome of each individual step.
class PrimaryStep {
/// Step Id and outcome of each individual step.
core.List<IndividualOutcome> individualOutcome;
/// Rollup test status of multiple steps that were run with the same
/// configuration as a group.
/// Possible string values are:
/// - "unset" : Do not use. For proto versioning only.
/// - "success" : The test matrix run was successful, for instance: - All the
/// test cases passed. - Robo did not detect a crash of the application under
/// test.
/// - "failure" : A run failed, for instance: - One or more test case failed.
/// - A test timed out. - The application under test crashed.
/// - "inconclusive" : Something unexpected happened. The run should still be
/// considered unsuccessful but this is likely a transient problem and
/// re-running the test might be successful.
/// - "skipped" : All tests were skipped, for instance: - All device
/// configurations were incompatible.
/// - "flaky" : A group of steps that were run with the same configuration had
/// both failure and success outcomes.
core.String rollUp;
PrimaryStep();
PrimaryStep.fromJson(core.Map _json) {
if (_json.containsKey('individualOutcome')) {
individualOutcome = (_json['individualOutcome'] as core.List)
.map<IndividualOutcome>((value) => IndividualOutcome.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('rollUp')) {
rollUp = _json['rollUp'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (individualOutcome != null) {
_json['individualOutcome'] =
individualOutcome.map((value) => value.toJson()).toList();
}
if (rollUp != null) {
_json['rollUp'] = rollUp;
}
return _json;
}
}
/// Per-project settings for the Tool Results service.
class 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
core.String defaultBucket;
/// The name of the project's settings. Always of the form:
/// projects/{project-id}/settings In update request: never set In response:
/// always set
core.String name;
ProjectSettings();
ProjectSettings.fromJson(core.Map _json) {
if (_json.containsKey('defaultBucket')) {
defaultBucket = _json['defaultBucket'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (defaultBucket != null) {
_json['defaultBucket'] = defaultBucket;
}
if (name != null) {
_json['name'] = name;
}
return _json;
}
}
/// Request message for StepService.PublishXunitXmlFiles.
class PublishXunitXmlFilesRequest {
/// URI of the Xunit XML files to publish. The maximum size of the file this
/// reference is pointing to is 50MB. Required.
core.List<FileReference> xunitXmlFiles;
PublishXunitXmlFilesRequest();
PublishXunitXmlFilesRequest.fromJson(core.Map _json) {
if (_json.containsKey('xunitXmlFiles')) {
xunitXmlFiles = (_json['xunitXmlFiles'] as core.List)
.map<FileReference>((value) => FileReference.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (xunitXmlFiles != null) {
_json['xunitXmlFiles'] =
xunitXmlFiles.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// A rectangular region.
class RegionProto {
/// The height, in pixels. Always set.
core.int heightPx;
/// The left side of the rectangle, in pixels. Always set.
core.int leftPx;
/// The top of the rectangle, in pixels. Always set.
core.int topPx;
/// The width, in pixels. Always set.
core.int widthPx;
RegionProto();
RegionProto.fromJson(core.Map _json) {
if (_json.containsKey('heightPx')) {
heightPx = _json['heightPx'] as core.int;
}
if (_json.containsKey('leftPx')) {
leftPx = _json['leftPx'] as core.int;
}
if (_json.containsKey('topPx')) {
topPx = _json['topPx'] as core.int;
}
if (_json.containsKey('widthPx')) {
widthPx = _json['widthPx'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (heightPx != null) {
_json['heightPx'] = heightPx;
}
if (leftPx != null) {
_json['leftPx'] = leftPx;
}
if (topPx != null) {
_json['topPx'] = topPx;
}
if (widthPx != null) {
_json['widthPx'] = widthPx;
}
return _json;
}
}
/// The storage for test results.
class ResultsStorage {
/// The root directory for test results.
FileReference resultsStoragePath;
/// The path to the Xunit XML file.
FileReference xunitXmlFile;
ResultsStorage();
ResultsStorage.fromJson(core.Map _json) {
if (_json.containsKey('resultsStoragePath')) {
resultsStoragePath = FileReference.fromJson(
_json['resultsStoragePath'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('xunitXmlFile')) {
xunitXmlFile = FileReference.fromJson(
_json['xunitXmlFile'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (resultsStoragePath != null) {
_json['resultsStoragePath'] = resultsStoragePath.toJson();
}
if (xunitXmlFile != null) {
_json['xunitXmlFile'] = xunitXmlFile.toJson();
}
return _json;
}
}
/// Execution stats for a user-provided Robo script.
class RoboScriptExecution {
/// The number of Robo script actions executed successfully.
core.int successfulActions;
/// The total number of actions in the Robo script.
core.int totalActions;
RoboScriptExecution();
RoboScriptExecution.fromJson(core.Map _json) {
if (_json.containsKey('successfulActions')) {
successfulActions = _json['successfulActions'] as core.int;
}
if (_json.containsKey('totalActions')) {
totalActions = _json['totalActions'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (successfulActions != null) {
_json['successfulActions'] = successfulActions;
}
if (totalActions != null) {
_json['totalActions'] = totalActions;
}
return _json;
}
}
/// 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.
class 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.
core.String privateDoNotAccessOrElseSafeHtmlWrappedValue;
SafeHtmlProto();
SafeHtmlProto.fromJson(core.Map _json) {
if (_json.containsKey('privateDoNotAccessOrElseSafeHtmlWrappedValue')) {
privateDoNotAccessOrElseSafeHtmlWrappedValue =
_json['privateDoNotAccessOrElseSafeHtmlWrappedValue'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (privateDoNotAccessOrElseSafeHtmlWrappedValue != null) {
_json['privateDoNotAccessOrElseSafeHtmlWrappedValue'] =
privateDoNotAccessOrElseSafeHtmlWrappedValue;
}
return _json;
}
}
class Screen {
/// File reference of the png file. Required.
core.String fileReference;
/// Locale of the device that the screenshot was taken on. Required.
core.String locale;
/// Model of the device that the screenshot was taken on. Required.
core.String model;
/// OS version of the device that the screenshot was taken on. Required.
core.String version;
Screen();
Screen.fromJson(core.Map _json) {
if (_json.containsKey('fileReference')) {
fileReference = _json['fileReference'] as core.String;
}
if (_json.containsKey('locale')) {
locale = _json['locale'] as core.String;
}
if (_json.containsKey('model')) {
model = _json['model'] as core.String;
}
if (_json.containsKey('version')) {
version = _json['version'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (fileReference != null) {
_json['fileReference'] = fileReference;
}
if (locale != null) {
_json['locale'] = locale;
}
if (model != null) {
_json['model'] = model;
}
if (version != null) {
_json['version'] = version;
}
return _json;
}
}
class ScreenshotCluster {
/// A string that describes the activity of every screen in the cluster.
core.String activity;
/// A unique identifier for the cluster. @OutputOnly
core.String clusterId;
/// 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
Screen keyScreen;
/// Full list of screens.
core.List<Screen> screens;
ScreenshotCluster();
ScreenshotCluster.fromJson(core.Map _json) {
if (_json.containsKey('activity')) {
activity = _json['activity'] as core.String;
}
if (_json.containsKey('clusterId')) {
clusterId = _json['clusterId'] as core.String;
}
if (_json.containsKey('keyScreen')) {
keyScreen = Screen.fromJson(
_json['keyScreen'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('screens')) {
screens = (_json['screens'] as core.List)
.map<Screen>((value) =>
Screen.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (activity != null) {
_json['activity'] = activity;
}
if (clusterId != null) {
_json['clusterId'] = clusterId;
}
if (keyScreen != null) {
_json['keyScreen'] = keyScreen.toJson();
}
if (screens != null) {
_json['screens'] = screens.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Result summary for a shard in an environment.
class 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.
core.List<StepSummary> runs;
/// Merged result of the shard.
MergedResult shardResult;
ShardSummary();
ShardSummary.fromJson(core.Map _json) {
if (_json.containsKey('runs')) {
runs = (_json['runs'] as core.List)
.map<StepSummary>((value) => StepSummary.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('shardResult')) {
shardResult = MergedResult.fromJson(
_json['shardResult'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (runs != null) {
_json['runs'] = runs.map((value) => value.toJson()).toList();
}
if (shardResult != null) {
_json['shardResult'] = shardResult.toJson();
}
return _json;
}
}
/// Details for an outcome with a SKIPPED outcome summary.
class SkippedDetail {
/// If the App doesn't support the specific API level.
core.bool incompatibleAppVersion;
/// If the App doesn't run on the specific architecture, for example, x86.
core.bool incompatibleArchitecture;
/// If the requested OS version doesn't run on the specific device model.
core.bool incompatibleDevice;
SkippedDetail();
SkippedDetail.fromJson(core.Map _json) {
if (_json.containsKey('incompatibleAppVersion')) {
incompatibleAppVersion = _json['incompatibleAppVersion'] as core.bool;
}
if (_json.containsKey('incompatibleArchitecture')) {
incompatibleArchitecture = _json['incompatibleArchitecture'] as core.bool;
}
if (_json.containsKey('incompatibleDevice')) {
incompatibleDevice = _json['incompatibleDevice'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (incompatibleAppVersion != null) {
_json['incompatibleAppVersion'] = incompatibleAppVersion;
}
if (incompatibleArchitecture != null) {
_json['incompatibleArchitecture'] = incompatibleArchitecture;
}
if (incompatibleDevice != null) {
_json['incompatibleDevice'] = incompatibleDevice;
}
return _json;
}
}
/// The details about how to run the execution.
class Specification {
/// An Android mobile test execution specification.
AndroidTest androidTest;
/// An iOS mobile test execution specification.
IosTest iosTest;
Specification();
Specification.fromJson(core.Map _json) {
if (_json.containsKey('androidTest')) {
androidTest = AndroidTest.fromJson(
_json['androidTest'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('iosTest')) {
iosTest = IosTest.fromJson(
_json['iosTest'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (androidTest != null) {
_json['androidTest'] = androidTest.toJson();
}
if (iosTest != null) {
_json['iosTest'] = iosTest.toJson();
}
return _json;
}
}
/// A stacktrace.
class StackTrace {
/// The stack trace message. Required
core.String exception;
StackTrace();
StackTrace.fromJson(core.Map _json) {
if (_json.containsKey('exception')) {
exception = _json['exception'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (exception != null) {
_json['exception'] = exception;
}
return _json;
}
}
/// User provided intent failed to resolve to an activity.
class StartActivityNotFound {
core.String action;
core.String uri;
StartActivityNotFound();
StartActivityNotFound.fromJson(core.Map _json) {
if (_json.containsKey('action')) {
action = _json['action'] as core.String;
}
if (_json.containsKey('uri')) {
uri = _json['uri'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (action != null) {
_json['action'] = action;
}
if (uri != null) {
_json['uri'] = uri;
}
return _json;
}
}
/// The `Status` type defines a logical error model that is suitable for
/// different programming environments, including REST APIs and RPC APIs. It is
/// used by [gRPC](https://github.com/grpc). Each `Status` message contains
/// three pieces of data: error code, error message, and error details. You can
/// find out more about this error model and how to work with it in the [API
/// Design Guide](https://cloud.google.com/apis/design/errors).
class Status {
/// The status code, which should be an enum value of google.rpc.Code.
core.int code;
/// A list of messages that carry the error details. There is a common set of
/// message types for APIs to use.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.List<core.Map<core.String, core.Object>> details;
/// A developer-facing error message, which should be in English. Any
/// user-facing error message should be localized and sent in the
/// google.rpc.Status.details field, or localized by the client.
core.String message;
Status();
Status.fromJson(core.Map _json) {
if (_json.containsKey('code')) {
code = _json['code'] as core.int;
}
if (_json.containsKey('details')) {
details = (_json['details'] as core.List)
.map<core.Map<core.String, core.Object>>((value) =>
commons.mapMap<core.Object, core.Object>(
(value as core.Map<core.String, core.dynamic>)
.cast<core.String, core.Object>(),
(core.Object item) => item as core.Object))
.toList();
}
if (_json.containsKey('message')) {
message = _json['message'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (code != null) {
_json['code'] = code;
}
if (details != null) {
_json['details'] = details;
}
if (message != null) {
_json['message'] = message;
}
return _json;
}
}
/// A Step represents a single operation performed as part of Execution. A step
/// can be used to represent the execution of a tool ( for example a test runner
/// execution or an execution of a compiler). Steps can overlap (for instance
/// two steps might have the same start time if some operations are done in
/// parallel). Here is an example, let's consider that we have a continuous
/// build is executing a test runner for each iteration. The workflow would look
/// like: - user creates a Execution with id 1 - user creates an
/// TestExecutionStep with id 100 for Execution 1 - user update
/// TestExecutionStep with id 100 to add a raw xml log + the service parses the
/// xml logs and returns a TestExecutionStep with updated TestResult(s). - user
/// update the status of TestExecutionStep with id 100 to COMPLETE A Step can be
/// updated until its state is set to COMPLETE at which points it becomes
/// immutable. Next tag: 27
class Step {
/// The time when the step status was set 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
Timestamp completionTime;
/// The time when the step was created. - In response: always set - In
/// create/update request: never set
Timestamp creationTime;
/// A description of this tool For example: mvn clean package -D
/// skipTests=true - In response: present if set by create/update request - In
/// create/update request: optional
core.String description;
/// How much the device resource is used to perform the test. This is the
/// device usage used for billing purpose, which is different from the
/// run_duration, for example, infrastructure failure won't be charged for
/// device usage. PRECONDITION_FAILED will be returned if one attempts to set
/// a device_usage on a step which already has this field set. - In response:
/// present if previously set. - In create request: optional - In update
/// request: optional
Duration deviceUsageDuration;
/// If the execution containing this step has any dimension_definition set,
/// then this field allows the child to specify the values of the dimensions.
/// The keys must exactly match the dimension_definition of the execution. For
/// example, if the execution has `dimension_definition = ['attempt',
/// 'device']` then a step must define values for those dimensions, eg.
/// `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does
/// not participate in one dimension of the matrix, the value for that
/// dimension should be empty string. For example, if one of the tests is
/// executed by a runner which does not support retries, the step could have
/// `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does
/// not participate in any dimensions of the matrix, it may leave
/// dimension_value unset. A PRECONDITION_FAILED will be returned if any of
/// the keys do not exist in the dimension_definition of the execution. A
/// PRECONDITION_FAILED will be returned if another step in this execution
/// already has the same name and dimension_value, but differs on other data
/// fields, for example, step field is different. A PRECONDITION_FAILED will
/// be returned if dimension_value is set, and there is a dimension_definition
/// in the execution which is not specified as one of the keys. - In response:
/// present if set by create - In create request: optional - In update
/// request: never set
core.List<StepDimensionValueEntry> dimensionValue;
/// Whether any of the outputs of this step are images whose thumbnails can be
/// fetched with ListThumbnails. - In response: always set - In create/update
/// request: never set
core.bool hasImages;
/// Arbitrary user-supplied key/value pairs that are associated with the step.
/// Users are responsible for managing the key namespace such that keys don't
/// accidentally collide. An INVALID_ARGUMENT will be returned if the number
/// of labels exceeds 100 or if the length of any of the keys or values
/// exceeds 100 characters. - In response: always set - In create request:
/// optional - In update request: optional; any new key/value pair will be
/// added to the map, and any new value for an existing key will update that
/// key's value
core.List<StepLabelsEntry> labels;
/// Details when multiple steps are run with the same configuration as a
/// group. These details can be used identify which group this step is part
/// of. It also identifies the groups 'primary step' which indexes all the
/// group members. - In response: present if previously set. - In create
/// request: optional, set iff this step was performed more than once. - In
/// update request: optional
MultiStep multiStep;
/// A short human-readable name to display in the UI. Maximum of 100
/// characters. For example: Clean build A PRECONDITION_FAILED will be
/// returned upon creating a new step if it shares its name and
/// dimension_value with an existing step. If two steps represent a similar
/// action, but have different dimension values, they should share the same
/// name. For instance, if the same set of tests is run on two different
/// platforms, the two steps should have the same name. - In response: always
/// set - In create request: always set - In update request: never set
core.String name;
/// Classification of the result, for example into SUCCESS or FAILURE - In
/// response: present if set by create/update request - In create/update
/// request: optional
Outcome outcome;
/// How long it took for this step to run. If unset, this is set to the
/// difference between creation_time and completion_time when the step is set
/// to the COMPLETE state. In some cases, it is appropriate to set this value
/// separately: For instance, if a step is created, but the operation it
/// represents is queued for a few minutes before it executes, it would be
/// appropriate not to include the time spent queued in its run_duration.
/// PRECONDITION_FAILED will be returned if one attempts to set a run_duration
/// on a step which already has this field set. - In response: present if
/// previously set; always present on COMPLETE step - In create request:
/// optional - In update request: optional
Duration runDuration;
/// The initial state is IN_PROGRESS. The only legal state transitions are *
/// IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an
/// invalid transition is requested. It is valid to create Step with a state
/// set to COMPLETE. The state can only be set to COMPLETE once. A
/// PRECONDITION_FAILED will be returned if the state is set to COMPLETE
/// multiple times. - In response: always set - In create/update request:
/// optional
/// Possible string values are:
/// - "unknownState" : Should never be in this state. Exists for proto
/// deserialization backward compatibility.
/// - "pending" : The Execution/Step is created, ready to run, but not running
/// yet. If an Execution/Step is created without initial state, it is assumed
/// that the Execution/Step is in PENDING state.
/// - "inProgress" : The Execution/Step is in progress.
/// - "complete" : The finalized, immutable state. Steps/Executions in this
/// state cannot be modified.
core.String state;
/// A unique identifier within a Execution for this Step. Returns
/// INVALID_ARGUMENT if this field is set or overwritten by the caller. - In
/// response: always set - In create/update request: never set
core.String stepId;
/// An execution of a test runner.
TestExecutionStep testExecutionStep;
/// An execution of a tool (used for steps we don't explicitly support).
ToolExecutionStep toolExecutionStep;
Step();
Step.fromJson(core.Map _json) {
if (_json.containsKey('completionTime')) {
completionTime = Timestamp.fromJson(
_json['completionTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('creationTime')) {
creationTime = Timestamp.fromJson(
_json['creationTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('deviceUsageDuration')) {
deviceUsageDuration = Duration.fromJson(
_json['deviceUsageDuration'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('dimensionValue')) {
dimensionValue = (_json['dimensionValue'] as core.List)
.map<StepDimensionValueEntry>((value) =>
StepDimensionValueEntry.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('hasImages')) {
hasImages = _json['hasImages'] as core.bool;
}
if (_json.containsKey('labels')) {
labels = (_json['labels'] as core.List)
.map<StepLabelsEntry>((value) => StepLabelsEntry.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('multiStep')) {
multiStep = MultiStep.fromJson(
_json['multiStep'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('outcome')) {
outcome = Outcome.fromJson(
_json['outcome'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('runDuration')) {
runDuration = Duration.fromJson(
_json['runDuration'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('stepId')) {
stepId = _json['stepId'] as core.String;
}
if (_json.containsKey('testExecutionStep')) {
testExecutionStep = TestExecutionStep.fromJson(
_json['testExecutionStep'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('toolExecutionStep')) {
toolExecutionStep = ToolExecutionStep.fromJson(
_json['toolExecutionStep'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (completionTime != null) {
_json['completionTime'] = completionTime.toJson();
}
if (creationTime != null) {
_json['creationTime'] = creationTime.toJson();
}
if (description != null) {
_json['description'] = description;
}
if (deviceUsageDuration != null) {
_json['deviceUsageDuration'] = deviceUsageDuration.toJson();
}
if (dimensionValue != null) {
_json['dimensionValue'] =
dimensionValue.map((value) => value.toJson()).toList();
}
if (hasImages != null) {
_json['hasImages'] = hasImages;
}
if (labels != null) {
_json['labels'] = labels.map((value) => value.toJson()).toList();
}
if (multiStep != null) {
_json['multiStep'] = multiStep.toJson();
}
if (name != null) {
_json['name'] = name;
}
if (outcome != null) {
_json['outcome'] = outcome.toJson();
}
if (runDuration != null) {
_json['runDuration'] = runDuration.toJson();
}
if (state != null) {
_json['state'] = state;
}
if (stepId != null) {
_json['stepId'] = stepId;
}
if (testExecutionStep != null) {
_json['testExecutionStep'] = testExecutionStep.toJson();
}
if (toolExecutionStep != null) {
_json['toolExecutionStep'] = toolExecutionStep.toJson();
}
return _json;
}
}
class StepDimensionValueEntry {
core.String key;
core.String value;
StepDimensionValueEntry();
StepDimensionValueEntry.fromJson(core.Map _json) {
if (_json.containsKey('key')) {
key = _json['key'] as core.String;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (key != null) {
_json['key'] = key;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
class StepLabelsEntry {
core.String key;
core.String value;
StepLabelsEntry();
StepLabelsEntry.fromJson(core.Map _json) {
if (_json.containsKey('key')) {
key = _json['key'] as core.String;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (key != null) {
_json['key'] = key;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// Lightweight summary of a step within this execution.
class StepSummary {
StepSummary();
StepSummary.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Details for an outcome with a SUCCESS outcome summary. LINT.IfChange
class SuccessDetail {
/// If a native process other than the app crashed.
core.bool otherNativeCrash;
SuccessDetail();
SuccessDetail.fromJson(core.Map _json) {
if (_json.containsKey('otherNativeCrash')) {
otherNativeCrash = _json['otherNativeCrash'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (otherNativeCrash != null) {
_json['otherNativeCrash'] = otherNativeCrash;
}
return _json;
}
}
/// A set of similar suggestions that we suspect are closely related. This proto
/// and most of the nested protos are branched from
/// foxandcrown.prelaunchreport.service.SuggestionClusterProto, replacing PLR's
/// dependencies with FTL's.
class SuggestionClusterProto {
/// Category in which these types of suggestions should appear. Always set.
/// Possible string values are:
/// - "unknownCategory"
/// - "contentLabeling"
/// - "touchTargetSize"
/// - "lowContrast"
/// - "implementation"
core.String category;
/// A sequence of suggestions. All of the suggestions within a cluster must
/// have the same SuggestionPriority and belong to the same
/// SuggestionCategory. Suggestions with the same screenshot URL should be
/// adjacent.
core.List<SuggestionProto> suggestions;
SuggestionClusterProto();
SuggestionClusterProto.fromJson(core.Map _json) {
if (_json.containsKey('category')) {
category = _json['category'] as core.String;
}
if (_json.containsKey('suggestions')) {
suggestions = (_json['suggestions'] as core.List)
.map<SuggestionProto>((value) => SuggestionProto.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (category != null) {
_json['category'] = category;
}
if (suggestions != null) {
_json['suggestions'] =
suggestions.map((value) => value.toJson()).toList();
}
return _json;
}
}
class SuggestionProto {
/// Reference to a help center article concerning this type of suggestion.
/// Always set.
core.String helpUrl;
/// Message, in the user's language, explaining the suggestion, which may
/// contain markup. Always set.
SafeHtmlProto longMessage;
/// Relative importance of a suggestion. Always set.
/// Possible string values are:
/// - "unknownPriority"
/// - "error"
/// - "warning"
/// - "info"
core.String priority;
/// A somewhat human readable identifier of the source view, if it does not
/// have a resource_name. This is a path within the accessibility hierarchy,
/// an element with resource name; similar to an XPath.
core.String pseudoResourceId;
/// Region within the screenshot that is relevant to this suggestion.
/// Optional.
RegionProto region;
/// Reference to a view element, identified by its resource name, if it has
/// one.
core.String resourceName;
/// ID of the screen for the suggestion. It is used for getting the
/// corresponding screenshot path. For example, screen_id "1" corresponds to
/// "1.png" file in GCS. Always set.
core.String screenId;
/// Relative importance of a suggestion as compared with other suggestions
/// that have the same priority and category. This is a meaningless value that
/// can be used to order suggestions that are in the same category and have
/// the same priority. The larger values have higher priority (i.e., are more
/// important). Optional.
core.double secondaryPriority;
/// Concise message, in the user's language, representing the suggestion,
/// which may contain markup. Always set.
SafeHtmlProto shortMessage;
/// General title for the suggestion, in the user's language, without markup.
/// Always set.
core.String title;
SuggestionProto();
SuggestionProto.fromJson(core.Map _json) {
if (_json.containsKey('helpUrl')) {
helpUrl = _json['helpUrl'] as core.String;
}
if (_json.containsKey('longMessage')) {
longMessage = SafeHtmlProto.fromJson(
_json['longMessage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('priority')) {
priority = _json['priority'] as core.String;
}
if (_json.containsKey('pseudoResourceId')) {
pseudoResourceId = _json['pseudoResourceId'] as core.String;
}
if (_json.containsKey('region')) {
region = RegionProto.fromJson(
_json['region'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('resourceName')) {
resourceName = _json['resourceName'] as core.String;
}
if (_json.containsKey('screenId')) {
screenId = _json['screenId'] as core.String;
}
if (_json.containsKey('secondaryPriority')) {
secondaryPriority = (_json['secondaryPriority'] as core.num).toDouble();
}
if (_json.containsKey('shortMessage')) {
shortMessage = SafeHtmlProto.fromJson(
_json['shortMessage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('title')) {
title = _json['title'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (helpUrl != null) {
_json['helpUrl'] = helpUrl;
}
if (longMessage != null) {
_json['longMessage'] = longMessage.toJson();
}
if (priority != null) {
_json['priority'] = priority;
}
if (pseudoResourceId != null) {
_json['pseudoResourceId'] = pseudoResourceId;
}
if (region != null) {
_json['region'] = region.toJson();
}
if (resourceName != null) {
_json['resourceName'] = resourceName;
}
if (screenId != null) {
_json['screenId'] = screenId;
}
if (secondaryPriority != null) {
_json['secondaryPriority'] = secondaryPriority;
}
if (shortMessage != null) {
_json['shortMessage'] = shortMessage.toJson();
}
if (title != null) {
_json['title'] = title;
}
return _json;
}
}
class TestCase {
/// The elapsed run time of the test case. Required.
Duration elapsedTime;
/// The end time of the test case.
Timestamp endTime;
/// Why the test case was skipped. Present only for skipped test case
core.String skippedMessage;
/// The stack trace details if the test case failed or encountered an error.
/// The maximum size of the stack traces is 100KiB, beyond which the stack
/// track will be truncated. Zero if the test case passed.
core.List<StackTrace> stackTraces;
/// The start time of the test case.
Timestamp startTime;
/// The status of the test case. Required.
/// Possible string values are:
/// - "passed" : Test passed.
/// - "failed" : Test failed.
/// - "error" : Test encountered an error
/// - "skipped" : Test skipped
/// - "flaky" : Test flaked. Present only for rollup test cases; test cases
/// from steps that were run with the same configuration had both failure and
/// success outcomes.
core.String status;
/// A unique identifier within a Step for this Test Case.
core.String testCaseId;
/// Test case reference, e.g. name, class name and test suite name. Required.
TestCaseReference testCaseReference;
/// References to opaque files of any format output by the tool execution.
/// @OutputOnly
core.List<ToolOutputReference> toolOutputs;
TestCase();
TestCase.fromJson(core.Map _json) {
if (_json.containsKey('elapsedTime')) {
elapsedTime = Duration.fromJson(
_json['elapsedTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('endTime')) {
endTime = Timestamp.fromJson(
_json['endTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('skippedMessage')) {
skippedMessage = _json['skippedMessage'] as core.String;
}
if (_json.containsKey('stackTraces')) {
stackTraces = (_json['stackTraces'] as core.List)
.map<StackTrace>((value) =>
StackTrace.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('startTime')) {
startTime = Timestamp.fromJson(
_json['startTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('status')) {
status = _json['status'] as core.String;
}
if (_json.containsKey('testCaseId')) {
testCaseId = _json['testCaseId'] as core.String;
}
if (_json.containsKey('testCaseReference')) {
testCaseReference = TestCaseReference.fromJson(
_json['testCaseReference'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('toolOutputs')) {
toolOutputs = (_json['toolOutputs'] as core.List)
.map<ToolOutputReference>((value) => ToolOutputReference.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (elapsedTime != null) {
_json['elapsedTime'] = elapsedTime.toJson();
}
if (endTime != null) {
_json['endTime'] = endTime.toJson();
}
if (skippedMessage != null) {
_json['skippedMessage'] = skippedMessage;
}
if (stackTraces != null) {
_json['stackTraces'] =
stackTraces.map((value) => value.toJson()).toList();
}
if (startTime != null) {
_json['startTime'] = startTime.toJson();
}
if (status != null) {
_json['status'] = status;
}
if (testCaseId != null) {
_json['testCaseId'] = testCaseId;
}
if (testCaseReference != null) {
_json['testCaseReference'] = testCaseReference.toJson();
}
if (toolOutputs != null) {
_json['toolOutputs'] =
toolOutputs.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// A reference to a test case. Test case references are canonically ordered
/// lexicographically by these three factors: * First, by test_suite_name. *
/// Second, by class_name. * Third, by name.
class TestCaseReference {
/// The name of the class.
core.String className;
/// The name of the test case. Required.
core.String name;
/// The name of the test suite to which this test case belongs.
core.String testSuiteName;
TestCaseReference();
TestCaseReference.fromJson(core.Map _json) {
if (_json.containsKey('className')) {
className = _json['className'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('testSuiteName')) {
testSuiteName = _json['testSuiteName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (className != null) {
_json['className'] = className;
}
if (name != null) {
_json['name'] = name;
}
if (testSuiteName != null) {
_json['testSuiteName'] = testSuiteName;
}
return _json;
}
}
/// A step that represents running tests. It accepts ant-junit xml files which
/// will be parsed into structured test results by the service. Xml file paths
/// are updated in order to append more files, however they can't be deleted.
/// Users can also add test results manually by using the test_result field.
class TestExecutionStep {
/// Issues observed during the test execution. For example, if the mobile app
/// under test crashed during the test, the error message and the stack trace
/// content can be recorded here to assist debugging. - In response: present
/// if set by create or update - In create/update request: optional
core.List<TestIssue> testIssues;
/// List of test suite overview contents. This could be parsed from xUnit XML
/// log by server, or uploaded directly by user. This references should only
/// be called when test suites are fully parsed or uploaded. The maximum
/// allowed number of test suite overviews per step is 1000. - In response:
/// always set - In create request: optional - In update request: never (use
/// publishXunitXmlFiles custom method instead)
core.List<TestSuiteOverview> testSuiteOverviews;
/// The timing break down of the test execution. - In response: present if set
/// by create or update - In create/update request: optional
TestTiming testTiming;
/// Represents the execution of the test runner. The exit code of this tool
/// will be used to determine if the test passed. - In response: always set -
/// In create/update request: optional
ToolExecution toolExecution;
TestExecutionStep();
TestExecutionStep.fromJson(core.Map _json) {
if (_json.containsKey('testIssues')) {
testIssues = (_json['testIssues'] as core.List)
.map<TestIssue>((value) =>
TestIssue.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('testSuiteOverviews')) {
testSuiteOverviews = (_json['testSuiteOverviews'] as core.List)
.map<TestSuiteOverview>((value) => TestSuiteOverview.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('testTiming')) {
testTiming = TestTiming.fromJson(
_json['testTiming'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('toolExecution')) {
toolExecution = ToolExecution.fromJson(
_json['toolExecution'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (testIssues != null) {
_json['testIssues'] = testIssues.map((value) => value.toJson()).toList();
}
if (testSuiteOverviews != null) {
_json['testSuiteOverviews'] =
testSuiteOverviews.map((value) => value.toJson()).toList();
}
if (testTiming != null) {
_json['testTiming'] = testTiming.toJson();
}
if (toolExecution != null) {
_json['toolExecution'] = toolExecution.toJson();
}
return _json;
}
}
/// An issue detected occurring during a test execution.
class TestIssue {
/// Category of issue. Required.
/// Possible string values are:
/// - "unspecifiedCategory" : Default unspecified category. Do not use. For
/// versioning only.
/// - "common" : Issue is not specific to a particular test kind (e.g., a
/// native crash).
/// - "robo" : Issue is specific to Robo run.
core.String category;
/// A brief human-readable message describing the issue. Required.
core.String errorMessage;
/// Severity of issue. Required.
/// Possible string values are:
/// - "unspecifiedSeverity" : Default unspecified severity. Do not use. For
/// versioning only.
/// - "info" : Non critical issue, providing users with some info about the
/// test run.
/// - "suggestion" : Non critical issue, providing users with some hints on
/// improving their testing experience, e.g., suggesting to use Game Loops.
/// - "warning" : Potentially critical issue.
/// - "severe" : Critical issue.
core.String severity;
/// Deprecated in favor of stack trace fields inside specific warnings.
StackTrace stackTrace;
/// Type of issue. Required.
/// Possible string values are:
/// - "unspecifiedType" : Default unspecified type. Do not use. For versioning
/// only.
/// - "fatalException" : Issue is a fatal exception.
/// - "nativeCrash" : Issue is a native crash.
/// - "anr" : Issue is an ANR crash.
/// - "unusedRoboDirective" : Issue is an unused robo directive.
/// - "compatibleWithOrchestrator" : Issue is a suggestion to use
/// orchestrator.
/// - "launcherActivityNotFound" : Issue with finding a launcher activity
/// - "startActivityNotFound" : Issue with resolving a user-provided intent to
/// start an activity
/// - "incompleteRoboScriptExecution" : A Robo script was not fully executed.
/// - "completeRoboScriptExecution" : A Robo script was fully and successfully
/// executed.
/// - "failedToInstall" : The APK failed to install.
/// - "availableDeepLinks" : The app-under-test has deep links, but none were
/// provided to Robo.
/// - "nonSdkApiUsageViolation" : App accessed a non-sdk Api.
/// - "nonSdkApiUsageReport" : App accessed a non-sdk Api (new detailed
/// report)
/// - "encounteredNonAndroidUiWidgetScreen" : Robo crawl encountered at least
/// one screen with elements that are not Android UI widgets.
/// - "encounteredLoginScreen" : Robo crawl encountered at least one probable
/// login screen.
/// - "performedGoogleLogin" : Robo signed in with Google.
/// - "iosException" : iOS App crashed with an exception.
/// - "iosCrash" : iOS App crashed without an exception (e.g. killed).
/// - "performedMonkeyActions" : Robo crawl involved performing some monkey
/// actions.
/// - "usedRoboDirective" : Robo crawl used a Robo directive.
/// - "usedRoboIgnoreDirective" : Robo crawl used a Robo directive to ignore
/// an UI element.
/// - "insufficientCoverage" : Robo did not crawl some potentially important
/// parts of the app.
/// - "inAppPurchases" : Robo crawl involved some in-app purchases.
/// - "crashDialogError" : Crash dialog was detected during the test execution
/// - "uiElementsTooDeep" : UI element depth is greater than the threshold
/// - "blankScreen" : Blank screen is found in the Robo crawl
/// - "overlappingUiElements" : Overlapping UI elements are found in the Robo
/// crawl
/// - "unityException" : An uncaught Unity exception was detected (these don't
/// crash apps).
core.String type;
/// Warning message with additional details of the issue. Should always be a
/// message from com.google.devtools.toolresults.v1.warnings
Any warning;
TestIssue();
TestIssue.fromJson(core.Map _json) {
if (_json.containsKey('category')) {
category = _json['category'] as core.String;
}
if (_json.containsKey('errorMessage')) {
errorMessage = _json['errorMessage'] as core.String;
}
if (_json.containsKey('severity')) {
severity = _json['severity'] as core.String;
}
if (_json.containsKey('stackTrace')) {
stackTrace = StackTrace.fromJson(
_json['stackTrace'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('type')) {
type = _json['type'] as core.String;
}
if (_json.containsKey('warning')) {
warning =
Any.fromJson(_json['warning'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (category != null) {
_json['category'] = category;
}
if (errorMessage != null) {
_json['errorMessage'] = errorMessage;
}
if (severity != null) {
_json['severity'] = severity;
}
if (stackTrace != null) {
_json['stackTrace'] = stackTrace.toJson();
}
if (type != null) {
_json['type'] = type;
}
if (warning != null) {
_json['warning'] = warning.toJson();
}
return _json;
}
}
/// A summary of a test suite result either parsed from XML or uploaded directly
/// by a user. Note: the API related comments are for StepService only. This
/// message is also being used in ExecutionService in a read only mode for the
/// corresponding step.
class TestSuiteOverview {
/// Elapsed time of test suite.
Duration elapsedTime;
/// Number of test cases in error, typically set by the service by parsing the
/// xml_source. - In create/response: always set - In update request: never
core.int errorCount;
/// Number of failed test cases, typically set by the service by parsing the
/// xml_source. May also be set by the user. - In create/response: always set
/// - In update request: never
core.int failureCount;
/// Number of flaky test cases, set by the service by rolling up flaky test
/// attempts. Present only for rollup test suite overview at environment
/// level. A step cannot have flaky test cases.
core.int flakyCount;
/// The name of the test suite. - In create/response: always set - In update
/// request: never
core.String name;
/// Number of test cases not run, typically set by the service by parsing the
/// xml_source. - In create/response: always set - In update request: never
core.int skippedCount;
/// Number of test cases, typically set by the service by parsing the
/// xml_source. - In create/response: always set - In update request: never
core.int totalCount;
/// If this test suite was parsed from XML, this is the URI where the original
/// XML file is stored. Note: Multiple test suites can share the same
/// xml_source Returns INVALID_ARGUMENT if the uri format is not supported. -
/// In create/response: optional - In update request: never
FileReference xmlSource;
TestSuiteOverview();
TestSuiteOverview.fromJson(core.Map _json) {
if (_json.containsKey('elapsedTime')) {
elapsedTime = Duration.fromJson(
_json['elapsedTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('errorCount')) {
errorCount = _json['errorCount'] as core.int;
}
if (_json.containsKey('failureCount')) {
failureCount = _json['failureCount'] as core.int;
}
if (_json.containsKey('flakyCount')) {
flakyCount = _json['flakyCount'] as core.int;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('skippedCount')) {
skippedCount = _json['skippedCount'] as core.int;
}
if (_json.containsKey('totalCount')) {
totalCount = _json['totalCount'] as core.int;
}
if (_json.containsKey('xmlSource')) {
xmlSource = FileReference.fromJson(
_json['xmlSource'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (elapsedTime != null) {
_json['elapsedTime'] = elapsedTime.toJson();
}
if (errorCount != null) {
_json['errorCount'] = errorCount;
}
if (failureCount != null) {
_json['failureCount'] = failureCount;
}
if (flakyCount != null) {
_json['flakyCount'] = flakyCount;
}
if (name != null) {
_json['name'] = name;
}
if (skippedCount != null) {
_json['skippedCount'] = skippedCount;
}
if (totalCount != null) {
_json['totalCount'] = totalCount;
}
if (xmlSource != null) {
_json['xmlSource'] = xmlSource.toJson();
}
return _json;
}
}
/// Testing timing break down to know phases.
class TestTiming {
/// How long it took to run the test process. - In response: present if
/// previously set. - In create/update request: optional
Duration testProcessDuration;
TestTiming();
TestTiming.fromJson(core.Map _json) {
if (_json.containsKey('testProcessDuration')) {
testProcessDuration = Duration.fromJson(
_json['testProcessDuration'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (testProcessDuration != null) {
_json['testProcessDuration'] = testProcessDuration.toJson();
}
return _json;
}
}
/// A single thumbnail, with its size and format.
class Thumbnail {
/// The thumbnail's content type, i.e. "image/png". Always set.
core.String contentType;
/// The thumbnail file itself. That is, the bytes here are precisely the bytes
/// that make up the thumbnail file; they can be served as an image as-is
/// (with the appropriate content type.) Always set.
core.String data;
core.List<core.int> get dataAsBytes => convert.base64.decode(data);
set dataAsBytes(core.List<core.int> _bytes) {
data =
convert.base64.encode(_bytes).replaceAll('/', '_').replaceAll('+', '-');
}
/// The height of the thumbnail, in pixels. Always set.
core.int heightPx;
/// The width of the thumbnail, in pixels. Always set.
core.int widthPx;
Thumbnail();
Thumbnail.fromJson(core.Map _json) {
if (_json.containsKey('contentType')) {
contentType = _json['contentType'] as core.String;
}
if (_json.containsKey('data')) {
data = _json['data'] as core.String;
}
if (_json.containsKey('heightPx')) {
heightPx = _json['heightPx'] as core.int;
}
if (_json.containsKey('widthPx')) {
widthPx = _json['widthPx'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (contentType != null) {
_json['contentType'] = contentType;
}
if (data != null) {
_json['data'] = data;
}
if (heightPx != null) {
_json['heightPx'] = heightPx;
}
if (widthPx != null) {
_json['widthPx'] = widthPx;
}
return _json;
}
}
/// 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.
class Timestamp {
/// 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.
core.int nanos;
/// 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.
core.String seconds;
Timestamp();
Timestamp.fromJson(core.Map _json) {
if (_json.containsKey('nanos')) {
nanos = _json['nanos'] as core.int;
}
if (_json.containsKey('seconds')) {
seconds = _json['seconds'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nanos != null) {
_json['nanos'] = nanos;
}
if (seconds != null) {
_json['seconds'] = seconds;
}
return _json;
}
}
/// An execution of an arbitrary tool. It could be a test runner or a tool
/// copying artifacts or deploying code.
class ToolExecution {
/// The full tokenized command line including the program name (equivalent to
/// argv in a C program). - In response: present if set by create request - In
/// create request: optional - In update request: never set
core.List<core.String> commandLineArguments;
/// Tool execution exit code. This field will be set once the tool has exited.
/// - In response: present if set by create/update request - In create
/// request: optional - In update request: optional, a FAILED_PRECONDITION
/// error will be returned if an exit_code is already set.
ToolExitCode exitCode;
/// References to any plain text logs output the tool execution. This field
/// can be set before the tool has exited in order to be able to have access
/// to a live view of the logs while the tool is running. The maximum allowed
/// number of tool logs per step is 1000. - In response: present if set by
/// create/update request - In create request: optional - In update request:
/// optional, any value provided will be appended to the existing list
core.List<FileReference> toolLogs;
/// References to opaque files of any format output by the tool execution. The
/// maximum allowed number of tool outputs per step is 1000. - In response:
/// present if set by create/update request - In create request: optional - In
/// update request: optional, any value provided will be appended to the
/// existing list
core.List<ToolOutputReference> toolOutputs;
ToolExecution();
ToolExecution.fromJson(core.Map _json) {
if (_json.containsKey('commandLineArguments')) {
commandLineArguments = (_json['commandLineArguments'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('exitCode')) {
exitCode = ToolExitCode.fromJson(
_json['exitCode'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('toolLogs')) {
toolLogs = (_json['toolLogs'] as core.List)
.map<FileReference>((value) => FileReference.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('toolOutputs')) {
toolOutputs = (_json['toolOutputs'] as core.List)
.map<ToolOutputReference>((value) => ToolOutputReference.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (commandLineArguments != null) {
_json['commandLineArguments'] = commandLineArguments;
}
if (exitCode != null) {
_json['exitCode'] = exitCode.toJson();
}
if (toolLogs != null) {
_json['toolLogs'] = toolLogs.map((value) => value.toJson()).toList();
}
if (toolOutputs != null) {
_json['toolOutputs'] =
toolOutputs.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Generic tool step to be used for binaries we do not explicitly support. For
/// example: running cp to copy artifacts from one location to another.
class ToolExecutionStep {
/// A Tool execution. - In response: present if set by create/update request -
/// In create/update request: optional
ToolExecution toolExecution;
ToolExecutionStep();
ToolExecutionStep.fromJson(core.Map _json) {
if (_json.containsKey('toolExecution')) {
toolExecution = ToolExecution.fromJson(
_json['toolExecution'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (toolExecution != null) {
_json['toolExecution'] = toolExecution.toJson();
}
return _json;
}
}
/// Exit code from a tool execution.
class ToolExitCode {
/// Tool execution exit code. A value of 0 means that the execution was
/// successful. - In response: always set - In create/update request: always
/// set
core.int number;
ToolExitCode();
ToolExitCode.fromJson(core.Map _json) {
if (_json.containsKey('number')) {
number = _json['number'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (number != null) {
_json['number'] = number;
}
return _json;
}
}
/// A reference to a ToolExecution output file.
class ToolOutputReference {
/// The creation time of the file. - In response: present if set by
/// create/update request - In create/update request: optional
Timestamp creationTime;
/// A FileReference to an output file. - In response: always set - In
/// create/update request: always set
FileReference output;
/// The test case to which this output file belongs. - In response: present if
/// set by create/update request - In create/update request: optional
TestCaseReference testCase;
ToolOutputReference();
ToolOutputReference.fromJson(core.Map _json) {
if (_json.containsKey('creationTime')) {
creationTime = Timestamp.fromJson(
_json['creationTime'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('output')) {
output = FileReference.fromJson(
_json['output'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('testCase')) {
testCase = TestCaseReference.fromJson(
_json['testCase'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (creationTime != null) {
_json['creationTime'] = creationTime.toJson();
}
if (output != null) {
_json['output'] = output.toJson();
}
if (testCase != null) {
_json['testCase'] = testCase.toJson();
}
return _json;
}
}
/// A warning that the screen hierarchy is deeper than the recommended
/// threshold.
class UIElementTooDeep {
/// The depth of the screen element
core.int depth;
/// The screen id of the element
core.String screenId;
/// The screen state id of the element
core.String screenStateId;
UIElementTooDeep();
UIElementTooDeep.fromJson(core.Map _json) {
if (_json.containsKey('depth')) {
depth = _json['depth'] as core.int;
}
if (_json.containsKey('screenId')) {
screenId = _json['screenId'] as core.String;
}
if (_json.containsKey('screenStateId')) {
screenStateId = _json['screenStateId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (depth != null) {
_json['depth'] = depth;
}
if (screenId != null) {
_json['screenId'] = screenId;
}
if (screenStateId != null) {
_json['screenStateId'] = screenStateId;
}
return _json;
}
}
/// Default unspecified warning.
class UnspecifiedWarning {
UnspecifiedWarning();
UnspecifiedWarning.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// Additional details of an unused robodirective.
class UnusedRoboDirective {
/// The name of the resource that was unused.
core.String resourceName;
UnusedRoboDirective();
UnusedRoboDirective.fromJson(core.Map _json) {
if (_json.containsKey('resourceName')) {
resourceName = _json['resourceName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (resourceName != null) {
_json['resourceName'] = resourceName;
}
return _json;
}
}
/// This insight is a recommendation to upgrade a given library to the specified
/// version, in order to avoid dependencies on non-SDK APIs.
class UpgradeInsight {
/// The name of the package to be upgraded.
core.String packageName;
/// The suggested version to upgrade to. Optional: In case we are not sure
/// which version solves this problem
core.String upgradeToVersion;
UpgradeInsight();
UpgradeInsight.fromJson(core.Map _json) {
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('upgradeToVersion')) {
upgradeToVersion = _json['upgradeToVersion'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (packageName != null) {
_json['packageName'] = packageName;
}
if (upgradeToVersion != null) {
_json['upgradeToVersion'] = upgradeToVersion;
}
return _json;
}
}
/// Additional details of a used Robo directive.
class UsedRoboDirective {
/// The name of the resource that was used.
core.String resourceName;
UsedRoboDirective();
UsedRoboDirective.fromJson(core.Map _json) {
if (_json.containsKey('resourceName')) {
resourceName = _json['resourceName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (resourceName != null) {
_json['resourceName'] = resourceName;
}
return _json;
}
}
/// Additional details of a used Robo directive with an ignore action. Note:
/// This is a different scenario than unused directive.
class UsedRoboIgnoreDirective {
/// The name of the resource that was ignored.
core.String resourceName;
UsedRoboIgnoreDirective();
UsedRoboIgnoreDirective.fromJson(core.Map _json) {
if (_json.containsKey('resourceName')) {
resourceName = _json['resourceName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (resourceName != null) {
_json['resourceName'] = resourceName;
}
return _json;
}
}