oauth_token_getter_proxy_unittest.cc 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. // Copyright 2017 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. #include "remoting/base/oauth_token_getter_proxy.h"
  5. #include "base/bind.h"
  6. #include "base/callback.h"
  7. #include "base/callback_helpers.h"
  8. #include "base/memory/weak_ptr.h"
  9. #include "base/run_loop.h"
  10. #include "base/test/task_environment.h"
  11. #include "base/threading/thread.h"
  12. #include "base/threading/thread_checker.h"
  13. #include "base/threading/thread_task_runner_handle.h"
  14. #include "testing/gtest/include/gtest/gtest.h"
  15. namespace remoting {
  16. namespace {
  17. OAuthTokenGetter::TokenCallback GetDoNothingTokenCallback() {
  18. return base::DoNothing();
  19. }
  20. class FakeOAuthTokenGetter : public OAuthTokenGetter {
  21. public:
  22. FakeOAuthTokenGetter();
  23. FakeOAuthTokenGetter(const FakeOAuthTokenGetter&) = delete;
  24. FakeOAuthTokenGetter& operator=(const FakeOAuthTokenGetter&) = delete;
  25. ~FakeOAuthTokenGetter() override;
  26. void ResolveCallback(Status status,
  27. const std::string& user_email,
  28. const std::string& access_token);
  29. void ExpectInvalidateCache();
  30. // OAuthTokenGetter overrides.
  31. void CallWithToken(TokenCallback on_access_token) override;
  32. void InvalidateCache() override;
  33. base::WeakPtr<FakeOAuthTokenGetter> GetWeakPtr();
  34. private:
  35. TokenCallback on_access_token_;
  36. bool invalidate_cache_expected_ = false;
  37. THREAD_CHECKER(thread_checker_);
  38. base::WeakPtrFactory<FakeOAuthTokenGetter> weak_factory_{this};
  39. };
  40. FakeOAuthTokenGetter::FakeOAuthTokenGetter() {
  41. DETACH_FROM_THREAD(thread_checker_);
  42. }
  43. FakeOAuthTokenGetter::~FakeOAuthTokenGetter() {
  44. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  45. DCHECK(!invalidate_cache_expected_);
  46. }
  47. void FakeOAuthTokenGetter::ResolveCallback(Status status,
  48. const std::string& user_email,
  49. const std::string& access_token) {
  50. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  51. DCHECK(!on_access_token_.is_null());
  52. std::move(on_access_token_).Run(status, user_email, access_token);
  53. }
  54. void FakeOAuthTokenGetter::ExpectInvalidateCache() {
  55. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  56. ASSERT_FALSE(invalidate_cache_expected_);
  57. invalidate_cache_expected_ = true;
  58. }
  59. void FakeOAuthTokenGetter::CallWithToken(TokenCallback on_access_token) {
  60. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  61. on_access_token_ = std::move(on_access_token);
  62. }
  63. void FakeOAuthTokenGetter::InvalidateCache() {
  64. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  65. ASSERT_TRUE(invalidate_cache_expected_);
  66. invalidate_cache_expected_ = false;
  67. }
  68. base::WeakPtr<FakeOAuthTokenGetter> FakeOAuthTokenGetter::GetWeakPtr() {
  69. return weak_factory_.GetWeakPtr();
  70. }
  71. } // namespace
  72. class OAuthTokenGetterProxyTest : public testing::Test {
  73. public:
  74. OAuthTokenGetterProxyTest() = default;
  75. OAuthTokenGetterProxyTest(const OAuthTokenGetterProxyTest&) = delete;
  76. OAuthTokenGetterProxyTest& operator=(const OAuthTokenGetterProxyTest&) =
  77. delete;
  78. ~OAuthTokenGetterProxyTest() override = default;
  79. // testing::Test overrides.
  80. void SetUp() override;
  81. void TearDown() override;
  82. protected:
  83. void TestCallWithTokenOnRunnerThread(OAuthTokenGetter::Status status,
  84. const std::string& user_email,
  85. const std::string& access_token);
  86. void TestCallWithTokenOnMainThread(OAuthTokenGetter::Status status,
  87. const std::string& user_email,
  88. const std::string& access_token);
  89. void ExpectInvalidateCache();
  90. void InvalidateTokenGetter();
  91. base::Thread runner_thread_{"runner_thread"};
  92. std::unique_ptr<FakeOAuthTokenGetter> token_getter_;
  93. std::unique_ptr<OAuthTokenGetterProxy> proxy_;
  94. private:
  95. struct TokenCallbackResult {
  96. OAuthTokenGetter::Status status;
  97. std::string user_email;
  98. std::string access_token;
  99. };
  100. void TestCallWithTokenImpl(OAuthTokenGetter::Status status,
  101. const std::string& user_email,
  102. const std::string& access_token);
  103. void OnTokenReceived(OAuthTokenGetter::Status status,
  104. const std::string& user_email,
  105. const std::string& access_token);
  106. std::unique_ptr<TokenCallbackResult> expected_callback_result_;
  107. base::test::SingleThreadTaskEnvironment task_environment_;
  108. };
  109. void OAuthTokenGetterProxyTest::SetUp() {
  110. token_getter_ = std::make_unique<FakeOAuthTokenGetter>();
  111. runner_thread_.Start();
  112. proxy_ = std::make_unique<OAuthTokenGetterProxy>(
  113. token_getter_->GetWeakPtr(), runner_thread_.task_runner());
  114. }
  115. void OAuthTokenGetterProxyTest::TearDown() {
  116. InvalidateTokenGetter();
  117. proxy_.reset();
  118. runner_thread_.FlushForTesting();
  119. ASSERT_FALSE(expected_callback_result_);
  120. }
  121. void OAuthTokenGetterProxyTest::TestCallWithTokenOnRunnerThread(
  122. OAuthTokenGetter::Status status,
  123. const std::string& user_email,
  124. const std::string& access_token) {
  125. runner_thread_.task_runner()->PostTask(
  126. FROM_HERE,
  127. base::BindOnce(&OAuthTokenGetterProxyTest::TestCallWithTokenImpl,
  128. base::Unretained(this),
  129. OAuthTokenGetter::Status::AUTH_ERROR, "email3", "token3"));
  130. runner_thread_.FlushForTesting();
  131. }
  132. void OAuthTokenGetterProxyTest::TestCallWithTokenOnMainThread(
  133. OAuthTokenGetter::Status status,
  134. const std::string& user_email,
  135. const std::string& access_token) {
  136. TestCallWithTokenImpl(status, user_email, access_token);
  137. runner_thread_.FlushForTesting();
  138. base::RunLoop().RunUntilIdle();
  139. }
  140. void OAuthTokenGetterProxyTest::ExpectInvalidateCache() {
  141. ASSERT_NE(nullptr, token_getter_.get());
  142. runner_thread_.task_runner()->PostTask(
  143. FROM_HERE, base::BindOnce(&FakeOAuthTokenGetter::ExpectInvalidateCache,
  144. token_getter_->GetWeakPtr()));
  145. }
  146. void OAuthTokenGetterProxyTest::InvalidateTokenGetter() {
  147. if (token_getter_) {
  148. runner_thread_.task_runner()->DeleteSoon(FROM_HERE,
  149. token_getter_.release());
  150. }
  151. }
  152. void OAuthTokenGetterProxyTest::TestCallWithTokenImpl(
  153. OAuthTokenGetter::Status status,
  154. const std::string& user_email,
  155. const std::string& access_token) {
  156. ASSERT_FALSE(expected_callback_result_);
  157. expected_callback_result_ = std::make_unique<TokenCallbackResult>();
  158. expected_callback_result_->status = status;
  159. expected_callback_result_->user_email = user_email;
  160. expected_callback_result_->access_token = access_token;
  161. proxy_->CallWithToken(base::BindOnce(
  162. &OAuthTokenGetterProxyTest::OnTokenReceived, base::Unretained(this)));
  163. runner_thread_.task_runner()->PostTask(
  164. FROM_HERE, base::BindOnce(&FakeOAuthTokenGetter::ResolveCallback,
  165. token_getter_->GetWeakPtr(), status, user_email,
  166. access_token));
  167. }
  168. void OAuthTokenGetterProxyTest::OnTokenReceived(
  169. OAuthTokenGetter::Status status,
  170. const std::string& user_email,
  171. const std::string& access_token) {
  172. ASSERT_TRUE(expected_callback_result_);
  173. EXPECT_EQ(expected_callback_result_->status, status);
  174. EXPECT_EQ(expected_callback_result_->user_email, user_email);
  175. EXPECT_EQ(expected_callback_result_->access_token, access_token);
  176. expected_callback_result_.reset();
  177. }
  178. TEST_F(OAuthTokenGetterProxyTest, CallWithTokenOnMainThread) {
  179. TestCallWithTokenOnMainThread(OAuthTokenGetter::Status::SUCCESS, "email1",
  180. "token1");
  181. TestCallWithTokenOnMainThread(OAuthTokenGetter::Status::NETWORK_ERROR,
  182. "email2", "token2");
  183. }
  184. TEST_F(OAuthTokenGetterProxyTest, CallWithTokenOnRunnerThread) {
  185. TestCallWithTokenOnRunnerThread(OAuthTokenGetter::Status::AUTH_ERROR,
  186. "email3", "token3");
  187. TestCallWithTokenOnRunnerThread(OAuthTokenGetter::Status::SUCCESS, "email4",
  188. "token4");
  189. }
  190. TEST_F(OAuthTokenGetterProxyTest, InvalidateCacheOnMainThread) {
  191. ExpectInvalidateCache();
  192. proxy_->InvalidateCache();
  193. runner_thread_.FlushForTesting();
  194. }
  195. TEST_F(OAuthTokenGetterProxyTest, InvalidateCacheOnRunnerThread) {
  196. ExpectInvalidateCache();
  197. runner_thread_.task_runner()->PostTask(
  198. FROM_HERE, base::BindOnce(&OAuthTokenGetterProxy::InvalidateCache,
  199. base::Unretained(proxy_.get())));
  200. runner_thread_.FlushForTesting();
  201. }
  202. TEST_F(
  203. OAuthTokenGetterProxyTest,
  204. CallWithTokenOnMainThreadAfterTokenGetterDestroyed_callsSilentlyDropped) {
  205. InvalidateTokenGetter();
  206. proxy_->CallWithToken(GetDoNothingTokenCallback());
  207. runner_thread_.FlushForTesting();
  208. }
  209. TEST_F(
  210. OAuthTokenGetterProxyTest,
  211. CallWithTokenOnRunnerThreadAfterTokenGetterDestroyed_callsSilentlyDropped) {
  212. InvalidateTokenGetter();
  213. runner_thread_.task_runner()->PostTask(
  214. FROM_HERE, base::BindOnce(&OAuthTokenGetterProxy::CallWithToken,
  215. base::Unretained(proxy_.get()),
  216. GetDoNothingTokenCallback()));
  217. runner_thread_.FlushForTesting();
  218. }
  219. TEST_F(
  220. OAuthTokenGetterProxyTest,
  221. InvalidateCacheOnMainThreadAfterTokenGetterDestroyed_callsSilentlyDropped) {
  222. InvalidateTokenGetter();
  223. proxy_->InvalidateCache();
  224. runner_thread_.FlushForTesting();
  225. }
  226. TEST_F(
  227. OAuthTokenGetterProxyTest,
  228. InvalidateCacheOnRunnerThreadAfterTokenGetterDestroyed_callsSilentlyDropped) {
  229. InvalidateTokenGetter();
  230. runner_thread_.task_runner()->PostTask(
  231. FROM_HERE, base::BindOnce(&OAuthTokenGetterProxy::InvalidateCache,
  232. base::Unretained(proxy_.get())));
  233. runner_thread_.FlushForTesting();
  234. }
  235. } // namespace remoting