Improved test coverage of login_utils_browsertest.cc.

chrome/browser/chromeos/login/login_utils_browsertest.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/chromeos/login/login_utils.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 127 matching lines @@
         fake_io_thread_("fake_io_thread"),
         loop_(MessageLoop::TYPE_IO),
         browser_process_(TestingBrowserProcess::GetGlobal()),
         local_state_(browser_process_),
         ui_thread_(BrowserThread::UI, &loop_),
         db_thread_(BrowserThread::DB),
         file_thread_(BrowserThread::FILE, &loop_),
         mock_async_method_caller_(NULL),
         connector_(NULL),
         cryptohome_(NULL),
-        prepared_profile_(NULL),
-        created_profile_(NULL) {}
+        prepared_profile_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     // This test is not a full blown InProcessBrowserTest, and doesn't have
     // all the usual threads running. However a lot of subsystems pulled from
     // ProfileImpl post to IO (usually from ProfileIOData), and DCHECK that
     // those tasks were posted. Those tasks in turn depend on a lot of other
     // components that aren't there during this test, so this kludge is used to
     // have a running IO loop that doesn't really execute any tasks.
     //
     // See InvokeOnIO() below for a way to perform specific tasks on IO, when
@@ skipping 191 matching lines @@
     // If there was work then keep waiting for more work.
     // If there was no work then quit the fake IO loop.
     return has_work;
   }
 
   virtual void OnProfilePrepared(Profile* profile) OVERRIDE {
     EXPECT_FALSE(prepared_profile_);
     prepared_profile_ = profile;
   }
 
-  virtual void OnProfileCreated(Profile* profile) OVERRIDE {
-    created_profile_ = profile;
-  }
-
 #if defined(ENABLE_RLZ)
   virtual void OnRlzInitialized(Profile* profile) OVERRIDE {
     rlz_initialized_cb_.Run();
   }
 #endif
 
   virtual void OnLoginFailure(const LoginFailure& error) OVERRIDE {
     FAIL() << "OnLoginFailure not expected";
   }
 
   virtual void OnLoginSuccess(const std::string& username,
                               const std::string& password,
                               bool pending_requests,
                               bool using_oauth) OVERRIDE {
     FAIL() << "OnLoginSuccess not expected";
   }
 
