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 "remoting/test/access_token_fetcher.h"
 #include "remoting/test/refresh_token_store.h"
+#include "remoting/test/remote_application_data.h"
 #include "remoting/test/remote_host_info.h"
 
+namespace {
+const char kHostAvailabilityFormatString[] = "%-25s%-40s%-10s\n";

[Wez, 2015/03/16 22:19:10]

You can define this immediately before the printf where you use it (and then you
don't need an anonymous namespace (which you didn't strictly need anyway, since
it's const :))

[joedow, 2015/03/18 20:13:09]

Done.

+}
+
 namespace remoting {
 namespace test {
 
 AppRemotingTestDriverEnvironment* AppRemotingSharedData;
 
 AppRemotingTestDriverEnvironment::AppRemotingTestDriverEnvironment(
     const std::string& user_name,
     ServiceEnvironment service_environment)
     : user_name_(user_name),
       service_environment_(service_environment),
@@ skipping 66 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() {
+  std::vector<std::string> app_names = GetRemoteApplicationNames();
+  std::map<std::string, ApplicationInfo> app_info =
+      GetRemoteApplicationInfoMap();
+  std::vector<std::string>::const_iterator it = app_names.begin();
+
+  printf(kHostAvailabilityFormatString, "Application Name", "Application ID",
+         "Status");
+
+  while (it != app_names.end()) {
+    std::string application_name = *it;
+
+    DCHECK_GT(app_info.count(application_name), 0UL);
+    ApplicationInfo& info = app_info.at(application_name);
+
+    RemoteHostInfo remote_host_info;
+    GetRemoteHostInfoForApplicationId(info.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 :(";
+    }
+
+    printf(kHostAvailabilityFormatString, application_name.c_str(),
+           info.application_id.c_str(), status.c_str());

[Wez, 2015/03/16 22:19:10]

Is it normal to use printf() in test fixtures, rather than LOG() etc?

[joedow, 2015/03/18 20:13:09]

Done.  I used printf in the main cc file and had figured this would be displayed
in the same way, I'm fine logging to the LOG function though since everything
else is displayed that way.

[Wez, 2015/03/21 00:14:01]

SGTM, although when I wrote that I hadn't realised that this is basically a
usage printout helper function - so printf() may make more sense here - up to
you.

[joedow, 2015/03/21 01:23:59]

Acknowledged.

+
+    ++it;
+  }
+}
+
 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