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/testing_pref_service.h" 13 #include "base/test/test_simple_task_runner.h" 14 #include "base/time/time.h" 15 #include "base/values.h" 16 #include "chrome/browser/policy/external_data_fetcher.h" 17 #include "chrome/browser/policy/mock_policy_service.h" 18 #include "chrome/browser/policy/policy_map.h" 19 #include "chrome/browser/policy/policy_statistics_collector.h" 20 #include "chrome/browser/policy/policy_types.h" 21 #include "chrome/browser/prefs/browser_prefs.h" 22 #include "chrome/common/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 chrome::RegisterLocalState(prefs_.registry()); 66 67 // Find ids for kTestPolicy1 and kTestPolicy2. 68 const policy::PolicyDefinitionList* policy_list = 69 policy::GetChromePolicyDefinitionList(); 70 for (const policy::PolicyDefinitionList::Entry* policy = policy_list->begin; 71 policy != policy_list->end; ++policy) { 72 if (strcmp(policy->name, kTestPolicy1) == 0) 73 test_policy_id1_ = policy->id; 74 else if (strcmp(policy->name, kTestPolicy2) == 0) 75 test_policy_id2_ = policy->id; 76 } 77 ASSERT_TRUE(test_policy_id1_ != -1); 78 ASSERT_TRUE(test_policy_id2_ != -1); 79 80 // Set up default function behaviour. 81 EXPECT_CALL(policy_service_, 82 GetPolicies(PolicyNamespace(POLICY_DOMAIN_CHROME, 83 std::string()))) 84 .WillRepeatedly(ReturnRef(policy_map_)); 85 86 // Arbitrary negative value (so it'll be different from |update_delay_|). 87 last_delay_ = base::TimeDelta::FromDays(-1); 88 policy_map_.Clear(); 89 policy_statistics_collector_.reset(new TestPolicyStatisticsCollector( 90 &policy_service_, 91 &prefs_, 92 task_runner_)); 93 } 94 95 void SetPolicy(const std::string& name) { 96 policy_map_.Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, 97 base::Value::CreateBooleanValue(true), NULL); 98 } 99 100 base::TimeDelta GetFirstDelay() const { 101 if (task_runner_->GetPendingTasks().empty()) { 102 ADD_FAILURE(); 103 return base::TimeDelta(); 104 } 105 return task_runner_->GetPendingTasks().front().delay; 106 } 107 108 const base::TimeDelta update_delay_; 109 110 int test_policy_id1_; 111 int test_policy_id2_; 112 113 base::TimeDelta last_delay_; 114 115 TestingPrefServiceSimple prefs_; 116 MockPolicyService policy_service_; 117 PolicyMap policy_map_; 118 119 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; 120 scoped_ptr<TestPolicyStatisticsCollector> policy_statistics_collector_; 121 }; 122 123 TEST_F(PolicyStatisticsCollectorTest, CollectPending) { 124 SetPolicy(kTestPolicy1); 125 126 prefs_.SetInt64(prefs::kLastPolicyStatisticsUpdate, 127 (base::Time::Now() - update_delay_).ToInternalValue()); 128 129 EXPECT_CALL(*policy_statistics_collector_.get(), 130 RecordPolicyUse(test_policy_id1_)); 131 132 policy_statistics_collector_->Initialize(); 133 EXPECT_EQ(1u, task_runner_->GetPendingTasks().size()); 134 EXPECT_EQ(update_delay_, GetFirstDelay()); 135 } 136 137 TEST_F(PolicyStatisticsCollectorTest, CollectPendingVeryOld) { 138 SetPolicy(kTestPolicy1); 139 140 // Must not be 0.0 (read comment for Time::FromDoubleT). 141 prefs_.SetInt64(prefs::kLastPolicyStatisticsUpdate, 142 base::Time::FromDoubleT(1.0).ToInternalValue()); 143 144 EXPECT_CALL(*policy_statistics_collector_.get(), 145 RecordPolicyUse(test_policy_id1_)); 146 147 policy_statistics_collector_->Initialize(); 148 EXPECT_EQ(1u, task_runner_->GetPendingTasks().size()); 149 EXPECT_EQ(update_delay_, GetFirstDelay()); 150 } 151 152 TEST_F(PolicyStatisticsCollectorTest, CollectLater) { 153 SetPolicy(kTestPolicy1); 154 155 prefs_.SetInt64(prefs::kLastPolicyStatisticsUpdate, 156 (base::Time::Now() - update_delay_ / 2).ToInternalValue()); 157 158 policy_statistics_collector_->Initialize(); 159 EXPECT_EQ(1u, task_runner_->GetPendingTasks().size()); 160 EXPECT_LT(GetFirstDelay(), update_delay_); 161 } 162 163 TEST_F(PolicyStatisticsCollectorTest, MultiplePolicies) { 164 SetPolicy(kTestPolicy1); 165 SetPolicy(kTestPolicy2); 166 167 prefs_.SetInt64(prefs::kLastPolicyStatisticsUpdate, 168 (base::Time::Now() - update_delay_).ToInternalValue()); 169 170 EXPECT_CALL(*policy_statistics_collector_.get(), 171 RecordPolicyUse(test_policy_id1_)); 172 EXPECT_CALL(*policy_statistics_collector_.get(), 173 RecordPolicyUse(test_policy_id2_)); 174 175 policy_statistics_collector_->Initialize(); 176 EXPECT_EQ(1u, task_runner_->GetPendingTasks().size()); 177 } 178 179 } // namespace policy 180
