Adding the AccessTokenFetcher and Environment class to the app remoting test

remoting/test/mock_access_token_fetcher.h

Index: remoting/test/mock_access_token_fetcher.h
diff --git a/remoting/test/mock_access_token_fetcher.h b/remoting/test/mock_access_token_fetcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d45431a0c7e26c95bf367bf7a6e1e8e11059aa6
--- /dev/null
+++ b/remoting/test/mock_access_token_fetcher.h
@@ -0,0 +1,49 @@
+// 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.
+
+#ifndef REMOTING_TEST_MOCK_ACCESS_TOKEN_FETCHER_H_
+#define REMOTING_TEST_MOCK_ACCESS_TOKEN_FETCHER_H_
+
+#include "remoting/test/access_token_fetcher.h"
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace remoting {
+namespace test {
+
+// Used for testing classes which rely on the AccessTokenFetcher and want to
+// simulate success and failure scenarios without using the actual class and
+// network connection.
+class MockAccessTokenFetcher : public AccessTokenFetcher {
+ public:
+  MockAccessTokenFetcher();
+  ~MockAccessTokenFetcher() override;
+
+  MOCK_METHOD2(GetAccessTokenFromAuthCode,
+               void(const std::string& auth_code,
+                    const AccessTokenCallback& callback));
+
+  MOCK_METHOD2(GetAccessTokenFromRefreshToken,
+               void(const std::string& refresh_token,
+                    const AccessTokenCallback& callback));
+
+  // Stores a fake object and wires up the mock methods to call through to the
+  // appropriate method on the fake object.

[Wez, 2015/02/19 22:00:24]

So the idea is that by default the supplied fake will be used, unless the test
overrides by mocking?

What happens if the caller never supplies a fake?

[joedow, 2015/02/20 02:58:36]

It depends on the class that uses it, if the class waits for the callback to run
then it should supply a fake to run the callback, if the class doesn't care
about the callback it could just use the mock.

The first version this class had the Mock and Fake in the same class which
wasn't right, so my approach this time is to have separate classes that can be
used independently.

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

I understand breaking the two classes apart; it's the purpose of this
SetFake...() method that seems to set up the mock to just fall-back to calling
on to a supplied read or fake fetcher.

IIUC the aim is to use the supplied fetcher for the actual fecther behaviour,
but still allow tests to use mocking to detect calls and verify them?

+  void SetFakeAccessTokenFetcher(scoped_ptr<AccessTokenFetcher> fake);
+
+ private:
+  // Delegates the default actions of the methods to a fake object.
+  // This must be called *before* the custom ON_CALL() statements.
+  void DelegateMethodCallsToFake();
+
+  scoped_ptr<AccessTokenFetcher> fake_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockAccessTokenFetcher);
+};
+
+}  // namespace test
+}  // namespace remoting
+
+#endif  // REMOTING_TEST_MOCK_ACCESS_TOKEN_FETCHER_H_