gcm_stats_recorder_impl_unittest.cc revision 5f1c94371a64b3196d4be9466099bb892df9b88e 
1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "components/gcm_driver/gcm_stats_recorder_impl.h"
6
7#include <deque>
8#include <string>
9#include <vector>
10
11#include "google_apis/gcm/engine/mcs_client.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace gcm {
15
16namespace {
17
18static uint64 kAndroidId = 4U;
19static const char kCheckinStatus[] = "URL_FETCHING_FAILED";
20static const char kHost[] = "www.example.com";
21static const char kAppId[] = "app id 1";
22static const char kFrom[] = "from";
23static const char kSenderIds[] = "s1,s2";
24static const char kReceiverId[] = "receiver 1";
25static const char kMessageId[] = "message id 1";
26static const int kQueuedSec = 5;
27static const gcm::MCSClient::MessageSendStatus kMessageSendStatus =
28    gcm::MCSClient::QUEUED;
29static const int kByteSize = 99;
30static const int kTTL = 7;
31static const int kRetries = 3;
32static const int64 kDelay = 15000;
33static const ConnectionFactory::ConnectionResetReason kReason =
34    ConnectionFactory::NETWORK_CHANGE;
35static const int kNetworkError = 1;
36
37static const RegistrationRequest::Status kRegistrationStatus =
38    RegistrationRequest::SUCCESS;
39static const UnregistrationRequest::Status kUnregistrationStatus =
40    UnregistrationRequest::SUCCESS;
41
42static const char kCheckinInitiatedEvent[] = "Checkin initiated";
43static const char kCheckinInitiatedDetails[] = "Android Id: 4";
44static const char kCheckinDelayedDueToBackoffEvent[] = "Checkin backoff";
45static const char kCheckinDelayedDueToBackoffDetails[] =
46    "Delayed for 15000 msec";
47static const char kCheckinSuccessEvent[] = "Checkin succeeded";
48static const char kCheckinSuccessDetails[] = "";
49static const char kCheckinFailureEvent[] = "Checkin failed";
50static const char kCheckinFailureDetails[] = "URL_FETCHING_FAILED. Will retry.";
51
52static const char kConnectionInitiatedEvent[] = "Connection initiated";
53static const char kConnectionInitiatedDetails[] = "www.example.com";
54static const char kConnectionDelayedDueToBackoffEvent[] = "Connection backoff";
55static const char kConnectionDelayedDueToBackoffDetails[] =
56    "Delayed for 15000 msec";
57static const char kConnectionSuccessEvent[] = "Connection succeeded";
58static const char kConnectionSuccessDetails[] = "";
59static const char kConnectionFailureEvent[] = "Connection failed";
60static const char kConnectionFailureDetails[] = "With network error 1";
61static const char kConnectionResetSignaledEvent[] = "Connection reset";
62static const char kConnectionResetSignaledDetails[] = "NETWORK_CHANGE";
63
64static const char kRegistrationSentEvent[] = "Registration request sent";
65static const char kRegistrationSentDetails[] = "";
66static const char kRegistrationResponseEvent[] =
67    "Registration response received";
68static const char kRegistrationResponseDetails[] = "SUCCESS";
69static const char kRegistrationRetryRequestedEvent[] =
70    "Registration retry requested";
71static const char kRegistrationRetryRequestedDetails[] = "Retries left: 3";
72static const char kUnregistrationSentEvent[] = "Unregistration request sent";
73static const char kUnregistrationSentDetails[] = "";
74static const char kUnregistrationResponseEvent[] =
75    "Unregistration response received";
76static const char kUnregistrationResponseDetails[] = "SUCCESS";
77static const char kUnregistrationRetryDelayedEvent[] =
78    "Unregistration retry delayed";
79static const char kUnregistrationRetryDelayedDetails[] =
80    "Delayed for 15000 msec";
81
82static const char kDataReceivedEvent[] = "Data msg received";
83static const char kDataReceivedDetails[] = "";
84static const char kDataReceivedNotRegisteredEvent[] = "Data msg received";
85static const char kDataReceivedNotRegisteredDetails[] =
86    "No such registered app found";
87static const char kDataDeletedMessageEvent[] = "Data msg received";
88static const char kDataDeletedMessageDetails[] =
89    "Message has been deleted on server";
90
91static const char kDataSentToWireEvent[] = "Data msg sent to wire";
92static const char kSentToWireDetails[] = "Msg queued for 5 seconds";
93static const char kNotifySendStatusEvent[] = "SEND status: QUEUED";
94static const char kNotifySendStatusDetails[] = "Msg size: 99 bytes, TTL: 7";
95static const char kIncomingSendErrorEvent[] = "Received 'send error' msg";
96static const char kIncomingSendErrorDetails[] = "";
97
98}  // namespace
99
100class GCMStatsRecorderImplTest : public testing::Test {
101 public:
102  GCMStatsRecorderImplTest();
103  virtual ~GCMStatsRecorderImplTest();
104  virtual void SetUp() OVERRIDE;
105
106  void VerifyRecordedCheckinCount(int expected_count) {
107    EXPECT_EQ(expected_count,
108              static_cast<int>(recorder_.checkin_activities().size()));
109  }
110  void VerifyRecordedConnectionCount(int expected_count) {
111    EXPECT_EQ(expected_count,
112              static_cast<int>(recorder_.connection_activities().size()));
113  }
114  void VerifyRecordedRegistrationCount(int expected_count) {
115    EXPECT_EQ(expected_count,
116              static_cast<int>(recorder_.registration_activities().size()));
117  }
118  void VerifyRecordedReceivingCount(int expected_count) {
119    EXPECT_EQ(expected_count,
120              static_cast<int>(recorder_.receiving_activities().size()));
121  }
122  void VerifyRecordedSendingCount(int expected_count) {
123    EXPECT_EQ(expected_count,
124              static_cast<int>(recorder_.sending_activities().size()));
125  }
126  void VerifyAllActivityQueueEmpty(const std::string& remark) {
127    EXPECT_TRUE(recorder_.checkin_activities().empty()) << remark;
128    EXPECT_TRUE(recorder_.connection_activities().empty()) << remark;
129    EXPECT_TRUE(recorder_.registration_activities().empty()) << remark;
130    EXPECT_TRUE(recorder_.receiving_activities().empty()) << remark;
131    EXPECT_TRUE(recorder_.sending_activities().empty()) << remark;
132  }
133
134  void VerifyCheckinInitiated(const std::string& remark) {
135    VerifyCheckin(recorder_.checkin_activities(),
136                  kCheckinInitiatedEvent,
137                  kCheckinInitiatedDetails,
138                  remark);
139  }
140
141  void VerifyCheckinDelayedDueToBackoff(const std::string& remark) {
142    VerifyCheckin(recorder_.checkin_activities(),
143                  kCheckinDelayedDueToBackoffEvent,
144                  kCheckinDelayedDueToBackoffDetails,
145                  remark);
146  }
147
148  void VerifyCheckinSuccess(const std::string& remark) {
149    VerifyCheckin(recorder_.checkin_activities(),
150                  kCheckinSuccessEvent,
151                  kCheckinSuccessDetails,
152                  remark);
153  }
154
155  void VerifyCheckinFailure(const std::string& remark) {
156    VerifyCheckin(recorder_.checkin_activities(),
157                  kCheckinFailureEvent,
158                  kCheckinFailureDetails,
159                  remark);
160  }
161
162  void VerifyConnectionInitiated(const std::string& remark) {
163    VerifyConnection(recorder_.connection_activities(),
164                     kConnectionInitiatedEvent,
165                     kConnectionInitiatedDetails,
166                     remark);
167  }
168
169  void VerifyConnectionDelayedDueToBackoff(const std::string& remark) {
170    VerifyConnection(recorder_.connection_activities(),
171                     kConnectionDelayedDueToBackoffEvent,
172                     kConnectionDelayedDueToBackoffDetails,
173                     remark);
174  }
175
176  void VerifyConnectionSuccess(const std::string& remark) {
177    VerifyConnection(recorder_.connection_activities(),
178                     kConnectionSuccessEvent,
179                     kConnectionSuccessDetails,
180                     remark);
181  }
182
183  void VerifyConnectionFailure(const std::string& remark) {
184    VerifyConnection(recorder_.connection_activities(),
185                     kConnectionFailureEvent,
186                     kConnectionFailureDetails,
187                     remark);
188  }
189
190  void VerifyConnectionResetSignaled(const std::string& remark) {
191    VerifyConnection(recorder_.connection_activities(),
192                     kConnectionResetSignaledEvent,
193                     kConnectionResetSignaledDetails,
194                     remark);
195  }
196
197  void VerifyRegistrationSent(const std::string& remark) {
198    VerifyRegistration(recorder_.registration_activities(),
199                       kSenderIds,
200                       kRegistrationSentEvent,
201                       kRegistrationSentDetails,
202                       remark);
203  }
204
205  void VerifyRegistrationResponse(const std::string& remark) {
206    VerifyRegistration(recorder_.registration_activities(),
207                       kSenderIds,
208                       kRegistrationResponseEvent,
209                       kRegistrationResponseDetails,
210                       remark);
211  }
212
213  void VerifyRegistrationRetryRequested(const std::string& remark) {
214    VerifyRegistration(recorder_.registration_activities(),
215                       kSenderIds,
216                       kRegistrationRetryRequestedEvent,
217                       kRegistrationRetryRequestedDetails,
218                       remark);
219  }
220
221  void VerifyUnregistrationSent(const std::string& remark) {
222    VerifyRegistration(recorder_.registration_activities(),
223                       std::string(),
224                       kUnregistrationSentEvent,
225                       kUnregistrationSentDetails,
226                       remark);
227  }
228
229  void VerifyUnregistrationResponse(const std::string& remark) {
230    VerifyRegistration(recorder_.registration_activities(),
231                       std::string(),
232                       kUnregistrationResponseEvent,
233                       kUnregistrationResponseDetails,
234                       remark);
235  }
236
237  void VerifyUnregistrationRetryDelayed(const std::string& remark) {
238    VerifyRegistration(recorder_.registration_activities(),
239                       std::string(),
240                       kUnregistrationRetryDelayedEvent,
241                       kUnregistrationRetryDelayedDetails,
242                       remark);
243  }
244
245  void VerifyDataMessageReceived(const std::string& remark) {
246    VerifyReceivingData(recorder_.receiving_activities(),
247                        kDataReceivedEvent,
248                        kDataReceivedDetails,
249                        remark);
250  }
251
252  void VerifyDataDeletedMessage(const std::string& remark) {
253    VerifyReceivingData(recorder_.receiving_activities(),
254                        kDataDeletedMessageEvent,
255                        kDataDeletedMessageDetails,
256                        remark);
257  }
258
259  void VerifyDataMessageReceivedNotRegistered(const std::string& remark) {
260    VerifyReceivingData(recorder_.receiving_activities(),
261                        kDataReceivedNotRegisteredEvent,
262                        kDataReceivedNotRegisteredDetails,
263                        remark);
264  }
265
266  void VerifyDataSentToWire(const std::string& remark) {
267    VerifySendingData(recorder_.sending_activities(),
268                      kDataSentToWireEvent,
269                      kSentToWireDetails,
270                      remark);
271  }
272
273  void VerifyNotifySendStatus(const std::string& remark) {
274    VerifySendingData(recorder_.sending_activities(),
275                      kNotifySendStatusEvent,
276                      kNotifySendStatusDetails,
277                      remark);
278  }
279
280  void VerifyIncomingSendError(const std::string& remark) {
281    VerifySendingData(recorder_.sending_activities(),
282                      kIncomingSendErrorEvent,
283                      kIncomingSendErrorDetails,
284                      remark);
285  }
286
287 protected:
288  void VerifyCheckin(
289      const std::deque<CheckinActivity>& queue,
290      const std::string& event,
291      const std::string& details,
292      const std::string& remark) {
293    EXPECT_EQ(event, queue.front().event) << remark;
294    EXPECT_EQ(details, queue.front().details) << remark;
295  }
296
297  void VerifyConnection(
298      const std::deque<ConnectionActivity>& queue,
299      const std::string& event,
300      const std::string& details,
301      const std::string& remark) {
302    EXPECT_EQ(event, queue.front().event) << remark;
303    EXPECT_EQ(details, queue.front().details) << remark;
304  }
305
306  void VerifyRegistration(
307      const std::deque<RegistrationActivity>& queue,
308      const std::string& sender_ids,
309      const std::string& event,
310      const std::string& details,
311      const std::string& remark) {
312    EXPECT_EQ(kAppId, queue.front().app_id) << remark;
313    EXPECT_EQ(sender_ids, queue.front().sender_ids) << remark;
314    EXPECT_EQ(event, queue.front().event) << remark;
315    EXPECT_EQ(details, queue.front().details) << remark;
316  }
317
318  void VerifyReceivingData(
319      const std::deque<ReceivingActivity>& queue,
320      const std::string& event,
321      const std::string& details,
322      const std::string& remark) {
323    EXPECT_EQ(kAppId, queue.front().app_id) << remark;
324    EXPECT_EQ(kFrom, queue.front().from) << remark;
325    EXPECT_EQ(kByteSize, queue.front().message_byte_size) << remark;
326    EXPECT_EQ(event, queue.front().event) << remark;
327    EXPECT_EQ(details, queue.front().details) << remark;
328  }
329
330  void VerifySendingData(
331      const std::deque<SendingActivity>& queue,
332      const std::string& event, const std::string& details,
333      const std::string& remark) {
334    EXPECT_EQ(kAppId, queue.front().app_id) << remark;
335    EXPECT_EQ(kReceiverId, queue.front().receiver_id) << remark;
336    EXPECT_EQ(kMessageId, queue.front().message_id) << remark;
337    EXPECT_EQ(event, queue.front().event) << remark;
338    EXPECT_EQ(details, queue.front().details) << remark;
339  }
340
341  std::vector<std::string> sender_ids_;
342  GCMStatsRecorderImpl recorder_;
343};
344
345GCMStatsRecorderImplTest::GCMStatsRecorderImplTest(){
346}
347
348GCMStatsRecorderImplTest::~GCMStatsRecorderImplTest() {}
349
350void GCMStatsRecorderImplTest::SetUp(){
351  sender_ids_.push_back("s1");
352  sender_ids_.push_back("s2");
353  recorder_.SetRecording(true);
354}
355
356TEST_F(GCMStatsRecorderImplTest, StartStopRecordingTest) {
357  EXPECT_TRUE(recorder_.is_recording());
358  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
359  VerifyRecordedSendingCount(1);
360  VerifyDataSentToWire("1st call");
361
362  recorder_.SetRecording(false);
363  EXPECT_FALSE(recorder_.is_recording());
364  recorder_.Clear();
365  VerifyAllActivityQueueEmpty("all cleared");
366
367  // Exercise every recording method below and verify that nothing is recorded.
368  recorder_.RecordCheckinInitiated(kAndroidId);
369  recorder_.RecordCheckinDelayedDueToBackoff(kDelay);
370  recorder_.RecordCheckinSuccess();
371  recorder_.RecordCheckinFailure(kCheckinStatus, true);
372  VerifyAllActivityQueueEmpty("no checkin");
373
374  recorder_.RecordConnectionInitiated(kHost);
375  recorder_.RecordConnectionDelayedDueToBackoff(kDelay);
376  recorder_.RecordConnectionSuccess();
377  recorder_.RecordConnectionFailure(kNetworkError);
378  recorder_.RecordConnectionResetSignaled(kReason);
379  VerifyAllActivityQueueEmpty("no registration");
380
381  recorder_.RecordRegistrationSent(kAppId, kSenderIds);
382  recorder_.RecordRegistrationResponse(kAppId, sender_ids_,
383                                       kRegistrationStatus);
384  recorder_.RecordRegistrationRetryRequested(kAppId, sender_ids_, kRetries);
385  recorder_.RecordUnregistrationSent(kAppId);
386  recorder_.RecordUnregistrationResponse(kAppId, kUnregistrationStatus);
387  recorder_.RecordUnregistrationRetryDelayed(kAppId, kDelay);
388  VerifyAllActivityQueueEmpty("no unregistration");
389
390  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, true,
391                                      GCMStatsRecorder::DATA_MESSAGE);
392  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, true,
393                                      GCMStatsRecorder::DELETED_MESSAGES);
394  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, false,
395                                      GCMStatsRecorder::DATA_MESSAGE);
396  VerifyAllActivityQueueEmpty("no receiving");
397
398  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
399  recorder_.RecordNotifySendStatus(kAppId, kReceiverId, kMessageId,
400                                   kMessageSendStatus, kByteSize, kTTL);
401  recorder_.RecordIncomingSendError(kAppId, kReceiverId, kMessageId);
402  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
403  VerifyAllActivityQueueEmpty("no sending");
404}
405
406TEST_F(GCMStatsRecorderImplTest, ClearLogTest) {
407  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
408  VerifyRecordedSendingCount(1);
409  VerifyDataSentToWire("1st call");
410
411  recorder_.RecordNotifySendStatus(kAppId, kReceiverId, kMessageId,
412                                   kMessageSendStatus, kByteSize, kTTL);
413  VerifyRecordedSendingCount(2);
414  VerifyNotifySendStatus("2nd call");
415
416  recorder_.Clear();
417  VerifyRecordedSendingCount(0);
418}
419
420TEST_F(GCMStatsRecorderImplTest, CheckinTest) {
421  recorder_.RecordCheckinInitiated(kAndroidId);
422  VerifyRecordedCheckinCount(1);
423  VerifyCheckinInitiated("1st call");
424
425  recorder_.RecordCheckinDelayedDueToBackoff(kDelay);
426  VerifyRecordedCheckinCount(2);
427  VerifyCheckinDelayedDueToBackoff("2nd call");
428
429  recorder_.RecordCheckinSuccess();
430  VerifyRecordedCheckinCount(3);
431  VerifyCheckinSuccess("3rd call");
432
433  recorder_.RecordCheckinFailure(kCheckinStatus, true);
434  VerifyRecordedCheckinCount(4);
435  VerifyCheckinFailure("4th call");
436}
437
438TEST_F(GCMStatsRecorderImplTest, ConnectionTest) {
439  recorder_.RecordConnectionInitiated(kHost);
440  VerifyRecordedConnectionCount(1);
441  VerifyConnectionInitiated("1st call");
442
443  recorder_.RecordConnectionDelayedDueToBackoff(kDelay);
444  VerifyRecordedConnectionCount(2);
445  VerifyConnectionDelayedDueToBackoff("2nd call");
446
447  recorder_.RecordConnectionSuccess();
448  VerifyRecordedConnectionCount(3);
449  VerifyConnectionSuccess("3rd call");
450
451  recorder_.RecordConnectionFailure(kNetworkError);
452  VerifyRecordedConnectionCount(4);
453  VerifyConnectionFailure("4th call");
454
455  recorder_.RecordConnectionResetSignaled(kReason);
456  VerifyRecordedConnectionCount(5);
457  VerifyConnectionResetSignaled("5th call");
458}
459
460TEST_F(GCMStatsRecorderImplTest, RegistrationTest) {
461  recorder_.RecordRegistrationSent(kAppId, kSenderIds);
462  VerifyRecordedRegistrationCount(1);
463  VerifyRegistrationSent("1st call");
464
465  recorder_.RecordRegistrationResponse(kAppId, sender_ids_,
466                                       kRegistrationStatus);
467  VerifyRecordedRegistrationCount(2);
468  VerifyRegistrationResponse("2nd call");
469
470  recorder_.RecordRegistrationRetryRequested(kAppId, sender_ids_, kRetries);
471  VerifyRecordedRegistrationCount(3);
472  VerifyRegistrationRetryRequested("3rd call");
473
474  recorder_.RecordUnregistrationSent(kAppId);
475  VerifyRecordedRegistrationCount(4);
476  VerifyUnregistrationSent("4th call");
477
478  recorder_.RecordUnregistrationResponse(kAppId, kUnregistrationStatus);
479  VerifyRecordedRegistrationCount(5);
480  VerifyUnregistrationResponse("5th call");
481
482  recorder_.RecordUnregistrationRetryDelayed(kAppId, kDelay);
483  VerifyRecordedRegistrationCount(6);
484  VerifyUnregistrationRetryDelayed("6th call");
485}
486
487TEST_F(GCMStatsRecorderImplTest, RecordReceivingTest) {
488  recorder_.RecordConnectionInitiated(std::string());
489  recorder_.RecordConnectionSuccess();
490  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, true,
491                                      GCMStatsRecorder::DATA_MESSAGE);
492  VerifyRecordedReceivingCount(1);
493  VerifyDataMessageReceived("1st call");
494
495  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, true,
496                                      GCMStatsRecorder::DELETED_MESSAGES);
497  VerifyRecordedReceivingCount(2);
498  VerifyDataDeletedMessage("2nd call");
499
500  recorder_.RecordDataMessageReceived(kAppId, kFrom, kByteSize, false,
501                                      GCMStatsRecorder::DATA_MESSAGE);
502  VerifyRecordedReceivingCount(3);
503  VerifyDataMessageReceivedNotRegistered("3rd call");
504}
505
506TEST_F(GCMStatsRecorderImplTest, RecordSendingTest) {
507  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
508  VerifyRecordedSendingCount(1);
509  VerifyDataSentToWire("1st call");
510
511  recorder_.RecordNotifySendStatus(kAppId, kReceiverId, kMessageId,
512                                   kMessageSendStatus, kByteSize, kTTL);
513  VerifyRecordedSendingCount(2);
514  VerifyNotifySendStatus("2nd call");
515
516  recorder_.RecordIncomingSendError(kAppId, kReceiverId, kMessageId);
517  VerifyRecordedSendingCount(3);
518  VerifyIncomingSendError("3rd call");
519
520  recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
521  VerifyRecordedSendingCount(4);
522  VerifyDataSentToWire("4th call");
523}
524
525}  // namespace gcm
526