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