src/chrome/browser/policy/policy_statistics_collector_unittest.cc

   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 <cstring>
   6 #include <string>
   7
   8 #include "base/callback.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/prefs/pref_registry_simple.h"
  13 #include "base/prefs/testing_pref_service.h"
  14 #include "base/test/test_simple_task_runner.h"
  15 #include "base/time/time.h"
  16 #include "base/values.h"
  17 #include "chrome/browser/policy/external_data_fetcher.h"
  18 #include "chrome/browser/policy/mock_policy_service.h"
  19 #include "chrome/browser/policy/policy_map.h"
  20 #include "chrome/browser/policy/policy_statistics_collector.h"
  21 #include "chrome/browser/policy/policy_types.h"
  22 #include "components/policy/core/common/policy_pref_names.h"
  23 #include "policy/policy_constants.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 namespace policy {
  28
  29 namespace {
  30
  31 using testing::_;
  32 using testing::Lt;
  33 using testing::Return;
  34 using testing::ReturnRef;
  35
  36 // Arbitrary policy names used for testing.
  37 const char* const kTestPolicy1 = key::kAlternateErrorPagesEnabled;
  38 const char* const kTestPolicy2 = key::kSearchSuggestEnabled;
  39
  40 class TestPolicyStatisticsCollector : public PolicyStatisticsCollector {
  41  public:
  42   TestPolicyStatisticsCollector(
  43       PolicyService* policy_service,
  44       PrefService* prefs,
  45       const scoped_refptr<base::TaskRunner>& task_runner)
  46       : PolicyStatisticsCollector(policy_service, prefs, task_runner) {
  47   }
  48
  49   MOCK_METHOD1(RecordPolicyUse, void(int));
  50 };
  51
  52 }  // namespace
  53
  54 class PolicyStatisticsCollectorTest : public testing::Test {
  55  protected:
  56   PolicyStatisticsCollectorTest()
  57       : update_delay_(base::TimeDelta::FromMilliseconds(
  58             PolicyStatisticsCollector::kStatisticsUpdateRate)),
  59         test_policy_id1_(-1),
  60         test_policy_id2_(-1),
  61         task_runner_(new base::TestSimpleTaskRunner()) {
  62   }
  63
  64   virtual void SetUp() OVERRIDE {
  65     prefs_.registry()->RegisterInt64Pref(
  66         policy_prefs::kLastPolicyStatisticsUpdate, 0);
  67
  68     // Find ids for kTestPolicy1 and kTestPolicy2.
  69     const policy::PolicyDefinitionList* policy_list =
  70         policy::GetChromePolicyDefinitionList();
  71     for (const policy::PolicyDefinitionList::Entry* policy = policy_list->begin;
  72          policy != policy_list->end; ++policy) {
  73       if (strcmp(policy->name, kTestPolicy1) == 0)
  74         test_policy_id1_ = policy->id;
  75       else if (strcmp(policy->name, kTestPolicy2) == 0)
  76         test_policy_id2_ = policy->id;
  77     }
  78     ASSERT_TRUE(test_policy_id1_ != -1);
  79     ASSERT_TRUE(test_policy_id2_ != -1);
  80
  81     // Set up default function behaviour.
  82     EXPECT_CALL(policy_service_,
  83                 GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME,
  84                                             std::string())))
  85         .WillRepeatedly(ReturnRef(policy_map_));
  86
  87     // Arbitrary negative value (so it'll be different from |update_delay_|).
  88     last_delay_ = base::TimeDelta::FromDays(-1);
  89     policy_map_.Clear();
  90     policy_statistics_collector_.reset(new TestPolicyStatisticsCollector(
  91         &policy_service_,
  92         &prefs_,
  93         task_runner_));
  94   }
  95
  96   void SetPolicy(const std::string& name) {
  97     policy_map_.Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
  98                     base::Value::CreateBooleanValue(true), NULL);
  99   }
 100
 101   base::TimeDelta GetFirstDelay() const {
 102     if (task_runner_->GetPendingTasks().empty()) {
 103       ADD_FAILURE();
 104       return base::TimeDelta();
 105     }
 106     return task_runner_->GetPendingTasks().front().delay;
 107   }
 108
 109   const base::TimeDelta update_delay_;
 110
 111   int test_policy_id1_;
 112   int test_policy_id2_;
 113
 114   base::TimeDelta last_delay_;
 115
 116   TestingPrefServiceSimple prefs_;
 117   MockPolicyService policy_service_;
 118   PolicyMap policy_map_;
 119
 120   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 121   scoped_ptr<TestPolicyStatisticsCollector> policy_statistics_collector_;
 122 };
 123
 124 TEST_F(PolicyStatisticsCollectorTest, CollectPending) {
 125   SetPolicy(kTestPolicy1);
 126
 127   prefs_.SetInt64(policy_prefs::kLastPolicyStatisticsUpdate,
 128                   (base::Time::Now() - update_delay_).ToInternalValue());
 129
 130   EXPECT_CALL(*policy_statistics_collector_.get(),
 131               RecordPolicyUse(test_policy_id1_));
 132
 133   policy_statistics_collector_->Initialize();
 134   EXPECT_EQ(1u, task_runner_->GetPendingTasks().size());
 135   EXPECT_EQ(update_delay_, GetFirstDelay());
 136 }
 137
 138 TEST_F(PolicyStatisticsCollectorTest, CollectPendingVeryOld) {
 139   SetPolicy(kTestPolicy1);
 140
 141   // Must not be 0.0 (read comment for Time::FromDoubleT).
 142   prefs_.SetInt64(policy_prefs::kLastPolicyStatisticsUpdate,
 143                   base::Time::FromDoubleT(1.0).ToInternalValue());
 144
 145   EXPECT_CALL(*policy_statistics_collector_.get(),
 146               RecordPolicyUse(test_policy_id1_));
 147
 148   policy_statistics_collector_->Initialize();
 149   EXPECT_EQ(1u, task_runner_->GetPendingTasks().size());
 150   EXPECT_EQ(update_delay_, GetFirstDelay());
 151 }
 152
 153 TEST_F(PolicyStatisticsCollectorTest, CollectLater) {
 154   SetPolicy(kTestPolicy1);
 155
 156   prefs_.SetInt64(policy_prefs::kLastPolicyStatisticsUpdate,
 157                   (base::Time::Now() - update_delay_ / 2).ToInternalValue());
 158
 159   policy_statistics_collector_->Initialize();
 160   EXPECT_EQ(1u, task_runner_->GetPendingTasks().size());
 161   EXPECT_LT(GetFirstDelay(), update_delay_);
 162 }
 163
 164 TEST_F(PolicyStatisticsCollectorTest, MultiplePolicies) {
 165   SetPolicy(kTestPolicy1);
 166   SetPolicy(kTestPolicy2);
 167
 168   prefs_.SetInt64(policy_prefs::kLastPolicyStatisticsUpdate,
 169                   (base::Time::Now() - update_delay_).ToInternalValue());
 170
 171   EXPECT_CALL(*policy_statistics_collector_.get(),
 172               RecordPolicyUse(test_policy_id1_));
 173   EXPECT_CALL(*policy_statistics_collector_.get(),
 174               RecordPolicyUse(test_policy_id2_));
 175
 176   policy_statistics_collector_->Initialize();
 177   EXPECT_EQ(1u, task_runner_->GetPendingTasks().size());
 178 }
 179
 180 }  // namespace policy