base_requests_unittest.cc 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. // Copyright (c) 2012 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 "google_apis/common/base_requests.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/run_loop.h"
  10. #include "base/test/task_environment.h"
  11. #include "base/values.h"
  12. #include "google_apis/common/dummy_auth_service.h"
  13. #include "google_apis/common/request_sender.h"
  14. #include "google_apis/common/test_util.h"
  15. #include "mojo/public/cpp/bindings/pending_remote.h"
  16. #include "mojo/public/cpp/bindings/remote.h"
  17. #include "net/test/embedded_test_server/embedded_test_server.h"
  18. #include "net/test/embedded_test_server/http_response.h"
  19. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  20. #include "services/network/network_service.h"
  21. #include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
  22. #include "services/network/public/mojom/network_context.mojom.h"
  23. #include "services/network/public/mojom/url_response_head.mojom.h"
  24. #include "services/network/test/fake_test_cert_verifier_params_factory.h"
  25. #include "testing/gtest/include/gtest/gtest.h"
  26. namespace google_apis {
  27. namespace {
  28. const char kValidJsonString[] = "{ \"test\": 123 }";
  29. const char kInvalidJsonString[] = "$$$";
  30. class FakeUrlFetchRequest : public UrlFetchRequestBase {
  31. public:
  32. FakeUrlFetchRequest(RequestSender* sender,
  33. PrepareCallback callback,
  34. const GURL& url)
  35. : UrlFetchRequestBase(sender, ProgressCallback(), ProgressCallback()),
  36. callback_(std::move(callback)),
  37. url_(url) {}
  38. ~FakeUrlFetchRequest() override {}
  39. protected:
  40. GURL GetURL() const override { return url_; }
  41. void ProcessURLFetchResults(
  42. const network::mojom::URLResponseHead* response_head,
  43. base::FilePath response_file,
  44. std::string response_body) override {
  45. std::move(callback_).Run(GetErrorCode());
  46. }
  47. void RunCallbackOnPrematureFailure(ApiErrorCode code) override {
  48. std::move(callback_).Run(code);
  49. }
  50. google_apis::ApiErrorCode MapReasonToError(
  51. google_apis::ApiErrorCode code,
  52. const std::string& reason) override {
  53. if (reason == "rateLimitExceeded")
  54. return google_apis::HTTP_SERVICE_UNAVAILABLE;
  55. return code;
  56. }
  57. bool IsSuccessfulErrorCode(ApiErrorCode error) override {
  58. return error == HTTP_SUCCESS;
  59. }
  60. PrepareCallback callback_;
  61. GURL url_;
  62. };
  63. } // namespace
  64. class BaseRequestsTest : public testing::Test {
  65. public:
  66. BaseRequestsTest() : response_code_(net::HTTP_OK) {
  67. mojo::Remote<network::mojom::NetworkService> network_service_remote;
  68. network_service_ = network::NetworkService::Create(
  69. network_service_remote.BindNewPipeAndPassReceiver());
  70. network::mojom::NetworkContextParamsPtr context_params =
  71. network::mojom::NetworkContextParams::New();
  72. // Use a dummy CertVerifier that always passes cert verification, since
  73. // these unittests don't need to test CertVerifier behavior.
  74. context_params->cert_verifier_params =
  75. network::FakeTestCertVerifierParamsFactory::GetCertVerifierParams();
  76. network_service_remote->CreateNetworkContext(
  77. network_context_.BindNewPipeAndPassReceiver(),
  78. std::move(context_params));
  79. mojo::PendingReceiver<network::mojom::URLLoaderNetworkServiceObserver>
  80. default_observer_receiver;
  81. network::mojom::NetworkServiceParamsPtr network_service_params =
  82. network::mojom::NetworkServiceParams::New();
  83. network_service_params->default_observer =
  84. default_observer_receiver.InitWithNewPipeAndPassRemote();
  85. network_service_remote->SetParams(std::move(network_service_params));
  86. network::mojom::URLLoaderFactoryParamsPtr params =
  87. network::mojom::URLLoaderFactoryParams::New();
  88. params->process_id = network::mojom::kBrowserProcessId;
  89. params->is_corb_enabled = false;
  90. network_context_->CreateURLLoaderFactory(
  91. url_loader_factory_.BindNewPipeAndPassReceiver(), std::move(params));
  92. test_shared_loader_factory_ =
  93. base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
  94. url_loader_factory_.get());
  95. }
  96. void SetUp() override {
  97. sender_ = std::make_unique<RequestSender>(
  98. std::make_unique<DummyAuthService>(), test_shared_loader_factory_,
  99. task_environment_.GetMainThreadTaskRunner(),
  100. std::string(), /* custom user agent */
  101. TRAFFIC_ANNOTATION_FOR_TESTS);
  102. test_server_.RegisterRequestHandler(base::BindRepeating(
  103. &BaseRequestsTest::HandleRequest, base::Unretained(this)));
  104. ASSERT_TRUE(test_server_.Start());
  105. }
  106. void TearDown() override {
  107. // Deleting the sender here will delete all request objects.
  108. sender_.reset();
  109. // Wait for any DeleteSoon tasks to run.
  110. task_environment_.RunUntilIdle();
  111. }
  112. std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
  113. const net::test_server::HttpRequest& request) {
  114. std::unique_ptr<net::test_server::BasicHttpResponse> response(
  115. new net::test_server::BasicHttpResponse);
  116. response->set_code(response_code_);
  117. response->set_content(response_body_);
  118. response->set_content_type("application/json");
  119. return std::move(response);
  120. }
  121. base::test::TaskEnvironment task_environment_{
  122. base::test::TaskEnvironment::MainThreadType::IO};
  123. std::unique_ptr<network::mojom::NetworkService> network_service_;
  124. mojo::Remote<network::mojom::NetworkContext> network_context_;
  125. mojo::Remote<network::mojom::URLLoaderFactory> url_loader_factory_;
  126. scoped_refptr<network::WeakWrapperSharedURLLoaderFactory>
  127. test_shared_loader_factory_;
  128. std::unique_ptr<RequestSender> sender_;
  129. net::EmbeddedTestServer test_server_;
  130. net::HttpStatusCode response_code_;
  131. std::string response_body_;
  132. };
  133. TEST_F(BaseRequestsTest, ParseValidJson) {
  134. std::unique_ptr<base::Value> json(ParseJson(kValidJsonString));
  135. base::DictionaryValue* root_dict = nullptr;
  136. ASSERT_TRUE(json);
  137. ASSERT_TRUE(json->GetAsDictionary(&root_dict));
  138. int int_value = 0;
  139. ASSERT_TRUE(root_dict->GetInteger("test", &int_value));
  140. EXPECT_EQ(123, int_value);
  141. }
  142. TEST_F(BaseRequestsTest, ParseInvalidJson) {
  143. EXPECT_FALSE(ParseJson(kInvalidJsonString));
  144. }
  145. TEST_F(BaseRequestsTest, UrlFetchRequestBaseResponseCodeOverride) {
  146. response_code_ = net::HTTP_FORBIDDEN;
  147. response_body_ =
  148. "{\"error\": {\n"
  149. " \"errors\": [\n"
  150. " {\n"
  151. " \"domain\": \"usageLimits\",\n"
  152. " \"reason\": \"rateLimitExceeded\",\n"
  153. " \"message\": \"Rate Limit Exceeded\"\n"
  154. " }\n"
  155. " ],\n"
  156. " \"code\": 403,\n"
  157. " \"message\": \"Rate Limit Exceeded\"\n"
  158. " }\n"
  159. "}\n";
  160. ApiErrorCode error = OTHER_ERROR;
  161. base::RunLoop run_loop;
  162. sender_->StartRequestWithAuthRetry(std::make_unique<FakeUrlFetchRequest>(
  163. sender_.get(),
  164. test_util::CreateQuitCallback(
  165. &run_loop, test_util::CreateCopyResultCallback(&error)),
  166. test_server_.base_url()));
  167. run_loop.Run();
  168. // HTTP_FORBIDDEN (403) is overridden by the error reason.
  169. EXPECT_EQ(HTTP_SERVICE_UNAVAILABLE, error);
  170. }
  171. } // namespace google_apis