Add version field to syncer::Invalidation.

sync/notifier/sync_invalidation_listener_unittest.cc

 // 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 <cstddef>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 128 matching lines @@
   explicit FakeDelegate(SyncInvalidationListener* listener)
       : listener_(listener),
         state_(TRANSIENT_INVALIDATION_ERROR) {}
   virtual ~FakeDelegate() {}
 
   int GetInvalidationCount(const ObjectId& id) const {
     ObjectIdCountMap::const_iterator it = invalidation_counts_.find(id);
     return (it == invalidation_counts_.end()) ? 0 : it->second;
   }
 
+  int64 GetVersion(const ObjectId& id) const {
+    ObjectIdInvalidationMap::const_iterator it = invalidations_.find(id);
+    return (it == invalidations_.end()) ? 0 : it->second.version;
+  }
+
   std::string GetPayload(const ObjectId& id) const {
     ObjectIdInvalidationMap::const_iterator it = invalidations_.find(id);
     return (it == invalidations_.end()) ? std::string() : it->second.payload;
   }
 
   InvalidatorState GetInvalidatorState() const {
     return state_;
   }
 
   void Acknowledge(const ObjectId& id) {
@@ skipping 129 matching lines @@
     // drain the task queue before calling it.
     message_loop_.RunUntilIdle();
     fake_invalidation_client_ = NULL;
     listener_.StopForTest();
   }
 
   int GetInvalidationCount(const ObjectId& id) const {
     return fake_delegate_.GetInvalidationCount(id);
   }
 
