Google Git
Sign in
chromium / chromium / src / lkgr / . / net / base / schemeful_site_unittest.cc
blob: 6fd9799fc386abf01ccae8a32535181ab79b4e7e [file] [log] [blame]
Avi Drissman64595482022-09-14 20:52:29[diff] [blame]1// Copyright 2020 The Chromium Authors
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]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 "net/base/schemeful_site.h"
6
Arthur Sonzogni46716872024-12-12 12:00:04[diff] [blame]7#include <array>
8
Matt Menke4f0b6912021-02-08 17:21:55[diff] [blame]9#include "base/test/metrics/histogram_tester.h"
Lily Chene4070ef2020-12-22 16:14:38[diff] [blame]10#include "net/base/url_util.h"
cfredriccbd7db12020-11-06 22:08:06[diff] [blame]11#include "testing/gmock/include/gmock/gmock-matchers.h"
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]12#include "testing/gtest/include/gtest/gtest.h"
13#include "url/gurl.h"
14#include "url/origin.h"
15#include "url/url_util.h"
16
17namespace net {
18
19TEST(SchemefulSiteTest, DifferentOriginSameRegisterableDomain) {
20 // List of origins which should all share a schemeful site.
21 url::Origin kTestOrigins[] = {
22 url::Origin::Create(GURL("http://a.foo.test")),
23 url::Origin::Create(GURL("http://b.foo.test")),
24 url::Origin::Create(GURL("http://foo.test")),
25 url::Origin::Create(GURL("http://a.b.foo.test"))};
26
27 for (const auto& origin_a : kTestOrigins) {
28 for (const auto& origin_b : kTestOrigins) {
29 EXPECT_EQ(SchemefulSite(origin_a), SchemefulSite(origin_b));
30 }
31 }
32}
33
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]34TEST(SchemefulSiteTest, IsSameSiteOpaque) {
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]35 url::Origin opaque;
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]36 const struct {
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]37 url::Origin a;
38 url::Origin b;
39 bool same_site;
40 } kTestCases[] = {
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]41 // Different opaque
42 {url::Origin(), url::Origin(), false},
43
44 // Opaque / non-opaque
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]45 {url::Origin(), url::Origin::Create(GURL("http://foo.test/")), false},
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]46
47 // Different opaque, one derived from the other.
48 {opaque, opaque.DeriveNewOpaqueOrigin(), false},
49
50 // Same opaque
51 {opaque, opaque, true},
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]52 };
53
54 for (const auto& test : kTestCases) {
55 SCOPED_TRACE(::testing::Message() << test.a << " " << test.b);
56 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(test.a, test.b));
57 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(test.b, test.a));
58 EXPECT_EQ(test.same_site, SchemefulSite(test.a).IsSameSiteWith(test.b));
59 EXPECT_EQ(test.same_site, SchemefulSite(test.b).IsSameSiteWith(test.a));
60 EXPECT_TRUE(SchemefulSite::IsSameSite(test.a, test.a));
61 EXPECT_TRUE(SchemefulSite::IsSameSite(test.b, test.b));
62 EXPECT_TRUE(SchemefulSite(test.a).IsSameSiteWith(test.a));
63 EXPECT_TRUE(SchemefulSite(test.b).IsSameSiteWith(test.b));
64 }
65}
66
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]67TEST(SchemefulSiteTest, IsSameSite) {
Charlie Harrisone039926f2025-04-04 22:05:30[diff] [blame]68 url::ScopedSchemeRegistryForTests scoped_registry;
69 url::AddStandardScheme("custom", url::SCHEME_WITH_HOST);
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]70 const struct {
71 std::string a;
72 std::string b;
73 bool same_site;
74 } kTestCases[] = {
75 // Different scheme
76 {"http://foo.test/", "https://foo.test/", false},
77 {"http://foo.test/some-path", "https://foo.test/some-path", false},
78 {"http://foo.test/path1", "https://foo.test/path2", false},
79
80 // Different eTLD+1
81 {"http://bar.test/", "http://foo.test/", false},
82 {"http://bar.test/path", "http://foo.test/path", false},
83
84 // Different file origins
85 {"file://foo", "file://bar", false},
86
Charlie Harrisone039926f2025-04-04 22:05:30[diff] [blame]87 // This custom scheme should fail the IsStandardSchemeWithNetworkHost
88 // check, causing SchemefulSite to compare the full host, despite the fact
89 // that the host will succeed in finding a registerable domain.
90 {"custom://foo.bar.test", "custom://bar.test", false},
91
Charlie Harrison15329a922025-03-07 14:36:18[diff] [blame]92 // Equal hosts
93 {"http://bar.foo.test/", "http://bar.foo.test/", true},
94
95 // Equal and empty hosts
96 {"file://", "file://", true},
97
98 // Equal file origins
99 {"file://foo", "file://foo", true},
100
101 // Equal eTLD+1
102 {"http://bar.foo.test/", "http://baz.foo.test/", true},
103 {"http://bar.foo.test/path1", "http://baz.foo.test/path1", true},
104 {"http://bar.foo.test/path1", "http://baz.foo.test/path2", true},
105
106 // Equal except port
107 {"http://bar.foo.test:80/", "http://baz.foo.test:81/", true},
108 {"http://bar.foo.test:80/path1", "http://baz.foo.test:81/path1", true},
109
110 // Blobs equal
111 {"blob:https://a.test/", "https://a.test/", true},
112
113 // Blobs not equal
114 {"blob:https://a.test/", "blob:https://b.test/", false},
115 {"blob:https://a.test/", "https://b.test/", false},
116 };
117
118 for (const auto& test : kTestCases) {
119 SCOPED_TRACE(::testing::Message() << test.a << " " << test.b);
120
121 GURL a_url = GURL(test.a);
122 GURL b_url = GURL(test.b);
123 url::Origin a_origin = url::Origin::Create(a_url);
124 url::Origin b_origin = url::Origin::Create(b_url);
125
126 // Origin tests
127 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(a_origin, b_origin));
128 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(b_origin, a_origin));
129 EXPECT_EQ(test.same_site, SchemefulSite(a_origin).IsSameSiteWith(b_origin));
130 EXPECT_EQ(test.same_site, SchemefulSite(b_origin).IsSameSiteWith(a_origin));
131 EXPECT_TRUE(SchemefulSite::IsSameSite(a_origin, a_origin));
132 EXPECT_TRUE(SchemefulSite::IsSameSite(b_origin, b_origin));
133 EXPECT_TRUE(SchemefulSite(a_origin).IsSameSiteWith(a_origin));
134 EXPECT_TRUE(SchemefulSite(b_origin).IsSameSiteWith(b_origin));
135
136 // GURL tests
137 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(a_url, b_url));
138 EXPECT_EQ(test.same_site, SchemefulSite::IsSameSite(b_url, a_url));
139 EXPECT_EQ(test.same_site, SchemefulSite(a_url).IsSameSiteWith(b_url));
140 EXPECT_EQ(test.same_site, SchemefulSite(b_url).IsSameSiteWith(a_url));
141 EXPECT_TRUE(SchemefulSite::IsSameSite(a_url, a_url));
142 EXPECT_TRUE(SchemefulSite::IsSameSite(b_url, b_url));
143 EXPECT_TRUE(SchemefulSite(a_url).IsSameSiteWith(a_url));
144 EXPECT_TRUE(SchemefulSite(b_url).IsSameSiteWith(b_url));
145 }
146}
147
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]148TEST(SchemefulSiteTest, Operators) {
149 // Create a list of origins that should all have different schemeful sites.
150 // These are in ascending order.
Arthur Sonzogni46716872024-12-12 12:00:04[diff] [blame]151 auto kTestOrigins = std::to_array<url::Origin>({
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]152 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>")),
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]153 url::Origin::Create(GURL("file://")),
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]154 url::Origin::Create(GURL("file://foo")),
155 url::Origin::Create(GURL("http://a.bar.test")),
156 url::Origin::Create(GURL("http://c.test")),
157 url::Origin::Create(GURL("http://d.test")),
158 url::Origin::Create(GURL("http://a.foo.test")),
159 url::Origin::Create(GURL("https://a.bar.test")),
160 url::Origin::Create(GURL("https://c.test")),
161 url::Origin::Create(GURL("https://d.test")),
Arthur Sonzogni46716872024-12-12 12:00:04[diff] [blame]162 url::Origin::Create(GURL("https://a.foo.test")),
163 });
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]164
165 // Compare each origin to every other origin and ensure the operators work as
166 // expected.
Daniel Cheng5feb16f2022-02-28 06:52:07[diff] [blame]167 for (size_t first = 0; first < std::size(kTestOrigins); ++first) {
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]168 SchemefulSite site1 = SchemefulSite(kTestOrigins[first]);
169 SCOPED_TRACE(site1.GetDebugString());
170
171 EXPECT_EQ(site1, site1);
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]172 EXPECT_TRUE(
173 SchemefulSite::IsSameSite(kTestOrigins[first], kTestOrigins[first]));
174 EXPECT_TRUE(site1.IsSameSiteWith(kTestOrigins[first]));
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]175 EXPECT_FALSE(site1 < site1);
176
177 // Check the operators work on copies.
178 SchemefulSite site1_copy = site1;
179 EXPECT_EQ(site1, site1_copy);
180 EXPECT_FALSE(site1 < site1_copy);
181
Daniel Cheng5feb16f2022-02-28 06:52:07[diff] [blame]182 for (size_t second = first + 1; second < std::size(kTestOrigins);
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]183 ++second) {
184 SchemefulSite site2 = SchemefulSite(kTestOrigins[second]);
185 SCOPED_TRACE(site2.GetDebugString());
186
187 EXPECT_TRUE(site1 < site2);
188 EXPECT_FALSE(site2 < site1);
189 EXPECT_FALSE(site1 == site2);
190 EXPECT_FALSE(site2 == site1);
Charlie Harrisone07e86eb2025-03-06 22:54:13[diff] [blame]191 EXPECT_FALSE(
192 SchemefulSite::IsSameSite(kTestOrigins[first], kTestOrigins[second]));
193 EXPECT_FALSE(site1.IsSameSiteWith(kTestOrigins[second]));
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]194 }
195 }
196}
197
198TEST(SchemefulSiteTest, SchemeUsed) {
199 url::Origin origin_a = url::Origin::Create(GURL("https://foo.test"));
200 url::Origin origin_b = url::Origin::Create(GURL("http://foo.test"));
201 EXPECT_NE(SchemefulSite(origin_a), SchemefulSite(origin_b));
202}
203
204TEST(SchemefulSiteTest, PortIgnored) {
205 // Both origins are non-opaque.
206 url::Origin origin_a = url::Origin::Create(GURL("https://foo.test:80"));
207 url::Origin origin_b = url::Origin::Create(GURL("https://foo.test:2395"));
208
209 EXPECT_EQ(SchemefulSite(origin_a), SchemefulSite(origin_b));
210}
211
212TEST(SchemefulSiteTest, TopLevelDomainsNotModified) {
213 url::Origin origin_tld = url::Origin::Create(GURL("https://com"));
214 EXPECT_EQ(url::Origin::Create(GURL("https://com")),
215 SchemefulSite(origin_tld).GetInternalOriginForTesting());
216
217 // Unknown TLD's should not be modified.
218 url::Origin origin_tld_unknown =
219 url::Origin::Create(GURL("https://bar:1234"));
220 EXPECT_EQ(url::Origin::Create(GURL("https://bar")),
221 SchemefulSite(origin_tld_unknown).GetInternalOriginForTesting());
222
223 // Check for two-part TLDs.
224 url::Origin origin_two_part_tld = url::Origin::Create(GURL("http://a.co.uk"));
225 EXPECT_EQ(url::Origin::Create(GURL("http://a.co.uk")),
226 SchemefulSite(origin_two_part_tld).GetInternalOriginForTesting());
227}
228
229TEST(SchemefulSiteTest, NonStandardScheme) {
230 url::ScopedSchemeRegistryForTests scoped_registry;
231 url::AddStandardScheme("foo", url::SCHEME_WITH_HOST);
232 url::Origin origin = url::Origin::Create(GURL("foo://a.b.test"));
233 EXPECT_FALSE(origin.opaque());
234
235 // We should not use registerable domains for non-standard schemes, even if
236 // one exists for the host.
237 EXPECT_EQ(url::Origin::Create(GURL("foo://a.b.test")),
238 SchemefulSite(origin).GetInternalOriginForTesting());
239}
240
241TEST(SchemefulSiteTest, IPBasedOriginsRemovePort) {
242 // IPv4 and IPv6 origins should not be modified, except for removing their
243 // ports.
244 url::Origin origin_ipv4_a =
245 url::Origin::Create(GURL("http://127.0.0.1:1234"));
246 url::Origin origin_ipv4_b = url::Origin::Create(GURL("http://127.0.0.1"));
247 EXPECT_EQ(url::Origin::Create(GURL("http://127.0.0.1")),
248 SchemefulSite(origin_ipv4_a).GetInternalOriginForTesting());
249 EXPECT_EQ(SchemefulSite(origin_ipv4_a), SchemefulSite(origin_ipv4_b));
250
251 url::Origin origin_ipv6 = url::Origin::Create(GURL("https://[::1]"));
252 EXPECT_EQ(url::Origin::Create(GURL("https://[::1]")),
253 SchemefulSite(origin_ipv6).GetInternalOriginForTesting());
254}
255
Chris Fredrickson3cc6d162023-05-03 16:43:15[diff] [blame]256TEST(SchemefulSiteTest, LocalhostOriginsRemovePort) {
257 // Localhost origins should not be modified, except for removing their ports.
258 url::Origin localhost_http =
259 url::Origin::Create(GURL("http://localhost:1234"));
260 EXPECT_EQ(url::Origin::Create(GURL("http://localhost")),
261 SchemefulSite(localhost_http).GetInternalOriginForTesting());
262
263 url::Origin localhost_https =
264 url::Origin::Create(GURL("https://localhost:1234"));
265 EXPECT_EQ(url::Origin::Create(GURL("https://localhost")),
266 SchemefulSite(localhost_https).GetInternalOriginForTesting());
267}
268
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]269TEST(SchemefulSiteTest, OpaqueOrigins) {
270 url::Origin opaque_origin_a =
271 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
272
273 // The schemeful site of an opaque origin should always equal other schemeful
274 // site instances of the same origin.
275 EXPECT_EQ(SchemefulSite(opaque_origin_a), SchemefulSite(opaque_origin_a));
276
277 url::Origin opaque_origin_b =
278 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>"));
279
280 // Two different opaque origins should never have the same SchemefulSite.
281 EXPECT_NE(SchemefulSite(opaque_origin_a), SchemefulSite(opaque_origin_b));
282}
283
Lily Chenef0225f2020-11-03 22:48:28[diff] [blame]284TEST(SchemefulSiteTest, FileOriginWithoutHostname) {
285 SchemefulSite site1(url::Origin::Create(GURL("file:///")));
286 SchemefulSite site2(url::Origin::Create(GURL("file:///path/")));
287
288 EXPECT_EQ(site1, site2);
289 EXPECT_TRUE(site1.GetInternalOriginForTesting().host().empty());
290}
291
Lily Chene4070ef2020-12-22 16:14:38[diff] [blame]292TEST(SchemefulSiteTest, SchemeWithNetworkHost) {
293 url::ScopedSchemeRegistryForTests scheme_registry;
294 AddStandardScheme("network", url::SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION);
295 AddStandardScheme("non-network", url::SCHEME_WITH_HOST);
296
297 ASSERT_TRUE(IsStandardSchemeWithNetworkHost("network"));
298 ASSERT_FALSE(IsStandardSchemeWithNetworkHost("non-network"));
299
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]300 std::optional<SchemefulSite> network_host_site =
Lily Chene4070ef2020-12-22 16:14:38[diff] [blame]301 SchemefulSite::CreateIfHasRegisterableDomain(
302 url::Origin::Create(GURL("network://site.example.test:1337")));
303 EXPECT_TRUE(network_host_site.has_value());
304 EXPECT_EQ("network",
305 network_host_site->GetInternalOriginForTesting().scheme());
306 EXPECT_EQ("example.test",
307 network_host_site->GetInternalOriginForTesting().host());
308
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]309 std::optional<SchemefulSite> non_network_host_site_null =
Lily Chene4070ef2020-12-22 16:14:38[diff] [blame]310 SchemefulSite::CreateIfHasRegisterableDomain(
311 url::Origin::Create(GURL("non-network://site.example.test")));
312 EXPECT_FALSE(non_network_host_site_null.has_value());
313 SchemefulSite non_network_host_site(GURL("non-network://site.example.test"));
314 EXPECT_EQ("non-network",
315 non_network_host_site.GetInternalOriginForTesting().scheme());
316 // The host is used as-is, without attempting to get a registrable domain.
317 EXPECT_EQ("site.example.test",
318 non_network_host_site.GetInternalOriginForTesting().host());
319}
320
321TEST(SchemefulSiteTest, FileSchemeHasRegistrableDomain) {
322 // Test file origin without host.
323 url::Origin origin_file =
324 url::Origin::Create(GURL("file:///dir1/dir2/file.txt"));
325 EXPECT_TRUE(origin_file.host().empty());
326 SchemefulSite site_file(origin_file);
327 EXPECT_EQ(url::Origin::Create(GURL("file:///")),
328 site_file.GetInternalOriginForTesting());
329
330 // Test file origin with host (with registrable domain).
331 url::Origin origin_file_with_host =
332 url::Origin::Create(GURL("file://host.example.test/file"));
333 ASSERT_EQ("host.example.test", origin_file_with_host.host());
334 SchemefulSite site_file_with_host(origin_file_with_host);
335 EXPECT_EQ(url::Origin::Create(GURL("file://example.test")),
336 site_file_with_host.GetInternalOriginForTesting());
337
338 // Test file origin with host same as registrable domain.
339 url::Origin origin_file_registrable_domain =
340 url::Origin::Create(GURL("file://example.test/file"));
341 ASSERT_EQ("example.test", origin_file_registrable_domain.host());
342 SchemefulSite site_file_registrable_domain(origin_file_registrable_domain);
343 EXPECT_EQ(url::Origin::Create(GURL("file://example.test")),
344 site_file_registrable_domain.GetInternalOriginForTesting());
345
346 EXPECT_NE(site_file, site_file_with_host);
347 EXPECT_NE(site_file, site_file_registrable_domain);
348 EXPECT_EQ(site_file_with_host, site_file_registrable_domain);
349}
350
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]351TEST(SchemefulSiteTest, SerializationConsistent) {
352 url::ScopedSchemeRegistryForTests scoped_registry;
353 url::AddStandardScheme("chrome", url::SCHEME_WITH_HOST);
354
355 // List of origins which should all share a schemeful site.
356 SchemefulSite kTestSites[] = {
357 SchemefulSite(url::Origin::Create(GURL("http://a.foo.test"))),
358 SchemefulSite(url::Origin::Create(GURL("https://b.foo.test"))),
359 SchemefulSite(url::Origin::Create(GURL("http://b.foo.test"))),
360 SchemefulSite(url::Origin::Create(GURL("http://a.b.foo.test"))),
361 SchemefulSite(url::Origin::Create(GURL("chrome://a.b.test")))};
362
363 for (const auto& site : kTestSites) {
364 SCOPED_TRACE(site.GetDebugString());
365 EXPECT_FALSE(site.GetInternalOriginForTesting().opaque());
366
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]367 std::optional<SchemefulSite> deserialized_site =
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]368 SchemefulSite::Deserialize(site.Serialize());
369 EXPECT_TRUE(deserialized_site);
370 EXPECT_EQ(site, deserialized_site);
371 }
372}
373
Dylan Cutlerb63c4142021-07-26 19:42:29[diff] [blame]374TEST(SchemefulSiteTest, SerializationFileSiteWithHost) {
375 const struct {
376 SchemefulSite site;
377 std::string expected;
378 } kTestCases[] = {
379 {SchemefulSite(GURL("file:///etc/passwd")), "file://"},
380 {SchemefulSite(GURL("file://example.com/etc/passwd")),
381 "file://example.com"},
382 {SchemefulSite(GURL("file://example.com")), "file://example.com"},
383 };
384
385 for (const auto& test_case : kTestCases) {
386 SCOPED_TRACE(test_case.site.GetDebugString());
387 std::string serialized_site = test_case.site.SerializeFileSiteWithHost();
388 EXPECT_EQ(test_case.expected, serialized_site);
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]389 std::optional<SchemefulSite> deserialized_site =
Dylan Cutlerb63c4142021-07-26 19:42:29[diff] [blame]390 SchemefulSite::Deserialize(serialized_site);
391 EXPECT_TRUE(deserialized_site);
392 EXPECT_EQ(test_case.site, deserialized_site);
393 }
394}
395
396TEST(SchemefulSiteTest, FileURLWithHostEquality) {
397 // Two file URLs with different hosts should result in unequal SchemefulSites.
398 SchemefulSite site1(GURL("file://foo/some/path.txt"));
399 SchemefulSite site2(GURL("file://bar/some/path.txt"));
400 EXPECT_NE(site1, site2);
401
402 // Two file URLs with the same host should result in equal SchemefulSites.
403 SchemefulSite site3(GURL("file://foo/another/path.pdf"));
404 EXPECT_EQ(site1, site3);
405}
406
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]407TEST(SchemefulSiteTest, OpaqueSerialization) {
408 // List of origins which should all share a schemeful site.
409 SchemefulSite kTestSites[] = {
410 SchemefulSite(), SchemefulSite(url::Origin()),
411 SchemefulSite(GURL("data:text/html,<body>Hello World</body>"))};
412
413 for (auto& site : kTestSites) {
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]414 std::optional<SchemefulSite> deserialized_site =
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]415 SchemefulSite::DeserializeWithNonce(*site.SerializeWithNonce());
416 EXPECT_TRUE(deserialized_site);
417 EXPECT_EQ(site, *deserialized_site);
418 }
419}
420
Lily Chen61217552020-12-22 18:12:29[diff] [blame]421TEST(SchemefulSiteTest, FromWire) {
422 SchemefulSite out;
423
424 // Opaque origin.
425 EXPECT_TRUE(SchemefulSite::FromWire(url::Origin(), &out));
426 EXPECT_TRUE(out.opaque());
427
428 // Valid origin.
429 EXPECT_TRUE(SchemefulSite::FromWire(
430 url::Origin::Create(GURL("https://example.test")), &out));
431 EXPECT_EQ(SchemefulSite(url::Origin::Create(GURL("https://example.test"))),
432 out);
433
434 // Invalid origin (not a registrable domain).
435 EXPECT_FALSE(SchemefulSite::FromWire(
436 url::Origin::Create(GURL("https://sub.example.test")), &out));
437
438 // Invalid origin (non-default port).
439 EXPECT_FALSE(SchemefulSite::FromWire(
440 url::Origin::Create(GURL("https://example.test:1337")), &out));
441}
442
cfredriccbd7db12020-11-06 22:08:06[diff] [blame]443TEST(SchemefulSiteTest, CreateIfHasRegisterableDomain) {
444 for (const auto& site : std::initializer_list<std::string>{
445 "http://a.bar.test",
446 "http://c.test",
447 "http://a.foo.test",
448 "https://a.bar.test",
449 "https://c.test",
450 "https://a.foo.test",
451 }) {
452 url::Origin origin = url::Origin::Create(GURL(site));
453 EXPECT_THAT(SchemefulSite::CreateIfHasRegisterableDomain(origin),
454 testing::Optional(SchemefulSite(origin)))
455 << "site = \"" << site << "\"";
456 }
457
458 for (const auto& site : std::initializer_list<std::string>{
459 "data:text/html,<body>Hello World</body>",
460 "file:///",
461 "file://foo",
462 "http://127.0.0.1:1234",
463 "https://127.0.0.1:1234",
464 }) {
465 url::Origin origin = url::Origin::Create(GURL(site));
466 EXPECT_EQ(SchemefulSite::CreateIfHasRegisterableDomain(origin),
David Benjamin506122dc2023-11-07 01:32:18[diff] [blame]467 std::nullopt)
cfredriccbd7db12020-11-06 22:08:06[diff] [blame]468 << "site = \"" << site << "\"";
469 }
470}
471
Lily Chen61217552020-12-22 18:12:29[diff] [blame]472TEST(SchemefulSiteTest, ConvertWebSocketToHttp) {
473 SchemefulSite ws_site(url::Origin::Create(GURL("ws://site.example.test")));
474 SchemefulSite http_site(
475 url::Origin::Create(GURL("http://site.example.test")));
476 SchemefulSite wss_site(url::Origin::Create(GURL("wss://site.example.test")));
477 SchemefulSite https_site(
478 url::Origin::Create(GURL("https://site.example.test")));
479
480 ASSERT_NE(ws_site, wss_site);
481 ASSERT_NE(ws_site, http_site);
482 ASSERT_NE(ws_site, https_site);
483 ASSERT_NE(wss_site, http_site);
484 ASSERT_NE(wss_site, https_site);
485
486 ws_site.ConvertWebSocketToHttp();
487 wss_site.ConvertWebSocketToHttp();
488
489 EXPECT_EQ(ws_site, http_site);
490 EXPECT_EQ(wss_site, https_site);
491
492 // Does not change non-WebSocket sites.
493 SchemefulSite http_site_copy(http_site);
494 http_site_copy.ConvertWebSocketToHttp();
495 EXPECT_EQ(http_site, http_site_copy);
496 EXPECT_EQ(url::kHttpScheme,
497 http_site_copy.GetInternalOriginForTesting().scheme());
498
499 SchemefulSite file_site(url::Origin::Create(GURL("file:///")));
500 file_site.ConvertWebSocketToHttp();
501 EXPECT_EQ(url::kFileScheme, file_site.GetInternalOriginForTesting().scheme());
502}
503
cfredrice3ed24502021-04-01 17:07:20[diff] [blame]504TEST(SchemefulSiteTest, GetGURL) {
505 struct {
506 url::Origin origin;
507 GURL wantGURL;
508 } kTestCases[] = {
509 {
510 url::Origin::Create(GURL("data:text/html,<body>Hello World</body>")),
511 GURL(),
512 },
513 {url::Origin::Create(GURL("file://foo")), GURL("file:///")},
514 {url::Origin::Create(GURL("http://a.bar.test")), GURL("http://bar.test")},
515 {url::Origin::Create(GURL("http://c.test")), GURL("http://c.test")},
516 {url::Origin::Create(GURL("http://c.test:8000")), GURL("http://c.test")},
517 {
518 url::Origin::Create(GURL("https://a.bar.test")),
519 GURL("https://bar.test"),
520 },
521 {
522 url::Origin::Create(GURL("https://c.test")),
523 GURL("https://c.test"),
524 },
525 {
526 url::Origin::Create(GURL("https://c.test:1337")),
527 GURL("https://c.test"),
528 },
529 };
530
531 for (const auto& testcase : kTestCases) {
532 SchemefulSite site(testcase.origin);
533 EXPECT_EQ(site.GetURL(), testcase.wantGURL);
534 }
535}
536
Ari Chivukula2e5fd082023-01-25 05:34:59[diff] [blame]537TEST(SchemefulSiteTest, InternalValue) {
538 url::Origin origin = url::Origin::Create(GURL("https://example.com"));
539 SchemefulSite site(origin);
540 EXPECT_EQ(site.internal_value(), origin);
541 url::Origin opaque_origin;
542 SchemefulSite opaque_site(opaque_origin);
543 EXPECT_EQ(opaque_site.internal_value(), opaque_origin);
544}
545
John Delaney513e53f2020-10-29 20:16:04[diff] [blame]546} // namespace net