Adding 'Show Host List' option to CTD

remoting/test/chromoting_test_driver.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_switches.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "remoting/test/chromoting_test_driver_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace switches {
 const char kAuthCodeSwitchName[] = "authcode";
 const char kHelpSwitchName[] = "help";
 const char kHostNameSwitchName[] = "hostname";
 const char kHostJidSwitchName[] = "hostjid";
 const char kLoggingLevelSwitchName[] = "verbosity";
 const char kPinSwitchName[] = "pin";
 const char kRefreshTokenPathSwitchName[] = "refresh-token-path";
 const char kSingleProcessTestsSwitchName[] = "single-process-tests";
+const char kShowHostListSwitchName[] = "show-host-list";
 const char kTestEnvironmentSwitchName[] = "use-test-env";
 const char kUserNameSwitchName[] = "username";
 }
 
 namespace {
 const char kChromotingAuthScopeValues[] =
     "https://www.googleapis.com/auth/chromoting "
     "https://www.googleapis.com/auth/googletalk "
     "https://www.googleapis.com/auth/userinfo.email";
 
@@ skipping 21 matching lines @@
   printf("************************************\n");
 
   printf("\nUsage:\n");
   printf("  chromoting_test_driver --username=<example@gmail.com> [options]"
          " --hostname=<example hostname>\n");
   printf("\nRequired Parameters:\n");
   printf("  %s: Specifies which account to use when running tests\n",
          switches::kUserNameSwitchName);
   printf("  %s: Specifies which host to connect to when running tests\n",
          switches::kHostNameSwitchName);
+  printf(
+      "  %s: Retrieves and displays the connection status for all known "
+      "hosts, no tests will be run\n",
+      switches::kShowHostListSwitchName);
   printf("\nOptional Parameters:\n");
   printf("  %s: Exchanged for a refresh and access token for authentication\n",
          switches::kAuthCodeSwitchName);
   printf("  %s: Displays additional usage information\n",
          switches::kHelpSwitchName);
   printf("  %s: Path to a JSON file containing username/refresh_token KVPs\n",
          switches::kRefreshTokenPathSwitchName);
   printf("  %s: Specifies the optional logging level of the tool (0-3)."
          " [default: off]\n", switches::kLoggingLevelSwitchName);
   printf(
@@ skipping 132 matching lines @@
   std::string auth_code =
       command_line->GetSwitchValueASCII(switches::kAuthCodeSwitchName);
   options.refresh_token_file_path =
      command_line->GetSwitchValuePath(switches::kRefreshTokenPathSwitchName);
 
   // The host name determines which host to initiate a session with from the
   // host list returned from the directory service.
   options.host_name =
       command_line->GetSwitchValueASCII(switches::kHostNameSwitchName);
 
-  if (options.host_name.empty()) {
+  if (!options.host_name.empty()) {
+    VLOG(1) << "host_name: '" << options.host_name << "'";
+  } else if (command_line->HasSwitch(switches::kShowHostListSwitchName)) {
+    options.host_name = "unspecified";
+  } else {
     LOG(ERROR) << "No hostname passed in, connect to host requires hostname!";
     return -1;
   }
-  VLOG(1) << "host_name: '" << options.host_name << "'";
 
   options.host_jid =
       command_line->GetSwitchValueASCII(switches::kHostJidSwitchName);
   VLOG(1) << "host_jid: '" << options.host_jid << "'";
 
   options.pin = command_line->GetSwitchValueASCII(switches::kPinSwitchName);
 
   options.use_test_environment =
       command_line->HasSwitch(switches::kTestEnvironmentSwitchName);
 
   // Create and register our global test data object. It will handle
   // retrieving an access token or host list for the user. The GTest framework
   // will own the lifetime of this object once it is registered below.
   std::unique_ptr<remoting::test::ChromotingTestDriverEnvironment> shared_data(
       new remoting::test::ChromotingTestDriverEnvironment(options));
 
   if (!shared_data->Initialize(auth_code)) {
     VLOG(1) << "Failed to initialize ChromotingTestDriverEnvironment instance.";
     // If we failed to initialize our shared data object, then bail.
     return -1;
   }
 
+  if (command_line->HasSwitch(switches::kShowHostListSwitchName)) {
+    // When this flag is specified, we will show the host list and exit.
+    shared_data->RefreshHostList();
+    shared_data->DisplayHostList();
+    return 0;
+  }
+
   // This method is necessary as there are occasional propagation delays in the
   // backend and we don't want the test to fail because of that.
-  if (!shared_data->WaitForHostOnline(options.host_jid, options.host_name)) {
+  if (!shared_data->WaitForHostOnline()) {
     VLOG(1) << "The expected host was not available for connections.";
     // Host is not online. No point running further tests.
     return -1;
   }
 
+  if (options.pin.empty()) {
+    LOG(WARNING) << "No PIN specified, tests may not run reliably.";
+  }
+
   // Since we've successfully set up our shared_data object, we'll assign the
   // value to our global* and transfer ownership to the framework.
   remoting::test::g_chromoting_shared_data = shared_data.release();
   testing::AddGlobalTestEnvironment(remoting::test::g_chromoting_shared_data);
 
   // Running the tests serially will avoid clients from connecting to the same
   // host.
 #if defined(OS_IOS)
   return base::LaunchUnitTests(
       argc, argv,
       base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
 #else
   return base::LaunchUnitTestsSerially(
       argc, argv,
       base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
 #endif
 }