/// TestMatrix captures all details about a test. It contains the environment /// configuration, test specification, test executions and overall state and /// outcome. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestMatrix { /// Output only. Unique id set by the service. #[prost(string, tag = "1")] pub test_matrix_id: ::prost::alloc::string::String, /// The cloud project that owns the test matrix. #[prost(string, tag = "7")] pub project_id: ::prost::alloc::string::String, /// Information about the client which invoked the test. #[prost(message, optional, tag = "10")] pub client_info: ::core::option::Option, /// Required. How to run the test. #[prost(message, optional, tag = "3")] pub test_specification: ::core::option::Option, /// Required. The devices the tests are being executed on. #[prost(message, optional, tag = "4")] pub environment_matrix: ::core::option::Option, /// Output only. The list of test executions that the service creates for /// this matrix. #[prost(message, repeated, tag = "5")] pub test_executions: ::prost::alloc::vec::Vec, /// Required. Where the results for the matrix are written. #[prost(message, optional, tag = "6")] pub result_storage: ::core::option::Option, /// Output only. Indicates the current progress of the test matrix. #[prost(enumeration = "TestState", tag = "8")] pub state: i32, /// Output only. The time this test matrix was initially created. #[prost(message, optional, tag = "9")] pub timestamp: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Describes why the matrix is considered invalid. /// Only useful for matrices in the INVALID state. #[prost(enumeration = "InvalidMatrixDetails", tag = "11")] pub invalid_matrix_details: i32, /// The number of times a TestExecution should be re-attempted if one or more /// of its test cases fail for any reason. /// The maximum number of reruns allowed is 10. /// /// Default is 0, which implies no reruns. #[prost(int32, tag = "13")] pub flaky_test_attempts: i32, /// Output Only. The overall outcome of the test. /// Only set when the test matrix state is FINISHED. #[prost(enumeration = "OutcomeSummary", tag = "14")] pub outcome_summary: i32, /// If true, only a single attempt at most will be made to run each /// execution/shard in the matrix. Flaky test attempts are not affected. /// /// Normally, 2 or more attempts are made if a potential infrastructure issue /// is detected. /// /// This feature is for latency sensitive workloads. The incidence of /// execution failures may be significantly greater for fail-fast matrices /// and support is more limited because of that expectation. #[prost(bool, tag = "17")] pub fail_fast: bool, } /// A single test executed in a single environment. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestExecution { /// Output only. Unique id set by the service. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// Output only. Id of the containing TestMatrix. #[prost(string, tag = "9")] pub matrix_id: ::prost::alloc::string::String, /// Output only. The cloud project that owns the test execution. #[prost(string, tag = "10")] pub project_id: ::prost::alloc::string::String, /// Output only. How to run the test. #[prost(message, optional, tag = "3")] pub test_specification: ::core::option::Option, /// Output only. Details about the shard. #[prost(message, optional, tag = "12")] pub shard: ::core::option::Option, /// Output only. How the host machine(s) are configured. #[prost(message, optional, tag = "4")] pub environment: ::core::option::Option, /// Output only. Indicates the current progress of the test execution /// (e.g., FINISHED). #[prost(enumeration = "TestState", tag = "5")] pub state: i32, /// Output only. Where the results for this execution are written. #[prost(message, optional, tag = "11")] pub tool_results_step: ::core::option::Option, /// Output only. The time this test execution was initially created. #[prost(message, optional, tag = "7")] pub timestamp: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Additional details about the running test. #[prost(message, optional, tag = "8")] pub test_details: ::core::option::Option, } /// A description of how to run the test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestSpecification { /// Max time a test execution is allowed to run before it is /// automatically cancelled. /// The default value is 5 min. #[prost(message, optional, tag = "1")] pub test_timeout: ::core::option::Option<::prost_types::Duration>, /// Disables video recording. May reduce test latency. #[prost(bool, tag = "10")] pub disable_video_recording: bool, /// Disables performance metrics recording. May reduce test latency. #[prost(bool, tag = "11")] pub disable_performance_metrics: bool, /// Test setup requirements. #[prost(oneof = "test_specification::Setup", tags = "6, 14")] pub setup: ::core::option::Option, /// Required. The type of test to run. #[prost(oneof = "test_specification::Test", tags = "2, 3, 9, 13, 15")] pub test: ::core::option::Option, } /// Nested message and enum types in `TestSpecification`. pub mod test_specification { /// Test setup requirements. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Setup { /// Test setup requirements for Android e.g. files to install, bootstrap /// scripts. #[prost(message, tag = "6")] TestSetup(super::TestSetup), /// Test setup requirements for iOS. #[prost(message, tag = "14")] IosTestSetup(super::IosTestSetup), } /// Required. The type of test to run. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Test { /// An Android instrumentation test. #[prost(message, tag = "2")] AndroidInstrumentationTest(super::AndroidInstrumentationTest), /// An Android robo test. #[prost(message, tag = "3")] AndroidRoboTest(super::AndroidRoboTest), /// An Android Application with a Test Loop. #[prost(message, tag = "9")] AndroidTestLoop(super::AndroidTestLoop), /// An iOS XCTest, via an .xctestrun file. #[prost(message, tag = "13")] IosXcTest(super::IosXcTest), /// An iOS application with a test loop. #[prost(message, tag = "15")] IosTestLoop(super::IosTestLoop), } } #[derive(Clone, PartialEq, ::prost::Message)] pub struct SystraceSetup { /// Systrace duration in seconds. /// Should be between 1 and 30 seconds. 0 disables systrace. #[prost(int32, tag = "1")] pub duration_seconds: i32, } /// A description of how to set up the Android device prior to running the test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestSetup { /// List of files to push to the device before starting the test. #[prost(message, repeated, tag = "1")] pub files_to_push: ::prost::alloc::vec::Vec, /// List of directories on the device to upload to GCS at the end of the test; /// they must be absolute paths under /sdcard, /storage or /data/local/tmp. /// Path names are restricted to characters a-z A-Z 0-9 _ - . + and / /// /// Note: The paths /sdcard and /data will be made available and treated as /// implicit path substitutions. E.g. if /sdcard on a particular device does /// not map to external storage, the system will replace it with the external /// storage path prefix for that device. #[prost(string, repeated, tag = "2")] pub directories_to_pull: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// APKs to install in addition to those being directly tested. /// Currently capped at 100. #[prost(message, repeated, tag = "3")] pub additional_apks: ::prost::alloc::vec::Vec, /// The device will be logged in on this account for the duration of the test. #[prost(message, optional, tag = "4")] pub account: ::core::option::Option, /// The network traffic profile used for running the test. /// Available network profiles can be queried by using the /// NETWORK_CONFIGURATION environment type when calling /// TestEnvironmentDiscoveryService.GetTestEnvironmentCatalog. #[prost(string, tag = "5")] pub network_profile: ::prost::alloc::string::String, /// Environment variables to set for the test (only applicable for /// instrumentation tests). #[prost(message, repeated, tag = "6")] pub environment_variables: ::prost::alloc::vec::Vec, /// Systrace configuration for the run. /// If set a systrace will be taken, starting on test start and lasting for the /// configured duration. The systrace file thus obtained is put in the results /// bucket together with the other artifacts from the run. #[prost(message, optional, tag = "9")] pub systrace: ::core::option::Option, /// Whether to prevent all runtime permissions to be granted at app install #[prost(bool, tag = "23")] pub dont_autogrant_permissions: bool, } /// A description of how to set up an iOS device prior to running the test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosTestSetup { /// The network traffic profile used for running the test. /// Available network profiles can be queried by using the /// NETWORK_CONFIGURATION environment type when calling /// TestEnvironmentDiscoveryService.GetTestEnvironmentCatalog. #[prost(string, tag = "1")] pub network_profile: ::prost::alloc::string::String, /// iOS apps to install in addition to those being directly tested. #[prost(message, repeated, tag = "2")] pub additional_ipas: ::prost::alloc::vec::Vec, /// List of files to push to the device before starting the test. #[prost(message, repeated, tag = "3")] pub push_files: ::prost::alloc::vec::Vec, /// List of directories on the device to upload to Cloud Storage at the end of /// the test. /// /// Directories should either be in a shared directory /// (e.g. /private/var/mobile/Media) or within an accessible directory inside /// the app's filesystem (e.g. /Documents) by specifying the bundle id. #[prost(message, repeated, tag = "4")] pub pull_directories: ::prost::alloc::vec::Vec, } /// A key-value pair passed as an environment variable to the test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EnvironmentVariable { /// Key for the environment variable. #[prost(string, tag = "1")] pub key: ::prost::alloc::string::String, /// Value for the environment variable. #[prost(string, tag = "2")] pub value: ::prost::alloc::string::String, } /// Identifies an account and how to log into it. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Account { /// Required. The type of account, based what it's for (e.g. Google) and what /// its login mechanism is (e.g. username and password). #[prost(oneof = "account::AccountType", tags = "1")] pub account_type: ::core::option::Option, } /// Nested message and enum types in `Account`. pub mod account { /// Required. The type of account, based what it's for (e.g. Google) and what /// its login mechanism is (e.g. username and password). #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum AccountType { /// An automatic google login account. #[prost(message, tag = "1")] GoogleAuto(super::GoogleAuto), } } /// Enables automatic Google account login. /// If set, the service automatically generates a Google test account and adds /// it to the device, before executing the test. Note that test accounts might be /// reused. /// Many applications show their full set of functionalities when an account is /// present on the device. Logging into the device with these generated accounts /// allows testing more functionalities. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GoogleAuto {} /// An Android package file to install. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Apk { /// The path to an APK to be installed on the device before the test begins. #[prost(message, optional, tag = "1")] pub location: ::core::option::Option, /// The java package for the APK to be installed. /// Value is determined by examining the application's manifest. #[prost(string, tag = "2")] pub package_name: ::prost::alloc::string::String, } /// An Android App Bundle file format, containing a BundleConfig.pb file, /// a base module directory, zero or more dynamic feature module directories. ///