-  void LockDevice(const std::string& username) {
+  void EnrollDevice(const std::string& username) {
     EXPECT_CALL(*cryptohome_, InstallAttributesIsFirstInstall())
         .WillOnce(Return(true))
         .WillRepeatedly(Return(false));
     EXPECT_EQ(policy::EnterpriseInstallAttributes::LOCK_SUCCESS,
               connector_->GetInstallAttributes()->LockDevice(
                   username, policy::DEVICE_MODE_ENTERPRISE, kDeviceId));
     RunUntilIdle();
   }
 
   void PrepareProfile(const std::string& username) {
     ScopedDeviceSettingsTestHelper device_settings_test_helper;
     MockSessionManagerClient* session_manager_client =
         mock_dbus_thread_manager_.mock_session_manager_client();
     EXPECT_CALL(*session_manager_client, StartSession(_));
     EXPECT_CALL(*cryptohome_, GetSystemSalt())
         .WillRepeatedly(Return(std::string("stub_system_salt")));
     EXPECT_CALL(*mock_async_method_caller_, AsyncMount(_, _, _, _))
         .WillRepeatedly(Return());
 
     scoped_refptr<Authenticator> authenticator =
         LoginUtils::Get()->CreateAuthenticator(this);
     authenticator->CompleteLogin(ProfileManager::GetDefaultProfile(),
                                  username,
                                  "password");
 
     const bool kPendingRequests = false;
     const bool kUsingOAuth = true;
-    const bool kHasCookies = true;
+    // Setting |kHasCookies| to false prevents ProfileAuthData::Transfer from
+    // waiting for an IO task before proceeding.
+    const bool kHasCookies = false;

[Joao da Silva, 2013/01/11 12:25:50]

This prevents the UI->IO->UI jump at ProfileAuthData::Transfer(), and makes the
OnProfileCreated() delegate calls unnecessary. Those calls were introduced in
https://chromiumcodereview.appspot.com/11576065/ to fix this test.

Calling LoginUtils::CompleteProfileCreate() directly from the test makes the
subsequent checks always pass, so if something breaks in the
profile-creation-unlocking logic then this test wouldn't catch it.

     LoginUtils::Get()->PrepareProfile(username, std::string(), "password",
                                       kPendingRequests, kUsingOAuth,
                                       kHasCookies, this);
     device_settings_test_helper.Flush();
     RunUntilIdle();
   }
 
   net::TestURLFetcher* PrepareOAuthFetcher(const std::string& expected_url) {
     net::TestURLFetcher* fetcher = test_url_fetcher_factory_.GetFetcherByID(0);
     EXPECT_TRUE(fetcher);
@@ skipping 61 matching lines @@
   MockDBusThreadManager mock_dbus_thread_manager_;
   input_method::MockInputMethodManager mock_input_method_manager_;
   disks::MockDiskMountManager mock_disk_mount_manager_;
   net::TestURLFetcherFactory test_url_fetcher_factory_;
 
   cryptohome::MockAsyncMethodCaller* mock_async_method_caller_;
 
   policy::BrowserPolicyConnector* connector_;
   MockCryptohomeLibrary* cryptohome_;
   Profile* prepared_profile_;
-  Profile* created_profile_;
 
   base::Closure rlz_initialized_cb_;
 
  private:
   base::ScopedTempDir scoped_temp_dir_;
 
   std::string device_policy_;
   std::string user_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsTest);
 };
 
 class LoginUtilsBlockingLoginTest
     : public LoginUtilsTest,
       public testing::WithParamInterface<int> {};
 
 TEST_F(LoginUtilsTest, NormalLoginDoesntBlock) {
   UserManager* user_manager = UserManager::Get();
-  ASSERT_TRUE(!user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_FALSE(connector_->IsEnterpriseManaged());
   EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_NONE,
+            connector_->GetUserAffiliation(kUsername));
 
   // The profile will be created without waiting for a policy response.
   PrepareProfile(kUsername);
 
-  // This should shortcut cookie transfer step that is missing due to
-  // IO thread being mocked.
-  EXPECT_TRUE(created_profile_);
-  LoginUtils::Get()->CompleteProfileCreate(created_profile_);
-
   EXPECT_TRUE(prepared_profile_);
   ASSERT_TRUE(user_manager->IsUserLoggedIn());
   EXPECT_EQ(kUsername, user_manager->GetLoggedInUser()->email());
 }
 
 TEST_F(LoginUtilsTest, EnterpriseLoginDoesntBlockForNormalUser) {
   UserManager* user_manager = UserManager::Get();
-  ASSERT_TRUE(!user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_FALSE(connector_->IsEnterpriseManaged());
   EXPECT_FALSE(prepared_profile_);
 
   // Enroll the device.
-  LockDevice(kUsername);
+  EnrollDevice(kUsername);
 
-  ASSERT_TRUE(!user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_TRUE(connector_->IsEnterpriseManaged());
   EXPECT_EQ(kDomain, connector_->GetEnterpriseDomain());
   EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_NONE,
+            connector_->GetUserAffiliation(kUsernameOtherDomain));
 
   // Login with a non-enterprise user shouldn't block.
   PrepareProfile(kUsernameOtherDomain);
 
-  // This should shortcut cookie transfer step that is missing due to
-  // IO thread being mocked.
-  EXPECT_TRUE(created_profile_);
-  LoginUtils::Get()->CompleteProfileCreate(created_profile_);
-
   EXPECT_TRUE(prepared_profile_);
   ASSERT_TRUE(user_manager->IsUserLoggedIn());
   EXPECT_EQ(kUsernameOtherDomain, user_manager->GetLoggedInUser()->email());
 }
 
 #if defined(ENABLE_RLZ)
 TEST_F(LoginUtilsTest, RlzInitialized) {
   // No RLZ brand code set initially.
   EXPECT_FALSE(local_state_.Get()->HasPrefPath(prefs::kRLZBrand));
 
   base::RunLoop wait_for_rlz_init;
   rlz_initialized_cb_ = wait_for_rlz_init.QuitClosure();
 
   PrepareProfile(kUsername);
 
-  // This should shortcut cookie transfer step that is missing due to
-  // IO thread being mocked.
-  EXPECT_TRUE(created_profile_);
-  LoginUtils::Get()->CompleteProfileCreate(created_profile_);
-
   wait_for_rlz_init.Run();
   // Wait for blocking RLZ tasks to complete.
   RunUntilIdle();
 
   // RLZ brand code has been set to empty string.
   EXPECT_TRUE(local_state_.Get()->HasPrefPath(prefs::kRLZBrand));
   EXPECT_EQ(std::string(), local_state_.Get()->GetString(prefs::kRLZBrand));
 
   // RLZ value for homepage access point should have been initialized.
   string16 rlz_string;
   EXPECT_TRUE(RLZTracker::GetAccessPointRlz(
       RLZTracker::CHROME_HOME_PAGE, &rlz_string));
   EXPECT_EQ(string16(), rlz_string);
 }
 #endif
 
 TEST_P(LoginUtilsBlockingLoginTest, EnterpriseLoginBlocksForEnterpriseUser) {
   UserManager* user_manager = UserManager::Get();
-  ASSERT_TRUE(!user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_FALSE(connector_->IsEnterpriseManaged());
   EXPECT_FALSE(prepared_profile_);
 
   // Enroll the device.
-  LockDevice(kUsername);
+  EnrollDevice(kUsername);
 
-  ASSERT_TRUE(!user_manager->IsUserLoggedIn());
+  EXPECT_FALSE(user_manager->IsUserLoggedIn());
   EXPECT_TRUE(connector_->IsEnterpriseManaged());
   EXPECT_EQ(kDomain, connector_->GetEnterpriseDomain());
   EXPECT_FALSE(prepared_profile_);
+  EXPECT_EQ(policy::USER_AFFILIATION_MANAGED,
+            connector_->GetUserAffiliation(kUsername));
+  EXPECT_FALSE(user_manager->IsKnownUser(kUsername));
 
   // Login with a user of the enterprise domain waits for policy.
   PrepareProfile(kUsername);
 
   EXPECT_FALSE(prepared_profile_);
   ASSERT_TRUE(user_manager->IsUserLoggedIn());
+  EXPECT_TRUE(user_manager->IsCurrentUserNew());
 
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
   net::TestURLFetcher* fetcher;
 
   // |steps| is the test parameter, and is the number of successful fetches.
   // The first incomplete fetch will fail. In any case, the profile creation
   // should resume.
   int steps = GetParam();
 
   do {
@@ skipping 46 matching lines @@
     // Verify that the profile hasn't been created yet.
     EXPECT_FALSE(prepared_profile_);
 
     // Make the current fetcher fail.
     net::TestURLFetcher* fetcher = test_url_fetcher_factory_.GetFetcherByID(0);
     ASSERT_TRUE(fetcher);
     EXPECT_TRUE(fetcher->delegate());
     fetcher->set_url(fetcher->GetOriginalURL());
     fetcher->set_response_code(500);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
+    RunUntilIdle();
   }
 
-  // This should shortcut cookie transfer step that is missing due to
-  // IO thread being mocked.
-  EXPECT_TRUE(created_profile_);
-  LoginUtils::Get()->CompleteProfileCreate(created_profile_);
-
   // The profile is finally ready:
   EXPECT_TRUE(prepared_profile_);
 }
 
 INSTANTIATE_TEST_CASE_P(
     LoginUtilsBlockingLoginTestInstance,
     LoginUtilsBlockingLoginTest,
     testing::Values(0, 1, 2, 3, 4, 5));
 
 }  // namespace
 
 }