+  int64 GetVersion(const ObjectId& id) const {
+    return fake_delegate_.GetVersion(id);
+  }
+
   std::string GetPayload(const ObjectId& id) const {
     return fake_delegate_.GetPayload(id);
   }
 
   InvalidatorState GetInvalidatorState() const {
     return fake_delegate_.GetInvalidatorState();
   }
 
   int64 GetMaxVersion(const ObjectId& id) const {
     return fake_tracker_.GetMaxVersion(id);
@@ skipping 122 matching lines @@
 // Invalidation tests.
 
 // Fire an invalidation without a payload.  It should be processed,
 // the payload should remain empty, and the version should be updated.
 TEST_F(SyncInvalidationListenerTest, InvalidateNoPayload) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidate(id, kVersion1, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion1, GetVersion(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 }
 
 // Fire an invalidation with an empty payload.  It should be
 // processed, the payload should remain empty, and the version should
 // be updated.
 TEST_F(SyncInvalidationListenerTest, InvalidateEmptyPayload) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidate(id, kVersion1, "");
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion1, GetVersion(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 }
 
 // Fire an invalidation with a payload.  It should be processed, and
 // both the payload and the version should be updated.
 TEST_F(SyncInvalidationListenerTest, InvalidateWithPayload) {
   const ObjectId& id = kPreferencesId_;
 
   FireInvalidate(id, kVersion1, kPayload1);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion1, GetVersion(id));
   EXPECT_EQ(kPayload1, GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 }
 
 // Fire an invalidation for an unregistered object ID with a payload.  It should
 // still be processed, and both the payload and the version should be updated.
 TEST_F(SyncInvalidationListenerTest, InvalidateUnregisteredWithPayload) {
   const ObjectId kUnregisteredId(
       kChromeSyncSourceId, "unregistered");
   const ObjectId& id = kUnregisteredId;
 
   EXPECT_EQ(0, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
 
   FireInvalidate(id, kVersion1, "unregistered payload");
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion1, GetVersion(id));
   EXPECT_EQ("unregistered payload", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 }
 
 // Fire an invalidation, then fire another one with a lower version.
 // The first one should be processed and should update the payload and
 // version, but the second one shouldn't.
 TEST_F(SyncInvalidationListenerTest, InvalidateVersion) {
   const ObjectId& id = kPreferencesId_;
 
   FireInvalidate(id, kVersion2, kPayload2);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion2, GetVersion(id));
   EXPECT_EQ(kPayload2, GetPayload(id));
   EXPECT_EQ(kVersion2, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 
   FireInvalidate(id, kVersion1, kPayload1);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(kVersion2, GetVersion(id));
   EXPECT_EQ(kPayload2, GetPayload(id));
   EXPECT_EQ(kVersion2, GetMaxVersion(id));
   VerifyAcknowledged(id);
 }
 
 // Fire an invalidation with an unknown version twice.  It shouldn't
 // update the payload or version either time, but it should still be
 // processed.
 TEST_F(SyncInvalidationListenerTest, InvalidateUnknownVersion) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidateUnknownVersion(id);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
+  EXPECT_EQ(Invalidation::kUnknownVersion, GetVersion(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 
   FireInvalidateUnknownVersion(id);
 
   EXPECT_EQ(2, GetInvalidationCount(id));
+  EXPECT_EQ(Invalidation::kUnknownVersion, GetVersion(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
   AcknowledgeAndVerify(id);
 }
 
 // Fire an invalidation for all enabled IDs.  It shouldn't update the
 // payload or version, but it should still invalidate the IDs.
 TEST_F(SyncInvalidationListenerTest, InvalidateAll) {
   FireInvalidateAll();
 
   for (ObjectIdSet::const_iterator it = registered_ids_.begin();
        it != registered_ids_.end(); ++it) {
     EXPECT_EQ(1, GetInvalidationCount(*it));
+    EXPECT_EQ(Invalidation::kUnknownVersion, GetVersion(*it));
     EXPECT_EQ("", GetPayload(*it));
     EXPECT_EQ(kMinVersion, GetMaxVersion(*it));
     AcknowledgeAndVerify(*it);
   }
 }
 
 // Comprehensive test of various scenarios for multiple IDs.
 TEST_F(SyncInvalidationListenerTest, InvalidateMultipleIds) {
   FireInvalidate(kBookmarksId_, 3, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
   AcknowledgeAndVerify(kBookmarksId_);
 
   FireInvalidate(kExtensionsId_, 2, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_));
+  EXPECT_EQ(2, GetVersion(kExtensionsId_));
   EXPECT_EQ("", GetPayload(kExtensionsId_));
   EXPECT_EQ(2, GetMaxVersion(kExtensionsId_));
   AcknowledgeAndVerify(kExtensionsId_);
 
   // Invalidations with lower version numbers should be ignored.
 
   FireInvalidate(kBookmarksId_, 1, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   FireInvalidate(kExtensionsId_, 1, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_));
+  EXPECT_EQ(2, GetVersion(kExtensionsId_));
   EXPECT_EQ("", GetPayload(kExtensionsId_));
   EXPECT_EQ(2, GetMaxVersion(kExtensionsId_));
 
   // InvalidateAll shouldn't change any version state.
 
   FireInvalidateAll();
 
   EXPECT_EQ(2, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(Invalidation::kUnknownVersion, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
   AcknowledgeAndVerify(kBookmarksId_);
 
   EXPECT_EQ(1, GetInvalidationCount(kPreferencesId_));
+  EXPECT_EQ(Invalidation::kUnknownVersion, GetVersion(kPreferencesId_));
   EXPECT_EQ("", GetPayload(kPreferencesId_));
   EXPECT_EQ(kMinVersion, GetMaxVersion(kPreferencesId_));
   AcknowledgeAndVerify(kPreferencesId_);
 
   // Note that kExtensionsId_ is not registered, so InvalidateAll() shouldn't
   // affect it.
   EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_));
+  EXPECT_EQ(2, GetVersion(kExtensionsId_));
   EXPECT_EQ("", GetPayload(kExtensionsId_));
   EXPECT_EQ(2, GetMaxVersion(kExtensionsId_));
   VerifyAcknowledged(kExtensionsId_);
 
   // Invalidations with higher version numbers should be processed.
 
   FireInvalidate(kPreferencesId_, 5, NULL);
   EXPECT_EQ(2, GetInvalidationCount(kPreferencesId_));
+  EXPECT_EQ(5, GetVersion(kPreferencesId_));
   EXPECT_EQ("", GetPayload(kPreferencesId_));
   EXPECT_EQ(5, GetMaxVersion(kPreferencesId_));
   AcknowledgeAndVerify(kPreferencesId_);
 
   FireInvalidate(kExtensionsId_, 3, NULL);
   EXPECT_EQ(2, GetInvalidationCount(kExtensionsId_));
+  EXPECT_EQ(3, GetVersion(kExtensionsId_));
   EXPECT_EQ("", GetPayload(kExtensionsId_));
   EXPECT_EQ(3, GetMaxVersion(kExtensionsId_));
   AcknowledgeAndVerify(kExtensionsId_);
 
   FireInvalidate(kBookmarksId_, 4, NULL);
   EXPECT_EQ(3, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(4, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(4, GetMaxVersion(kBookmarksId_));
   AcknowledgeAndVerify(kBookmarksId_);
 }
 
 // Various tests for the local invalidation feature.
 // Tests a "normal" scenario. We allow one timeout period to expire by sending
 // ack handles that are not the "latest" ack handle. Once the timeout expires,
 // we verify that we get a second callback and then acknowledge it. Once
 // acknowledged, no further timeouts should occur.
 TEST_F(SyncInvalidationListenerTest, InvalidateOneTimeout) {
   listener_.GetAckTrackerForTest()->SetCreateBackoffEntryCallbackForTest(
       base::Bind(&CreateMockEntry, &tick_clock_));
 
   // Trigger the initial invalidation.
   FireInvalidate(kBookmarksId_, 3, NULL);
   EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
   VerifyUnacknowledged(kBookmarksId_);
 
   // Trigger one timeout.
   tick_clock_.LeapForward(60);
   EXPECT_TRUE(listener_.GetAckTrackerForTest()->TriggerTimeoutAtForTest(
       tick_clock_.NowTicks()));
   EXPECT_EQ(2, GetInvalidationCount(kBookmarksId_));
   // Other properties should remain the same.
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   AcknowledgeAndVerify(kBookmarksId_);
 
   // No more invalidations should remain in the queue.
   EXPECT_TRUE(listener_.GetAckTrackerForTest()->IsQueueEmptyForTest());
 }
 
 // Test that an unacknowledged invalidation triggers reminders if the listener
 // is restarted.
 TEST_F(SyncInvalidationListenerTest, InvalidationTimeoutRestart) {
   listener_.GetAckTrackerForTest()->SetCreateBackoffEntryCallbackForTest(
       base::Bind(&CreateMockEntry, &tick_clock_));
 
   FireInvalidate(kBookmarksId_, 3, NULL);
   EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   // Trigger one timeout.
   tick_clock_.LeapForward(60);
   EXPECT_TRUE(listener_.GetAckTrackerForTest()->TriggerTimeoutAtForTest(
       tick_clock_.NowTicks()));
   EXPECT_EQ(2, GetInvalidationCount(kBookmarksId_));
   // Other properties should remain the same.
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   // Restarting the client should reset the retry count and the timeout period
   // (e.g. it shouldn't increase to 120 seconds). Skip ahead 1200 seconds to be
   // on the safe side.
   StopClient();
   tick_clock_.LeapForward(1200);
   StartClient();
 
   // The bookmark invalidation state should not have changed.
   EXPECT_EQ(2, GetInvalidationCount(kBookmarksId_));
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   // Now trigger the invalidation reminder after the client restarts.
   tick_clock_.LeapForward(60);
   EXPECT_TRUE(listener_.GetAckTrackerForTest()->TriggerTimeoutAtForTest(
       tick_clock_.NowTicks()));
   EXPECT_EQ(3, GetInvalidationCount(kBookmarksId_));
   // Other properties should remain the same.
+  EXPECT_EQ(3, GetVersion(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   AcknowledgeAndVerify(kBookmarksId_);
 
   // No more invalidations should remain in the queue.
   EXPECT_TRUE(listener_.GetAckTrackerForTest()->IsQueueEmptyForTest());
 
   // The queue should remain empty when we restart now.
   RestartClient();
@@ skipping 257 matching lines @@
   EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, GetInvalidatorState());
 
   listener_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(INVALIDATIONS_ENABLED, GetInvalidatorState());
 }
 
 }  // namespace
 
 }  // namespace syncer