Index: chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.cc |
diff --git a/chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.cc b/chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.cc |
deleted file mode 100644 |
index e887bfdf72aebfd60cd9df3bb65393f421f156e3..0000000000000000000000000000000000000000 |
--- a/chrome/browser/policy/cloud_policy_refresh_scheduler_unittest.cc |
+++ /dev/null |
@@ -1,294 +0,0 @@ |
-// Copyright (c) 2012 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/callback.h" |
-#include "base/compiler_specific.h" |
-#include "base/memory/ref_counted.h" |
-#include "base/memory/scoped_ptr.h" |
-#include "base/message_loop.h" |
-#include "base/test/test_simple_task_runner.h" |
-#include "chrome/browser/policy/cloud_policy_constants.h" |
-#include "chrome/browser/policy/cloud_policy_refresh_scheduler.h" |
-#include "chrome/browser/policy/mock_cloud_policy_client.h" |
-#include "chrome/browser/policy/mock_cloud_policy_store.h" |
-#include "chrome/browser/prefs/browser_prefs.h" |
-#include "policy/policy_constants.h" |
-#include "testing/gmock/include/gmock/gmock.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-namespace em = enterprise_management; |
- |
-using testing::DoAll; |
-using testing::Mock; |
-using testing::Return; |
-using testing::SaveArg; |
-using testing::_; |
- |
-namespace policy { |
- |
-namespace { |
-const int64 kPolicyRefreshRate = 4 * 60 * 60 * 1000; |
-} // namespace |
- |
-class CloudPolicyRefreshSchedulerTest : public testing::Test { |
- protected: |
- CloudPolicyRefreshSchedulerTest() |
- : task_runner_(new base::TestSimpleTaskRunner()), |
- network_change_notifier_(net::NetworkChangeNotifier::CreateMock()) {} |
- |
- virtual void SetUp() OVERRIDE { |
- client_.SetDMToken("token"); |
- |
- // Set up the protobuf timestamp to be one minute in the past. Since the |
- // protobuf field only has millisecond precision, we convert the actual |
- // value back to get a millisecond-clamped time stamp for the checks below. |
- store_.policy_.reset(new em::PolicyData()); |
- store_.policy_->set_timestamp( |
- ((base::Time::NowFromSystemTime() - base::TimeDelta::FromMinutes(1)) - |
- base::Time::UnixEpoch()).InMilliseconds()); |
- last_refresh_ = |
- base::Time::UnixEpoch() + |
- base::TimeDelta::FromMilliseconds(store_.policy_->timestamp()); |
- } |
- |
- CloudPolicyRefreshScheduler* CreateRefreshScheduler() { |
- CloudPolicyRefreshScheduler* scheduler = |
- new CloudPolicyRefreshScheduler(&client_, &store_, task_runner_); |
- scheduler->SetRefreshDelay(kPolicyRefreshRate); |
- return scheduler; |
- } |
- |
- void NotifyIPAddressChanged() { |
- net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
- loop_.RunUntilIdle(); |
- } |
- |
- base::TimeDelta GetLastDelay() const { |
- const std::deque<base::TestPendingTask>& pending_tasks = |
- task_runner_->GetPendingTasks(); |
- return |
- pending_tasks.empty() ? base::TimeDelta() : pending_tasks.back().delay; |
- } |
- |
- void CheckTiming(int64 expected_delay_ms) const { |
- EXPECT_FALSE(task_runner_->GetPendingTasks().empty()); |
- base::Time now(base::Time::NowFromSystemTime()); |
- base::TimeDelta expected_delay( |
- base::TimeDelta::FromMilliseconds(expected_delay_ms)); |
- EXPECT_GE(GetLastDelay(), expected_delay - (now - last_refresh_)); |
- EXPECT_LE(GetLastDelay(), expected_delay); |
- } |
- |
- MessageLoop loop_; |
- MockCloudPolicyClient client_; |
- MockCloudPolicyStore store_; |
- scoped_refptr<base::TestSimpleTaskRunner> task_runner_; |
- scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_; |
- |
- // Base time for the refresh that the scheduler should be using. |
- base::Time last_refresh_; |
-}; |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshNoPolicy) { |
- store_.policy_.reset(); |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- EXPECT_FALSE(task_runner_->GetPendingTasks().empty()); |
- EXPECT_EQ(GetLastDelay(), base::TimeDelta()); |
- EXPECT_CALL(client_, FetchPolicy()).Times(1); |
- task_runner_->RunUntilIdle(); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshUnmanaged) { |
- store_.policy_->set_state(em::PolicyData::UNMANAGED); |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- CheckTiming(CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs); |
- EXPECT_CALL(client_, FetchPolicy()).Times(1); |
- task_runner_->RunUntilIdle(); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedNotYetFetched) { |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- EXPECT_FALSE(task_runner_->GetPendingTasks().empty()); |
- EXPECT_EQ(GetLastDelay(), base::TimeDelta()); |
- EXPECT_CALL(client_, FetchPolicy()).Times(1); |
- task_runner_->RunUntilIdle(); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, InitialRefreshManagedAlreadyFetched) { |
- last_refresh_ = base::Time::NowFromSystemTime(); |
- client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType, |
- std::string()), |
- em::PolicyFetchResponse()); |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- CheckTiming(kPolicyRefreshRate); |
- EXPECT_CALL(client_, FetchPolicy()).Times(1); |
- task_runner_->RunUntilIdle(); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, Unregistered) { |
- client_.SetDMToken(""); |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- client_.NotifyPolicyFetched(); |
- client_.NotifyRegistrationStateChanged(); |
- client_.NotifyClientError(); |
- scheduler->SetRefreshDelay(12 * 60 * 60 * 1000); |
- store_.NotifyStoreLoaded(); |
- store_.NotifyStoreError(); |
- EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerTest, RefreshSoonRateLimit) { |
- scoped_ptr<CloudPolicyRefreshScheduler> scheduler(CreateRefreshScheduler()); |
- // Max out the request rate. |
- for (int i = 0; i < 5; ++i) { |
- EXPECT_CALL(client_, FetchPolicy()).Times(1); |
- scheduler->RefreshSoon(); |
- task_runner_->RunUntilIdle(); |
- Mock::VerifyAndClearExpectations(&client_); |
- } |
- // The next refresh is throttled. |
- EXPECT_CALL(client_, FetchPolicy()).Times(0); |
- scheduler->RefreshSoon(); |
- task_runner_->RunPendingTasks(); |
- Mock::VerifyAndClearExpectations(&client_); |
-} |
- |
-class CloudPolicyRefreshSchedulerSteadyStateTest |
- : public CloudPolicyRefreshSchedulerTest { |
- protected: |
- CloudPolicyRefreshSchedulerSteadyStateTest() |
- : refresh_scheduler_(&client_, &store_, task_runner_) {} |
- |
- virtual void SetUp() OVERRIDE { |
- refresh_scheduler_.SetRefreshDelay(kPolicyRefreshRate); |
- CloudPolicyRefreshSchedulerTest::SetUp(); |
- last_refresh_ = base::Time::NowFromSystemTime(); |
- client_.NotifyPolicyFetched(); |
- CheckTiming(kPolicyRefreshRate); |
- } |
- |
- CloudPolicyRefreshScheduler refresh_scheduler_; |
-}; |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnPolicyFetched) { |
- client_.NotifyPolicyFetched(); |
- CheckTiming(kPolicyRefreshRate); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnRegistrationStateChanged) { |
- client_.SetDMToken("new_token"); |
- client_.NotifyRegistrationStateChanged(); |
- EXPECT_EQ(GetLastDelay(), base::TimeDelta()); |
- |
- task_runner_->ClearPendingTasks(); |
- client_.SetDMToken(""); |
- client_.NotifyRegistrationStateChanged(); |
- EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnStoreLoaded) { |
- store_.NotifyStoreLoaded(); |
- CheckTiming(kPolicyRefreshRate); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnStoreError) { |
- task_runner_->ClearPendingTasks(); |
- store_.NotifyStoreError(); |
- EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, RefreshDelayChange) { |
- const int delay_short_ms = 5 * 60 * 1000; |
- refresh_scheduler_.SetRefreshDelay(delay_short_ms); |
- CheckTiming(CloudPolicyRefreshScheduler::kRefreshDelayMinMs); |
- |
- const int delay_ms = 12 * 60 * 60 * 1000; |
- refresh_scheduler_.SetRefreshDelay(delay_ms); |
- CheckTiming(delay_ms); |
- |
- const int delay_long_ms = 2 * 24 * 60 * 60 * 1000; |
- refresh_scheduler_.SetRefreshDelay(delay_long_ms); |
- CheckTiming(CloudPolicyRefreshScheduler::kRefreshDelayMaxMs); |
-} |
- |
-TEST_F(CloudPolicyRefreshSchedulerSteadyStateTest, OnIPAddressChanged) { |
- NotifyIPAddressChanged(); |
- CheckTiming(kPolicyRefreshRate); |
- |
- client_.SetStatus(DM_STATUS_REQUEST_FAILED); |
- NotifyIPAddressChanged(); |
- EXPECT_EQ(GetLastDelay(), base::TimeDelta()); |
-} |
- |
-struct ClientErrorTestParam { |
- DeviceManagementStatus client_error; |
- int64 expected_delay_ms; |
- int backoff_factor; |
-}; |
- |
-static const ClientErrorTestParam kClientErrorTestCases[] = { |
- { DM_STATUS_REQUEST_INVALID, |
- CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs, 1 }, |
- { DM_STATUS_REQUEST_FAILED, |
- CloudPolicyRefreshScheduler::kInitialErrorRetryDelayMs, 2 }, |
- { DM_STATUS_TEMPORARY_UNAVAILABLE, |
- CloudPolicyRefreshScheduler::kInitialErrorRetryDelayMs, 2 }, |
- { DM_STATUS_HTTP_STATUS_ERROR, |
- CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs, 1 }, |
- { DM_STATUS_RESPONSE_DECODING_ERROR, |
- CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs, 1 }, |
- { DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED, |
- CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs, 1 }, |
- { DM_STATUS_SERVICE_DEVICE_NOT_FOUND, |
- -1, 1 }, |
- { DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID, |
- -1, 1 }, |
- { DM_STATUS_SERVICE_ACTIVATION_PENDING, |
- kPolicyRefreshRate, 1 }, |
- { DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER, |
- -1, 1 }, |
- { DM_STATUS_SERVICE_MISSING_LICENSES, |
- -1, 1 }, |
- { DM_STATUS_SERVICE_DEVICE_ID_CONFLICT, |
- -1, 1 }, |
- { DM_STATUS_SERVICE_POLICY_NOT_FOUND, |
- kPolicyRefreshRate, 1 }, |
-}; |
- |
-class CloudPolicyRefreshSchedulerClientErrorTest |
- : public CloudPolicyRefreshSchedulerSteadyStateTest, |
- public testing::WithParamInterface<ClientErrorTestParam> { |
-}; |
- |
-TEST_P(CloudPolicyRefreshSchedulerClientErrorTest, OnClientError) { |
- client_.SetStatus(GetParam().client_error); |
- task_runner_->ClearPendingTasks(); |
- |
- // See whether the error triggers the right refresh delay. |
- int64 expected_delay_ms = GetParam().expected_delay_ms; |
- client_.NotifyClientError(); |
- if (expected_delay_ms >= 0) { |
- CheckTiming(expected_delay_ms); |
- |
- // Check whether exponential backoff is working as expected and capped at |
- // the regular refresh rate (if applicable). |
- do { |
- expected_delay_ms *= GetParam().backoff_factor; |
- last_refresh_ = base::Time::NowFromSystemTime(); |
- client_.NotifyClientError(); |
- CheckTiming(std::max(std::min(expected_delay_ms, kPolicyRefreshRate), |
- GetParam().expected_delay_ms)); |
- } while (GetParam().backoff_factor > 1 && |
- expected_delay_ms <= kPolicyRefreshRate); |
- } else { |
- EXPECT_EQ(base::TimeDelta(), GetLastDelay()); |
- EXPECT_TRUE(task_runner_->GetPendingTasks().empty()); |
- } |
-} |
- |
-INSTANTIATE_TEST_CASE_P(CloudPolicyRefreshSchedulerClientErrorTest, |
- CloudPolicyRefreshSchedulerClientErrorTest, |
- testing::ValuesIn(kClientErrorTestCases)); |
- |
-} // namespace policy |