Home | History | Annotate | Download | only in cloud 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/policy/core/common/cloud/cloud_policy_core.h"
      6 
      7 #include "base/basictypes.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "base/prefs/pref_registry_simple.h"
     10 #include "base/prefs/testing_pref_service.h"
     11 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
     12 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
     13 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
     14 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
     15 #include "components/policy/core/common/policy_pref_names.h"
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 
     18 namespace policy {
     19 
     20 class CloudPolicyCoreTest : public testing::Test,
     21                             public CloudPolicyCore::Observer {
     22  protected:
     23   CloudPolicyCoreTest()
     24       : core_(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
     25                                  std::string()),
     26               &store_,
     27               loop_.message_loop_proxy()),
     28         core_connected_callback_count_(0),
     29         refresh_scheduler_started_callback_count_(0),
     30         core_disconnecting_callback_count_(0),
     31         bad_callback_count_(0) {
     32     prefs_.registry()->RegisterIntegerPref(
     33         policy_prefs::kUserPolicyRefreshRate,
     34         CloudPolicyRefreshScheduler::kDefaultRefreshDelayMs);
     35     core_.AddObserver(this);
     36   }
     37 
     38   virtual ~CloudPolicyCoreTest() {
     39     core_.RemoveObserver(this);
     40   }
     41 
     42   virtual void OnCoreConnected(CloudPolicyCore* core) OVERRIDE {
     43     // Make sure core is connected at callback time.
     44     if (core_.client())
     45       core_connected_callback_count_++;
     46     else
     47       bad_callback_count_++;
     48   }
     49 
     50   virtual void OnRefreshSchedulerStarted(CloudPolicyCore* core) OVERRIDE {
     51     // Make sure refresh scheduler is started at callback time.
     52     if (core_.refresh_scheduler())
     53       refresh_scheduler_started_callback_count_++;
     54     else
     55       bad_callback_count_++;
     56   }
     57 
     58   virtual void OnCoreDisconnecting(CloudPolicyCore* core) OVERRIDE {
     59     // Make sure core is still connected at callback time.
     60     if (core_.client())
     61       core_disconnecting_callback_count_++;
     62     else
     63       bad_callback_count_++;
     64   }
     65 
     66   base::MessageLoop loop_;
     67 
     68   TestingPrefServiceSimple prefs_;
     69   MockCloudPolicyStore store_;
     70   CloudPolicyCore core_;
     71 
     72   int core_connected_callback_count_;
     73   int refresh_scheduler_started_callback_count_;
     74   int core_disconnecting_callback_count_;
     75   int bad_callback_count_;
     76 
     77  private:
     78   DISALLOW_COPY_AND_ASSIGN(CloudPolicyCoreTest);
     79 };
     80 
     81 TEST_F(CloudPolicyCoreTest, ConnectAndDisconnect) {
     82   EXPECT_TRUE(core_.store());
     83   EXPECT_FALSE(core_.client());
     84   EXPECT_FALSE(core_.service());
     85   EXPECT_FALSE(core_.refresh_scheduler());
     86 
     87   // Connect() brings up client and service.
     88   core_.Connect(scoped_ptr<CloudPolicyClient>(new MockCloudPolicyClient()));
     89   EXPECT_TRUE(core_.client());
     90   EXPECT_TRUE(core_.service());
     91   EXPECT_FALSE(core_.refresh_scheduler());
     92   EXPECT_EQ(1, core_connected_callback_count_);
     93   EXPECT_EQ(0, refresh_scheduler_started_callback_count_);
     94   EXPECT_EQ(0, core_disconnecting_callback_count_);
     95 
     96   // Disconnect() goes back to no client and service.
     97   core_.Disconnect();
     98   EXPECT_FALSE(core_.client());
     99   EXPECT_FALSE(core_.service());
    100   EXPECT_FALSE(core_.refresh_scheduler());
    101   EXPECT_EQ(1, core_connected_callback_count_);
    102   EXPECT_EQ(0, refresh_scheduler_started_callback_count_);
    103   EXPECT_EQ(1, core_disconnecting_callback_count_);
    104 
    105   // Calling Disconnect() twice doesn't do bad things.
    106   core_.Disconnect();
    107   EXPECT_FALSE(core_.client());
    108   EXPECT_FALSE(core_.service());
    109   EXPECT_FALSE(core_.refresh_scheduler());
    110   EXPECT_EQ(1, core_connected_callback_count_);
    111   EXPECT_EQ(0, refresh_scheduler_started_callback_count_);
    112   EXPECT_EQ(1, core_disconnecting_callback_count_);
    113   EXPECT_EQ(0, bad_callback_count_);
    114 }
    115 
    116 TEST_F(CloudPolicyCoreTest, RefreshScheduler) {
    117   EXPECT_FALSE(core_.refresh_scheduler());
    118   core_.Connect(scoped_ptr<CloudPolicyClient>(new MockCloudPolicyClient()));
    119   core_.StartRefreshScheduler();
    120   ASSERT_TRUE(core_.refresh_scheduler());
    121 
    122   int default_refresh_delay = core_.refresh_scheduler()->refresh_delay();
    123 
    124   const int kRefreshRate = 1000 * 60 * 60;
    125   prefs_.SetInteger(policy_prefs::kUserPolicyRefreshRate, kRefreshRate);
    126   core_.TrackRefreshDelayPref(&prefs_, policy_prefs::kUserPolicyRefreshRate);
    127   EXPECT_EQ(kRefreshRate, core_.refresh_scheduler()->refresh_delay());
    128 
    129   prefs_.ClearPref(policy_prefs::kUserPolicyRefreshRate);
    130   EXPECT_EQ(default_refresh_delay, core_.refresh_scheduler()->refresh_delay());
    131 
    132   EXPECT_EQ(1, core_connected_callback_count_);
    133   EXPECT_EQ(1, refresh_scheduler_started_callback_count_);
    134   EXPECT_EQ(0, core_disconnecting_callback_count_);
    135   EXPECT_EQ(0, bad_callback_count_);
    136 }
    137 
    138 }  // namespace policy
    139