Store/Retrieve CrOS user policy in session_manager.

chrome/browser/policy/cros_user_policy_cache_unittest.cc

Index: chrome/browser/policy/cros_user_policy_cache_unittest.cc
diff --git a/chrome/browser/policy/cros_user_policy_cache_unittest.cc b/chrome/browser/policy/cros_user_policy_cache_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..afff4995a28ceaceba7ba1f6f2c0dd24ca50a900
--- /dev/null
+++ b/chrome/browser/policy/cros_user_policy_cache_unittest.cc
@@ -0,0 +1,190 @@
+// 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 "base/bind.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/scoped_temp_dir.h"
+#include "base/time.h"
+#include "chrome/browser/policy/cloud_policy_data_store.h"
+#include "chrome/browser/policy/cros_user_policy_cache.h"
+#include "chrome/browser/policy/proto/cloud_policy.pb.h"
+#include "chrome/browser/policy/proto/device_management_backend.pb.h"
+#include "chrome/browser/policy/proto/device_management_local.pb.h"
+#include "chromeos/dbus/mock_session_manager_client.h"
+#include "content/test/test_browser_thread.h"
+#include "policy/policy_constants.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::InvokeArgument;
+using testing::_;
+
+namespace em = enterprise_management;
+
+// These should probably be moved to a more central place.
+ACTION_TEMPLATE(InvokeCallbackArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(p1)) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(::std::tr1::get<k>(args), p1));
+}
+ACTION_TEMPLATE(InvokeCallbackArgument,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_2_VALUE_PARAMS(p1, p2)) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(::std::tr1::get<k>(args), p1, p2));
+}
+
+namespace policy {
+namespace {
+
+const char kFakeToken[] = "token";
+const char kFakeSignature[] = "signature";
+const char kFakeMachineName[] = "machine-name";
+const char kFakeUsername[] = "username";
+const int kFakePublicKeyVersion = 17;
+const char kFakeDeviceId[] = "device-id";
+
+class CrosUserPolicyCacheTest : public testing::Test {
+ protected:
+  CrosUserPolicyCacheTest()
+      : loop_(MessageLoop::TYPE_UI),
+        data_store_(CloudPolicyDataStore::CreateForUserPolicies()),
+        ui_thread_(content::BrowserThread::UI, &loop_),
+        file_thread_(content::BrowserThread::FILE, &loop_) {}
+
+  virtual void SetUp() {
+    ASSERT_TRUE(tmp_dir_.CreateUniqueTempDir());
+  }
+
+  void CreatePolicyResponse(em::PolicyFetchResponse* response) {
+    em::CloudPolicySettings policy_settings;
+    policy_settings.mutable_showhomebutton()->set_showhomebutton(true);
+
+    em::PolicyData policy_data;
+    policy_data.set_policy_type(dm_protocol::kChromeUserPolicyType);
+    policy_data.set_timestamp((base::Time::NowFromSystemTime() -
+                               base::Time::UnixEpoch()).InMilliseconds());
+    policy_data.set_request_token(kFakeToken);
+    ASSERT_TRUE(
+        policy_settings.SerializeToString(policy_data.mutable_policy_value()));
+    policy_data.set_machine_name(kFakeMachineName);
+    policy_data.set_public_key_version(kFakePublicKeyVersion);
+    policy_data.set_username(kFakeUsername);
+    policy_data.set_device_id(kFakeDeviceId);
+    policy_data.set_state(em::PolicyData::ACTIVE);
+
+    ASSERT_TRUE(policy_data.SerializeToString(response->mutable_policy_data()));
+    response->set_policy_data_signature(kFakeSignature);
+  }
+
+  FilePath token_file() {
+    return tmp_dir_.path().Append(FILE_PATH_LITERAL("token"));
+  }
+
+  FilePath policy_file() {
+    return tmp_dir_.path().Append(FILE_PATH_LITERAL("policy"));
+  }
+
+  MessageLoop loop_;
+
+  chromeos::MockSessionManagerClient session_manager_client_;
+  scoped_ptr<CloudPolicyDataStore> data_store_;
+
+ private:
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+  ScopedTempDir tmp_dir_;
+
+  DISALLOW_COPY_AND_ASSIGN(CrosUserPolicyCacheTest);
+};
+
+TEST_F(CrosUserPolicyCacheTest, InitAndSetPolicy) {
+  CrosUserPolicyCache cache(&session_manager_client_,
+                            data_store_.get(),
+                            false,
+                            token_file(),
+                            policy_file());
+  EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(data_store_->token_cache_loaded());
+
+  // Initialize the cache.
+  EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_))
+      .WillOnce(InvokeCallbackArgument<0>(std::string()));
+
+  cache.Load();
+  loop_.RunAllPending();
+
+  EXPECT_TRUE(cache.IsReady());
+  EXPECT_TRUE(data_store_->token_cache_loaded());
+  EXPECT_EQ(0U, cache.policy()->size());
+
+  // Set policy.
+  em::PolicyFetchResponse response;
+  CreatePolicyResponse(&response);
+  std::string serialized_response;
+  ASSERT_TRUE(response.SerializeToString(&serialized_response));
+  testing::Sequence seq;
+  EXPECT_CALL(session_manager_client_, StoreUserPolicy(serialized_response, _))
+      .InSequence(seq)
+      .WillOnce(InvokeCallbackArgument<1>(true));
+  EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_))
+      .InSequence(seq)
+      .WillOnce(InvokeCallbackArgument<0>(serialized_response));
+
+  EXPECT_TRUE(cache.SetPolicy(response));
+  loop_.RunAllPending();
+
+  EXPECT_EQ(1U, cache.policy()->size());
+  const PolicyMap::Entry* entry = cache.policy()->Get(key::kShowHomeButton);
+  ASSERT_TRUE(entry);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(entry->value));
+};
+
+TEST_F(CrosUserPolicyCacheTest, Migration) {
+  std::string data;
+
+  em::DeviceCredentials credentials;
+  credentials.set_device_token(kFakeToken);
+  credentials.set_device_id(kFakeDeviceId);
+  ASSERT_TRUE(credentials.SerializeToString(&data));
+  ASSERT_NE(-1, file_util::WriteFile(token_file(), data.c_str(), data.size()));
+
+  em::CachedCloudPolicyResponse policy;
+  CreatePolicyResponse(policy.mutable_cloud_policy());
+  ASSERT_TRUE(policy.SerializeToString(&data));
+  ASSERT_NE(-1, file_util::WriteFile(policy_file(), data.c_str(), data.size()));
+
+  CrosUserPolicyCache cache(&session_manager_client_,
+                            data_store_.get(),
+                            false,
+                            token_file(),
+                            policy_file());
+  EXPECT_FALSE(cache.IsReady());
+  EXPECT_FALSE(data_store_->token_cache_loaded());
+
+  // Initialize the cache.
+  EXPECT_CALL(session_manager_client_, RetrieveUserPolicy(_))
+      .WillOnce(InvokeCallbackArgument<0>(std::string()));
+
+  cache.Load();
+  loop_.RunAllPending();
+
+  EXPECT_TRUE(cache.IsReady());
+  EXPECT_TRUE(data_store_->token_cache_loaded());
+  EXPECT_EQ(kFakeDeviceId, data_store_->device_id());
+  EXPECT_EQ(kFakeToken, data_store_->device_token());
+  EXPECT_EQ(1U, cache.policy()->size());
+  const PolicyMap::Entry* entry = cache.policy()->Get(key::kShowHomeButton);
+  ASSERT_TRUE(entry);
+  EXPECT_TRUE(base::FundamentalValue(true).Equals(entry->value));
+};
+
+}  // namespace
+}  // namespace policy