remoting/test/app_remoting_test_driver_environment_unittest.cc

   1 // Copyright 2015 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 "remoting/test/app_remoting_test_driver_environment.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/files/file_path.h"
  10 #include "remoting/test/fake_access_token_fetcher.h"
  11 #include "remoting/test/fake_app_remoting_report_issue_request.h"
  12 #include "remoting/test/fake_refresh_token_store.h"
  13 #include "remoting/test/fake_remote_host_info_fetcher.h"
  14 #include "remoting/test/mock_access_token_fetcher.h"
  15 #include "remoting/test/refresh_token_store.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace {
  20 const char kAuthCodeValue[] = "4/892379827345jkefvkdfbv";
  21 const char kUserNameValue[] = "remoting_user@gmail.com";
  22 const char kTestApplicationId[] = "sadlkjlsjgadjfgoajdfgagb";
  23 const char kAnotherTestApplicationId[] = "waklgoisdhfnvjkdsfbljn";
  24 const char kTestHostId1[] = "awesome_test_host_id";
  25 const char kTestHostId2[] = "super_awesome_test_host_id";
  26 const char kTestHostId3[] = "uber_awesome_test_host_id";
  27 }
  28
  29 namespace remoting {
  30 namespace test {
  31
  32 using testing::_;
  33
  34 class AppRemotingTestDriverEnvironmentTest : public ::testing::Test {
  35  public:
  36   AppRemotingTestDriverEnvironmentTest();
  37   ~AppRemotingTestDriverEnvironmentTest() override;
  38
  39   FakeAccessTokenFetcher* fake_access_token_fetcher() const {
  40     return fake_access_token_fetcher_;
  41   }
  42
  43  protected:
  44   void Initialize();
  45   void Initialize(
  46       const AppRemotingTestDriverEnvironment::EnvironmentOptions& options);
  47
  48   FakeAccessTokenFetcher* fake_access_token_fetcher_;
  49   FakeAppRemotingReportIssueRequest fake_report_issue_request_;
  50   FakeRefreshTokenStore fake_token_store_;
  51   FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher_;
  52   MockAccessTokenFetcher mock_access_token_fetcher_;
  53
  54   scoped_ptr<AppRemotingTestDriverEnvironment> environment_object_;
  55
  56  private:
  57   DISALLOW_COPY_AND_ASSIGN(AppRemotingTestDriverEnvironmentTest);
  58 };
  59
  60 AppRemotingTestDriverEnvironmentTest::AppRemotingTestDriverEnvironmentTest()
  61     : fake_access_token_fetcher_(nullptr) {
  62 }
  63
  64 AppRemotingTestDriverEnvironmentTest::~AppRemotingTestDriverEnvironmentTest() {
  65 }
  66
  67 void AppRemotingTestDriverEnvironmentTest::Initialize() {
  68   AppRemotingTestDriverEnvironment::EnvironmentOptions options;
  69   options.user_name = kUserNameValue;
  70   options.service_environment = kDeveloperEnvironment;
  71
  72   Initialize(options);
  73 }
  74
  75 void AppRemotingTestDriverEnvironmentTest::Initialize(
  76     const AppRemotingTestDriverEnvironment::EnvironmentOptions& options) {
  77   environment_object_.reset(new AppRemotingTestDriverEnvironment(options));
  78
  79   scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
  80       new FakeAccessTokenFetcher());
  81   fake_access_token_fetcher_ = fake_access_token_fetcher.get();
  82   mock_access_token_fetcher_.SetAccessTokenFetcher(
  83       fake_access_token_fetcher.Pass());
  84
  85   environment_object_->SetAccessTokenFetcherForTest(
  86       &mock_access_token_fetcher_);
  87   environment_object_->SetAppRemotingReportIssueRequestForTest(
  88       &fake_report_issue_request_);
  89   environment_object_->SetRefreshTokenStoreForTest(&fake_token_store_);
  90   environment_object_->SetRemoteHostInfoFetcherForTest(
  91       &fake_remote_host_info_fetcher_);
  92 }
  93
  94 TEST_F(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCode) {
  95   Initialize();
  96
  97   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _));
  98
  99   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _))
 100       .Times(0);
 101
 102   EXPECT_TRUE(environment_object_->Initialize(kAuthCodeValue));
 103   EXPECT_TRUE(fake_token_store_.refresh_token_write_attempted());
 104   EXPECT_EQ(fake_token_store_.stored_refresh_token_value(),
 105             kFakeAccessTokenFetcherRefreshTokenValue);
 106   EXPECT_EQ(environment_object_->user_name(), kUserNameValue);
 107   EXPECT_EQ(environment_object_->access_token(),
 108             kFakeAccessTokenFetcherAccessTokenValue);
 109
 110   // Attempt to init again, we should not see any additional calls or errors.
 111   EXPECT_TRUE(environment_object_->Initialize(kAuthCodeValue));
 112 }
 113
 114 TEST_F(AppRemotingTestDriverEnvironmentTest,
 115        InitializeObjectWithAuthCodeFailed) {
 116   Initialize();
 117
 118   fake_access_token_fetcher()->set_fail_access_token_from_auth_code(true);
 119
 120   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _));
 121
 122   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _))
 123       .Times(0);
 124
 125   EXPECT_FALSE(environment_object_->Initialize(kAuthCodeValue));
 126   EXPECT_FALSE(fake_token_store_.refresh_token_write_attempted());
 127 }
 128
 129 TEST_F(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithRefreshToken) {
 130   Initialize();
 131
 132   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _));
 133
 134   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _))
 135       .Times(0);
 136
 137   // Pass in an empty auth code since we are using a refresh token.
 138   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 139
 140   // We should not write the refresh token a second time if we read from the
 141   // disk originally.
 142   EXPECT_FALSE(fake_token_store_.refresh_token_write_attempted());
 143
 144   // Verify the object was initialized correctly.
 145   EXPECT_EQ(environment_object_->user_name(), kUserNameValue);
 146   EXPECT_EQ(environment_object_->access_token(),
 147             kFakeAccessTokenFetcherAccessTokenValue);
 148
 149   // Attempt to init again, we should not see any additional calls or errors.
 150   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 151 }
 152
 153 TEST_F(AppRemotingTestDriverEnvironmentTest, TearDownAfterInitializeSucceeds) {
 154   Initialize();
 155
 156   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _));
 157
 158   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _))
 159       .Times(0);
 160
 161   // Pass in an empty auth code since we are using a refresh token.
 162   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 163
 164   // Note: We are using a static cast here because the TearDown() method is
 165   //       private as it is an interface method that we only want to call
 166   //       directly in tests or by the GTEST framework.
 167   static_cast<testing::Environment*>(environment_object_.get())->TearDown();
 168 }
 169
 170 TEST_F(AppRemotingTestDriverEnvironmentTest,
 171        InitializeObjectWithRefreshTokenFailed) {
 172   Initialize();
 173
 174   fake_access_token_fetcher()->set_fail_access_token_from_refresh_token(true);
 175
 176   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _));
 177
 178   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _))
 179       .Times(0);
 180
 181   // Pass in an empty auth code since we are using a refresh token.
 182   EXPECT_FALSE(environment_object_->Initialize(std::string()));
 183   EXPECT_FALSE(fake_token_store_.refresh_token_write_attempted());
 184 }
 185
 186 TEST_F(AppRemotingTestDriverEnvironmentTest,
 187        InitializeObjectNoAuthCodeOrRefreshToken) {
 188   Initialize();
 189
 190   // Neither method should be called in this scenario.
 191   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _))
 192       .Times(0);
 193
 194   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _))
 195       .Times(0);
 196
 197   // Clear out the 'stored' refresh token value.
 198   fake_token_store_.set_refresh_token_value(std::string());
 199
 200   // With no auth code or refresh token, then the initialization should fail.
 201   EXPECT_FALSE(environment_object_->Initialize(std::string()));
 202   EXPECT_FALSE(fake_token_store_.refresh_token_write_attempted());
 203 }
 204
 205 TEST_F(AppRemotingTestDriverEnvironmentTest,
 206        InitializeObjectWithAuthCodeWriteFailed) {
 207   Initialize();
 208
 209   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _));
 210
 211   EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromRefreshToken(_, _))
 212       .Times(0);
 213
 214   // Simulate a failure writing the token to the disk.
 215   fake_token_store_.set_refresh_token_write_succeeded(false);
 216
 217   EXPECT_FALSE(environment_object_->Initialize(kAuthCodeValue));
 218   EXPECT_TRUE(fake_token_store_.refresh_token_write_attempted());
 219 }
 220
 221 TEST_F(AppRemotingTestDriverEnvironmentTest,
 222        RefreshAccessTokenAfterUsingAuthCode) {
 223   Initialize();
 224
 225   {
 226     testing::InSequence call_sequence;
 227
 228     EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _));
 229
 230     EXPECT_CALL(mock_access_token_fetcher_,
 231                 GetAccessTokenFromRefreshToken(_, _));
 232   }
 233
 234   EXPECT_TRUE(environment_object_->Initialize(kAuthCodeValue));
 235   EXPECT_TRUE(fake_token_store_.refresh_token_write_attempted());
 236   EXPECT_EQ(fake_token_store_.stored_refresh_token_value(),
 237             kFakeAccessTokenFetcherRefreshTokenValue);
 238   EXPECT_EQ(environment_object_->user_name(), kUserNameValue);
 239   EXPECT_EQ(environment_object_->access_token(),
 240             kFakeAccessTokenFetcherAccessTokenValue);
 241
 242   // Attempt to init again, we should not see any additional calls or errors.
 243   EXPECT_TRUE(environment_object_->RefreshAccessToken());
 244 }
 245
 246 TEST_F(AppRemotingTestDriverEnvironmentTest, RefreshAccessTokenFailure) {
 247   Initialize();
 248
 249   {
 250     testing::InSequence call_sequence;
 251
 252     // Mock is set up for this call to succeed.
 253     EXPECT_CALL(mock_access_token_fetcher_, GetAccessTokenFromAuthCode(_, _));
 254
 255     // Mock is set up for this call to fail.
 256     EXPECT_CALL(mock_access_token_fetcher_,
 257                 GetAccessTokenFromRefreshToken(_, _));
 258   }
 259
 260   EXPECT_TRUE(environment_object_->Initialize(kAuthCodeValue));
 261   EXPECT_TRUE(fake_token_store_.refresh_token_write_attempted());
 262   EXPECT_EQ(fake_token_store_.stored_refresh_token_value(),
 263             kFakeAccessTokenFetcherRefreshTokenValue);
 264   EXPECT_EQ(environment_object_->user_name(), kUserNameValue);
 265   EXPECT_EQ(environment_object_->access_token(),
 266             kFakeAccessTokenFetcherAccessTokenValue);
 267
 268   fake_access_token_fetcher()->set_fail_access_token_from_refresh_token(true);
 269
 270   // We expect the refresh to have failed, the user name to remain valid,
 271   // and the access token to have been cleared.
 272   EXPECT_FALSE(environment_object_->RefreshAccessToken());
 273   EXPECT_TRUE(environment_object_->access_token().empty());
 274   EXPECT_EQ(environment_object_->user_name(), kUserNameValue);
 275 }
 276
 277 TEST_F(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoSuccess) {
 278   Initialize();
 279
 280   // Pass in an empty auth code since we are using a refresh token.
 281   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 282
 283   RemoteHostInfo remote_host_info;
 284   EXPECT_TRUE(environment_object_->GetRemoteHostInfoForApplicationId(
 285       kTestApplicationId, &remote_host_info));
 286   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 287 }
 288
 289 TEST_F(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoFailure) {
 290   Initialize();
 291
 292   // Pass in an empty auth code since we are using a refresh token.
 293   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 294
 295   fake_remote_host_info_fetcher_.set_fail_retrieve_remote_host_info(true);
 296
 297   RemoteHostInfo remote_host_info;
 298   EXPECT_FALSE(environment_object_->GetRemoteHostInfoForApplicationId(
 299       kTestApplicationId, &remote_host_info));
 300 }
 301
 302 TEST_F(AppRemotingTestDriverEnvironmentTest,
 303        GetRemoteHostInfoWithoutInitializing) {
 304   Initialize();
 305
 306   RemoteHostInfo remote_host_info;
 307   EXPECT_FALSE(environment_object_->GetRemoteHostInfoForApplicationId(
 308       kTestApplicationId, &remote_host_info));
 309 }
 310
 311 TEST_F(AppRemotingTestDriverEnvironmentTest, NoRemoteHostsReleasedOnTearDown) {
 312   // Use the default options as the flag to release the remote hosts is not
 313   // enabled by default.
 314   Initialize();
 315
 316   // Pass in an empty auth code since we are using a refresh token.
 317   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 318
 319   RemoteHostInfo remote_host_info;
 320   EXPECT_TRUE(environment_object_->GetRemoteHostInfoForApplicationId(
 321       kTestApplicationId, &remote_host_info));
 322   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 323
 324   EXPECT_EQ(fake_report_issue_request_.get_host_ids_released().size(), 0UL);
 325
 326   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId1);
 327
 328   // Note: We are using a static cast here because the TearDown() method is
 329   //       private as it is an interface method that we only want to call
 330   //       directly in tests or by the GTEST framework.
 331   static_cast<testing::Environment*>(environment_object_.get())->TearDown();
 332
 333   // Verify no hosts were released via a report issue request.
 334   EXPECT_EQ(fake_report_issue_request_.get_host_ids_released().size(), 0UL);
 335 }
 336
 337 TEST_F(AppRemotingTestDriverEnvironmentTest, OneRemoteHostReleasedOnTearDown) {
 338   AppRemotingTestDriverEnvironment::EnvironmentOptions options;
 339   options.user_name = kUserNameValue;
 340   options.release_hosts_when_done = true;
 341   options.service_environment = kDeveloperEnvironment;
 342   Initialize(options);
 343
 344   // Pass in an empty auth code since we are using a refresh token.
 345   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 346
 347   RemoteHostInfo remote_host_info;
 348   EXPECT_TRUE(environment_object_->GetRemoteHostInfoForApplicationId(
 349       kTestApplicationId, &remote_host_info));
 350   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 351
 352   EXPECT_EQ(fake_report_issue_request_.get_host_ids_released().size(), 0UL);
 353
 354   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId1);
 355
 356   // Note: We are using a static cast here because the TearDown() method is
 357   //       private as it is an interface method that we only want to call
 358   //       directly in tests or by the GTEST framework.
 359   static_cast<testing::Environment*>(environment_object_.get())->TearDown();
 360
 361   std::string expected_host(
 362       MakeFormattedStringForReleasedHost(kTestApplicationId, kTestHostId1));
 363   std::vector<std::string> actual_host_list =
 364       fake_report_issue_request_.get_host_ids_released();
 365
 366   EXPECT_EQ(actual_host_list.size(), 1UL);
 367   EXPECT_EQ(actual_host_list[0], expected_host);
 368 }
 369
 370 TEST_F(AppRemotingTestDriverEnvironmentTest, RemoteHostsReleasedOnTearDown) {
 371   AppRemotingTestDriverEnvironment::EnvironmentOptions options;
 372   options.user_name = kUserNameValue;
 373   options.release_hosts_when_done = true;
 374   options.service_environment = kDeveloperEnvironment;
 375   Initialize(options);
 376
 377   // Pass in an empty auth code since we are using a refresh token.
 378   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 379
 380   RemoteHostInfo remote_host_info;
 381   EXPECT_TRUE(environment_object_->GetRemoteHostInfoForApplicationId(
 382       kTestApplicationId, &remote_host_info));
 383   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 384
 385   std::vector<std::string> expected_host_list;
 386   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId1);
 387   expected_host_list.push_back(
 388       MakeFormattedStringForReleasedHost(kTestApplicationId, kTestHostId1));
 389
 390   environment_object_->AddHostToReleaseList(kAnotherTestApplicationId,
 391                                             kTestHostId2);
 392   expected_host_list.push_back(MakeFormattedStringForReleasedHost(
 393       kAnotherTestApplicationId, kTestHostId2));
 394
 395   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId3);
 396   expected_host_list.push_back(
 397       MakeFormattedStringForReleasedHost(kTestApplicationId, kTestHostId3));
 398
 399   // Note: We are using a static cast here because the TearDown() method is
 400   //       private as it is an interface method that we only want to call
 401   //       directly in tests or by the GTEST framework.
 402   static_cast<testing::Environment*>(environment_object_.get())->TearDown();
 403
 404   std::vector<std::string> actual_host_list =
 405       fake_report_issue_request_.get_host_ids_released();
 406
 407   std::sort(actual_host_list.begin(), actual_host_list.end());
 408   std::sort(expected_host_list.begin(), expected_host_list.end());
 409
 410   EXPECT_EQ(actual_host_list.size(), expected_host_list.size());
 411   for (size_t i = 0; i < actual_host_list.size(); ++i) {
 412     EXPECT_EQ(actual_host_list[i], expected_host_list[i]);
 413   }
 414 }
 415
 416 TEST_F(AppRemotingTestDriverEnvironmentTest, RemoteHostsReleasedOnce) {
 417   AppRemotingTestDriverEnvironment::EnvironmentOptions options;
 418   options.user_name = kUserNameValue;
 419   options.release_hosts_when_done = true;
 420   options.service_environment = kDeveloperEnvironment;
 421   Initialize(options);
 422
 423   // Pass in an empty auth code since we are using a refresh token.
 424   EXPECT_TRUE(environment_object_->Initialize(std::string()));
 425
 426   RemoteHostInfo remote_host_info;
 427   EXPECT_TRUE(environment_object_->GetRemoteHostInfoForApplicationId(
 428       kTestApplicationId, &remote_host_info));
 429   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 430
 431   std::vector<std::string> expected_host_list;
 432   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId1);
 433   expected_host_list.push_back(
 434       MakeFormattedStringForReleasedHost(kTestApplicationId, kTestHostId1));
 435
 436   environment_object_->AddHostToReleaseList(kAnotherTestApplicationId,
 437                                             kTestHostId2);
 438   expected_host_list.push_back(MakeFormattedStringForReleasedHost(
 439       kAnotherTestApplicationId, kTestHostId2));
 440
 441   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId3);
 442   expected_host_list.push_back(
 443       MakeFormattedStringForReleasedHost(kTestApplicationId, kTestHostId3));
 444
 445   // Attempt to add the previous hosts again, they should not be added since
 446   // they will already exist in the list of hosts to release.
 447   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId1);
 448   environment_object_->AddHostToReleaseList(kAnotherTestApplicationId,
 449                                             kTestHostId2);
 450   environment_object_->AddHostToReleaseList(kTestApplicationId, kTestHostId3);
 451
 452   // Note: We are using a static cast here because the TearDown() method is
 453   //       private as it is an interface method that we only want to call
 454   //       directly in tests or by the GTEST framework.
 455   static_cast<testing::Environment*>(environment_object_.get())->TearDown();
 456
 457   std::vector<std::string> actual_host_list =
 458       fake_report_issue_request_.get_host_ids_released();
 459
 460   std::sort(actual_host_list.begin(), actual_host_list.end());
 461   std::sort(expected_host_list.begin(), expected_host_list.end());
 462
 463   EXPECT_EQ(actual_host_list.size(), expected_host_list.size());
 464   for (size_t i = 0; i < actual_host_list.size(); ++i) {
 465     EXPECT_EQ(actual_host_list[i], expected_host_list[i]);
 466   }
 467 }
 468
 469 }  // namespace test
 470 }  // namespace remoting