Persist 'this device is not managed' information

chrome/browser/policy/device_management_policy_provider_unittest.cc

 // Copyright (c) 2010 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/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/mock_configuration_policy_store.h"
 #include "chrome/browser/policy/mock_device_management_backend.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
@@ skipping 12 matching lines @@
 class DeviceManagementPolicyProviderTest : public testing::Test {
  public:
   DeviceManagementPolicyProviderTest()
       : ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   virtual ~DeviceManagementPolicyProviderTest() {}
 
   virtual void SetUp() {
     EXPECT_TRUE(storage_dir_.CreateUniqueTempDir());
+    device_management_dir_ =
+        DeviceManagementPolicyProvider::GetOrCreateDeviceManagementDir(
+            storage_dir_.path());
     CreateNewBackend();
-    CreateNewProvider();
+    CreateNewProviderDontRunPending();
+    EXPECT_TRUE(provider_->WaitingForInitialPolicies());
+    loop_.RunAllPending();
   }
 
   void CreateNewBackend() {
     backend_ = new MockDeviceManagementBackend;
   }
 
   void CreateNewProvider() {

[danno, 2010/11/25 16:35:01]

Probably would be clearer to have:
CreateNewProvider --> just creates provider
CreateNewProviderRunPending --> calls CreateNewProvider and runs all.

[Jakob Kummerow, 2010/11/25 16:54:24]

Done. See Mattias' comment and my reply.

+    CreateNewProviderDontRunPending();
+    loop_.RunAllPending();
+  }
+
+  void CreateNewProviderDontRunPending() {

[Mattias Nissler (ping if slow), 2010/11/25 16:12:36]

Hm, maybe it's worth to just have one of them and make the caller do the
RunAllPending() call when required?

And if not, I'd rather change the names so this function is called
CreateNewProvider and the other one CreateNewProviderAndRunPending.

[Jakob Kummerow, 2010/11/25 16:28:45]

Done.
I went for the first option -- only provide one method, which doesn't include
RunAllPending().

     token_service_.reset(new TokenService);
     provider_.reset(new DeviceManagementPolicyProvider(
         ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList(),
         backend_,
         token_service_.get(),
         storage_dir_.path()));
-    loop_.RunAllPending();
   }
 
   void SimulateSuccessfulLoginAndRunPending() {
     loop_.RunAllPending();
     token_service_->IssueAuthTokenForTest(
         GaiaConstants::kDeviceManagementService, kTestToken);
     loop_.RunAllPending();
   }
 
   void SimulateSuccessfulInitialPolicyFetch() {
     MockConfigurationPolicyStore store;
     EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedRegister());
     EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
         MockDeviceManagementBackendSucceedBooleanPolicy(
             key::kDisableSpdy, true));
     SimulateSuccessfulLoginAndRunPending();
+    EXPECT_FALSE(provider_->WaitingForInitialPolicies());
     EXPECT_CALL(store, Apply(kPolicyDisableSpdy, _)).Times(1);
     provider_->Provide(&store);
     ASSERT_EQ(1U, store.policy_map().size());
     Mock::VerifyAndClearExpectations(backend_);
     Mock::VerifyAndClearExpectations(&store);
   }
 
+  void OverwriteUnmanagedDeviceTimestamp(const FilePath& storage_dir,
+                                         const base::Time& timestamp) {
+    DeviceManagementPolicyProvider::CreateUnmanagedDeviceMarker(
+        storage_dir, timestamp);
+  }
+
   virtual void TearDown() {
     loop_.RunAllPending();
   }
 
   MockDeviceManagementBackend* backend_;  // weak
   scoped_ptr<DeviceManagementPolicyProvider> provider_;
 
  protected:
   void SetRefreshDelays(DeviceManagementPolicyProvider* provider,
                         int64 policy_refresh_rate_ms,
                         int64 policy_refresh_max_earlier_ms,
                         int64 policy_refresh_error_delay_ms,
                         int64 token_fetch_error_delay_ms) {
     provider->set_policy_refresh_rate_ms(policy_refresh_rate_ms);
     provider->set_policy_refresh_max_earlier_ms(policy_refresh_max_earlier_ms);
     provider->set_policy_refresh_error_delay_ms(policy_refresh_error_delay_ms);
     provider->set_token_fetch_error_delay_ms(token_fetch_error_delay_ms);
   }
 
+  MessageLoop loop_;
+  ScopedTempDir storage_dir_;
+  FilePath device_management_dir_;
+
  private:
-  MessageLoop loop_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
-  ScopedTempDir storage_dir_;
   scoped_ptr<TokenService> token_service_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyProviderTest);
 };
 
 // If there's no login and no previously-fetched policy, the provider should
 // provide an empty policy.
 TEST_F(DeviceManagementPolicyProviderTest, InitialProvideNoLogin) {
   MockConfigurationPolicyStore store;
   EXPECT_CALL(store, Apply(_, _)).Times(0);
   provider_->Provide(&store);
   EXPECT_TRUE(store.policy_map().empty());
+  EXPECT_TRUE(provider_->WaitingForInitialPolicies());
 }
 
 // If the login is successful and there's no previously-fetched policy, the
 // policy should be fetched from the server and should be available the first
 // time the Provide method is called.
 TEST_F(DeviceManagementPolicyProviderTest, InitialProvideWithLogin) {
+  EXPECT_TRUE(provider_->WaitingForInitialPolicies());
   SimulateSuccessfulInitialPolicyFetch();
 }
 
 // If the login succeed but the device management backend is unreachable,
 // there should be no policy provided if there's no previously-fetched policy,
 TEST_F(DeviceManagementPolicyProviderTest, EmptyProvideWithFailedBackend) {
   MockConfigurationPolicyStore store;
   EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailRegister(
           DeviceManagementBackend::kErrorRequestFailed));
@@ skipping 74 matching lines @@
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorRequestFailed));
   SimulateSuccessfulLoginAndRunPending();
 }
 
+// This test tests three things (see numbered comments below):
+TEST_F(DeviceManagementPolicyProviderTest, UnmanagedDevice) {
+  InSequence s;
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailRegister(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
+  SimulateSuccessfulLoginAndRunPending();
+  // (1) Since the backend call returned "unmanaged", the corresponding marker
+  // file should have been created.
+  FilePath path(device_management_dir_.Append("UnmanagedDevice"));
+  EXPECT_TRUE(file_util::PathExists(path));
+  // Manipulate the timestamp to trick the restarted provider into re-checking
+  // immediately.
+  OverwriteUnmanagedDeviceTimestamp(
+      device_management_dir_,
+      base::Time::NowFromSystemTime() - base::TimeDelta::FromDays(2));
+  CreateNewBackend();
+  CreateNewProviderDontRunPending();
+  // (2) On restart, the provider should detect that this is not the first
+  // login.
+  EXPECT_FALSE(provider_->WaitingForInitialPolicies());
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  SimulateSuccessfulLoginAndRunPending();
+  // (3) Since the backend call this time returned a device id, the "unmanaged"
+  // marker should have been deleted.
+  EXPECT_FALSE(file_util::PathExists(path));
+}
+
 }  // namespace policy