OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "google_apis/gcm/engine/gcm_store_impl.h" | 5 #include "google_apis/gcm/engine/gcm_store_impl.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | |
9 #include <string> | 8 #include <string> |
| 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
11 | 11 |
12 #include "base/bind.h" | 12 #include "base/bind.h" |
13 #include "base/command_line.h" | 13 #include "base/command_line.h" |
14 #include "base/files/file_path.h" | 14 #include "base/files/file_path.h" |
15 #include "base/files/scoped_temp_dir.h" | 15 #include "base/files/scoped_temp_dir.h" |
16 #include "base/memory/scoped_ptr.h" | 16 #include "base/memory/scoped_ptr.h" |
17 #include "base/strings/string_number_conversions.h" | 17 #include "base/strings/string_number_conversions.h" |
18 #include "base/test/test_simple_task_runner.h" | 18 #include "base/test/test_simple_task_runner.h" |
19 #include "base/thread_task_runner_handle.h" | 19 #include "base/thread_task_runner_handle.h" |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
103 std::string GCMStoreImplTest::GetNextPersistentId() { | 103 std::string GCMStoreImplTest::GetNextPersistentId() { |
104 return base::Uint64ToString(next_persistent_id_++); | 104 return base::Uint64ToString(next_persistent_id_++); |
105 } | 105 } |
106 | 106 |
107 void GCMStoreImplTest::PumpLoop() { task_runner_->RunUntilIdle(); } | 107 void GCMStoreImplTest::PumpLoop() { task_runner_->RunUntilIdle(); } |
108 | 108 |
109 void GCMStoreImplTest::LoadCallback( | 109 void GCMStoreImplTest::LoadCallback( |
110 scoped_ptr<GCMStore::LoadResult>* result_dst, | 110 scoped_ptr<GCMStore::LoadResult>* result_dst, |
111 scoped_ptr<GCMStore::LoadResult> result) { | 111 scoped_ptr<GCMStore::LoadResult> result) { |
112 ASSERT_TRUE(result->success); | 112 ASSERT_TRUE(result->success); |
113 LoadWithoutCheckCallback(result_dst, result.Pass()); | 113 LoadWithoutCheckCallback(result_dst, std::move(result)); |
114 } | 114 } |
115 | 115 |
116 void GCMStoreImplTest::LoadWithoutCheckCallback( | 116 void GCMStoreImplTest::LoadWithoutCheckCallback( |
117 scoped_ptr<GCMStore::LoadResult>* result_dst, | 117 scoped_ptr<GCMStore::LoadResult>* result_dst, |
118 scoped_ptr<GCMStore::LoadResult> result) { | 118 scoped_ptr<GCMStore::LoadResult> result) { |
119 *result_dst = result.Pass(); | 119 *result_dst = std::move(result); |
120 } | 120 } |
121 | 121 |
122 void GCMStoreImplTest::UpdateCallback(bool success) { | 122 void GCMStoreImplTest::UpdateCallback(bool success) { |
123 ASSERT_EQ(expected_success_, success); | 123 ASSERT_EQ(expected_success_, success); |
124 } | 124 } |
125 | 125 |
126 // Verify creating a new database and loading it. | 126 // Verify creating a new database and loading it. |
127 TEST_F(GCMStoreImplTest, LoadNew) { | 127 TEST_F(GCMStoreImplTest, LoadNew) { |
128 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 128 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
129 scoped_ptr<GCMStore::LoadResult> load_result; | 129 scoped_ptr<GCMStore::LoadResult> load_result; |
(...skipping 26 matching lines...) Expand all Loading... |
156 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 156 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
157 scoped_ptr<GCMStore::LoadResult> load_result; | 157 scoped_ptr<GCMStore::LoadResult> load_result; |
158 LoadGCMStore(gcm_store.get(), &load_result); | 158 LoadGCMStore(gcm_store.get(), &load_result); |
159 | 159 |
160 gcm_store->SetDeviceCredentials( | 160 gcm_store->SetDeviceCredentials( |
161 kDeviceId, | 161 kDeviceId, |
162 kDeviceToken, | 162 kDeviceToken, |
163 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 163 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
164 PumpLoop(); | 164 PumpLoop(); |
165 | 165 |
166 gcm_store = BuildGCMStore().Pass(); | 166 gcm_store = BuildGCMStore(); |
167 LoadGCMStore(gcm_store.get(), &load_result); | 167 LoadGCMStore(gcm_store.get(), &load_result); |
168 | 168 |
169 ASSERT_EQ(kDeviceId, load_result->device_android_id); | 169 ASSERT_EQ(kDeviceId, load_result->device_android_id); |
170 ASSERT_EQ(kDeviceToken, load_result->device_security_token); | 170 ASSERT_EQ(kDeviceToken, load_result->device_security_token); |
171 } | 171 } |
172 | 172 |
173 TEST_F(GCMStoreImplTest, LastCheckinInfo) { | 173 TEST_F(GCMStoreImplTest, LastCheckinInfo) { |
174 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 174 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
175 scoped_ptr<GCMStore::LoadResult> load_result; | 175 scoped_ptr<GCMStore::LoadResult> load_result; |
176 LoadGCMStore(gcm_store.get(), &load_result); | 176 LoadGCMStore(gcm_store.get(), &load_result); |
177 | 177 |
178 base::Time last_checkin_time = base::Time::Now(); | 178 base::Time last_checkin_time = base::Time::Now(); |
179 std::set<std::string> accounts; | 179 std::set<std::string> accounts; |
180 accounts.insert("test_user1@gmail.com"); | 180 accounts.insert("test_user1@gmail.com"); |
181 accounts.insert("test_user2@gmail.com"); | 181 accounts.insert("test_user2@gmail.com"); |
182 | 182 |
183 gcm_store->SetLastCheckinInfo( | 183 gcm_store->SetLastCheckinInfo( |
184 last_checkin_time, | 184 last_checkin_time, |
185 accounts, | 185 accounts, |
186 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 186 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
187 PumpLoop(); | 187 PumpLoop(); |
188 | 188 |
189 gcm_store = BuildGCMStore().Pass(); | 189 gcm_store = BuildGCMStore(); |
190 LoadGCMStore(gcm_store.get(), &load_result); | 190 LoadGCMStore(gcm_store.get(), &load_result); |
191 ASSERT_EQ(last_checkin_time, load_result->last_checkin_time); | 191 ASSERT_EQ(last_checkin_time, load_result->last_checkin_time); |
192 ASSERT_EQ(accounts, load_result->last_checkin_accounts); | 192 ASSERT_EQ(accounts, load_result->last_checkin_accounts); |
193 | 193 |
194 // Negative cases, where the value read is gibberish. | 194 // Negative cases, where the value read is gibberish. |
195 gcm_store->SetValueForTesting( | 195 gcm_store->SetValueForTesting( |
196 "last_checkin_time", | 196 "last_checkin_time", |
197 "gibberish", | 197 "gibberish", |
198 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 198 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
199 PumpLoop(); | 199 PumpLoop(); |
200 | 200 |
201 gcm_store = BuildGCMStore().Pass(); | 201 gcm_store = BuildGCMStore(); |
202 LoadGCMStore(gcm_store.get(), &load_result); | 202 LoadGCMStore(gcm_store.get(), &load_result); |
203 EXPECT_EQ(base::Time(), load_result->last_checkin_time); | 203 EXPECT_EQ(base::Time(), load_result->last_checkin_time); |
204 } | 204 } |
205 | 205 |
206 TEST_F(GCMStoreImplTest, GServicesSettings_ProtocolV2) { | 206 TEST_F(GCMStoreImplTest, GServicesSettings_ProtocolV2) { |
207 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 207 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
208 scoped_ptr<GCMStore::LoadResult> load_result; | 208 scoped_ptr<GCMStore::LoadResult> load_result; |
209 LoadGCMStore(gcm_store.get(), &load_result); | 209 LoadGCMStore(gcm_store.get(), &load_result); |
210 | 210 |
211 std::map<std::string, std::string> settings; | 211 std::map<std::string, std::string> settings; |
212 settings["checkin_interval"] = "12345"; | 212 settings["checkin_interval"] = "12345"; |
213 settings["mcs_port"] = "438"; | 213 settings["mcs_port"] = "438"; |
214 settings["checkin_url"] = "http://checkin.google.com"; | 214 settings["checkin_url"] = "http://checkin.google.com"; |
215 std::string digest = "digest1"; | 215 std::string digest = "digest1"; |
216 | 216 |
217 gcm_store->SetGServicesSettings( | 217 gcm_store->SetGServicesSettings( |
218 settings, | 218 settings, |
219 digest, | 219 digest, |
220 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 220 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
221 PumpLoop(); | 221 PumpLoop(); |
222 | 222 |
223 gcm_store = BuildGCMStore().Pass(); | 223 gcm_store = BuildGCMStore(); |
224 LoadGCMStore(gcm_store.get(), &load_result); | 224 LoadGCMStore(gcm_store.get(), &load_result); |
225 | 225 |
226 ASSERT_EQ(settings, load_result->gservices_settings); | 226 ASSERT_EQ(settings, load_result->gservices_settings); |
227 ASSERT_EQ(digest, load_result->gservices_digest); | 227 ASSERT_EQ(digest, load_result->gservices_digest); |
228 | 228 |
229 // Remove some, and add some. | 229 // Remove some, and add some. |
230 settings.clear(); | 230 settings.clear(); |
231 settings["checkin_interval"] = "54321"; | 231 settings["checkin_interval"] = "54321"; |
232 settings["registration_url"] = "http://registration.google.com"; | 232 settings["registration_url"] = "http://registration.google.com"; |
233 digest = "digest2"; | 233 digest = "digest2"; |
234 | 234 |
235 gcm_store->SetGServicesSettings( | 235 gcm_store->SetGServicesSettings( |
236 settings, | 236 settings, |
237 digest, | 237 digest, |
238 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 238 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
239 PumpLoop(); | 239 PumpLoop(); |
240 | 240 |
241 gcm_store = BuildGCMStore().Pass(); | 241 gcm_store = BuildGCMStore(); |
242 LoadGCMStore(gcm_store.get(), &load_result); | 242 LoadGCMStore(gcm_store.get(), &load_result); |
243 | 243 |
244 ASSERT_EQ(settings, load_result->gservices_settings); | 244 ASSERT_EQ(settings, load_result->gservices_settings); |
245 ASSERT_EQ(digest, load_result->gservices_digest); | 245 ASSERT_EQ(digest, load_result->gservices_digest); |
246 } | 246 } |
247 | 247 |
248 TEST_F(GCMStoreImplTest, Registrations) { | 248 TEST_F(GCMStoreImplTest, Registrations) { |
249 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 249 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
250 scoped_ptr<GCMStore::LoadResult> load_result; | 250 scoped_ptr<GCMStore::LoadResult> load_result; |
251 LoadGCMStore(gcm_store.get(), &load_result); | 251 LoadGCMStore(gcm_store.get(), &load_result); |
252 | 252 |
253 // Add one registration with one sender. | 253 // Add one registration with one sender. |
254 std::string registration = "sender1=registration1"; | 254 std::string registration = "sender1=registration1"; |
255 gcm_store->AddRegistration( | 255 gcm_store->AddRegistration( |
256 kAppName, | 256 kAppName, |
257 registration, | 257 registration, |
258 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 258 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
259 PumpLoop(); | 259 PumpLoop(); |
260 | 260 |
261 // Add one registration with multiple senders. | 261 // Add one registration with multiple senders. |
262 std::string registration2 = "sender1,sender2=registration2"; | 262 std::string registration2 = "sender1,sender2=registration2"; |
263 gcm_store->AddRegistration( | 263 gcm_store->AddRegistration( |
264 kAppName2, | 264 kAppName2, |
265 registration2, | 265 registration2, |
266 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 266 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
267 PumpLoop(); | 267 PumpLoop(); |
268 | 268 |
269 gcm_store = BuildGCMStore().Pass(); | 269 gcm_store = BuildGCMStore(); |
270 LoadGCMStore(gcm_store.get(), &load_result); | 270 LoadGCMStore(gcm_store.get(), &load_result); |
271 | 271 |
272 ASSERT_EQ(2u, load_result->registrations.size()); | 272 ASSERT_EQ(2u, load_result->registrations.size()); |
273 ASSERT_TRUE(load_result->registrations.find(kAppName) != | 273 ASSERT_TRUE(load_result->registrations.find(kAppName) != |
274 load_result->registrations.end()); | 274 load_result->registrations.end()); |
275 EXPECT_EQ(registration, load_result->registrations[kAppName]); | 275 EXPECT_EQ(registration, load_result->registrations[kAppName]); |
276 ASSERT_TRUE(load_result->registrations.find(kAppName2) != | 276 ASSERT_TRUE(load_result->registrations.find(kAppName2) != |
277 load_result->registrations.end()); | 277 load_result->registrations.end()); |
278 EXPECT_EQ(registration2, load_result->registrations[kAppName2]); | 278 EXPECT_EQ(registration2, load_result->registrations[kAppName2]); |
279 | 279 |
280 gcm_store->RemoveRegistration( | 280 gcm_store->RemoveRegistration( |
281 kAppName2, | 281 kAppName2, |
282 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 282 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
283 PumpLoop(); | 283 PumpLoop(); |
284 | 284 |
285 gcm_store = BuildGCMStore().Pass(); | 285 gcm_store = BuildGCMStore(); |
286 LoadGCMStore(gcm_store.get(), &load_result); | 286 LoadGCMStore(gcm_store.get(), &load_result); |
287 | 287 |
288 ASSERT_EQ(1u, load_result->registrations.size()); | 288 ASSERT_EQ(1u, load_result->registrations.size()); |
289 ASSERT_TRUE(load_result->registrations.find(kAppName) != | 289 ASSERT_TRUE(load_result->registrations.find(kAppName) != |
290 load_result->registrations.end()); | 290 load_result->registrations.end()); |
291 EXPECT_EQ(registration, load_result->registrations[kAppName]); | 291 EXPECT_EQ(registration, load_result->registrations[kAppName]); |
292 } | 292 } |
293 | 293 |
294 // Verify saving some incoming messages, reopening the directory, and then | 294 // Verify saving some incoming messages, reopening the directory, and then |
295 // removing those incoming messages. | 295 // removing those incoming messages. |
296 TEST_F(GCMStoreImplTest, IncomingMessages) { | 296 TEST_F(GCMStoreImplTest, IncomingMessages) { |
297 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 297 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
298 scoped_ptr<GCMStore::LoadResult> load_result; | 298 scoped_ptr<GCMStore::LoadResult> load_result; |
299 LoadGCMStore(gcm_store.get(), &load_result); | 299 LoadGCMStore(gcm_store.get(), &load_result); |
300 | 300 |
301 std::vector<std::string> persistent_ids; | 301 std::vector<std::string> persistent_ids; |
302 for (int i = 0; i < kNumPersistentIds; ++i) { | 302 for (int i = 0; i < kNumPersistentIds; ++i) { |
303 persistent_ids.push_back(GetNextPersistentId()); | 303 persistent_ids.push_back(GetNextPersistentId()); |
304 gcm_store->AddIncomingMessage( | 304 gcm_store->AddIncomingMessage( |
305 persistent_ids.back(), | 305 persistent_ids.back(), |
306 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 306 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
307 PumpLoop(); | 307 PumpLoop(); |
308 } | 308 } |
309 | 309 |
310 gcm_store = BuildGCMStore().Pass(); | 310 gcm_store = BuildGCMStore(); |
311 LoadGCMStore(gcm_store.get(), &load_result); | 311 LoadGCMStore(gcm_store.get(), &load_result); |
312 | 312 |
313 ASSERT_EQ(persistent_ids, load_result->incoming_messages); | 313 ASSERT_EQ(persistent_ids, load_result->incoming_messages); |
314 ASSERT_TRUE(load_result->outgoing_messages.empty()); | 314 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
315 | 315 |
316 gcm_store->RemoveIncomingMessages( | 316 gcm_store->RemoveIncomingMessages( |
317 persistent_ids, | 317 persistent_ids, |
318 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 318 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
319 PumpLoop(); | 319 PumpLoop(); |
320 | 320 |
321 gcm_store = BuildGCMStore().Pass(); | 321 gcm_store = BuildGCMStore(); |
322 load_result->incoming_messages.clear(); | 322 load_result->incoming_messages.clear(); |
323 LoadGCMStore(gcm_store.get(), &load_result); | 323 LoadGCMStore(gcm_store.get(), &load_result); |
324 | 324 |
325 ASSERT_TRUE(load_result->incoming_messages.empty()); | 325 ASSERT_TRUE(load_result->incoming_messages.empty()); |
326 ASSERT_TRUE(load_result->outgoing_messages.empty()); | 326 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
327 } | 327 } |
328 | 328 |
329 // Verify saving some outgoing messages, reopening the directory, and then | 329 // Verify saving some outgoing messages, reopening the directory, and then |
330 // removing those outgoing messages. | 330 // removing those outgoing messages. |
331 TEST_F(GCMStoreImplTest, OutgoingMessages) { | 331 TEST_F(GCMStoreImplTest, OutgoingMessages) { |
332 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 332 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
333 scoped_ptr<GCMStore::LoadResult> load_result; | 333 scoped_ptr<GCMStore::LoadResult> load_result; |
334 LoadGCMStore(gcm_store.get(), &load_result); | 334 LoadGCMStore(gcm_store.get(), &load_result); |
335 | 335 |
336 std::vector<std::string> persistent_ids; | 336 std::vector<std::string> persistent_ids; |
337 const int kNumPersistentIds = 10; | 337 const int kNumPersistentIds = 10; |
338 for (int i = 0; i < kNumPersistentIds; ++i) { | 338 for (int i = 0; i < kNumPersistentIds; ++i) { |
339 persistent_ids.push_back(GetNextPersistentId()); | 339 persistent_ids.push_back(GetNextPersistentId()); |
340 mcs_proto::DataMessageStanza message; | 340 mcs_proto::DataMessageStanza message; |
341 message.set_from(kAppName + persistent_ids.back()); | 341 message.set_from(kAppName + persistent_ids.back()); |
342 message.set_category(kCategoryName + persistent_ids.back()); | 342 message.set_category(kCategoryName + persistent_ids.back()); |
343 gcm_store->AddOutgoingMessage( | 343 gcm_store->AddOutgoingMessage( |
344 persistent_ids.back(), | 344 persistent_ids.back(), |
345 MCSMessage(message), | 345 MCSMessage(message), |
346 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 346 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
347 PumpLoop(); | 347 PumpLoop(); |
348 } | 348 } |
349 | 349 |
350 gcm_store = BuildGCMStore().Pass(); | 350 gcm_store = BuildGCMStore(); |
351 LoadGCMStore(gcm_store.get(), &load_result); | 351 LoadGCMStore(gcm_store.get(), &load_result); |
352 | 352 |
353 ASSERT_TRUE(load_result->incoming_messages.empty()); | 353 ASSERT_TRUE(load_result->incoming_messages.empty()); |
354 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); | 354 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); |
355 for (int i = 0; i < kNumPersistentIds; ++i) { | 355 for (int i = 0; i < kNumPersistentIds; ++i) { |
356 std::string id = persistent_ids[i]; | 356 std::string id = persistent_ids[i]; |
357 ASSERT_TRUE(load_result->outgoing_messages[id].get()); | 357 ASSERT_TRUE(load_result->outgoing_messages[id].get()); |
358 const mcs_proto::DataMessageStanza* message = | 358 const mcs_proto::DataMessageStanza* message = |
359 reinterpret_cast<mcs_proto::DataMessageStanza*>( | 359 reinterpret_cast<mcs_proto::DataMessageStanza*>( |
360 load_result->outgoing_messages[id].get()); | 360 load_result->outgoing_messages[id].get()); |
361 ASSERT_EQ(message->from(), kAppName + id); | 361 ASSERT_EQ(message->from(), kAppName + id); |
362 ASSERT_EQ(message->category(), kCategoryName + id); | 362 ASSERT_EQ(message->category(), kCategoryName + id); |
363 } | 363 } |
364 | 364 |
365 gcm_store->RemoveOutgoingMessages( | 365 gcm_store->RemoveOutgoingMessages( |
366 persistent_ids, | 366 persistent_ids, |
367 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 367 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
368 PumpLoop(); | 368 PumpLoop(); |
369 | 369 |
370 gcm_store = BuildGCMStore().Pass(); | 370 gcm_store = BuildGCMStore(); |
371 load_result->outgoing_messages.clear(); | 371 load_result->outgoing_messages.clear(); |
372 LoadGCMStore(gcm_store.get(), &load_result); | 372 LoadGCMStore(gcm_store.get(), &load_result); |
373 | 373 |
374 ASSERT_TRUE(load_result->incoming_messages.empty()); | 374 ASSERT_TRUE(load_result->incoming_messages.empty()); |
375 ASSERT_TRUE(load_result->outgoing_messages.empty()); | 375 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
376 } | 376 } |
377 | 377 |
378 // Verify incoming and outgoing messages don't conflict. | 378 // Verify incoming and outgoing messages don't conflict. |
379 TEST_F(GCMStoreImplTest, IncomingAndOutgoingMessages) { | 379 TEST_F(GCMStoreImplTest, IncomingAndOutgoingMessages) { |
380 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 380 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
(...skipping 12 matching lines...) Expand all Loading... |
393 mcs_proto::DataMessageStanza message; | 393 mcs_proto::DataMessageStanza message; |
394 message.set_from(kAppName + persistent_ids.back()); | 394 message.set_from(kAppName + persistent_ids.back()); |
395 message.set_category(kCategoryName + persistent_ids.back()); | 395 message.set_category(kCategoryName + persistent_ids.back()); |
396 gcm_store->AddOutgoingMessage( | 396 gcm_store->AddOutgoingMessage( |
397 persistent_ids.back(), | 397 persistent_ids.back(), |
398 MCSMessage(message), | 398 MCSMessage(message), |
399 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 399 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
400 PumpLoop(); | 400 PumpLoop(); |
401 } | 401 } |
402 | 402 |
403 gcm_store = BuildGCMStore().Pass(); | 403 gcm_store = BuildGCMStore(); |
404 LoadGCMStore(gcm_store.get(), &load_result); | 404 LoadGCMStore(gcm_store.get(), &load_result); |
405 | 405 |
406 ASSERT_EQ(persistent_ids, load_result->incoming_messages); | 406 ASSERT_EQ(persistent_ids, load_result->incoming_messages); |
407 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); | 407 ASSERT_EQ(load_result->outgoing_messages.size(), persistent_ids.size()); |
408 for (int i = 0; i < kNumPersistentIds; ++i) { | 408 for (int i = 0; i < kNumPersistentIds; ++i) { |
409 std::string id = persistent_ids[i]; | 409 std::string id = persistent_ids[i]; |
410 ASSERT_TRUE(load_result->outgoing_messages[id].get()); | 410 ASSERT_TRUE(load_result->outgoing_messages[id].get()); |
411 const mcs_proto::DataMessageStanza* message = | 411 const mcs_proto::DataMessageStanza* message = |
412 reinterpret_cast<mcs_proto::DataMessageStanza*>( | 412 reinterpret_cast<mcs_proto::DataMessageStanza*>( |
413 load_result->outgoing_messages[id].get()); | 413 load_result->outgoing_messages[id].get()); |
414 ASSERT_EQ(message->from(), kAppName + id); | 414 ASSERT_EQ(message->from(), kAppName + id); |
415 ASSERT_EQ(message->category(), kCategoryName + id); | 415 ASSERT_EQ(message->category(), kCategoryName + id); |
416 } | 416 } |
417 | 417 |
418 gcm_store->RemoveIncomingMessages( | 418 gcm_store->RemoveIncomingMessages( |
419 persistent_ids, | 419 persistent_ids, |
420 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 420 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
421 PumpLoop(); | 421 PumpLoop(); |
422 gcm_store->RemoveOutgoingMessages( | 422 gcm_store->RemoveOutgoingMessages( |
423 persistent_ids, | 423 persistent_ids, |
424 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 424 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
425 PumpLoop(); | 425 PumpLoop(); |
426 | 426 |
427 gcm_store = BuildGCMStore().Pass(); | 427 gcm_store = BuildGCMStore(); |
428 load_result->incoming_messages.clear(); | 428 load_result->incoming_messages.clear(); |
429 load_result->outgoing_messages.clear(); | 429 load_result->outgoing_messages.clear(); |
430 LoadGCMStore(gcm_store.get(), &load_result); | 430 LoadGCMStore(gcm_store.get(), &load_result); |
431 | 431 |
432 ASSERT_TRUE(load_result->incoming_messages.empty()); | 432 ASSERT_TRUE(load_result->incoming_messages.empty()); |
433 ASSERT_TRUE(load_result->outgoing_messages.empty()); | 433 ASSERT_TRUE(load_result->outgoing_messages.empty()); |
434 } | 434 } |
435 | 435 |
436 // Test that per-app message limits are enforced, persisted across restarts, | 436 // Test that per-app message limits are enforced, persisted across restarts, |
437 // and updated as messages are removed. | 437 // and updated as messages are removed. |
(...skipping 22 matching lines...) Expand all Loading... |
460 message.set_category(kCategoryName); | 460 message.set_category(kCategoryName); |
461 EXPECT_FALSE(gcm_store->AddOutgoingMessage( | 461 EXPECT_FALSE(gcm_store->AddOutgoingMessage( |
462 base::IntToString(i + kNumMessagesPerApp), | 462 base::IntToString(i + kNumMessagesPerApp), |
463 MCSMessage(message), | 463 MCSMessage(message), |
464 base::Bind(&GCMStoreImplTest::UpdateCallback, | 464 base::Bind(&GCMStoreImplTest::UpdateCallback, |
465 base::Unretained(this)))); | 465 base::Unretained(this)))); |
466 PumpLoop(); | 466 PumpLoop(); |
467 } | 467 } |
468 | 468 |
469 // Tear down and restore the database. | 469 // Tear down and restore the database. |
470 gcm_store = BuildGCMStore().Pass(); | 470 gcm_store = BuildGCMStore(); |
471 LoadGCMStore(gcm_store.get(), &load_result); | 471 LoadGCMStore(gcm_store.get(), &load_result); |
472 | 472 |
473 // Adding more messages should still fail. | 473 // Adding more messages should still fail. |
474 for (int i = 0; i < kNumMessagesPerApp; ++i) { | 474 for (int i = 0; i < kNumMessagesPerApp; ++i) { |
475 mcs_proto::DataMessageStanza message; | 475 mcs_proto::DataMessageStanza message; |
476 message.set_from(kAppName); | 476 message.set_from(kAppName); |
477 message.set_category(kCategoryName); | 477 message.set_category(kCategoryName); |
478 EXPECT_FALSE(gcm_store->AddOutgoingMessage( | 478 EXPECT_FALSE(gcm_store->AddOutgoingMessage( |
479 base::IntToString(i + kNumMessagesPerApp), | 479 base::IntToString(i + kNumMessagesPerApp), |
480 MCSMessage(message), | 480 MCSMessage(message), |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
531 | 531 |
532 gcm_store->AddAccountMapping( | 532 gcm_store->AddAccountMapping( |
533 account_mapping1, | 533 account_mapping1, |
534 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 534 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
535 PumpLoop(); | 535 PumpLoop(); |
536 gcm_store->AddAccountMapping( | 536 gcm_store->AddAccountMapping( |
537 account_mapping2, | 537 account_mapping2, |
538 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 538 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
539 PumpLoop(); | 539 PumpLoop(); |
540 | 540 |
541 gcm_store = BuildGCMStore().Pass(); | 541 gcm_store = BuildGCMStore(); |
542 LoadGCMStore(gcm_store.get(), &load_result); | 542 LoadGCMStore(gcm_store.get(), &load_result); |
543 | 543 |
544 EXPECT_EQ(2UL, load_result->account_mappings.size()); | 544 EXPECT_EQ(2UL, load_result->account_mappings.size()); |
545 GCMStore::AccountMappings::iterator iter = | 545 GCMStore::AccountMappings::iterator iter = |
546 load_result->account_mappings.begin(); | 546 load_result->account_mappings.begin(); |
547 EXPECT_EQ(account_mapping1.account_id, iter->account_id); | 547 EXPECT_EQ(account_mapping1.account_id, iter->account_id); |
548 EXPECT_EQ(account_mapping1.email, iter->email); | 548 EXPECT_EQ(account_mapping1.email, iter->email); |
549 EXPECT_TRUE(iter->access_token.empty()); | 549 EXPECT_TRUE(iter->access_token.empty()); |
550 EXPECT_EQ(AccountMapping::ADDING, iter->status); | 550 EXPECT_EQ(AccountMapping::ADDING, iter->status); |
551 EXPECT_EQ(account_mapping1.status_change_timestamp, | 551 EXPECT_EQ(account_mapping1.status_change_timestamp, |
552 iter->status_change_timestamp); | 552 iter->status_change_timestamp); |
553 EXPECT_EQ(account_mapping1.last_message_id, iter->last_message_id); | 553 EXPECT_EQ(account_mapping1.last_message_id, iter->last_message_id); |
554 ++iter; | 554 ++iter; |
555 EXPECT_EQ(account_mapping2.account_id, iter->account_id); | 555 EXPECT_EQ(account_mapping2.account_id, iter->account_id); |
556 EXPECT_EQ(account_mapping2.email, iter->email); | 556 EXPECT_EQ(account_mapping2.email, iter->email); |
557 EXPECT_TRUE(iter->access_token.empty()); | 557 EXPECT_TRUE(iter->access_token.empty()); |
558 EXPECT_EQ(AccountMapping::REMOVING, iter->status); | 558 EXPECT_EQ(AccountMapping::REMOVING, iter->status); |
559 EXPECT_EQ(account_mapping2.status_change_timestamp, | 559 EXPECT_EQ(account_mapping2.status_change_timestamp, |
560 iter->status_change_timestamp); | 560 iter->status_change_timestamp); |
561 EXPECT_EQ(account_mapping2.last_message_id, iter->last_message_id); | 561 EXPECT_EQ(account_mapping2.last_message_id, iter->last_message_id); |
562 | 562 |
563 gcm_store->RemoveAccountMapping( | 563 gcm_store->RemoveAccountMapping( |
564 account_mapping1.account_id, | 564 account_mapping1.account_id, |
565 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 565 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
566 PumpLoop(); | 566 PumpLoop(); |
567 | 567 |
568 gcm_store = BuildGCMStore().Pass(); | 568 gcm_store = BuildGCMStore(); |
569 LoadGCMStore(gcm_store.get(), &load_result); | 569 LoadGCMStore(gcm_store.get(), &load_result); |
570 | 570 |
571 EXPECT_EQ(1UL, load_result->account_mappings.size()); | 571 EXPECT_EQ(1UL, load_result->account_mappings.size()); |
572 iter = load_result->account_mappings.begin(); | 572 iter = load_result->account_mappings.begin(); |
573 EXPECT_EQ(account_mapping2.account_id, iter->account_id); | 573 EXPECT_EQ(account_mapping2.account_id, iter->account_id); |
574 EXPECT_EQ(account_mapping2.email, iter->email); | 574 EXPECT_EQ(account_mapping2.email, iter->email); |
575 EXPECT_TRUE(iter->access_token.empty()); | 575 EXPECT_TRUE(iter->access_token.empty()); |
576 EXPECT_EQ(AccountMapping::REMOVING, iter->status); | 576 EXPECT_EQ(AccountMapping::REMOVING, iter->status); |
577 EXPECT_EQ(account_mapping2.status_change_timestamp, | 577 EXPECT_EQ(account_mapping2.status_change_timestamp, |
578 iter->status_change_timestamp); | 578 iter->status_change_timestamp); |
(...skipping 14 matching lines...) Expand all Loading... |
593 scope1, | 593 scope1, |
594 heartbeat1, | 594 heartbeat1, |
595 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 595 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
596 PumpLoop(); | 596 PumpLoop(); |
597 gcm_store->AddHeartbeatInterval( | 597 gcm_store->AddHeartbeatInterval( |
598 scope2, | 598 scope2, |
599 heartbeat2, | 599 heartbeat2, |
600 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 600 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
601 PumpLoop(); | 601 PumpLoop(); |
602 | 602 |
603 gcm_store = BuildGCMStore().Pass(); | 603 gcm_store = BuildGCMStore(); |
604 LoadGCMStore(gcm_store.get(), &load_result); | 604 LoadGCMStore(gcm_store.get(), &load_result); |
605 | 605 |
606 EXPECT_EQ(2UL, load_result->heartbeat_intervals.size()); | 606 EXPECT_EQ(2UL, load_result->heartbeat_intervals.size()); |
607 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope1) != | 607 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope1) != |
608 load_result->heartbeat_intervals.end()); | 608 load_result->heartbeat_intervals.end()); |
609 EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]); | 609 EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]); |
610 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope2) != | 610 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope2) != |
611 load_result->heartbeat_intervals.end()); | 611 load_result->heartbeat_intervals.end()); |
612 EXPECT_EQ(heartbeat2, load_result->heartbeat_intervals[scope2]); | 612 EXPECT_EQ(heartbeat2, load_result->heartbeat_intervals[scope2]); |
613 | 613 |
614 gcm_store->RemoveHeartbeatInterval( | 614 gcm_store->RemoveHeartbeatInterval( |
615 scope2, | 615 scope2, |
616 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 616 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
617 PumpLoop(); | 617 PumpLoop(); |
618 | 618 |
619 gcm_store = BuildGCMStore().Pass(); | 619 gcm_store = BuildGCMStore(); |
620 LoadGCMStore(gcm_store.get(), &load_result); | 620 LoadGCMStore(gcm_store.get(), &load_result); |
621 | 621 |
622 EXPECT_EQ(1UL, load_result->heartbeat_intervals.size()); | 622 EXPECT_EQ(1UL, load_result->heartbeat_intervals.size()); |
623 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope1) != | 623 ASSERT_TRUE(load_result->heartbeat_intervals.find(scope1) != |
624 load_result->heartbeat_intervals.end()); | 624 load_result->heartbeat_intervals.end()); |
625 EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]); | 625 EXPECT_EQ(heartbeat1, load_result->heartbeat_intervals[scope1]); |
626 } | 626 } |
627 | 627 |
628 // When the database is destroyed, all database updates should fail. At the | 628 // When the database is destroyed, all database updates should fail. At the |
629 // same time, they per-app message counts should not go up, as failures should | 629 // same time, they per-app message counts should not go up, as failures should |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
667 scoped_ptr<GCMStore::LoadResult> load_result; | 667 scoped_ptr<GCMStore::LoadResult> load_result; |
668 LoadGCMStore(gcm_store.get(), &load_result); | 668 LoadGCMStore(gcm_store.get(), &load_result); |
669 EXPECT_EQ(base::Time(), load_result->last_token_fetch_time); | 669 EXPECT_EQ(base::Time(), load_result->last_token_fetch_time); |
670 | 670 |
671 base::Time last_token_fetch_time = base::Time::Now(); | 671 base::Time last_token_fetch_time = base::Time::Now(); |
672 gcm_store->SetLastTokenFetchTime( | 672 gcm_store->SetLastTokenFetchTime( |
673 last_token_fetch_time, | 673 last_token_fetch_time, |
674 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 674 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
675 PumpLoop(); | 675 PumpLoop(); |
676 | 676 |
677 gcm_store = BuildGCMStore().Pass(); | 677 gcm_store = BuildGCMStore(); |
678 LoadGCMStore(gcm_store.get(), &load_result); | 678 LoadGCMStore(gcm_store.get(), &load_result); |
679 EXPECT_EQ(last_token_fetch_time, load_result->last_token_fetch_time); | 679 EXPECT_EQ(last_token_fetch_time, load_result->last_token_fetch_time); |
680 | 680 |
681 // Negative cases, where the value read is gibberish. | 681 // Negative cases, where the value read is gibberish. |
682 gcm_store->SetValueForTesting( | 682 gcm_store->SetValueForTesting( |
683 "last_token_fetch_time", | 683 "last_token_fetch_time", |
684 "gibberish", | 684 "gibberish", |
685 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 685 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
686 PumpLoop(); | 686 PumpLoop(); |
687 | 687 |
688 gcm_store = BuildGCMStore().Pass(); | 688 gcm_store = BuildGCMStore(); |
689 LoadGCMStore(gcm_store.get(), &load_result); | 689 LoadGCMStore(gcm_store.get(), &load_result); |
690 EXPECT_EQ(base::Time(), load_result->last_token_fetch_time); | 690 EXPECT_EQ(base::Time(), load_result->last_token_fetch_time); |
691 } | 691 } |
692 | 692 |
693 TEST_F(GCMStoreImplTest, InstanceIDData) { | 693 TEST_F(GCMStoreImplTest, InstanceIDData) { |
694 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); | 694 scoped_ptr<GCMStoreImpl> gcm_store(BuildGCMStore()); |
695 scoped_ptr<GCMStore::LoadResult> load_result; | 695 scoped_ptr<GCMStore::LoadResult> load_result; |
696 LoadGCMStore(gcm_store.get(), &load_result); | 696 LoadGCMStore(gcm_store.get(), &load_result); |
697 | 697 |
698 std::string instance_id_data("Foo"); | 698 std::string instance_id_data("Foo"); |
699 gcm_store->AddInstanceIDData( | 699 gcm_store->AddInstanceIDData( |
700 kAppName, | 700 kAppName, |
701 instance_id_data, | 701 instance_id_data, |
702 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 702 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
703 PumpLoop(); | 703 PumpLoop(); |
704 | 704 |
705 std::string instance_id_data2("Hello Instance ID"); | 705 std::string instance_id_data2("Hello Instance ID"); |
706 gcm_store->AddInstanceIDData( | 706 gcm_store->AddInstanceIDData( |
707 kAppName2, | 707 kAppName2, |
708 instance_id_data2, | 708 instance_id_data2, |
709 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 709 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
710 PumpLoop(); | 710 PumpLoop(); |
711 | 711 |
712 gcm_store = BuildGCMStore().Pass(); | 712 gcm_store = BuildGCMStore(); |
713 LoadGCMStore(gcm_store.get(), &load_result); | 713 LoadGCMStore(gcm_store.get(), &load_result); |
714 | 714 |
715 ASSERT_EQ(2u, load_result->instance_id_data.size()); | 715 ASSERT_EQ(2u, load_result->instance_id_data.size()); |
716 ASSERT_TRUE(load_result->instance_id_data.find(kAppName) != | 716 ASSERT_TRUE(load_result->instance_id_data.find(kAppName) != |
717 load_result->instance_id_data.end()); | 717 load_result->instance_id_data.end()); |
718 ASSERT_TRUE(load_result->instance_id_data.find(kAppName2) != | 718 ASSERT_TRUE(load_result->instance_id_data.find(kAppName2) != |
719 load_result->instance_id_data.end()); | 719 load_result->instance_id_data.end()); |
720 EXPECT_EQ(instance_id_data, load_result->instance_id_data[kAppName]); | 720 EXPECT_EQ(instance_id_data, load_result->instance_id_data[kAppName]); |
721 EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]); | 721 EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]); |
722 | 722 |
723 gcm_store->RemoveInstanceIDData( | 723 gcm_store->RemoveInstanceIDData( |
724 kAppName, | 724 kAppName, |
725 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); | 725 base::Bind(&GCMStoreImplTest::UpdateCallback, base::Unretained(this))); |
726 PumpLoop(); | 726 PumpLoop(); |
727 | 727 |
728 gcm_store = BuildGCMStore().Pass(); | 728 gcm_store = BuildGCMStore(); |
729 LoadGCMStore(gcm_store.get(), &load_result); | 729 LoadGCMStore(gcm_store.get(), &load_result); |
730 | 730 |
731 ASSERT_EQ(1u, load_result->instance_id_data.size()); | 731 ASSERT_EQ(1u, load_result->instance_id_data.size()); |
732 ASSERT_TRUE(load_result->instance_id_data.find(kAppName2) != | 732 ASSERT_TRUE(load_result->instance_id_data.find(kAppName2) != |
733 load_result->instance_id_data.end()); | 733 load_result->instance_id_data.end()); |
734 EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]); | 734 EXPECT_EQ(instance_id_data2, load_result->instance_id_data[kAppName2]); |
735 } | 735 } |
736 | 736 |
737 } // namespace | 737 } // namespace |
738 | 738 |
739 } // namespace gcm | 739 } // namespace gcm |
OLD | NEW |