google_apis/google_api_keys_unittest.cc

   1 // Copyright (c) 2012 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 // Unit tests for implementation of google_api_keys namespace.
   6 //
   7 // Because the file deals with a lot of preprocessor defines and
   8 // optionally includes an internal header, the way we test is by
   9 // including the .cc file multiple times with different defines set.
  10 // This is a little unorthodox, but it lets us test the behavior as
  11 // close to unmodified as possible.
  12
  13 #include "google_apis/google_api_keys.h"
  14
  15 #include "build/build_config.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 // The Win builders fail (with a linker crash) when trying to link
  19 // unit_tests, and the Android builders complain about multiply
  20 // defined symbols (likely they don't do name decoration as well as
  21 // the Mac and Linux linkers).  Therefore these tests are only built
  22 // and run on Mac and Linux, which should provide plenty of coverage
  23 // since there are no platform-specific bits in this code.
  24 #if defined(OS_LINUX) || defined(OS_MACOSX)
  25
  26 // We need to include everything included by google_api_keys.cc once
  27 // at global scope so that things like STL and classes from base don't
  28 // get defined when we re-include the google_api_keys.cc file
  29 // below. We used to include that file in its entirety here, but that
  30 // can cause problems if the linker decides the version of symbols
  31 // from that file included here is the "right" version.
  32 #include <string>
  33 #include "base/command_line.h"
  34 #include "base/environment.h"
  35 #include "base/lazy_instance.h"
  36 #include "base/logging.h"
  37 #include "base/memory/scoped_ptr.h"
  38 #include "base/strings/stringize_macros.h"
  39
  40 // This is the default baked-in value for OAuth IDs and secrets.
  41 static const char kDummyToken[] = "dummytoken";
  42
  43 struct EnvironmentCache {
  44  public:
  45   EnvironmentCache() : variable_name(NULL), was_set(false) {}
  46
  47   const char* variable_name;
  48   bool was_set;
  49   std::string value;
  50 };
  51
  52 class GoogleAPIKeysTest : public testing::Test {
  53  public:
  54   GoogleAPIKeysTest() : env_(base::Environment::Create()) {
  55     env_cache_[0].variable_name = "GOOGLE_API_KEY";
  56     env_cache_[1].variable_name = "GOOGLE_CLIENT_ID_MAIN";
  57     env_cache_[2].variable_name = "GOOGLE_CLIENT_SECRET_MAIN";
  58     env_cache_[3].variable_name = "GOOGLE_CLIENT_ID_CLOUD_PRINT";
  59     env_cache_[4].variable_name = "GOOGLE_CLIENT_SECRET_CLOUD_PRINT";
  60     env_cache_[5].variable_name = "GOOGLE_CLIENT_ID_REMOTING";
  61     env_cache_[6].variable_name = "GOOGLE_CLIENT_SECRET_REMOTING";
  62     env_cache_[7].variable_name = "GOOGLE_DEFAULT_CLIENT_ID";
  63     env_cache_[8].variable_name = "GOOGLE_DEFAULT_CLIENT_SECRET";
  64   }
  65
  66   virtual void SetUp() {
  67     // Unset all environment variables that can affect these tests,
  68     // for the duration of the tests.
  69     for (size_t i = 0; i < arraysize(env_cache_); ++i) {
  70       EnvironmentCache& cache = env_cache_[i];
  71       cache.was_set = env_->HasVar(cache.variable_name);
  72       cache.value.clear();
  73       if (cache.was_set) {
  74         env_->GetVar(cache.variable_name, &cache.value);
  75         env_->UnSetVar(cache.variable_name);
  76       }
  77     }
  78   }
  79
  80   virtual void TearDown() {
  81     // Restore environment.
  82     for (size_t i = 0; i < arraysize(env_cache_); ++i) {
  83       EnvironmentCache& cache = env_cache_[i];
  84       if (cache.was_set) {
  85         env_->SetVar(cache.variable_name, cache.value);
  86       }
  87     }
  88   }
  89
  90  private:
  91   scoped_ptr<base::Environment> env_;
  92
  93   // Why 3?  It is for GOOGLE_API_KEY, GOOGLE_DEFAULT_CLIENT_ID and
  94   // GOOGLE_DEFAULT_CLIENT_SECRET.
  95   //
  96   // Why 2 times CLIENT_NUM_ITEMS?  This is the number of different
  97   // clients in the OAuth2Client enumeration, and for each of these we
  98   // have both an ID and a secret.
  99   EnvironmentCache env_cache_[3 + 2 * google_apis::CLIENT_NUM_ITEMS];
 100 };
 101
 102 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
 103 // Test official build behavior, since we are in a checkout where this
 104 // is possible.
 105 namespace official_build {
 106
 107 // We start every test by creating a clean environment for the
 108 // preprocessor defines used in google_api_keys.cc
 109 #undef DUMMY_API_TOKEN
 110 #undef GOOGLE_API_KEY
 111 #undef GOOGLE_CLIENT_ID_MAIN
 112 #undef GOOGLE_CLIENT_SECRET_MAIN
 113 #undef GOOGLE_CLIENT_ID_CLOUD_PRINT
 114 #undef GOOGLE_CLIENT_SECRET_CLOUD_PRINT
 115 #undef GOOGLE_CLIENT_ID_REMOTING
 116 #undef GOOGLE_CLIENT_SECRET_REMOTING
 117 #undef GOOGLE_DEFAULT_CLIENT_ID
 118 #undef GOOGLE_DEFAULT_CLIENT_SECRET
 119
 120 // Try setting some keys, these should be ignored since it's a build
 121 // with official keys.
 122 #define GOOGLE_API_KEY "bogus api_key"
 123 #define GOOGLE_CLIENT_ID_MAIN "bogus client_id_main"
 124
 125 // Undef include guard so things get defined again, within this namespace.
 126 #undef GOOGLE_APIS_GOOGLE_API_KEYS_H_
 127 #undef GOOGLE_APIS_INTERNAL_GOOGLE_CHROME_API_KEYS_
 128 #include "google_apis/google_api_keys.cc"
 129
 130 }  // namespace official_build
 131
 132 TEST_F(GoogleAPIKeysTest, OfficialKeys) {
 133   namespace testcase = official_build::google_apis;
 134
 135   EXPECT_TRUE(testcase::HasKeysConfigured());
 136
 137   std::string api_key = testcase::g_api_key_cache.Get().api_key();
 138   std::string id_main = testcase::g_api_key_cache.Get().GetClientID(
 139       testcase::CLIENT_MAIN);
 140   std::string secret_main = testcase::g_api_key_cache.Get().GetClientSecret(
 141       testcase::CLIENT_MAIN);
 142   std::string id_cloud_print =
 143       testcase::g_api_key_cache.Get().GetClientID(
 144           testcase::CLIENT_CLOUD_PRINT);
 145   std::string secret_cloud_print =
 146       testcase::g_api_key_cache.Get().GetClientSecret(
 147           testcase::CLIENT_CLOUD_PRINT);
 148   std::string id_remoting = testcase::g_api_key_cache.Get().GetClientID(
 149       testcase::CLIENT_REMOTING);
 150   std::string secret_remoting =
 151       testcase::g_api_key_cache.Get().GetClientSecret(
 152           testcase::CLIENT_REMOTING);
 153
 154   EXPECT_NE(0u, api_key.size());
 155   EXPECT_NE(DUMMY_API_TOKEN, api_key);
 156   EXPECT_NE("bogus api_key", api_key);
 157   EXPECT_NE(kDummyToken, api_key);
 158
 159   EXPECT_NE(0u, id_main.size());
 160   EXPECT_NE(DUMMY_API_TOKEN, id_main);
 161   EXPECT_NE("bogus client_id_main", id_main);
 162   EXPECT_NE(kDummyToken, id_main);
 163
 164   EXPECT_NE(0u, secret_main.size());
 165   EXPECT_NE(DUMMY_API_TOKEN, secret_main);
 166   EXPECT_NE(kDummyToken, secret_main);
 167
 168   EXPECT_NE(0u, id_cloud_print.size());
 169   EXPECT_NE(DUMMY_API_TOKEN, id_cloud_print);
 170   EXPECT_NE(kDummyToken, id_cloud_print);
 171
 172   EXPECT_NE(0u, secret_cloud_print.size());
 173   EXPECT_NE(DUMMY_API_TOKEN, secret_cloud_print);
 174   EXPECT_NE(kDummyToken, secret_cloud_print);
 175
 176   EXPECT_NE(0u, id_remoting.size());
 177   EXPECT_NE(DUMMY_API_TOKEN, id_remoting);
 178   EXPECT_NE(kDummyToken, id_remoting);
 179
 180   EXPECT_NE(0u, secret_remoting.size());
 181   EXPECT_NE(DUMMY_API_TOKEN, secret_remoting);
 182   EXPECT_NE(kDummyToken, secret_remoting);
 183 }
 184 #endif  // defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
 185
 186 // After this test, for the remainder of this compilation unit, we
 187 // need official keys to not be used.
 188 #undef GOOGLE_CHROME_BUILD
 189 #undef USE_OFFICIAL_GOOGLE_API_KEYS
 190
 191 // Test the set of keys temporarily baked into Chromium by default.
 192 namespace default_keys {
 193
 194 // We start every test by creating a clean environment for the
 195 // preprocessor defines used in google_api_keys.cc
 196 #undef DUMMY_API_TOKEN
 197 #undef GOOGLE_API_KEY
 198 #undef GOOGLE_CLIENT_ID_MAIN
 199 #undef GOOGLE_CLIENT_SECRET_MAIN
 200 #undef GOOGLE_CLIENT_ID_CLOUD_PRINT
 201 #undef GOOGLE_CLIENT_SECRET_CLOUD_PRINT
 202 #undef GOOGLE_CLIENT_ID_REMOTING
 203 #undef GOOGLE_CLIENT_SECRET_REMOTING
 204 #undef GOOGLE_DEFAULT_CLIENT_ID
 205 #undef GOOGLE_DEFAULT_CLIENT_SECRET
 206
 207 // Undef include guard so things get defined again, within this namespace.
 208 #undef GOOGLE_APIS_GOOGLE_API_KEYS_H_
 209 #undef GOOGLE_APIS_INTERNAL_GOOGLE_CHROME_API_KEYS_
 210 #include "google_apis/google_api_keys.cc"
 211
 212 }  // namespace default_keys
 213
 214 TEST_F(GoogleAPIKeysTest, DefaultKeys) {
 215   namespace testcase = default_keys::google_apis;
 216
 217   EXPECT_FALSE(testcase::HasKeysConfigured());
 218
 219   std::string api_key = testcase::g_api_key_cache.Get().api_key();
 220   std::string id_main = testcase::g_api_key_cache.Get().GetClientID(
 221       testcase::CLIENT_MAIN);
 222   std::string secret_main = testcase::g_api_key_cache.Get().GetClientSecret(
 223       testcase::CLIENT_MAIN);
 224   std::string id_cloud_print =
 225       testcase::g_api_key_cache.Get().GetClientID(
 226           testcase::CLIENT_CLOUD_PRINT);
 227   std::string secret_cloud_print =
 228       testcase::g_api_key_cache.Get().GetClientSecret(
 229           testcase::CLIENT_CLOUD_PRINT);
 230   std::string id_remoting = testcase::g_api_key_cache.Get().GetClientID(
 231       testcase::CLIENT_REMOTING);
 232   std::string secret_remoting =
 233       testcase::g_api_key_cache.Get().GetClientSecret(
 234           testcase::CLIENT_REMOTING);
 235
 236   EXPECT_EQ(kDummyToken, api_key);
 237   EXPECT_EQ(kDummyToken, id_main);
 238   EXPECT_EQ(kDummyToken, secret_main);
 239   EXPECT_EQ(kDummyToken, id_cloud_print);
 240   EXPECT_EQ(kDummyToken, secret_cloud_print);
 241   EXPECT_EQ(kDummyToken, id_remoting);
 242   EXPECT_EQ(kDummyToken, secret_remoting);
 243 }
 244
 245 // Override a couple of keys, leave the rest default.
 246 namespace override_some_keys {
 247
 248 // We start every test by creating a clean environment for the
 249 // preprocessor defines used in google_api_keys.cc
 250 #undef DUMMY_API_TOKEN
 251 #undef GOOGLE_API_KEY
 252 #undef GOOGLE_CLIENT_ID_MAIN
 253 #undef GOOGLE_CLIENT_SECRET_MAIN
 254 #undef GOOGLE_CLIENT_ID_CLOUD_PRINT
 255 #undef GOOGLE_CLIENT_SECRET_CLOUD_PRINT
 256 #undef GOOGLE_CLIENT_ID_REMOTING
 257 #undef GOOGLE_CLIENT_SECRET_REMOTING
 258 #undef GOOGLE_DEFAULT_CLIENT_ID
 259 #undef GOOGLE_DEFAULT_CLIENT_SECRET
 260
 261 #define GOOGLE_API_KEY "API_KEY override"
 262 #define GOOGLE_CLIENT_ID_REMOTING "CLIENT_ID_REMOTING override"
 263
 264 // Undef include guard so things get defined again, within this namespace.
 265 #undef GOOGLE_APIS_GOOGLE_API_KEYS_H_
 266 #undef GOOGLE_APIS_INTERNAL_GOOGLE_CHROME_API_KEYS_
 267 #include "google_apis/google_api_keys.cc"
 268
 269 }  // namespace override_some_keys
 270
 271 TEST_F(GoogleAPIKeysTest, OverrideSomeKeys) {
 272   namespace testcase = override_some_keys::google_apis;
 273
 274   EXPECT_FALSE(testcase::HasKeysConfigured());
 275
 276   std::string api_key = testcase::g_api_key_cache.Get().api_key();
 277   std::string id_main = testcase::g_api_key_cache.Get().GetClientID(
 278       testcase::CLIENT_MAIN);
 279   std::string secret_main = testcase::g_api_key_cache.Get().GetClientSecret(
 280       testcase::CLIENT_MAIN);
 281   std::string id_cloud_print =
 282       testcase::g_api_key_cache.Get().GetClientID(
 283           testcase::CLIENT_CLOUD_PRINT);
 284   std::string secret_cloud_print =
 285       testcase::g_api_key_cache.Get().GetClientSecret(
 286           testcase::CLIENT_CLOUD_PRINT);
 287   std::string id_remoting = testcase::g_api_key_cache.Get().GetClientID(
 288       testcase::CLIENT_REMOTING);
 289   std::string secret_remoting =
 290       testcase::g_api_key_cache.Get().GetClientSecret(
 291           testcase::CLIENT_REMOTING);
 292
 293   EXPECT_EQ("API_KEY override", api_key);
 294   EXPECT_EQ(kDummyToken, id_main);
 295   EXPECT_EQ(kDummyToken, secret_main);
 296   EXPECT_EQ(kDummyToken, id_cloud_print);
 297   EXPECT_EQ(kDummyToken, secret_cloud_print);
 298   EXPECT_EQ("CLIENT_ID_REMOTING override", id_remoting);
 299   EXPECT_EQ(kDummyToken, secret_remoting);
 300 }
 301
 302 // Override all keys.
 303 namespace override_all_keys {
 304
 305 // We start every test by creating a clean environment for the
 306 // preprocessor defines used in google_api_keys.cc
 307 #undef DUMMY_API_TOKEN
 308 #undef GOOGLE_API_KEY
 309 #undef GOOGLE_CLIENT_ID_MAIN
 310 #undef GOOGLE_CLIENT_SECRET_MAIN
 311 #undef GOOGLE_CLIENT_ID_CLOUD_PRINT
 312 #undef GOOGLE_CLIENT_SECRET_CLOUD_PRINT
 313 #undef GOOGLE_CLIENT_ID_REMOTING
 314 #undef GOOGLE_CLIENT_SECRET_REMOTING
 315 #undef GOOGLE_DEFAULT_CLIENT_ID
 316 #undef GOOGLE_DEFAULT_CLIENT_SECRET
 317
 318 #define GOOGLE_API_KEY "API_KEY"
 319 #define GOOGLE_CLIENT_ID_MAIN "ID_MAIN"
 320 #define GOOGLE_CLIENT_SECRET_MAIN "SECRET_MAIN"
 321 #define GOOGLE_CLIENT_ID_CLOUD_PRINT "ID_CLOUD_PRINT"
 322 #define GOOGLE_CLIENT_SECRET_CLOUD_PRINT "SECRET_CLOUD_PRINT"
 323 #define GOOGLE_CLIENT_ID_REMOTING "ID_REMOTING"
 324 #define GOOGLE_CLIENT_SECRET_REMOTING "SECRET_REMOTING"
 325
 326 // Undef include guard so things get defined again, within this namespace.
 327 #undef GOOGLE_APIS_GOOGLE_API_KEYS_H_
 328 #undef GOOGLE_APIS_INTERNAL_GOOGLE_CHROME_API_KEYS_
 329 #include "google_apis/google_api_keys.cc"
 330
 331 }  // namespace override_all_keys
 332
 333 TEST_F(GoogleAPIKeysTest, OverrideAllKeys) {
 334   namespace testcase = override_all_keys::google_apis;
 335
 336   EXPECT_TRUE(testcase::HasKeysConfigured());
 337
 338   std::string api_key = testcase::g_api_key_cache.Get().api_key();
 339   std::string id_main = testcase::g_api_key_cache.Get().GetClientID(
 340       testcase::CLIENT_MAIN);
 341   std::string secret_main = testcase::g_api_key_cache.Get().GetClientSecret(
 342       testcase::CLIENT_MAIN);
 343   std::string id_cloud_print =
 344       testcase::g_api_key_cache.Get().GetClientID(
 345           testcase::CLIENT_CLOUD_PRINT);
 346   std::string secret_cloud_print =
 347       testcase::g_api_key_cache.Get().GetClientSecret(
 348           testcase::CLIENT_CLOUD_PRINT);
 349   std::string id_remoting = testcase::g_api_key_cache.Get().GetClientID(
 350       testcase::CLIENT_REMOTING);
 351   std::string secret_remoting =
 352       testcase::g_api_key_cache.Get().GetClientSecret(
 353           testcase::CLIENT_REMOTING);
 354
 355   EXPECT_EQ("API_KEY", api_key);
 356   EXPECT_EQ("ID_MAIN", id_main);
 357   EXPECT_EQ("SECRET_MAIN", secret_main);
 358   EXPECT_EQ("ID_CLOUD_PRINT", id_cloud_print);
 359   EXPECT_EQ("SECRET_CLOUD_PRINT", secret_cloud_print);
 360   EXPECT_EQ("ID_REMOTING", id_remoting);
 361   EXPECT_EQ("SECRET_REMOTING", secret_remoting);
 362 }
 363
 364 // Override all keys using both preprocessor defines and environment
 365 // variables.  The environment variables should win.
 366 namespace override_all_keys_env {
 367
 368 // We start every test by creating a clean environment for the
 369 // preprocessor defines used in google_api_keys.cc
 370 #undef DUMMY_API_TOKEN
 371 #undef GOOGLE_API_KEY
 372 #undef GOOGLE_CLIENT_ID_MAIN
 373 #undef GOOGLE_CLIENT_SECRET_MAIN
 374 #undef GOOGLE_CLIENT_ID_CLOUD_PRINT
 375 #undef GOOGLE_CLIENT_SECRET_CLOUD_PRINT
 376 #undef GOOGLE_CLIENT_ID_REMOTING
 377 #undef GOOGLE_CLIENT_SECRET_REMOTING
 378 #undef GOOGLE_DEFAULT_CLIENT_ID
 379 #undef GOOGLE_DEFAULT_CLIENT_SECRET
 380
 381 #define GOOGLE_API_KEY "API_KEY"
 382 #define GOOGLE_CLIENT_ID_MAIN "ID_MAIN"
 383 #define GOOGLE_CLIENT_SECRET_MAIN "SECRET_MAIN"
 384 #define GOOGLE_CLIENT_ID_CLOUD_PRINT "ID_CLOUD_PRINT"
 385 #define GOOGLE_CLIENT_SECRET_CLOUD_PRINT "SECRET_CLOUD_PRINT"
 386 #define GOOGLE_CLIENT_ID_REMOTING "ID_REMOTING"
 387 #define GOOGLE_CLIENT_SECRET_REMOTING "SECRET_REMOTING"
 388
 389 // Undef include guard so things get defined again, within this namespace.
 390 #undef GOOGLE_APIS_GOOGLE_API_KEYS_H_
 391 #undef GOOGLE_APIS_INTERNAL_GOOGLE_CHROME_API_KEYS_
 392 #include "google_apis/google_api_keys.cc"
 393
 394 }  // namespace override_all_keys_env
 395
 396 TEST_F(GoogleAPIKeysTest, OverrideAllKeysUsingEnvironment) {
 397   namespace testcase = override_all_keys_env::google_apis;
 398
 399   scoped_ptr<base::Environment> env(base::Environment::Create());
 400   env->SetVar("GOOGLE_API_KEY", "env-API_KEY");
 401   env->SetVar("GOOGLE_CLIENT_ID_MAIN", "env-ID_MAIN");
 402   env->SetVar("GOOGLE_CLIENT_ID_CLOUD_PRINT", "env-ID_CLOUD_PRINT");
 403   env->SetVar("GOOGLE_CLIENT_ID_REMOTING", "env-ID_REMOTING");
 404   env->SetVar("GOOGLE_CLIENT_SECRET_MAIN", "env-SECRET_MAIN");
 405   env->SetVar("GOOGLE_CLIENT_SECRET_CLOUD_PRINT", "env-SECRET_CLOUD_PRINT");
 406   env->SetVar("GOOGLE_CLIENT_SECRET_REMOTING", "env-SECRET_REMOTING");
 407
 408   EXPECT_TRUE(testcase::HasKeysConfigured());
 409
 410   // It's important that the first call to Get() only happen after the
 411   // environment variables have been set.
 412   std::string api_key = testcase::g_api_key_cache.Get().api_key();
 413   std::string id_main = testcase::g_api_key_cache.Get().GetClientID(
 414       testcase::CLIENT_MAIN);
 415   std::string secret_main = testcase::g_api_key_cache.Get().GetClientSecret(
 416       testcase::CLIENT_MAIN);
 417   std::string id_cloud_print =
 418       testcase::g_api_key_cache.Get().GetClientID(
 419           testcase::CLIENT_CLOUD_PRINT);
 420   std::string secret_cloud_print =
 421       testcase::g_api_key_cache.Get().GetClientSecret(
 422           testcase::CLIENT_CLOUD_PRINT);
 423   std::string id_remoting = testcase::g_api_key_cache.Get().GetClientID(
 424       testcase::CLIENT_REMOTING);
 425   std::string secret_remoting =
 426       testcase::g_api_key_cache.Get().GetClientSecret(
 427           testcase::CLIENT_REMOTING);
 428
 429   EXPECT_EQ("env-API_KEY", api_key);
 430   EXPECT_EQ("env-ID_MAIN", id_main);
 431   EXPECT_EQ("env-SECRET_MAIN", secret_main);
 432   EXPECT_EQ("env-ID_CLOUD_PRINT", id_cloud_print);
 433   EXPECT_EQ("env-SECRET_CLOUD_PRINT", secret_cloud_print);
 434   EXPECT_EQ("env-ID_REMOTING", id_remoting);
 435   EXPECT_EQ("env-SECRET_REMOTING", secret_remoting);
 436 }
 437
 438 #endif  // defined(OS_LINUX) || defined(OS_MACOSX)