| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef REMOTING_TEST_APP_REMOTING_TEST_DRIVER_ENVIRONMENT_H_ |
| #define REMOTING_TEST_APP_REMOTING_TEST_DRIVER_ENVIRONMENT_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/files/file_path.h" |
| #include "base/macros.h" |
| #include "remoting/test/remote_application_details.h" |
| #include "remoting/test/remote_host_info_fetcher.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace base { |
| class MessageLoopForIO; |
| } |
| |
| namespace remoting { |
| namespace test { |
| |
| class AccessTokenFetcher; |
| class AppRemotingReportIssueRequest; |
| class RefreshTokenStore; |
| struct RemoteHostInfo; |
| |
| // Globally accessible to all test fixtures and cases and has its |
| // lifetime managed by the GTest framework. It is responsible for managing |
| // access tokens and retrieving remote host connection information. |
| class AppRemotingTestDriverEnvironment : public testing::Environment { |
| public: |
| struct EnvironmentOptions { |
| EnvironmentOptions(); |
| ~EnvironmentOptions(); |
| |
| std::string user_name; |
| base::FilePath refresh_token_file_path; |
| ServiceEnvironment service_environment; |
| bool release_hosts_when_done; |
| }; |
| |
| explicit AppRemotingTestDriverEnvironment(const EnvironmentOptions& options); |
| ~AppRemotingTestDriverEnvironment() override; |
| |
| // Returns false if a valid access token cannot be retrieved. |
| bool Initialize(const std::string& auth_code); |
| |
| // Synchronously request a new access token using |refresh_token_|. |
| // Returns true if a valid access token has been retrieved. |
| bool RefreshAccessToken(); |
| |
| // Synchronously request remote host information for |application_id|. |
| // Returns true if the request was successful and |remote_host_info| is valid. |
| bool GetRemoteHostInfoForApplicationId(const std::string& application_id, |
| RemoteHostInfo* remote_host_info); |
| |
| // Adds the host_id to the list of hosts that will be released after the tests |
| // have all been run. |
| void AddHostToReleaseList(const std::string& application_id, |
| const std::string& host_id); |
| |
| // Retrieves connection information for all known applications and displays |
| // their availability to STDOUT. |
| void ShowHostAvailability(); |
| |
| // Provides the RemoteApplicationDetails for the specified |application_name|. |
| const RemoteApplicationDetails& GetDetailsFromAppName( |
| const std::string& application_name); |
| |
| // Used to set fake/mock objects for AppRemotingTestDriverEnvironment tests. |
| // The caller retains ownership of the supplied objects, and must ensure that |
| // they remain valid until the AppRemotingTestDriverEnvironment instance has |
| // been destroyed. |
| void SetAccessTokenFetcherForTest(AccessTokenFetcher* access_token_fetcher); |
| void SetAppRemotingReportIssueRequestForTest( |
| AppRemotingReportIssueRequest* app_remoting_report_issue_request); |
| void SetRefreshTokenStoreForTest(RefreshTokenStore* refresh_token_store); |
| void SetRemoteHostInfoFetcherForTest( |
| RemoteHostInfoFetcher* remote_host_info_fetcher); |
| |
| // Accessors for fields used by tests. |
| const std::string& access_token() const { return access_token_; } |
| const std::string& user_name() const { return user_name_; } |
| |
| protected: |
| // Contains the names of all supported remote applications. |
| // Once initialized, this vector is not modified. |
| std::vector<std::string> application_names_; |
| |
| // Contains RemoteApplicationDetails for all supported remote applications. |
| // Once initialized, this map is not modified. |
| std::map<std::string, RemoteApplicationDetails> application_details_map_; |
| |
| private: |
| // testing::Environment interface. |
| void TearDown() override; |
| |
| // Used to retrieve an access token. If |auth_code| is empty, then the stored |
| // refresh_token will be used instead of |auth_code|. |
| // Returns true if a new, valid access token has been retrieved. |
| bool RetrieveAccessToken(const std::string& auth_code); |
| |
| // Called after the access token fetcher completes. |
| // The tokens will be empty on failure. |
| void OnAccessTokenRetrieved(base::Closure done_closure, |
| const std::string& access_token, |
| const std::string& refresh_token); |
| |
| // Called after the remote host info fetcher completes. |
| // |remote_host_info| is modified on failure. |
| void OnRemoteHostInfoRetrieved( |
| base::Closure done_closure, |
| RemoteHostInfo* remote_host_info, |
| const RemoteHostInfo& retrieved_remote_host_info); |
| |
| // Used for authenticating with the app remoting service API. |
| std::string access_token_; |
| |
| // Used to retrieve an access token. |
| std::string refresh_token_; |
| |
| // Used for authentication. |
| std::string user_name_; |
| |
| // Service API to target when retrieving remote host connection information. |
| ServiceEnvironment service_environment_; |
| |
| // Specifies whether to tell the service to release the remote hosts we |
| // requested after the tests have completed. |
| bool release_hosts_when_done_; |
| |
| // Path to a JSON file containing refresh tokens. |
| base::FilePath refresh_token_file_path_; |
| |
| // Access token fetcher used by TestDriverEnvironment tests. |
| remoting::test::AccessTokenFetcher* test_access_token_fetcher_; |
| |
| // AppRemotingReportIssueRequest used by TestDriverEnvironment tests. |
| remoting::test::AppRemotingReportIssueRequest* |
| test_app_remoting_report_issue_request_; |
| |
| // RefreshTokenStore used by TestDriverEnvironment tests. |
| remoting::test::RefreshTokenStore* test_refresh_token_store_; |
| |
| // RemoteHostInfoFetcher used by TestDriverEnvironment tests. |
| remoting::test::RemoteHostInfoFetcher* test_remote_host_info_fetcher_; |
| |
| // Used for running network request tasks. |
| std::unique_ptr<base::MessageLoopForIO> message_loop_; |
| |
| // Contains the host ids to release when the environment is torn down. |
| // The key is the application id and the value is a list of hosts. |
| std::map<std::string, std::vector<std::string>> host_ids_to_release_; |
| |
| DISALLOW_COPY_AND_ASSIGN(AppRemotingTestDriverEnvironment); |
| }; |
| |
| // Used to provide application specific instances of the |
| // AppRemotingTestDriverEnvironment class. |
| extern std::unique_ptr<AppRemotingTestDriverEnvironment> |
| CreateAppRemotingTestDriverEnvironment( |
| const AppRemotingTestDriverEnvironment::EnvironmentOptions& options); |
| |
| // Unfortunately a global var is how the GTEST framework handles sharing data |
| // between tests and keeping long-lived objects around. Used to share auth |
| // tokens and remote host connection information across tests. |
| extern AppRemotingTestDriverEnvironment* AppRemotingSharedData; |
| |
| } // namespace test |
| } // namespace remoting |
| |
| #endif // REMOTING_TEST_APP_REMOTING_TEST_DRIVER_ENVIRONMENT_H_ |