components/invalidation/invalidation_logger_unittest.cc

   1 // Copyright 2014 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 "components/invalidation/invalidation_logger.h"
   6 #include "components/invalidation/invalidation_logger_observer.h"
   7
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace invalidation {
  11
  12 class InvalidationLoggerObserverTest : public InvalidationLoggerObserver {
  13  public:
  14   InvalidationLoggerObserverTest() { ResetStates(); }
  15
  16   void ResetStates() {
  17     registration_change_received = false;
  18     state_received = false;
  19     update_id_received = false;
  20     debug_message_received = false;
  21     invalidation_received = false;
  22     detailed_status_received = false;
  23     update_id_replicated = std::map<std::string, syncer::ObjectIdCountMap>();
  24     registered_handlers = std::multiset<std::string>();
  25   }
  26
  27   virtual void OnRegistrationChange(const std::multiset<std::string>& handlers)
  28       OVERRIDE {
  29     registered_handlers = handlers;
  30     registration_change_received = true;
  31   }
  32
  33   virtual void OnStateChange(const syncer::InvalidatorState& new_state,
  34                              const base::Time& last_change_timestamp)
  35       OVERRIDE {
  36     state_received = true;
  37   }
  38
  39   virtual void OnUpdateIds(const std::string& handler,
  40                            const syncer::ObjectIdCountMap& details) OVERRIDE {
  41     update_id_received = true;
  42     update_id_replicated[handler] = details;
  43   }
  44
  45   virtual void OnDebugMessage(const base::DictionaryValue& details) OVERRIDE {
  46     debug_message_received = true;
  47   }
  48
  49   virtual void OnInvalidation(
  50       const syncer::ObjectIdInvalidationMap& new_invalidations) OVERRIDE {
  51     invalidation_received = true;
  52   }
  53
  54   virtual void OnDetailedStatus(const base::DictionaryValue& details) OVERRIDE {
  55     detailed_status_received = true;
  56   }
  57
  58   bool registration_change_received;
  59   bool state_received;
  60   bool update_id_received;
  61   bool debug_message_received;
  62   bool invalidation_received;
  63   bool detailed_status_received;
  64   std::map<std::string, syncer::ObjectIdCountMap> update_id_replicated;
  65   std::multiset<std::string> registered_handlers;
  66 };
  67
  68 // Test that the callbacks are actually being called when observers are
  69 // registered and don't produce any other callback in the meantime.
  70 TEST(InvalidationLoggerTest, TestCallbacks) {
  71   InvalidationLogger log;
  72   InvalidationLoggerObserverTest observer_test;
  73
  74   log.RegisterObserver(&observer_test);
  75   log.OnStateChange(syncer::INVALIDATIONS_ENABLED);
  76   EXPECT_TRUE(observer_test.state_received);
  77   EXPECT_FALSE(observer_test.update_id_received);
  78   EXPECT_FALSE(observer_test.registration_change_received);
  79   EXPECT_FALSE(observer_test.invalidation_received);
  80   EXPECT_FALSE(observer_test.debug_message_received);
  81   EXPECT_FALSE(observer_test.detailed_status_received);
  82
  83   observer_test.ResetStates();
  84
  85   log.OnInvalidation(syncer::ObjectIdInvalidationMap());
  86   EXPECT_TRUE(observer_test.invalidation_received);
  87   EXPECT_FALSE(observer_test.state_received);
  88   EXPECT_FALSE(observer_test.update_id_received);
  89   EXPECT_FALSE(observer_test.registration_change_received);
  90   EXPECT_FALSE(observer_test.debug_message_received);
  91   EXPECT_FALSE(observer_test.detailed_status_received);
  92
  93   log.UnregisterObserver(&observer_test);
  94 }
  95
  96 // Test that after registering an observer and then unregistering it
  97 // no callbacks regarding that observer are called.
  98 // (i.e. the observer is cleanly removed)
  99 TEST(InvalidationLoggerTest, TestReleaseOfObserver) {
 100   InvalidationLogger log;
 101   InvalidationLoggerObserverTest observer_test;
 102
 103   log.RegisterObserver(&observer_test);
 104   log.UnregisterObserver(&observer_test);
 105
 106   log.OnInvalidation(syncer::ObjectIdInvalidationMap());
 107   log.OnStateChange(syncer::INVALIDATIONS_ENABLED);
 108   log.OnRegistration(std::string());
 109   log.OnUnregistration(std::string());
 110   log.OnDebugMessage(base::DictionaryValue());
 111   log.OnUpdateIds(std::map<std::string, syncer::ObjectIdSet>());
 112   EXPECT_FALSE(observer_test.registration_change_received);
 113   EXPECT_FALSE(observer_test.update_id_received);
 114   EXPECT_FALSE(observer_test.invalidation_received);
 115   EXPECT_FALSE(observer_test.state_received);
 116   EXPECT_FALSE(observer_test.debug_message_received);
 117   EXPECT_FALSE(observer_test.detailed_status_received);
 118 }
 119
 120 // Test the EmitContet in InvalidationLogger is actually
 121 // sending state and updateIds notifications.
 122 TEST(InvalidationLoggerTest, TestEmitContent) {
 123   InvalidationLogger log;
 124   InvalidationLoggerObserverTest observer_test;
 125
 126   log.RegisterObserver(&observer_test);
 127   EXPECT_FALSE(observer_test.state_received);
 128   EXPECT_FALSE(observer_test.update_id_received);
 129   log.EmitContent();
 130   // Expect state and registered handlers only because no Ids were registered.
 131   EXPECT_TRUE(observer_test.state_received);
 132   EXPECT_TRUE(observer_test.registration_change_received);
 133   EXPECT_FALSE(observer_test.update_id_received);
 134   EXPECT_FALSE(observer_test.invalidation_received);
 135   EXPECT_FALSE(observer_test.debug_message_received);
 136   EXPECT_FALSE(observer_test.detailed_status_received);
 137
 138   observer_test.ResetStates();
 139   std::map<std::string, syncer::ObjectIdSet> test_map;
 140   test_map["Test"] = syncer::ObjectIdSet();
 141   log.OnUpdateIds(test_map);
 142   EXPECT_TRUE(observer_test.update_id_received);
 143   observer_test.ResetStates();
 144
 145   log.EmitContent();
 146   // Expect now state, ids and registered handlers change.
 147   EXPECT_TRUE(observer_test.state_received);
 148   EXPECT_TRUE(observer_test.update_id_received);
 149   EXPECT_TRUE(observer_test.registration_change_received);
 150   EXPECT_FALSE(observer_test.invalidation_received);
 151   EXPECT_FALSE(observer_test.debug_message_received);
 152   EXPECT_FALSE(observer_test.detailed_status_received);
 153   log.UnregisterObserver(&observer_test);
 154 }
 155
 156 // Test that the updateId notification actually sends the same ObjectId that
 157 // was sent to the Observer.
 158 // The ObserverTest rebuilds the map that was sent in pieces by the logger.
 159 TEST(InvalidationLoggerTest, TestUpdateIdsMap) {
 160   InvalidationLogger log;
 161   InvalidationLoggerObserverTest observer_test;
 162   std::map<std::string, syncer::ObjectIdSet> send_test_map;
 163   std::map<std::string, syncer::ObjectIdCountMap> expected_received_map;
 164   log.RegisterObserver(&observer_test);
 165
 166   syncer::ObjectIdSet sync_set_A;
 167   syncer::ObjectIdCountMap counted_sync_set_A;
 168
 169   ObjectId o1(1000, "DataType1");
 170   sync_set_A.insert(o1);
 171   counted_sync_set_A[o1] = 0;
 172
 173   ObjectId o2(1000, "DataType2");
 174   sync_set_A.insert(o2);
 175   counted_sync_set_A[o2] = 0;
 176
 177   syncer::ObjectIdSet sync_set_B;
 178   syncer::ObjectIdCountMap counted_sync_set_B;
 179
 180   ObjectId o3(1020, "DataTypeA");
 181   sync_set_B.insert(o3);
 182   counted_sync_set_B[o3] = 0;
 183
 184   send_test_map["TestA"] = sync_set_A;
 185   send_test_map["TestB"] = sync_set_B;
 186   expected_received_map["TestA"] = counted_sync_set_A;
 187   expected_received_map["TestB"] = counted_sync_set_B;
 188
 189   // Send the objects ids registered for the two different handler name.
 190   log.OnUpdateIds(send_test_map);
 191   EXPECT_EQ(expected_received_map, observer_test.update_id_replicated);
 192
 193   syncer::ObjectIdSet sync_set_B2;
 194   syncer::ObjectIdCountMap counted_sync_set_B2;
 195
 196   ObjectId o4(1020, "DataTypeF");
 197   sync_set_B2.insert(o4);
 198   counted_sync_set_B2[o4] = 0;
 199
 200   ObjectId o5(1020, "DataTypeG");
 201   sync_set_B2.insert(o5);
 202   counted_sync_set_B2[o5] = 0;
 203
 204   send_test_map["TestB"] = sync_set_B2;
 205   expected_received_map["TestB"] = counted_sync_set_B2;
 206
 207   // Test now that if we replace the registered datatypes for TestB, the
 208   // original don't show up again.
 209   log.OnUpdateIds(send_test_map);
 210   EXPECT_EQ(expected_received_map, observer_test.update_id_replicated);
 211
 212   // The emit content should return the same map too.
 213   observer_test.ResetStates();
 214   log.EmitContent();
 215   EXPECT_EQ(expected_received_map, observer_test.update_id_replicated);
 216   log.UnregisterObserver(&observer_test);
 217 }
 218
 219 // Test that the invalidation notification changes the total count
 220 // of invalidations received for that datatype.
 221 TEST(InvalidationLoggerTest, TestInvalidtionsTotalCount) {
 222   InvalidationLogger log;
 223   InvalidationLoggerObserverTest observer_test;
 224   log.RegisterObserver(&observer_test);
 225
 226   std::map<std::string, syncer::ObjectIdSet> send_test_map;
 227   std::map<std::string, syncer::ObjectIdCountMap> expected_received_map;
 228   syncer::ObjectIdSet sync_set;
 229   syncer::ObjectIdCountMap counted_sync_set;
 230
 231   ObjectId o1(1020, "DataTypeA");
 232   sync_set.insert(o1);
 233   counted_sync_set[o1] = 1;
 234
 235   // Generate invalidation for datatype A only.
 236   syncer::ObjectIdInvalidationMap fake_invalidations =
 237       syncer::ObjectIdInvalidationMap::InvalidateAll(sync_set);
 238
 239   ObjectId o2(1040, "DataTypeB");
 240   sync_set.insert(o2);
 241   counted_sync_set[o2] = 0;
 242
 243   // Registed the two objectIds and send an invalidation only for the
 244   // Datatype A.
 245   send_test_map["Test"] = sync_set;
 246   log.OnUpdateIds(send_test_map);
 247   log.OnInvalidation(fake_invalidations);
 248
 249   expected_received_map["Test"] = counted_sync_set;
 250
 251   // Reset the state of the observer to receive the ObjectIds with the
 252   // count of invalidations received (1 and 0).
 253   observer_test.ResetStates();
 254   log.EmitContent();
 255   EXPECT_EQ(expected_received_map, observer_test.update_id_replicated);
 256
 257   log.UnregisterObserver(&observer_test);
 258 }
 259
 260 // Test that registered handlers are being sent to the observers.
 261 TEST(InvalidationLoggerTest, TestRegisteredHandlers) {
 262   InvalidationLogger log;
 263   InvalidationLoggerObserverTest observer_test;
 264   log.RegisterObserver(&observer_test);
 265
 266   log.OnRegistration(std::string("FakeHandler1"));
 267   std::multiset<std::string> test_multiset;
 268   test_multiset.insert("FakeHandler1");
 269   EXPECT_TRUE(observer_test.registration_change_received);
 270   EXPECT_EQ(observer_test.registered_handlers, test_multiset);
 271
 272   observer_test.ResetStates();
 273   log.OnRegistration(std::string("FakeHandler2"));
 274   test_multiset.insert("FakeHandler2");
 275   EXPECT_TRUE(observer_test.registration_change_received);
 276   EXPECT_EQ(observer_test.registered_handlers, test_multiset);
 277
 278   observer_test.ResetStates();
 279   log.OnUnregistration(std::string("FakeHandler2"));
 280   test_multiset.erase("FakeHandler2");
 281   EXPECT_TRUE(observer_test.registration_change_received);
 282   EXPECT_EQ(observer_test.registered_handlers, test_multiset);
 283
 284   log.UnregisterObserver(&observer_test);
 285 }
 286 }  // namespace invalidation