remoting/test/app_remoting_test_driver_environment_unittest.cc - chromium/src - Git at Google

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "remoting/test/app_remoting_test_driver_environment.h"

 #include "remoting/test/fake_access_token_fetcher.h"
 #include "remoting/test/fake_remote_host_info_fetcher.h"
 #include "remoting/test/mock_access_token_fetcher.h"
 #include "remoting/test/refresh_token_store.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {
 const char kAuthCodeValue[] = "4/892379827345jkefvkdfbv";
 const char kRefreshTokenValue[] = "1/lkjalseLKJlsiJgr45jbv";
 const char kUserNameValue[] = "remoting_user@gmail.com";
 const char kTestApplicationId[] = "sadlkjlsjgadjfgoajdfgagb";
 }

 namespace remoting {
 namespace test {

 using testing::_;

 // Stubs out the file API and returns fake data so we can remove
 // file system dependencies when testing the TestDriverEnvironment.
 class FakeRefreshTokenStore : public RefreshTokenStore {
  public:
   FakeRefreshTokenStore() :
       refresh_token_value(kRefreshTokenValue),
       refresh_token_write_succeeded(true),
       refresh_token_write_attempted(false) {}
   ~FakeRefreshTokenStore() override {}

   std::string FetchRefreshToken() override {
     return refresh_token_value;
   };

   bool StoreRefreshToken(const std::string& refresh_token) override {
     // Record the information passed to us to write.
     refresh_token_write_attempted = true;
     refresh_token_value_written = refresh_token;

     return refresh_token_write_succeeded;
   };

   // Control members used to return specific data to the caller.
   std::string refresh_token_value;
   bool refresh_token_write_succeeded;

   // Verification members to observe the value of the data being written.
   bool refresh_token_write_attempted;
   std::string refresh_token_value_written;

  private:
   DISALLOW_COPY_AND_ASSIGN(FakeRefreshTokenStore);
 };

 TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCode) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(new FakeAccessTokenFetcher()));

   FakeRefreshTokenStore fake_token_store;

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(1);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   bool init_result = environment_object.Initialize(kAuthCodeValue);

   EXPECT_TRUE(init_result);
   EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
   EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
       kFakeAccessTokenFetcherRefreshTokenValue), 0);
   EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
   EXPECT_EQ(environment_object.access_token().compare(
       kFakeAccessTokenFetcherAccessTokenValue), 0);

   // Attempt to init again, we should not see any additional calls or errors.
   init_result = environment_object.Initialize(kAuthCodeValue);
   EXPECT_TRUE(init_result);
 }

 TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCodeFailed) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
       new FakeAccessTokenFetcher());

   fake_access_token_fetcher->set_fail_access_token_from_auth_code(true);

   mock_access_token_fetcher.SetAccessTokenFetcher(
       fake_access_token_fetcher.Pass());

   FakeRefreshTokenStore fake_token_store;

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(1);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   bool init_result = environment_object.Initialize(kAuthCodeValue);

   EXPECT_FALSE(init_result);
   EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
 }

 TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithRefreshToken) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(new FakeAccessTokenFetcher()));

   FakeRefreshTokenStore fake_token_store;

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(1);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Pass in an empty auth code since we are using a refresh token.
   bool init_result = environment_object.Initialize(std::string());

   EXPECT_TRUE(init_result);

   // We should not write the refresh token a second time if we read from the
   // disk originally.
   EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);

   // Verify the object was initialized correctly.
   EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
   EXPECT_EQ(environment_object.access_token().compare(
       kFakeAccessTokenFetcherAccessTokenValue), 0);

   // Attempt to init again, we should not see any additional calls or errors.
   init_result = environment_object.Initialize(std::string());
   EXPECT_TRUE(init_result);
 }

 TEST(AppRemotingTestDriverEnvironmentTest,
      InitializeObjectWithRefreshTokenFailed) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
       new FakeAccessTokenFetcher());

   fake_access_token_fetcher->set_fail_access_token_from_refresh_token(true);

   mock_access_token_fetcher.SetAccessTokenFetcher(
       fake_access_token_fetcher.Pass());

   FakeRefreshTokenStore fake_token_store;

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(1);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Pass in an empty auth code since we are using a refresh token.
   bool init_result = environment_object.Initialize(std::string());

   EXPECT_FALSE(init_result);
   EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
 }

 TEST(AppRemotingTestDriverEnvironmentTest,
      InitializeObjectNoAuthCodeOrRefreshToken) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(new FakeAccessTokenFetcher()));

   FakeRefreshTokenStore fake_token_store;

   // Neither method should be called in this scenario.
   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(0);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Clear out the 'stored' refresh token value.
   fake_token_store.refresh_token_value = "";

   // Pass in an empty auth code.
   bool init_result = environment_object.Initialize(std::string());

   // With no auth code or refresh token, then the initialization should fail.
   EXPECT_FALSE(init_result);
   EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
 }

 TEST(AppRemotingTestDriverEnvironmentTest,
      InitializeObjectWithAuthCodeWriteFailed) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(new FakeAccessTokenFetcher()));

   FakeRefreshTokenStore fake_token_store;

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
       .Times(1);

   EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
       .Times(0);

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Simulate a failure writing the token to the disk.
   fake_token_store.refresh_token_write_succeeded = false;

   bool init_result = environment_object.Initialize(kAuthCodeValue);

   EXPECT_FALSE(init_result);
   EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
 }

 TEST(AppRemotingTestDriverEnvironmentTest,
      RefreshAccessTokenAfterUsingAuthCode) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(new FakeAccessTokenFetcher()));

   FakeRefreshTokenStore fake_token_store;

   {
     testing::Sequence call_sequence;

     EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
         .Times(1);

     EXPECT_CALL(mock_access_token_fetcher,
                 GetAccessTokenFromRefreshToken(_, _)).Times(1);
   }

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   bool init_result = environment_object.Initialize(kAuthCodeValue);

   EXPECT_TRUE(init_result);
   EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
   EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
       kFakeAccessTokenFetcherRefreshTokenValue), 0);
   EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
   EXPECT_EQ(environment_object.access_token().compare(
       kFakeAccessTokenFetcherAccessTokenValue), 0);

   // Attempt to init again, we should not see any additional calls or errors.
   bool refresh_result = environment_object.RefreshAccessToken();
   EXPECT_TRUE(refresh_result);
 }

 TEST(AppRemotingTestDriverEnvironmentTest, RefreshAccessTokenFailure) {
   MockAccessTokenFetcher mock_access_token_fetcher;

   // Use a raw pointer as we want to adjust behavior after we've handed off the
   // mock class.
   FakeAccessTokenFetcher* fake_access_token_fetcher =
       new FakeAccessTokenFetcher();
   mock_access_token_fetcher.SetAccessTokenFetcher(
       make_scoped_ptr(fake_access_token_fetcher));

   FakeRefreshTokenStore fake_token_store;

   {
     testing::Sequence call_sequence;

     // Mock is set up for this call to succeed.
     EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
         .Times(1);

     // Mock is set up for this call to fail.
     EXPECT_CALL(mock_access_token_fetcher,
                 GetAccessTokenFromRefreshToken(_, _)).Times(1);
   }

   AppRemotingTestDriverEnvironment environment_object(
       kUserNameValue,
       kDeveloperEnvironment);

   environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   bool init_result = environment_object.Initialize(kAuthCodeValue);

   EXPECT_TRUE(init_result);
   EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
   EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
       kFakeAccessTokenFetcherRefreshTokenValue), 0);
   EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
   EXPECT_EQ(environment_object.access_token().compare(
       kFakeAccessTokenFetcherAccessTokenValue), 0);

   fake_access_token_fetcher->set_fail_access_token_from_refresh_token(true);

   bool refresh_result = environment_object.RefreshAccessToken();

   // We expect the refresh to have failed, the user name to remain valid,
   // and the access token to have been cleared.
   EXPECT_FALSE(refresh_result);
   EXPECT_TRUE(environment_object.access_token().empty());
   EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
 }

 TEST(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoSuccess) {
   AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
                                                       kDeveloperEnvironment);

   FakeAccessTokenFetcher fake_access_token_fetcher;
   environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

   FakeRefreshTokenStore fake_token_store;
   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Pass in an empty auth code since we are using a refresh token.
   bool init_result = environment_object.Initialize(std::string());

   EXPECT_TRUE(init_result);

   FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
   environment_object.SetRemoteHostInfoFetcherForTest(
       &fake_remote_host_info_fetcher);

   RemoteHostInfo remote_host_info;
   bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
       kTestApplicationId, &remote_host_info);

   EXPECT_TRUE(request_result);
   EXPECT_TRUE(remote_host_info.IsReadyForConnection());
 }

 TEST(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoFailure) {
   AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
                                                       kDeveloperEnvironment);

   FakeAccessTokenFetcher fake_access_token_fetcher;
   environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

   FakeRefreshTokenStore fake_token_store;
   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   // Pass in an empty auth code since we are using a refresh token.
   bool init_result = environment_object.Initialize(std::string());

   EXPECT_TRUE(init_result);

   FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
   fake_remote_host_info_fetcher.set_fail_retrieve_remote_host_info(true);
   environment_object.SetRemoteHostInfoFetcherForTest(
       &fake_remote_host_info_fetcher);

   RemoteHostInfo remote_host_info;
   bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
       kTestApplicationId, &remote_host_info);

   EXPECT_FALSE(request_result);
 }

 TEST(AppRemotingTestDriverEnvironmentTest,
      GetRemoteHostInfoWithoutInitializing) {
   AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
                                                       kDeveloperEnvironment);

   FakeAccessTokenFetcher fake_access_token_fetcher;
   environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

   FakeRefreshTokenStore fake_token_store;
   environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

   FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
   environment_object.SetRemoteHostInfoFetcherForTest(
       &fake_remote_host_info_fetcher);

   RemoteHostInfo remote_host_info;
   bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
       kTestApplicationId, &remote_host_info);

   EXPECT_FALSE(request_result);
 }

 }  // namespace test
 }  // namespace remoting
	// Copyright 2015 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "remoting/test/app_remoting_test_driver_environment.h"

	#include "remoting/test/fake_access_token_fetcher.h"
	#include "remoting/test/fake_remote_host_info_fetcher.h"
	#include "remoting/test/mock_access_token_fetcher.h"
	#include "remoting/test/refresh_token_store.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {
	const char kAuthCodeValue[] = "4/892379827345jkefvkdfbv";
	const char kRefreshTokenValue[] = "1/lkjalseLKJlsiJgr45jbv";
	const char kUserNameValue[] = "remoting_user@gmail.com";
	const char kTestApplicationId[] = "sadlkjlsjgadjfgoajdfgagb";
	}

	namespace remoting {
	namespace test {

	using testing::_;

	// Stubs out the file API and returns fake data so we can remove
	// file system dependencies when testing the TestDriverEnvironment.
	class FakeRefreshTokenStore : public RefreshTokenStore {
	public:
	FakeRefreshTokenStore() :
	refresh_token_value(kRefreshTokenValue),
	refresh_token_write_succeeded(true),
	refresh_token_write_attempted(false) {}
	~FakeRefreshTokenStore() override {}

	std::string FetchRefreshToken() override {
	return refresh_token_value;
	};

	bool StoreRefreshToken(const std::string& refresh_token) override {
	// Record the information passed to us to write.
	refresh_token_write_attempted = true;
	refresh_token_value_written = refresh_token;

	return refresh_token_write_succeeded;
	};

	// Control members used to return specific data to the caller.
	std::string refresh_token_value;
	bool refresh_token_write_succeeded;

	// Verification members to observe the value of the data being written.
	bool refresh_token_write_attempted;
	std::string refresh_token_value_written;

	private:
	DISALLOW_COPY_AND_ASSIGN(FakeRefreshTokenStore);
	};

	TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCode) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(new FakeAccessTokenFetcher()));

	FakeRefreshTokenStore fake_token_store;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	bool init_result = environment_object.Initialize(kAuthCodeValue);

	EXPECT_TRUE(init_result);
	EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
	EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
	kFakeAccessTokenFetcherRefreshTokenValue), 0);
	EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
	EXPECT_EQ(environment_object.access_token().compare(
	kFakeAccessTokenFetcherAccessTokenValue), 0);

	// Attempt to init again, we should not see any additional calls or errors.
	init_result = environment_object.Initialize(kAuthCodeValue);
	EXPECT_TRUE(init_result);
	}

	TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCodeFailed) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
	new FakeAccessTokenFetcher());

	fake_access_token_fetcher->set_fail_access_token_from_auth_code(true);

	mock_access_token_fetcher.SetAccessTokenFetcher(
	fake_access_token_fetcher.Pass());

	FakeRefreshTokenStore fake_token_store;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	bool init_result = environment_object.Initialize(kAuthCodeValue);

	EXPECT_FALSE(init_result);
	EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
	}

	TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithRefreshToken) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(new FakeAccessTokenFetcher()));

	FakeRefreshTokenStore fake_token_store;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Pass in an empty auth code since we are using a refresh token.
	bool init_result = environment_object.Initialize(std::string());

	EXPECT_TRUE(init_result);

	// We should not write the refresh token a second time if we read from the
	// disk originally.
	EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);

	// Verify the object was initialized correctly.
	EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
	EXPECT_EQ(environment_object.access_token().compare(
	kFakeAccessTokenFetcherAccessTokenValue), 0);

	// Attempt to init again, we should not see any additional calls or errors.
	init_result = environment_object.Initialize(std::string());
	EXPECT_TRUE(init_result);
	}

	TEST(AppRemotingTestDriverEnvironmentTest,
	InitializeObjectWithRefreshTokenFailed) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
	new FakeAccessTokenFetcher());

	fake_access_token_fetcher->set_fail_access_token_from_refresh_token(true);

	mock_access_token_fetcher.SetAccessTokenFetcher(
	fake_access_token_fetcher.Pass());

	FakeRefreshTokenStore fake_token_store;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Pass in an empty auth code since we are using a refresh token.
	bool init_result = environment_object.Initialize(std::string());

	EXPECT_FALSE(init_result);
	EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
	}

	TEST(AppRemotingTestDriverEnvironmentTest,
	InitializeObjectNoAuthCodeOrRefreshToken) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(new FakeAccessTokenFetcher()));

	FakeRefreshTokenStore fake_token_store;

	// Neither method should be called in this scenario.
	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(0);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Clear out the 'stored' refresh token value.
	fake_token_store.refresh_token_value = "";

	// Pass in an empty auth code.
	bool init_result = environment_object.Initialize(std::string());

	// With no auth code or refresh token, then the initialization should fail.
	EXPECT_FALSE(init_result);
	EXPECT_FALSE(fake_token_store.refresh_token_write_attempted);
	}

	TEST(AppRemotingTestDriverEnvironmentTest,
	InitializeObjectWithAuthCodeWriteFailed) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(new FakeAccessTokenFetcher()));

	FakeRefreshTokenStore fake_token_store;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
	.Times(0);

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Simulate a failure writing the token to the disk.
	fake_token_store.refresh_token_write_succeeded = false;

	bool init_result = environment_object.Initialize(kAuthCodeValue);

	EXPECT_FALSE(init_result);
	EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
	}

	TEST(AppRemotingTestDriverEnvironmentTest,
	RefreshAccessTokenAfterUsingAuthCode) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(new FakeAccessTokenFetcher()));

	FakeRefreshTokenStore fake_token_store;

	{
	testing::Sequence call_sequence;

	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(1);

	EXPECT_CALL(mock_access_token_fetcher,
	GetAccessTokenFromRefreshToken(_, _)).Times(1);
	}

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	bool init_result = environment_object.Initialize(kAuthCodeValue);

	EXPECT_TRUE(init_result);
	EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
	EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
	kFakeAccessTokenFetcherRefreshTokenValue), 0);
	EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
	EXPECT_EQ(environment_object.access_token().compare(
	kFakeAccessTokenFetcherAccessTokenValue), 0);

	// Attempt to init again, we should not see any additional calls or errors.
	bool refresh_result = environment_object.RefreshAccessToken();
	EXPECT_TRUE(refresh_result);
	}

	TEST(AppRemotingTestDriverEnvironmentTest, RefreshAccessTokenFailure) {
	MockAccessTokenFetcher mock_access_token_fetcher;

	// Use a raw pointer as we want to adjust behavior after we've handed off the
	// mock class.
	FakeAccessTokenFetcher* fake_access_token_fetcher =
	new FakeAccessTokenFetcher();
	mock_access_token_fetcher.SetAccessTokenFetcher(
	make_scoped_ptr(fake_access_token_fetcher));

	FakeRefreshTokenStore fake_token_store;

	{
	testing::Sequence call_sequence;

	// Mock is set up for this call to succeed.
	EXPECT_CALL(mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
	.Times(1);

	// Mock is set up for this call to fail.
	EXPECT_CALL(mock_access_token_fetcher,
	GetAccessTokenFromRefreshToken(_, _)).Times(1);
	}

	AppRemotingTestDriverEnvironment environment_object(
	kUserNameValue,
	kDeveloperEnvironment);

	environment_object.SetAccessTokenFetcherForTest(&mock_access_token_fetcher);

	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	bool init_result = environment_object.Initialize(kAuthCodeValue);

	EXPECT_TRUE(init_result);
	EXPECT_TRUE(fake_token_store.refresh_token_write_attempted);
	EXPECT_EQ(fake_token_store.refresh_token_value_written.compare(
	kFakeAccessTokenFetcherRefreshTokenValue), 0);
	EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
	EXPECT_EQ(environment_object.access_token().compare(
	kFakeAccessTokenFetcherAccessTokenValue), 0);

	fake_access_token_fetcher->set_fail_access_token_from_refresh_token(true);

	bool refresh_result = environment_object.RefreshAccessToken();

	// We expect the refresh to have failed, the user name to remain valid,
	// and the access token to have been cleared.
	EXPECT_FALSE(refresh_result);
	EXPECT_TRUE(environment_object.access_token().empty());
	EXPECT_EQ(environment_object.user_name().compare(kUserNameValue), 0);
	}

	TEST(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoSuccess) {
	AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
	kDeveloperEnvironment);

	FakeAccessTokenFetcher fake_access_token_fetcher;
	environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

	FakeRefreshTokenStore fake_token_store;
	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Pass in an empty auth code since we are using a refresh token.
	bool init_result = environment_object.Initialize(std::string());

	EXPECT_TRUE(init_result);

	FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
	environment_object.SetRemoteHostInfoFetcherForTest(
	&fake_remote_host_info_fetcher);

	RemoteHostInfo remote_host_info;
	bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
	kTestApplicationId, &remote_host_info);

	EXPECT_TRUE(request_result);
	EXPECT_TRUE(remote_host_info.IsReadyForConnection());
	}

	TEST(AppRemotingTestDriverEnvironmentTest, GetRemoteHostInfoFailure) {
	AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
	kDeveloperEnvironment);

	FakeAccessTokenFetcher fake_access_token_fetcher;
	environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

	FakeRefreshTokenStore fake_token_store;
	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	// Pass in an empty auth code since we are using a refresh token.
	bool init_result = environment_object.Initialize(std::string());

	EXPECT_TRUE(init_result);

	FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
	fake_remote_host_info_fetcher.set_fail_retrieve_remote_host_info(true);
	environment_object.SetRemoteHostInfoFetcherForTest(
	&fake_remote_host_info_fetcher);

	RemoteHostInfo remote_host_info;
	bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
	kTestApplicationId, &remote_host_info);

	EXPECT_FALSE(request_result);
	}

	TEST(AppRemotingTestDriverEnvironmentTest,
	GetRemoteHostInfoWithoutInitializing) {
	AppRemotingTestDriverEnvironment environment_object(kUserNameValue,
	kDeveloperEnvironment);

	FakeAccessTokenFetcher fake_access_token_fetcher;
	environment_object.SetAccessTokenFetcherForTest(&fake_access_token_fetcher);

	FakeRefreshTokenStore fake_token_store;
	environment_object.SetRefreshTokenStoreForTest(&fake_token_store);

	FakeRemoteHostInfoFetcher fake_remote_host_info_fetcher;
	environment_object.SetRemoteHostInfoFetcherForTest(
	&fake_remote_host_info_fetcher);

	RemoteHostInfo remote_host_info;
	bool request_result = environment_object.GetRemoteHostInfoForApplicationId(
	kTestApplicationId, &remote_host_info);

	EXPECT_FALSE(request_result);
	}

	} // namespace test
	} // namespace remoting