| Index: generated/googleapis_beta/lib/toolresults/v1beta3.dart
|
| diff --git a/generated/googleapis_beta/lib/toolresults/v1beta3.dart b/generated/googleapis_beta/lib/toolresults/v1beta3.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..2e225f1d00f111c04edfc88524ce2bc163ef4f35
|
| --- /dev/null
|
| +++ b/generated/googleapis_beta/lib/toolresults/v1beta3.dart
|
| @@ -0,0 +1,3073 @@
|
| +// This is a generated file (see the discoveryapis_generator project).
|
| +
|
| +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:crypto/crypto.dart' as crypto;
|
| +import 'package:http/http.dart' as http;
|
| +
|
| +export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
|
| + ApiRequestError, DetailedApiRequestError;
|
| +
|
| +const core.String USER_AGENT = 'dart-api-client toolresults/v1beta3';
|
| +
|
| +/** Read and publish results from Cloud Test Lab. */
|
| +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 => new ProjectsResourceApi(_requester);
|
| +
|
| + ToolresultsApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "toolresults/v1beta3/projects/"}) :
|
| + _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
|
| +}
|
| +
|
| +
|
| +class ProjectsResourceApi {
|
| + final commons.ApiRequester _requester;
|
| +
|
| + ProjectsHistoriesResourceApi get histories => new 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/settings';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ProjectSettings.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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
|
| + * the name of the user calling. Except 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 project-private ACL: All project team
|
| + * members are given permissions to the bucket and objects created within it
|
| + * according to their roles. Project owners have owners rights, and so on. The
|
| + * default ACL on objects created in the bucket is project-private as well.
|
| + * 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 deteleted, 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + ':initializeSettings';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "POST",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ProjectSettings.fromJson(data));
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +class ProjectsHistoriesResourceApi {
|
| + final commons.ApiRequester _requester;
|
| +
|
| + ProjectsHistoriesExecutionsResourceApi get executions => new 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (requestId != null) {
|
| + _queryParams["requestId"] = [requestId];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "POST",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new History.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId');
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new History.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (filterByName != null) {
|
| + _queryParams["filterByName"] = [filterByName];
|
| + }
|
| + if (pageSize != null) {
|
| + _queryParams["pageSize"] = ["${pageSize}"];
|
| + }
|
| + if (pageToken != null) {
|
| + _queryParams["pageToken"] = [pageToken];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ListHistoriesResponse.fromJson(data));
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +class ProjectsHistoriesExecutionsResourceApi {
|
| + final commons.ApiRequester _requester;
|
| +
|
| + ProjectsHistoriesExecutionsStepsResourceApi get steps => new 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (requestId != null) {
|
| + _queryParams["requestId"] = [requestId];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "POST",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Execution.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId');
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Execution.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * Lists Histories for a given Project.
|
| + *
|
| + * 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (pageSize != null) {
|
| + _queryParams["pageSize"] = ["${pageSize}"];
|
| + }
|
| + if (pageToken != null) {
|
| + _queryParams["pageToken"] = [pageToken];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ListExecutionsResponse.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (requestId != null) {
|
| + _queryParams["requestId"] = [requestId];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId');
|
| +
|
| + var _response = _requester.request(_url,
|
| + "PATCH",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Execution.fromJson(data));
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +class ProjectsHistoriesExecutionsStepsResourceApi {
|
| + final commons.ApiRequester _requester;
|
| +
|
| + ProjectsHistoriesExecutionsStepsThumbnailsResourceApi get thumbnails => new ProjectsHistoriesExecutionsStepsThumbnailsResourceApi(_requester);
|
| +
|
| + ProjectsHistoriesExecutionsStepsResourceApi(commons.ApiRequester client) :
|
| + _requester = client;
|
| +
|
| + /**
|
| + * 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] - A Project id.
|
| + *
|
| + * Required.
|
| + *
|
| + * [historyId] - A History id.
|
| + *
|
| + * Required.
|
| + *
|
| + * [executionId] - A Execution id.
|
| + *
|
| + * Required.
|
| + *
|
| + * [requestId] - A unique request ID for server to detect duplicated requests.
|
| + * For example, a UUID.
|
| + *
|
| + * Optional, but strongly recommended.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (requestId != null) {
|
| + _queryParams["requestId"] = [requestId];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "POST",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Step.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (stepId == null) {
|
| + throw new core.ArgumentError("Parameter stepId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps/' + commons.Escaper.ecapeVariable('$stepId');
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Step.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (pageSize != null) {
|
| + _queryParams["pageSize"] = ["${pageSize}"];
|
| + }
|
| + if (pageToken != null) {
|
| + _queryParams["pageToken"] = [pageToken];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ListStepsResponse.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (stepId == null) {
|
| + throw new core.ArgumentError("Parameter stepId is required.");
|
| + }
|
| + if (requestId != null) {
|
| + _queryParams["requestId"] = [requestId];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps/' + commons.Escaper.ecapeVariable('$stepId');
|
| +
|
| + var _response = _requester.request(_url,
|
| + "PATCH",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Step.fromJson(data));
|
| + }
|
| +
|
| + /**
|
| + * 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.
|
| + *
|
| + * 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) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (request != null) {
|
| + _body = convert.JSON.encode((request).toJson());
|
| + }
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (stepId == null) {
|
| + throw new core.ArgumentError("Parameter stepId is required.");
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps/' + commons.Escaper.ecapeVariable('$stepId') + ':publishXunitXmlFiles';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "POST",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new Step.fromJson(data));
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +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.
|
| + *
|
| + * 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}) {
|
| + var _url = null;
|
| + var _queryParams = new core.Map();
|
| + var _uploadMedia = null;
|
| + var _uploadOptions = null;
|
| + var _downloadOptions = commons.DownloadOptions.Metadata;
|
| + var _body = null;
|
| +
|
| + if (projectId == null) {
|
| + throw new core.ArgumentError("Parameter projectId is required.");
|
| + }
|
| + if (historyId == null) {
|
| + throw new core.ArgumentError("Parameter historyId is required.");
|
| + }
|
| + if (executionId == null) {
|
| + throw new core.ArgumentError("Parameter executionId is required.");
|
| + }
|
| + if (stepId == null) {
|
| + throw new core.ArgumentError("Parameter stepId is required.");
|
| + }
|
| + if (pageSize != null) {
|
| + _queryParams["pageSize"] = ["${pageSize}"];
|
| + }
|
| + if (pageToken != null) {
|
| + _queryParams["pageToken"] = [pageToken];
|
| + }
|
| +
|
| + _url = commons.Escaper.ecapeVariable('$projectId') + '/histories/' + commons.Escaper.ecapeVariable('$historyId') + '/executions/' + commons.Escaper.ecapeVariable('$executionId') + '/steps/' + commons.Escaper.ecapeVariable('$stepId') + '/thumbnails';
|
| +
|
| + var _response = _requester.request(_url,
|
| + "GET",
|
| + body: _body,
|
| + queryParams: _queryParams,
|
| + uploadOptions: _uploadOptions,
|
| + uploadMedia: _uploadMedia,
|
| + downloadOptions: _downloadOptions);
|
| + return _response.then((data) => new ListStepThumbnailsResponse.fromJson(data));
|
| + }
|
| +
|
| +}
|
| +
|
| +
|
| +
|
| +/**
|
| + * `Any` contains an arbitrary serialized 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); }
|
| + *
|
| + * 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 whose content describes the type of the serialized
|
| + * message.
|
| + *
|
| + * For URLs which use the schema `http`, `https`, or no schema, the following
|
| + * restrictions and interpretations apply:
|
| + *
|
| + * * If no schema is provided, `https` is assumed. * The last segment of the
|
| + * URL's path must represent the fully qualified name of the type (as in
|
| + * `path/google.protobuf.Duration`). * 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.)
|
| + *
|
| + * Schemas other than `http`, `https` (or the empty schema) might be used with
|
| + * implementation specific semantics.
|
| + */
|
| + core.String typeUrl;
|
| + /** Must be valid serialized data of the above specified type. */
|
| + core.String value;
|
| + core.List<core.int> get valueAsBytes {
|
| + return crypto.CryptoUtils.base64StringToBytes(value);
|
| + }
|
| +
|
| + void set valueAsBytes(core.List<core.int> _bytes) {
|
| + value = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
|
| + }
|
| +
|
| + Any();
|
| +
|
| + Any.fromJson(core.Map _json) {
|
| + if (_json.containsKey("typeUrl")) {
|
| + typeUrl = _json["typeUrl"];
|
| + }
|
| + if (_json.containsKey("value")) {
|
| + value = _json["value"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (typeUrl != null) {
|
| + _json["typeUrl"] = typeUrl;
|
| + }
|
| + if (value != null) {
|
| + _json["value"] = value;
|
| + }
|
| + 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.
|
| + *
|
| + * Example 1: Compute Duration from two Timestamps in pseudo code.
|
| + *
|
| + * Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
|
| + *
|
| + * duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos -
|
| + * start.nanos;
|
| + *
|
| + * if (duration.seconds 0) { duration.seconds += 1; duration.nanos -=
|
| + * 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) {
|
| + * duration.seconds -= 1; duration.nanos += 1000000000; }
|
| + *
|
| + * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
|
| + *
|
| + * Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
|
| + *
|
| + * end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos +
|
| + * duration.nanos;
|
| + *
|
| + * if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
|
| + */
|
| +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.
|
| + */
|
| + core.String seconds;
|
| +
|
| + Duration();
|
| +
|
| + Duration.fromJson(core.Map _json) {
|
| + if (_json.containsKey("nanos")) {
|
| + nanos = _json["nanos"];
|
| + }
|
| + if (_json.containsKey("seconds")) {
|
| + seconds = _json["seconds"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (nanos != null) {
|
| + _json["nanos"] = nanos;
|
| + }
|
| + if (seconds != null) {
|
| + _json["seconds"] = seconds;
|
| + }
|
| + 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. Next tag: 12
|
| + */
|
| +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;
|
| + /**
|
| + * 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;
|
| + /**
|
| + * 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:
|
| + * - "complete"
|
| + * - "inProgress"
|
| + * - "pending"
|
| + * - "unknownState"
|
| + */
|
| + core.String state;
|
| + /**
|
| + * TestExecution Matrix ID that the Test Service 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 = new Timestamp.fromJson(_json["completionTime"]);
|
| + }
|
| + if (_json.containsKey("creationTime")) {
|
| + creationTime = new Timestamp.fromJson(_json["creationTime"]);
|
| + }
|
| + if (_json.containsKey("executionId")) {
|
| + executionId = _json["executionId"];
|
| + }
|
| + if (_json.containsKey("outcome")) {
|
| + outcome = new Outcome.fromJson(_json["outcome"]);
|
| + }
|
| + if (_json.containsKey("state")) {
|
| + state = _json["state"];
|
| + }
|
| + if (_json.containsKey("testExecutionMatrixId")) {
|
| + testExecutionMatrixId = _json["testExecutionMatrixId"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (completionTime != null) {
|
| + _json["completionTime"] = (completionTime).toJson();
|
| + }
|
| + if (creationTime != null) {
|
| + _json["creationTime"] = (creationTime).toJson();
|
| + }
|
| + if (executionId != null) {
|
| + _json["executionId"] = executionId;
|
| + }
|
| + if (outcome != null) {
|
| + _json["outcome"] = (outcome).toJson();
|
| + }
|
| + if (state != null) {
|
| + _json["state"] = state;
|
| + }
|
| + if (testExecutionMatrixId != null) {
|
| + _json["testExecutionMatrixId"] = testExecutionMatrixId;
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +class FailureDetail {
|
| + /** If the failure was severe because the system under test crashed. */
|
| + core.bool crashed;
|
| + /**
|
| + * 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 other than the app crashed. */
|
| + core.bool otherNativeCrash;
|
| + /** If the test overran some time limit, and that is why it failed. */
|
| + core.bool timedOut;
|
| +
|
| + FailureDetail();
|
| +
|
| + FailureDetail.fromJson(core.Map _json) {
|
| + if (_json.containsKey("crashed")) {
|
| + crashed = _json["crashed"];
|
| + }
|
| + if (_json.containsKey("notInstalled")) {
|
| + notInstalled = _json["notInstalled"];
|
| + }
|
| + if (_json.containsKey("otherNativeCrash")) {
|
| + otherNativeCrash = _json["otherNativeCrash"];
|
| + }
|
| + if (_json.containsKey("timedOut")) {
|
| + timedOut = _json["timedOut"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (crashed != null) {
|
| + _json["crashed"] = crashed;
|
| + }
|
| + if (notInstalled != null) {
|
| + _json["notInstalled"] = notInstalled;
|
| + }
|
| + if (otherNativeCrash != null) {
|
| + _json["otherNativeCrash"] = otherNativeCrash;
|
| + }
|
| + if (timedOut != null) {
|
| + _json["timedOut"] = timedOut;
|
| + }
|
| + 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"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (fileUri != null) {
|
| + _json["fileUri"] = fileUri;
|
| + }
|
| + 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. Next tag: 7
|
| + */
|
| +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 100
|
| + * characters.
|
| + *
|
| + * - In response always set - In create request: always set
|
| + */
|
| + core.String name;
|
| +
|
| + History();
|
| +
|
| + History.fromJson(core.Map _json) {
|
| + if (_json.containsKey("displayName")) {
|
| + displayName = _json["displayName"];
|
| + }
|
| + if (_json.containsKey("historyId")) {
|
| + historyId = _json["historyId"];
|
| + }
|
| + if (_json.containsKey("name")) {
|
| + name = _json["name"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (displayName != null) {
|
| + _json["displayName"] = displayName;
|
| + }
|
| + if (historyId != null) {
|
| + _json["historyId"] = historyId;
|
| + }
|
| + if (name != null) {
|
| + _json["name"] = name;
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * An image, with a link to the main image and a thumbnail.
|
| + *
|
| + * Next tag: 6
|
| + */
|
| +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 = new Status.fromJson(_json["error"]);
|
| + }
|
| + if (_json.containsKey("sourceImage")) {
|
| + sourceImage = new ToolOutputReference.fromJson(_json["sourceImage"]);
|
| + }
|
| + if (_json.containsKey("stepId")) {
|
| + stepId = _json["stepId"];
|
| + }
|
| + if (_json.containsKey("thumbnail")) {
|
| + thumbnail = new Thumbnail.fromJson(_json["thumbnail"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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;
|
| + }
|
| +}
|
| +
|
| +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 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;
|
| + /**
|
| + * A native process crashed on the device, producing a tombstone. It is
|
| + * unclear whether the crash was related to the app under test.
|
| + *
|
| + * For example, OpenGL crashed, but it is unclear if the app is responsible.
|
| + * TODO(yinfu): Remove after all reference from TestService are deleted.
|
| + */
|
| + core.bool nativeCrash;
|
| +
|
| + InconclusiveDetail();
|
| +
|
| + InconclusiveDetail.fromJson(core.Map _json) {
|
| + if (_json.containsKey("abortedByUser")) {
|
| + abortedByUser = _json["abortedByUser"];
|
| + }
|
| + if (_json.containsKey("infrastructureFailure")) {
|
| + infrastructureFailure = _json["infrastructureFailure"];
|
| + }
|
| + if (_json.containsKey("nativeCrash")) {
|
| + nativeCrash = _json["nativeCrash"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (abortedByUser != null) {
|
| + _json["abortedByUser"] = abortedByUser;
|
| + }
|
| + if (infrastructureFailure != null) {
|
| + _json["infrastructureFailure"] = infrastructureFailure;
|
| + }
|
| + if (nativeCrash != null) {
|
| + _json["nativeCrash"] = nativeCrash;
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +/** Next tag: 3 */
|
| +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"].map((value) => new Execution.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("nextPageToken")) {
|
| + nextPageToken = _json["nextPageToken"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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"].map((value) => new History.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("nextPageToken")) {
|
| + nextPageToken = _json["nextPageToken"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (histories != null) {
|
| + _json["histories"] = histories.map((value) => (value).toJson()).toList();
|
| + }
|
| + if (nextPageToken != null) {
|
| + _json["nextPageToken"] = nextPageToken;
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * A response containing the thumbnails in a step.
|
| + *
|
| + * Next tag: 3
|
| + */
|
| +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"];
|
| + }
|
| + if (_json.containsKey("thumbnails")) {
|
| + thumbnails = _json["thumbnails"].map((value) => new Image.fromJson(value)).toList();
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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"];
|
| + }
|
| + if (_json.containsKey("steps")) {
|
| + steps = _json["steps"].map((value) => new Step.fromJson(value)).toList();
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (nextPageToken != null) {
|
| + _json["nextPageToken"] = nextPageToken;
|
| + }
|
| + if (steps != null) {
|
| + _json["steps"] = steps.map((value) => (value).toJson()).toList();
|
| + }
|
| + 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:
|
| + * - "failure"
|
| + * - "inconclusive"
|
| + * - "skipped"
|
| + * - "success"
|
| + * - "unset"
|
| + */
|
| + core.String summary;
|
| +
|
| + Outcome();
|
| +
|
| + Outcome.fromJson(core.Map _json) {
|
| + if (_json.containsKey("failureDetail")) {
|
| + failureDetail = new FailureDetail.fromJson(_json["failureDetail"]);
|
| + }
|
| + if (_json.containsKey("inconclusiveDetail")) {
|
| + inconclusiveDetail = new InconclusiveDetail.fromJson(_json["inconclusiveDetail"]);
|
| + }
|
| + if (_json.containsKey("skippedDetail")) {
|
| + skippedDetail = new SkippedDetail.fromJson(_json["skippedDetail"]);
|
| + }
|
| + if (_json.containsKey("successDetail")) {
|
| + successDetail = new SuccessDetail.fromJson(_json["successDetail"]);
|
| + }
|
| + if (_json.containsKey("summary")) {
|
| + summary = _json["summary"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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;
|
| + }
|
| +}
|
| +
|
| +/** 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"];
|
| + }
|
| + if (_json.containsKey("name")) {
|
| + name = _json["name"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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"].map((value) => new FileReference.fromJson(value)).toList();
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (xunitXmlFiles != null) {
|
| + _json["xunitXmlFiles"] = xunitXmlFiles.map((value) => (value).toJson()).toList();
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +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"];
|
| + }
|
| + if (_json.containsKey("incompatibleArchitecture")) {
|
| + incompatibleArchitecture = _json["incompatibleArchitecture"];
|
| + }
|
| + if (_json.containsKey("incompatibleDevice")) {
|
| + incompatibleDevice = _json["incompatibleDevice"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (incompatibleAppVersion != null) {
|
| + _json["incompatibleAppVersion"] = incompatibleAppVersion;
|
| + }
|
| + if (incompatibleArchitecture != null) {
|
| + _json["incompatibleArchitecture"] = incompatibleArchitecture;
|
| + }
|
| + if (incompatibleDevice != null) {
|
| + _json["incompatibleDevice"] = incompatibleDevice;
|
| + }
|
| + 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). The error model is designed to be:
|
| + *
|
| + * - Simple to use and understand for most users - Flexible enough to meet
|
| + * unexpected needs
|
| + *
|
| + * # Overview
|
| + *
|
| + * The `Status` message contains three pieces of data: error code, error
|
| + * message, and error details. The error code should be an enum value of
|
| + * [google.rpc.Code][], but it may accept additional error codes if needed. The
|
| + * error message should be a developer-facing English message that helps
|
| + * developers *understand* and *resolve* the error. If a localized user-facing
|
| + * error message is needed, put the localized message in the error details or
|
| + * localize it in the client. The optional error details may contain arbitrary
|
| + * information about the error. There is a predefined set of error detail types
|
| + * in the package `google.rpc` which can be used for common error conditions.
|
| + *
|
| + * # Language mapping
|
| + *
|
| + * The `Status` message is the logical representation of the error model, but it
|
| + * is not necessarily the actual wire format. When the `Status` message is
|
| + * exposed in different client libraries and different wire protocols, it can be
|
| + * mapped differently. For example, it will likely be mapped to some exceptions
|
| + * in Java, but more likely mapped to some error codes in C.
|
| + *
|
| + * # Other uses
|
| + *
|
| + * The error model and the `Status` message can be used in a variety of
|
| + * environments, either with or without APIs, to provide a consistent developer
|
| + * experience across different environments.
|
| + *
|
| + * Example uses of this error model include:
|
| + *
|
| + * - Partial errors. If a service needs to return partial errors to the client,
|
| + * it may embed the `Status` in the normal response to indicate the partial
|
| + * errors.
|
| + *
|
| + * - Workflow errors. A typical workflow has multiple steps. Each step may have
|
| + * a `Status` message for error reporting purpose.
|
| + *
|
| + * - Batch operations. If a client uses batch request and batch response, the
|
| + * `Status` message should be used directly inside batch response, one for each
|
| + * error sub-response.
|
| + *
|
| + * - Asynchronous operations. If an API call embeds asynchronous operation
|
| + * results in its response, the status of those operations should be represented
|
| + * directly using the `Status` message.
|
| + *
|
| + * - Logging. If some API errors are stored in logs, the message `Status` could
|
| + * be used directly after any stripping needed for security/privacy reasons.
|
| + */
|
| +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 will be a common set
|
| + * of message types for APIs to use.
|
| + */
|
| + core.List<Any> 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"];
|
| + }
|
| + if (_json.containsKey("details")) {
|
| + details = _json["details"].map((value) => new Any.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("message")) {
|
| + message = _json["message"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (code != null) {
|
| + _json["code"] = code;
|
| + }
|
| + if (details != null) {
|
| + _json["details"] = details.map((value) => (value).toJson()).toList();
|
| + }
|
| + 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: 20
|
| + */
|
| +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;
|
| + /**
|
| + * 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:
|
| + * - "complete"
|
| + * - "inProgress"
|
| + * - "pending"
|
| + * - "unknownState"
|
| + */
|
| + 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 = new Timestamp.fromJson(_json["completionTime"]);
|
| + }
|
| + if (_json.containsKey("creationTime")) {
|
| + creationTime = new Timestamp.fromJson(_json["creationTime"]);
|
| + }
|
| + if (_json.containsKey("description")) {
|
| + description = _json["description"];
|
| + }
|
| + if (_json.containsKey("deviceUsageDuration")) {
|
| + deviceUsageDuration = new Duration.fromJson(_json["deviceUsageDuration"]);
|
| + }
|
| + if (_json.containsKey("dimensionValue")) {
|
| + dimensionValue = _json["dimensionValue"].map((value) => new StepDimensionValueEntry.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("hasImages")) {
|
| + hasImages = _json["hasImages"];
|
| + }
|
| + if (_json.containsKey("labels")) {
|
| + labels = _json["labels"].map((value) => new StepLabelsEntry.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("name")) {
|
| + name = _json["name"];
|
| + }
|
| + if (_json.containsKey("outcome")) {
|
| + outcome = new Outcome.fromJson(_json["outcome"]);
|
| + }
|
| + if (_json.containsKey("runDuration")) {
|
| + runDuration = new Duration.fromJson(_json["runDuration"]);
|
| + }
|
| + if (_json.containsKey("state")) {
|
| + state = _json["state"];
|
| + }
|
| + if (_json.containsKey("stepId")) {
|
| + stepId = _json["stepId"];
|
| + }
|
| + if (_json.containsKey("testExecutionStep")) {
|
| + testExecutionStep = new TestExecutionStep.fromJson(_json["testExecutionStep"]);
|
| + }
|
| + if (_json.containsKey("toolExecutionStep")) {
|
| + toolExecutionStep = new ToolExecutionStep.fromJson(_json["toolExecutionStep"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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 (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"];
|
| + }
|
| + if (_json.containsKey("value")) {
|
| + value = _json["value"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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"];
|
| + }
|
| + if (_json.containsKey("value")) {
|
| + value = _json["value"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (key != null) {
|
| + _json["key"] = key;
|
| + }
|
| + if (value != null) {
|
| + _json["value"] = value;
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +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"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (otherNativeCrash != null) {
|
| + _json["otherNativeCrash"] = otherNativeCrash;
|
| + }
|
| + 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"];
|
| + }
|
| + if (_json.containsKey("name")) {
|
| + name = _json["name"];
|
| + }
|
| + if (_json.containsKey("testSuiteName")) {
|
| + testSuiteName = _json["testSuiteName"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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. Next
|
| + * tag: 7
|
| + */
|
| +class TestExecutionStep {
|
| + /**
|
| + * 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("testSuiteOverviews")) {
|
| + testSuiteOverviews = _json["testSuiteOverviews"].map((value) => new TestSuiteOverview.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("testTiming")) {
|
| + testTiming = new TestTiming.fromJson(_json["testTiming"]);
|
| + }
|
| + if (_json.containsKey("toolExecution")) {
|
| + toolExecution = new ToolExecution.fromJson(_json["toolExecution"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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;
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * 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.
|
| + *
|
| + * Next tag: 7
|
| + */
|
| +class TestSuiteOverview {
|
| + /**
|
| + * 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;
|
| + /**
|
| + * 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("errorCount")) {
|
| + errorCount = _json["errorCount"];
|
| + }
|
| + if (_json.containsKey("failureCount")) {
|
| + failureCount = _json["failureCount"];
|
| + }
|
| + if (_json.containsKey("name")) {
|
| + name = _json["name"];
|
| + }
|
| + if (_json.containsKey("skippedCount")) {
|
| + skippedCount = _json["skippedCount"];
|
| + }
|
| + if (_json.containsKey("totalCount")) {
|
| + totalCount = _json["totalCount"];
|
| + }
|
| + if (_json.containsKey("xmlSource")) {
|
| + xmlSource = new FileReference.fromJson(_json["xmlSource"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (errorCount != null) {
|
| + _json["errorCount"] = errorCount;
|
| + }
|
| + if (failureCount != null) {
|
| + _json["failureCount"] = failureCount;
|
| + }
|
| + 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 = new Duration.fromJson(_json["testProcessDuration"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (testProcessDuration != null) {
|
| + _json["testProcessDuration"] = (testProcessDuration).toJson();
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * A single thumbnail, with its size and format.
|
| + *
|
| + * Next tag: 102
|
| + */
|
| +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 {
|
| + return crypto.CryptoUtils.base64StringToBytes(data);
|
| + }
|
| +
|
| + void set dataAsBytes(core.List<core.int> _bytes) {
|
| + data = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
|
| + }
|
| + /**
|
| + * 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"];
|
| + }
|
| + if (_json.containsKey("data")) {
|
| + data = _json["data"];
|
| + }
|
| + if (_json.containsKey("heightPx")) {
|
| + heightPx = _json["heightPx"];
|
| + }
|
| + if (_json.containsKey("widthPx")) {
|
| + widthPx = _json["widthPx"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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
|
| + * calendar, represented as seconds and fractions of seconds at nanosecond
|
| + * resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian
|
| + * Calendar which extends the Gregorian calendar backwards to year one. It is
|
| + * encoded assuming all minutes are 60 seconds long, i.e. leap seconds are
|
| + * "smeared" so that no leap second table is needed for interpretation. 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 date
|
| + * strings. See
|
| + * [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
|
| + *
|
| + * Example 1: Compute Timestamp from POSIX `time()`.
|
| + *
|
| + * Timestamp timestamp; timestamp.set_seconds(time(NULL));
|
| + * timestamp.set_nanos(0);
|
| + *
|
| + * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
|
| + *
|
| + * struct timeval tv; gettimeofday(&tv, NULL);
|
| + *
|
| + * Timestamp timestamp; timestamp.set_seconds(tv.tv_sec);
|
| + * timestamp.set_nanos(tv.tv_usec * 1000);
|
| + *
|
| + * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
|
| + *
|
| + * FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks =
|
| + * (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
| + *
|
| + * // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z //
|
| + * is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp
|
| + * timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) -
|
| + * 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
|
| + *
|
| + * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
|
| + *
|
| + * long millis = System.currentTimeMillis();
|
| + *
|
| + * Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
|
| + * .setNanos((int) ((millis % 1000) * 1000000)).build();
|
| + *
|
| + *
|
| + *
|
| + * Example 5: Compute Timestamp from current time in Python.
|
| + *
|
| + * now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9)
|
| + * timestamp = Timestamp(seconds=seconds, nanos=nanos)
|
| + */
|
| +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 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"];
|
| + }
|
| + if (_json.containsKey("seconds")) {
|
| + seconds = _json["seconds"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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. Next tag: 7
|
| + */
|
| +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"];
|
| + }
|
| + if (_json.containsKey("exitCode")) {
|
| + exitCode = new ToolExitCode.fromJson(_json["exitCode"]);
|
| + }
|
| + if (_json.containsKey("toolLogs")) {
|
| + toolLogs = _json["toolLogs"].map((value) => new FileReference.fromJson(value)).toList();
|
| + }
|
| + if (_json.containsKey("toolOutputs")) {
|
| + toolOutputs = _json["toolOutputs"].map((value) => new ToolOutputReference.fromJson(value)).toList();
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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 = new ToolExecution.fromJson(_json["toolExecution"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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"];
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + 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 = new Timestamp.fromJson(_json["creationTime"]);
|
| + }
|
| + if (_json.containsKey("output")) {
|
| + output = new FileReference.fromJson(_json["output"]);
|
| + }
|
| + if (_json.containsKey("testCase")) {
|
| + testCase = new TestCaseReference.fromJson(_json["testCase"]);
|
| + }
|
| + }
|
| +
|
| + core.Map toJson() {
|
| + var _json = new core.Map();
|
| + if (creationTime != null) {
|
| + _json["creationTime"] = (creationTime).toJson();
|
| + }
|
| + if (output != null) {
|
| + _json["output"] = (output).toJson();
|
| + }
|
| + if (testCase != null) {
|
| + _json["testCase"] = (testCase).toJson();
|
| + }
|
| + return _json;
|
| + }
|
| +}
|
|
|
Chromium Code Reviews
Issue 1797933002:
Api-roll 33: 2016-03-14 (Closed)
Base URL: git@github.com:dart-lang/googleapis.git@master