Add checkin activity recording to gcm recorder.

google_apis/gcm/monitoring/gcm_stats_recorder_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "google_apis/gcm/engine/mcs_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
+static uint64 kAndroidId = 4U;
+static const char kCheckinStatus[] = "URL_FETCHING_FAILED";
 static const char kHost[] = "www.example.com";
 static const char kAppId[] = "app id 1";
 static const char kFrom[] = "from";
 static const char kSenderIds[] = "s1,s2";
 static const char kReceiverId[] = "receiver 1";
 static const char kMessageId[] = "message id 1";
 static const int kQueuedSec = 5;
 static const gcm::MCSClient::MessageSendStatus kMessageSendStatus =
     gcm::MCSClient::QUEUED;
 static const int kByteSize = 99;
 static const int kTTL = 7;
 static const int kRetries = 3;
 static const int64 kDelay = 15000;
 static const ConnectionFactory::ConnectionResetReason kReason =
     ConnectionFactory::NETWORK_CHANGE;
 static const int kNetworkError = 1;
 
 static const RegistrationRequest::Status kRegistrationStatus =
     RegistrationRequest::SUCCESS;
 static const UnregistrationRequest::Status kUnregistrationStatus =
     UnregistrationRequest::SUCCESS;
 
+static const char kCheckinInitiatedEvent[] = "Checkin initiated";
+static const char kCheckinInitiatedDetails[] = "Android Id: 4";
+static const char kCheckinDelayedDueToBackoffEvent[] = "Checkin backoff";
+static const char kCheckinDelayedDueToBackoffDetails[] =
+    "Delayed for 15000 msec";
+static const char kCheckinSuccessEvent[] = "Checkin succeeded";
+static const char kCheckinSuccessDetails[] = "";
+static const char kCheckinFailureEvent[] = "Checkin failed";
+static const char kCheckinFailureDetails[] = "URL_FETCHING_FAILED. Will retry.";
+
 static const char kConnectionInitiatedEvent[] = "Connection initiated";
 static const char kConnectionInitiatedDetails[] = "www.example.com";
 static const char kConnectionDelayedDueToBackoffEvent[] = "Connection backoff";
 static const char kConnectionDelayedDueToBackoffDetails[] =
     "Delayed for 15000 msec";
 static const char kConnectionSuccessEvent[] = "Connection succeeded";
 static const char kConnectionSuccessDetails[] = "";
 static const char kConnectionFailureEvent[] = "Connection failed";
 static const char kConnectionFailureDetails[] = "With network error 1";
 static const char kConnectionResetSignaledEvent[] = "Connection reset";
@@ skipping 34 matching lines @@
 static const char kIncomingSendErrorDetails[] = "";
 
 }  // namespace
 
 class GCMStatsRecorderTest : public testing::Test {
  public:
   GCMStatsRecorderTest();
   virtual ~GCMStatsRecorderTest();
   virtual void SetUp() OVERRIDE;
 
+  void VerifyRecordedCheckinCount(int expected_count) {
+    EXPECT_EQ(expected_count,
+              static_cast<int>(recorder_.checkin_activities().size()));
+  }
   void VerifyRecordedConnectionCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.connection_activities().size()));
   }
   void VerifyRecordedRegistrationCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.registration_activities().size()));
   }
   void VerifyRecordedReceivingCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.receiving_activities().size()));
   }
   void VerifyRecordedSendingCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.sending_activities().size()));
   }
 
