Adding the AccessTokenFetcher and Environment class to the app remoting test

remoting/test/app_remoting_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/logging.h"
 #include "base/strings/stringprintf.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/app_remoting_test_driver_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace switches {
+  const char kAuthCodeSwitchName[] = "authcode";
+  const char kHelpSwitchName[] = "help";
+  const char kLoggingLevelSwitchName[] = "verbosity";

[Wez, 2015/02/13 03:01:52]

Is this the name that other Chromium code uses for this?  I thought Chrome just
uses "v"?

[joedow, 2015/02/14 02:31:27]

I wanted a separate switch which only turned on logging for the remoting
components.  If you specify v, IIRC you also have to specify a vmodule pattern,
and I wanted to make it simpler to turn logging on for all of the remoting
components.

[Wez, 2015/02/19 22:00:22]

Is --vmodule format really that complex?

+  const char kServiceEnvironmentSwitchName[] = "environment";
+  const char kSingleProcessTestsSwitchName[] = "single-process-tests";
   const char kUserNameSwitchName[] = "username";

[Wez, 2015/02/13 03:01:52]

Indentation

[joedow, 2015/02/14 02:31:27]

Done.

-  const char kAuthCodeSwitchName[] = "authcode";
-  const char kServiceEnvironmentSwitchName[] = "environment";
-  const char kHelpSwitchName[] = "help";
-  const char kSingleProcessTestsSwitchName[] = "single-process-tests";
 }
 
 namespace {
 
 // Requested permissions needed for App Remoting tests.  The spaces in between
 // scope fragments are necessary and will be escaped properly before use.
 const char kAppRemotingAuthScopeValues[] =
     "https://www.googleapis.com/auth/appremoting.runapplication"
     " https://www.googleapis.com/auth/googletalk"
     " https://www.googleapis.com/auth/userinfo.email"
@@ skipping 27 matching lines @@
   printf("\nRequired Parameters:\n");
   printf("  %s: Specifies which account to use when running tests\n",
          switches::kUserNameSwitchName);
   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: Specifies the service api to use (dev|test) [default: dev]\n",
          switches::kServiceEnvironmentSwitchName);
+  printf("  %s: Specifies the optional logging level of the tool (0-3)."
+         " [default: off]\n",
+         switches::kLoggingLevelSwitchName);
 }
 
 void PrintAuthCodeInfo() {
   printf("\n*******************************\n");
   printf("*** Auth Code Example Usage ***\n");
   printf("*******************************\n\n");
 
   printf("If this is the first time you are running the tool,\n");
   printf("you will need to provide an authorization code.\n");
   printf("This code will be exchanged for a long term refresh token which\n");
@@ skipping 19 matching lines @@
          "chrome-remote-desktop/dev?code=4/AKtf...\n");
 
   printf("\nTool usage example with the newly created auth code:\n");
   printf("ar_test_driver --%s=example@gmail.com --%s=4/AKtf...\n\n",
          switches::kUserNameSwitchName,
          switches::kAuthCodeSwitchName);
 }
 
 }  // namespace
 
+using remoting::test::AppRemotingSharedData;

[Wez, 2015/02/13 03:01:52]

nit: You only refer to this a few times; suggest not using using here.

[joedow, 2015/02/14 02:31:27]

Done.

+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   TestSuite test_suite(argc, argv);
 
+  // In some configurations, GTest will run main twice.  This should not happen
+  // since we inject the single-process flag, but this is a safeguard in case

[Wez, 2015/02/13 03:01:52]

Why would the single-process flag have any effect on how many times main() is
run in a particular process?

[joedow, 2015/02/14 02:31:27]

It seemed like main was run twice when GTest was in multiprocess mode and I saw
the global* get re-initialized but that was ~4 months ago so maybe I am
remembering wrong...

+  // the flag is changed later.  If main is run twice, we don't want to double
+  // initialize the global data as that will result in a leak or crash.  If we

[Wez, 2015/02/13 03:01:52]

Why do we not tear down the global data when main exits?

[joedow, 2015/02/14 02:31:27]

