[GCM] Adding basic G-services handling

google_apis/gcm/engine/checkin_request_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 <string>
 #include <vector>
 
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 #include "net/base/backoff_entry.h"
@@ skipping 33 matching lines @@
   false,
 };
 
 }
 
 const uint64 kAndroidId = 42UL;
 const uint64 kBlankAndroidId = 999999UL;
 const uint64 kBlankSecurityToken = 999999UL;
 const char kChromeVersion[] = "Version String";
 const uint64 kSecurityToken = 77;
+const char kSettingsDigest[] = "settings_digest";
 
 class CheckinRequestTest : public testing::Test {
  public:
   enum ResponseScenario {
     VALID_RESPONSE,  // Both android_id and security_token set in response.
     MISSING_ANDROID_ID,  // android_id is missing.
     MISSING_SECURITY_TOKEN,  // security_token is missing.
     ANDROID_ID_IS_ZER0,  // android_id is 0.
     SECURITY_TOKEN_IS_ZERO  // security_token is 0.
   };
 
   CheckinRequestTest();
   virtual ~CheckinRequestTest();
 
-  void FetcherCallback(uint64 android_id, uint64 security_token);
+  void FetcherCallback(
+      const checkin_proto::AndroidCheckinResponse& response);
 
   void CreateRequest(uint64 android_id, uint64 security_token);
 
   void SetResponseStatusAndString(
       net::HttpStatusCode status_code,
       const std::string& response_data);
 
   void CompleteFetch();
 
   void SetResponse(ResponseScenario response_scenario);
@@ skipping 16 matching lines @@
       android_id_(kBlankAndroidId),
       security_token_(kBlankSecurityToken),
       checkin_device_type_(0),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {
   account_ids_.push_back("account_id");
 }
 
 CheckinRequestTest::~CheckinRequestTest() {}
 
-void CheckinRequestTest::FetcherCallback(uint64 android_id,
-                                         uint64 security_token) {
+void CheckinRequestTest::FetcherCallback(
+    const checkin_proto::AndroidCheckinResponse& checkin_response) {
   callback_called_ = true;
-  android_id_ = android_id;
-  security_token_ = security_token;
+  if (checkin_response.has_android_id())
+    android_id_ = checkin_response.android_id();
+  if (checkin_response.has_security_token())
+    security_token_ = checkin_response.security_token();
 }
 
 void CheckinRequestTest::CreateRequest(uint64 android_id,
                                        uint64 security_token) {
   // First setup a chrome_build protobuf.
   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);
+
+  CheckinRequest::RequestInfo request_info(
+      android_id,
+      security_token,
+      kSettingsDigest,
+      account_ids_,
+      chrome_build_proto_);
   // Then create a request with that protobuf and specified android_id,
   // security_token.
   request_.reset(new CheckinRequest(
+      request_info,
+      kDefaultBackoffPolicy,
       base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
-      kDefaultBackoffPolicy,
-      chrome_build_proto_,
-      android_id,
-      security_token,
-      account_ids_,
       url_request_context_getter_.get()));
 
   // Setting android_id_ and security_token_ to blank value, not used elsewhere
   // in the tests.
   callback_called_ = false;
   android_id_ = kBlankAndroidId;
   security_token_ = kBlankSecurityToken;
 }
 
 void CheckinRequestTest::SetResponseStatusAndString(
@@ skipping 52 matching lines @@
   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
 
+  EXPECT_EQ(kSettingsDigest, request_proto.digest());
   EXPECT_EQ(1, request_proto.account_cookie_size());
   EXPECT_EQ("[account_id]", request_proto.account_cookie(0));
 }
 
 TEST_F(CheckinRequestTest, ResponseBodyEmpty) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, std::string());
   CompleteFetch();
@@ skipping 26 matching lines @@
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusUnauthorized) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, std::string());
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(0u, android_id_);
-  EXPECT_EQ(0u, security_token_);
+  EXPECT_EQ(kBlankAndroidId, android_id_);
+  EXPECT_EQ(kBlankSecurityToken, security_token_);
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusBadRequest) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_BAD_REQUEST, std::string());
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
-  EXPECT_EQ(0u, android_id_);
-  EXPECT_EQ(0u, security_token_);
+  EXPECT_EQ(kBlankAndroidId, android_id_);
+  EXPECT_EQ(kBlankSecurityToken, security_token_);
 }
 
 TEST_F(CheckinRequestTest, ResponseHttpStatusNotOK) {
   CreateRequest(0u, 0u);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_INTERNAL_SERVER_ERROR, std::string());
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
@@ skipping 92 matching lines @@
 
   SetResponse(VALID_RESPONSE);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(kAndroidId, android_id_);
   EXPECT_EQ(kSecurityToken, security_token_);
 }
 
 }  // namespace gcm