[invalidations] Added table with registered objectsIds

chrome/browser/invalidation/invalidation_logger_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 "chrome/browser/invalidation/invalidation_logger.h"
 #include "chrome/browser/invalidation/invalidation_logger_observer.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace invalidation {
 
 class InvalidationLoggerTest : public testing::Test {
  public:
   InvalidationLoggerTest() {}
 };
 
 class InvalidationLoggerObserverTest : public InvalidationLoggerObserver {
  public:
-  InvalidationLoggerObserverTest() { resetStates(); }
+  InvalidationLoggerObserverTest() { ResetStates(); }
 
-  void resetStates() {
+  void ResetStates() {
     registrationReceived = false;

[Nicolas Zea, 2014/02/11 21:58:25]

all of these variables (and all variables in the rest of this file) should be in
the format unix_hacker_style.

Not sure if it checks variable names, but you git cl format might help

[mferreria_g, 2014/02/12 00:03:46]

They are not checked by cl format. Applied that modification to all variables.

     unregistrationReceived = false;
     stateReceived = false;
     updateIdReceived = false;
     debugMessageReceived = false;
     invalidationReceived = false;
+    updateIdsReplicated = std::map<std::string, syncer::ObjectIdSet>();
   }
 
   virtual void OnRegistration(const base::DictionaryValue& details) OVERRIDE {
     registrationReceived = true;
   }
 
   virtual void OnUnregistration(const base::DictionaryValue& details) OVERRIDE {
     unregistrationReceived = true;
   }
 
   virtual void OnStateChange(const syncer::InvalidatorState& newState)
       OVERRIDE {
     stateReceived = true;
   }
 
-  virtual void OnUpdateIds(const base::DictionaryValue& details) OVERRIDE {
+  virtual void OnUpdateIds(std::string handler,
+                           const syncer::ObjectIdSet& details) OVERRIDE {
     updateIdReceived = true;
+    updateIdsReplicated[handler] = details;
   }
 
   virtual void OnDebugMessage(const base::DictionaryValue& details) OVERRIDE {
     debugMessageReceived = true;
   }
 
   virtual void OnInvalidation(
       const syncer::ObjectIdInvalidationMap& newInvalidations) OVERRIDE {
     invalidationReceived = true;
   }
 
   bool registrationReceived;
   bool unregistrationReceived;
   bool stateReceived;
   bool updateIdReceived;
   bool debugMessageReceived;
   bool invalidationReceived;
+  std::map<std::string, syncer::ObjectIdSet> updateIdsReplicated;
 };
 
 // Test that the callbacks are actually being called when observers are
 // registered and don't produce any other callback in the meantime.
 TEST_F(InvalidationLoggerTest, TestCallbacks) {
   InvalidationLogger log;
   InvalidationLoggerObserverTest observerTest;
 
   log.RegisterForDebug(&observerTest);
   log.OnStateChange(syncer::INVALIDATIONS_ENABLED);
   EXPECT_TRUE(observerTest.stateReceived);
   EXPECT_FALSE(observerTest.updateIdReceived);
   EXPECT_FALSE(observerTest.registrationReceived);
   EXPECT_FALSE(observerTest.invalidationReceived);
   EXPECT_FALSE(observerTest.unregistrationReceived);
   EXPECT_FALSE(observerTest.debugMessageReceived);
 
-  observerTest.resetStates();
+  observerTest.ResetStates();
 
   log.OnInvalidation(syncer::ObjectIdInvalidationMap());
   EXPECT_TRUE(observerTest.invalidationReceived);
   EXPECT_FALSE(observerTest.stateReceived);
   EXPECT_FALSE(observerTest.updateIdReceived);
   EXPECT_FALSE(observerTest.registrationReceived);
   EXPECT_FALSE(observerTest.unregistrationReceived);
   EXPECT_FALSE(observerTest.debugMessageReceived);
 
   log.UnregisterForDebug(&observerTest);
 }
 
 // Test that after registering an observer and then unregistering it
 // no callbacks regarding that observer are called.
 // (i.e. the observer is cleanly removed)
 TEST_F(InvalidationLoggerTest, TestReleaseOfObserver) {
   InvalidationLogger log;
   InvalidationLoggerObserverTest observerTest;
 
   log.RegisterForDebug(&observerTest);
   log.UnregisterForDebug(&observerTest);
 
   log.OnInvalidation(syncer::ObjectIdInvalidationMap());
   log.OnStateChange(syncer::INVALIDATIONS_ENABLED);
   log.OnRegistration(base::DictionaryValue());
   log.OnUnregistration(base::DictionaryValue());
   log.OnDebugMessage(base::DictionaryValue());
-  log.OnUpdateIds(base::DictionaryValue());
+  log.OnUpdateIds(std::map<std::string, syncer::ObjectIdSet>());
   EXPECT_FALSE(observerTest.registrationReceived);
   EXPECT_FALSE(observerTest.unregistrationReceived);
   EXPECT_FALSE(observerTest.updateIdReceived);
   EXPECT_FALSE(observerTest.invalidationReceived);
   EXPECT_FALSE(observerTest.stateReceived);
   EXPECT_FALSE(observerTest.debugMessageReceived);
 }
 
 // Test the EmitContet in InvalidationLogger is actually
-// sending (only) state notifications.
+// sending state and updateIds notifications.
 TEST_F(InvalidationLoggerTest, TestEmitContent) {
   InvalidationLogger log;
   InvalidationLoggerObserverTest observerTest;
 
   log.RegisterForDebug(&observerTest);
   EXPECT_FALSE(observerTest.stateReceived);
+  EXPECT_FALSE(observerTest.updateIdReceived);
   log.EmitContent();
-
+  // Only expect state because no Ids were registered.
   EXPECT_TRUE(observerTest.stateReceived);
   EXPECT_FALSE(observerTest.registrationReceived);
   EXPECT_FALSE(observerTest.unregistrationReceived);
   EXPECT_FALSE(observerTest.updateIdReceived);
   EXPECT_FALSE(observerTest.invalidationReceived);
   EXPECT_FALSE(observerTest.debugMessageReceived);
+
+  observerTest.ResetStates();
+  std::map<std::string, syncer::ObjectIdSet> testMap;
+  testMap["Test"] = syncer::ObjectIdSet();
+  log.OnUpdateIds(testMap);
+  EXPECT_TRUE(observerTest.updateIdReceived);
+  observerTest.ResetStates();
+
+  log.EmitContent();
+  // Expect now state and ids change.
+  EXPECT_TRUE(observerTest.stateReceived);
+  EXPECT_TRUE(observerTest.updateIdReceived);
+  EXPECT_FALSE(observerTest.registrationReceived);
+  EXPECT_FALSE(observerTest.unregistrationReceived);
+  EXPECT_FALSE(observerTest.invalidationReceived);
+  EXPECT_FALSE(observerTest.debugMessageReceived);
+  log.UnregisterForDebug(&observerTest);
+}
+
+// Test that the updateId notification actually sends
+// what was is sent to the Observer.

[Nicolas Zea, 2014/02/11 21:58:25]

nit: what was is -> what was

[mferreria_g, 2014/02/12 00:03:46]

Done.

+// The ObserverTest rebuilds the map that is sent in pieces by the logger.

[Nicolas Zea, 2014/02/11 21:58:25]

nit: that is sent -> that was sent

[mferreria_g, 2014/02/12 00:03:46]

Done.

+TEST_F(InvalidationLoggerTest, TestUpdateIdsMap) {
+  InvalidationLogger log;
+  InvalidationLoggerObserverTest observerTest;
+  std::map<std::string, syncer::ObjectIdSet> testMap;
+  log.RegisterForDebug(&observerTest);
+
+  syncer::ObjectIdSet syncSetA;
+  syncSetA.insert(ObjectId(1000, "DataType1"));
+  syncSetA.insert(ObjectId(1000, "DataType2"));
+  syncer::ObjectIdSet syncSetB;
+  syncSetB.insert(ObjectId(1020, "DataTypeA"));
+  testMap["TestA"] = syncSetA;
+  testMap["TestB"] = syncSetB;
+
+  log.OnUpdateIds(testMap);
+  EXPECT_EQ(testMap, observerTest.updateIdsReplicated);
+
+  syncer::ObjectIdSet syncSetB2;
+  syncSetB2.insert(ObjectId(1020, "DataTypeF"));
+  syncSetB2.insert(ObjectId(1020, "DataTypeG"));
+  testMap["TestB"] = syncSetB2;
+
+  log.OnUpdateIds(testMap);
+  EXPECT_EQ(testMap, observerTest.updateIdsReplicated);
+
+  // The emit content should return the same map too.
+  observerTest.ResetStates();
+  log.EmitContent();
+  EXPECT_EQ(testMap, observerTest.updateIdsReplicated);
+
   log.UnregisterForDebug(&observerTest);
 }
 }  // namespace invalidation