OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include <cstddef> |
| 6 #include <set> |
5 #include <string> | 7 #include <string> |
6 | 8 |
| 9 #include "base/compiler_specific.h" |
7 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
8 #include "google/cacheinvalidation/include/invalidation-client.h" | 11 #include "google/cacheinvalidation/include/invalidation-client.h" |
9 #include "google/cacheinvalidation/include/types.h" | 12 #include "google/cacheinvalidation/include/types.h" |
10 #include "google/cacheinvalidation/types.pb.h" | |
11 #include "jingle/notifier/listener/fake_push_client.h" | 13 #include "jingle/notifier/listener/fake_push_client.h" |
12 #include "sync/internal_api/public/util/weak_handle.h" | 14 #include "sync/internal_api/public/util/weak_handle.h" |
13 #include "sync/notifier/chrome_invalidation_client.h" | 15 #include "sync/notifier/chrome_invalidation_client.h" |
14 #include "sync/notifier/mock_invalidation_state_tracker.h" | 16 #include "sync/notifier/fake_invalidation_state_tracker.h" |
15 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "sync/notifier/invalidation_util.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
17 | 19 |
18 namespace syncer { | 20 namespace syncer { |
19 | 21 |
20 using ::testing::_; | |
21 using ::testing::InSequence; | |
22 using ::testing::Return; | |
23 using ::testing::StrictMock; | |
24 | |
25 namespace { | 22 namespace { |
26 | 23 |
| 24 using invalidation::AckHandle; |
| 25 using invalidation::ObjectId; |
| 26 |
27 const char kClientId[] = "client_id"; | 27 const char kClientId[] = "client_id"; |
28 const char kClientInfo[] = "client_info"; | 28 const char kClientInfo[] = "client_info"; |
| 29 |
29 const char kState[] = "state"; | 30 const char kState[] = "state"; |
30 const char kNewState[] = "new_state"; | 31 const char kNewState[] = "new_state"; |
31 | 32 |
| 33 const char kPayload1[] = "payload1"; |
| 34 const char kPayload2[] = "payload2"; |
| 35 |
| 36 const int64 kMinVersion = FakeInvalidationStateTracker::kMinVersion; |
| 37 const int64 kVersion1 = 1LL; |
| 38 const int64 kVersion2 = 2LL; |
| 39 |
32 const int kChromeSyncSourceId = 1004; | 40 const int kChromeSyncSourceId = 1004; |
33 | 41 |
34 class MockInvalidationClient : public invalidation::InvalidationClient { | 42 struct AckHandleLessThan { |
| 43 bool operator()(const AckHandle& lhs, const AckHandle& rhs) const { |
| 44 return lhs.handle_data() < rhs.handle_data(); |
| 45 } |
| 46 }; |
| 47 |
| 48 typedef std::set<AckHandle, AckHandleLessThan> AckHandleSet; |
| 49 |
| 50 // Fake invalidation::InvalidationClient implementation that keeps |
| 51 // track of registered IDs and acked handles. |
| 52 class FakeInvalidationClient : public invalidation::InvalidationClient { |
35 public: | 53 public: |
36 MOCK_METHOD0(Start, void()); | 54 FakeInvalidationClient() : started_(false) {} |
37 MOCK_METHOD0(Stop, void()); | 55 virtual ~FakeInvalidationClient() {} |
38 MOCK_METHOD1(Register, void(const invalidation::ObjectId&)); | 56 |
39 MOCK_METHOD1(Register, void(const std::vector<invalidation::ObjectId>&)); | 57 const ObjectIdSet& GetRegisteredIds() const { |
40 MOCK_METHOD1(Unregister, void(const invalidation::ObjectId&)); | 58 return registered_ids_; |
41 MOCK_METHOD1(Unregister, void(const std::vector<invalidation::ObjectId>&)); | 59 } |
42 MOCK_METHOD1(Acknowledge, void(const invalidation::AckHandle&)); | 60 |
| 61 void ClearAckedHandles() { |
| 62 acked_handles_.clear(); |
| 63 } |
| 64 |
| 65 bool IsAckedHandle(const AckHandle& ack_handle) const { |
| 66 return (acked_handles_.find(ack_handle) != acked_handles_.end()); |
| 67 } |
| 68 |
| 69 // invalidation::InvalidationClient implementation. |
| 70 |
| 71 virtual void Start() OVERRIDE { |
| 72 started_ = true; |
| 73 } |
| 74 |
| 75 virtual void Stop() OVERRIDE { |
| 76 started_ = false; |
| 77 } |
| 78 |
| 79 virtual void Register(const ObjectId& object_id) OVERRIDE { |
| 80 if (!started_) { |
| 81 ADD_FAILURE(); |
| 82 return; |
| 83 } |
| 84 registered_ids_.insert(object_id); |
| 85 } |
| 86 |
| 87 virtual void Register( |
| 88 const invalidation::vector<ObjectId>& object_ids) OVERRIDE { |
| 89 if (!started_) { |
| 90 ADD_FAILURE(); |
| 91 return; |
| 92 } |
| 93 registered_ids_.insert(object_ids.begin(), object_ids.end()); |
| 94 } |
| 95 |
| 96 virtual void Unregister(const ObjectId& object_id) OVERRIDE { |
| 97 if (!started_) { |
| 98 ADD_FAILURE(); |
| 99 return; |
| 100 } |
| 101 registered_ids_.erase(object_id); |
| 102 } |
| 103 |
| 104 virtual void Unregister( |
| 105 const invalidation::vector<ObjectId>& object_ids) OVERRIDE { |
| 106 if (!started_) { |
| 107 ADD_FAILURE(); |
| 108 return; |
| 109 } |
| 110 for (invalidation::vector<ObjectId>::const_iterator |
| 111 it = object_ids.begin(); it != object_ids.end(); ++it) { |
| 112 registered_ids_.erase(*it); |
| 113 } |
| 114 } |
| 115 |
| 116 virtual void Acknowledge(const AckHandle& ack_handle) OVERRIDE { |
| 117 if (!started_) { |
| 118 ADD_FAILURE(); |
| 119 return; |
| 120 } |
| 121 acked_handles_.insert(ack_handle); |
| 122 } |
| 123 |
| 124 private: |
| 125 bool started_; |
| 126 ObjectIdSet registered_ids_; |
| 127 AckHandleSet acked_handles_; |
43 }; | 128 }; |
44 | 129 |
45 class MockListener : public ChromeInvalidationClient::Listener { | 130 // Fake listener tkat keeps track of invalidation counts, payloads, |
| 131 // and state. |
| 132 class FakeListener : public ChromeInvalidationClient::Listener { |
46 public: | 133 public: |
47 MOCK_METHOD1(OnInvalidate, void(const ObjectIdPayloadMap&)); | 134 FakeListener() : reason_(TRANSIENT_NOTIFICATION_ERROR) {} |
48 MOCK_METHOD0(OnNotificationsEnabled, void()); | 135 virtual ~FakeListener() {} |
49 MOCK_METHOD1(OnNotificationsDisabled, void(NotificationsDisabledReason)); | 136 |
| 137 int GetInvalidationCount(const ObjectId& id) const { |
| 138 ObjectIdCountMap::const_iterator it = invalidation_counts_.find(id); |
| 139 return (it == invalidation_counts_.end()) ? 0 : it->second; |
| 140 } |
| 141 |
| 142 std::string GetPayload(const ObjectId& id) const { |
| 143 ObjectIdPayloadMap::const_iterator it = payloads_.find(id); |
| 144 return (it == payloads_.end()) ? "" : it->second; |
| 145 } |
| 146 |
| 147 // NO_NOTIFICATION_ERROR is the enabled state. |
| 148 NotificationsDisabledReason GetNotificationsDisabledReason() const { |
| 149 return reason_; |
| 150 } |
| 151 |
| 152 // ChromeInvalidationClient::Listener implementation. |
| 153 |
| 154 virtual void OnInvalidate(const ObjectIdPayloadMap& id_payloads) OVERRIDE { |
| 155 for (ObjectIdPayloadMap::const_iterator it = id_payloads.begin(); |
| 156 it != id_payloads.end(); ++it) { |
| 157 ++invalidation_counts_[it->first]; |
| 158 payloads_[it->first] = it->second; |
| 159 } |
| 160 } |
| 161 |
| 162 virtual void OnNotificationsEnabled() { |
| 163 reason_ = NO_NOTIFICATION_ERROR; |
| 164 } |
| 165 |
| 166 virtual void OnNotificationsDisabled(NotificationsDisabledReason reason) { |
| 167 reason_ = reason; |
| 168 } |
| 169 |
| 170 private: |
| 171 typedef std::map<ObjectId, int, ObjectIdLessThan> ObjectIdCountMap; |
| 172 ObjectIdCountMap invalidation_counts_; |
| 173 ObjectIdPayloadMap payloads_; |
| 174 NotificationsDisabledReason reason_; |
50 }; | 175 }; |
51 | 176 |
52 ObjectIdSet MakeSetFromId(const invalidation::ObjectId& id) { | 177 invalidation::InvalidationClient* CreateFakeInvalidationClient( |
53 ObjectIdSet ids; | 178 FakeInvalidationClient** fake_invalidation_client, |
54 ids.insert(id); | 179 invalidation::SystemResources* resources, |
55 return ids; | 180 int client_type, |
56 } | 181 const invalidation::string& client_name, |
57 | 182 const invalidation::string& application_name, |
58 ObjectIdPayloadMap ObjectIdsAndPayloadToMap(const ObjectIdSet& ids, | 183 invalidation::InvalidationListener* listener) { |
59 const std::string& payload) { | 184 *fake_invalidation_client = new FakeInvalidationClient(); |
60 ObjectIdPayloadMap id_payloads; | 185 return *fake_invalidation_client; |
61 for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) { | 186 } |
62 id_payloads[*it] = payload; | |
63 } | |
64 return id_payloads; | |
65 } | |
66 | |
67 } // namespace | |
68 | 187 |
69 class ChromeInvalidationClientTest : public testing::Test { | 188 class ChromeInvalidationClientTest : public testing::Test { |
70 protected: | 189 protected: |
71 ChromeInvalidationClientTest() | 190 ChromeInvalidationClientTest() |
72 : fake_push_client_(new notifier::FakePushClient()), | 191 : kBookmarksId_(kChromeSyncSourceId, "BOOKMARK"), |
73 client_(scoped_ptr<notifier::PushClient>(fake_push_client_)), | |
74 kBookmarksId_(kChromeSyncSourceId, "BOOKMARK"), | |
75 kPreferencesId_(kChromeSyncSourceId, "PREFERENCE"), | 192 kPreferencesId_(kChromeSyncSourceId, "PREFERENCE"), |
76 kExtensionsId_(kChromeSyncSourceId, "EXTENSION"), | 193 kExtensionsId_(kChromeSyncSourceId, "EXTENSION"), |
77 kAppsId_(kChromeSyncSourceId, "APP") {} | 194 kAppsId_(kChromeSyncSourceId, "APP"), |
| 195 fake_push_client_(new notifier::FakePushClient()), |
| 196 fake_invalidation_client_(NULL), |
| 197 client_(scoped_ptr<notifier::PushClient>(fake_push_client_)) {} |
78 | 198 |
79 virtual void SetUp() { | 199 virtual void SetUp() { |
80 client_.Start(kClientId, kClientInfo, kState, | 200 StartClient(); |
81 InvalidationVersionMap(), | 201 |
82 MakeWeakHandle(mock_invalidation_state_tracker_.AsWeakPtr()), | 202 registered_ids_.insert(kBookmarksId_); |
83 &mock_listener_); | 203 registered_ids_.insert(kPreferencesId_); |
| 204 client_.UpdateRegisteredIds(registered_ids_); |
84 } | 205 } |
85 | 206 |
86 virtual void TearDown() { | 207 virtual void TearDown() { |
87 // client_.Stop() stops the invalidation scheduler, which deletes any | 208 StopClient(); |
88 // pending tasks without running them. Some tasks "run and delete" another | 209 } |
89 // task, so they must be run in order to avoid leaking the inner task. | 210 |
90 // client_.Stop() does not schedule any tasks, so it's both necessary and | 211 // Restart client without re-registering IDs. |
91 // sufficient to drain the task queue before calling it. | 212 void RestartClient() { |
92 message_loop_.RunAllPending(); | 213 StopClient(); |
93 client_.Stop(); | 214 StartClient(); |
94 } | 215 } |
95 | 216 |
96 // |payload| can be NULL, but not |type_name|. | 217 int GetInvalidationCount(const ObjectId& id) const { |
97 void FireInvalidate(const char* type_name, | 218 return fake_listener_.GetInvalidationCount(id); |
| 219 } |
| 220 |
| 221 std::string GetPayload(const ObjectId& id) const { |
| 222 return fake_listener_.GetPayload(id); |
| 223 } |
| 224 |
| 225 NotificationsDisabledReason GetNotificationsDisabledReason() const { |
| 226 return fake_listener_.GetNotificationsDisabledReason(); |
| 227 } |
| 228 |
| 229 int64 GetMaxVersion(const ObjectId& id) const { |
| 230 return fake_tracker_.GetMaxVersion(id); |
| 231 } |
| 232 |
| 233 std::string GetInvalidationState() const { |
| 234 return fake_tracker_.GetInvalidationState(); |
| 235 } |
| 236 |
| 237 ObjectIdSet GetRegisteredIds() const { |
| 238 return fake_invalidation_client_->GetRegisteredIds(); |
| 239 } |
| 240 |
| 241 // |payload| can be NULL. |
| 242 void FireInvalidate(const ObjectId& object_id, |
98 int64 version, const char* payload) { | 243 int64 version, const char* payload) { |
99 const invalidation::ObjectId object_id( | |
100 ipc::invalidation::ObjectSource::CHROME_SYNC, type_name); | |
101 std::string payload_tmp = payload ? payload : ""; | |
102 invalidation::Invalidation inv; | 244 invalidation::Invalidation inv; |
103 if (payload) { | 245 if (payload) { |
104 inv = invalidation::Invalidation(object_id, version, payload); | 246 inv = invalidation::Invalidation(object_id, version, payload); |
105 } else { | 247 } else { |
106 inv = invalidation::Invalidation(object_id, version); | 248 inv = invalidation::Invalidation(object_id, version); |
107 } | 249 } |
108 invalidation::AckHandle ack_handle("fakedata"); | 250 const AckHandle ack_handle("fakedata"); |
109 EXPECT_CALL(mock_invalidation_client_, Acknowledge(ack_handle)); | 251 fake_invalidation_client_->ClearAckedHandles(); |
110 client_.Invalidate(&mock_invalidation_client_, inv, ack_handle); | 252 client_.Invalidate(fake_invalidation_client_, inv, ack_handle); |
| 253 EXPECT_TRUE(fake_invalidation_client_->IsAckedHandle(ack_handle)); |
111 // Pump message loop to trigger | 254 // Pump message loop to trigger |
112 // InvalidationStateTracker::SetMaxVersion(). | 255 // InvalidationStateTracker::SetMaxVersion(). |
113 message_loop_.RunAllPending(); | 256 message_loop_.RunAllPending(); |
114 } | 257 } |
115 | 258 |
116 // |payload| can be NULL, but not |type_name|. | 259 // |payload| can be NULL, but not |type_name|. |
117 void FireInvalidateUnknownVersion(const char* type_name) { | 260 void FireInvalidateUnknownVersion(const ObjectId& object_id) { |
118 const invalidation::ObjectId object_id( | 261 const AckHandle ack_handle("fakedata_unknown"); |
119 ipc::invalidation::ObjectSource::CHROME_SYNC, type_name); | 262 fake_invalidation_client_->ClearAckedHandles(); |
120 | 263 client_.InvalidateUnknownVersion(fake_invalidation_client_, object_id, |
121 invalidation::AckHandle ack_handle("fakedata"); | |
122 EXPECT_CALL(mock_invalidation_client_, Acknowledge(ack_handle)); | |
123 client_.InvalidateUnknownVersion(&mock_invalidation_client_, object_id, | |
124 ack_handle); | 264 ack_handle); |
| 265 EXPECT_TRUE(fake_invalidation_client_->IsAckedHandle(ack_handle)); |
125 } | 266 } |
126 | 267 |
127 void FireInvalidateAll() { | 268 void FireInvalidateAll() { |
128 invalidation::AckHandle ack_handle("fakedata"); | 269 const AckHandle ack_handle("fakedata_all"); |
129 EXPECT_CALL(mock_invalidation_client_, Acknowledge(ack_handle)); | 270 fake_invalidation_client_->ClearAckedHandles(); |
130 client_.InvalidateAll(&mock_invalidation_client_, ack_handle); | 271 client_.InvalidateAll(fake_invalidation_client_, ack_handle); |
| 272 EXPECT_TRUE(fake_invalidation_client_->IsAckedHandle(ack_handle)); |
| 273 } |
| 274 |
| 275 void WriteState(const std::string& new_state) { |
| 276 client_.WriteState(new_state); |
| 277 // Pump message loop to trigger |
| 278 // InvalidationStateTracker::WriteState(). |
| 279 message_loop_.RunAllPending(); |
| 280 } |
| 281 |
| 282 void EnableNotifications() { |
| 283 fake_push_client_->EnableNotifications(); |
| 284 } |
| 285 |
| 286 void DisableNotifications(notifier::NotificationsDisabledReason reason) { |
| 287 fake_push_client_->DisableNotifications(reason); |
| 288 } |
| 289 |
| 290 const ObjectId kBookmarksId_; |
| 291 const ObjectId kPreferencesId_; |
| 292 const ObjectId kExtensionsId_; |
| 293 const ObjectId kAppsId_; |
| 294 |
| 295 ObjectIdSet registered_ids_; |
| 296 |
| 297 private: |
| 298 void StartClient() { |
| 299 fake_invalidation_client_ = NULL; |
| 300 client_.Start(base::Bind(&CreateFakeInvalidationClient, |
| 301 &fake_invalidation_client_), |
| 302 kClientId, kClientInfo, kState, |
| 303 InvalidationVersionMap(), |
| 304 MakeWeakHandle(fake_tracker_.AsWeakPtr()), |
| 305 &fake_listener_); |
| 306 DCHECK(fake_invalidation_client_); |
| 307 } |
| 308 |
| 309 void StopClient() { |
| 310 // client_.StopForTest() stops the invalidation scheduler, which |
| 311 // deletes any pending tasks without running them. Some tasks |
| 312 // "run and delete" another task, so they must be run in order to |
| 313 // avoid leaking the inner task. client_.StopForTest() does not |
| 314 // schedule any tasks, so it's both necessary and sufficient to |
| 315 // drain the task queue before calling it. |
| 316 message_loop_.RunAllPending(); |
| 317 fake_invalidation_client_ = NULL; |
| 318 client_.StopForTest(); |
131 } | 319 } |
132 | 320 |
133 MessageLoop message_loop_; | 321 MessageLoop message_loop_; |
134 StrictMock<MockListener> mock_listener_; | 322 |
135 StrictMock<MockInvalidationStateTracker> | 323 FakeListener fake_listener_; |
136 mock_invalidation_state_tracker_; | 324 FakeInvalidationStateTracker fake_tracker_; |
137 StrictMock<MockInvalidationClient> mock_invalidation_client_; | |
138 notifier::FakePushClient* const fake_push_client_; | 325 notifier::FakePushClient* const fake_push_client_; |
| 326 |
| 327 protected: |
| 328 // Tests need to access these directly. |
| 329 FakeInvalidationClient* fake_invalidation_client_; |
139 ChromeInvalidationClient client_; | 330 ChromeInvalidationClient client_; |
140 | |
141 const invalidation::ObjectId kBookmarksId_; | |
142 const invalidation::ObjectId kPreferencesId_; | |
143 const invalidation::ObjectId kExtensionsId_; | |
144 const invalidation::ObjectId kAppsId_; | |
145 }; | 331 }; |
146 | 332 |
147 // Checks that we still dispatch an invalidation for something that's not | 333 // Write a new state to the client. It should propagate to the |
148 // currently registered (perhaps it was unregistered while it was still in | 334 // tracker. |
149 // flight). | 335 TEST_F(ChromeInvalidationClientTest, WriteState) { |
150 TEST_F(ChromeInvalidationClientTest, InvalidateBadObjectId) { | 336 WriteState(kNewState); |
151 ObjectIdSet ids; | 337 |
152 ids.insert(kBookmarksId_); | 338 EXPECT_EQ(kNewState, GetInvalidationState()); |
153 ids.insert(kAppsId_); | 339 } |
154 client_.RegisterIds(ids); | 340 |
155 EXPECT_CALL(mock_listener_, OnInvalidate( | 341 // Invalidation tests. |
156 ObjectIdsAndPayloadToMap( | 342 |
157 MakeSetFromId(invalidation::ObjectId(kChromeSyncSourceId, "bad")), | 343 // Fire an invalidation without a payload. It should be processed, |
158 std::string()))); | 344 // the payload should remain empty, and the version should be updated. |
159 EXPECT_CALL(mock_invalidation_state_tracker_, | |
160 SetMaxVersion(invalidation::ObjectId(kChromeSyncSourceId, "bad"), | |
161 1)); | |
162 FireInvalidate("bad", 1, NULL); | |
163 } | |
164 | |
165 TEST_F(ChromeInvalidationClientTest, InvalidateNoPayload) { | 345 TEST_F(ChromeInvalidationClientTest, InvalidateNoPayload) { |
166 EXPECT_CALL(mock_listener_, OnInvalidate( | 346 const ObjectId& id = kBookmarksId_; |
167 ObjectIdsAndPayloadToMap(MakeSetFromId(kBookmarksId_), std::string()))); | 347 |
168 EXPECT_CALL(mock_invalidation_state_tracker_, | 348 FireInvalidate(id, kVersion1, NULL); |
169 SetMaxVersion(kBookmarksId_, 1)); | 349 |
170 FireInvalidate("BOOKMARK", 1, NULL); | 350 EXPECT_EQ(1, GetInvalidationCount(id)); |
171 } | 351 EXPECT_EQ("", GetPayload(id)); |
172 | 352 EXPECT_EQ(kVersion1, GetMaxVersion(id)); |
| 353 } |
| 354 |
| 355 // Fire an invalidation with an empty payload. It should be |
| 356 // processed, the payload should remain empty, and the version should |
| 357 // be updated. |
| 358 TEST_F(ChromeInvalidationClientTest, InvalidateEmptyPayload) { |
| 359 const ObjectId& id = kBookmarksId_; |
| 360 |
| 361 FireInvalidate(id, kVersion1, ""); |
| 362 |
| 363 EXPECT_EQ(1, GetInvalidationCount(id)); |
| 364 EXPECT_EQ("", GetPayload(id)); |
| 365 EXPECT_EQ(kVersion1, GetMaxVersion(id)); |
| 366 } |
| 367 |
| 368 // Fire an invalidation with a payload. It should be processed, and |
| 369 // both the payload and the version should be updated. |
173 TEST_F(ChromeInvalidationClientTest, InvalidateWithPayload) { | 370 TEST_F(ChromeInvalidationClientTest, InvalidateWithPayload) { |
174 EXPECT_CALL(mock_listener_, OnInvalidate( | 371 const ObjectId& id = kPreferencesId_; |
175 ObjectIdsAndPayloadToMap(MakeSetFromId(kPreferencesId_), "payload"))); | 372 |
176 EXPECT_CALL(mock_invalidation_state_tracker_, | 373 FireInvalidate(id, kVersion1, kPayload1); |
177 SetMaxVersion(kPreferencesId_, 1)); | 374 |
178 FireInvalidate("PREFERENCE", 1, "payload"); | 375 EXPECT_EQ(1, GetInvalidationCount(id)); |
179 } | 376 EXPECT_EQ(kPayload1, GetPayload(id)); |
180 | 377 EXPECT_EQ(kVersion1, GetMaxVersion(id)); |
| 378 } |
| 379 |
| 380 // Fire an invalidation with a payload. It should still be processed, |
| 381 // and both the payload and the version should be updated. |
| 382 TEST_F(ChromeInvalidationClientTest, InvalidateUnregistered) { |
| 383 const ObjectId kUnregisteredId( |
| 384 kChromeSyncSourceId, "unregistered"); |
| 385 const ObjectId& id = kUnregisteredId; |
| 386 |
| 387 EXPECT_EQ(0, GetInvalidationCount(id)); |
| 388 EXPECT_EQ("", GetPayload(id)); |
| 389 EXPECT_EQ(kMinVersion, GetMaxVersion(id)); |
| 390 |
| 391 FireInvalidate(id, kVersion1, NULL); |
| 392 |
| 393 EXPECT_EQ(1, GetInvalidationCount(id)); |
| 394 EXPECT_EQ("", GetPayload(id)); |
| 395 EXPECT_EQ(kVersion1, GetMaxVersion(id)); |
| 396 } |
| 397 |
| 398 // Fire an invalidation, then fire another one with a lower version. |
| 399 // The first one should be processed and should update the payload and |
| 400 // version, but the second one shouldn't. |
181 TEST_F(ChromeInvalidationClientTest, InvalidateVersion) { | 401 TEST_F(ChromeInvalidationClientTest, InvalidateVersion) { |
182 using ::testing::Mock; | 402 const ObjectId& id = kPreferencesId_; |
183 | 403 |
184 EXPECT_CALL(mock_listener_, OnInvalidate( | 404 FireInvalidate(id, kVersion2, kPayload2); |
185 ObjectIdsAndPayloadToMap(MakeSetFromId(kAppsId_), std::string()))); | 405 |
186 EXPECT_CALL(mock_invalidation_state_tracker_, | 406 EXPECT_EQ(1, GetInvalidationCount(id)); |
187 SetMaxVersion(kAppsId_, 1)); | 407 EXPECT_EQ(kPayload2, GetPayload(id)); |
188 | 408 EXPECT_EQ(kVersion2, GetMaxVersion(id)); |
189 // Should trigger. | 409 |
190 FireInvalidate("APP", 1, NULL); | 410 FireInvalidate(id, kVersion1, kPayload1); |
191 | 411 |
192 Mock::VerifyAndClearExpectations(&mock_listener_); | 412 EXPECT_EQ(1, GetInvalidationCount(id)); |
193 | 413 EXPECT_EQ(kPayload2, GetPayload(id)); |
194 // Should be dropped. | 414 EXPECT_EQ(kVersion2, GetMaxVersion(id)); |
195 FireInvalidate("APP", 1, NULL); | 415 } |
196 } | 416 |
197 | 417 // Fire an invalidation with an unknown version twice. It shouldn't |
| 418 // update the payload or version either time, but it should still be |
| 419 // processed. |
198 TEST_F(ChromeInvalidationClientTest, InvalidateUnknownVersion) { | 420 TEST_F(ChromeInvalidationClientTest, InvalidateUnknownVersion) { |
199 EXPECT_CALL(mock_listener_, OnInvalidate( | 421 const ObjectId& id = kBookmarksId_; |
200 ObjectIdsAndPayloadToMap(MakeSetFromId(kExtensionsId_), | 422 |
201 std::string()))).Times(2); | 423 FireInvalidateUnknownVersion(id); |
202 | 424 |
203 // Should trigger twice. | 425 EXPECT_EQ(1, GetInvalidationCount(id)); |
204 FireInvalidateUnknownVersion("EXTENSION"); | 426 EXPECT_EQ("", GetPayload(id)); |
205 FireInvalidateUnknownVersion("EXTENSION"); | 427 EXPECT_EQ(kMinVersion, GetMaxVersion(id)); |
206 } | 428 |
207 | 429 FireInvalidateUnknownVersion(id); |
208 // Comprehensive test of various invalidations that we might receive from Tango | 430 |
209 // and how they interact. | 431 EXPECT_EQ(2, GetInvalidationCount(id)); |
210 TEST_F(ChromeInvalidationClientTest, InvalidateVersionMultipleTypes) { | 432 EXPECT_EQ("", GetPayload(id)); |
211 using ::testing::Mock; | 433 EXPECT_EQ(kMinVersion, GetMaxVersion(id)); |
212 | 434 } |
213 ObjectIdSet ids; | 435 |
214 ids.insert(kBookmarksId_); | 436 // Fire an invalidation for all enabled IDs. It shouldn't update the |
215 ids.insert(kAppsId_); | 437 // payload or version, but it should still invalidate the IDs. |
216 client_.RegisterIds(ids); | 438 TEST_F(ChromeInvalidationClientTest, InvalidateAll) { |
217 | 439 FireInvalidateAll(); |
218 // Initial invalidations to the client should be recorded and dispatched to | 440 |
219 // the listener. | 441 for (ObjectIdSet::const_iterator it = registered_ids_.begin(); |
220 EXPECT_CALL(mock_listener_, OnInvalidate( | 442 it != registered_ids_.end(); ++it) { |
221 ObjectIdsAndPayloadToMap(MakeSetFromId(kAppsId_), std::string()))); | 443 EXPECT_EQ(1, GetInvalidationCount(*it)); |
222 EXPECT_CALL(mock_listener_, OnInvalidate( | 444 EXPECT_EQ("", GetPayload(*it)); |
223 ObjectIdsAndPayloadToMap(MakeSetFromId(kExtensionsId_), std::string()))); | 445 EXPECT_EQ(kMinVersion, GetMaxVersion(*it)); |
224 | 446 } |
225 EXPECT_CALL(mock_invalidation_state_tracker_, | 447 } |
226 SetMaxVersion(kAppsId_, 3)); | 448 |
227 EXPECT_CALL(mock_invalidation_state_tracker_, | 449 // Comprehensive test of various scenarios for multiple IDs. |
228 SetMaxVersion(kExtensionsId_, 2)); | 450 TEST_F(ChromeInvalidationClientTest, InvalidateMultipleIds) { |
229 | 451 FireInvalidate(kBookmarksId_, 3, NULL); |
230 FireInvalidate("APP", 3, NULL); | 452 |
231 FireInvalidate("EXTENSION", 2, NULL); | 453 EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_)); |
232 | 454 EXPECT_EQ("", GetPayload(kBookmarksId_)); |
233 Mock::VerifyAndClearExpectations(&mock_listener_); | 455 EXPECT_EQ(3, GetMaxVersion(kBookmarksId_)); |
234 Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_); | 456 |
235 | 457 FireInvalidate(kExtensionsId_, 2, NULL); |
236 // Out-of-order invalidations with lower version numbers should be ignored. | 458 |
237 FireInvalidate("APP", 1, NULL); | 459 EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_)); |
238 FireInvalidate("EXTENSION", 1, NULL); | 460 EXPECT_EQ("", GetPayload(kExtensionsId_)); |
239 | 461 EXPECT_EQ(2, GetMaxVersion(kExtensionsId_)); |
240 Mock::VerifyAndClearExpectations(&mock_listener_); | 462 |
241 Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_); | 463 // Invalidations with lower version numbers should be ignored. |
| 464 |
| 465 FireInvalidate(kBookmarksId_, 1, NULL); |
| 466 |
| 467 EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_)); |
| 468 EXPECT_EQ("", GetPayload(kBookmarksId_)); |
| 469 EXPECT_EQ(3, GetMaxVersion(kBookmarksId_)); |
| 470 |
| 471 FireInvalidate(kExtensionsId_, 1, NULL); |
| 472 |
| 473 EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_)); |
| 474 EXPECT_EQ("", GetPayload(kExtensionsId_)); |
| 475 EXPECT_EQ(2, GetMaxVersion(kExtensionsId_)); |
242 | 476 |
243 // InvalidateAll shouldn't change any version state. | 477 // InvalidateAll shouldn't change any version state. |
244 EXPECT_CALL(mock_listener_, | 478 |
245 OnInvalidate(ObjectIdsAndPayloadToMap(ids, std::string()))); | |
246 FireInvalidateAll(); | 479 FireInvalidateAll(); |
247 | 480 |
248 Mock::VerifyAndClearExpectations(&mock_listener_); | 481 EXPECT_EQ(2, GetInvalidationCount(kBookmarksId_)); |
249 Mock::VerifyAndClearExpectations(&mock_invalidation_state_tracker_); | 482 EXPECT_EQ("", GetPayload(kBookmarksId_)); |
250 | 483 EXPECT_EQ(3, GetMaxVersion(kBookmarksId_)); |
251 EXPECT_CALL(mock_listener_, OnInvalidate( | 484 |
252 ObjectIdsAndPayloadToMap(MakeSetFromId(kPreferencesId_), std::string()))); | 485 EXPECT_EQ(1, GetInvalidationCount(kPreferencesId_)); |
253 EXPECT_CALL(mock_listener_, OnInvalidate( | 486 EXPECT_EQ("", GetPayload(kPreferencesId_)); |
254 ObjectIdsAndPayloadToMap(MakeSetFromId(kExtensionsId_), std::string()))); | 487 EXPECT_EQ(kMinVersion, GetMaxVersion(kPreferencesId_)); |
255 EXPECT_CALL(mock_listener_, OnInvalidate( | 488 |
256 ObjectIdsAndPayloadToMap(MakeSetFromId(kAppsId_), std::string()))); | 489 EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_)); |
257 | 490 EXPECT_EQ("", GetPayload(kExtensionsId_)); |
258 // Normal invalidations with monotonically increasing version numbers. | 491 EXPECT_EQ(2, GetMaxVersion(kExtensionsId_)); |
259 EXPECT_CALL(mock_invalidation_state_tracker_, | 492 |
260 SetMaxVersion(kPreferencesId_, 5)); | 493 // Invalidations with higher version numbers should be processed. |
261 EXPECT_CALL(mock_invalidation_state_tracker_, | 494 |
262 SetMaxVersion(kExtensionsId_, 3)); | 495 FireInvalidate(kPreferencesId_, 5, NULL); |
263 EXPECT_CALL(mock_invalidation_state_tracker_, | 496 EXPECT_EQ(2, GetInvalidationCount(kPreferencesId_)); |
264 SetMaxVersion(kAppsId_, 4)); | 497 EXPECT_EQ("", GetPayload(kPreferencesId_)); |
265 | 498 EXPECT_EQ(5, GetMaxVersion(kPreferencesId_)); |
266 // All three should be triggered. | 499 |
267 FireInvalidate("PREFERENCE", 5, NULL); | 500 FireInvalidate(kExtensionsId_, 3, NULL); |
268 FireInvalidate("EXTENSION", 3, NULL); | 501 EXPECT_EQ(2, GetInvalidationCount(kExtensionsId_)); |
269 FireInvalidate("APP", 4, NULL); | 502 EXPECT_EQ("", GetPayload(kExtensionsId_)); |
270 } | 503 EXPECT_EQ(3, GetMaxVersion(kExtensionsId_)); |
271 | 504 |
272 TEST_F(ChromeInvalidationClientTest, InvalidateAll) { | 505 FireInvalidate(kBookmarksId_, 4, NULL); |
273 ObjectIdSet ids; | 506 EXPECT_EQ(3, GetInvalidationCount(kBookmarksId_)); |
274 ids.insert(kPreferencesId_); | 507 EXPECT_EQ("", GetPayload(kBookmarksId_)); |
275 ids.insert(kExtensionsId_); | 508 EXPECT_EQ(4, GetMaxVersion(kBookmarksId_)); |
276 client_.RegisterIds(ids); | 509 } |
277 EXPECT_CALL(mock_listener_, OnInvalidate( | 510 |
278 ObjectIdsAndPayloadToMap(ids, std::string()))); | 511 // Registration tests. |
279 FireInvalidateAll(); | 512 |
280 } | 513 // With IDs already registered, enable notifications then ready the |
281 | 514 // client. The IDs should be registered only after the client is |
282 TEST_F(ChromeInvalidationClientTest, RegisterTypes) { | 515 // readied. |
283 ObjectIdSet ids; | 516 TEST_F(ChromeInvalidationClientTest, RegisterEnableReady) { |
284 ids.insert(kPreferencesId_); | 517 EXPECT_TRUE(GetRegisteredIds().empty()); |
285 ids.insert(kExtensionsId_); | 518 |
286 client_.RegisterIds(ids); | 519 EnableNotifications(); |
287 // Registered types should be preserved across Stop/Start. | 520 |
288 TearDown(); | 521 EXPECT_TRUE(GetRegisteredIds().empty()); |
289 SetUp(); | 522 |
290 EXPECT_CALL(mock_listener_,OnInvalidate( | 523 client_.Ready(fake_invalidation_client_); |
291 ObjectIdsAndPayloadToMap(ids, std::string()))); | 524 |
292 FireInvalidateAll(); | 525 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
293 } | 526 } |
294 | 527 |
295 TEST_F(ChromeInvalidationClientTest, WriteState) { | 528 // With IDs already registered, ready the client then enable |
296 EXPECT_CALL(mock_invalidation_state_tracker_, | 529 // notifications. The IDs should be registered after the client is |
297 SetInvalidationState(kNewState)); | 530 // readied. |
298 client_.WriteState(kNewState); | 531 TEST_F(ChromeInvalidationClientTest, RegisterReadyEnable) { |
299 } | 532 EXPECT_TRUE(GetRegisteredIds().empty()); |
300 | 533 |
301 TEST_F(ChromeInvalidationClientTest, StateChangesNotReady) { | 534 client_.Ready(fake_invalidation_client_); |
302 InSequence dummy; | 535 |
303 EXPECT_CALL(mock_listener_, | 536 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
304 OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR)); | 537 |
305 EXPECT_CALL(mock_listener_, | 538 EnableNotifications(); |
306 OnNotificationsDisabled(NOTIFICATION_CREDENTIALS_REJECTED)); | 539 |
307 EXPECT_CALL(mock_listener_, | 540 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
308 OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR)); | 541 } |
309 | 542 |
310 fake_push_client_->DisableNotifications( | 543 // Unregister the IDs, enable notifications, re-register the IDs, then |
| 544 // ready the client. The IDs should be registered only after the |
| 545 // client is readied. |
| 546 TEST_F(ChromeInvalidationClientTest, EnableRegisterReady) { |
| 547 client_.UpdateRegisteredIds(ObjectIdSet()); |
| 548 |
| 549 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 550 |
| 551 EnableNotifications(); |
| 552 |
| 553 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 554 |
| 555 client_.UpdateRegisteredIds(registered_ids_); |
| 556 |
| 557 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 558 |
| 559 client_.Ready(fake_invalidation_client_); |
| 560 |
| 561 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 562 } |
| 563 |
| 564 // Unregister the IDs, enable notifications, ready the client, then |
| 565 // re-register the IDs. The IDs should be registered only after the |
| 566 // client is readied. |
| 567 TEST_F(ChromeInvalidationClientTest, EnableReadyRegister) { |
| 568 client_.UpdateRegisteredIds(ObjectIdSet()); |
| 569 |
| 570 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 571 |
| 572 EnableNotifications(); |
| 573 |
| 574 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 575 |
| 576 client_.Ready(fake_invalidation_client_); |
| 577 |
| 578 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 579 |
| 580 client_.UpdateRegisteredIds(registered_ids_); |
| 581 |
| 582 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 583 } |
| 584 |
| 585 // Unregister the IDs, ready the client, enable notifications, then |
| 586 // re-register the IDs. The IDs should be registered only after the |
| 587 // client is readied. |
| 588 TEST_F(ChromeInvalidationClientTest, ReadyEnableRegister) { |
| 589 client_.UpdateRegisteredIds(ObjectIdSet()); |
| 590 |
| 591 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 592 |
| 593 EnableNotifications(); |
| 594 |
| 595 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 596 |
| 597 client_.Ready(fake_invalidation_client_); |
| 598 |
| 599 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 600 |
| 601 client_.UpdateRegisteredIds(registered_ids_); |
| 602 |
| 603 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 604 } |
| 605 |
| 606 // Unregister the IDs, ready the client, re-register the IDs, then |
| 607 // enable notifications. The IDs should be registered only after the |
| 608 // client is readied. |
| 609 // |
| 610 // This test is important: see http://crbug.com/139424. |
| 611 TEST_F(ChromeInvalidationClientTest, ReadyRegisterEnable) { |
| 612 client_.UpdateRegisteredIds(ObjectIdSet()); |
| 613 |
| 614 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 615 |
| 616 client_.Ready(fake_invalidation_client_); |
| 617 |
| 618 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 619 |
| 620 client_.UpdateRegisteredIds(registered_ids_); |
| 621 |
| 622 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 623 |
| 624 EnableNotifications(); |
| 625 |
| 626 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 627 } |
| 628 |
| 629 // With IDs already registered, ready the client, restart the client, |
| 630 // then re-ready it. The IDs should still be registered. |
| 631 TEST_F(ChromeInvalidationClientTest, RegisterTypesPreserved) { |
| 632 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 633 |
| 634 client_.Ready(fake_invalidation_client_); |
| 635 |
| 636 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 637 |
| 638 RestartClient(); |
| 639 |
| 640 EXPECT_TRUE(GetRegisteredIds().empty()); |
| 641 |
| 642 client_.Ready(fake_invalidation_client_); |
| 643 |
| 644 EXPECT_EQ(registered_ids_, GetRegisteredIds()); |
| 645 } |
| 646 |
| 647 // Without readying the client, disable notifications, then enable |
| 648 // them. The listener should still think notifications are disabled. |
| 649 TEST_F(ChromeInvalidationClientTest, EnableNotificationsNotReady) { |
| 650 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, |
| 651 GetNotificationsDisabledReason()); |
| 652 |
| 653 DisableNotifications( |
311 notifier::TRANSIENT_NOTIFICATION_ERROR); | 654 notifier::TRANSIENT_NOTIFICATION_ERROR); |
312 fake_push_client_->DisableNotifications( | 655 |
| 656 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, |
| 657 GetNotificationsDisabledReason()); |
| 658 |
| 659 DisableNotifications( |
313 notifier::NOTIFICATION_CREDENTIALS_REJECTED); | 660 notifier::NOTIFICATION_CREDENTIALS_REJECTED); |
314 fake_push_client_->EnableNotifications(); | 661 |
315 } | 662 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
316 | 663 GetNotificationsDisabledReason()); |
317 TEST_F(ChromeInvalidationClientTest, StateChangesReady) { | 664 |
318 InSequence dummy; | 665 EnableNotifications(); |
319 EXPECT_CALL(mock_listener_, | 666 |
320 OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR)); | 667 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, |
321 EXPECT_CALL(mock_listener_, OnNotificationsEnabled()); | 668 GetNotificationsDisabledReason()); |
322 EXPECT_CALL(mock_listener_, | 669 } |
323 OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR)); | 670 |
324 EXPECT_CALL(mock_listener_, | 671 // Enable notifications then Ready the invalidation client. The |
325 OnNotificationsDisabled(NOTIFICATION_CREDENTIALS_REJECTED)); | 672 // listener should then be ready. |
326 EXPECT_CALL(mock_listener_, OnNotificationsEnabled()); | 673 TEST_F(ChromeInvalidationClientTest, EnableNotificationsThenReady) { |
327 | 674 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
328 fake_push_client_->EnableNotifications(); | 675 |
329 client_.Ready(NULL); | 676 EnableNotifications(); |
330 fake_push_client_->DisableNotifications( | 677 |
331 notifier::TRANSIENT_NOTIFICATION_ERROR); | 678 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
332 fake_push_client_->DisableNotifications( | 679 |
| 680 client_.Ready(fake_invalidation_client_); |
| 681 |
| 682 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 683 } |
| 684 |
| 685 // Ready the invalidation client then enable notifications. The |
| 686 // listener should then be ready. |
| 687 TEST_F(ChromeInvalidationClientTest, ReadyThenEnableNotifications) { |
| 688 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 689 |
| 690 client_.Ready(fake_invalidation_client_); |
| 691 |
| 692 EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 693 |
| 694 EnableNotifications(); |
| 695 |
| 696 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 697 } |
| 698 |
| 699 // Enable notifications and ready the client. Then disable |
| 700 // notifications with an auth error and re-enable notifications. The |
| 701 // listener should go into an auth error mode and then back out. |
| 702 TEST_F(ChromeInvalidationClientTest, PushClientAuthError) { |
| 703 EnableNotifications(); |
| 704 client_.Ready(fake_invalidation_client_); |
| 705 |
| 706 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 707 |
| 708 DisableNotifications( |
333 notifier::NOTIFICATION_CREDENTIALS_REJECTED); | 709 notifier::NOTIFICATION_CREDENTIALS_REJECTED); |
334 fake_push_client_->EnableNotifications(); | 710 |
335 } | 711 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
336 | 712 GetNotificationsDisabledReason()); |
337 TEST_F(ChromeInvalidationClientTest, StateChangesAuthError) { | 713 |
338 InSequence dummy; | 714 EnableNotifications(); |
339 EXPECT_CALL(mock_listener_, | 715 |
340 OnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR)); | 716 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
341 EXPECT_CALL(mock_listener_, OnNotificationsEnabled()); | 717 } |
342 EXPECT_CALL(mock_listener_, | 718 |
343 OnNotificationsDisabled(NOTIFICATION_CREDENTIALS_REJECTED)) | 719 // Enable notifications and ready the client. Then simulate an auth |
344 .Times(4); | 720 // error from the invalidation client. Simulate some notification |
345 EXPECT_CALL(mock_listener_, OnNotificationsEnabled()); | 721 // events, then re-ready the client. The listener should go into an |
346 | 722 // auth error mode and come out of it only after the client is ready. |
347 fake_push_client_->EnableNotifications(); | 723 TEST_F(ChromeInvalidationClientTest, InvalidationClientAuthError) { |
348 client_.Ready(NULL); | 724 EnableNotifications(); |
| 725 client_.Ready(fake_invalidation_client_); |
| 726 |
| 727 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
349 | 728 |
350 client_.InformError( | 729 client_.InformError( |
351 NULL, | 730 fake_invalidation_client_, |
352 invalidation::ErrorInfo( | 731 invalidation::ErrorInfo( |
353 invalidation::ErrorReason::AUTH_FAILURE, | 732 invalidation::ErrorReason::AUTH_FAILURE, |
354 false /* is_transient */, | 733 false /* is_transient */, |
355 "auth error", | 734 "auth error", |
356 invalidation::ErrorContext())); | 735 invalidation::ErrorContext())); |
357 fake_push_client_->DisableNotifications( | 736 |
| 737 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
| 738 GetNotificationsDisabledReason()); |
| 739 |
| 740 DisableNotifications( |
358 notifier::TRANSIENT_NOTIFICATION_ERROR); | 741 notifier::TRANSIENT_NOTIFICATION_ERROR); |
359 fake_push_client_->DisableNotifications( | 742 |
360 notifier::NOTIFICATION_CREDENTIALS_REJECTED); | 743 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
361 fake_push_client_->EnableNotifications(); | 744 GetNotificationsDisabledReason()); |
362 client_.Ready(NULL); | 745 |
363 } | 746 DisableNotifications( |
| 747 notifier::TRANSIENT_NOTIFICATION_ERROR); |
| 748 |
| 749 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
| 750 GetNotificationsDisabledReason()); |
| 751 |
| 752 EnableNotifications(); |
| 753 |
| 754 EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED, |
| 755 GetNotificationsDisabledReason()); |
| 756 |
| 757 client_.Ready(fake_invalidation_client_); |
| 758 |
| 759 EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason()); |
| 760 } |
| 761 |
| 762 } // namespace |
364 | 763 |
365 } // namespace syncer | 764 } // namespace syncer |
OLD | NEW |