GCM Checkin implementation with unit tests and protobufs

google_apis/gcm/engine/gcm_checkin_request_unittest.cc

Index: google_apis/gcm/engine/gcm_checkin_request_unittest.cc
diff --git a/google_apis/gcm/engine/gcm_checkin_request_unittest.cc b/google_apis/gcm/engine/gcm_checkin_request_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..308b0bc0ece964ce39d8fd1789f217f964aad0bd
--- /dev/null
+++ b/google_apis/gcm/engine/gcm_checkin_request_unittest.cc
@@ -0,0 +1,182 @@
+// Copyright (c) 2013 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 <string>
+
+#include "google_apis/gcm/engine/gcm_checkin_request.h"
+#include "google_apis/gcm/protocol/checkin.pb.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gcm {
+
+const int64 kAndroidId = 42;
+const int64 kBlankAndroidId = -1;
+const uint64 kBlankSecurityToken = 999999;
+const char kChromeVersion[] = "Version String";
+const uint64 kSecurityToken = 77;
+const int64 kUserSerialNumber = 7;
+
+class GCMCheckinRequestTest : public testing::Test {
+ public:
+  GCMCheckinRequestTest();
+  virtual ~GCMCheckinRequestTest();
+
+  checkin_proto::ChromeBuildProto CreateChromeBuildProto();
+
+  void FetcherCallback(uint64 android_id, uint64 security_token);
+
+  void SetResponse(net::TestURLFetcher* fetcher,
+                   uint64 android_id,
+                   uint64 security_token);
+
+ protected:
+  int64 android_id_;
+  uint64 security_token_;
+  int checkin_device_type_;
+  GCMClient::CheckInInfo user_checkin_info_;
+  base::MessageLoop message_loop_;
+  net::TestURLFetcherFactory factory_;
+  scoped_refptr<net::TestURLRequestContextGetter> getter_;
+};
+
+GCMCheckinRequestTest::GCMCheckinRequestTest()
+    : android_id_(kBlankAndroidId),
+      security_token_(kBlankSecurityToken),
+      checkin_device_type_(0),
+      getter_(new net::TestURLRequestContextGetter(
+          message_loop_.message_loop_proxy())) {}
+
+GCMCheckinRequestTest::~GCMCheckinRequestTest() {}
+
+checkin_proto::ChromeBuildProto
+GCMCheckinRequestTest::CreateChromeBuildProto() {
+  checkin_proto::ChromeBuildProto chrome_build_proto;
+  chrome_build_proto.set_platform(
+      checkin_proto::ChromeBuildProto::PLATFORM_LINUX);
+  chrome_build_proto.set_channel(
+      checkin_proto::ChromeBuildProto::CHANNEL_CANARY);
+  chrome_build_proto.set_chrome_version(kChromeVersion);
+  return chrome_build_proto;
+}
+
+void GCMCheckinRequestTest::FetcherCallback(uint64 android_id,
+                                            uint64 security_token) {
+  android_id_ = android_id;
+  security_token_ = security_token;
+}
+
+void GCMCheckinRequestTest::SetResponse(net::TestURLFetcher* fetcher,
+                                        uint64 android_id,
+                                        uint64 security_token) {
+  checkin_proto::AndroidCheckinResponse response;
+  response.set_stats_ok(true);
+  response.set_android_id(android_id);
+  response.set_security_token(security_token);
+
+  std::string response_string;
+  response.SerializeToString(&response_string);
+  fetcher->SetResponseString(response_string);
+}
+
+TEST_F(GCMCheckinRequestTest, EmptyResponseBody) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  GCMCheckinRequest request(base::Bind(&GCMCheckinRequestTest::FetcherCallback,
+                                       base::Unretained(this)),
+                            chrome_build_proto,
+                            kUserSerialNumber,
+                            user_checkin_info_,
+                            getter_.get());
+  request.Start();
+
+  EXPECT_EQ(kBlankAndroidId, android_id_);
+  EXPECT_EQ(kBlankSecurityToken, security_token_);
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  fetcher->SetResponseString(std::string());
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(GCMCheckinRequestTest, FetcherData) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  user_checkin_info_.android_id = kAndroidId;
+  user_checkin_info_.secret = kSecurityToken;
+  GCMCheckinRequest request(base::Bind(&GCMCheckinRequestTest::FetcherCallback,
+                                       base::Unretained(this)),
+                            chrome_build_proto,
+                            kUserSerialNumber,
+                            user_checkin_info_,
+                            getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  checkin_proto::AndroidCheckinRequest request_proto;
+  request_proto.ParseFromString(fetcher->upload_data());
+  EXPECT_EQ(kAndroidId, request_proto.id());
+  EXPECT_EQ(kSecurityToken, request_proto.security_token());
+  EXPECT_EQ(kUserSerialNumber, request_proto.user_serial_number());
+  EXPECT_EQ(chrome_build_proto.platform(),
+            request_proto.checkin().chrome_build().platform());
+  EXPECT_EQ(chrome_build_proto.chrome_version(),
+            request_proto.checkin().chrome_build().chrome_version());
+  EXPECT_EQ(chrome_build_proto.channel(),
+            request_proto.checkin().chrome_build().channel());
+
+#if defined(CHROME_OS)
+  EXPECT_EQ(checkin_proto::DEVICE_CHROME_OS, request_proto.checkin().type());
+#else
+  EXPECT_EQ(checkin_proto::DEVICE_CHROME_BROWSER,
+            request_proto.checkin().type());
+#endif
+}
+
+TEST_F(GCMCheckinRequestTest, SuccessfulCheckin) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  user_checkin_info_.android_id = kAndroidId;
+  user_checkin_info_.secret = kSecurityToken;
+  GCMCheckinRequest request(base::Bind(&GCMCheckinRequestTest::FetcherCallback,
+                                       base::Unretained(this)),
+                            chrome_build_proto,
+                            kUserSerialNumber,
+                            user_checkin_info_,
+                            getter_.get());
+  request.Start();
+
+  EXPECT_EQ(kBlankAndroidId, android_id_);
+  EXPECT_EQ(kBlankSecurityToken, security_token_);
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  SetResponse(fetcher, kAndroidId, kSecurityToken);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(kAndroidId, android_id_);
+  EXPECT_EQ(kSecurityToken, security_token_);
+}
+
+TEST_F(GCMCheckinRequestTest, SuccessfulFirstTimeCheckin) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  GCMCheckinRequest request(base::Bind(&GCMCheckinRequestTest::FetcherCallback,
+                                       base::Unretained(this)),
+                            chrome_build_proto,
+                            kUserSerialNumber,
+                            user_checkin_info_,
+                            getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  SetResponse(fetcher, kAndroidId, kSecurityToken);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(kAndroidId, android_id_);
+  EXPECT_EQ(kSecurityToken, security_token_);
+}
+
+}  // namespace gcm