Add an extra delay for policy invalidations to be available.

chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sample_map.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/run_loop.h"
+#include "base/test/simple_test_clock.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/enterprise_metrics.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
@@ skipping 113 matching lines @@
   bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 
   // Determines if the invalidator has registered for an object with the
   // invalidation service.
   bool IsInvalidatorRegistered();
 
   // Get the current count for the given metric.
   base::HistogramBase::Count GetCount(MetricPolicyRefresh metric);
   base::HistogramBase::Count GetInvalidationCount(bool with_payload);
 
+  // Advance the test clock.
+  void AdvanceClock(base::TimeDelta delta);
+
  private:
   // Checks that the policy was refreshed due to an invalidation with the given
   // base delay.
   bool CheckPolicyRefreshed(base::TimeDelta delay);
 
   // Checks that the policy was refreshed the given number of times.
   bool CheckPolicyRefreshCount(int count);
 
   // Returns the object id of the given policy object.
   const invalidation::ObjectId& GetPolicyObjectId(PolicyObject object) const;
 
   // Get histogram samples for the given histogram.
   scoped_ptr<base::HistogramSamples> GetHistogramSamples(
       const std::string& name) const;
 
   base::MessageLoop loop_;
 
   // Objects the invalidator depends on.
   invalidation::FakeInvalidationService invalidation_service_;
   MockCloudPolicyStore store_;
   CloudPolicyCore core_;
   MockCloudPolicyClient* client_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::SimpleTestClock* clock_;
 
   // The invalidator which will be tested.
   scoped_ptr<CloudPolicyInvalidator> invalidator_;
 
   // Object ids for the test policy objects.
   invalidation::ObjectId object_id_a_;
   invalidation::ObjectId object_id_b_;
 
   // Increasing policy timestamp.
   int64 timestamp_;
@@ skipping 13 matching lines @@
   scoped_ptr<base::HistogramSamples> invalidations_samples_;
 };
 
 CloudPolicyInvalidatorTest::CloudPolicyInvalidatorTest()
     : core_(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
                                std::string()),
             &store_,
             loop_.message_loop_proxy()),
       client_(NULL),
       task_runner_(new base::TestSimpleTaskRunner()),
+      clock_(new base::SimpleTestClock()),
       object_id_a_(135, "asdf"),
       object_id_b_(246, "zxcv"),
       timestamp_(123456),
       policy_value_a_("asdf"),
       policy_value_b_("zxcv"),
       policy_value_cur_(policy_value_a_) {}
 
 void CloudPolicyInvalidatorTest::SetUp() {
   base::StatisticsRecorder::Initialize();
   refresh_samples_ = GetHistogramSamples(kMetricPolicyRefresh);
   invalidations_samples_ = GetHistogramSamples(kMetricPolicyInvalidations);
 }
 
 void CloudPolicyInvalidatorTest::TearDown() {
   if (invalidator_)
     invalidator_->Shutdown();
   core_.Disconnect();
 }
 
 void CloudPolicyInvalidatorTest::StartInvalidator(
     bool initialize,
     bool start_refresh_scheduler) {
-  invalidator_.reset(new CloudPolicyInvalidator(&core_, task_runner_));
+  invalidator_.reset(new CloudPolicyInvalidator(&core_, task_runner_, clock_));
   if (start_refresh_scheduler) {
     ConnectCore();
     StartRefreshScheduler();
   }
   if (initialize)
     InitializeInvalidator();
 }
 
 void CloudPolicyInvalidatorTest::InitializeInvalidator() {
   invalidator_->Initialize(&invalidation_service_);
@@ skipping 134 matching lines @@
       refresh_samples_->GetCount(metric);
 }
 
 base::HistogramBase::Count CloudPolicyInvalidatorTest::GetInvalidationCount(
     bool with_payload) {
   int metric = with_payload ? 1 : 0;
   return GetHistogramSamples(kMetricPolicyInvalidations)->GetCount(metric) -
       invalidations_samples_->GetCount(metric);
 }
 
