google_apis/gcm/engine/checkin_request_unittest.cc

   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 <string>
   6
   7 #include "google_apis/gcm/engine/checkin_request.h"
   8 #include "google_apis/gcm/engine/gcm_request_test_base.h"
   9 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
  10 #include "google_apis/gcm/protocol/checkin.pb.h"
  11
  12 namespace gcm {
  13
  14 const uint64 kAndroidId = 42UL;
  15 const uint64 kBlankAndroidId = 999999UL;
  16 const uint64 kBlankSecurityToken = 999999UL;
  17 const char kCheckinURL[] = "http://foo.bar/checkin";
  18 const char kChromeVersion[] = "Version String";
  19 const uint64 kSecurityToken = 77;
  20 const char kSettingsDigest[] = "settings_digest";
  21 const char kEmailAddress[] = "test_user@gmail.com";
  22 const char kTokenValue[] = "token_value";
  23
  24 class CheckinRequestTest : public GCMRequestTestBase {
  25  public:
  26   enum ResponseScenario {
  27     VALID_RESPONSE,  // Both android_id and security_token set in response.
  28     MISSING_ANDROID_ID,  // android_id is missing.
  29     MISSING_SECURITY_TOKEN,  // security_token is missing.
  30     ANDROID_ID_IS_ZER0,  // android_id is 0.
  31     SECURITY_TOKEN_IS_ZERO  // security_token is 0.
  32   };
  33
  34   CheckinRequestTest();
  35   ~CheckinRequestTest() override;
  36
  37   void FetcherCallback(
  38       const checkin_proto::AndroidCheckinResponse& response);
  39
  40   void CreateRequest(uint64 android_id, uint64 security_token);
  41
  42   void SetResponseScenario(ResponseScenario response_scenario);
  43
  44  protected:
  45   bool callback_called_;
  46   uint64 android_id_;
  47   uint64 security_token_;
  48   int checkin_device_type_;
  49   checkin_proto::ChromeBuildProto chrome_build_proto_;
  50   scoped_ptr<CheckinRequest> request_;
  51   FakeGCMStatsRecorder recorder_;
  52 };
  53
  54 CheckinRequestTest::CheckinRequestTest()
  55     : callback_called_(false),
  56       android_id_(kBlankAndroidId),
  57       security_token_(kBlankSecurityToken),
  58       checkin_device_type_(0) {
  59 }
  60
  61 CheckinRequestTest::~CheckinRequestTest() {}
  62
  63 void CheckinRequestTest::FetcherCallback(
  64     const checkin_proto::AndroidCheckinResponse& checkin_response) {
  65   callback_called_ = true;
  66   if (checkin_response.has_android_id())
  67     android_id_ = checkin_response.android_id();
  68   if (checkin_response.has_security_token())
  69     security_token_ = checkin_response.security_token();
  70 }
  71
  72 void CheckinRequestTest::CreateRequest(uint64 android_id,
  73                                        uint64 security_token) {
  74   // First setup a chrome_build protobuf.
  75   chrome_build_proto_.set_platform(
  76       checkin_proto::ChromeBuildProto::PLATFORM_LINUX);
  77   chrome_build_proto_.set_channel(
  78       checkin_proto::ChromeBuildProto::CHANNEL_CANARY);
  79   chrome_build_proto_.set_chrome_version(kChromeVersion);
  80
  81   std::map<std::string, std::string> account_tokens;
  82   account_tokens[kEmailAddress] = kTokenValue;
  83
  84   CheckinRequest::RequestInfo request_info(android_id,
  85                                            security_token,
  86                                            account_tokens,
  87                                            kSettingsDigest,
  88                                            chrome_build_proto_);
  89   // Then create a request with that protobuf and specified android_id,
  90   // security_token.
  91   request_.reset(new CheckinRequest(
  92       GURL(kCheckinURL),
  93       request_info,
  94       GetBackoffPolicy(),
  95       base::Bind(&CheckinRequestTest::FetcherCallback, base::Unretained(this)),
  96       url_request_context_getter(),
  97       &recorder_));
  98
  99   // Setting android_id_ and security_token_ to blank value, not used elsewhere
 100   // in the tests.
 101   callback_called_ = false;
 102   android_id_ = kBlankAndroidId;
 103   security_token_ = kBlankSecurityToken;
 104 }
 105
 106 void CheckinRequestTest::SetResponseScenario(
 107     ResponseScenario response_scenario) {
 108   checkin_proto::AndroidCheckinResponse response;
 109   response.set_stats_ok(true);
 110
 111   uint64 android_id = response_scenario == ANDROID_ID_IS_ZER0 ? 0 : kAndroidId;
 112   uint64 security_token =
 113       response_scenario == SECURITY_TOKEN_IS_ZERO ? 0 : kSecurityToken;
 114
 115   if (response_scenario != MISSING_ANDROID_ID)
 116     response.set_android_id(android_id);
 117
 118   if (response_scenario != MISSING_SECURITY_TOKEN)
 119     response.set_security_token(security_token);
 120
 121   std::string response_string;
 122   response.SerializeToString(&response_string);
 123   SetResponse(net::HTTP_OK, response_string);
 124 }
 125
 126 TEST_F(CheckinRequestTest, FetcherDataAndURL) {
 127   CreateRequest(kAndroidId, kSecurityToken);
 128   request_->Start();
 129
 130   // Get data sent by request.
 131   net::TestURLFetcher* fetcher = GetFetcher();
 132   ASSERT_TRUE(fetcher);
 133   EXPECT_EQ(GURL(kCheckinURL), fetcher->GetOriginalURL());
 134
 135   checkin_proto::AndroidCheckinRequest request_proto;
 136   request_proto.ParseFromString(fetcher->upload_data());
 137   EXPECT_EQ(kAndroidId, static_cast<uint64>(request_proto.id()));
 138   EXPECT_EQ(kSecurityToken, request_proto.security_token());
 139   EXPECT_EQ(chrome_build_proto_.platform(),
 140             request_proto.checkin().chrome_build().platform());
 141   EXPECT_EQ(chrome_build_proto_.chrome_version(),
 142             request_proto.checkin().chrome_build().chrome_version());
 143   EXPECT_EQ(chrome_build_proto_.channel(),
 144             request_proto.checkin().chrome_build().channel());
 145   EXPECT_EQ(2, request_proto.account_cookie_size());
 146   EXPECT_EQ(kEmailAddress, request_proto.account_cookie(0));
 147   EXPECT_EQ(kTokenValue, request_proto.account_cookie(1));
 148
 149 #if defined(CHROME_OS)
 150   EXPECT_EQ(checkin_proto::DEVICE_CHROME_OS, request_proto.checkin().type());
 151 #else
 152   EXPECT_EQ(checkin_proto::DEVICE_CHROME_BROWSER,
 153             request_proto.checkin().type());
 154 #endif
 155
 156   EXPECT_EQ(kSettingsDigest, request_proto.digest());
 157 }
 158
 159 TEST_F(CheckinRequestTest, ResponseBodyEmpty) {
 160   CreateRequest(0u, 0u);
 161   request_->Start();
 162
 163   SetResponse(net::HTTP_OK, std::string());
 164   CompleteFetch();
 165
 166   EXPECT_FALSE(callback_called_);
 167
 168   SetResponseScenario(VALID_RESPONSE);
 169   CompleteFetch();
 170
 171   EXPECT_TRUE(callback_called_);
 172   EXPECT_EQ(kAndroidId, android_id_);
 173   EXPECT_EQ(kSecurityToken, security_token_);
 174 }
 175
 176 TEST_F(CheckinRequestTest, ResponseBodyCorrupted) {
 177   CreateRequest(0u, 0u);
 178   request_->Start();
 179
 180   SetResponse(net::HTTP_OK, "Corrupted response body");
 181   CompleteFetch();
 182
 183   EXPECT_FALSE(callback_called_);
 184
 185   SetResponseScenario(VALID_RESPONSE);
 186   CompleteFetch();
 187
 188   EXPECT_TRUE(callback_called_);
 189   EXPECT_EQ(kAndroidId, android_id_);
 190   EXPECT_EQ(kSecurityToken, security_token_);
 191 }
 192
 193 TEST_F(CheckinRequestTest, ResponseHttpStatusUnauthorized) {
 194   CreateRequest(0u, 0u);
 195   request_->Start();
 196
 197   SetResponse(net::HTTP_UNAUTHORIZED, std::string());
 198   CompleteFetch();
 199
 200   EXPECT_TRUE(callback_called_);
 201   EXPECT_EQ(kBlankAndroidId, android_id_);
 202   EXPECT_EQ(kBlankSecurityToken, security_token_);
 203 }
 204
 205 TEST_F(CheckinRequestTest, ResponseHttpStatusBadRequest) {
 206   CreateRequest(0u, 0u);
 207   request_->Start();
 208
 209   SetResponse(net::HTTP_BAD_REQUEST, std::string());
 210   CompleteFetch();
 211
 212   EXPECT_TRUE(callback_called_);
 213   EXPECT_EQ(kBlankAndroidId, android_id_);
 214   EXPECT_EQ(kBlankSecurityToken, security_token_);
 215 }
 216
 217 TEST_F(CheckinRequestTest, ResponseHttpStatusNotOK) {
 218   CreateRequest(0u, 0u);
 219   request_->Start();
 220
 221   SetResponse(net::HTTP_INTERNAL_SERVER_ERROR, std::string());
 222   CompleteFetch();
 223
 224   EXPECT_FALSE(callback_called_);
 225
 226   SetResponseScenario(VALID_RESPONSE);
 227   CompleteFetch();
 228
 229   EXPECT_TRUE(callback_called_);
 230   EXPECT_EQ(kAndroidId, android_id_);
 231   EXPECT_EQ(kSecurityToken, security_token_);
 232 }
 233
 234 TEST_F(CheckinRequestTest, ResponseMissingAndroidId) {
 235   CreateRequest(0u, 0u);
 236   request_->Start();
 237
 238   SetResponseScenario(MISSING_ANDROID_ID);
 239   CompleteFetch();
 240
 241   EXPECT_FALSE(callback_called_);
 242
 243   SetResponseScenario(VALID_RESPONSE);
 244   CompleteFetch();
 245
 246   EXPECT_TRUE(callback_called_);
 247   EXPECT_EQ(kAndroidId, android_id_);
 248   EXPECT_EQ(kSecurityToken, security_token_);
 249 }
 250
 251 TEST_F(CheckinRequestTest, ResponseMissingSecurityToken) {
 252   CreateRequest(0u, 0u);
 253   request_->Start();
 254
 255   SetResponseScenario(MISSING_SECURITY_TOKEN);
 256   CompleteFetch();
 257
 258   EXPECT_FALSE(callback_called_);
 259
 260   SetResponseScenario(VALID_RESPONSE);
 261   CompleteFetch();
 262
 263   EXPECT_TRUE(callback_called_);
 264   EXPECT_EQ(kAndroidId, android_id_);
 265   EXPECT_EQ(kSecurityToken, security_token_);
 266 }
 267
 268 TEST_F(CheckinRequestTest, AndroidIdEqualsZeroInResponse) {
 269   CreateRequest(0u, 0u);
 270   request_->Start();
 271
 272   SetResponseScenario(ANDROID_ID_IS_ZER0);
 273   CompleteFetch();
 274
 275   EXPECT_FALSE(callback_called_);
 276
 277   SetResponseScenario(VALID_RESPONSE);
 278   CompleteFetch();
 279
 280   EXPECT_TRUE(callback_called_);
 281   EXPECT_EQ(kAndroidId, android_id_);
 282   EXPECT_EQ(kSecurityToken, security_token_);
 283 }
 284
 285 TEST_F(CheckinRequestTest, SecurityTokenEqualsZeroInResponse) {
 286   CreateRequest(0u, 0u);
 287   request_->Start();
 288
 289   SetResponseScenario(SECURITY_TOKEN_IS_ZERO);
 290   CompleteFetch();
 291
 292   EXPECT_FALSE(callback_called_);
 293
 294   SetResponseScenario(VALID_RESPONSE);
 295   CompleteFetch();
 296
 297   EXPECT_TRUE(callback_called_);
 298   EXPECT_EQ(kAndroidId, android_id_);
 299   EXPECT_EQ(kSecurityToken, security_token_);
 300 }
 301
 302 TEST_F(CheckinRequestTest, SuccessfulFirstTimeCheckin) {
 303   CreateRequest(0u, 0u);
 304   request_->Start();
 305
 306   SetResponseScenario(VALID_RESPONSE);
 307   CompleteFetch();
 308
 309   EXPECT_TRUE(callback_called_);
 310   EXPECT_EQ(kAndroidId, android_id_);
 311   EXPECT_EQ(kSecurityToken, security_token_);
 312 }
 313
 314 TEST_F(CheckinRequestTest, SuccessfulSubsequentCheckin) {
 315   CreateRequest(kAndroidId, kSecurityToken);
 316   request_->Start();
 317
 318   SetResponseScenario(VALID_RESPONSE);
 319   CompleteFetch();
 320
 321   EXPECT_TRUE(callback_called_);
 322   EXPECT_EQ(kAndroidId, android_id_);
 323   EXPECT_EQ(kSecurityToken, security_token_);
 324 }
 325
 326 }  // namespace gcm