sync/notifier/ack_tracker_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 "sync/notifier/ack_tracker.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/time/tick_clock.h"
  11 #include "google/cacheinvalidation/include/types.h"
  12 #include "google/cacheinvalidation/types.pb.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace syncer {
  17
  18 namespace {
  19
  20 class FakeTickClock : public base::TickClock {
  21  public:
  22   FakeTickClock() {}
  23
  24   virtual ~FakeTickClock() {}
  25
  26   void LeapForward(int seconds) {
  27     ASSERT_GT(seconds, 0);
  28     fake_now_ticks_ += base::TimeDelta::FromSeconds(seconds);
  29   }
  30
  31   // After the next call to Now(), immediately leap forward by |seconds|.
  32   void DelayedLeapForward(int seconds) {
  33     ASSERT_GT(seconds, 0);
  34     delayed_leap_ = base::TimeDelta::FromSeconds(seconds);
  35   }
  36
  37   virtual base::TimeTicks NowTicks() OVERRIDE {
  38     base::TimeTicks fake_now_ticks = fake_now_ticks_;
  39     if (delayed_leap_ > base::TimeDelta()) {
  40       fake_now_ticks_ += delayed_leap_;
  41       delayed_leap_ = base::TimeDelta();
  42     }
  43     return fake_now_ticks;
  44   }
  45
  46  private:
  47   base::TimeTicks fake_now_ticks_;
  48   base::TimeDelta delayed_leap_;
  49 };
  50
  51 class FakeBackoffEntry : public net::BackoffEntry {
  52  public:
  53   FakeBackoffEntry(const Policy* const policy, base::TickClock* tick_clock)
  54       : BackoffEntry(policy),
  55         tick_clock_(tick_clock) {
  56   }
  57
  58  protected:
  59   virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE {
  60     return tick_clock_->NowTicks();
  61   }
  62
  63  private:
  64   base::TickClock* const tick_clock_;
  65 };
  66
  67 class MockDelegate : public AckTracker::Delegate {
  68  public:
  69   MOCK_METHOD1(OnTimeout, void(const ObjectIdSet&));
  70 };
  71
  72 scoped_ptr<net::BackoffEntry> CreateMockEntry(
  73     base::TickClock* tick_clock,
  74     const net::BackoffEntry::Policy* const policy) {
  75   return scoped_ptr<net::BackoffEntry>(new FakeBackoffEntry(
  76       policy, tick_clock));
  77 }
  78
  79 }  // namespace
  80
  81 class AckTrackerTest : public testing::Test {
  82  public:
  83   AckTrackerTest()
  84       : ack_tracker_(&fake_tick_clock_, &delegate_),
  85         kIdOne(ipc::invalidation::ObjectSource::TEST, "one"),
  86         kIdTwo(ipc::invalidation::ObjectSource::TEST, "two") {
  87     ack_tracker_.SetCreateBackoffEntryCallbackForTest(
  88         base::Bind(&CreateMockEntry, &fake_tick_clock_));
  89   }
  90
  91  protected:
  92   bool TriggerTimeoutNow() {
  93     return ack_tracker_.TriggerTimeoutAtForTest(fake_tick_clock_.NowTicks());
  94   }
  95
  96   base::TimeDelta GetTimerDelay() const {
  97     const base::Timer& timer = ack_tracker_.GetTimerForTest();
  98     if (!timer.IsRunning())
  99       ADD_FAILURE() << "Timer is not running!";
 100     return timer.GetCurrentDelay();
 101   }
 102
 103   FakeTickClock fake_tick_clock_;
 104   ::testing::StrictMock<MockDelegate> delegate_;
 105   AckTracker ack_tracker_;
 106
 107   const invalidation::ObjectId kIdOne;
 108   const invalidation::ObjectId kIdTwo;
 109
 110   // AckTracker uses base::Timer internally, which depends on the existence of a
 111   // MessageLoop.
 112   base::MessageLoop message_loop_;
 113 };
 114
 115 // Tests that various combinations of Track()/Ack() behave as
 116 // expected.
 117 TEST_F(AckTrackerTest, TrackAndAck) {
 118   ObjectIdSet ids_one;
 119   ids_one.insert(kIdOne);
 120   ObjectIdSet ids_two;
 121   ids_two.insert(kIdTwo);
 122   ObjectIdSet ids_all;
 123   ids_all.insert(kIdOne);
 124   ids_all.insert(kIdTwo);
 125
 126   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 127   ack_tracker_.Track(ids_one);
 128   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 129   ack_tracker_.Track(ids_two);
 130   ack_tracker_.Ack(ids_one);
 131   ack_tracker_.Ack(ids_two);
 132   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 133
 134   ack_tracker_.Track(ids_all);
 135   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 136   ack_tracker_.Ack(ids_one);
 137   ack_tracker_.Ack(ids_two);
 138   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 139
 140   ack_tracker_.Track(ids_one);
 141   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 142   ack_tracker_.Track(ids_two);
 143   ack_tracker_.Ack(ids_all);
 144   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 145
 146   ack_tracker_.Track(ids_all);
 147   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 148   ack_tracker_.Ack(ids_all);
 149   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 150 }
 151
 152 TEST_F(AckTrackerTest, DoubleTrack) {
 153   ObjectIdSet ids;
 154   ids.insert(kIdOne);
 155
 156   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 157   ack_tracker_.Track(ids);
 158   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 159   ack_tracker_.Track(ids);
 160   ack_tracker_.Ack(ids);
 161   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 162 }
 163
 164 TEST_F(AckTrackerTest, UntrackedAck) {
 165   ObjectIdSet ids;
 166   ids.insert(kIdOne);
 167
 168   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 169   ack_tracker_.Ack(ids);
 170   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 171 }
 172
 173 TEST_F(AckTrackerTest, Clear) {
 174   ObjectIdSet ids;
 175   ids.insert(kIdOne);
 176   ids.insert(kIdOne);
 177
 178   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 179   ack_tracker_.Track(ids);
 180   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 181   ack_tracker_.Clear();
 182   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 183 }
 184
 185 // Test that timeout behavior for one object ID. The timeout should increase
 186 // exponentially until it hits the cap.
 187 TEST_F(AckTrackerTest, SimpleTimeout) {
 188   ObjectIdSet ids;
 189   ids.insert(kIdOne);
 190
 191   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 192   ack_tracker_.Track(ids);
 193   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 194
 195   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
 196   fake_tick_clock_.LeapForward(60);
 197   EXPECT_CALL(delegate_, OnTimeout(ids));
 198   EXPECT_TRUE(TriggerTimeoutNow());
 199
 200   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
 201   fake_tick_clock_.LeapForward(120);
 202   EXPECT_CALL(delegate_, OnTimeout(ids));
 203   EXPECT_TRUE(TriggerTimeoutNow());
 204
 205   EXPECT_EQ(base::TimeDelta::FromSeconds(240), GetTimerDelay());
 206   fake_tick_clock_.LeapForward(240);
 207   EXPECT_CALL(delegate_, OnTimeout(ids));
 208   EXPECT_TRUE(TriggerTimeoutNow());
 209
 210   EXPECT_EQ(base::TimeDelta::FromSeconds(480), GetTimerDelay());
 211   fake_tick_clock_.LeapForward(480);
 212   EXPECT_CALL(delegate_, OnTimeout(ids));
 213   EXPECT_TRUE(TriggerTimeoutNow());
 214
 215   EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay());
 216   fake_tick_clock_.LeapForward(600);
 217   EXPECT_CALL(delegate_, OnTimeout(ids));
 218   EXPECT_TRUE(TriggerTimeoutNow());
 219
 220   EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay());
 221   fake_tick_clock_.LeapForward(600);
 222   EXPECT_CALL(delegate_, OnTimeout(ids));
 223   EXPECT_TRUE(TriggerTimeoutNow());
 224
 225   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 226   ack_tracker_.Ack(ids);
 227   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 228
 229   // The backoff time should be reset after an Ack/Track cycle.
 230   ack_tracker_.Track(ids);
 231   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 232
 233   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
 234   fake_tick_clock_.LeapForward(60);
 235   EXPECT_CALL(delegate_, OnTimeout(ids));
 236   EXPECT_TRUE(TriggerTimeoutNow());
 237
 238   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 239   ack_tracker_.Ack(ids);
 240   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 241 }
 242
 243 // Tests that a sequence of Track() calls that results in interleaving
 244 // timeouts occurs as expected.
 245 TEST_F(AckTrackerTest, InterleavedTimeout) {
 246   ObjectIdSet ids_one;
 247   ids_one.insert(kIdOne);
 248   ObjectIdSet ids_two;
 249   ids_two.insert(kIdTwo);
 250
 251   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 252   ack_tracker_.Track(ids_one);
 253   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 254
 255   fake_tick_clock_.LeapForward(30);
 256   ack_tracker_.Track(ids_two);
 257   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 258
 259   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
 260   fake_tick_clock_.LeapForward(30);
 261   EXPECT_CALL(delegate_, OnTimeout(ids_one));
 262   EXPECT_TRUE(TriggerTimeoutNow());
 263
 264   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
 265   fake_tick_clock_.LeapForward(30);
 266   EXPECT_CALL(delegate_, OnTimeout(ids_two));
 267   EXPECT_TRUE(TriggerTimeoutNow());
 268
 269   EXPECT_EQ(base::TimeDelta::FromSeconds(90), GetTimerDelay());
 270   fake_tick_clock_.LeapForward(90);
 271   EXPECT_CALL(delegate_, OnTimeout(ids_one));
 272   EXPECT_TRUE(TriggerTimeoutNow());
 273
 274   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
 275   fake_tick_clock_.LeapForward(30);
 276   EXPECT_CALL(delegate_, OnTimeout(ids_two));
 277   EXPECT_TRUE(TriggerTimeoutNow());
 278
 279   ack_tracker_.Ack(ids_one);
 280   ack_tracker_.Ack(ids_two);
 281   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 282 }
 283
 284 // Tests that registering a new object ID properly shortens the timeout when
 285 // needed.
 286 TEST_F(AckTrackerTest, ShortenTimeout) {
 287   ObjectIdSet ids_one;
 288   ids_one.insert(kIdOne);
 289   ObjectIdSet ids_two;
 290   ids_two.insert(kIdTwo);
 291
 292   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 293   ack_tracker_.Track(ids_one);
 294   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 295
 296   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
 297   fake_tick_clock_.LeapForward(60);
 298   EXPECT_CALL(delegate_, OnTimeout(ids_one));
 299   EXPECT_TRUE(TriggerTimeoutNow());
 300
 301   // Without this next register, the next timeout should occur in 120 seconds
 302   // from the last timeout event.
 303   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
 304   fake_tick_clock_.LeapForward(30);
 305   ack_tracker_.Track(ids_two);
 306   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 307
 308   // Now that we've registered another entry though, we should receive a timeout
 309   // in 60 seconds.
 310   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
 311   fake_tick_clock_.LeapForward(60);
 312   EXPECT_CALL(delegate_, OnTimeout(ids_two));
 313   EXPECT_TRUE(TriggerTimeoutNow());
 314
 315   // Verify that the original timeout for kIdOne still occurs as expected.
 316   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
 317   fake_tick_clock_.LeapForward(30);
 318   EXPECT_CALL(delegate_, OnTimeout(ids_one));
 319   EXPECT_TRUE(TriggerTimeoutNow());
 320
 321   ack_tracker_.Ack(ids_one);
 322   ack_tracker_.Ack(ids_two);
 323   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 324 }
 325
 326 // Tests that a delay between inserting a new object ID registration and start
 327 // the timer that is greater than the initial timeout period (60 seconds) does
 328 // not break things. This could happen on a heavily loaded system, for instance.
 329 TEST_F(AckTrackerTest, ImmediateTimeout) {
 330   ObjectIdSet ids;
 331   ids.insert(kIdOne);
 332
 333   fake_tick_clock_.DelayedLeapForward(90);
 334   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 335   ack_tracker_.Track(ids);
 336   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 337
 338   EXPECT_EQ(base::TimeDelta::FromSeconds(0), GetTimerDelay());
 339   EXPECT_CALL(delegate_, OnTimeout(ids));
 340   message_loop_.RunUntilIdle();
 341
 342   // The next timeout should still be scheduled normally.
 343   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
 344   fake_tick_clock_.LeapForward(120);
 345   EXPECT_CALL(delegate_, OnTimeout(ids));
 346   EXPECT_TRUE(TriggerTimeoutNow());
 347
 348   ack_tracker_.Ack(ids);
 349   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 350 }
 351
 352 }  // namespace syncer