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