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) 499
