Api-Roll 53: 2017-08-21

discovery/googleapis_beta/toolresults__v1beta3firstparty.json

 {
     "basePath": "/toolresults/v1beta3firstparty/projects/",
     "baseUrl": "https://www.googleapis.com/toolresults/v1beta3firstparty/projects/",
     "batchPath": "batch",
     "canonicalName": "Tool Results",
     "description": "Reads and publishes results from Firebase Test Lab.",
     "discoveryVersion": "v1",
     "documentationLink": "https://firebase.google.com/docs/test-lab/",
-    "etag": "\"YWOzh2SDasdU84ArJnpYek-OMdg/iLYoOHQx5r8GDcLi8XjG6IPdi_0\"",
+    "etag": "\"YWOzh2SDasdU84ArJnpYek-OMdg/dlMcK_O5qqvy3yxCr-z4e9qy7Xs\"",
     "icons": {
         "x16": "https://www.gstatic.com/images/branding/product/1x/googleg_16dp.png",
         "x32": "https://www.gstatic.com/images/branding/product/1x/googleg_32dp.png"
     },
     "id": "toolresults:v1beta3firstparty",
     "kind": "discovery#restDescription",
     "name": "toolresults",
     "ownerDomain": "google.com",
     "ownerName": "Google",
     "parameters": {
@@ skipping 328 matching lines @@
                                     "path": "{projectId}/histories/{historyId}/executions/{executionId}",
                                     "request": {
                                         "$ref": "Execution"
                                     },
                                     "response": {
                                         "$ref": "Execution"
                                     }
                                 }
                             },
                             "resources": {
+                                "clusters": {
+                                    "methods": {
+                                        "list": {
+                                            "description": "Lists Screenshot Clusters\n\nReturns the list of screenshot clusters corresponding to an execution. Screenshot clusters are created after the execution is finished. Clusters are created from a set of screenshots. Between any two screenshots, a matching score is calculated based off their metadata that determines how similar they are. Screenshots are placed in the cluster that has screens which have the highest matching scores.",
+                                            "httpMethod": "GET",
+                                            "id": "toolresults.projects.histories.executions.clusters.list",
+                                            "parameterOrder": [
+                                                "projectId",
+                                                "historyId",
+                                                "executionId"
+                                            ],
+                                            "parameters": {
+                                                "executionId": {
+                                                    "description": "An Execution id.\n\nRequired.",
+                                                    "location": "path",
+                                                    "required": true,
+                                                    "type": "string"
+                                                },
+                                                "historyId": {
+                                                    "description": "A History id.\n\nRequired.",
+                                                    "location": "path",
+                                                    "required": true,
+                                                    "type": "string"
+                                                },
+                                                "projectId": {
+                                                    "description": "A Project id.\n\nRequired.",
+                                                    "location": "path",
+                                                    "required": true,
+                                                    "type": "string"
+                                                }
+                                            },
+                                            "path": "{projectId}/histories/{historyId}/executions/{executionId}/clusters",
+                                            "response": {
+                                                "$ref": "ListScreenshotClustersResponse"
+                                            }
+                                        }
+                                    }
+                                },
                                 "steps": {
                                     "methods": {
                                         "create": {
                                             "description": "Creates a Step.\n\nThe returned Step will have the id set.\n\nMay return any of the following canonical error codes:\n\n- 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",
                                             "httpMethod": "POST",
                                             "id": "toolresults.projects.histories.executions.steps.create",
                                             "parameterOrder": [
                                                 "projectId",
                                                 "historyId",
                                                 "executionId"
@@ skipping 632 matching lines @@
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     },
-    "revision": "20170727",
+    "revision": "20170818",
     "rootUrl": "https://www.googleapis.com/",
     "schemas": {
+        "AndroidAppInfo": {
+            "description": "Android app information.",
+            "id": "AndroidAppInfo",
+            "properties": {
+                "name": {
+                    "description": "The name of the app. Optional",
+                    "type": "string"
+                },
+                "packageName": {
+                    "description": "The package name of the app. Required.",
+                    "type": "string"
+                },
+                "versionCode": {
+                    "description": "The internal version code of the app. Optional.",
+                    "type": "string"
+                },
+                "versionName": {
+                    "description": "The version name of the app. Optional.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "AndroidInstrumentationTest": {
+            "description": "A test of an Android application that can control an Android component independently of its normal lifecycle.\n\nSee  for more information on types of Android tests.",
+            "id": "AndroidInstrumentationTest",
+            "properties": {
+                "testPackageId": {
+                    "description": "The java package for the test to be executed. Required",
+                    "type": "string"
+                },
+                "testRunnerClass": {
+                    "description": "The InstrumentationTestRunner class. Required",
+                    "type": "string"
+                },
+                "testTargets": {
+                    "description": "Each target must be fully qualified with the package name or class name, in one of these formats: - \"package package_name\" - \"class package_name.class_name\" - \"class package_name.class_name#method_name\"\n\nIf empty, all targets in the module will be run.",
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "useOrchestrator": {
+                    "description": "The flag indicates whether Android Test Orchestrator will be used to run test or not. Test orchestrator is used if either: - orchestrator_option field is USE_ORCHESTRATOR, and test runner is compatible with orchestrator. Or - orchestrator_option field is unspecified or ORCHESTRATOR_OPTION_UNSPECIFIED, and test runner is compatible with orchestrator.",
+                    "type": "boolean"
+                }
+            },
+            "type": "object"
+        },
+        "AndroidRoboTest": {
+            "description": "A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes.",
+            "id": "AndroidRoboTest",
+            "properties": {
+                "appInitialActivity": {
+                    "description": "The initial activity that should be used to start the app. Optional",
+                    "type": "string"
+                },
+                "bootstrapPackageId": {
+                    "description": "The java package for the bootstrap. Optional",
+                    "type": "string"
+                },
+                "bootstrapRunnerClass": {
+                    "description": "The runner class for the bootstrap. Optional",
+                    "type": "string"
+                },
+                "maxDepth": {
+                    "description": "The max depth of the traversal stack Robo can explore. Optional",
+                    "format": "int32",
+                    "type": "integer"
+                },
+                "maxSteps": {
+                    "description": "The max number of steps/actions Robo can execute. Default is no limit (0). Optional",
+                    "format": "int32",
+                    "type": "integer"
+                }
+            },
+            "type": "object"
+        },
+        "AndroidTest": {
+            "description": "An Android mobile test specification.",
+            "id": "AndroidTest",
+            "properties": {
+                "androidAppInfo": {
+                    "$ref": "AndroidAppInfo",
+                    "description": "Infomation about the application under test."
+                },
+                "androidInstrumentationTest": {
+                    "$ref": "AndroidInstrumentationTest",
+                    "description": "An Android instrumentation test."
+                },
+                "androidRoboTest": {
+                    "$ref": "AndroidRoboTest",
+                    "description": "An Android robo test."
+                },
+                "testTimeout": {
+                    "$ref": "Duration",
+                    "description": "Max time a test is allowed to run before it is automatically cancelled."
+                }
+            },
+            "type": "object"
+        },
         "Any": {
             "description": "`Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\nFoo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }\n\nExample 2: Pack and unpack a message in Java.\n\nFoo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); }\n\nExample 3: Pack and unpack a message in Python.\n\nfoo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...\n\nExample 4: Pack and unpack a message in Go\n\nfoo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... }\n\nThe 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\".\n\n\n\nJSON ==== 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:\n\npackage google.profile; message Person { string first_name = 1; string last_name = 2; }\n\n{ \"@type\": \"type.googleapis.com/google.profile.Person\", \"firstName\": , \"lastName\":  }\n\nIf 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][]):\n\n{ \"@type\": \"type.googleapis.com/google.protobuf.Duration\", \"value\": \"1.212s\" }",
             "id": "Any",
             "properties": {
                 "typeUrl": {
                     "description": "A URL/resource name whose content describes the type of the serialized protocol buffer message.\n\nFor URLs which use the scheme `http`, `https`, or no scheme, the following restrictions and interpretations apply:\n\n* If no scheme 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`). The name should be in a canonical form (e.g., leading \".\" is not accepted). * 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.)\n\nSchemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.",
                     "type": "string"
                 },
                 "value": {
                     "description": "Must be a valid serialized protocol buffer of the above specified type.",
@@ skipping 169 matching lines @@
                     "description": "The time when the Execution was created.\n\nThis value will be set automatically when CreateExecution is called.\n\n- In response: always set - In create/update request: never set"
                 },
                 "executionId": {
                     "description": "A unique identifier within a History for this Execution.\n\nReturns INVALID_ARGUMENT if this field is set or overwritten by the caller.\n\n- In response always set - In create/update request: never set",
                     "type": "string"
                 },
                 "outcome": {
                     "$ref": "Outcome",
                     "description": "Classify the result, for example into SUCCESS or FAILURE\n\n- In response: present if set by create/update request - In create/update request: optional"
                 },
+                "specification": {
+                    "$ref": "Specification",
+                    "description": "Lightweight information about execution request.\n\n- In response: present if set by create - In create: optional - In update: optional"
+                },
                 "state": {
                     "description": "The initial state is IN_PROGRESS.\n\nThe only legal state transitions is from IN_PROGRESS to COMPLETE.\n\nA PRECONDITION_FAILED will be returned if an invalid transition is requested.\n\nThe state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.\n\nIf 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.\n\n- In response always set - In create/update request: optional",
                     "enum": [
                         "complete",
                         "inProgress",
                         "pending",
                         "unknownState"
                     ],
                     "enumDescriptions": [
                         "",
@@ skipping 160 matching lines @@
                 },
                 "perfSamples": {
                     "items": {
                         "$ref": "PerfSample"
                     },
                     "type": "array"
                 }
             },
             "type": "object"
         },
+        "ListScreenshotClustersResponse": {
+            "id": "ListScreenshotClustersResponse",
+            "properties": {
+                "clusters": {
+                    "description": "The set of clustres associated with an execution Always set",
+                    "items": {
+                        "$ref": "ScreenshotCluster"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
         "ListStepThumbnailsResponse": {
             "description": "A response containing the thumbnails in a step.",
             "id": "ListStepThumbnailsResponse",
             "properties": {
                 "nextPageToken": {
                     "description": "A continuation token to resume the query at the next item.\n\nIf set, indicates that there are more thumbnails to read, by calling list again with this value in the page_token field.",
                     "type": "string"
                 },
                 "thumbnails": {
                     "description": "A list of image data.\n\nImages 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).",
@@ skipping 215 matching lines @@
                 "xunitXmlFiles": {
                     "description": "URI of the Xunit XML files to publish.\n\nThe maximum size of the file this reference is pointing to is 50MB.\n\nRequired.",
                     "items": {
                         "$ref": "FileReference"
                     },
                     "type": "array"
                 }
             },
             "type": "object"
         },
+        "Screen": {
+            "id": "Screen",
+            "properties": {
+                "fileReference": {
+                    "description": "File reference of the png file. Required.",
+                    "type": "string"
+                },
+                "locale": {
+                    "description": "Locale of the device that the screenshot was taken on. Required.",
+                    "type": "string"
+                },
+                "model": {
+                    "description": "Model of the device that the screenshot was taken on. Required.",
+                    "type": "string"
+                },
+                "version": {
+                    "description": "OS version of the device that the screenshot was taken on. Required.",
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "ScreenshotCluster": {
+            "id": "ScreenshotCluster",
+            "properties": {
+                "activity": {
+                    "description": "A string that describes the activity of every screen in the cluster.",
+                    "type": "string"
+                },
+                "clusterId": {
+                    "description": "A unique identifier for the cluster.",
+                    "type": "string"
+                },
+                "keyScreen": {
+                    "$ref": "Screen",
+                    "description": "A singular screen that represents the cluster as a whole. This screen will act as the \"cover\" of the entire cluster. When users look at the clusters, only the key screen from each cluster will be shown. Which screen is the key screen is determined by the ClusteringAlgorithm"
+                },
+                "screens": {
+                    "description": "Full list of screens.",
+                    "items": {
+                        "$ref": "Screen"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
         "SkippedDetail": {
             "id": "SkippedDetail",
             "properties": {
                 "incompatibleAppVersion": {
                     "description": "If the App doesn't support the specific API level.",
                     "type": "boolean"
                 },
                 "incompatibleArchitecture": {
                     "description": "If the App doesn't run on the specific architecture, for example, x86.",
                     "type": "boolean"
                 },
                 "incompatibleDevice": {
                     "description": "If the requested OS version doesn't run on the specific device model.",
                     "type": "boolean"
                 }
             },
             "type": "object"
         },
+        "Specification": {
+            "description": "The details about how to run the execution.",
+            "id": "Specification",
+            "properties": {
+                "androidTest": {
+                    "$ref": "AndroidTest",
+                    "description": "An Android mobile test execution specification."
+                }
+            },
+            "type": "object"
+        },
         "StackTrace": {
             "description": "A stacktrace.",
             "id": "StackTrace",
             "properties": {
                 "clusterId": {
                     "description": "Exception cluster ID",
                     "type": "string"
                 },
                 "exception": {
                     "description": "The stack trace message.\n\nRequired",
@@ skipping 186 matching lines @@
                     "description": "The timing break down of the test execution.\n\n- In response: present if set by create or update - In create/update request: optional"
                 },
                 "toolExecution": {
                     "$ref": "ToolExecution",
                     "description": "Represents the execution of the test runner.\n\nThe exit code of this tool will be used to determine if the test passed.\n\n- In response: always set - In create/update request: optional"
                 }
             },
             "type": "object"
         },
         "TestIssue": {
-            "description": "An abnormal event observed during the test execution.",
+            "description": "An issue detected occurring during a test execution.",
             "id": "TestIssue",
             "properties": {
                 "errorMessage": {
-                    "description": "A brief human-readable message describing the abnormal event.\n\nRequired.",
+                    "description": "A brief human-readable message describing the issue. Required.",
+                    "type": "string"
+                },
+                "severity": {
+                    "description": "Severity of issue. Required.",
+                    "enum": [
+                        "info",
+                        "severe",
+                        "unspecifiedSeverity",
+                        "warning"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "",
+                        "",
+                        ""
+                    ],
                     "type": "string"
                 },
                 "stackTrace": {
                     "$ref": "StackTrace",
-                    "description": "Optional."
+                    "description": "Deprecated in favor of stack trace fields inside specific warnings."
+                },
+                "type": {
+                    "description": "Type of issue. Required.",
+                    "enum": [
+                        "anr",
+                        "fatalException",
+                        "nativeCrash",
+                        "unspecifiedType"
+                    ],
+                    "enumDescriptions": [
+                        "",
+                        "",
+                        "",
+                        ""
+                    ],
+                    "type": "string"
+                },
+                "warning": {
+                    "$ref": "Any",
+                    "description": "Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings Required."
                 }
             },
             "type": "object"
         },
         "TestSuiteOverview": {
             "description": "A summary of a test suite result either parsed from XML or uploaded directly by a user.\n\nNote: 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.",
             "id": "TestSuiteOverview",
             "properties": {
                 "errorCount": {
                     "description": "Number of test cases in error, typically set by the service by parsing the xml_source.\n\n- In create/response: always set - In update request: never",
@@ skipping 152 matching lines @@
                     "description": "The test case to which this output file belongs.\n\n- In response: present if set by create/update request - In create/update request: optional"
                 }
             },
             "type": "object"
         }
     },
     "servicePath": "toolresults/v1beta3firstparty/projects/",
     "title": "Cloud Tool Results firstparty API",
     "version": "v1beta3firstparty"
 }