Dynamically create Gaia accounts when running E2E sync integration tests.

chrome/browser/sync/test/integration/sync_test.cc

 // Copyright (c) 2012 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 "chrome/browser/sync/test/integration/sync_test.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/guid.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 36 matching lines @@
 #include "components/invalidation/impl/p2p_invalidator.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/os_crypt/os_crypt.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/signin/core/browser/profile_identity_provider.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/sync_driver/invalidation_helper.h"
 #include "components/sync_driver/sync_driver_switches.h"
+#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/port_util.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
@@ skipping 100 matching lines @@
   return BuildP2PProfileInvalidationProvider(context, syncer::NOTIFY_OTHERS);
 }
 
 }  // namespace
 
 SyncTest::SyncTest(TestType test_type)
     : test_type_(test_type),
       server_type_(SERVER_TYPE_UNDECIDED),
       num_clients_(-1),
       use_verifier_(true),
-      notifications_enabled_(true) {
+      notifications_enabled_(true),
+      create_gaia_account_at_runtime_(false) {
   sync_datatype_helper::AssociateWithTest(this);
   switch (test_type_) {
     case SINGLE_CLIENT:
     case SINGLE_CLIENT_LEGACY: {
       num_clients_ = 1;
       break;
     }
     case TWO_CLIENT:
     case TWO_CLIENT_LEGACY: {
       num_clients_ = 2;
       break;
     }
     case MULTIPLE_CLIENT: {
       num_clients_ = 3;
       break;
     }
   }
 }
 
 SyncTest::~SyncTest() {}
 
 void SyncTest::SetUp() {
+  // Sets |server_type_| if it wasn't specified by the test.
+  DecideServerType();
+
   base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kPasswordFileForTest)) {
     ReadPasswordFile();
-  } else if (cl->HasSwitch(switches::kSyncUserForTest) &&
-             cl->HasSwitch(switches::kSyncPasswordForTest)) {
-    username_ = cl->GetSwitchValueASCII(switches::kSyncUserForTest);
-    password_ = cl->GetSwitchValueASCII(switches::kSyncPasswordForTest);
   } else {
-    username_ = "user@gmail.com";
-    password_ = "password";
+    // Decide on username to use or create one.
+    if (cl->HasSwitch(switches::kSyncUserForTest)) {
+      username_ = cl->GetSwitchValueASCII(switches::kSyncUserForTest);
+    } else if (UsingExternalServers()) {
+      // We assume the need to automatically create a Gaia account which
+      // requires URL navigation and needs to be done outside SetUp() function.
+      create_gaia_account_at_runtime_ = true;
+      username_ = base::GenerateGUID();
+    } else {
+      username_ = "user@gmail.com";
+    }
+    // Decide on password to use.
+    password_ = cl->HasSwitch(switches::kSyncPasswordForTest)
+        ? cl->GetSwitchValueASCII(switches::kSyncPasswordForTest)
+        : "password";
   }
 
   if (username_.empty() || password_.empty())
     LOG(FATAL) << "Cannot run sync tests without GAIA credentials.";
 
-  // Sets |server_type_| if it wasn't specified by the test.
-  DecideServerType();
-
   // Mock the Mac Keychain service.  The real Keychain can block on user input.
 #if defined(OS_MACOSX)
   OSCrypt::UseMockKeychain(true);
 #endif
 
   // Start up a sync test server if one is needed and setup mock gaia responses.
   // Note: This must be done prior to the call to SetupClients() because we want
   // the mock gaia responses to be available before GaiaUrls is initialized.
   SetUpTestServerIfRequired();
 
@@ skipping 30 matching lines @@
   // Disable non-essential access of external network resources.
   if (!cl->HasSwitch(switches::kDisableBackgroundNetworking))
     cl->AppendSwitch(switches::kDisableBackgroundNetworking);
 
   if (!cl->HasSwitch(switches::kSyncShortInitialRetryOverride))
     cl->AppendSwitch(switches::kSyncShortInitialRetryOverride);
 }
 
 void SyncTest::AddOptionalTypesToCommandLine(base::CommandLine* cl) {}
 
+bool SyncTest::CreateGaiaAccount(const std::string& username,
+                                 const std::string& password) {
+  std::string relative_url = base::StringPrintf("/CreateUsers?%s=%s",
+                                                username.c_str(),
+                                                password.c_str());
+  GURL create_user_url =
+      GaiaUrls::GetInstance()->gaia_url().Resolve(relative_url);
+  // NavigateToURL blocks until the navigation finishes.
+  ui_test_utils::NavigateToURL(browser(), create_user_url);
+  content::WebContents* contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  content::NavigationEntry* entry = contents->GetController().GetVisibleEntry();
+  CHECK(entry) << "Could not get a hold on NavigationEntry post URL navigate.";
+  DVLOG(1) << "Create Gaia account request return code = "
+      << entry->GetHttpStatusCode();
+  return entry->GetHttpStatusCode() == 200;
+}
+
 // Called when the ProfileManager has created a profile.
 // static
 void SyncTest::CreateProfileCallback(const base::Closure& quit_closure,
                                      Profile* profile,
                                      Profile::CreateStatus status) {
   EXPECT_TRUE(profile);
   EXPECT_NE(Profile::CREATE_STATUS_LOCAL_FAIL, status);
   EXPECT_NE(Profile::CREATE_STATUS_REMOTE_FAIL, status);
   // This will be called multiple times. Wait until the profile is initialized
   // fully to quit the loop.
@@ skipping 237 matching lines @@
                                 GetInvalidationService());
     p2p_invalidation_service->UpdateCredentials(username_, password_);
     // Start listening for and emitting notifications of commits.
     invalidation_forwarders_[index] =
         new P2PInvalidationForwarder(clients_[index]->service(),
                                      p2p_invalidation_service);
   }
 }
 
 bool SyncTest::SetupSync() {
+  if (create_gaia_account_at_runtime_) {
+    CHECK(UsingExternalServers()) <<
+        "Cannot create Gaia accounts without external authentication servers";
+    if (!CreateGaiaAccount(username_, password_))
+      LOG(FATAL) << "Could not create Gaia account.";
+  }
   // Create sync profiles and clients if they haven't already been created.
   if (profiles_.empty()) {
     if (!SetupClients())
       LOG(FATAL) << "SetupClients() failed.";
   }
 
   // Sync each of the profiles.
   for (int i = 0; i < num_clients_; ++i) {
     if (!GetClient(i)->SetupSync())
       LOG(FATAL) << "SetupSync() failed.";
@@ skipping 516 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
       content::Source<Profile>(GetProfile(index)),
       content::Details<const syncer::ModelTypeSet>(&model_types));
 }
 
 void SyncTest::SetPreexistingPreferencesFileContents(
     const std::string& contents) {
   preexisting_preferences_file_contents_ = contents;
 }