google_apis/gcm/engine/gservices_settings_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 "base/strings/string_number_conversions.h"
   6 #include "google_apis/gcm/engine/gservices_settings.h"
   7 #include "google_apis/gcm/engine/registration_info.h"
   8 #include "google_apis/gcm/gcm_client.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace gcm {
  12
  13 namespace {
  14
  15 const int64 kAlternativeCheckinInterval = 16 * 60 * 60;
  16 const char kAlternativeCheckinURL[] = "http://alternative.url/checkin";
  17 const char kAlternativeMCSHostname[] = "http://alternative.gcm.host";
  18 const int kAlternativeMCSSecurePort = 443;
  19 const char kAlternativeRegistrationURL[] =
  20     "http://alternative.url/registration";
  21
  22 const int64 kDefaultCheckinInterval = 2 * 24 * 60 * 60;  // seconds = 2 days.
  23 const char kDefaultCheckinURL[] = "https://android.clients.google.com/checkin";
  24 const char kDefaultMCSHostname[] = "https://mtalk.google.com";
  25 const int kDefaultMCSSecurePort = 5228;
  26 const char kDefaultRegistrationURL[] =
  27     "https://android.clients.google.com/c2dm/register3";
  28
  29 class FakeGCMStore : public GCMStore {
  30  public:
  31   FakeGCMStore();
  32   virtual ~FakeGCMStore();
  33
  34   virtual void Load(const gcm::GCMStore::LoadCallback& callback) OVERRIDE {}
  35   virtual void Close() OVERRIDE {}
  36   virtual void Destroy(const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {
  37   }
  38   virtual void SetDeviceCredentials(
  39       uint64 device_android_id,
  40       uint64 device_security_token,
  41       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  42   virtual void AddRegistration(
  43       const std::string& app_id,
  44       const linked_ptr<gcm::RegistrationInfo>& registration,
  45       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  46   virtual void RemoveRegistration(
  47       const std::string& app_id,
  48       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  49   virtual void AddIncomingMessage(
  50       const std::string& persistent_id,
  51       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  52   virtual void RemoveIncomingMessage(
  53       const std::string& persistent_id,
  54       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  55   virtual void RemoveIncomingMessages(
  56       const PersistentIdList& persistent_ids,
  57       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  58   virtual bool AddOutgoingMessage(
  59       const std::string& persistent_id,
  60       const gcm::MCSMessage& message,
  61       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {
  62     return true;
  63   }
  64   virtual void OverwriteOutgoingMessage(
  65       const std::string& persistent_id,
  66       const gcm::MCSMessage& message,
  67       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  68   virtual void RemoveOutgoingMessage(
  69       const std::string& persistent_id,
  70       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  71   virtual void RemoveOutgoingMessages(
  72       const PersistentIdList& persistent_ids,
  73       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  74   virtual void SetLastCheckinTime(
  75       const base::Time& last_checkin_time,
  76       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {}
  77
  78   // G-service settings handling.
  79   virtual void SetGServicesSettings(
  80       const std::map<std::string, std::string>& settings,
  81       const std::string& settings_digest,
  82       const gcm::GCMStore::UpdateCallback& callback) OVERRIDE {
  83     settings_saved_ = true;
  84   }
  85
  86   void Reset() {
  87     settings_saved_ = false;
  88   }
  89
  90   bool settings_saved() const { return settings_saved_; }
  91
  92  private:
  93   bool settings_saved_;
  94 };
  95
  96 FakeGCMStore::FakeGCMStore() : settings_saved_(false) {}
  97
  98 FakeGCMStore::~FakeGCMStore() {}
  99
 100 }  // namespace
 101
 102 class GServicesSettingsTest : public testing::Test {
 103  public:
 104   GServicesSettingsTest();
 105   virtual ~GServicesSettingsTest();
 106
 107   virtual void SetUp() OVERRIDE;
 108
 109   void CheckAllSetToDefault();
 110   void CheckAllSetToAlternative();
 111   void SetWithAlternativeSettings(
 112       checkin_proto::AndroidCheckinResponse& checkin_response);
 113
 114   GServicesSettings& settings() {
 115     return gserivces_settings_;
 116   }
 117
 118   const std::map<std::string, std::string>& alternative_settings() {
 119     return alternative_settings_;
 120   }
 121
 122   FakeGCMStore& gcm_store() { return gcm_store_; }
 123
 124   std::map<std::string, std::string> alternative_settings_;
 125
 126  private:
 127   FakeGCMStore gcm_store_;
 128   GServicesSettings gserivces_settings_;
 129 };
 130
 131 GServicesSettingsTest::GServicesSettingsTest()
 132     : gserivces_settings_(&gcm_store_) {
 133 }
 134
 135 GServicesSettingsTest::~GServicesSettingsTest() {}
 136
 137 void GServicesSettingsTest::SetUp() {
 138   alternative_settings_["checkin_interval"] =
 139       base::Int64ToString(kAlternativeCheckinInterval);
 140   alternative_settings_["checkin_url"] = kAlternativeCheckinURL;
 141   alternative_settings_["gcm_hostname"] = kAlternativeMCSHostname;
 142   alternative_settings_["gcm_secure_port"] =
 143       base::IntToString(kAlternativeMCSSecurePort);
 144   alternative_settings_["gcm_registration_url"] = kAlternativeRegistrationURL;
 145 }
 146
 147 void GServicesSettingsTest::CheckAllSetToDefault() {
 148   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
 149             settings().checkin_interval());
 150   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().checkin_url());
 151   EXPECT_EQ(kDefaultMCSHostname, settings().mcs_hostname());
 152   EXPECT_EQ(kDefaultMCSSecurePort, settings().mcs_secure_port());
 153   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().registration_url());
 154 }
 155
 156 void GServicesSettingsTest::CheckAllSetToAlternative() {
 157   EXPECT_EQ(base::TimeDelta::FromSeconds(kAlternativeCheckinInterval),
 158             settings().checkin_interval());
 159   EXPECT_EQ(GURL(kAlternativeCheckinURL), settings().checkin_url());
 160   EXPECT_EQ(kAlternativeMCSHostname, settings().mcs_hostname());
 161   EXPECT_EQ(kAlternativeMCSSecurePort, settings().mcs_secure_port());
 162   EXPECT_EQ(GURL(kAlternativeRegistrationURL), settings().registration_url());
 163 }
 164
 165 void GServicesSettingsTest::SetWithAlternativeSettings(
 166     checkin_proto::AndroidCheckinResponse& checkin_response) {
 167   for (std::map<std::string, std::string>::const_iterator iter =
 168            alternative_settings_.begin();
 169        iter != alternative_settings_.end(); ++iter) {
 170     checkin_proto::GservicesSetting* setting = checkin_response.add_setting();
 171     setting->set_name(iter->first);
 172     setting->set_value(iter->second);
 173   }
 174 }
 175
 176 // Verifies default values of the G-services settings and settings digest.
 177 TEST_F(GServicesSettingsTest, DefaultSettingsAndDigest) {
 178   CheckAllSetToDefault();
 179   EXPECT_EQ(std::string(), settings().digest());
 180 }
 181
 182 // Verifies that settings are not updated when load result is empty.
 183 TEST_F(GServicesSettingsTest, UpdateFromEmptyLoadResult) {
 184   GCMStore::LoadResult result;
 185   result.gservices_digest = "digest_value";
 186   settings().UpdateFromLoadResult(result);
 187
 188   CheckAllSetToDefault();
 189   EXPECT_EQ(std::string(), settings().digest());
 190 }
 191
 192 // Verifies that settings are not updated when one of them is missing.
 193 TEST_F(GServicesSettingsTest, UpdateFromLoadResultWithSettingMissing) {
 194   GCMStore::LoadResult result;
 195   result.gservices_settings = alternative_settings();
 196   result.gservices_digest = "digest_value";
 197   result.gservices_settings.erase("gcm_hostname");
 198   settings().UpdateFromLoadResult(result);
 199
 200   CheckAllSetToDefault();
 201   EXPECT_EQ(std::string(), settings().digest());
 202 }
 203
 204 // Verifies that the settings are set correctly based on the load result.
 205 TEST_F(GServicesSettingsTest, UpdateFromLoadResult) {
 206   GCMStore::LoadResult result;
 207   result.gservices_settings = alternative_settings();
 208   result.gservices_digest = "digest_value";
 209   settings().UpdateFromLoadResult(result);
 210
 211   CheckAllSetToAlternative();
 212   EXPECT_EQ("digest_value", settings().digest());
 213 }
 214
 215 // Verifies that the settings are set correctly after parsing a checkin
 216 // response.
 217 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponse) {
 218   checkin_proto::AndroidCheckinResponse checkin_response;
 219
 220   checkin_response.set_digest("digest_value");
 221   SetWithAlternativeSettings(checkin_response);
 222
 223   settings().UpdateFromCheckinResponse(checkin_response);
 224   EXPECT_TRUE(gcm_store().settings_saved());
 225
 226   CheckAllSetToAlternative();
 227   EXPECT_EQ("digest_value", settings().digest());
 228 }
 229
 230 // Verifies that the checkin interval is updated to minimum if the original
 231 // value is less than minimum.
 232 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponseMinimumCheckinInterval) {
 233   checkin_proto::AndroidCheckinResponse checkin_response;
 234
 235   checkin_response.set_digest("digest_value");
 236   // Setting the checkin interval to less than minimum.
 237   alternative_settings_["checkin_interval"] = base::IntToString(3600);
 238   SetWithAlternativeSettings(checkin_response);
 239
 240   settings().UpdateFromCheckinResponse(checkin_response);
 241   EXPECT_TRUE(gcm_store().settings_saved());
 242
 243   EXPECT_EQ(GServicesSettings::MinimumCheckinInterval(),
 244             settings().checkin_interval());
 245   EXPECT_EQ("digest_value", settings().digest());
 246 }
 247
 248 // Verifies that settings are not updated when one of them is missing.
 249 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponseWithSettingMissing) {
 250   checkin_proto::AndroidCheckinResponse checkin_response;
 251
 252   checkin_response.set_digest("digest_value");
 253   alternative_settings_.erase("gcm_hostname");
 254   SetWithAlternativeSettings(checkin_response);
 255
 256   settings().UpdateFromCheckinResponse(checkin_response);
 257   EXPECT_FALSE(gcm_store().settings_saved());
 258
 259   CheckAllSetToDefault();
 260   EXPECT_EQ(std::string(), settings().digest());
 261 }
 262
 263 // Verifies that no update is done, when a checkin response misses digest.
 264 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponseNoDigest) {
 265   checkin_proto::AndroidCheckinResponse checkin_response;
 266
 267   SetWithAlternativeSettings(checkin_response);
 268   settings().UpdateFromCheckinResponse(checkin_response);
 269   EXPECT_FALSE(gcm_store().settings_saved());
 270
 271   CheckAllSetToDefault();
 272   EXPECT_EQ(std::string(), settings().digest());
 273 }
 274
 275 // Verifies that no update is done, when a checkin response digest is the same.
 276 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponseSameDigest) {
 277   GCMStore::LoadResult load_result;
 278   load_result.gservices_digest = "old_digest";
 279   load_result.gservices_settings = alternative_settings();
 280   settings().UpdateFromLoadResult(load_result);
 281
 282   checkin_proto::AndroidCheckinResponse checkin_response;
 283   checkin_response.set_digest("old_digest");
 284   SetWithAlternativeSettings(checkin_response);
 285   settings().UpdateFromCheckinResponse(checkin_response);
 286   EXPECT_FALSE(gcm_store().settings_saved());
 287
 288   CheckAllSetToAlternative();
 289   EXPECT_EQ("old_digest", settings().digest());
 290 }
 291
 292 }  // namespace gcm