UserPolicyCache only becomes ready after policy has been fetched.

chrome/browser/policy/cloud_policy_controller_unittest.cc

 // Copyright (c) 2011 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/policy/cloud_policy_controller.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
@@ skipping 33 matching lines @@
  public:
   CloudPolicyControllerTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~CloudPolicyControllerTest() {}
 
   virtual void SetUp() {
     ASSERT_TRUE(temp_user_data_dir_.CreateUniqueTempDir());
     cache_.reset(new UserPolicyCache(
-        temp_user_data_dir_.path().AppendASCII("CloudPolicyControllerTest")));
+        temp_user_data_dir_.path().AppendASCII("CloudPolicyControllerTest"),
+        false  /* wait_for_policy_fetch */));
     token_fetcher_.reset(new MockDeviceTokenFetcher(cache_.get()));
     EXPECT_CALL(service_, CreateBackend())
         .Times(AnyNumber())
         .WillRepeatedly(MockDeviceManagementServiceProxyBackend(&backend_));
     data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
   }
 
   virtual void TearDown() {
     controller_.reset();  // Unregisters observers.
     data_store_.reset();
   }
 
   void CreateNewController() {
     controller_.reset(new CloudPolicyController(
         &service_, cache_.get(), token_fetcher_.get(), data_store_.get(),
         &notifier_, new DummyWorkScheduler));
   }
 
+  void CreateNewWaitingCache() {
+    cache_.reset(new UserPolicyCache(
+        temp_user_data_dir_.path().AppendASCII("CloudPolicyControllerTest"),
+        true  /* wait_for_policy_fetch */));
+    // Make this cache's disk cache ready, but have it still waiting for a
+    // policy fetch.
+    cache_->Load();
+    loop_.RunAllPending();
+    ASSERT_TRUE(cache_->last_policy_refresh_time().is_null());
+    ASSERT_FALSE(cache_->IsReady());
+  }
+
   void ExpectHasSpdyPolicy() {
     base::FundamentalValue expected(true);
     const PolicyMap* policy_map = cache_->policy(
         CloudPolicyCacheBase::POLICY_LEVEL_MANDATORY);
     ASSERT_TRUE(Value::Equals(&expected, policy_map->Get(kPolicyDisableSpdy)));
   }
 
   void StopMessageLoop() {
     loop_.QuitNow();
   }
@@ skipping 149 matching lines @@
   data_store_->SetupForTesting("device_token", "device_id",
                                "who@what.com", "auth", true);
   EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorServiceInvalidSerialNumber));
   EXPECT_CALL(*token_fetcher_.get(), SetSerialNumberInvalidState()).Times(1);
   CreateNewController();
   loop_.RunAllPending();
 }
 
+TEST_F(CloudPolicyControllerTest, DontSetFetchingDoneWithoutTokens) {
+  CreateNewWaitingCache();
+  CreateNewController();
+  // Initialized without an oauth token, goes into TOKEN_UNAVAILABLE state.
+  // This means the controller is still waiting for an oauth token fetch.
+  EXPECT_FALSE(cache_->IsReady());
+}
+
+TEST_F(CloudPolicyControllerTest, DontSetFetchingDoneWithoutFetching) {
+  CreateNewWaitingCache();
+  data_store_->SetupForTesting("device_token", "device_id",
+                               "who@what.com", "auth", true);
+  CreateNewController();
+  // Initialized with an oauth token, goes into TOKEN_VALID state.
+  // This means the controller has an oauth token and should fetch the next
+  // token, which is the dm server register token.
+  EXPECT_FALSE(cache_->IsReady());
+}
+
+TEST_F(CloudPolicyControllerTest, SetFetchingDoneForUnmanagedUsers) {
+  CreateNewWaitingCache();
+  data_store_->SetupForTesting("", "device_id",
+                               "user@gmail.com", "auth", true);
+  CreateNewController();
+  loop_.RunAllPending();
+  // User is in an unmanaged domain.
+  EXPECT_TRUE(cache_->IsReady());
+  EXPECT_TRUE(cache_->last_policy_refresh_time().is_null());
+}
+
+TEST_F(CloudPolicyControllerTest, SetFetchingDoneAfterPolicyFetch) {
+  CreateNewWaitingCache();
+  data_store_->SetupForTesting("device_token", "device_id",
+                               "user@enterprise.com", "auth", true);
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+      InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
+      MockDeviceManagementBackendSucceedSpdyCloudPolicy()));
+  CreateNewController();
+  loop_.RunAllPending();
+  EXPECT_TRUE(cache_->IsReady());
+  EXPECT_FALSE(cache_->last_policy_refresh_time().is_null());
+}
+
+TEST_F(CloudPolicyControllerTest, SetFetchingDoneAfterPolicyFetchFails) {
+  CreateNewWaitingCache();
+  data_store_->SetupForTesting("device_token", "device_id",
+                               "user@enterprise.com", "auth", true);
+  EXPECT_CALL(backend_, ProcessPolicyRequest(_, _, _, _, _)).WillOnce(DoAll(
+      InvokeWithoutArgs(this, &CloudPolicyControllerTest::StopMessageLoop),
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorRequestFailed)));
+  CreateNewController();
+  loop_.RunAllPending();
+  EXPECT_TRUE(cache_->IsReady());
+  EXPECT_TRUE(cache_->last_policy_refresh_time().is_null());
+}
+
 }  // namespace policy