GCM Checkin implementation with unit tests and protobufs

google_apis/gcm/engine/checkin_request_unittest.cc

Index: google_apis/gcm/engine/checkin_request_unittest.cc
diff --git a/google_apis/gcm/engine/checkin_request_unittest.cc b/google_apis/gcm/engine/checkin_request_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9f0fd276c90f0b4241485ba9582811f34d215a58
--- /dev/null
+++ b/google_apis/gcm/engine/checkin_request_unittest.cc
@@ -0,0 +1,316 @@
+// 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/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 uint64 kAndroidId = 42UL;
+const uint64 kBlankAndroidId = 999999UL;
+const uint64 kBlankSecurityToken = 999999UL;
+const char kChromeVersion[] = "Version String";
+const uint64 kSecurityToken = 77;
+const int64 kUserSerialNumber = 7;
+
+class CheckinRequestTest : public testing::Test {
+ public:
+  enum MissingValue {
+    MISSING_ANDROID_ID,
+    MISSING_SECURITY_TOKEN
+  };
+
+  CheckinRequestTest();
+  virtual ~CheckinRequestTest();
+
+  checkin_proto::ChromeBuildProto CreateChromeBuildProto();
+
+  void FetcherCallback(uint64 android_id, uint64 security_token);
+
+  void SetResponse(net::TestURLFetcher* fetcher,
+                   uint64 android_id,
+                   uint64 security_token);
+
+  void SetResponseMissingValue(net::TestURLFetcher* fetcher,

[Nicolas Zea, 2014/01/07 00:41:52]

Can you just have a single SetResponse(ValueState value_state), where ValueStat
is one of MISSING_ANDROID_ID, MISSING_SECURITY_TOKEN, MISSING_NONE? It seems
like fetcher_ can be a protected member variable, and the same android id and
security token are used everywhere.

[fgorski, 2014/01/07 23:46:44]

I actually dealt without ever storing the fetcher. I can query the factory to
get it every time. I did extend the enum with response to cover 5 options.
(Called it ResponseScenario)

+                               MissingValue missing_value);
+
+ protected:
+  uint64 android_id_;
+  uint64 security_token_;
+  int checkin_device_type_;
+  GCMClient::CheckinInfo user_checkin_info_;
+  base::MessageLoop message_loop_;
+  net::TestURLFetcherFactory url_fetcher_factory_;
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
+};
+
+CheckinRequestTest::CheckinRequestTest()
+    : android_id_(kBlankAndroidId),
+      security_token_(kBlankSecurityToken),
+      checkin_device_type_(0),
+      url_request_context_getter_(new net::TestURLRequestContextGetter(
+          message_loop_.message_loop_proxy())) {}
+
+CheckinRequestTest::~CheckinRequestTest() {}
+
+checkin_proto::ChromeBuildProto CheckinRequestTest::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 CheckinRequestTest::FetcherCallback(uint64 android_id,
+                                         uint64 security_token) {
+  android_id_ = android_id;
+  security_token_ = security_token;
+}
+
+void CheckinRequestTest::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);
+}
+
+void CheckinRequestTest::SetResponseMissingValue(net::TestURLFetcher* fetcher,
+                                                 MissingValue missing_value) {
+  checkin_proto::AndroidCheckinResponse response;
+  response.set_stats_ok(true);
+  if (missing_value != MISSING_ANDROID_ID)
+    response.set_android_id(kAndroidId);
+  else
+    response.set_security_token(kSecurityToken);
+
+  std::string response_string;
+  response.SerializeToString(&response_string);
+  fetcher->SetResponseString(response_string);
+}
+
+TEST_F(CheckinRequestTest, FetcherData) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  user_checkin_info_.android_id = kAndroidId;
+  user_checkin_info_.secret = kSecurityToken;
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_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, static_cast<uint64>(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(CheckinRequestTest, ResponseBodyEmpty) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_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(CheckinRequestTest, ResponseBodyCorrupted) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_OK);
+  fetcher->SetResponseString("Corrupted response body");
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, ResponseHttpStatusNotOK) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
+  fetcher->SetResponseString(std::string());
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, ResponseMissingAndroidId) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
+  SetResponseMissingValue(fetcher, MISSING_ANDROID_ID);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, ResponseMissingSecurityToken) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
+  SetResponseMissingValue(fetcher, MISSING_SECURITY_TOKEN);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, ResponseValueOfAndroidIdIsZero) {

[jianli, 2014/01/06 23:28:43]

nit: ResponseContainingZeroAndroidId

[fgorski, 2014/01/07 23:46:44]

Done.

+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
+  SetResponse(fetcher, 0, kSecurityToken);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, ResponseValueOfSecurityTokenIsZero) {

[jianli, 2014/01/06 23:28:43]

nit: ditto

[fgorski, 2014/01/07 23:46:44]

Done.

+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+  fetcher->set_response_code(net::HTTP_UNAUTHORIZED);
+  SetResponse(fetcher, kAndroidId, 0);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+  EXPECT_EQ(0u, android_id_);
+  EXPECT_EQ(0u, security_token_);
+}
+
+TEST_F(CheckinRequestTest, SuccessfulFirstTimeCheckin) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  net::TestURLFetcher* fetcher = url_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(CheckinRequestTest, SuccessfulSubsequentCheckin) {
+  checkin_proto::ChromeBuildProto chrome_build_proto = CreateChromeBuildProto();
+  // Having non-zero android_id and secret indicate it is a subsequent check in.
+  user_checkin_info_.android_id = kAndroidId;
+  user_checkin_info_.secret = kSecurityToken;
+  CheckinRequest request(
+      base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
+      chrome_build_proto,
+      kUserSerialNumber,
+      user_checkin_info_,
+      url_request_context_getter_.get());
+  request.Start();
+
+  EXPECT_EQ(kBlankAndroidId, android_id_);
+  EXPECT_EQ(kBlankSecurityToken, security_token_);
+  net::TestURLFetcher* fetcher = url_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