+  void VerifyCheckinInitiated(const std::string& remark) {
+    VerifyCheckin(recorder_.checkin_activities(),
+                  kCheckinInitiatedEvent,
+                  kCheckinInitiatedDetails,
+                  remark);
+  }
+
+  void VerifyCheckinDelayedDueToBackoff(const std::string& remark) {
+    VerifyCheckin(recorder_.checkin_activities(),
+                  kCheckinDelayedDueToBackoffEvent,
+                  kCheckinDelayedDueToBackoffDetails,
+                  remark);
+  }
+
+  void VerifyCheckinSuccess(const std::string& remark) {
+    VerifyCheckin(recorder_.checkin_activities(),
+                  kCheckinSuccessEvent,
+                  kCheckinSuccessDetails,
+                  remark);
+  }
+
+  void VerifyCheckinFailure(const std::string& remark) {
+    VerifyCheckin(recorder_.checkin_activities(),
+                  kCheckinFailureEvent,
+                  kCheckinFailureDetails,
+                  remark);
+  }
+
   void VerifyConnectionInitiated(const std::string& remark) {
     VerifyConnection(recorder_.connection_activities(),
                      kConnectionInitiatedEvent,
                      kConnectionInitiatedDetails,
                      remark);
   }
 
   void VerifyConnectionDelayedDueToBackoff(const std::string& remark) {
     VerifyConnection(recorder_.connection_activities(),
                      kConnectionDelayedDueToBackoffEvent,
@@ skipping 106 matching lines @@
   }
 
   void VerifyIncomingSendError(const std::string& remark) {
     VerifySendingData(recorder_.sending_activities(),
                       kIncomingSendErrorEvent,
                       kIncomingSendErrorDetails,
                       remark);
   }
 
  protected:
+  void VerifyCheckin(
+      const std::deque<GCMStatsRecorder::CheckinActivity>& queue,
+      const std::string& event,
+      const std::string& details,
+      const std::string& remark) {
+    EXPECT_EQ(event, queue.front().event) << remark;
+    EXPECT_EQ(details, queue.front().details) << remark;
+  }
+
   void VerifyConnection(
       const std::deque<GCMStatsRecorder::ConnectionActivity>& queue,
       const std::string& event,
       const std::string& details,
       const std::string& remark) {
     EXPECT_EQ(event, queue.front().event) << remark;
     EXPECT_EQ(details, queue.front().details) << remark;
   }
 
   void VerifyRegistration(
@@ skipping 66 matching lines @@
 
   recorder_.RecordNotifySendStatus(kAppId, kReceiverId, kMessageId,
                                    kMessageSendStatus, kByteSize, kTTL);
   VerifyRecordedSendingCount(2);
   VerifyNotifySendStatus("2nd call");
 
   recorder_.Clear();
   VerifyRecordedSendingCount(0);
 }
 
+TEST_F(GCMStatsRecorderTest, CheckinTest) {
+  recorder_.RecordCheckinInitiated(kAndroidId);
+  VerifyRecordedCheckinCount(1);
+  VerifyCheckinInitiated("1st call");
+
+  recorder_.RecordCheckinDelayedDueToBackoff(kDelay);
+  VerifyRecordedCheckinCount(2);
+  VerifyCheckinDelayedDueToBackoff("2nd call");
+
+  recorder_.RecordCheckinSuccess();
+  VerifyRecordedCheckinCount(3);
+  VerifyCheckinSuccess("3rd call");
+
+  recorder_.RecordCheckinFailure(kCheckinStatus, true);
+  VerifyRecordedCheckinCount(4);
+  VerifyCheckinFailure("4th call");
+}
+
 TEST_F(GCMStatsRecorderTest, ConnectionTest) {
   recorder_.RecordConnectionInitiated(kHost);
   VerifyRecordedConnectionCount(1);
   VerifyConnectionInitiated("1st call");
 
   recorder_.RecordConnectionDelayedDueToBackoff(kDelay);
   VerifyRecordedConnectionCount(2);
   VerifyConnectionDelayedDueToBackoff("2nd call");
 
   recorder_.RecordConnectionSuccess();
@@ skipping 66 matching lines @@
   recorder_.RecordIncomingSendError(kAppId, kReceiverId, kMessageId);
   VerifyRecordedSendingCount(3);
   VerifyIncomingSendError("3rd call");
 
   recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
   VerifyRecordedSendingCount(4);
   VerifyDataSentToWire("4th call");
 }
 
 }  // namespace gcm