1 // Copyright 2018 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 
5 #include <memory>
6 #include <string>
7 #include <utility>
8 #include <vector>
9 
10 #include "base/bind.h"
11 #include "base/check.h"
12 #include "base/memory/shared_memory_mapping.h"
13 #include "base/run_loop.h"
14 #include "base/strings/string_piece.h"
15 #include "base/strings/stringprintf.h"
16 #include "base/test/task_environment.h"
17 #include "chrome/browser/chromeos/wilco_dtc_supportd/mojo_utils.h"
18 #include "chrome/browser/chromeos/wilco_dtc_supportd/testing_wilco_dtc_supportd_network_context.h"
19 #include "chrome/browser/chromeos/wilco_dtc_supportd/wilco_dtc_supportd_web_request_service.h"
20 #include "chrome/services/wilco_dtc_supportd/public/mojom/wilco_dtc_supportd.mojom.h"
21 #include "net/base/net_errors.h"
22 #include "net/http/http_request_headers.h"
23 #include "net/http/http_status_code.h"
24 #include "services/network/public/cpp/resource_request.h"
25 #include "services/network/test/test_url_loader_factory.h"
26 #include "services/network/test/test_utils.h"
27 #include "testing/gmock/include/gmock/gmock.h"
28 #include "testing/gtest/include/gtest/gtest.h"
29 #include "url/gurl.h"
30 
31 namespace chromeos {
32 
33 namespace {
34 
35 constexpr char kFakeUrl[] = "https://fake.url.com";
36 constexpr char kLocalhostUrl[] = "https://localhost:8000/";
37 constexpr char kIncorrectHttpUrl[] = "http://fake.url.com";
38 constexpr char kInvalidUrl[] = "\0\0\1invalid_url";
39 constexpr char kFakeRequestBody[] = "Fake\0Request\11Body\n\0";
40 constexpr char kFakeResponseBody[] = "Fake\11Response\0\0\nBody";
41 
42 // Tests for the WilcoDtcSupportdWebRequestService class.
43 class WilcoDtcSupportdWebRequestServiceTest : public testing::Test {
44  protected:
45   struct WebRequestResult {
WebRequestResultchromeos::__anon5d030d5b0111::WilcoDtcSupportdWebRequestServiceTest::WebRequestResult46     WebRequestResult(
47         wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus status,
48         int http_status,
49         mojo::ScopedHandle response_body_handle)
50         : status(status), http_status(http_status) {
51       if (!response_body_handle.is_valid()) {
52         response_body = "";
53         return;
54       }
55       base::ReadOnlySharedMemoryMapping shared_memory;
56       response_body = std::string(MojoUtils::GetStringPieceFromMojoHandle(
57           std::move(response_body_handle), &shared_memory));
58       if (!shared_memory.IsValid()) {
59         response_body = "";
60         return;
61       }
62     }
63 
64     wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus status;
65     int http_status;
66     std::string response_body;
67   };
68 
WilcoDtcSupportdWebRequestServiceTest()69   WilcoDtcSupportdWebRequestServiceTest() {
70     auto testing_network_context =
71         std::make_unique<TestingWilcoDtcSupportdNetworkContext>();
72     testing_network_context_ = testing_network_context.get();
73 
74     web_request_service_ = std::make_unique<WilcoDtcSupportdWebRequestService>(
75         std::move(testing_network_context));
76   }
77 
~WilcoDtcSupportdWebRequestServiceTest()78   ~WilcoDtcSupportdWebRequestServiceTest() override {}
79 
TearDown()80   void TearDown() override {
81     if (testing_network_context_) {
82       testing_network_context_->test_url_loader_factory()->ClearResponses();
83     }
84   }
85 
86   // Start new web request with the next parameters:
87   // * web request parameters:
88   //   * |http_method|
89   //   * |url|
90   //   * |headers|
91   //   * |request_body|
92   // * |request_result| - once the request is complete, this structure contains
93   //                      web response.
94   // * |run_loop| - the current run loop.
StartWebRequest(wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod http_method,const std::string & url,const std::vector<base::StringPiece> & headers,const std::string & request_body,std::unique_ptr<WebRequestResult> * request_result,base::RunLoop * run_loop)95   void StartWebRequest(
96       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod
97           http_method,
98       const std::string& url,
99       const std::vector<base::StringPiece>& headers,
100       const std::string& request_body,
101       std::unique_ptr<WebRequestResult>* request_result,
102       base::RunLoop* run_loop) {
103     web_request_service()->PerformRequest(
104         http_method, GURL(url), headers, request_body,
105         base::BindOnce(
106             &WilcoDtcSupportdWebRequestServiceTest::OnRequestComplete,
107             base::Unretained(this), request_result, run_loop->QuitClosure()));
108   }
109 
110   // Injects the web response for |url|.
InjectNetworkResponse(const std::string & url,std::unique_ptr<net::HttpStatusCode> response_status,net::Error net_error,const std::string & response_body)111   void InjectNetworkResponse(
112       const std::string& url,
113       std::unique_ptr<net::HttpStatusCode> response_status,
114       net::Error net_error,
115       const std::string& response_body) {
116     auto response_head = response_status
117                              ? network::CreateURLResponseHead(*response_status)
118                              : network::mojom::URLResponseHead::New();
119     ASSERT_TRUE(testing_network_context_);
120     testing_network_context_->test_url_loader_factory()->AddResponse(
121         GURL(url), std::move(response_head), response_body,
122         network::URLLoaderCompletionStatus(net_error));
123   }
124 
DestroyService()125   void DestroyService() {
126     testing_network_context_ = nullptr;
127     web_request_service_.reset();
128   }
129 
web_request_service()130   WilcoDtcSupportdWebRequestService* web_request_service() {
131     return web_request_service_.get();
132   }
133 
134   // Returns a Content-Type header value or empty string if none.
GetContentTypeFromPendingRequest(const std::string & url)135   std::string GetContentTypeFromPendingRequest(const std::string& url) {
136     DCHECK(testing_network_context_);
137     const network::ResourceRequest* request;
138     if (!testing_network_context_->test_url_loader_factory()->IsPending(
139             GURL(url).spec(), &request) ||
140         !request) {
141       return "";
142     }
143     std::string content_type_value;
144     if (!request->headers.GetHeader(net::HttpRequestHeaders::kContentType,
145                                     &content_type_value)) {
146       return "";
147     }
148     return content_type_value;
149   }
150 
151  private:
OnRequestComplete(std::unique_ptr<WebRequestResult> * request_result,base::RepeatingClosure callback,wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus status,int http_status,mojo::ScopedHandle response_body)152   void OnRequestComplete(
153       std::unique_ptr<WebRequestResult>* request_result,
154       base::RepeatingClosure callback,
155       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus status,
156       int http_status,
157       mojo::ScopedHandle response_body) {
158     auto response = std::make_unique<WebRequestResult>(
159         status, http_status, std::move(response_body));
160     *request_result = std::move(response);
161     std::move(callback).Run();
162   }
163 
164   std::unique_ptr<WilcoDtcSupportdWebRequestService> web_request_service_;
165   base::test::SingleThreadTaskEnvironment task_environment_;
166 
167   // Owned by |web_request_service_|.
168   TestingWilcoDtcSupportdNetworkContext* testing_network_context_ = nullptr;
169 };
170 
171 }  // namespace
172 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodInvalid)173 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodInvalid) {
174   std::unique_ptr<WebRequestResult> request_result;
175   base::RunLoop run_loop;
176 
177   const auto kInvalidHttpMethod = static_cast<
178       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod>(
179       static_cast<int>(wilco_dtc_supportd::mojom::
180                            WilcoDtcSupportdWebRequestHttpMethod::kMaxValue) +
181       1);
182 
183   StartWebRequest(kInvalidHttpMethod, kFakeUrl, {} /* headers */,
184                   kFakeRequestBody, &request_result, &run_loop);
185   // The test fails with a network error on the same thread.
186   ASSERT_TRUE(request_result);
187   EXPECT_EQ(request_result->status,
188             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
189                 kNetworkError);
190   EXPECT_EQ(request_result->http_status, 0);
191   EXPECT_EQ(request_result->response_body, "");
192 }
193 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodGetNonEmptyBody)194 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodGetNonEmptyBody) {
195   std::unique_ptr<WebRequestResult> request_result;
196   base::RunLoop run_loop;
197 
198   StartWebRequest(
199       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kGet,
200       kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result, &run_loop);
201   // The test fails with a network error on the same thread.
202   ASSERT_TRUE(request_result);
203   EXPECT_EQ(request_result->status,
204             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
205                 kNetworkError);
206   EXPECT_EQ(request_result->http_status, 0);
207   EXPECT_EQ(request_result->response_body, "");
208 }
209 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodHeadEmptyBody)210 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodHeadEmptyBody) {
211   std::unique_ptr<WebRequestResult> request_result;
212   base::RunLoop run_loop;
213 
214   StartWebRequest(
215       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
216       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
217       &run_loop);
218   EXPECT_FALSE(request_result);
219   InjectNetworkResponse(kFakeUrl,
220                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
221                         net::OK, "" /* response_body */);
222   run_loop.Run();
223   ASSERT_TRUE(request_result);
224   EXPECT_EQ(request_result->status,
225             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
226   EXPECT_EQ(request_result->http_status, net::HTTP_OK);
227   EXPECT_EQ(request_result->response_body, "");
228 }
229 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodPostNonEmptyBody)230 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodPostNonEmptyBody) {
231   constexpr char kContentTypeValue[] = "text/xml";
232   const std::string kContentTypeHeader = base::StringPrintf(
233       "%s:%s", net::HttpRequestHeaders::kContentType, kContentTypeValue);
234   std::unique_ptr<WebRequestResult> request_result;
235   base::RunLoop run_loop;
236 
237   StartWebRequest(
238       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPost,
239       kFakeUrl, {kContentTypeHeader}, kFakeRequestBody, &request_result,
240       &run_loop);
241   EXPECT_FALSE(request_result);
242   EXPECT_EQ(kContentTypeValue, GetContentTypeFromPendingRequest(kFakeUrl));
243   InjectNetworkResponse(kFakeUrl,
244                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
245                         net::OK, kFakeResponseBody);
246   run_loop.Run();
247   ASSERT_TRUE(request_result);
248   EXPECT_EQ(request_result->status,
249             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
250   EXPECT_EQ(request_result->http_status, net::HTTP_OK);
251   EXPECT_EQ(request_result->response_body, kFakeResponseBody);
252 }
253 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodPutEmptyBody)254 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodPutEmptyBody) {
255   std::unique_ptr<WebRequestResult> request_result;
256   base::RunLoop run_loop;
257 
258   StartWebRequest(
259       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPut,
260       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
261       &run_loop);
262   EXPECT_FALSE(request_result);
263   InjectNetworkResponse(kFakeUrl,
264                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
265                         net::OK, "" /* response_body */);
266   run_loop.Run();
267   ASSERT_TRUE(request_result);
268   EXPECT_EQ(request_result->status,
269             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
270   EXPECT_EQ(request_result->http_status, net::HTTP_OK);
271   EXPECT_EQ(request_result->response_body, "");
272 }
273 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpMethodPatchEmptyBody)274 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpMethodPatchEmptyBody) {
275   std::unique_ptr<WebRequestResult> request_result;
276   base::RunLoop run_loop;
277 
278   StartWebRequest(
279       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPatch,
280       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
281       &run_loop);
282   EXPECT_FALSE(request_result);
283   InjectNetworkResponse(kFakeUrl,
284                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
285                         net::OK, "" /* response_body */);
286   run_loop.Run();
287   ASSERT_TRUE(request_result);
288   EXPECT_EQ(request_result->status,
289             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
290   EXPECT_EQ(request_result->http_status, net::HTTP_OK);
291   EXPECT_EQ(request_result->response_body, "");
292 }
293 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,ResponseCodeParsingError)294 TEST_F(WilcoDtcSupportdWebRequestServiceTest, ResponseCodeParsingError) {
295   std::unique_ptr<WebRequestResult> request_result;
296   base::RunLoop run_loop;
297 
298   StartWebRequest(
299       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPost,
300       kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result, &run_loop);
301   EXPECT_FALSE(request_result);
302   InjectNetworkResponse(kFakeUrl, nullptr /* response_status */, net::OK,
303                         "" /* response_body */);
304   run_loop.Run();
305   ASSERT_TRUE(request_result);
306   EXPECT_EQ(
307       request_result->status,
308       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kHttpError);
309   EXPECT_EQ(request_result->http_status, net::HTTP_INTERNAL_SERVER_ERROR);
310   EXPECT_EQ(request_result->response_body, "");
311 }
312 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,ResponseCodeParsingErrorNetError)313 TEST_F(WilcoDtcSupportdWebRequestServiceTest,
314        ResponseCodeParsingErrorNetError) {
315   std::unique_ptr<WebRequestResult> request_result;
316   base::RunLoop run_loop;
317 
318   StartWebRequest(
319       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kGet,
320       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
321       &run_loop);
322   EXPECT_FALSE(request_result);
323   InjectNetworkResponse(kFakeUrl, nullptr /* response_status */,
324                         net::ERR_CERT_INVALID, kFakeResponseBody);
325   run_loop.Run();
326   ASSERT_TRUE(request_result);
327   EXPECT_EQ(request_result->status,
328             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
329                 kNetworkError);
330   EXPECT_EQ(request_result->http_status, 0);
331   EXPECT_EQ(request_result->response_body, "");
332 }
333 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpStatusOkNetError)334 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpStatusOkNetError) {
335   std::unique_ptr<WebRequestResult> request_result;
336   base::RunLoop run_loop;
337 
338   StartWebRequest(
339       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPost,
340       kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result, &run_loop);
341   EXPECT_FALSE(request_result);
342   InjectNetworkResponse(kFakeUrl,
343                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
344                         net::ERR_CERT_INVALID, kFakeResponseBody);
345   run_loop.Run();
346   ASSERT_TRUE(request_result);
347   EXPECT_EQ(request_result->status,
348             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
349                 kNetworkError);
350   EXPECT_EQ(request_result->http_status, 0);
351   EXPECT_EQ(request_result->response_body, "");
352 }
353 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpErrorNetError)354 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpErrorNetError) {
355   std::unique_ptr<WebRequestResult> request_result;
356   base::RunLoop run_loop;
357 
358   StartWebRequest(
359       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPost,
360       kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result, &run_loop);
361   EXPECT_FALSE(request_result);
362   InjectNetworkResponse(
363       kFakeUrl, std::make_unique<net::HttpStatusCode>(net::HTTP_BAD_REQUEST),
364       net::ERR_CERT_INVALID, kFakeResponseBody);
365   run_loop.Run();
366   ASSERT_TRUE(request_result);
367   EXPECT_EQ(request_result->status,
368             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
369                 kNetworkError);
370   EXPECT_EQ(request_result->http_status, 0);
371   EXPECT_EQ(request_result->response_body, "");
372 }
373 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,DestroyServiceWithActiveWebRequest)374 TEST_F(WilcoDtcSupportdWebRequestServiceTest,
375        DestroyServiceWithActiveWebRequest) {
376   std::unique_ptr<WebRequestResult> request_result;
377   base::RunLoop run_loop;
378 
379   StartWebRequest(
380       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPost,
381       kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result, &run_loop);
382   InjectNetworkResponse(kFakeUrl,
383                         std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
384                         net::OK, kFakeResponseBody);
385   EXPECT_FALSE(request_result);
386   DestroyService();
387   run_loop.Run();
388 
389   ASSERT_TRUE(request_result);
390   EXPECT_EQ(request_result->status,
391             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
392                 kNetworkError);
393   EXPECT_EQ(request_result->http_status, 0);
394   EXPECT_EQ(request_result->response_body, "");
395 }
396 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,TwoWebRequests)397 TEST_F(WilcoDtcSupportdWebRequestServiceTest, TwoWebRequests) {
398   constexpr int kNumberOfRequests = 2;
399 
400   std::unique_ptr<WebRequestResult> request_results[kNumberOfRequests];
401   base::RunLoop run_loops[kNumberOfRequests];
402 
403   for (int i = 0; i < kNumberOfRequests; ++i) {
404     StartWebRequest(
405         wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPut,
406         kFakeUrl, {} /* headers */, kFakeRequestBody, &request_results[i],
407         &run_loops[i]);
408     InjectNetworkResponse(kFakeUrl,
409                           std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
410                           net::OK, kFakeResponseBody);
411     EXPECT_FALSE(request_results[i]);
412   }
413 
414   // The first request is active and the second is in the queue.
415   EXPECT_EQ(kNumberOfRequests - 1,
416             web_request_service()->request_queue_size_for_testing());
417   for (auto& run_loop : run_loops) {
418     run_loop.Run();
419   }
420   EXPECT_EQ(0, web_request_service()->request_queue_size_for_testing());
421 
422   for (const auto& request_result : request_results) {
423     ASSERT_TRUE(request_result);
424     EXPECT_EQ(request_result->status,
425               wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
426     EXPECT_EQ(request_result->http_status, net::HTTP_OK);
427     EXPECT_EQ(request_result->response_body, kFakeResponseBody);
428   }
429 }
430 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,RequestQueueOverflow)431 TEST_F(WilcoDtcSupportdWebRequestServiceTest, RequestQueueOverflow) {
432   // The number of requests in the queue is
433   // kWilcoDtcSupportdRequestQueueMaxSize. One is already pending.
434   std::unique_ptr<WebRequestResult>
435       request_results[kWilcoDtcSupportdWebRequestQueueMaxSize + 1];
436   base::RunLoop run_loops[kWilcoDtcSupportdWebRequestQueueMaxSize + 1];
437 
438   for (int i = 0; i < kWilcoDtcSupportdWebRequestQueueMaxSize + 1; ++i) {
439     StartWebRequest(
440         wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPut,
441         kFakeUrl, {} /* headers */, kFakeRequestBody, &request_results[i],
442         &run_loops[i]);
443     InjectNetworkResponse(kFakeUrl,
444                           std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
445                           net::OK, kFakeResponseBody);
446     EXPECT_FALSE(request_results[i]);
447   }
448   EXPECT_EQ(kWilcoDtcSupportdWebRequestQueueMaxSize,
449             web_request_service()->request_queue_size_for_testing());
450 
451   // Try to add one more. Should fail with kNetworkError.
452   {
453     std::unique_ptr<WebRequestResult> request_result;
454     base::RunLoop run_loop;
455     StartWebRequest(
456         wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kPut,
457         kFakeUrl, {} /* headers */, kFakeRequestBody, &request_result,
458         &run_loop);
459     InjectNetworkResponse(kFakeUrl,
460                           std::make_unique<net::HttpStatusCode>(net::HTTP_OK),
461                           net::OK, kFakeResponseBody);
462     // The test fails with a network error on the same thread.
463     EXPECT_TRUE(request_result);
464     EXPECT_EQ(request_result->status,
465               wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
466                   kNetworkError);
467     EXPECT_EQ(request_result->http_status, 0);
468     EXPECT_EQ(request_result->response_body, "");
469   }
470   for (auto& run_loop : run_loops) {
471     run_loop.Run();
472   }
473   for (const auto& request_result : request_results) {
474     EXPECT_TRUE(request_result);
475     EXPECT_EQ(request_result->status,
476               wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
477     EXPECT_EQ(request_result->http_status, net::HTTP_OK);
478     EXPECT_EQ(request_result->response_body, kFakeResponseBody);
479   }
480 }
481 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,ResponseBodyMaxSize)482 TEST_F(WilcoDtcSupportdWebRequestServiceTest, ResponseBodyMaxSize) {
483   std::unique_ptr<WebRequestResult> request_result;
484   base::RunLoop run_loop;
485 
486   StartWebRequest(
487       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
488       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
489       &run_loop);
490   EXPECT_FALSE(request_result);
491   InjectNetworkResponse(
492       kFakeUrl, std::make_unique<net::HttpStatusCode>(net::HTTP_OK), net::OK,
493       std::string(kWilcoDtcSupportdWebResponseMaxSizeInBytes, 'A'));
494   run_loop.Run();
495   ASSERT_TRUE(request_result);
496   EXPECT_EQ(request_result->status,
497             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::kOk);
498   EXPECT_EQ(request_result->http_status, net::HTTP_OK);
499   EXPECT_EQ(request_result->response_body,
500             std::string(kWilcoDtcSupportdWebResponseMaxSizeInBytes, 'A'));
501 }
502 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,ResponseBodyOverflow)503 TEST_F(WilcoDtcSupportdWebRequestServiceTest, ResponseBodyOverflow) {
504   std::unique_ptr<WebRequestResult> request_result;
505   base::RunLoop run_loop;
506 
507   StartWebRequest(
508       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
509       kFakeUrl, {} /* headers */, "" /* request_body */, &request_result,
510       &run_loop);
511   EXPECT_FALSE(request_result);
512   InjectNetworkResponse(
513       kFakeUrl, std::make_unique<net::HttpStatusCode>(net::HTTP_OK), net::OK,
514       std::string(kWilcoDtcSupportdWebResponseMaxSizeInBytes + 1, 'A'));
515   run_loop.Run();
516   ASSERT_TRUE(request_result);
517   EXPECT_EQ(request_result->status,
518             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
519                 kNetworkError);
520   EXPECT_EQ(request_result->http_status, 0);
521   EXPECT_EQ(request_result->response_body, "");
522 }
523 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,LocalhostRequestNetworkError)524 TEST_F(WilcoDtcSupportdWebRequestServiceTest, LocalhostRequestNetworkError) {
525   std::unique_ptr<WebRequestResult> request_result;
526   base::RunLoop run_loop;
527 
528   StartWebRequest(
529       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
530       kLocalhostUrl, {} /* headers */, "" /* request_body */, &request_result,
531       &run_loop);
532   // The test fails with a network error on the same thread.
533   run_loop.Run();
534   ASSERT_TRUE(request_result);
535   EXPECT_EQ(request_result->status,
536             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
537                 kNetworkError);
538   EXPECT_EQ(request_result->http_status, 0);
539   EXPECT_EQ(request_result->response_body, "");
540 }
541 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,HttpUrlNetworkError)542 TEST_F(WilcoDtcSupportdWebRequestServiceTest, HttpUrlNetworkError) {
543   std::unique_ptr<WebRequestResult> request_result;
544   base::RunLoop run_loop;
545 
546   StartWebRequest(
547       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
548       kIncorrectHttpUrl, {} /* headers */, "" /* request_body */,
549       &request_result, &run_loop);
550   // The test fails with a network error on the same thread.
551   ASSERT_TRUE(request_result);
552   EXPECT_EQ(request_result->status,
553             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
554                 kNetworkError);
555   EXPECT_EQ(request_result->http_status, 0);
556   EXPECT_EQ(request_result->response_body, "");
557 }
558 
TEST_F(WilcoDtcSupportdWebRequestServiceTest,InvalidUrlNetworkError)559 TEST_F(WilcoDtcSupportdWebRequestServiceTest, InvalidUrlNetworkError) {
560   std::unique_ptr<WebRequestResult> request_result;
561   base::RunLoop run_loop;
562 
563   StartWebRequest(
564       wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestHttpMethod::kHead,
565       kInvalidUrl, {} /* headers */, "" /* request_body */, &request_result,
566       &run_loop);
567   // The test fails with a network error on the same thread.
568   ASSERT_TRUE(request_result);
569   EXPECT_EQ(request_result->status,
570             wilco_dtc_supportd::mojom::WilcoDtcSupportdWebRequestStatus::
571                 kNetworkError);
572   EXPECT_EQ(request_result->http_status, 0);
573   EXPECT_EQ(request_result->response_body, "");
574 }
575 }  // namespace chromeos
576