See for guidance on /// building App Bundles. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AppBundle { /// Required. Bundle location information. #[prost(oneof = "app_bundle::Bundle", tags = "1")] pub bundle: ::core::option::Option, } /// Nested message and enum types in `AppBundle`. pub mod app_bundle { /// Required. Bundle location information. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Bundle { /// .aab file representing the app bundle under test. #[prost(message, tag = "1")] BundleLocation(super::FileReference), } } /// A single device file description. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeviceFile { /// Required. #[prost(oneof = "device_file::DeviceFile", tags = "1, 2")] pub device_file: ::core::option::Option, } /// Nested message and enum types in `DeviceFile`. pub mod device_file { /// Required. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum DeviceFile { /// A reference to an opaque binary blob file. #[prost(message, tag = "1")] ObbFile(super::ObbFile), /// A reference to a regular file. #[prost(message, tag = "2")] RegularFile(super::RegularFile), } } /// An opaque binary blob file to install on the device before the test starts. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ObbFile { /// Required. OBB file name which must conform to the format as specified by /// Android /// e.g. \[main|patch\].0300110.com.example.android.obb /// which will be installed into /// \/Android/obb/\/ /// on the device. #[prost(string, tag = "1")] pub obb_file_name: ::prost::alloc::string::String, /// Required. Opaque Binary Blob (OBB) file(s) to install on the device. #[prost(message, optional, tag = "2")] pub obb: ::core::option::Option, } /// A file or directory to install on the device before the test starts. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RegularFile { /// Required. The source file. #[prost(message, optional, tag = "1")] pub content: ::core::option::Option, /// Required. Where to put the content on the device. Must be an absolute, /// allowlisted path. If the file exists, it will be replaced. /// The following device-side directories and any of their subdirectories are /// allowlisted: ///

${EXTERNAL_STORAGE}, /sdcard, or /storage

///

${ANDROID_DATA}/local/tmp, or /data/local/tmp

///

Specifying a path outside of these directory trees is invalid. /// ///

The paths /sdcard and /data will be made available and treated as /// implicit path substitutions. E.g. if /sdcard on a particular device does /// not map to external storage, the system will replace it with the external /// storage path prefix for that device and copy the file there. /// ///

