1 // Copyright 2024 The Chromium Authors
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 <algorithm>
6 #include <memory>
7 #include <optional>
8 #include <string>
9 #include <string_view>
10 #include <vector>
11
12 #include "base/functional/callback.h"
13 #include "base/run_loop.h"
14 #include "base/test/bind.h"
15 #include "base/test/scoped_feature_list.h"
16 #include "base/time/time.h"
17 #include "net/base/address_family.h"
18 #include "net/base/features.h"
19 #include "net/base/net_errors.h"
20 #include "net/base/network_anonymization_key.h"
21 #include "net/dns/address_sorter.h"
22 #include "net/dns/dns_task_results_manager.h"
23 #include "net/dns/dns_test_util.h"
24 #include "net/dns/host_resolver.h"
25 #include "net/dns/host_resolver_manager_service_endpoint_request_impl.h"
26 #include "net/dns/host_resolver_manager_unittest.h"
27 #include "net/dns/host_resolver_results_test_util.h"
28 #include "net/dns/public/host_resolver_results.h"
29 #include "net/dns/public/host_resolver_source.h"
30 #include "net/dns/resolve_context.h"
31 #include "net/log/net_log_with_source.h"
32 #include "net/test/gtest_util.h"
33 #include "testing/gmock/include/gmock/gmock.h"
34 #include "testing/gtest/include/gtest/gtest.h"
35 #include "url/scheme_host_port.h"
36
37 using ::testing::ElementsAre;
38 using ::testing::IsEmpty;
39 using ::testing::UnorderedElementsAre;
40
41 using net::test::IsError;
42 using net::test::IsOk;
43
44 namespace net {
45
46 using ServiceEndpointRequest = HostResolver::ServiceEndpointRequest;
47 using ResolveHostRequest = HostResolver::ResolveHostRequest;
48 using ResolveHostParameters = HostResolver::ResolveHostParameters;
49
50 namespace {
51
MakeIPEndPoint(std::string_view ip_literal,uint16_t port=0)52 IPEndPoint MakeIPEndPoint(std::string_view ip_literal, uint16_t port = 0) {
53 std::optional<IPAddress> ip = IPAddress::FromIPLiteral(std::move(ip_literal));
54 return IPEndPoint(*ip, port);
55 }
56
57 // Sorts endpoints using IPAddress's comparator.
58 class FakeAddressSorter : public AddressSorter {
59 public:
Sort(const std::vector<IPEndPoint> & endpoints,CallbackType callback) const60 void Sort(const std::vector<IPEndPoint>& endpoints,
61 CallbackType callback) const override {
62 std::vector<IPEndPoint> sorted = endpoints;
63 std::sort(sorted.begin(), sorted.end(),
64 [](const IPEndPoint& a, const IPEndPoint& b) {
65 return a.address() < b.address();
66 });
67 std::move(callback).Run(true, sorted);
68 }
69 };
70
71 class Requester : public ServiceEndpointRequest::Delegate {
72 public:
Requester(std::unique_ptr<ServiceEndpointRequest> request)73 explicit Requester(std::unique_ptr<ServiceEndpointRequest> request)
74 : request_(std::move(request)) {}
75
76 ~Requester() override = default;
77
78 // ServiceEndpointRequest::Delegate overrides:
79
OnServiceEndpointsUpdated()80 void OnServiceEndpointsUpdated() override {
81 if (on_updated_callback_) {
82 std::move(on_updated_callback_).Run();
83 }
84 }
85
OnServiceEndpointRequestFinished(int rv)86 void OnServiceEndpointRequestFinished(int rv) override {
87 SetFinishedResult(rv);
88
89 if (on_finished_callback_) {
90 std::move(on_finished_callback_).Run();
91 }
92
93 if (wait_for_finished_callback_) {
94 std::move(wait_for_finished_callback_).Run();
95 }
96 }
97
Start()98 int Start() {
99 int rv = request_->Start(this);
100 if (rv != ERR_IO_PENDING) {
101 SetFinishedResult(rv);
102 }
103 return rv;
104 }
105
CancelRequest()106 void CancelRequest() { request_.reset(); }
107
CancelRequestOnUpdated()108 void CancelRequestOnUpdated() {
109 SetOnUpdatedCallback(base::BindLambdaForTesting([&] { CancelRequest(); }));
110 }
111
CancelRequestOnFinished()112 void CancelRequestOnFinished() {
113 SetOnFinishedCallback(base::BindLambdaForTesting([&] { CancelRequest(); }));
114 }
115
SetOnUpdatedCallback(base::OnceClosure callback)116 void SetOnUpdatedCallback(base::OnceClosure callback) {
117 CHECK(!finished_result_);
118 CHECK(!on_updated_callback_);
119 on_updated_callback_ = std::move(callback);
120 }
121
SetOnFinishedCallback(base::OnceClosure callback)122 void SetOnFinishedCallback(base::OnceClosure callback) {
123 CHECK(!finished_result_);
124 CHECK(!on_finished_callback_);
125 on_finished_callback_ = std::move(callback);
126 }
127
WaitForFinished()128 void WaitForFinished() {
129 CHECK(!finished_result_);
130 CHECK(!wait_for_finished_callback_);
131 base::RunLoop run_loop;
132 wait_for_finished_callback_ = run_loop.QuitClosure();
133 run_loop.Run();
134 }
135
request() const136 ServiceEndpointRequest* request() const { return request_.get(); }
137
finished_result() const138 std::optional<int> finished_result() const { return finished_result_; }
139
finished_endpoints() const140 const std::vector<ServiceEndpoint>& finished_endpoints() const {
141 CHECK(finished_result_.has_value());
142 return finished_endpoints_;
143 }
144
145 private:
SetFinishedResult(int rv)146 void SetFinishedResult(int rv) {
147 CHECK(!finished_result_);
148 finished_result_ = rv;
149
150 if (request_) {
151 finished_endpoints_ = request_->GetEndpointResults();
152 }
153 }
154
155 std::unique_ptr<ServiceEndpointRequest> request_;
156
157 std::optional<int> finished_result_;
158 std::vector<ServiceEndpoint> finished_endpoints_;
159
160 base::OnceClosure wait_for_finished_callback_;
161 base::OnceClosure on_updated_callback_;
162 base::OnceClosure on_finished_callback_;
163 };
164
165 class LegacyRequester {
166 public:
LegacyRequester(std::unique_ptr<ResolveHostRequest> request)167 explicit LegacyRequester(std::unique_ptr<ResolveHostRequest> request)
168 : request_(std::move(request)) {}
169
170 ~LegacyRequester() = default;
171
Start()172 int Start() {
173 return request_->Start(
174 base::BindOnce(&LegacyRequester::OnComplete, base::Unretained(this)));
175 }
176
CancelRequest()177 void CancelRequest() { request_.reset(); }
178
complete_result() const179 std::optional<int> complete_result() const { return complete_result_; }
180
181 private:
OnComplete(int rv)182 void OnComplete(int rv) { complete_result_ = rv; }
183
184 std::unique_ptr<ResolveHostRequest> request_;
185 std::optional<int> complete_result_;
186 };
187
188 } // namespace
189
190 class HostResolverServiceEndpointRequestTest
191 : public HostResolverManagerDnsTest {
192 public:
HostResolverServiceEndpointRequestTest()193 HostResolverServiceEndpointRequestTest() {
194 feature_list_.InitAndEnableFeature(features::kUseServiceEndpointRequest);
195 }
196
197 ~HostResolverServiceEndpointRequestTest() override = default;
198
199 protected:
SetUp()200 void SetUp() override {
201 HostResolverManagerDnsTest::SetUp();
202
203 // MockHostResolverProc resolves all requests to "127.0.0.1" when there is
204 // no rule. Add a rule to prevent the default behavior.
205 proc_->AddRule(std::string(), ADDRESS_FAMILY_UNSPECIFIED, "192.0.2.1");
206 }
207
SetDnsRules(MockDnsClientRuleList rules)208 void SetDnsRules(MockDnsClientRuleList rules) {
209 CreateResolver();
210 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
211 }
212
UseNoDomanDnsRules(const std::string & host)213 void UseNoDomanDnsRules(const std::string& host) {
214 MockDnsClientRuleList rules;
215 AddDnsRule(&rules, host, dns_protocol::kTypeA,
216 MockDnsClientRule::ResultType::kNoDomain, /*delay=*/false);
217 AddDnsRule(&rules, host, dns_protocol::kTypeAAAA,
218 MockDnsClientRule::ResultType::kNoDomain, /*delay=*/false);
219 SetDnsRules(std::move(rules));
220 }
221
UseNonDelayedDnsRules(const std::string & host)222 void UseNonDelayedDnsRules(const std::string& host) {
223 MockDnsClientRuleList rules;
224 AddDnsRule(&rules, host, dns_protocol::kTypeA,
225 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
226 AddDnsRule(&rules, host, dns_protocol::kTypeAAAA,
227 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
228 SetDnsRules(std::move(rules));
229 }
230
UseIpv4DelayedDnsRules(const std::string & host)231 void UseIpv4DelayedDnsRules(const std::string& host) {
232 MockDnsClientRuleList rules;
233 AddDnsRule(&rules, host, dns_protocol::kTypeA,
234 MockDnsClientRule::ResultType::kOk, /*delay=*/true);
235 AddDnsRule(&rules, host, dns_protocol::kTypeAAAA,
236 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
237 SetDnsRules(std::move(rules));
238 }
239
UseIpv6DelayedDnsRules(const std::string & host)240 void UseIpv6DelayedDnsRules(const std::string& host) {
241 MockDnsClientRuleList rules;
242 AddDnsRule(&rules, host, dns_protocol::kTypeA,
243 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
244 AddDnsRule(&rules, host, dns_protocol::kTypeAAAA,
245 MockDnsClientRule::ResultType::kOk, /*delay=*/true);
246 SetDnsRules(std::move(rules));
247 }
248
UseHttpsDelayedDnsRules(const std::string & host)249 void UseHttpsDelayedDnsRules(const std::string& host) {
250 MockDnsClientRuleList rules;
251 AddDnsRule(&rules, host, dns_protocol::kTypeA,
252 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
253 AddDnsRule(&rules, host, dns_protocol::kTypeAAAA,
254 MockDnsClientRule::ResultType::kOk, /*delay=*/false);
255
256 std::vector<DnsResourceRecord> records = {
257 BuildTestHttpsServiceRecord(host, /*priority=*/1, /*service_name=*/".",
258 /*params=*/{})};
259 rules.emplace_back(host, dns_protocol::kTypeHttps,
260 /*secure=*/false,
261 MockDnsClientRule::Result(BuildTestDnsResponse(
262 host, dns_protocol::kTypeHttps, records)),
263 /*delay=*/true);
264 SetDnsRules(std::move(rules));
265 }
266
CreateRequest(std::string_view host,ResolveHostParameters parameters=ResolveHostParameters ())267 std::unique_ptr<ServiceEndpointRequest> CreateRequest(
268 std::string_view host,
269 ResolveHostParameters parameters = ResolveHostParameters()) {
270 return resolver_->CreateServiceEndpointRequest(
271 url::SchemeHostPort(GURL(host)), NetworkAnonymizationKey(),
272 NetLogWithSource(), std::move(parameters), resolve_context_.get());
273 }
274
CreateRequester(std::string_view host,ResolveHostParameters parameters=ResolveHostParameters ())275 Requester CreateRequester(
276 std::string_view host,
277 ResolveHostParameters parameters = ResolveHostParameters()) {
278 return Requester(CreateRequest(host, std::move(parameters)));
279 }
280
CreateLegacyRequester(std::string_view host)281 LegacyRequester CreateLegacyRequester(std::string_view host) {
282 return LegacyRequester(resolver_->CreateRequest(
283 url::SchemeHostPort(GURL(host)), NetworkAnonymizationKey(),
284 NetLogWithSource(), ResolveHostParameters(), resolve_context_.get()));
285 }
286
287 private:
288 base::test::ScopedFeatureList feature_list_;
289 };
290
TEST_F(HostResolverServiceEndpointRequestTest,NameNotResolved)291 TEST_F(HostResolverServiceEndpointRequestTest, NameNotResolved) {
292 UseNoDomanDnsRules("nodomain");
293
294 proc_->SignalMultiple(1u);
295 Requester requester = CreateRequester("https://nodomain");
296 int rv = requester.Start();
297 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
298 requester.WaitForFinished();
299 EXPECT_THAT(*requester.finished_result(), IsError(ERR_NAME_NOT_RESOLVED));
300 }
301
TEST_F(HostResolverServiceEndpointRequestTest,Ok)302 TEST_F(HostResolverServiceEndpointRequestTest, Ok) {
303 UseNonDelayedDnsRules("ok");
304
305 Requester requester = CreateRequester("https://ok");
306 int rv = requester.Start();
307 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
308 requester.WaitForFinished();
309 EXPECT_THAT(*requester.finished_result(), IsOk());
310 EXPECT_THAT(requester.finished_endpoints(),
311 ElementsAre(ExpectServiceEndpoint(
312 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
313 ElementsAre(MakeIPEndPoint("::1", 443)))));
314 }
315
TEST_F(HostResolverServiceEndpointRequestTest,ResolveLocally)316 TEST_F(HostResolverServiceEndpointRequestTest, ResolveLocally) {
317 UseNonDelayedDnsRules("ok");
318
319 // The first local only request should complete synchronously with a cache
320 // miss.
321 {
322 ResolveHostParameters parameters;
323 parameters.source = HostResolverSource::LOCAL_ONLY;
324 Requester requester = CreateRequester("https://ok", std::move(parameters));
325 int rv = requester.Start();
326 EXPECT_THAT(rv, IsError(ERR_DNS_CACHE_MISS));
327 }
328
329 // Populate the cache.
330 {
331 Requester requester = CreateRequester("https://ok");
332 int rv = requester.Start();
333 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
334 requester.WaitForFinished();
335 EXPECT_THAT(*requester.finished_result(), IsOk());
336 EXPECT_THAT(requester.finished_endpoints(),
337 ElementsAre(ExpectServiceEndpoint(
338 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
339 ElementsAre(MakeIPEndPoint("::1", 443)))));
340 }
341
342 // The second local only request should complete synchronously with a cache
343 // hit.
344 {
345 ResolveHostParameters parameters;
346 parameters.source = HostResolverSource::LOCAL_ONLY;
347 Requester requester = CreateRequester("https://ok", std::move(parameters));
348 int rv = requester.Start();
349 EXPECT_THAT(rv, IsOk());
350 EXPECT_THAT(requester.finished_endpoints(),
351 ElementsAre(ExpectServiceEndpoint(
352 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
353 ElementsAre(MakeIPEndPoint("::1", 443)))));
354 }
355 }
356
TEST_F(HostResolverServiceEndpointRequestTest,EndpointsAreSorted)357 TEST_F(HostResolverServiceEndpointRequestTest, EndpointsAreSorted) {
358 MockDnsClientRuleList rules;
359 constexpr const char* kHost = "multiple";
360
361 DnsResponse a_response = BuildTestDnsResponse(
362 kHost, dns_protocol::kTypeA,
363 {BuildTestAddressRecord(kHost, *IPAddress::FromIPLiteral("192.0.2.2")),
364 BuildTestAddressRecord(kHost, *IPAddress::FromIPLiteral("192.0.2.1"))});
365 DnsResponse aaaa_response = BuildTestDnsResponse(
366 kHost, dns_protocol::kTypeAAAA,
367 {BuildTestAddressRecord(kHost, *IPAddress::FromIPLiteral("2001:db8::2")),
368 BuildTestAddressRecord(kHost,
369 *IPAddress::FromIPLiteral("2001:db8::1"))});
370 AddDnsRule(&rules, kHost, dns_protocol::kTypeA, std::move(a_response),
371 /*delay=*/false);
372 AddDnsRule(&rules, kHost, dns_protocol::kTypeAAAA, std::move(aaaa_response),
373 /*delay=*/false);
374
375 CreateResolver();
376 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
377 mock_dns_client_->SetAddressSorterForTesting(
378 std::make_unique<FakeAddressSorter>());
379
380 Requester requester = CreateRequester("https://multiple");
381 int rv = requester.Start();
382 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
383 requester.WaitForFinished();
384 EXPECT_THAT(*requester.finished_result(), IsOk());
385 EXPECT_THAT(requester.finished_endpoints(),
386 ElementsAre(ExpectServiceEndpoint(
387 ElementsAre(MakeIPEndPoint("192.0.2.1", 443),
388 MakeIPEndPoint("192.0.2.2", 443)),
389 ElementsAre(MakeIPEndPoint("2001:db8::1", 443),
390 MakeIPEndPoint("2001:db8::2", 443)))));
391 }
392
TEST_F(HostResolverServiceEndpointRequestTest,CancelRequestOnUpdated)393 TEST_F(HostResolverServiceEndpointRequestTest, CancelRequestOnUpdated) {
394 UseIpv4DelayedDnsRules("4slow_ok");
395
396 Requester requester = CreateRequester("https://4slow_ok");
397 requester.CancelRequestOnUpdated();
398 int rv = requester.Start();
399 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
400 RunUntilIdle();
401 // The finished callback should not be called because the request was
402 // already cancelled.
403 ASSERT_FALSE(requester.finished_result().has_value());
404 ASSERT_FALSE(requester.request());
405 }
406
TEST_F(HostResolverServiceEndpointRequestTest,CancelRequestOnFinished)407 TEST_F(HostResolverServiceEndpointRequestTest, CancelRequestOnFinished) {
408 UseIpv4DelayedDnsRules("4slow_ok");
409
410 Requester requester = CreateRequester("https://4slow_ok");
411 requester.CancelRequestOnFinished();
412 int rv = requester.Start();
413 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
414 mock_dns_client_->CompleteDelayedTransactions();
415 requester.WaitForFinished();
416 // The result should be OK because we cancel the request after completing the
417 // associated Job.
418 EXPECT_THAT(*requester.finished_result(), IsOk());
419 }
420
TEST_F(HostResolverServiceEndpointRequestTest,Ipv4Slow)421 TEST_F(HostResolverServiceEndpointRequestTest, Ipv4Slow) {
422 UseIpv4DelayedDnsRules("4slow_ok");
423
424 Requester requester = CreateRequester("https://4slow_ok");
425 int rv = requester.Start();
426 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
427 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
428
429 // AAAA and HTTPS should complete.
430 RunUntilIdle();
431 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
432 ASSERT_FALSE(requester.finished_result().has_value());
433 ASSERT_TRUE(requester.request()->EndpointsCryptoReady());
434 EXPECT_THAT(requester.request()->GetEndpointResults(),
435 ElementsAre(ExpectServiceEndpoint(
436 IsEmpty(), ElementsAre(MakeIPEndPoint("::1", 443)))));
437 EXPECT_THAT(requester.request()->GetDnsAliasResults(),
438 UnorderedElementsAre("4slow_ok"));
439
440 // Complete A request, which finishes the request synchronously.
441 mock_dns_client_->CompleteDelayedTransactions();
442 ASSERT_TRUE(requester.request()->EndpointsCryptoReady());
443 EXPECT_THAT(*requester.finished_result(), IsOk());
444 EXPECT_THAT(requester.finished_endpoints(),
445 ElementsAre(ExpectServiceEndpoint(
446 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
447 ElementsAre(MakeIPEndPoint("::1", 443)))));
448 EXPECT_THAT(requester.request()->GetDnsAliasResults(),
449 UnorderedElementsAre("4slow_ok"));
450 }
451
TEST_F(HostResolverServiceEndpointRequestTest,Ipv6Slow)452 TEST_F(HostResolverServiceEndpointRequestTest, Ipv6Slow) {
453 UseIpv6DelayedDnsRules("6slow_ok");
454
455 Requester requester = CreateRequester("https://6slow_ok");
456 int rv = requester.Start();
457 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
458 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
459
460 // A and HTTPS should complete, but no endpoints should be available since
461 // waiting for AAAA response.
462 RunUntilIdle();
463 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
464 ASSERT_FALSE(requester.finished_result().has_value());
465 ASSERT_TRUE(requester.request()->EndpointsCryptoReady());
466 EXPECT_THAT(requester.request()->GetEndpointResults(), IsEmpty());
467
468 // Complete AAAA request, which finishes the request synchronously.
469 mock_dns_client_->CompleteDelayedTransactions();
470 EXPECT_THAT(*requester.finished_result(), IsOk());
471 EXPECT_THAT(requester.finished_endpoints(),
472 ElementsAre(ExpectServiceEndpoint(
473 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
474 ElementsAre(MakeIPEndPoint("::1", 443)))));
475 }
476
TEST_F(HostResolverServiceEndpointRequestTest,Ipv6SlowResolutionDelayPassed)477 TEST_F(HostResolverServiceEndpointRequestTest, Ipv6SlowResolutionDelayPassed) {
478 UseIpv6DelayedDnsRules("6slow_ok");
479
480 Requester requester = CreateRequester("https://6slow_ok");
481 int rv = requester.Start();
482 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
483 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
484
485 // A and HTTPS should complete, but no endpoints should be available since
486 // waiting for AAAA response.
487 RunUntilIdle();
488 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
489 ASSERT_FALSE(requester.finished_result().has_value());
490 ASSERT_TRUE(requester.request()->EndpointsCryptoReady());
491 EXPECT_THAT(requester.request()->GetEndpointResults(), IsEmpty());
492
493 // The resolution delay timer fired, IPv4 endpoints should be available.
494 FastForwardBy(DnsTaskResultsManager::kResolutionDelay +
495 base::Milliseconds(1));
496 RunUntilIdle();
497 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
498 ASSERT_FALSE(requester.finished_result().has_value());
499 EXPECT_THAT(requester.request()->GetEndpointResults(),
500 ElementsAre(ExpectServiceEndpoint(
501 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)), IsEmpty())));
502
503 // Complete AAAA request, which finishes the request synchronously.
504 mock_dns_client_->CompleteDelayedTransactions();
505 EXPECT_THAT(*requester.finished_result(), IsOk());
506 EXPECT_THAT(requester.finished_endpoints(),
507 ElementsAre(ExpectServiceEndpoint(
508 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
509 ElementsAre(MakeIPEndPoint("::1", 443)))));
510 }
511
TEST_F(HostResolverServiceEndpointRequestTest,HttpsSlow)512 TEST_F(HostResolverServiceEndpointRequestTest, HttpsSlow) {
513 UseHttpsDelayedDnsRules("https_slow_ok");
514
515 Requester requester = CreateRequester("https://https_slow_ok");
516 int rv = requester.Start();
517 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
518 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
519
520 // A and AAAA should complete.
521 RunUntilIdle();
522 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
523 ASSERT_FALSE(requester.finished_result().has_value());
524 ASSERT_FALSE(requester.request()->EndpointsCryptoReady());
525 EXPECT_THAT(requester.request()->GetEndpointResults(),
526 ElementsAre(ExpectServiceEndpoint(
527 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
528 ElementsAre(MakeIPEndPoint("::1", 443)))));
529
530 // Complete HTTPS request, which finishes the request synchronously.
531 mock_dns_client_->CompleteDelayedTransactions();
532 EXPECT_THAT(*requester.finished_result(), IsOk());
533 EXPECT_THAT(
534 requester.finished_endpoints(),
535 ElementsAre(
536 ExpectServiceEndpoint(
537 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
538 ElementsAre(MakeIPEndPoint("::1", 443)),
539 ConnectionEndpointMetadata(
540 /*supported_protocol_alpns=*/{"http/1.1"},
541 /*ech_config_list=*/{}, std::string("https_slow_ok"))),
542 // Non-SVCB endpoints.
543 ExpectServiceEndpoint(ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
544 ElementsAre(MakeIPEndPoint("::1", 443)))));
545 }
546
TEST_F(HostResolverServiceEndpointRequestTest,DestroyResolverWhileUpdating)547 TEST_F(HostResolverServiceEndpointRequestTest, DestroyResolverWhileUpdating) {
548 // Using 4slow_ok not to complete transactions at once.
549 UseIpv4DelayedDnsRules("4slow_ok");
550
551 Requester requester = CreateRequester("https://4slow_ok");
552 int rv = requester.Start();
553 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
554
555 requester.SetOnUpdatedCallback(
556 base::BindLambdaForTesting([&]() { DestroyResolver(); }));
557
558 RunUntilIdle();
559 EXPECT_THAT(*requester.finished_result(), IsError(ERR_DNS_REQUEST_CANCELLED));
560 }
561
TEST_F(HostResolverServiceEndpointRequestTest,DestroyResolverWhileFinishing)562 TEST_F(HostResolverServiceEndpointRequestTest, DestroyResolverWhileFinishing) {
563 UseNonDelayedDnsRules("ok");
564
565 Requester requester = CreateRequester("https://ok");
566 int rv = requester.Start();
567 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
568
569 requester.SetOnFinishedCallback(
570 base::BindLambdaForTesting([&]() { DestroyResolver(); }));
571
572 RunUntilIdle();
573 EXPECT_THAT(*requester.finished_result(), IsOk());
574 }
575
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsOk)576 TEST_F(HostResolverServiceEndpointRequestTest, MultipleRequestsOk) {
577 UseIpv4DelayedDnsRules("4slow_ok");
578
579 constexpr std::string_view kHost = "https://4slow_ok";
580 Requester requester1 = CreateRequester(kHost);
581 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
582 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
583
584 Requester requester2 = CreateRequester(kHost);
585 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
586 // The second request should share the same job with the first request.
587 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
588
589 RunUntilIdle();
590 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
591
592 // Complete the delayed transaction, which finishes requests synchronously.
593 mock_dns_client_->CompleteDelayedTransactions();
594 EXPECT_THAT(*requester1.finished_result(), IsOk());
595 EXPECT_THAT(requester1.finished_endpoints(),
596 ElementsAre(ExpectServiceEndpoint(
597 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
598 ElementsAre(MakeIPEndPoint("::1", 443)))));
599
600 EXPECT_THAT(*requester2.finished_result(), IsOk());
601 EXPECT_THAT(requester2.finished_endpoints(),
602 ElementsAre(ExpectServiceEndpoint(
603 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
604 ElementsAre(MakeIPEndPoint("::1", 443)))));
605 }
606
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsAddRequestInTheMiddleOfResolution)607 TEST_F(HostResolverServiceEndpointRequestTest,
608 MultipleRequestsAddRequestInTheMiddleOfResolution) {
609 UseIpv4DelayedDnsRules("4slow_ok");
610
611 constexpr std::string_view kHost = "https://4slow_ok";
612 Requester requester1 = CreateRequester(kHost);
613 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
614 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
615
616 // Partially complete transactions. Only IPv6 endpoints should be available.
617 RunUntilIdle();
618 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
619 ASSERT_FALSE(requester1.finished_result().has_value());
620 EXPECT_THAT(requester1.request()->GetEndpointResults(),
621 ElementsAre(ExpectServiceEndpoint(
622 IsEmpty(), ElementsAre(MakeIPEndPoint("::1", 443)))));
623
624 // Add a new request in the middle of resolution. The request should be
625 // attached to the ongoing job.
626 Requester requester2 = CreateRequester(kHost);
627 requester2.CancelRequestOnFinished();
628 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
629 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
630
631 // The second request should have the same intermediate results as the first
632 // request.
633 ASSERT_FALSE(requester2.finished_result().has_value());
634 EXPECT_THAT(requester2.request()->GetEndpointResults(),
635 ElementsAre(ExpectServiceEndpoint(
636 IsEmpty(), ElementsAre(MakeIPEndPoint("::1", 443)))));
637
638 // Complete all transactions. Both requests should finish and have the same
639 // results.
640 mock_dns_client_->CompleteDelayedTransactions();
641 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
642
643 EXPECT_THAT(*requester1.finished_result(), IsOk());
644 EXPECT_THAT(requester1.finished_endpoints(),
645 ElementsAre(ExpectServiceEndpoint(
646 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
647 ElementsAre(MakeIPEndPoint("::1", 443)))));
648
649 EXPECT_THAT(*requester2.finished_result(), IsOk());
650 EXPECT_THAT(requester2.finished_endpoints(),
651 ElementsAre(ExpectServiceEndpoint(
652 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
653 ElementsAre(MakeIPEndPoint("::1", 443)))));
654 }
655
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsAddAndCancelRequestInUpdatedCallback)656 TEST_F(HostResolverServiceEndpointRequestTest,
657 MultipleRequestsAddAndCancelRequestInUpdatedCallback) {
658 UseIpv4DelayedDnsRules("4slow_ok");
659
660 constexpr std::string_view kHost = "https://4slow_ok";
661 Requester requester1 = CreateRequester(kHost);
662 Requester requester2 = CreateRequester(kHost);
663
664 requester1.SetOnUpdatedCallback(base::BindLambdaForTesting([&] {
665 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
666 requester1.CancelRequest();
667 }));
668
669 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
670 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
671
672 // Partially complete transactions. The update callback of the first request
673 // should start the second request and then cancel the first request.
674 RunUntilIdle();
675 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
676
677 ASSERT_FALSE(requester1.finished_result().has_value());
678 ASSERT_FALSE(requester1.request());
679
680 ASSERT_FALSE(requester2.finished_result().has_value());
681 EXPECT_THAT(requester2.request()->GetEndpointResults(),
682 ElementsAre(ExpectServiceEndpoint(
683 IsEmpty(), ElementsAre(MakeIPEndPoint("::1", 443)))));
684
685 // Complete all transactions. The second request should finish successfully.
686 mock_dns_client_->CompleteDelayedTransactions();
687 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
688
689 ASSERT_FALSE(requester1.finished_result().has_value());
690 ASSERT_FALSE(requester1.request());
691
692 EXPECT_THAT(*requester2.finished_result(), IsOk());
693 EXPECT_THAT(requester2.finished_endpoints(),
694 ElementsAre(ExpectServiceEndpoint(
695 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
696 ElementsAre(MakeIPEndPoint("::1", 443)))));
697 }
698
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsAddRequestInFinishedCallback)699 TEST_F(HostResolverServiceEndpointRequestTest,
700 MultipleRequestsAddRequestInFinishedCallback) {
701 UseNonDelayedDnsRules("ok");
702
703 constexpr std::string_view kHost = "https://ok";
704 Requester requester1 = CreateRequester(kHost);
705 Requester requester2 = CreateRequester(kHost);
706
707 requester1.SetOnFinishedCallback(base::BindLambdaForTesting([&] {
708 // The second request should finish synchronously because it should
709 // share the same job as the first one and the job has finished already.
710 EXPECT_THAT(requester2.Start(), IsOk());
711 }));
712
713 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
714 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
715
716 RunUntilIdle();
717 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
718
719 EXPECT_THAT(*requester1.finished_result(), IsOk());
720 EXPECT_THAT(requester1.finished_endpoints(),
721 ElementsAre(ExpectServiceEndpoint(
722 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
723 ElementsAre(MakeIPEndPoint("::1", 443)))));
724
725 EXPECT_THAT(*requester2.finished_result(), IsOk());
726 EXPECT_THAT(requester2.finished_endpoints(),
727 ElementsAre(ExpectServiceEndpoint(
728 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
729 ElementsAre(MakeIPEndPoint("::1", 443)))));
730 }
731
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsCancelOneRequestOnUpdated)732 TEST_F(HostResolverServiceEndpointRequestTest,
733 MultipleRequestsCancelOneRequestOnUpdated) {
734 UseIpv4DelayedDnsRules("4slow_ok");
735
736 constexpr std::string_view kHost = "https://4slow_ok";
737 Requester requester1 = CreateRequester(kHost);
738 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
739 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
740
741 Requester requester2 = CreateRequester(kHost);
742 // The second request destroys self when notified an update.
743 requester2.CancelRequestOnUpdated();
744 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
745 // The second request should share the same job with the first request.
746 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
747
748 RunUntilIdle();
749 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
750
751 // Complete the delayed transaction, which finishes the first request
752 // synchronously.
753 mock_dns_client_->CompleteDelayedTransactions();
754 EXPECT_THAT(*requester1.finished_result(), IsOk());
755 EXPECT_THAT(requester1.finished_endpoints(),
756 ElementsAre(ExpectServiceEndpoint(
757 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
758 ElementsAre(MakeIPEndPoint("::1", 443)))));
759 // The second request was destroyed so it didn't get notified.
760 ASSERT_FALSE(requester2.finished_result().has_value());
761 ASSERT_FALSE(requester2.request());
762 }
763
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsCancelAllRequestOnUpdated)764 TEST_F(HostResolverServiceEndpointRequestTest,
765 MultipleRequestsCancelAllRequestOnUpdated) {
766 UseIpv4DelayedDnsRules("4slow_ok");
767
768 constexpr std::string_view kHost = "https://4slow_ok";
769 Requester requester1 = CreateRequester(kHost);
770 requester1.CancelRequestOnUpdated();
771 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
772 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
773
774 Requester requester2 = CreateRequester(kHost);
775 requester2.CancelRequestOnUpdated();
776 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
777 // The second request should share the same job with the first request.
778 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
779
780 // Complete non-delayed transactions and invoke update callbacks, which
781 // destroy all requests.
782 RunUntilIdle();
783 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
784
785 ASSERT_FALSE(requester1.finished_result().has_value());
786 ASSERT_FALSE(requester1.request());
787 ASSERT_FALSE(requester2.finished_result().has_value());
788 ASSERT_FALSE(requester2.request());
789 }
790
TEST_F(HostResolverServiceEndpointRequestTest,MultipleRequestsCancelAllRequestOnFinished)791 TEST_F(HostResolverServiceEndpointRequestTest,
792 MultipleRequestsCancelAllRequestOnFinished) {
793 UseNonDelayedDnsRules("ok");
794
795 constexpr std::string_view kHost = "https://ok";
796 Requester requester1 = CreateRequester(kHost);
797 requester1.CancelRequestOnFinished();
798 EXPECT_THAT(requester1.Start(), IsError(ERR_IO_PENDING));
799 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
800
801 Requester requester2 = CreateRequester(kHost);
802 requester2.CancelRequestOnFinished();
803 EXPECT_THAT(requester2.Start(), IsError(ERR_IO_PENDING));
804 // The second request should share the same job with the first request.
805 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
806
807 RunUntilIdle();
808 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
809 EXPECT_THAT(*requester1.finished_result(), IsOk());
810 EXPECT_THAT(*requester2.finished_result(), IsOk());
811 }
812
TEST_F(HostResolverServiceEndpointRequestTest,WithLegacyRequestOk)813 TEST_F(HostResolverServiceEndpointRequestTest, WithLegacyRequestOk) {
814 UseIpv4DelayedDnsRules("4slow_ok");
815
816 constexpr std::string_view kHost = "https://4slow_ok";
817 LegacyRequester legacy_requester = CreateLegacyRequester(kHost);
818 int rv = legacy_requester.Start();
819 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
820 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
821
822 Requester requester = CreateRequester(kHost);
823 rv = requester.Start();
824 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
825 // The request should share the same job with the legacy request.
826 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
827
828 // Partially complete transactions. Requests should not complete but
829 // the non-legacy request should provide intermediate endpoints.
830 RunUntilIdle();
831 EXPECT_EQ(1u, resolver_->num_running_dispatcher_jobs_for_tests());
832 ASSERT_FALSE(legacy_requester.complete_result().has_value());
833 ASSERT_FALSE(requester.finished_result().has_value());
834 ASSERT_TRUE(requester.request()->EndpointsCryptoReady());
835 EXPECT_THAT(requester.request()->GetEndpointResults(),
836 ElementsAre(ExpectServiceEndpoint(
837 IsEmpty(), ElementsAre(MakeIPEndPoint("::1", 443)))));
838
839 // Complete delayed transactions, which finish requests synchronously.
840 mock_dns_client_->CompleteDelayedTransactions();
841 EXPECT_THAT(*legacy_requester.complete_result(), IsOk());
842 EXPECT_THAT(*requester.finished_result(), IsOk());
843 EXPECT_THAT(requester.finished_endpoints(),
844 ElementsAre(ExpectServiceEndpoint(
845 ElementsAre(MakeIPEndPoint("127.0.0.1", 443)),
846 ElementsAre(MakeIPEndPoint("::1", 443)))));
847 }
848
TEST_F(HostResolverServiceEndpointRequestTest,WithLegacyRequestDestroyResolverOnUpdated)849 TEST_F(HostResolverServiceEndpointRequestTest,
850 WithLegacyRequestDestroyResolverOnUpdated) {
851 UseIpv4DelayedDnsRules("4slow_ok");
852
853 constexpr std::string_view kHost = "https://4slow_ok";
854 LegacyRequester legacy_requester = CreateLegacyRequester(kHost);
855 int rv = legacy_requester.Start();
856 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
857 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
858
859 Requester requester = CreateRequester(kHost);
860 rv = requester.Start();
861 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
862 // The request should share the same job with the legacy request.
863 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
864
865 requester.SetOnUpdatedCallback(
866 base::BindLambdaForTesting([&]() { DestroyResolver(); }));
867
868 RunUntilIdle();
869 // DestroyResolver() removed the corresponding job and the legacy reqquest
870 // didn't get notified, but the non-legacy request got notified via the
871 // update callback.
872 ASSERT_FALSE(legacy_requester.complete_result().has_value());
873 EXPECT_THAT(*requester.finished_result(), IsError(ERR_DNS_REQUEST_CANCELLED));
874 }
875
TEST_F(HostResolverServiceEndpointRequestTest,WithLegacyRequestCancelRequestOnUpdated)876 TEST_F(HostResolverServiceEndpointRequestTest,
877 WithLegacyRequestCancelRequestOnUpdated) {
878 UseIpv4DelayedDnsRules("4slow_ok");
879
880 constexpr std::string_view kHost = "https://4slow_ok";
881 LegacyRequester legacy_requester = CreateLegacyRequester(kHost);
882 int rv = legacy_requester.Start();
883 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
884 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
885
886 Requester requester = CreateRequester(kHost);
887 requester.CancelRequestOnUpdated();
888 rv = requester.Start();
889 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
890 // The request should share the same job with the legacy request.
891 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
892
893 // Partially complete transactions to trigger the update callback on
894 // non-legacy request, which cancels the request itself.
895 RunUntilIdle();
896 ASSERT_FALSE(legacy_requester.complete_result().has_value());
897 ASSERT_FALSE(requester.request());
898
899 // Complete delayed transactions, which finish the legacy request
900 // synchronously. Non-legacy request was already destroyed.
901 mock_dns_client_->CompleteDelayedTransactions();
902 EXPECT_THAT(*legacy_requester.complete_result(), IsOk());
903 }
904
TEST_F(HostResolverServiceEndpointRequestTest,WithLegacyRequestCancelLegacyRequest)905 TEST_F(HostResolverServiceEndpointRequestTest,
906 WithLegacyRequestCancelLegacyRequest) {
907 UseNonDelayedDnsRules("ok");
908
909 constexpr std::string_view kHost = "https://ok";
910
911 LegacyRequester legacy_requester = CreateLegacyRequester(kHost);
912 int rv = legacy_requester.Start();
913 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
914 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
915
916 Requester requester = CreateRequester(kHost);
917 requester.CancelRequestOnUpdated();
918 rv = requester.Start();
919 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
920 // The request should share the same job with the legacy request.
921 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
922
923 // Cancelling legacy request should not cancel non-legacy request.
924 legacy_requester.CancelRequest();
925 ASSERT_FALSE(requester.finished_result().has_value());
926 EXPECT_EQ(3u, resolver_->num_running_dispatcher_jobs_for_tests());
927
928 requester.WaitForFinished();
929 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
930 EXPECT_THAT(*requester.finished_result(), IsOk());
931 }
932
933 } // namespace net
934