src/chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

   1 // Copyright 2013 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 <string>
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/metrics/histogram_samples.h"
  14 #include "base/metrics/sample_map.h"
  15 #include "base/metrics/statistics_recorder.h"
  16 #include "base/run_loop.h"
  17 #include "base/test/simple_test_clock.h"
  18 #include "base/test/test_simple_task_runner.h"
  19 #include "base/time/time.h"
  20 #include "base/values.h"
  21 #include "chrome/browser/invalidation/fake_invalidation_service.h"
  22 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
  23 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
  24 #include "components/policy/core/common/cloud/cloud_policy_core.h"
  25 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
  26 #include "components/policy/core/common/cloud/enterprise_metrics.h"
  27 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
  28 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
  29 #include "components/policy/core/common/policy_types.h"
  30 #include "policy/policy_constants.h"
  31 #include "policy/proto/device_management_backend.pb.h"
  32 #include "sync/notifier/invalidation_util.h"
  33 #include "testing/gmock/include/gmock/gmock.h"
  34 #include "testing/gtest/include/gtest/gtest.h"
  35
  36 namespace policy {
  37
  38 class CloudPolicyInvalidatorTest : public testing::Test {
  39  protected:
  40   // Policy objects which can be used in tests.
  41   enum PolicyObject {
  42     POLICY_OBJECT_NONE,
  43     POLICY_OBJECT_A,
  44     POLICY_OBJECT_B
  45   };
  46
  47   CloudPolicyInvalidatorTest();
  48
  49   virtual void SetUp() OVERRIDE;
  50
  51   virtual void TearDown() OVERRIDE;
  52
  53   // Starts the invalidator which will be tested.
  54   // |initialize| determines if the invalidator should be initialized.
  55   // |start_refresh_scheduler| determines if the refresh scheduler should start.
  56   void StartInvalidator(bool initialize, bool start_refresh_scheduler);
  57   void StartInvalidator() {
  58     StartInvalidator(true /* initialize */, true /* start_refresh_scheduler */);
  59   }
  60
  61   // Calls Initialize on the invalidator.
  62   void InitializeInvalidator();
  63
  64   // Calls Shutdown on the invalidator. Test must call DestroyInvalidator
  65   // afterwards to prevent Shutdown from being called twice.
  66   void ShutdownInvalidator();
  67
  68   // Destroys the invalidator.
  69   void DestroyInvalidator();
  70
  71   // Connects the cloud policy core.
  72   void ConnectCore();
  73
  74   // Starts the refresh scheduler.
  75   void StartRefreshScheduler();
  76
  77   // Disconnects the cloud policy core.
  78   void DisconnectCore();
  79
  80   // Simulates storing a new policy to the policy store.
  81   // |object| determines which policy object the store will report the
  82   // invalidator should register for. May be POLICY_OBJECT_NONE for no object.
  83   // |invalidation_version| determines what invalidation the store will report.
  84   // |policy_changed| determines whether a policy value different from the
  85   // current value will be stored.
  86   // |time| determines the timestamp the store will report.
  87   void StorePolicy(
  88       PolicyObject object,
  89       int64 invalidation_version,
  90       bool policy_changed,
  91       const base::Time& time);
  92   void StorePolicy(
  93       PolicyObject object,
  94       int64 invalidation_version,
  95       bool policy_changed) {
  96     StorePolicy(object,
  97                 invalidation_version,
  98                 policy_changed,
  99                 Now() - base::TimeDelta::FromMinutes(5));
 100   }
 101   void StorePolicy(PolicyObject object, int64 invalidation_version) {
 102     StorePolicy(object, invalidation_version, false);
 103   }
 104   void StorePolicy(PolicyObject object) {
 105     StorePolicy(object, 0);
 106   }
 107
 108   // Disables the invalidation service. It is enabled by default.
 109   void DisableInvalidationService();
 110
 111   // Enables the invalidation service. It is enabled by default.
 112   void EnableInvalidationService();
 113
 114   // Causes the invalidation service to fire an invalidation.
 115   syncer::Invalidation FireInvalidation(
 116       PolicyObject object,
 117       int64 version,
 118       const std::string& payload);
 119
 120   // Causes the invalidation service to fire an invalidation with unknown
 121   // version.
 122   syncer::Invalidation FireUnknownVersionInvalidation(PolicyObject object);
 123
 124   // Checks the expected value of the currently set invalidation info.
 125   bool CheckInvalidationInfo(int64 version, const std::string& payload);
 126
 127   // Checks that the policy was not refreshed due to an invalidation.
 128   bool CheckPolicyNotRefreshed();
 129
 130   // Checks that the policy was refreshed due to an invalidation within an
 131   // appropriate timeframe depending on whether the invalidation had unknown
 132   // version.
 133   bool CheckPolicyRefreshed();
 134   bool CheckPolicyRefreshedWithUnknownVersion();
 135
 136   bool IsUnsent(const syncer::Invalidation& invalidation);
 137
 138   // Returns the invalidations enabled state set by the invalidator on the
 139   // refresh scheduler.
 140   bool InvalidationsEnabled();
 141
 142   // Determines if the invalidation with the given ack handle has been
 143   // acknowledged.
 144   bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 145
 146   // Determines if the invalidator has registered for an object with the
 147   // invalidation service.
 148   bool IsInvalidatorRegistered();
 149
 150   // Get the current count for the given metric.
 151   base::HistogramBase::Count GetCount(MetricPolicyRefresh metric);
 152   base::HistogramBase::Count GetInvalidationCount(PolicyInvalidationType type);
 153
 154   // Advance the test clock.
 155   void AdvanceClock(base::TimeDelta delta);
 156
 157   // Get the current time on the test clock.
 158   base::Time Now();
 159
 160   // Translate a version number into an appropriate invalidation version (which
 161   // is based on the current time).
 162   int64 V(int version);
 163
 164   // Get an invalidation version for the given time.
 165   int64 GetVersion(base::Time time);
 166
 167  private:
 168   // Checks that the policy was refreshed due to an invalidation with the given
 169   // base delay.
 170   bool CheckPolicyRefreshed(base::TimeDelta delay);
 171
 172   // Checks that the policy was refreshed the given number of times.
 173   bool CheckPolicyRefreshCount(int count);
 174
 175   // Returns the object id of the given policy object.
 176   const invalidation::ObjectId& GetPolicyObjectId(PolicyObject object) const;
 177
 178   // Get histogram samples for the given histogram.
 179   scoped_ptr<base::HistogramSamples> GetHistogramSamples(
 180       const std::string& name) const;
 181
 182   base::MessageLoop loop_;
 183
 184   // Objects the invalidator depends on.
 185   invalidation::FakeInvalidationService invalidation_service_;
 186   MockCloudPolicyStore store_;
 187   CloudPolicyCore core_;
 188   MockCloudPolicyClient* client_;
 189   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 190   base::SimpleTestClock* clock_;
 191
 192   // The invalidator which will be tested.
 193   scoped_ptr<CloudPolicyInvalidator> invalidator_;
 194
 195   // Object ids for the test policy objects.
 196   invalidation::ObjectId object_id_a_;
 197   invalidation::ObjectId object_id_b_;
 198
 199   // Fake policy values which are alternated to cause the store to report a
 200   // changed policy.
 201   const char* policy_value_a_;
 202   const char* policy_value_b_;
 203
 204   // The currently used policy value.
 205   const char* policy_value_cur_;
 206
 207   // Stores starting histogram counts for kMetricPolicyRefresh.
 208   scoped_ptr<base::HistogramSamples> refresh_samples_;
 209
 210   // Stores starting histogram counts for kMetricPolicyInvalidations.
 211   scoped_ptr<base::HistogramSamples> invalidations_samples_;
 212 };
 213
 214 CloudPolicyInvalidatorTest::CloudPolicyInvalidatorTest()
 215     : core_(PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType,
 216                                std::string()),
 217             &store_,
 218             loop_.message_loop_proxy()),
 219       client_(NULL),
 220       task_runner_(new base::TestSimpleTaskRunner()),
 221       clock_(new base::SimpleTestClock()),
 222       object_id_a_(135, "asdf"),
 223       object_id_b_(246, "zxcv"),
 224       policy_value_a_("asdf"),
 225       policy_value_b_("zxcv"),
 226       policy_value_cur_(policy_value_a_) {
 227   clock_->SetNow(
 228       base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(987654321));
 229 }
 230
 231 void CloudPolicyInvalidatorTest::SetUp() {
 232   base::StatisticsRecorder::Initialize();
 233   refresh_samples_ = GetHistogramSamples(kMetricPolicyRefresh);
 234   invalidations_samples_ = GetHistogramSamples(kMetricPolicyInvalidations);
 235 }
 236
 237 void CloudPolicyInvalidatorTest::TearDown() {
 238   if (invalidator_)
 239     invalidator_->Shutdown();
 240   core_.Disconnect();
 241 }
 242
 243 void CloudPolicyInvalidatorTest::StartInvalidator(
 244     bool initialize,
 245     bool start_refresh_scheduler) {
 246   invalidator_.reset(new CloudPolicyInvalidator(
 247       &core_,
 248       task_runner_,
 249       scoped_ptr<base::Clock>(clock_)));
 250   if (start_refresh_scheduler) {
 251     ConnectCore();
 252     StartRefreshScheduler();
 253   }
 254   if (initialize)
 255     InitializeInvalidator();
 256 }
 257
 258 void CloudPolicyInvalidatorTest::InitializeInvalidator() {
 259   invalidator_->Initialize(&invalidation_service_);
 260 }
 261
 262 void CloudPolicyInvalidatorTest::ShutdownInvalidator() {
 263   invalidator_->Shutdown();
 264 }
 265
 266 void CloudPolicyInvalidatorTest::DestroyInvalidator() {
 267   invalidator_.reset();
 268 }
 269
 270 void CloudPolicyInvalidatorTest::ConnectCore() {
 271   client_ = new MockCloudPolicyClient();
 272   client_->SetDMToken("dm");
 273   core_.Connect(scoped_ptr<CloudPolicyClient>(client_));
 274 }
 275
 276 void CloudPolicyInvalidatorTest::StartRefreshScheduler() {
 277   core_.StartRefreshScheduler();
 278 }
 279
 280 void CloudPolicyInvalidatorTest::DisconnectCore() {
 281   client_ = NULL;
 282   core_.Disconnect();
 283 }
 284
 285 void CloudPolicyInvalidatorTest::StorePolicy(
 286     PolicyObject object,
 287     int64 invalidation_version,
 288     bool policy_changed,
 289     const base::Time& time) {
 290   enterprise_management::PolicyData* data =
 291       new enterprise_management::PolicyData();
 292   if (object != POLICY_OBJECT_NONE) {
 293     data->set_invalidation_source(GetPolicyObjectId(object).source());
 294     data->set_invalidation_name(GetPolicyObjectId(object).name());
 295   }
 296   data->set_timestamp((time - base::Time::UnixEpoch()).InMilliseconds());
 297   // Swap the policy value if a policy change is desired.
 298   if (policy_changed)
 299     policy_value_cur_ = policy_value_cur_ == policy_value_a_ ?
 300         policy_value_b_ : policy_value_a_;
 301   data->set_policy_value(policy_value_cur_);
 302   store_.invalidation_version_ = invalidation_version;
 303   store_.policy_.reset(data);
 304   base::DictionaryValue policies;
 305   policies.SetInteger(
 306       key::kMaxInvalidationFetchDelay,
 307       CloudPolicyInvalidator::kMaxFetchDelayMin);
 308   store_.policy_map_.LoadFrom(
 309       &policies,
 310       POLICY_LEVEL_MANDATORY,
 311       POLICY_SCOPE_MACHINE);
 312   store_.NotifyStoreLoaded();
 313 }
 314
 315 void CloudPolicyInvalidatorTest::DisableInvalidationService() {
 316   invalidation_service_.SetInvalidatorState(
 317       syncer::TRANSIENT_INVALIDATION_ERROR);
 318 }
 319
 320 void CloudPolicyInvalidatorTest::EnableInvalidationService() {
 321   invalidation_service_.SetInvalidatorState(syncer::INVALIDATIONS_ENABLED);
 322 }
 323
 324 syncer::Invalidation CloudPolicyInvalidatorTest::FireInvalidation(
 325     PolicyObject object,
 326     int64 version,
 327     const std::string& payload) {
 328   syncer::Invalidation invalidation = syncer::Invalidation::Init(
 329       GetPolicyObjectId(object),
 330       version,
 331       payload);
 332   invalidation_service_.EmitInvalidationForTest(invalidation);
 333   return invalidation;
 334 }
 335
 336 syncer::Invalidation CloudPolicyInvalidatorTest::FireUnknownVersionInvalidation(
 337     PolicyObject object) {
 338   syncer::Invalidation invalidation = syncer::Invalidation::InitUnknownVersion(
 339       GetPolicyObjectId(object));
 340   invalidation_service_.EmitInvalidationForTest(invalidation);
 341   return invalidation;
 342 }
 343
 344 bool CloudPolicyInvalidatorTest::CheckInvalidationInfo(
 345     int64 version,
 346     const std::string& payload) {
 347   MockCloudPolicyClient* client =
 348       static_cast<MockCloudPolicyClient*>(core_.client());
 349   return version == client->invalidation_version_ &&
 350       payload == client->invalidation_payload_;
 351 }
 352
 353 bool CloudPolicyInvalidatorTest::CheckPolicyNotRefreshed() {
 354   return CheckPolicyRefreshCount(0);
 355 }
 356
 357 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed() {
 358   return CheckPolicyRefreshed(base::TimeDelta());
 359 }
 360
 361 bool CloudPolicyInvalidatorTest::IsUnsent(
 362     const syncer::Invalidation& invalidation) {
 363   return invalidation_service_.GetMockAckHandler()->IsUnsent(invalidation);
 364 }
 365
 366 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshedWithUnknownVersion() {
 367   return CheckPolicyRefreshed(base::TimeDelta::FromMinutes(
 368         CloudPolicyInvalidator::kMissingPayloadDelay));
 369 }
 370
 371 bool CloudPolicyInvalidatorTest::InvalidationsEnabled() {
 372   return core_.refresh_scheduler()->invalidations_available();
 373 }
 374
 375 bool CloudPolicyInvalidatorTest::IsInvalidationAcknowledged(
 376     const syncer::Invalidation& invalidation) {
 377   // The acknowledgement task is run through a WeakHandle that posts back to our
 378   // own thread.  We need to run any posted tasks before we can check
 379   // acknowledgement status.
 380   loop_.RunUntilIdle();
 381
 382   EXPECT_FALSE(IsUnsent(invalidation));
 383   return !invalidation_service_.GetMockAckHandler()->IsUnacked(invalidation);
 384 }
 385
 386 bool CloudPolicyInvalidatorTest::IsInvalidatorRegistered() {
 387   return !invalidation_service_.invalidator_registrar()
 388       .GetRegisteredIds(invalidator_.get()).empty();
 389 }
 390
 391 base::HistogramBase::Count CloudPolicyInvalidatorTest::GetCount(
 392     MetricPolicyRefresh metric) {
 393   return GetHistogramSamples(kMetricPolicyRefresh)->GetCount(metric) -
 394       refresh_samples_->GetCount(metric);
 395 }
 396
 397 base::HistogramBase::Count CloudPolicyInvalidatorTest::GetInvalidationCount(
 398     PolicyInvalidationType type) {
 399   return GetHistogramSamples(kMetricPolicyInvalidations)->GetCount(type) -
 400       invalidations_samples_->GetCount(type);
 401 }
 402
 403 void CloudPolicyInvalidatorTest::AdvanceClock(base::TimeDelta delta) {
 404   clock_->Advance(delta);
 405 }
 406
 407 base::Time CloudPolicyInvalidatorTest::Now() {
 408   return clock_->Now();
 409 }
 410
 411 int64 CloudPolicyInvalidatorTest::V(int version) {
 412   return GetVersion(Now()) + version;
 413 }
 414
 415 int64 CloudPolicyInvalidatorTest::GetVersion(base::Time time) {
 416   return (time - base::Time::UnixEpoch()).InMicroseconds();
 417 }
 418
 419 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed(base::TimeDelta delay) {
 420   base::TimeDelta max_delay = delay + base::TimeDelta::FromMilliseconds(
 421       CloudPolicyInvalidator::kMaxFetchDelayMin);
 422
 423   if (task_runner_->GetPendingTasks().empty())
 424     return false;
 425   base::TimeDelta actual_delay = task_runner_->GetPendingTasks().back().delay;
 426   EXPECT_GE(actual_delay, delay);
 427   EXPECT_LE(actual_delay, max_delay);
 428
 429   return CheckPolicyRefreshCount(1);
 430 }
 431
 432 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshCount(int count) {
 433   if (!client_) {
 434     task_runner_->RunUntilIdle();
 435     return count == 0;
 436   }
 437
 438   // Clear any non-invalidation refreshes which may be pending.
 439   EXPECT_CALL(*client_, FetchPolicy()).Times(testing::AnyNumber());
 440   base::RunLoop().RunUntilIdle();
 441   testing::Mock::VerifyAndClearExpectations(client_);
 442
 443   // Run the invalidator tasks then check for invalidation refreshes.
 444   EXPECT_CALL(*client_, FetchPolicy()).Times(count);
 445   task_runner_->RunUntilIdle();
 446   base::RunLoop().RunUntilIdle();
 447   return testing::Mock::VerifyAndClearExpectations(client_);
 448 }
 449
 450 const invalidation::ObjectId& CloudPolicyInvalidatorTest::GetPolicyObjectId(
 451     PolicyObject object) const {
 452   EXPECT_TRUE(object == POLICY_OBJECT_A || object == POLICY_OBJECT_B);
 453   return object == POLICY_OBJECT_A ? object_id_a_ : object_id_b_;
 454 }
 455
 456 scoped_ptr<base::HistogramSamples>
 457     CloudPolicyInvalidatorTest::GetHistogramSamples(
 458         const std::string& name) const {
 459   base::HistogramBase* histogram =
 460       base::StatisticsRecorder::FindHistogram(name);
 461   if (!histogram)
 462     return scoped_ptr<base::HistogramSamples>(new base::SampleMap());
 463   return histogram->SnapshotSamples();
 464 }
 465
 466 TEST_F(CloudPolicyInvalidatorTest, Uninitialized) {
 467   // No invalidations should be processed if the invalidator is not initialized.
 468   StartInvalidator(false /* initialize */, true /* start_refresh_scheduler */);
 469   StorePolicy(POLICY_OBJECT_A);
 470   EXPECT_FALSE(IsInvalidatorRegistered());
 471   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 472   EXPECT_TRUE(CheckPolicyNotRefreshed());
 473 }
 474
 475 TEST_F(CloudPolicyInvalidatorTest, RefreshSchedulerNotStarted) {
 476   // No invalidations should be processed if the refresh scheduler is not
 477   // started.
 478   StartInvalidator(true /* initialize */, false /* start_refresh_scheduler */);
 479   StorePolicy(POLICY_OBJECT_A);
 480   EXPECT_FALSE(IsInvalidatorRegistered());
 481   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 482   EXPECT_TRUE(CheckPolicyNotRefreshed());
 483 }
 484
 485 TEST_F(CloudPolicyInvalidatorTest, DisconnectCoreThenInitialize) {
 486   // No invalidations should be processed if the core is disconnected before
 487   // initialization.
 488   StartInvalidator(false /* initialize */, true /* start_refresh_scheduler */);
 489   DisconnectCore();
 490   InitializeInvalidator();
 491   StorePolicy(POLICY_OBJECT_A);
 492   EXPECT_FALSE(IsInvalidatorRegistered());
 493   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 494   EXPECT_TRUE(CheckPolicyNotRefreshed());
 495 }
 496
 497 TEST_F(CloudPolicyInvalidatorTest, InitializeThenStartRefreshScheduler) {
 498   // Make sure registration occurs and invalidations are processed when
 499   // Initialize is called before starting the refresh scheduler.
 500   // Note that the reverse case (start refresh scheduler then initialize) is
 501   // the default behavior for the test fixture, so will be tested in most other
 502   // tests.
 503   StartInvalidator(true /* initialize */, false /* start_refresh_scheduler */);
 504   ConnectCore();
 505   StartRefreshScheduler();
 506   StorePolicy(POLICY_OBJECT_A);
 507   EXPECT_TRUE(IsInvalidatorRegistered());
 508   FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 509   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 510 }
 511
 512 TEST_F(CloudPolicyInvalidatorTest, RegisterOnStoreLoaded) {
 513   // No registration when store is not loaded.
 514   StartInvalidator();
 515   EXPECT_FALSE(IsInvalidatorRegistered());
 516   EXPECT_FALSE(InvalidationsEnabled());
 517   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 518   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
 519   EXPECT_TRUE(CheckPolicyNotRefreshed());
 520
 521   // No registration when store is loaded with no invalidation object id.
 522   StorePolicy(POLICY_OBJECT_NONE);
 523   EXPECT_FALSE(IsInvalidatorRegistered());
 524   EXPECT_FALSE(InvalidationsEnabled());
 525   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 526   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
 527   EXPECT_TRUE(CheckPolicyNotRefreshed());
 528
 529   // Check registration when store is loaded for object A.
 530   StorePolicy(POLICY_OBJECT_A);
 531   EXPECT_TRUE(IsInvalidatorRegistered());
 532   EXPECT_TRUE(InvalidationsEnabled());
 533   FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 534   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 535   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
 536   EXPECT_TRUE(CheckPolicyNotRefreshed());
 537 }
 538
 539 TEST_F(CloudPolicyInvalidatorTest, ChangeRegistration) {
 540   // Register for object A.
 541   StartInvalidator();
 542   StorePolicy(POLICY_OBJECT_A);
 543   EXPECT_TRUE(IsInvalidatorRegistered());
 544   EXPECT_TRUE(InvalidationsEnabled());
 545   FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 546   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 547   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
 548   EXPECT_TRUE(CheckPolicyNotRefreshed());
 549   syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 550
 551   // Check re-registration for object B. Make sure the pending invalidation for
 552   // object A is acknowledged without making the callback.
 553   StorePolicy(POLICY_OBJECT_B);
 554   EXPECT_TRUE(IsInvalidatorRegistered());
 555   EXPECT_TRUE(InvalidationsEnabled());
 556   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
 557   EXPECT_TRUE(CheckPolicyNotRefreshed());
 558
 559   // Make sure future invalidations for object A are ignored and for object B
 560   // are processed.
 561   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 562   EXPECT_TRUE(CheckPolicyNotRefreshed());
 563   FireUnknownVersionInvalidation(POLICY_OBJECT_B);
 564   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 565 }
 566
 567 TEST_F(CloudPolicyInvalidatorTest, UnregisterOnStoreLoaded) {
 568   // Register for object A.
 569   StartInvalidator();
 570   StorePolicy(POLICY_OBJECT_A);
 571   EXPECT_TRUE(IsInvalidatorRegistered());
 572   EXPECT_TRUE(InvalidationsEnabled());
 573   FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 574   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 575
 576   // Check unregistration when store is loaded with no invalidation object id.
 577   syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 578   EXPECT_FALSE(IsInvalidationAcknowledged(inv));
 579   StorePolicy(POLICY_OBJECT_NONE);
 580   EXPECT_FALSE(IsInvalidatorRegistered());
 581   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
 582   EXPECT_FALSE(InvalidationsEnabled());
 583   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_A)));
 584   EXPECT_TRUE(IsUnsent(FireUnknownVersionInvalidation(POLICY_OBJECT_B)));
 585   EXPECT_TRUE(CheckPolicyNotRefreshed());
 586
 587   // Check re-registration for object B.
 588   StorePolicy(POLICY_OBJECT_B);
 589   EXPECT_TRUE(IsInvalidatorRegistered());
 590   EXPECT_TRUE(InvalidationsEnabled());
 591   FireUnknownVersionInvalidation(POLICY_OBJECT_B);
 592   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 593 }
 594
 595 TEST_F(CloudPolicyInvalidatorTest, HandleInvalidation) {
 596   // Register and fire invalidation
 597   StorePolicy(POLICY_OBJECT_A);
 598   StartInvalidator();
 599   EXPECT_TRUE(InvalidationsEnabled());
 600   syncer::Invalidation inv =
 601       FireInvalidation(POLICY_OBJECT_A, V(12), "test_payload");
 602
 603   // Make sure client info is set as soon as the invalidation is received.
 604   EXPECT_TRUE(CheckInvalidationInfo(V(12), "test_payload"));
 605   EXPECT_TRUE(CheckPolicyRefreshed());
 606
 607   // Make sure invalidation is not acknowledged until the store is loaded.
 608   EXPECT_FALSE(IsInvalidationAcknowledged(inv));
 609   EXPECT_TRUE(CheckInvalidationInfo(V(12), "test_payload"));
 610   StorePolicy(POLICY_OBJECT_A, V(12));
 611   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
 612   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 613 }
 614
 615 TEST_F(CloudPolicyInvalidatorTest, HandleInvalidationWithUnknownVersion) {
 616   // Register and fire invalidation with unknown version.
 617   StorePolicy(POLICY_OBJECT_A);
 618   StartInvalidator();
 619   syncer::Invalidation inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 620
 621   // Make sure client info is not set until after the invalidation callback is
 622   // made.
 623   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 624   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 625   EXPECT_TRUE(CheckInvalidationInfo(-1, std::string()));
 626
 627   // Make sure invalidation is not acknowledged until the store is loaded.
 628   EXPECT_FALSE(IsInvalidationAcknowledged(inv));
 629   StorePolicy(POLICY_OBJECT_A, -1);
 630   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
 631   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 632 }
 633
 634 TEST_F(CloudPolicyInvalidatorTest, HandleMultipleInvalidations) {
 635   // Generate multiple invalidations.
 636   StorePolicy(POLICY_OBJECT_A);
 637   StartInvalidator();
 638   syncer::Invalidation inv1 = FireInvalidation(POLICY_OBJECT_A, V(1), "test1");
 639   EXPECT_TRUE(CheckInvalidationInfo(V(1), "test1"));
 640   syncer::Invalidation inv2 = FireInvalidation(POLICY_OBJECT_A, V(2), "test2");
 641   EXPECT_TRUE(CheckInvalidationInfo(V(2), "test2"));
 642   syncer::Invalidation inv3 = FireInvalidation(POLICY_OBJECT_A, V(3), "test3");
 643   EXPECT_TRUE(CheckInvalidationInfo(V(3), "test3"));
 644
 645   // Make sure the replaced invalidations are acknowledged.
 646   EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
 647   EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
 648
 649   // Make sure the policy is refreshed once.
 650   EXPECT_TRUE(CheckPolicyRefreshed());
 651
 652   // Make sure that the last invalidation is only acknowledged after the store
 653   // is loaded with the latest version.
 654   StorePolicy(POLICY_OBJECT_A, V(1));
 655   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
 656   StorePolicy(POLICY_OBJECT_A, V(2));
 657   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
 658   StorePolicy(POLICY_OBJECT_A, V(3));
 659   EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 660 }
 661
 662 TEST_F(CloudPolicyInvalidatorTest,
 663        HandleMultipleInvalidationsWithUnknownVersion) {
 664   // Validate that multiple invalidations with unknown version each generate
 665   // unique invalidation version numbers.
 666   StorePolicy(POLICY_OBJECT_A);
 667   StartInvalidator();
 668   syncer::Invalidation inv1 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 669   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 670   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 671   EXPECT_TRUE(CheckInvalidationInfo(-1, std::string()));
 672   syncer::Invalidation inv2 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 673   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 674   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 675   EXPECT_TRUE(CheckInvalidationInfo(-2, std::string()));
 676   syncer::Invalidation inv3 = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 677   EXPECT_TRUE(CheckInvalidationInfo(0, std::string()));
 678   EXPECT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 679   EXPECT_TRUE(CheckInvalidationInfo(-3, std::string()));
 680
 681   // Make sure the replaced invalidations are acknowledged.
 682   EXPECT_TRUE(IsInvalidationAcknowledged(inv1));
 683   EXPECT_TRUE(IsInvalidationAcknowledged(inv2));
 684
 685   // Make sure that the last invalidation is only acknowledged after the store
 686   // is loaded with the last unknown version.
 687   StorePolicy(POLICY_OBJECT_A, -1);
 688   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
 689   StorePolicy(POLICY_OBJECT_A, -2);
 690   EXPECT_FALSE(IsInvalidationAcknowledged(inv3));
 691   StorePolicy(POLICY_OBJECT_A, -3);
 692   EXPECT_TRUE(IsInvalidationAcknowledged(inv3));
 693 }
 694
 695 TEST_F(CloudPolicyInvalidatorTest, AcknowledgeBeforeRefresh) {
 696   // Generate an invalidation.
 697   StorePolicy(POLICY_OBJECT_A);
 698   StartInvalidator();
 699   syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(3), "test");
 700
 701   // Ensure that the policy is not refreshed and the invalidation is
 702   // acknowledged if the store is loaded with the latest version before the
 703   // refresh can occur.
 704   StorePolicy(POLICY_OBJECT_A, V(3));
 705   EXPECT_TRUE(IsInvalidationAcknowledged(inv));
 706   EXPECT_TRUE(CheckPolicyNotRefreshed());
 707 }
 708
 709 TEST_F(CloudPolicyInvalidatorTest, NoCallbackAfterShutdown) {
 710   // Generate an invalidation.
 711   StorePolicy(POLICY_OBJECT_A);
 712   StartInvalidator();
 713   syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(3), "test");
 714
 715   // Ensure that the policy refresh is not made after the invalidator is shut
 716   // down.
 717   ShutdownInvalidator();
 718   EXPECT_TRUE(CheckPolicyNotRefreshed());
 719   DestroyInvalidator();
 720 }
 721
 722 TEST_F(CloudPolicyInvalidatorTest, StateChanged) {
 723   // Test invalidation service state changes while not registered.
 724   StartInvalidator();
 725   DisableInvalidationService();
 726   EnableInvalidationService();
 727   EXPECT_FALSE(InvalidationsEnabled());
 728
 729   // Test invalidation service state changes while registered.
 730   StorePolicy(POLICY_OBJECT_A);
 731   EXPECT_TRUE(InvalidationsEnabled());
 732   DisableInvalidationService();
 733   EXPECT_FALSE(InvalidationsEnabled());
 734   DisableInvalidationService();
 735   EXPECT_FALSE(InvalidationsEnabled());
 736   EnableInvalidationService();
 737   EXPECT_TRUE(InvalidationsEnabled());
 738   EnableInvalidationService();
 739   EXPECT_TRUE(InvalidationsEnabled());
 740
 741   // Test registration changes with invalidation service enabled.
 742   StorePolicy(POLICY_OBJECT_NONE);
 743   EXPECT_FALSE(InvalidationsEnabled());
 744   StorePolicy(POLICY_OBJECT_NONE);
 745   EXPECT_FALSE(InvalidationsEnabled());
 746   StorePolicy(POLICY_OBJECT_A);
 747   EXPECT_TRUE(InvalidationsEnabled());
 748   StorePolicy(POLICY_OBJECT_A);
 749   EXPECT_TRUE(InvalidationsEnabled());
 750
 751   // Test registration changes with invalidation service disabled.
 752   DisableInvalidationService();
 753   EXPECT_FALSE(InvalidationsEnabled());
 754   StorePolicy(POLICY_OBJECT_NONE);
 755   StorePolicy(POLICY_OBJECT_A);
 756   EXPECT_FALSE(InvalidationsEnabled());
 757 }
 758
 759 TEST_F(CloudPolicyInvalidatorTest, Disconnect) {
 760   // Generate an invalidation.
 761   StorePolicy(POLICY_OBJECT_A);
 762   StartInvalidator();
 763   syncer::Invalidation inv = FireInvalidation(POLICY_OBJECT_A, V(1), "test");
 764   EXPECT_TRUE(InvalidationsEnabled());
 765
 766   // Ensure that the policy is not refreshed after disconnecting the core, but
 767   // a call to indicate that invalidations are disabled is made.
 768   DisconnectCore();
 769   EXPECT_TRUE(CheckPolicyNotRefreshed());
 770
 771   // Ensure that invalidation service events do not cause refreshes while the
 772   // invalidator is stopped.
 773   EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(2), "test")));
 774   EXPECT_TRUE(CheckPolicyNotRefreshed());
 775   DisableInvalidationService();
 776   EnableInvalidationService();
 777
 778   // Connect and disconnect without starting the refresh scheduler.
 779   ConnectCore();
 780   EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(3), "test")));
 781   EXPECT_TRUE(CheckPolicyNotRefreshed());
 782   DisconnectCore();
 783   EXPECT_TRUE(IsUnsent(FireInvalidation(POLICY_OBJECT_A, V(4), "test")));
 784   EXPECT_TRUE(CheckPolicyNotRefreshed());
 785
 786   // Ensure that the invalidator returns to normal after reconnecting.
 787   ConnectCore();
 788   StartRefreshScheduler();
 789   EXPECT_TRUE(CheckPolicyNotRefreshed());
 790   EXPECT_TRUE(InvalidationsEnabled());
 791   FireInvalidation(POLICY_OBJECT_A, V(5), "test");
 792   EXPECT_TRUE(CheckInvalidationInfo(V(5), "test"));
 793   EXPECT_TRUE(CheckPolicyRefreshed());
 794   DisableInvalidationService();
 795   EXPECT_FALSE(InvalidationsEnabled());
 796 }
 797
 798 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsUnregistered) {
 799   // Store loads occurring before invalidation registration are not counted.
 800   StartInvalidator();
 801   StorePolicy(POLICY_OBJECT_NONE, 0, false /* policy_changed */);
 802   StorePolicy(POLICY_OBJECT_NONE, 0, true /* policy_changed */);
 803   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED));
 804   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 805   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
 806   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
 807   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 808 }
 809
 810 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsNoInvalidations) {
 811   // Store loads occurring while registered should be differentiated depending
 812   // on whether the invalidation service was enabled or not.
 813   StorePolicy(POLICY_OBJECT_A);
 814   StartInvalidator();
 815
 816   // Initially, invalidations have not been enabled past the grace period, so
 817   // invalidations are OFF.
 818   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 819   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 820   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 821
 822   // If the clock advances less than the grace period, invalidations are OFF.
 823   AdvanceClock(base::TimeDelta::FromSeconds(1));
 824   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 825   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 826   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 827
 828   // After the grace period elapses, invalidations are ON.
 829   AdvanceClock(base::TimeDelta::FromSeconds(
 830       CloudPolicyInvalidator::kInvalidationGracePeriod));
 831   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 832   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 833   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_CHANGED));
 834
 835   // After the invalidation service is disabled, invalidations are OFF.
 836   DisableInvalidationService();
 837   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 838   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 839   EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 840
 841   // Enabling the invalidation service results in a new grace period, so
 842   // invalidations are OFF.
 843   EnableInvalidationService();
 844   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 845   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 846   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 847
 848   // After the grace period elapses, invalidations are ON.
 849   AdvanceClock(base::TimeDelta::FromSeconds(
 850       CloudPolicyInvalidator::kInvalidationGracePeriod));
 851   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 852   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 853
 854   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_CHANGED));
 855   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 856   EXPECT_EQ(6, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
 857   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
 858   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 859 }
 860
 861 TEST_F(CloudPolicyInvalidatorTest, RefreshMetricsInvalidation) {
 862   // Store loads after an invalidation are counted as invalidated, even if
 863   // the loads do not result in the invalidation being acknowledged.
 864   StartInvalidator();
 865   StorePolicy(POLICY_OBJECT_A);
 866   AdvanceClock(base::TimeDelta::FromSeconds(
 867       CloudPolicyInvalidator::kInvalidationGracePeriod));
 868   FireInvalidation(POLICY_OBJECT_A, V(5), "test");
 869   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 870   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 871   StorePolicy(POLICY_OBJECT_A, V(5), true /* policy_changed */);
 872
 873   // Store loads after the invalidation is complete are not counted as
 874   // invalidated.
 875   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 876   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 877   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 878   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 879   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 880   StorePolicy(POLICY_OBJECT_A, 0, true /* policy_changed */);
 881   StorePolicy(POLICY_OBJECT_A, 0, false /* policy_changed */);
 882
 883   EXPECT_EQ(3, GetCount(METRIC_POLICY_REFRESH_CHANGED));
 884   EXPECT_EQ(0, GetCount(METRIC_POLICY_REFRESH_CHANGED_NO_INVALIDATIONS));
 885   EXPECT_EQ(4, GetCount(METRIC_POLICY_REFRESH_UNCHANGED));
 886   EXPECT_EQ(2, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_CHANGED));
 887   EXPECT_EQ(1, GetCount(METRIC_POLICY_REFRESH_INVALIDATED_UNCHANGED));
 888 }
 889
 890 TEST_F(CloudPolicyInvalidatorTest, ExpiredInvalidations) {
 891   StorePolicy(POLICY_OBJECT_A, 0, false, Now());
 892   StartInvalidator();
 893
 894   // Invalidations fired before the last fetch time (adjusted by max time delta)
 895   // should be ignored.
 896   base::Time time = Now() - base::TimeDelta::FromSeconds(
 897       CloudPolicyInvalidator::kMaxInvalidationTimeDelta + 300);
 898   syncer::Invalidation inv =
 899       FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
 900   ASSERT_TRUE(IsInvalidationAcknowledged(inv));
 901   ASSERT_TRUE(CheckPolicyNotRefreshed());
 902
 903   time += base::TimeDelta::FromMinutes(5) - base::TimeDelta::FromSeconds(1);
 904   inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
 905   ASSERT_TRUE(IsInvalidationAcknowledged(inv));
 906   ASSERT_TRUE(CheckPolicyNotRefreshed());
 907
 908   // Invalidations fired after the last fetch should not be ignored.
 909   time += base::TimeDelta::FromSeconds(1);
 910   inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
 911   ASSERT_FALSE(IsInvalidationAcknowledged(inv));
 912   ASSERT_TRUE(CheckPolicyRefreshed());
 913
 914   time += base::TimeDelta::FromMinutes(10);
 915   inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
 916   ASSERT_FALSE(IsInvalidationAcknowledged(inv));
 917   ASSERT_TRUE(CheckPolicyRefreshed());
 918
 919   time += base::TimeDelta::FromMinutes(10);
 920   inv = FireInvalidation(POLICY_OBJECT_A, GetVersion(time), "test");
 921   ASSERT_FALSE(IsInvalidationAcknowledged(inv));
 922   ASSERT_TRUE(CheckPolicyRefreshed());
 923
 924   // Unknown version invalidations fired just after the last fetch time should
 925   // be ignored.
 926   inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 927   ASSERT_TRUE(IsInvalidationAcknowledged(inv));
 928   ASSERT_TRUE(CheckPolicyNotRefreshed());
 929
 930   AdvanceClock(base::TimeDelta::FromSeconds(
 931       CloudPolicyInvalidator::kUnknownVersionIgnorePeriod - 1));
 932   inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 933   ASSERT_TRUE(IsInvalidationAcknowledged(inv));
 934   ASSERT_TRUE(CheckPolicyNotRefreshed());
 935
 936   // Unknown version invalidations fired past the ignore period should not be
 937   // ignored.
 938   AdvanceClock(base::TimeDelta::FromSeconds(1));
 939   inv = FireUnknownVersionInvalidation(POLICY_OBJECT_A);
 940   ASSERT_FALSE(IsInvalidationAcknowledged(inv));
 941   ASSERT_TRUE(CheckPolicyRefreshedWithUnknownVersion());
 942
 943   // Verify that received invalidations metrics are correct.
 944   EXPECT_EQ(1, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD));
 945   EXPECT_EQ(3, GetInvalidationCount(POLICY_INVALIDATION_TYPE_NORMAL));
 946   EXPECT_EQ(2,
 947             GetInvalidationCount(POLICY_INVALIDATION_TYPE_NO_PAYLOAD_EXPIRED));
 948   EXPECT_EQ(2, GetInvalidationCount(POLICY_INVALIDATION_TYPE_EXPIRED));
 949 }
 950
 951 }  // namespace policy