It is strongly advised to use the > /// Environment API in app and test code to access files on the device in a /// portable way. #[prost(string, tag = "2")] pub device_path: ::prost::alloc::string::String, } /// A file or directory to install on the device before the test starts. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosDeviceFile { /// The source file #[prost(message, optional, tag = "1")] pub content: ::core::option::Option, /// The bundle id of the app where this file lives. /// /// iOS apps sandbox their own filesystem, so app files must specify which app /// installed on the device. #[prost(string, tag = "2")] pub bundle_id: ::prost::alloc::string::String, /// Location of the file on the device, inside the app's sandboxed filesystem #[prost(string, tag = "3")] pub device_path: ::prost::alloc::string::String, } /// A test of an Android Application with a Test Loop. /// The intent \ will be implicitly added, since Games is the only /// user of this api, for the time being. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidTestLoop { /// The java package for the application under test. /// The default is determined by examining the application's manifest. #[prost(string, tag = "2")] pub app_package_id: ::prost::alloc::string::String, /// The list of scenarios that should be run during the test. /// The default is all test loops, derived from the application's /// manifest. #[prost(int32, repeated, tag = "3")] pub scenarios: ::prost::alloc::vec::Vec, /// The list of scenario labels that should be run during the test. /// The scenario labels should map to labels defined in the application's /// manifest. For example, player_experience and /// com.google.test.loops.player_experience add all of the loops labeled in the /// manifest with the com.google.test.loops.player_experience name to the /// execution. /// Scenarios can also be specified in the scenarios field. #[prost(string, repeated, tag = "4")] pub scenario_labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Required. The Android package to test. #[prost(oneof = "android_test_loop::AppUnderTest", tags = "1, 5")] pub app_under_test: ::core::option::Option, } /// Nested message and enum types in `AndroidTestLoop`. pub mod android_test_loop { /// Required. The Android package to test. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum AppUnderTest { /// The APK for the application under test. #[prost(message, tag = "1")] AppApk(super::FileReference), /// A multi-apk app bundle for the application under test. #[prost(message, tag = "5")] AppBundle(super::AppBundle), } } /// A test of an iOS application that uses the XCTest framework. /// Xcode supports the option to "build for testing", which generates an /// .xctestrun file that contains a test specification (arguments, test methods, /// etc). This test type accepts a zip file containing the .xctestrun file and /// the corresponding contents of the Build/Products directory that contains all /// the binaries needed to run the tests. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosXcTest { /// Required. The .zip containing the .xctestrun file and the contents of the /// DerivedData/Build/Products directory. /// The .xctestrun file in this zip is ignored if the xctestrun field is /// specified. #[prost(message, optional, tag = "1")] pub tests_zip: ::core::option::Option, /// An .xctestrun file that will override the .xctestrun file in the /// tests zip. Because the .xctestrun file contains environment variables along /// with test methods to run and/or ignore, this can be useful for sharding /// tests. Default is taken from the tests zip. #[prost(message, optional, tag = "2")] pub xctestrun: ::core::option::Option, /// The Xcode version that should be used for the test. /// Use the TestEnvironmentDiscoveryService to get supported options. /// Defaults to the latest Xcode version Firebase Test Lab supports. #[prost(string, tag = "3")] pub xcode_version: ::prost::alloc::string::String, /// Output only. The bundle id for the application under test. #[prost(string, tag = "4")] pub app_bundle_id: ::prost::alloc::string::String, /// The option to test special app entitlements. Setting this would re-sign the /// app having special entitlements with an explicit application-identifier. /// Currently supports testing aps-environment entitlement. #[prost(bool, tag = "6")] pub test_special_entitlements: bool, } /// A test of an iOS application that implements one or more game loop scenarios. /// This test type accepts an archived application (.ipa file) and a list of /// integer scenarios that will be executed on the app sequentially. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosTestLoop { /// Required. The .ipa of the application to test. #[prost(message, optional, tag = "1")] pub app_ipa: ::core::option::Option, /// The list of scenarios that should be run during the test. Defaults to the /// single scenario 0 if unspecified. #[prost(int32, repeated, tag = "2")] pub scenarios: ::prost::alloc::vec::Vec, /// Output only. The bundle id for the application under test. #[prost(string, tag = "3")] pub app_bundle_id: ::prost::alloc::string::String, } /// A test of an Android application that can control an Android component /// independently of its normal lifecycle. /// Android instrumentation tests run an application APK and test APK inside the /// same process on a virtual or physical AndroidDevice. They also specify /// a test runner class, such as com.google.GoogleTestRunner, which can vary /// on the specific instrumentation framework chosen. /// /// See <> for /// more information on types of Android tests. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidInstrumentationTest { /// Required. The APK containing the test code to be executed. #[prost(message, optional, tag = "2")] pub test_apk: ::core::option::Option, /// The java package for the application under test. /// The default value is determined by examining the application's manifest. #[prost(string, tag = "3")] pub app_package_id: ::prost::alloc::string::String, /// The java package for the test to be executed. /// The default value is determined by examining the application's manifest. #[prost(string, tag = "4")] pub test_package_id: ::prost::alloc::string::String, /// The InstrumentationTestRunner class. /// The default value is determined by examining the application's manifest. #[prost(string, tag = "5")] pub test_runner_class: ::prost::alloc::string::String, /// Each target must be fully qualified with the package name or class name, /// in one of these formats: /// - "package package_name" /// - "class package_name.class_name" /// - "class package_name.class_name#method_name" /// /// If empty, all targets in the module will be run. #[prost(string, repeated, tag = "6")] pub test_targets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The option of whether running each test within its own invocation of /// instrumentation with Android Test Orchestrator or not. /// ** Orchestrator is only compatible with AndroidJUnitRunner version 1.0 or /// higher! ** /// Orchestrator offers the following benefits: /// - No shared state /// - Crashes are isolated /// - Logs are scoped per test /// /// See /// <> /// for more information about Android Test Orchestrator. /// /// If not set, the test will be run without the orchestrator. #[prost(enumeration = "OrchestratorOption", tag = "7")] pub orchestrator_option: i32, /// The option to run tests in multiple shards in parallel. #[prost(message, optional, tag = "9")] pub sharding_option: ::core::option::Option, /// Required. #[prost(oneof = "android_instrumentation_test::AppUnderTest", tags = "1, 8")] pub app_under_test: ::core::option::Option, } /// Nested message and enum types in `AndroidInstrumentationTest`. pub mod android_instrumentation_test { /// Required. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum AppUnderTest { /// The APK for the application under test. #[prost(message, tag = "1")] AppApk(super::FileReference), /// A multi-apk app bundle for the application under test. #[prost(message, tag = "8")] AppBundle(super::AppBundle), } } /// A test of an android application that explores the application on a virtual /// or physical Android Device, finding culprits and crashes as it goes. /// Next tag: 30 #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidRoboTest { /// The java package for the application under test. /// The default value is determined by examining the application's manifest. #[prost(string, tag = "2")] pub app_package_id: ::prost::alloc::string::String, /// The initial activity that should be used to start the app. #[prost(string, tag = "3")] pub app_initial_activity: ::prost::alloc::string::String, /// The max depth of the traversal stack Robo can explore. Needs to be at least /// 2 to make Robo explore the app beyond the first activity. /// Default is 50. #[deprecated] #[prost(int32, tag = "7")] pub max_depth: i32, /// The max number of steps Robo can execute. /// Default is no limit. #[deprecated] #[prost(int32, tag = "8")] pub max_steps: i32, /// A set of directives Robo should apply during the crawl. /// This allows users to customize the crawl. For example, the username and /// password for a test account can be provided. #[prost(message, repeated, tag = "11")] pub robo_directives: ::prost::alloc::vec::Vec, /// A JSON file with a sequence of actions Robo should perform as a prologue /// for the crawl. #[prost(message, optional, tag = "13")] pub robo_script: ::core::option::Option, /// The intents used to launch the app for the crawl. /// If none are provided, then the main launcher activity is launched. /// If some are provided, then only those provided are launched (the main /// launcher activity must be provided explicitly). #[prost(message, repeated, tag = "15")] pub starting_intents: ::prost::alloc::vec::Vec, /// Required. #[prost(oneof = "android_robo_test::AppUnderTest", tags = "1, 16")] pub app_under_test: ::core::option::Option, } /// Nested message and enum types in `AndroidRoboTest`. pub mod android_robo_test { /// Required. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum AppUnderTest { /// The APK for the application under test. #[prost(message, tag = "1")] AppApk(super::FileReference), /// A multi-apk app bundle for the application under test. #[prost(message, tag = "16")] AppBundle(super::AppBundle), } } /// Directs Robo to interact with a specific UI element if it is encountered /// during the crawl. Currently, Robo can perform text entry or element click. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RoboDirective { /// Required. The android resource name of the target UI element. /// For example, /// in Java: R.string.foo /// in xml: @string/foo /// Only the "foo" part is needed. /// Reference doc: /// #[prost(string, tag = "1")] pub resource_name: ::prost::alloc::string::String, /// The text that Robo is directed to set. If left empty, the directive will be /// treated as a CLICK on the element matching the resource_name. #[prost(string, tag = "2")] pub input_text: ::prost::alloc::string::String, /// Required. The type of action that Robo should perform on the specified /// element. #[prost(enumeration = "RoboActionType", tag = "3")] pub action_type: i32, } /// Message for specifying the start activities to crawl. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RoboStartingIntent { /// Timeout in seconds for each intent. #[prost(message, optional, tag = "3")] pub timeout: ::core::option::Option<::prost_types::Duration>, /// Required. Intent details to start an activity. #[prost(oneof = "robo_starting_intent::StartingIntent", tags = "1, 2")] pub starting_intent: ::core::option::Option, } /// Nested message and enum types in `RoboStartingIntent`. pub mod robo_starting_intent { /// Required. Intent details to start an activity. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum StartingIntent { /// An intent that starts the main launcher activity. #[prost(message, tag = "1")] LauncherActivity(super::LauncherActivityIntent), /// An intent that starts an activity with specific details. #[prost(message, tag = "2")] StartActivity(super::StartActivityIntent), } } /// Specifies an intent that starts the main launcher activity. #[derive(Clone, PartialEq, ::prost::Message)] pub struct LauncherActivityIntent {} /// A starting intent specified by an action, uri, and categories. #[derive(Clone, PartialEq, ::prost::Message)] pub struct StartActivityIntent { /// Action name. /// Required for START_ACTIVITY. #[prost(string, tag = "2")] pub action: ::prost::alloc::string::String, /// URI for the action. #[prost(string, tag = "3")] pub uri: ::prost::alloc::string::String, /// Intent categories to set on the intent. #[prost(string, repeated, tag = "4")] pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// The matrix of environments in which the test is to be executed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct EnvironmentMatrix { /// Required. The environment matrix. #[prost(oneof = "environment_matrix::EnvironmentMatrix", tags = "1, 2, 3")] pub environment_matrix: ::core::option::Option, } /// Nested message and enum types in `EnvironmentMatrix`. pub mod environment_matrix { /// Required. The environment matrix. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum EnvironmentMatrix { /// A matrix of Android devices. #[prost(message, tag = "1")] AndroidMatrix(super::AndroidMatrix), /// A list of Android devices; the test will be run only on the specified /// devices. #[prost(message, tag = "2")] AndroidDeviceList(super::AndroidDeviceList), /// A list of iOS devices. #[prost(message, tag = "3")] IosDeviceList(super::IosDeviceList), } } /// A list of Android device configurations in which the test is to be executed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidDeviceList { /// Required. A list of Android devices. #[prost(message, repeated, tag = "1")] pub android_devices: ::prost::alloc::vec::Vec, } /// A list of iOS device configurations in which the test is to be executed. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosDeviceList { /// Required. A list of iOS devices. #[prost(message, repeated, tag = "1")] pub ios_devices: ::prost::alloc::vec::Vec, } /// A set of Android device configuration permutations is defined by the /// the cross-product of the given axes. Internally, the given AndroidMatrix /// will be expanded into a set of AndroidDevices. /// /// Only supported permutations will be instantiated. Invalid permutations /// (e.g., incompatible models/versions) are ignored. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidMatrix { /// Required. The ids of the set of Android device to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, repeated, tag = "1")] pub android_model_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Required. The ids of the set of Android OS version to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, repeated, tag = "2")] pub android_version_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Required. The set of locales the test device will enable for testing. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, repeated, tag = "3")] pub locales: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Required. The set of orientations to test with. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, repeated, tag = "4")] pub orientations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Information about the client which invoked the test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ClientInfo { /// Required. Client name, such as gcloud. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The list of detailed information about client. #[prost(message, repeated, tag = "2")] pub client_info_details: ::prost::alloc::vec::Vec, } /// Key-value pair of detailed information about the client which invoked the /// test. Examples: {'Version', '1.0'}, {'Release Track', 'BETA'}. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ClientInfoDetail { /// Required. The key of detailed client information. #[prost(string, tag = "1")] pub key: ::prost::alloc::string::String, /// Required. The value of detailed client information. #[prost(string, tag = "2")] pub value: ::prost::alloc::string::String, } /// Locations where the results of running the test are stored. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResultStorage { /// Required. #[prost(message, optional, tag = "1")] pub google_cloud_storage: ::core::option::Option, /// The tool results history that contains the tool results execution that /// results are written to. /// /// If not provided, the service will choose an appropriate value. #[prost(message, optional, tag = "5")] pub tool_results_history: ::core::option::Option, /// Output only. The tool results execution that results are written to. #[prost(message, optional, tag = "6")] pub tool_results_execution: ::core::option::Option, /// Output only. URL to the results in the Firebase Web Console. #[prost(string, tag = "7")] pub results_url: ::prost::alloc::string::String, } /// Represents a tool results history resource. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ToolResultsHistory { /// Required. The cloud project that owns the tool results history. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// Required. A tool results history ID. #[prost(string, tag = "2")] pub history_id: ::prost::alloc::string::String, } /// Represents a tool results execution resource. /// /// This has the results of a TestMatrix. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ToolResultsExecution { /// Output only. The cloud project that owns the tool results execution. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// Output only. A tool results history ID. #[prost(string, tag = "2")] pub history_id: ::prost::alloc::string::String, /// Output only. A tool results execution ID. #[prost(string, tag = "3")] pub execution_id: ::prost::alloc::string::String, } /// Represents a tool results step resource. /// /// This has the results of a TestExecution. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ToolResultsStep { /// Output only. The cloud project that owns the tool results step. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// Output only. A tool results history ID. #[prost(string, tag = "2")] pub history_id: ::prost::alloc::string::String, /// Output only. A tool results execution ID. #[prost(string, tag = "3")] pub execution_id: ::prost::alloc::string::String, /// Output only. A tool results step ID. #[prost(string, tag = "4")] pub step_id: ::prost::alloc::string::String, } /// A storage location within Google cloud storage (GCS). #[derive(Clone, PartialEq, ::prost::Message)] pub struct GoogleCloudStorage { /// Required. The path to a directory in GCS that will /// eventually contain the results for this test. /// The requesting user must have write access on the bucket in the supplied /// path. #[prost(string, tag = "1")] pub gcs_path: ::prost::alloc::string::String, } /// A reference to a file, used for user inputs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FileReference { /// Required. The file reference. #[prost(oneof = "file_reference::File", tags = "1")] pub file: ::core::option::Option, } /// Nested message and enum types in `FileReference`. pub mod file_reference { /// Required. The file reference. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum File { /// A path to a file in Google Cloud Storage. /// Example: gs://build-app-1414623860166/app%40debug-unaligned.apk /// These paths are expected to be url encoded (percent encoding) #[prost(string, tag = "1")] GcsPath(::prost::alloc::string::String), } } /// The environment in which the test is run. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Environment { /// Required. The environment. #[prost(oneof = "environment::Environment", tags = "1, 2")] pub environment: ::core::option::Option, } /// Nested message and enum types in `Environment`. pub mod environment { /// Required. The environment. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Environment { /// An Android device which must be used with an Android test. #[prost(message, tag = "1")] AndroidDevice(super::AndroidDevice), /// An iOS device which must be used with an iOS test. #[prost(message, tag = "2")] IosDevice(super::IosDevice), } } /// A single Android device. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidDevice { /// Required. The id of the Android device to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "1")] pub android_model_id: ::prost::alloc::string::String, /// Required. The id of the Android OS version to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "2")] pub android_version_id: ::prost::alloc::string::String, /// Required. The locale the test device used for testing. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "3")] pub locale: ::prost::alloc::string::String, /// Required. How the device is oriented during the test. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "4")] pub orientation: ::prost::alloc::string::String, } /// A single iOS device. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosDevice { /// Required. The id of the iOS device to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "1")] pub ios_model_id: ::prost::alloc::string::String, /// Required. The id of the iOS major software version to be used. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "2")] pub ios_version_id: ::prost::alloc::string::String, /// Required. The locale the test device used for testing. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "3")] pub locale: ::prost::alloc::string::String, /// Required. How the device is oriented during the test. /// Use the TestEnvironmentDiscoveryService to get supported options. #[prost(string, tag = "4")] pub orientation: ::prost::alloc::string::String, } /// Additional details about the progress of the running test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestDetails { /// Output only. Human-readable, detailed descriptions of the test's progress. /// For example: "Provisioning a device", "Starting Test". /// /// During the course of execution new data may be appended /// to the end of progress_messages. #[prost(string, repeated, tag = "3")] pub progress_messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Output only. If the TestState is ERROR, then this string will contain /// human-readable details about the error. #[prost(string, tag = "4")] pub error_message: ::prost::alloc::string::String, } /// Details behind an invalid request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct InvalidRequestDetail { /// The reason behind the error. #[prost(enumeration = "invalid_request_detail::Reason", tag = "1")] pub reason: i32, } /// Nested message and enum types in `InvalidRequestDetail`. pub mod invalid_request_detail { /// Possible invalid request reasons. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Reason { /// No reason has been specified - the default. Unspecified = 0, /// The request is not valid. RequestInvalid = 1, /// One or more of the resources specified in the request is too large. ResourceTooBig = 2, /// One or more resources specified in the request cannot be found. ResourceNotFound = 3, /// This request is not (currently) supported. Unsupported = 4, /// This request is not currently implemented. NotImplemented = 5, } } /// Options for enabling sharding. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ShardingOption { #[prost(oneof = "sharding_option::Option", tags = "1, 2")] pub option: ::core::option::Option, } /// Nested message and enum types in `ShardingOption`. pub mod sharding_option { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Option { /// Uniformly shards test cases given a total number of shards. #[prost(message, tag = "1")] UniformSharding(super::UniformSharding), /// Shards test cases into the specified groups of packages, classes, and/or /// methods. #[prost(message, tag = "2")] ManualSharding(super::ManualSharding), } } /// Uniformly shards test cases given a total number of shards. /// /// For Instrumentation test, it will be translated to "-e numShard" "-e /// shardIndex" AndroidJUnitRunner arguments. With uniform sharding enabled, /// specifying these sharding arguments via environment_variables is invalid. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UniformSharding { /// Required. Total number of shards. When any physical devices are selected, /// the number must be >= 1 and <= 50. When no physical devices are selected, /// the number must be >= 1 and <= 500. #[prost(int32, tag = "1")] pub num_shards: i32, } /// Shards test cases into the specified groups of packages, classes, and/or /// methods. /// /// With manual sharding enabled, specifying test targets via /// environment_variables or in InstrumentationTest is invalid. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ManualSharding { /// Required. Group of packages, classes, and/or test methods to be run for /// each shard. When any physical devices are selected, the number of /// test_targets_for_shard must be >= 1 and <= 50. When no physical devices are /// selected, the number must be >= 1 and <= 500. #[prost(message, repeated, tag = "1")] pub test_targets_for_shard: ::prost::alloc::vec::Vec, } /// Test targets for a shard. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestTargetsForShard { /// Group of packages, classes, and/or test methods to be run for each shard. /// The targets need to be specified in AndroidJUnitRunner argument format. For /// example, "package com.my.packages" "class com.my.package.MyClass". /// /// The number of shard_test_targets must be greater than 0. #[prost(string, repeated, tag = "1")] pub test_targets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Output only. Details about the shard. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Shard { /// Output only. The index of the shard among all the shards. #[prost(int32, tag = "1")] pub shard_index: i32, /// Output only. The total number of shards. #[prost(int32, tag = "2")] pub num_shards: i32, /// Output only. Test targets for each shard. #[prost(message, optional, tag = "3")] pub test_targets_for_shard: ::core::option::Option, } /// Request to submit a matrix of tests for execution. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateTestMatrixRequest { /// The GCE project under which this job will run. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// The matrix of tests that the user wants to run. #[prost(message, optional, tag = "2")] pub test_matrix: ::core::option::Option, /// A string id used to detect duplicated requests. /// Ids are automatically scoped to a project, so /// users should ensure the ID is unique per-project. /// A UUID is recommended. /// /// Optional, but strongly recommended. #[prost(string, tag = "3")] pub request_id: ::prost::alloc::string::String, } /// Request to get the Test Matrix with the given id. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetTestMatrixRequest { /// Cloud project that owns the test matrix. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// Unique test matrix id which was assigned by the service. #[prost(string, tag = "2")] pub test_matrix_id: ::prost::alloc::string::String, } /// Request to stop running all of the tests in the specified matrix. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelTestMatrixRequest { /// Cloud project that owns the test. #[prost(string, tag = "1")] pub project_id: ::prost::alloc::string::String, /// Test matrix that will be canceled. #[prost(string, tag = "2")] pub test_matrix_id: ::prost::alloc::string::String, } /// Response containing the current state of the specified test matrix. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelTestMatrixResponse { /// The current rolled-up state of the test matrix. /// If this state is already final, then the cancelation request will /// have no effect. #[prost(enumeration = "TestState", tag = "1")] pub test_state: i32, } /// Specifies how to execute the test. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum OrchestratorOption { /// Default value: the server will choose the mode. Currently implies that /// the test will run without the orchestrator. In the future, /// all instrumentation tests will be run with the orchestrator. /// Using the orchestrator is highly encouraged because of all the benefits it /// offers. Unspecified = 0, /// Run test using orchestrator. /// ** Only compatible with AndroidJUnitRunner version 1.0 or higher! ** /// Recommended. UseOrchestrator = 1, /// Run test without using orchestrator. DoNotUseOrchestrator = 2, } /// Actions which Robo can perform on UI elements. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RoboActionType { /// DO NOT USE. For proto versioning only. ActionTypeUnspecified = 0, /// Direct Robo to click on the specified element. No-op if specified element /// is not clickable. SingleClick = 1, /// Direct Robo to enter text on the specified element. No-op if specified /// element is not enabled or does not allow text entry. EnterText = 2, /// Direct Robo to ignore interactions with a specific element. Ignore = 3, } /// The detailed reason that a Matrix was deemed INVALID. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum InvalidMatrixDetails { /// Do not use. For proto versioning only. Unspecified = 0, /// The matrix is INVALID, but there are no further details available. DetailsUnavailable = 1, /// The input app APK could not be parsed. MalformedApk = 2, /// The input test APK could not be parsed. MalformedTestApk = 3, /// The AndroidManifest.xml could not be found. NoManifest = 4, /// The APK manifest does not declare a package name. NoPackageName = 5, /// The APK application ID (aka package name) is invalid. /// See also /// InvalidPackageName = 31, /// The test package and app package are the same. TestSameAsApp = 6, /// The test apk does not declare an instrumentation. NoInstrumentation = 7, /// The input app apk does not have a signature. NoSignature = 20, /// The test runner class specified by user or in the test APK's manifest file /// is not compatible with Android Test Orchestrator. /// Orchestrator is only compatible with AndroidJUnitRunner version 1.0 or /// higher. /// Orchestrator can be disabled by using DO_NOT_USE_ORCHESTRATOR /// OrchestratorOption. InstrumentationOrchestratorIncompatible = 18, /// The test APK does not contain the test runner class specified by user or in /// the manifest file. /// This can be caused by either of the following reasons: /// - the user provided a runner class name that's incorrect, or /// - the test runner isn't built into the test APK (might be in the app APK /// instead). NoTestRunnerClass = 19, /// A main launcher activity could not be found. NoLauncherActivity = 8, /// The app declares one or more permissions that are not allowed. ForbiddenPermissions = 9, /// There is a conflict in the provided robo_directives. InvalidRoboDirectives = 10, /// There is at least one invalid resource name in the provided /// robo directives InvalidResourceName = 33, /// Invalid definition of action in the robo directives /// (e.g. a click or ignore action includes an input text field) InvalidDirectiveAction = 34, /// There is no test loop intent filter, or the one that is given is /// not formatted correctly. TestLoopIntentFilterNotFound = 12, /// The request contains a scenario label that was not declared in the /// manifest. ScenarioLabelNotDeclared = 13, /// There was an error when parsing a label's value. ScenarioLabelMalformed = 14, /// The request contains a scenario number that was not declared in the /// manifest. ScenarioNotDeclared = 15, /// Device administrator applications are not allowed. DeviceAdminReceiver = 17, /// The zipped XCTest was malformed. The zip did not contain a single /// .xctestrun file and the contents of the DerivedData/Build/Products /// directory. MalformedXcTestZip = 11, /// The zipped XCTest was built for the iOS simulator rather than for a /// physical device. BuiltForIosSimulator = 24, /// The .xctestrun file did not specify any test targets. NoTestsInXcTestZip = 25, /// One or more of the test targets defined in the .xctestrun file specifies /// "UseDestinationArtifacts", which is disallowed. UseDestinationArtifacts = 26, /// XC tests which run on physical devices must have /// "IsAppHostedTestBundle" == "true" in the xctestrun file. TestNotAppHosted = 28, /// An Info.plist file in the XCTest zip could not be parsed. PlistCannotBeParsed = 30, /// The APK is marked as "testOnly". /// Deprecated and not currently used. TestOnlyApk = 21, /// The input IPA could not be parsed. MalformedIpa = 22, /// The application doesn't register the game loop URL scheme. MissingUrlScheme = 35, /// The iOS application bundle (.app) couldn't be processed. MalformedAppBundle = 36, /// APK contains no code. /// See also /// NoCodeApk = 23, /// Either the provided input APK path was malformed, /// the APK file does not exist, or the user does not have permission to /// access the APK file. InvalidInputApk = 27, /// APK is built for a preview SDK which is unsupported InvalidApkPreviewSdk = 29, } /// The state (i.e., progress) of a test execution or matrix. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum TestState { /// Do not use. For proto versioning only. Unspecified = 0, /// The execution or matrix is being validated. Validating = 8, /// The execution or matrix is waiting for resources to become available. Pending = 1, /// The execution is currently being processed. /// /// Can only be set on an execution. Running = 2, /// The execution or matrix has terminated normally. /// /// On a matrix this means that the matrix level processing completed normally, /// but individual executions may be in an ERROR state. Finished = 3, /// The execution or matrix has stopped because it encountered an /// infrastructure failure. Error = 4, /// The execution was not run because it corresponds to a unsupported /// environment. /// /// Can only be set on an execution. UnsupportedEnvironment = 5, /// The execution was not run because the provided inputs are incompatible with /// the requested environment. /// /// Example: requested AndroidVersion is lower than APK's minSdkVersion /// /// Can only be set on an execution. IncompatibleEnvironment = 9, /// The execution was not run because the provided inputs are incompatible with /// the requested architecture. /// /// Example: requested device does not support running the native code in /// the supplied APK /// /// Can only be set on an execution. IncompatibleArchitecture = 10, /// The user cancelled the execution. /// /// Can only be set on an execution. Cancelled = 6, /// The execution or matrix was not run because the provided inputs are not /// valid. /// /// Examples: input file is not of the expected type, is malformed/corrupt, or /// was flagged as malware Invalid = 7, } /// Outcome summary for a finished test matrix. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum OutcomeSummary { /// Do not use. For proto versioning only. Unspecified = 0, /// The test matrix run was successful, for instance: /// - All the test cases passed. /// - Robo did not detect a crash of the application under test. Success = 1, /// A run failed, for instance: /// - One or more test case failed. /// - A test timed out. /// - The application under test crashed. Failure = 2, /// Something unexpected happened. The run should still be considered /// unsuccessful but this is likely a transient problem and re-running the /// test might be successful. Inconclusive = 3, /// All tests were skipped, for instance: /// - All device configurations were incompatible. Skipped = 4, } #[doc = r" Generated client implementations."] pub mod test_execution_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " A service for requesting test executions and querying their status."] #[doc = ""] #[doc = " This service is part of Firebase Test Lab. To learn about how to use the"] #[doc = " product, and how to integrate it with your system,"] #[doc = " visit https://firebase.google.com/docs/test-lab."] #[doc = ""] #[doc = " Each test execution will wait for available capacity. It will then be"] #[doc = " invoked as described. The test may be invoked multiple times if an"] #[doc = " infrastructure failure is detected. Results and other files generated by"] #[doc = " the test will be stored in an external storage system."] #[doc = ""] #[doc = " The TestExecutionService models this behavior using two resource types:"] #[doc = ""] #[doc = " - TestMatrix: a group of one or more TestExecutions, built by taking a"] #[doc = " product of values over a pre-defined set of axes. In the case of Android"] #[doc = " Tests, for example, device model and OS version are two axes of the matrix."] #[doc = ""] #[doc = " - TestExecution: a single execution of one or more test targets on a"] #[doc = " single device. These are created automatically when a TestMatrix is"] #[doc = " created."] #[doc = ""] #[doc = " This service returns any error codes from the canonical error space (i.e."] #[doc = " google.rpc.Code). The errors which may be returned are specified on each"] #[doc = " method. In addition, any method may return UNAVAILABLE or INTERNAL."] #[derive(Debug, Clone)] pub struct TestExecutionServiceClient { inner: tonic::client::Grpc, } impl TestExecutionServiceClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> TestExecutionServiceClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { TestExecutionServiceClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Creates and runs a matrix of tests according to the given specifications."] #[doc = " Unsupported environments will be returned in the state UNSUPPORTED."] #[doc = " A test matrix is limited to use at most 2000 devices in parallel."] #[doc = ""] #[doc = " May return any of the following canonical error codes:"] #[doc = ""] #[doc = " - PERMISSION_DENIED - if the user is not authorized to write to project"] #[doc = " - INVALID_ARGUMENT - if the request is malformed or if the matrix tries"] #[doc = " to use too many simultaneous devices."] pub async fn create_test_matrix( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.devtools.testing.v1.TestExecutionService/CreateTestMatrix", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Checks the status of a test matrix."] #[doc = ""] #[doc = " May return any of the following canonical error codes:"] #[doc = ""] #[doc = " - PERMISSION_DENIED - if the user is not authorized to read project"] #[doc = " - INVALID_ARGUMENT - if the request is malformed"] #[doc = " - NOT_FOUND - if the Test Matrix does not exist"] pub async fn get_test_matrix( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.devtools.testing.v1.TestExecutionService/GetTestMatrix", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Cancels unfinished test executions in a test matrix."] #[doc = " This call returns immediately and cancellation proceeds asynchronously."] #[doc = " If the matrix is already final, this operation will have no effect."] #[doc = ""] #[doc = " May return any of the following canonical error codes:"] #[doc = ""] #[doc = " - PERMISSION_DENIED - if the user is not authorized to read project"] #[doc = " - INVALID_ARGUMENT - if the request is malformed"] #[doc = " - NOT_FOUND - if the Test Matrix does not exist"] pub async fn cancel_test_matrix( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.devtools.testing.v1.TestExecutionService/CancelTestMatrix", ); self.inner.unary(request.into_request(), path, codec).await } } } /// Android application details based on application manifest and apk archive /// contents. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ApkDetail { #[prost(message, optional, tag = "1")] pub apk_manifest: ::core::option::Option, } /// An Android app manifest. See /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct ApkManifest { /// Full Java-style package name for this application, e.g. /// "com.example.foo". #[prost(string, tag = "1")] pub package_name: ::prost::alloc::string::String, /// Minimum API level required for the application to run. #[prost(int32, tag = "2")] pub min_sdk_version: i32, /// Maximum API level on which the application is designed to run. #[prost(int32, tag = "3")] pub max_sdk_version: i32, /// Specifies the API Level on which the application is designed to run. #[prost(int32, tag = "6")] pub target_sdk_version: i32, /// User-readable name for the application. #[prost(string, tag = "4")] pub application_label: ::prost::alloc::string::String, #[prost(message, repeated, tag = "5")] pub intent_filters: ::prost::alloc::vec::Vec, /// Permissions declared to be used by the application #[prost(string, repeated, tag = "7")] pub uses_permission: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// The section of an tag. /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct IntentFilter { /// The android:name value of the tag. #[prost(string, repeated, tag = "1")] pub action_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The android:name value of the tag. #[prost(string, repeated, tag = "2")] pub category_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The android:mimeType value of the tag. #[prost(string, tag = "3")] pub mime_type: ::prost::alloc::string::String, } /// A request to get the details of an Android application APK. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetApkDetailsRequest { /// The APK to be parsed for details. #[prost(message, optional, tag = "1")] pub location: ::core::option::Option, } /// Response containing the details of the specified Android application APK. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetApkDetailsResponse { /// Details of the Android APK. #[prost(message, optional, tag = "1")] pub apk_detail: ::core::option::Option, } #[doc = r" Generated client implementations."] pub mod application_detail_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " A service which parses input applications and returns details that can be"] #[doc = " useful in the context of testing."] #[derive(Debug, Clone)] pub struct ApplicationDetailServiceClient { inner: tonic::client::Grpc, } impl ApplicationDetailServiceClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> ApplicationDetailServiceClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { ApplicationDetailServiceClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Gets the details of an Android application APK."] pub async fn get_apk_details( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.devtools.testing.v1.ApplicationDetailService/GetApkDetails", ); self.inner.unary(request.into_request(), path, codec).await } } } /// A single device IP block #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeviceIpBlock { /// An IP address block in CIDR notation eg: 34.68.194.64/29 #[prost(string, tag = "1")] pub block: ::prost::alloc::string::String, /// Whether this block is used by physical or virtual devices #[prost(enumeration = "DeviceForm", tag = "2")] pub form: i32, /// The date this block was added to Firebase Test Lab #[prost(message, optional, tag = "3")] pub added_date: ::core::option::Option, } /// Request to list the currently supported values for an environment type. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetTestEnvironmentCatalogRequest { /// Required. The type of environment that should be listed. #[prost(enumeration = "get_test_environment_catalog_request::EnvironmentType", tag = "1")] pub environment_type: i32, /// For authorization, the cloud project requesting the TestEnvironmentCatalog. #[prost(string, tag = "2")] pub project_id: ::prost::alloc::string::String, } /// Nested message and enum types in `GetTestEnvironmentCatalogRequest`. pub mod get_test_environment_catalog_request { /// Types of environments the Test API supports. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum EnvironmentType { /// Do not use. For proto versioning only. Unspecified = 0, /// A device running a version of the Android OS. Android = 1, /// A device running a version of iOS. Ios = 3, /// A network configuration to use when running a test. NetworkConfiguration = 4, /// The software environment provided by TestExecutionService. ProvidedSoftware = 5, /// The IP blocks used by devices in the test environment. DeviceIpBlocks = 6, } } /// A description of a test environment. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TestEnvironmentCatalog { /// Output only. #[prost(oneof = "test_environment_catalog::EnvironmentCatalog", tags = "1, 3, 4, 5, 6")] pub environment_catalog: ::core::option::Option, } /// Nested message and enum types in `TestEnvironmentCatalog`. pub mod test_environment_catalog { /// Output only. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum EnvironmentCatalog { /// Supported Android devices. #[prost(message, tag = "1")] AndroidDeviceCatalog(super::AndroidDeviceCatalog), /// Supported iOS devices. #[prost(message, tag = "3")] IosDeviceCatalog(super::IosDeviceCatalog), /// Supported network configurations. #[prost(message, tag = "4")] NetworkConfigurationCatalog(super::NetworkConfigurationCatalog), /// The software test environment provided by TestExecutionService. #[prost(message, tag = "5")] SoftwareCatalog(super::ProvidedSoftwareCatalog), /// The IP blocks used by devices in the test environment. #[prost(message, tag = "6")] DeviceIpBlockCatalog(super::DeviceIpBlockCatalog), } } /// List of IP blocks used by the Firebase Test Lab #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeviceIpBlockCatalog { /// The device IP blocks used by Firebase Test Lab #[prost(message, repeated, tag = "1")] pub ip_blocks: ::prost::alloc::vec::Vec, } /// The currently supported Android devices. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidDeviceCatalog { /// The set of supported Android device models. #[prost(message, repeated, tag = "1")] pub models: ::prost::alloc::vec::Vec, /// The set of supported Android OS versions. #[prost(message, repeated, tag = "2")] pub versions: ::prost::alloc::vec::Vec, /// The set of supported runtime configurations. #[prost(message, optional, tag = "3")] pub runtime_configuration: ::core::option::Option, } /// Android configuration that can be selected at the time a test is run. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidRuntimeConfiguration { /// The set of available locales. #[prost(message, repeated, tag = "1")] pub locales: ::prost::alloc::vec::Vec, /// The set of available orientations. #[prost(message, repeated, tag = "2")] pub orientations: ::prost::alloc::vec::Vec, } /// A description of an Android device tests may be run on. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidModel { /// The unique opaque id for this model. /// Use this for invoking the TestExecutionService. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The human-readable marketing name for this device model. /// Examples: "Nexus 5", "Galaxy S5". #[prost(string, tag = "2")] pub name: ::prost::alloc::string::String, /// The manufacturer of this device. #[prost(string, tag = "3")] pub manufacturer: ::prost::alloc::string::String, /// The company that this device is branded with. /// Example: "Google", "Samsung". #[prost(string, tag = "9")] pub brand: ::prost::alloc::string::String, /// The name of the industrial design. /// This corresponds to android.os.Build.DEVICE. #[prost(string, tag = "10")] pub codename: ::prost::alloc::string::String, /// Whether this device is virtual or physical. #[prost(enumeration = "DeviceForm", tag = "4")] pub form: i32, /// Whether this device is a phone, tablet, wearable, etc. #[prost(enumeration = "DeviceFormFactor", tag = "16")] pub form_factor: i32, /// Screen size in the horizontal (X) dimension measured in pixels. #[prost(int32, tag = "5")] pub screen_x: i32, /// Screen size in the vertical (Y) dimension measured in pixels. #[prost(int32, tag = "6")] pub screen_y: i32, /// Screen density in DPI. /// This corresponds to ro.sf.lcd_density #[prost(int32, tag = "12")] pub screen_density: i32, /// True if and only if tests with this model are recorded by stitching /// together screenshots. See use_low_spec_video_recording in device config. #[prost(bool, tag = "17")] pub low_fps_video_recording: bool, /// The set of Android versions this device supports. #[prost(string, repeated, tag = "7")] pub supported_version_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The list of supported ABIs for this device. /// This corresponds to either android.os.Build.SUPPORTED_ABIS (for API level /// 21 and above) or android.os.Build.CPU_ABI/CPU_ABI2. /// The most preferred ABI is the first element in the list. /// /// Elements are optionally prefixed by "version_id:" (where version_id is /// the id of an AndroidVersion), denoting an ABI that is supported only on /// a particular version. #[prost(string, repeated, tag = "11")] pub supported_abis: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Tags for this dimension. /// Examples: "default", "preview", "deprecated". #[prost(string, repeated, tag = "8")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// URL of a thumbnail image (photo) of the device. /// e.g. #[prost(string, tag = "19")] pub thumbnail_url: ::prost::alloc::string::String, } /// A version of the Android OS. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AndroidVersion { /// An opaque id for this Android version. /// Use this id to invoke the TestExecutionService. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// A string representing this version of the Android OS. /// Examples: "4.3", "4.4". #[prost(string, tag = "2")] pub version_string: ::prost::alloc::string::String, /// The API level for this Android version. /// Examples: 18, 19. #[prost(int32, tag = "3")] pub api_level: i32, /// The code name for this Android version. /// Examples: "JellyBean", "KitKat". #[prost(string, tag = "4")] pub code_name: ::prost::alloc::string::String, /// The date this Android version became available in the market. #[prost(message, optional, tag = "5")] pub release_date: ::core::option::Option, /// Market share for this version. #[prost(message, optional, tag = "6")] pub distribution: ::core::option::Option, /// Tags for this dimension. /// Examples: "default", "preview", "deprecated". #[prost(string, repeated, tag = "7")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Data about the relative number of devices running a /// given configuration of the Android platform. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Distribution { /// Output only. The time this distribution was measured. #[prost(message, optional, tag = "1")] pub measurement_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The estimated fraction (0-1) of the total market with this /// configuration. #[prost(double, tag = "2")] pub market_share: f64, } /// The currently supported iOS devices. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosDeviceCatalog { /// The set of supported iOS device models. #[prost(message, repeated, tag = "1")] pub models: ::prost::alloc::vec::Vec, /// The set of supported iOS software versions. #[prost(message, repeated, tag = "2")] pub versions: ::prost::alloc::vec::Vec, /// The set of supported Xcode versions. #[prost(message, repeated, tag = "4")] pub xcode_versions: ::prost::alloc::vec::Vec, /// The set of supported runtime configurations. #[prost(message, optional, tag = "3")] pub runtime_configuration: ::core::option::Option, } /// iOS configuration that can be selected at the time a test is run. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosRuntimeConfiguration { /// The set of available locales. #[prost(message, repeated, tag = "1")] pub locales: ::prost::alloc::vec::Vec, /// The set of available orientations. #[prost(message, repeated, tag = "2")] pub orientations: ::prost::alloc::vec::Vec, } /// A description of an iOS device tests may be run on. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosModel { /// The unique opaque id for this model. /// Use this for invoking the TestExecutionService. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The human-readable name for this device model. /// Examples: "iPhone 4s", "iPad Mini 2". #[prost(string, tag = "2")] pub name: ::prost::alloc::string::String, /// The set of iOS major software versions this device supports. #[prost(string, repeated, tag = "3")] pub supported_version_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Tags for this dimension. /// Examples: "default", "preview", "deprecated". #[prost(string, repeated, tag = "4")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Device capabilities. /// Copied from /// #[prost(string, repeated, tag = "5")] pub device_capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// Screen size in the horizontal (X) dimension measured in pixels. #[prost(int32, tag = "7")] pub screen_x: i32, /// Screen size in the vertical (Y) dimension measured in pixels. #[prost(int32, tag = "8")] pub screen_y: i32, /// Screen density in DPI. #[prost(int32, tag = "9")] pub screen_density: i32, /// Whether this device is a phone, tablet, wearable, etc. #[prost(enumeration = "DeviceFormFactor", tag = "6")] pub form_factor: i32, } /// An iOS version. #[derive(Clone, PartialEq, ::prost::Message)] pub struct IosVersion { /// An opaque id for this iOS version. /// Use this id to invoke the TestExecutionService. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// An integer representing the major iOS version. /// Examples: "8", "9". #[prost(int32, tag = "2")] pub major_version: i32, /// An integer representing the minor iOS version. /// Examples: "1", "2". #[prost(int32, tag = "4")] pub minor_version: i32, /// Tags for this dimension. /// Examples: "default", "preview", "deprecated". #[prost(string, repeated, tag = "3")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// The available Xcode versions for this version. #[prost(string, repeated, tag = "5")] pub supported_xcode_version_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// A location/region designation for language. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Locale { /// The id for this locale. /// Example: "en_US". #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// A human-friendly name for this language/locale. /// Example: "English". #[prost(string, tag = "2")] pub name: ::prost::alloc::string::String, /// A human-friendly string representing the region for this /// locale. Example: "United States". Not present for every locale. #[prost(string, tag = "3")] pub region: ::prost::alloc::string::String, /// Tags for this dimension. /// Example: "default". #[prost(string, repeated, tag = "4")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Screen orientation of the device. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Orientation { /// The id for this orientation. /// Example: "portrait". #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// A human-friendly name for this orientation. /// Example: "portrait". #[prost(string, tag = "2")] pub name: ::prost::alloc::string::String, /// Tags for this dimension. /// Example: "default". #[prost(string, repeated, tag = "3")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// An Xcode version that an iOS version is compatible with. #[derive(Clone, PartialEq, ::prost::Message)] pub struct XcodeVersion { /// The id for this version. /// Example: "9.2". #[prost(string, tag = "1")] pub version: ::prost::alloc::string::String, /// Tags for this Xcode version. /// Example: "default". #[prost(string, repeated, tag = "2")] pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct NetworkConfigurationCatalog { #[prost(message, repeated, tag = "1")] pub configurations: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct NetworkConfiguration { /// The unique opaque id for this network traffic configuration. #[prost(string, tag = "1")] pub id: ::prost::alloc::string::String, /// The emulation rule applying to the upload traffic. #[prost(message, optional, tag = "2")] pub up_rule: ::core::option::Option, /// The emulation rule applying to the download traffic. #[prost(message, optional, tag = "3")] pub down_rule: ::core::option::Option, } /// Network emulation parameters. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TrafficRule { /// Packet delay, must be >= 0. #[prost(message, optional, tag = "1")] pub delay: ::core::option::Option<::prost_types::Duration>, /// Packet loss ratio (0.0 - 1.0). #[prost(float, tag = "2")] pub packet_loss_ratio: f32, /// Packet duplication ratio (0.0 - 1.0). #[prost(float, tag = "3")] pub packet_duplication_ratio: f32, /// Bandwidth in kbits/second. #[prost(float, tag = "4")] pub bandwidth: f32, /// Burst size in kbits. #[prost(float, tag = "5")] pub burst: f32, } /// The currently provided software environment on the devices under test. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ProvidedSoftwareCatalog { /// A string representing the current version of Android Test Orchestrator /// that is used in the environment. The package is available at /// #[prost(string, tag = "1")] pub orchestrator_version: ::prost::alloc::string::String, /// A string representing the current version of AndroidX Test Orchestrator /// that is used in the environment. The package is available at /// #[prost(string, tag = "2")] pub androidx_orchestrator_version: ::prost::alloc::string::String, } /// Whether the device is physical or virtual. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DeviceForm { /// Do not use. For proto versioning only. Unspecified = 0, /// Android virtual device using Compute Engine native virtualization. Firebase /// Test Lab only. Virtual = 1, /// Actual hardware. Physical = 2, /// Android virtual device using emulator in nested virtualization. Equivalent /// to Android Studio. Emulator = 3, } /// The form factor of a device. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DeviceFormFactor { /// Do not use. For proto versioning only. Unspecified = 0, /// This device has the shape of a phone. Phone = 1, /// This device has the shape of a tablet. Tablet = 2, /// This device has the shape of a watch or other wearable. Wearable = 3, } #[doc = r" Generated client implementations."] pub mod test_environment_discovery_service_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " Service for discovering environments supported by the TestExecutionService."] #[doc = ""] #[doc = " Over time the TestService may add or remove devices or configuration options"] #[doc = " (e.g., when new devices and APIs are released). Clients should check here"] #[doc = " periodically to discover what options are supported."] #[doc = ""] #[doc = " It defines the following resource model:"] #[doc = ""] #[doc = " - The API a collection of [TestEnvironmentCatalog]"] #[doc = " [google.devtools.test.v1.TestEnvironmentCatalog] resources, named"] #[doc = " `testEnvironmentCatalog/*`"] #[doc = ""] #[doc = " - Each TestEnvironmentCatalog resource describes a set of supported"] #[doc = " environments."] #[doc = ""] #[doc = " - An [AndroidDeviceCatalog][google.devtools.test.v1.AndroidDeviceCatalog]"] #[doc = " describes supported Android devices. It contains lists of supported"] #[doc = " [AndroidModels][google.devtools.test.v1.AndroidModel] and"] #[doc = " [AndroidVersions][google.devtools.test.v1.AndroidVersion] along with a"] #[doc = " [AndroidRuntimeConfiguration][google.devtools.test.v1.AndroidRuntimeConfiguration]."] #[doc = " Each AndroidModel contains a list of Versions it supports. All"] #[doc = " models support all locales and orientations described by the"] #[doc = " AndroidRuntimeConfiguration"] #[doc = ""] #[doc = " - An [IosDeviceCatalog][google.devtools.test.v1.IosDeviceCatalog]"] #[doc = " describes supported iOS devices. It contains lists of supported"] #[doc = " [IosModels][google.devtools.test.v1.IosModel] and"] #[doc = " [IosVersions][google.devtools.test.v1.IosVersion] along with a"] #[doc = " [IosRuntimeConfiguration][google.devtools.test.v1.IosRuntimeConfiguration]."] #[doc = " Each IosModel contains a list of Versions it supports. All"] #[doc = " models support all locales and orientations described by the"] #[doc = " IosRuntimeConfiguration."] #[derive(Debug, Clone)] pub struct TestEnvironmentDiscoveryServiceClient { inner: tonic::client::Grpc, } impl TestEnvironmentDiscoveryServiceClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> TestEnvironmentDiscoveryServiceClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { TestEnvironmentDiscoveryServiceClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Gets the catalog of supported test environments."] #[doc = ""] #[doc = " May return any of the following canonical error codes:"] #[doc = ""] #[doc = " - INVALID_ARGUMENT - if the request is malformed"] #[doc = " - NOT_FOUND - if the environment type does not exist"] #[doc = " - INTERNAL - if an internal error occurred"] pub async fn get_test_environment_catalog( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http :: uri :: PathAndQuery :: from_static ("/google.devtools.testing.v1.TestEnvironmentDiscoveryService/GetTestEnvironmentCatalog") ; self.inner.unary(request.into_request(), path, codec).await } } }