+void CloudPolicyInvalidatorTest::AdvanceClock(base::TimeDelta delta) {
+  clock_->Advance(delta);
+}
+
 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed(base::TimeDelta delay) {
   base::TimeDelta max_delay = delay + base::TimeDelta::FromMilliseconds(
       CloudPolicyInvalidator::kMaxFetchDelayMin);
 
   if (task_runner_->GetPendingTasks().empty())
     return false;
   base::TimeDelta actual_delay = task_runner_->GetPendingTasks().back().delay;
   EXPECT_GE(actual_delay, delay);
   EXPECT_LE(actual_delay, max_delay);
 
@@ skipping 376 matching lines @@
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
 
 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsNoInvalidations) {
   // Store loads occurring while registered should be differentiated depending
   // on whether the invalidation service was enabled or not.
   StorePolicy(POLICY_OBJECT_A);
   StartInvalidator();
+
+  // Initially, invalidations have not been enabled past the grace period, so
+  // invalidations are OFF.
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
+  EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
+
+  // If the clock advances less than the grace period, invalidations are OFF.
+  AdvanceClock(base::TimeDelta::FromSeconds(1));
+  StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
+  StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
+  EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
+
+  // After the grace period elapses, invalidations are ON.
+  AdvanceClock(base::TimeDelta::FromSeconds(
+      CloudPolicyInvalidator::kInvalidationGracePeriod));
+  StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
+  StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
+  EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED));
+
+  // After the invalidation service is disabled, invalidations are OFF.
   DisableInvalidationService();
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
+  EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
+
+  // Enabling the invalidation service results in a new grace period, so
+  // invalidations are OFF.
+  EnableInvalidationService();
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
-  EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED));
-  EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
-  EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
+  EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
+
+  // After the grace period elapses, invalidations are ON.
+  AdvanceClock(base::TimeDelta::FromSeconds(
+      CloudPolicyInvalidator::kInvalidationGracePeriod));
+  StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
+  StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
+
+  EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED));
+  EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
+  EXPECT_EQ(6, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 }
-
-TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsStoreSameTimestamp) {
-  // Store loads with the same timestamp as the load which causes registration
-  // are not counted.
-  StartInvalidator();
-  StorePolicy(
-      POLICY_OBJECT_A, 0, false /* policy_changed */, 12 /* timestamp */);
-  StorePolicy(
-      POLICY_OBJECT_A, 0, false /* policy_changed */, 12 /* timestamp */);
-  StorePolicy(
-      POLICY_OBJECT_A, 0, true /* policy_changed */, 12 /* timestamp */);
-
-  // The next load with a different timestamp counts.
-  StorePolicy(
-      POLICY_OBJECT_A, 0, true /* policy_changed */, 13 /* timestamp */);
-
-  EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED));
-  EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
-  EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
-  EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
-  EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
-}
 
 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsInvalidation) {
   // Store loads after an invalidation are counted as invalidated, even if
   // the loads do not result in the invalidation being acknowledged.
   StartInvalidator();
   StorePolicy(POLICY_OBJECT_A);
+  AdvanceClock(base::TimeDelta::FromSeconds(
+      CloudPolicyInvalidator::kInvalidationGracePeriod));
   FireInvalidation(POLICY_OBJECT_A, 5, "test");
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 5, true /* policy_changed */);
 
   // Store loads after the invalidation is complete are not counted as
   // invalidated.
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
@@ skipping 22 matching lines @@
   FireUnknownVersionInvalidation(POLICY_OBJECT_A);
   FireInvalidation(POLICY_OBJECT_A, 3, "test");
   FireInvalidation(POLICY_OBJECT_A, 4, "test");
 
   // Verify that received invalidations metrics are correct.
   EXPECT_EQ(3, GetInvalidationCount(false /* with_payload */));
   EXPECT_EQ(4, GetInvalidationCount(true /* with_payload */));
 }
 
 }  // namespace policy