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[] = "alternative.gcm.host";
  18 const int kAlternativeMCSSecurePort = 7777;
  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 kDefaultRegistrationURL[] =
  25     "https://android.clients.google.com/c2dm/register3";
  26 const char kDefaultSettingsDigest[] =
  27     "1-da39a3ee5e6b4b0d3255bfef95601890afd80709";
  28 const char kAlternativeSettingsDigest[] =
  29     "1-7da4aa4eb38a8bd3e330e3751cc0899924499134";
  30
  31 void AddSettingsToResponse(
  32     checkin_proto::AndroidCheckinResponse& checkin_response,
  33     const GServicesSettings::SettingsMap& settings,
  34     bool settings_diff) {
  35   for (GServicesSettings::SettingsMap::const_iterator iter = settings.begin();
  36        iter != settings.end();
  37        ++iter) {
  38     checkin_proto::GservicesSetting* setting = checkin_response.add_setting();
  39     setting->set_name(iter->first);
  40     setting->set_value(iter->second);
  41   }
  42   checkin_response.set_settings_diff(settings_diff);
  43 }
  44
  45 }  // namespace
  46
  47 class GServicesSettingsTest : public testing::Test {
  48  public:
  49   GServicesSettingsTest();
  50   virtual ~GServicesSettingsTest();
  51
  52   void CheckAllSetToDefault();
  53
  54   GServicesSettings& settings() {
  55     return gserivces_settings_;
  56   }
  57
  58  private:
  59   GServicesSettings gserivces_settings_;
  60 };
  61
  62 GServicesSettingsTest::GServicesSettingsTest()
  63     : gserivces_settings_() {
  64 }
  65
  66 GServicesSettingsTest::~GServicesSettingsTest() {}
  67
  68 void GServicesSettingsTest::CheckAllSetToDefault() {
  69   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
  70             settings().GetCheckinInterval());
  71   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
  72   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
  73             settings().GetMCSMainEndpoint());
  74   EXPECT_EQ(GURL("https://mtalk.google.com:443"),
  75             settings().GetMCSFallbackEndpoint());
  76   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
  77 }
  78
  79 // Verifies default values of the G-services settings and settings digest.
  80 TEST_F(GServicesSettingsTest, DefaultSettingsAndDigest) {
  81   CheckAllSetToDefault();
  82   EXPECT_EQ(kDefaultSettingsDigest, settings().digest());
  83   EXPECT_EQ(kDefaultSettingsDigest,
  84             GServicesSettings::CalculateDigest(settings().settings_map()));
  85 }
  86
  87 // Verifies digest calculation for the sample provided by protocol owners.
  88 TEST_F(GServicesSettingsTest, CalculateDigest) {
  89   GServicesSettings::SettingsMap settings_map;
  90   settings_map["android_id"] = "55XXXXXXXXXXXXXXXX0";
  91   settings_map["checkin_interval"] = "86400";
  92   settings_map["checkin_url"] =
  93       "https://fake.address.google.com/canary/checkin";
  94   settings_map["chrome_device"] = "1";
  95   settings_map["device_country"] = "us";
  96   settings_map["gcm_hostname"] = "fake.address.google.com";
  97   settings_map["gcm_secure_port"] = "443";
  98
  99   EXPECT_EQ("1-33381ccd1cf5791dc0e6dfa234266fa9f1259197",
 100             GServicesSettings::CalculateDigest(settings_map));
 101 }
 102
 103 // Verifies that settings are not updated when load result is empty.
 104 TEST_F(GServicesSettingsTest, UpdateFromEmptyLoadResult) {
 105   GCMStore::LoadResult result;
 106   result.gservices_digest = "";
 107   settings().UpdateFromLoadResult(result);
 108
 109   CheckAllSetToDefault();
 110   EXPECT_EQ(kDefaultSettingsDigest, settings().digest());
 111 }
 112
 113 // Verifies that settings are not when digest value does not match.
 114 TEST_F(GServicesSettingsTest, UpdateFromLoadResultWithSettingMissing) {
 115   GCMStore::LoadResult result;
 116   result.gservices_settings["checkin_internval"] = "100000";
 117   result.gservices_digest = "digest_value";
 118   settings().UpdateFromLoadResult(result);
 119
 120   CheckAllSetToDefault();
 121   EXPECT_EQ(kDefaultSettingsDigest, settings().digest());
 122 }
 123
 124 // Verifies that the settings are set correctly based on the load result.
 125 TEST_F(GServicesSettingsTest, UpdateFromLoadResult) {
 126   GCMStore::LoadResult result;
 127   result.gservices_settings["checkin_interval"] =
 128       base::Int64ToString(kAlternativeCheckinInterval);
 129   result.gservices_settings["checkin_url"] = kAlternativeCheckinURL;
 130   result.gservices_settings["gcm_hostname"] = kAlternativeMCSHostname;
 131   result.gservices_settings["gcm_secure_port"] =
 132       base::IntToString(kAlternativeMCSSecurePort);
 133   result.gservices_settings["gcm_registration_url"] =
 134       kAlternativeRegistrationURL;
 135   result.gservices_digest = kAlternativeSettingsDigest;
 136   settings().UpdateFromLoadResult(result);
 137
 138   EXPECT_EQ(base::TimeDelta::FromSeconds(kAlternativeCheckinInterval),
 139             settings().GetCheckinInterval());
 140   EXPECT_EQ(GURL(kAlternativeCheckinURL), settings().GetCheckinURL());
 141   EXPECT_EQ(GURL("https://alternative.gcm.host:7777"),
 142             settings().GetMCSMainEndpoint());
 143   EXPECT_EQ(GURL("https://alternative.gcm.host:443"),
 144             settings().GetMCSFallbackEndpoint());
 145   EXPECT_EQ(GURL(kAlternativeRegistrationURL), settings().GetRegistrationURL());
 146   EXPECT_EQ(GServicesSettings::CalculateDigest(result.gservices_settings),
 147             settings().digest());
 148 }
 149
 150 // Verifies that the checkin interval is updated to minimum if the original
 151 // value is less than minimum.
 152 TEST_F(GServicesSettingsTest, CheckinResponseMinimumCheckinInterval) {
 153   // Setting the checkin interval to less than minimum.
 154   checkin_proto::AndroidCheckinResponse checkin_response;
 155   GServicesSettings::SettingsMap new_settings;
 156   new_settings["checkin_interval"] = "3600";
 157   AddSettingsToResponse(checkin_response, new_settings, false);
 158
 159   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 160
 161   EXPECT_EQ(GServicesSettings::MinimumCheckinInterval(),
 162             settings().GetCheckinInterval());
 163   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 164             settings().digest());
 165 }
 166
 167 // Verifies that default checkin interval can be selectively overwritten.
 168 TEST_F(GServicesSettingsTest, CheckinResponseUpdateCheckinInterval) {
 169   checkin_proto::AndroidCheckinResponse checkin_response;
 170   GServicesSettings::SettingsMap new_settings;
 171   new_settings["checkin_interval"] = "86400";
 172   AddSettingsToResponse(checkin_response, new_settings, false);
 173
 174   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 175
 176   // Only the checkin interval was updated:
 177   EXPECT_EQ(base::TimeDelta::FromSeconds(86400),
 178             settings().GetCheckinInterval());
 179
 180   // Other settings still set to default.
 181   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
 182             settings().GetMCSMainEndpoint());
 183   EXPECT_EQ(GURL("https://mtalk.google.com:443"),
 184             settings().GetMCSFallbackEndpoint());
 185   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
 186   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
 187
 188   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 189             settings().digest());
 190 }
 191
 192 // Verifies that default registration URL can be selectively overwritten.
 193 TEST_F(GServicesSettingsTest, CheckinResponseUpdateRegistrationURL) {
 194   checkin_proto::AndroidCheckinResponse checkin_response;
 195   GServicesSettings::SettingsMap new_settings;
 196   new_settings["gcm_registration_url"] = "https://new.registration.url";
 197   AddSettingsToResponse(checkin_response, new_settings, false);
 198
 199   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 200
 201   // Only the registration URL was updated:
 202   EXPECT_EQ(GURL("https://new.registration.url"),
 203             settings().GetRegistrationURL());
 204
 205   // Other settings still set to default.
 206   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
 207             settings().GetCheckinInterval());
 208   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
 209             settings().GetMCSMainEndpoint());
 210   EXPECT_EQ(GURL("https://mtalk.google.com:443"),
 211             settings().GetMCSFallbackEndpoint());
 212   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
 213
 214   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 215             settings().digest());
 216 }
 217
 218 // Verifies that default checkin URL can be selectively overwritten.
 219 TEST_F(GServicesSettingsTest, CheckinResponseUpdateCheckinURL) {
 220   checkin_proto::AndroidCheckinResponse checkin_response;
 221   GServicesSettings::SettingsMap new_settings;
 222   new_settings["checkin_url"] = "https://new.checkin.url";
 223   AddSettingsToResponse(checkin_response, new_settings, false);
 224
 225   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 226
 227   // Only the checkin URL was updated:
 228   EXPECT_EQ(GURL("https://new.checkin.url"), settings().GetCheckinURL());
 229
 230   // Other settings still set to default.
 231   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
 232             settings().GetCheckinInterval());
 233   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
 234             settings().GetMCSMainEndpoint());
 235   EXPECT_EQ(GURL("https://mtalk.google.com:443"),
 236             settings().GetMCSFallbackEndpoint());
 237   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
 238
 239   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 240             settings().digest());
 241 }
 242
 243 // Verifies that default MCS hostname can be selectively overwritten.
 244 TEST_F(GServicesSettingsTest, CheckinResponseUpdateMCSHostname) {
 245   checkin_proto::AndroidCheckinResponse checkin_response;
 246   GServicesSettings::SettingsMap new_settings;
 247   new_settings["gcm_hostname"] = "new.gcm.hostname";
 248   AddSettingsToResponse(checkin_response, new_settings, false);
 249
 250   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 251
 252   // Only the MCS endpoints were updated:
 253   EXPECT_EQ(GURL("https://new.gcm.hostname:5228"),
 254             settings().GetMCSMainEndpoint());
 255   EXPECT_EQ(GURL("https://new.gcm.hostname:443"),
 256             settings().GetMCSFallbackEndpoint());
 257
 258   // Other settings still set to default.
 259   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
 260             settings().GetCheckinInterval());
 261   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
 262   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
 263
 264   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 265             settings().digest());
 266 }
 267
 268 // Verifies that default MCS secure port can be selectively overwritten.
 269 TEST_F(GServicesSettingsTest, CheckinResponseUpdateMCSSecurePort) {
 270   checkin_proto::AndroidCheckinResponse checkin_response;
 271   GServicesSettings::SettingsMap new_settings;
 272   new_settings["gcm_secure_port"] = "5229";
 273   AddSettingsToResponse(checkin_response, new_settings, false);
 274
 275   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 276
 277   // Only the main MCS endpoint was updated:
 278   EXPECT_EQ(GURL("https://mtalk.google.com:5229"),
 279             settings().GetMCSMainEndpoint());
 280
 281   // Other settings still set to default.
 282   EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultCheckinInterval),
 283             settings().GetCheckinInterval());
 284   EXPECT_EQ(GURL(kDefaultCheckinURL), settings().GetCheckinURL());
 285   EXPECT_EQ(GURL("https://mtalk.google.com:443"),
 286             settings().GetMCSFallbackEndpoint());
 287   EXPECT_EQ(GURL(kDefaultRegistrationURL), settings().GetRegistrationURL());
 288
 289   EXPECT_EQ(GServicesSettings::CalculateDigest(new_settings),
 290             settings().digest());
 291 }
 292
 293 // Update from checkin response should also do incremental update for both cases
 294 // where some settings are removed or added.
 295 TEST_F(GServicesSettingsTest, UpdateFromCheckinResponseSettingsDiff) {
 296   checkin_proto::AndroidCheckinResponse checkin_response;
 297
 298   // Only the new settings will be included in the response with settings diff.
 299   GServicesSettings::SettingsMap settings_diff;
 300   settings_diff["new_setting_1"] = "new_setting_1_value";
 301   settings_diff["new_setting_2"] = "new_setting_2_value";
 302   settings_diff["gcm_secure_port"] = "5229";
 303
 304   // Full settings are necessary to calculate digest.
 305   GServicesSettings::SettingsMap full_settings(settings_diff);
 306   std::string digest = GServicesSettings::CalculateDigest(full_settings);
 307
 308   checkin_response.Clear();
 309   AddSettingsToResponse(checkin_response, settings_diff, true);
 310   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 311   EXPECT_EQ(full_settings, settings().settings_map());
 312   // Default setting overwritten by settings diff.
 313   EXPECT_EQ(GURL("https://mtalk.google.com:5229"),
 314             settings().GetMCSMainEndpoint());
 315
 316   // Setting up diff removing some of the values (including default setting).
 317   settings_diff.clear();
 318   settings_diff["delete_new_setting_1"] = "";
 319   settings_diff["delete_gcm_secure_port"] = "";
 320   settings_diff["new_setting_3"] = "new_setting_3_value";
 321
 322   // Updating full settings to calculate digest.
 323   full_settings.erase(full_settings.find("new_setting_1"));
 324   full_settings.erase(full_settings.find("gcm_secure_port"));
 325   full_settings["new_setting_3"] = "new_setting_3_value";
 326   digest = GServicesSettings::CalculateDigest(full_settings);
 327
 328   checkin_response.Clear();
 329   AddSettingsToResponse(checkin_response, settings_diff, true);
 330   EXPECT_TRUE(settings().UpdateFromCheckinResponse(checkin_response));
 331   EXPECT_EQ(full_settings, settings().settings_map());
 332   // Default setting back to norm.
 333   EXPECT_EQ(GURL("https://mtalk.google.com:5228"),
 334             settings().GetMCSMainEndpoint());
 335 }
 336
 337 }  // namespace gcm