The GTest framework handles it, there is a comment further down where I describe
what happens.

+  // decide to run in multiple processes, we will want to move the global init
+  // code into a base::TestSuite derivation and use it instead of the base
+  // class we use now.
+  DCHECK(!AppRemotingSharedData);
+
   // The pointer returned here refers to a singleton, since we don't own the
   // lifetime of the object, don't wrap in a scoped_ptr construct or release it.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   DCHECK(command_line);
 
   // We do not want to retry failures as a failed test should signify an error
   // to be investigated.
   command_line->AppendSwitchASCII(switches::kTestLauncherRetryLimit, "0");
 
   // We do not want to run the tests in parallel and we do not want to retry
@@ skipping 16 matching lines @@
         base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
   }
 
   // Verify we received the required input from the command line.
   if (!command_line->HasSwitch(switches::kUserNameSwitchName)) {
     LOG(ERROR) << "No user name passed in, can't authenticate without that!";
     PrintUsage();
     return -1;
   }
 
+  std::string user_name;
+  user_name = command_line->GetSwitchValueASCII(switches::kUserNameSwitchName);
+  DVLOG(1) << "Running tests as: " << user_name;
+
+  std::string auth_code;
+  // Check to see if the user passed in a one time use auth_code for
+  // refreshing their credentials.
+  if (command_line->HasSwitch(switches::kAuthCodeSwitchName)) {
+    auth_code = command_line->GetSwitchValueASCII(
+        switches::kAuthCodeSwitchName);

[Wez, 2015/02/13 03:01:52]

Note that you can just call GetSwitchValueASCII and it'll return an empty string
if there is no such value.

[joedow, 2015/02/14 02:31:27]

Done.

+  }
+
+  std::string service_environment;
+  // If the user passed in a service environment, use it, otherwise set a
+  // default value.
+  if (command_line->HasSwitch(switches::kServiceEnvironmentSwitchName)) {
+    service_environment = command_line->GetSwitchValueASCII(
+        switches::kServiceEnvironmentSwitchName);
+  } else {
+    // Default to the development service environment.
+    service_environment = "dev";
+  }
+  // Only two values are allowed, so validate them before proceeding.
+  if (service_environment != "test" && service_environment != "dev") {
+    LOG(ERROR) << "Invalid " << switches::kServiceEnvironmentSwitchName
+               << " argument passed in.";
+    PrintUsage();
+    return -1;
+  }
+
+  // Update the logging verbosity level is user specified one.
+  std::string verbosity_level;
+  if (command_line->HasSwitch(switches::kLoggingLevelSwitchName)) {
+    verbosity_level = command_line->GetSwitchValueASCII(
+        switches::kLoggingLevelSwitchName);
+
+    // Turn on logging for the test_driver and remoting components.
+    // This switch is parsed during logging::InitLogging.
+    command_line->AppendSwitchASCII("vmodule",
+        "*/remoting/*=" + verbosity_level);
+    logging::LoggingSettings logging_settings;
+    logging::InitLogging(logging_settings);
+  }
+
+  // Create and register our global test data object.  It will handle
+  // retrieving an access token for the user and spinning up VMs.
+  // The GTest framework will own the lifetime of this object once
+  // it is registered below.
+  scoped_ptr<remoting::test::AppRemotingTestDriverEnvironment> shared_data;
+
+  shared_data.reset(
+      new remoting::test::AppRemotingTestDriverEnvironment(
+          user_name,
+          service_environment));
+
+  if (!shared_data->Initialize(auth_code)) {
+    // If we failed to initialize our shared data object, then bail.
+    return -1;
+  }
+
+  // Since we've successfully set up our shared_data object, we'll assign the
+  // value to our global* and transfer ownership to the framework.
+  AppRemotingSharedData = shared_data.release();
+  testing::AddGlobalTestEnvironment(AppRemotingSharedData);
+
   // Because many tests may access the same remoting host(s), we need to run
   // the tests sequentially so they do not interfere with each other.
   return base::LaunchUnitTestsSerially(
       argc,
       argv,
       base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
 }