Enable supervised users password sync/import on ChromeOS

chrome/browser/chromeos/login/managed/supervised_user_creation_browsertest.cc

 // Copyright 2013 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 <string>
 
 
 #include "base/compiler_specific.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/login_manager_test.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/webui_login_view.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/browser/managed_mode/managed_user_registration_utility.h"
 #include "chrome/browser/managed_mode/managed_user_registration_utility_stub.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
+#include "chromeos/cryptohome/mock_homedir_methods.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 
 using testing::_;
 
 namespace chromeos {
 
 namespace {
 
 const char kStubEthernetServicePath[] = "eth0";
 
 const char kTestManager[] = "test-manager@gmail.com";
 const char kTestOtherUser[] = "test-user@gmail.com";
 
 const char kTestManagerPassword[] = "password";
 const char kSupervisedUserDisplayName[] = "John Doe";
 const char kSupervisedUserPassword[] = "simplepassword";
 
 }  // namespace
 
 class SupervisedUserTest : public chromeos::LoginManagerTest {
  protected:
   SupervisedUserTest() : LoginManagerTest(true),
                          mock_async_method_caller_(NULL),
+                         mock_homedir_methods_(NULL),
                          network_portal_detector_(NULL),
                          registration_utility_stub_(NULL) {
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     LoginManagerTest::SetUpInProcessBrowserTestFixture();
     mock_async_method_caller_ = new cryptohome::MockAsyncMethodCaller;
     mock_async_method_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
     cryptohome::AsyncMethodCaller::InitializeForTesting(
         mock_async_method_caller_);
 
+    mock_homedir_methods_ = new cryptohome::MockHomedirMethods;
+    mock_homedir_methods_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
+    cryptohome::HomedirMethods::InitializeForTesting(mock_homedir_methods_);
+
     registration_utility_stub_ = new ManagedUserRegistrationUtilityStub();
     scoped_utility_.reset(
         new ScopedTestingManagedUserRegistrationUtility(
             registration_utility_stub_));
 
     // Setup network portal detector to return online state for both
     // ethernet and wifi networks. Ethernet is an active network by
     // default.
     network_portal_detector_ = new NetworkPortalDetectorTestImpl();
     NetworkPortalDetector::InitializeForTesting(network_portal_detector_);
     NetworkPortalDetector::CaptivePortalState online_state;
     online_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
     online_state.response_code = 204;
     network_portal_detector_->SetDefaultNetworkPathForTesting(
         kStubEthernetServicePath);
     network_portal_detector_->SetDetectionResultsForTesting(
         kStubEthernetServicePath, online_state);
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
     LoginManagerTest::CleanUpOnMainThread();
     scoped_utility_.reset(NULL);
   }
 
   virtual void TearDown() OVERRIDE {
     cryptohome::AsyncMethodCaller::Shutdown();
+    cryptohome::HomedirMethods::Shutdown();
+    mock_homedir_methods_ = NULL;
     mock_async_method_caller_ = NULL;
     LoginManagerTest::TearDown();
   }
 
   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
     NetworkPortalDetector::Shutdown();
   }
 
   void JSEval(const std::string& script) {
     EXPECT_TRUE(content::ExecuteScript(web_contents(), script));
@@ skipping 22 matching lines @@
   }
 
   void PrepareUsers();
   void CreateSupervisedUser();
   void SigninAsSupervisedUser();
   void RemoveSupervisedUser();
   void LogInAsManagerAndFillUserData();
 
  protected:
    cryptohome::MockAsyncMethodCaller* mock_async_method_caller_;
+   cryptohome::MockHomedirMethods* mock_homedir_methods_;
    NetworkPortalDetectorTestImpl* network_portal_detector_;
    ManagedUserRegistrationUtilityStub* registration_utility_stub_;
    scoped_ptr<ScopedTestingManagedUserRegistrationUtility> scoped_utility_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SupervisedUserTest);
 };
 
 void SupervisedUserTest::PrepareUsers() {
   RegisterUser(kTestManager);
@@ skipping 66 matching lines @@
       "#managed-user-creation-password-confirm",
       kSupervisedUserPassword);
 
   JSEval("$('managed-user-creation').updateNextButtonForUser_()");
   JSExpect("!$('managed-user-creation-next-button').disabled");
 }
 
 void SupervisedUserTest::CreateSupervisedUser() {
   LogInAsManagerAndFillUserData();
 
-  EXPECT_CALL(*mock_async_method_caller_, AsyncMount(_, _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_async_method_caller_, AsyncGetSanitizedUsername(_, _))
-      .Times(1);
-  EXPECT_CALL(*mock_async_method_caller_, AsyncAddKey(_, _, _, _))
-      .Times(1);
+  EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
+  EXPECT_CALL(*mock_homedir_methods_, AddKeyEx(_, _, _, _, _)).Times(1);
 
   JSEval("$('managed-user-creation-next-button').click()");
 
-  testing::Mock::VerifyAndClearExpectations(mock_async_method_caller_);
+  testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 
   EXPECT_TRUE(registration_utility_stub_->register_was_called());
   EXPECT_EQ(registration_utility_stub_->display_name(),
             base::UTF8ToUTF16(kSupervisedUserDisplayName));
 
   registration_utility_stub_->RunSuccessCallback("token");
 
   // Token writing moves control to BlockingPool and back.
   base::RunLoop().RunUntilIdle();
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   JSExpect("$('managed-user-creation').currentPage_ == 'created'");
   JSEval("$('managed-user-creation-gotit-button').click()");
 }
 
 void SupervisedUserTest::SigninAsSupervisedUser() {
+  EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
   // Log in as supervised user, make sure that everything works.
   ASSERT_EQ(3UL, UserManager::Get()->GetUsers().size());
   // Created supervised user have to be first in a list.
   const User* user = UserManager::Get()->GetUsers().at(0);
   ASSERT_EQ(base::UTF8ToUTF16(kSupervisedUserDisplayName),
             user->display_name());
   LoginUser(user->email());
+  testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 }
 
 void SupervisedUserTest::RemoveSupervisedUser() {
   // Remove supervised user.
 
   ASSERT_EQ(3UL, UserManager::Get()->GetUsers().size());
   // Created supervised user have to be first in a list.
   const User* user = UserManager::Get()->GetUsers().at(0);
   ASSERT_EQ(base::UTF8ToUTF16(kSupervisedUserDisplayName),
             user->display_name());
@@ skipping 92 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(SupervisedUserTransactionCleanupTest,
     PRE_PRE_CreateAndCancelSupervisedUser) {
   PrepareUsers();
 }
 
 IN_PROC_BROWSER_TEST_F(SupervisedUserTransactionCleanupTest,
     PRE_CreateAndCancelSupervisedUser) {
   LogInAsManagerAndFillUserData();
 
-  EXPECT_CALL(*mock_async_method_caller_, AsyncMount(_, _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_async_method_caller_, AsyncGetSanitizedUsername(_, _))
-      .Times(1);
-  EXPECT_CALL(*mock_async_method_caller_, AsyncAddKey(_, _, _, _))
-      .Times(1);
+  EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
+  EXPECT_CALL(*mock_homedir_methods_, AddKeyEx(_, _, _, _, _)).Times(1);
 
   JSEval("$('managed-user-creation-next-button').click()");
 
-  testing::Mock::VerifyAndClearExpectations(mock_async_method_caller_);
+  testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 
   EXPECT_TRUE(registration_utility_stub_->register_was_called());
   EXPECT_EQ(registration_utility_stub_->display_name(),
             base::UTF8ToUTF16(kSupervisedUserDisplayName));
 
   std::string user_id = registration_utility_stub_->managed_user_id();
   // Make sure user is already in list.
   ASSERT_EQ(3UL, UserManager::Get()->GetUsers().size());
   // We wait for token now. Press cancel button at this point.
   JSEval("$('cancel-add-user-button').click()");
 }
 
 IN_PROC_BROWSER_TEST_F(SupervisedUserTransactionCleanupTest,
     CreateAndCancelSupervisedUser) {
   // Make sure there is no supervised user in list.
   ASSERT_EQ(2UL, UserManager::Get()->GetUsers().size());
 }
 
 }  // namespace chromeos