Implement ephemeral users

chrome/browser/chromeos/login/user_manager_unittest.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 <cstdlib>
+#include <cstring>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/values.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/cros_settings.h"
+#include "chrome/browser/chromeos/cros_settings_names.h"
+#include "chrome/browser/chromeos/cros_settings_provider.h"
+#include "chrome/browser/chromeos/login/user.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/stub_cros_settings_provider.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_pref_service.h"
+#include "content/test/test_browser_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+class UserManagerTest : public testing::Test {

[Ivan Korotkov, 2012/03/01 13:37:50]

Looks like this ought to be an InProcessBrowserTest, really.

[use bartfab instead, 2012/03/01 18:33:43]

It does not need the complete browser. I can change it of course, but why make
it more heavyweight?

[Ivan Korotkov, 2012/03/01 20:16:30]

Ok, let's leave it a unittest.

+ public:
+  UserManagerTest()
+      : message_loop_(MessageLoop::TYPE_UI),
+        ui_thread_(content::BrowserThread::UI, &message_loop_),
+        file_thread_(content::BrowserThread::FILE, &message_loop_) {
+  }
+
+  virtual void SetUp() {
+    cros_settings_ = CrosSettings::Get();
+
+    // Replace the real DeviceSettingsProvider with a stub.
+    device_settings_provider_ =
+        cros_settings_->GetProvider(chromeos::kReportDeviceVersionInfo);
+    EXPECT_TRUE(device_settings_provider_ != NULL);
+    EXPECT_TRUE(
+        cros_settings_->RemoveSettingsProvider(device_settings_provider_));
+    cros_settings_->AddSettingsProvider(&stub_settings_provider_);
+
+    // Populate the stub DeviceSettingsProvider with valid values.
+    SetDeviceSettings(false, "");
+
+    // Register an in-memory local settings instance.
+    local_state_.reset(new TestingPrefService);
+    reinterpret_cast<TestingBrowserProcess*>(g_browser_process)
+        ->SetLocalState(local_state_.get());
+    UserManager::RegisterPrefs(local_state_.get());
+
+    user_manager_ = UserManager::Get();
+
+    //

[Ivan Korotkov, 2012/03/01 13:37:50]

Text missing?

[use bartfab instead, 2012/03/01 18:33:43]

Done.

+    ResetUserManagerLoggedInUser();
+  }
+
+  virtual void TearDown() {
+    // Unregister the in-memory local settings instance.
+    reinterpret_cast<TestingBrowserProcess*>(g_browser_process)
+        ->SetLocalState(0);
+
+    // Restore the real DeviceSettingsProvider.
+    EXPECT_TRUE(
+      cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
+    cros_settings_->AddSettingsProvider(device_settings_provider_);
+  }
+
+  scoped_ptr<bool>& GetUserManagerEphemeralUsersEnabled() {
+    return user_manager_->ephemeral_users_enabled_;
+  }
+
+  scoped_ptr<std::string>& GetUserManagerOwner() {
+    return user_manager_->owner_;
+  }
+
+  void ResetUserManagerLoggedInUser() {
+    // One does not simply log out of UserManager. The UserManager is normally

[Ivan Korotkov, 2012/03/01 13:37:50]

This looks very fragile. In case of InProcessBrowserTest (when you don't care
about teardown and this is only need to add multiple users) you can just reset
user_is_logged_in_ before each UserLoggedIn() call.

[use bartfab instead, 2012/03/01 18:33:43]

It would also be sufficient to reset user_is_logged_in_ for a unit test. I am
resetting the rest of the internal state to make the test is less fragile, in
case some code in UserManager comes to rely on it being valid and consistent in
the future.

[Ivan Korotkov, 2012/03/01 20:16:30]

Hmmmm ok. What about adding a method UserManager::LogoutForTest then?

[use bartfab instead, 2012/03/05 18:07:32]

Done.

+    // torn down on logout along with the entire Chrome process. Since this is
+    // not possible in the test environment, UserManager's internal state is
+    // reset instead.
+    if (user_manager_->logged_in_user_ &&
+        user_manager_->current_user_is_ephemeral_)
+      delete user_manager_->logged_in_user_;
+    user_manager_->logged_in_user_ = NULL;

[Ivan Korotkov, 2012/03/01 20:16:30]

Safer to set it to stub_user_ as done initially.

[use bartfab instead, 2012/03/05 18:07:32]

I set it to NULL intentionally. This is the value that logged_in_user_ normally
has until a user logs in. The stub_user_ is a hack needed by other specific test
cases only.

+    user_manager_->current_user_is_owner_ = false;
+    user_manager_->current_user_is_new_ = false;
+    user_manager_->current_user_is_ephemeral_ = false;
+    user_manager_->user_is_logged_in_ = false;
+  }
+
+  void SetDeviceSettings(bool ephemeral_users_enabled,
+                         const std::string &owner) {
+    scoped_ptr<base::Value> ephemeral_users_enabled_value(
+        base::Value::CreateBooleanValue(ephemeral_users_enabled));
+    scoped_ptr<base::Value> owner_value(

[Ivan Korotkov, 2012/03/01 13:37:50]

You don't need heep-allocated values here.

[use bartfab instead, 2012/03/01 18:33:43]

Done.

+        base::Value::CreateStringValue(owner));
+    stub_settings_provider_.Set(kAccountsPrefEphemeralUsersEnabled,
+                                *ephemeral_users_enabled_value.get());
+    stub_settings_provider_.Set(kDeviceOwner, *owner_value.get());
+  }
+
+ protected:
+  UserManager* user_manager_;
+
+  MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+
+  CrosSettings* cros_settings_;
+  CrosSettingsProvider* device_settings_provider_;
+  StubCrosSettingsProvider stub_settings_provider_;
+  scoped_ptr<TestingPrefService> local_state_;
+};
+
+TEST_F(UserManagerTest, RetrieveTrustedDevicePolicies) {
+  GetUserManagerEphemeralUsersEnabled().reset(new bool(true));
+  GetUserManagerOwner().reset(NULL);
+
+  SetDeviceSettings(false, "owner@invalid.domain");
+  user_manager_->RetrieveTrustedDevicePolicies();
+
+  EXPECT_TRUE(GetUserManagerEphemeralUsersEnabled().get() != NULL);
+  EXPECT_FALSE(*GetUserManagerEphemeralUsersEnabled().get());
+  EXPECT_TRUE(GetUserManagerOwner().get() != NULL);
+  EXPECT_EQ(*GetUserManagerOwner().get(), "owner@invalid.domain");
+}
+
+TEST_F(UserManagerTest, RemoveAllExceptOwnerFromList) {
+  user_manager_->UserLoggedIn("owner@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user0@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user1@invalid.domain");
+  ResetUserManagerLoggedInUser();
+
+  const UserList* users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 3);
+  EXPECT_EQ((*users)[0]->email(), "user1@invalid.domain");
+  EXPECT_EQ((*users)[1]->email(), "user0@invalid.domain");
+  EXPECT_EQ((*users)[2]->email(), "owner@invalid.domain");
+
+  SetDeviceSettings(true, "owner@invalid.domain");
+  user_manager_->RetrieveTrustedDevicePolicies();
+
+  users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 1);
+  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+}
+
+TEST_F(UserManagerTest, EphemeralUserLoggedIn) {
+  SetDeviceSettings(true, "owner@invalid.domain");
+  user_manager_->RetrieveTrustedDevicePolicies();
+
+  user_manager_->UserLoggedIn("owner@invalid.domain");
+  ResetUserManagerLoggedInUser();
+  user_manager_->UserLoggedIn("user0@invalid.domain");
+  ResetUserManagerLoggedInUser();
+
+  const UserList* users = &user_manager_->GetUsers();
+  EXPECT_TRUE(users->size() == 1);
+  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+}
+
+}  // namespace chromeos