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. 42static const char kDummyToken[] = "dummytoken"; 43 44struct 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 53class 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. 108namespace 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 137TEST_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. 210namespace 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 234TEST_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. 273namespace 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 300TEST_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. 339namespace 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 373TEST_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. 413namespace 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 447TEST_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