Adding the AccessTokenFetcher and Environment class to the app remoting test

remoting/test/app_remoting_test_driver_environment_unittest.cc

+// 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/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 kDevEnvironmentValue[] = "dev";
+}
+
+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() {
+    // Set some success defaults.
+    refresh_token_value = kRefreshTokenValue;
+    refresh_token_write_attempted = false;
+    refresh_token_write_succeeded = true;
+  }
+  ~FakeRefreshTokenStore() override {}
+
+  std::string FetchRefreshToken(const std::string& user_name) override {
+    return refresh_token_value;
+  };
+
+  bool StoreRefreshToken(
+      const std::string& user_name,
+      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;
+    user_name_written = user_name;
+
+    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;
+  std::string user_name_written;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRefreshTokenStore);
+};
+
+// Gives unit tests the ability to access/mutate private members of the
+// AppRemotingTestDriverEnvironment class.
+class AppRemotingTestDriverEnvironmentUnittestHelper {

[Wez, 2015/02/23 20:17:14]

What's the benefit of having this class versus having the two settings in the
real class with a ForTest() name? Naming something with ForTest() will mean the
PRESUBMIT checks will fire if non-test code tries to use it.

If you prefer to keep this class then consider making it a class that tests
actually instantiate, and that owns the AccessTokenFetcher and RefreshTokenStore
- that way the driver environment can have bare pointers for those, rather than
owning them itself, and you won't have to Pass() them to it, which will simplify
your tests below.

[joedow, 2015/02/24 02:01:24]

Done.

+ public:
+  static void SetAccessTokenFetcher(
+    AppRemotingTestDriverEnvironment* environment,
+    scoped_ptr<AccessTokenFetcher> access_token_fetcher) {
+    DCHECK(environment);
+    DCHECK(access_token_fetcher);
+
+    environment->test_access_token_fetcher_ = access_token_fetcher.Pass();
+  }
+
+  static void SetRefreshTokenStore(
+    AppRemotingTestDriverEnvironment* environment,
+    scoped_ptr<RefreshTokenStore> refresh_token_store) {
+    DCHECK(environment);
+    DCHECK(refresh_token_store);
+
+    environment->refresh_token_store_ = refresh_token_store.Pass();
+  }
+
+ private:
+  AppRemotingTestDriverEnvironmentUnittestHelper() {}
+  ~AppRemotingTestDriverEnvironmentUnittestHelper() {}
+};

[Wez, 2015/02/23 20:17:14]

DISALLOW_COPY_AND_ASSIGN

[joedow, 2015/02/24 02:01:24]

Done.

+
+TEST(AppRemotingTestDriverEnvironmentTest, InitializeObjectWithAuthCode) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(new FakeAccessTokenFetcher()));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
+      .Times(1);
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
+      .Times(0);
+
+  AppRemotingTestDriverEnvironment environment_object(
+      kUserNameValue,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(fake_token_store));
+
+  bool init_result = environment_object.Initialize(kAuthCodeValue);
+
+  EXPECT_TRUE(init_result);
+  EXPECT_TRUE(fake_token_store->refresh_token_write_attempted);
+  EXPECT_STREQ(kUserNameValue,
+               fake_token_store->user_name_written.c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherRefreshTokenValue,
+               fake_token_store->refresh_token_value_written.c_str());
+  EXPECT_STREQ(kUserNameValue, environment_object.user_name().c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherAccessTokenValue,
+               environment_object.access_token().c_str());
+
+  // 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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
+      new FakeAccessTokenFetcher());
+
+  fake_access_token_fetcher->SetAuthCodeError(true);
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      fake_access_token_fetcher.Pass());
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
+      .Times(1);
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
+      .Times(0);
+
+  AppRemotingTestDriverEnvironment environment_object(
+      kUserNameValue,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(new FakeAccessTokenFetcher()));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
+      .Times(1);
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
+      .Times(0);
+
+  AppRemotingTestDriverEnvironment environment_object(
+      kUserNameValue,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(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_STREQ(kUserNameValue, environment_object.user_name().c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherAccessTokenValue,
+               environment_object.access_token().c_str());
+
+  // 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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  scoped_ptr<FakeAccessTokenFetcher> fake_access_token_fetcher(
+      new FakeAccessTokenFetcher());
+
+  fake_access_token_fetcher->SetRefreshTokenError(true);
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      fake_access_token_fetcher.Pass());
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
+      .Times(1);
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
+      .Times(0);
+
+  AppRemotingTestDriverEnvironment environment_object(
+      kUserNameValue,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(new FakeAccessTokenFetcher()));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  // 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,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(new FakeAccessTokenFetcher()));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromAuthCode(_, _))
+      .Times(1);
+
+  EXPECT_CALL(*mock_access_token_fetcher, GetAccessTokenFromRefreshToken(_, _))
+      .Times(0);
+
+  AppRemotingTestDriverEnvironment environment_object(
+      kUserNameValue,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  mock_access_token_fetcher->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(new FakeAccessTokenFetcher()));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  {
+    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,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(fake_token_store));
+
+  bool init_result = environment_object.Initialize(kAuthCodeValue);
+
+  EXPECT_TRUE(init_result);
+  EXPECT_TRUE(fake_token_store->refresh_token_write_attempted);
+  EXPECT_STREQ(kUserNameValue,
+               fake_token_store->user_name_written.c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherRefreshTokenValue,
+               fake_token_store->refresh_token_value_written.c_str());
+  EXPECT_STREQ(kUserNameValue, environment_object.user_name().c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherAccessTokenValue,
+               environment_object.access_token().c_str());
+
+  // 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) {
+  scoped_ptr<MockAccessTokenFetcher> mock_access_token_fetcher(
+      new MockAccessTokenFetcher());
+
+  // 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->SetFakeAccessTokenFetcher(
+      make_scoped_ptr(fake_access_token_fetcher));
+
+  // We need to use the |fake_token_store| object for verification purposes so
+  // use a raw pointer here instead of a scoped_ptr.
+  FakeRefreshTokenStore* fake_token_store = new FakeRefreshTokenStore();
+
+  {
+    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,
+      kDevEnvironmentValue);
+
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetAccessTokenFetcher(
+      &environment_object, mock_access_token_fetcher.Pass());
+
+  // Pass in a new scoped_ptr to transfer ownership of |fake_token_store| to the
+  // environment object.  The |fake_token_store| object will remain accessible
+  // until the environment object is destroyed.
+  AppRemotingTestDriverEnvironmentUnittestHelper::SetRefreshTokenStore(
+      &environment_object, make_scoped_ptr(fake_token_store));
+
+  bool init_result = environment_object.Initialize(kAuthCodeValue);
+
+  EXPECT_TRUE(init_result);
+  EXPECT_TRUE(fake_token_store->refresh_token_write_attempted);
+  EXPECT_STREQ(kUserNameValue,
+               fake_token_store->user_name_written.c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherRefreshTokenValue,
+               fake_token_store->refresh_token_value_written.c_str());
+  EXPECT_STREQ(kUserNameValue, environment_object.user_name().c_str());
+  EXPECT_STREQ(kFakeAccessTokenFetcherAccessTokenValue,
+               environment_object.access_token().c_str());
+
+  fake_access_token_fetcher->SetRefreshTokenError(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_STREQ(kUserNameValue, environment_object.user_name().c_str());
+  EXPECT_STREQ("", environment_object.access_token().c_str());
+}
+
+}  // namespace test
+}  // namespace remoting