Adding Test Fixture for initial test cases for the App Remoting Test Driver. Also includes the pub…

remoting/test/app_remoting_test_driver_environment.cc

 // 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.
 
 #include "remoting/test/app_remoting_test_driver_environment.h"
 
+#include <map>
+#include <string>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
 #include "remoting/test/access_token_fetcher.h"
 #include "remoting/test/refresh_token_store.h"
 #include "remoting/test/remote_host_info.h"
 
 namespace remoting {
 namespace test {
 
 AppRemotingTestDriverEnvironment* AppRemotingSharedData;
 
 AppRemotingTestDriverEnvironment::AppRemotingTestDriverEnvironment(
     const std::string& user_name,
     ServiceEnvironment service_environment)
     : user_name_(user_name),
       service_environment_(service_environment),
       test_access_token_fetcher_(nullptr),
       test_refresh_token_store_(nullptr),
       test_remote_host_info_fetcher_(nullptr) {
   DCHECK(!user_name_.empty());
   DCHECK(service_environment < kUnknownEnvironment);
+
+  PopulateApplicationNames();
+  PopulateApplicationDetailsMap();
 }
 
 AppRemotingTestDriverEnvironment::~AppRemotingTestDriverEnvironment() {
 }
 
 bool AppRemotingTestDriverEnvironment::Initialize(
     const std::string& auth_code) {
   if (!access_token_.empty()) {
     return true;
   }
@@ skipping 51 matching lines @@
 
   scoped_ptr<base::MessageLoopForIO> message_loop;
   if (!base::MessageLoop::current()) {
     // Create a temporary message loop if the current thread does not already
     // have one so we can use its task runner for our network request.
     message_loop.reset(new base::MessageLoopForIO);
   }
 
   base::RunLoop run_loop;
 
-  RemoteHostInfoCallback remote_host_info_fetch_callback =
-      base::Bind(&AppRemotingTestDriverEnvironment::OnRemoteHostInfoRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure(),
-                 remote_host_info);
+  RemoteHostInfoCallback remote_host_info_fetch_callback = base::Bind(
+      &AppRemotingTestDriverEnvironment::OnRemoteHostInfoRetrieved,
+      base::Unretained(this), run_loop.QuitClosure(), remote_host_info);
 
   // If a unit test has set |test_remote_host_info_fetcher_| then we should use
   // it below.  Note that we do not want to destroy the test object at the end
   // of the function which is why we have the dance below.
   scoped_ptr<RemoteHostInfoFetcher> temporary_remote_host_info_fetcher;
   RemoteHostInfoFetcher* remote_host_info_fetcher =
       test_remote_host_info_fetcher_;
   if (!remote_host_info_fetcher) {
     temporary_remote_host_info_fetcher.reset(new RemoteHostInfoFetcher());
     remote_host_info_fetcher = temporary_remote_host_info_fetcher.get();
   }
 
   remote_host_info_fetcher->RetrieveRemoteHostInfo(
-      application_id,
-      access_token_,
-      service_environment_,
+      application_id, access_token_, service_environment_,
       remote_host_info_fetch_callback);
 
   run_loop.Run();
 
   return remote_host_info->IsReadyForConnection();
 }
 
+void AppRemotingTestDriverEnvironment::ShowHostAvailability() {
+  const char kHostAvailabilityFormatString[] = "%-25s%-35s%-10s";
+  std::vector<std::string>::const_iterator it = application_names_.begin();
+
+  LOG(INFO) << base::StringPrintf(kHostAvailabilityFormatString,
+                                  "Application Name", "Application ID",
+                                  "Status");
+
+  while (it != application_names_.end()) {
+    std::string application_name = *it;
+
+    const RemoteApplicationDetails& application_details = GetDetailsFromAppName(
+        application_name);
+
+    RemoteHostInfo remote_host_info;
+    GetRemoteHostInfoForApplicationId(application_details.application_id,
+                                      &remote_host_info);
+
+    std::string status;
+    RemoteHostStatus remote_host_status = remote_host_info.remote_host_status;
+    if (remote_host_status == kRemoteHostStatusReady) {
+      status = "Ready :)";
+    } else if (remote_host_status == kRemoteHostStatusPending) {
+      status = "Pending :|";
+    } else {
+      status = "Unknown :(";
+    }
+
+    LOG(INFO) << base::StringPrintf(
+        kHostAvailabilityFormatString, application_name.c_str(),
+        application_details.application_id.c_str(), status.c_str());
+
+    ++it;
+  }
+}
+
+const RemoteApplicationDetails&
+AppRemotingTestDriverEnvironment::GetDetailsFromAppName(
+    const std::string& application_name) {
+  DCHECK_GT(application_details_map_.count(application_name), 0UL);
+
+  return application_details_map_.at(application_name);
+}
+
 void AppRemotingTestDriverEnvironment::SetAccessTokenFetcherForTest(
     AccessTokenFetcher* access_token_fetcher) {
   DCHECK(access_token_fetcher);
 
   test_access_token_fetcher_ = access_token_fetcher;
 }
 
 void AppRemotingTestDriverEnvironment::SetRefreshTokenStoreForTest(
     RefreshTokenStore* refresh_token_store) {
   DCHECK(refresh_token_store);
@@ skipping 17 matching lines @@
     // have one so we can use its task runner for our network request.
     message_loop.reset(new base::MessageLoopForIO);
   }
 
   base::RunLoop run_loop;
 
   access_token_.clear();
 
   AccessTokenCallback access_token_callback =
       base::Bind(&AppRemotingTestDriverEnvironment::OnAccessTokenRetrieved,
-                 base::Unretained(this),
-                 run_loop.QuitClosure());
+                 base::Unretained(this), run_loop.QuitClosure());
 
   // If a unit test has set |test_access_token_fetcher_| then we should use it
   // below.  Note that we do not want to destroy the test object at the end of
   // the function which is why we have the dance below.
   scoped_ptr<AccessTokenFetcher> temporary_access_token_fetcher;
   AccessTokenFetcher* access_token_fetcher = test_access_token_fetcher_;
   if (!access_token_fetcher) {
     temporary_access_token_fetcher.reset(new AccessTokenFetcher());
     access_token_fetcher = temporary_access_token_fetcher.get();
   }
 
   if (!auth_code.empty()) {
     // If the user passed in an authcode, then use it to retrieve an
     // updated access/refresh token.
-    access_token_fetcher->GetAccessTokenFromAuthCode(
-        auth_code,
-        access_token_callback);
+    access_token_fetcher->GetAccessTokenFromAuthCode(auth_code,
+                                                     access_token_callback);
   } else {
     DCHECK(!refresh_token_.empty());
 
-    access_token_fetcher->GetAccessTokenFromRefreshToken(
-        refresh_token_,
-        access_token_callback);
+    access_token_fetcher->GetAccessTokenFromRefreshToken(refresh_token_,
+                                                         access_token_callback);
   }
 
   run_loop.Run();
 
   // If we were using an auth_code and received a valid refresh token,
   // then we want to store it locally.  If we had an auth code and did not
   // receive a refresh token, then we should let the user know and exit.
   if (!auth_code.empty()) {
     if (!refresh_token_.empty()) {
       // If a unit test has set |test_refresh_token_store_| then we should use
@@ skipping 34 matching lines @@
 
   done_closure.Run();
 }
 
 void AppRemotingTestDriverEnvironment::OnRemoteHostInfoRetrieved(
     base::Closure done_closure,
     RemoteHostInfo* remote_host_info,
     const RemoteHostInfo& retrieved_remote_host_info) {
   DCHECK(remote_host_info);
 
-  if (retrieved_remote_host_info.IsReadyForConnection()) {
-    *remote_host_info = retrieved_remote_host_info;
-  }
+  *remote_host_info = retrieved_remote_host_info;
 
   done_closure.Run();
 }
 
 }  // namespace test
 }  // namespace remoting