| OLD | NEW |
|---|
| (Empty) |
| 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 "chrome/browser/invalidation/invalidation_logger.h" | |
| 6 #include "chrome/browser/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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 255273002:
First step towards invalidations componentization (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src