Google Git
Sign in
chromium / chromium / src / 6cb15f0f9fcdd1e34dba5cc914975f873d10a7dd / . / net / base / url_util_unittest.cc
blob: 940c93b129ea6eea08b62ac05a737d21f36d152c [file] [log] [blame]
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/url_util.h"
#include <optional>
#include <ostream>
#include "base/format_macros.h"
#include "base/strings/utf_string_conversions.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#include "url/scheme_host_port.h"
#include "url/url_util.h"
using base::ASCIIToUTF16;
using base::WideToUTF16;
namespace net {
namespace {
TEST(UrlUtilTest, AppendQueryParameter) {
// Appending a name-value pair to a URL without a query component.
EXPECT_EQ("http://example.com/path?name=value",
AppendQueryParameter(GURL("http://example.com/path"),
"name", "value").spec());
// Appending a name-value pair to a URL with a query component.
// The original component should be preserved, and the new pair should be
// appended with '&'.
EXPECT_EQ("http://example.com/path?existing=one&name=value",
AppendQueryParameter(GURL("http://example.com/path?existing=one"),
"name", "value").spec());
// Appending a name-value pair with unsafe characters included. The
// unsafe characters should be escaped.
EXPECT_EQ("http://example.com/path?existing=one&na+me=v.alue%3D",
AppendQueryParameter(GURL("http://example.com/path?existing=one"),
"na me", "v.alue=")
.spec());
}
TEST(UrlUtilTest, AppendOrReplaceQueryParameter) {
// Appending a name-value pair to a URL without a query component.
EXPECT_EQ("http://example.com/path?name=value",
AppendOrReplaceQueryParameter(GURL("http://example.com/path"),
"name", "value").spec());
// Appending a name-value pair to a URL with a query component.
// The original component should be preserved, and the new pair should be
// appended with '&'.
EXPECT_EQ("http://example.com/path?existing=one&name=value",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one"),
"name", "value").spec());
// Appending a name-value pair with unsafe characters included. The
// unsafe characters should be escaped.
EXPECT_EQ("http://example.com/path?existing=one&na+me=v.alue%3D",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one"),
"na me", "v.alue=").spec());
// Replace value of an existing paramater.
EXPECT_EQ("http://example.com/path?existing=one&name=new",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one&name=old"),
"name", "new").spec());
// Replace a name-value pair with unsafe characters included. The
// unsafe characters should be escaped.
EXPECT_EQ("http://example.com/path?na+me=n.ew%3D&existing=one",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?na+me=old&existing=one"),
"na me", "n.ew=").spec());
// Replace the value of first parameter with this name only.
EXPECT_EQ("http://example.com/path?name=new&existing=one&name=old",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?name=old&existing=one&name=old"),
"name", "new").spec());
// Preserve the content of the original params regardless of our failure to
// interpret them correctly.
EXPECT_EQ("http://example.com/path?bar&name=new&left=&"
"=right&=&&name=again",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?bar&name=old&left=&"
"=right&=&&name=again"),
"name", "new").spec());
// ----- Removing the key using nullopt value -----
// Removes the name-value pair from the URL preserving other query parameters.
EXPECT_EQ("http://example.com/path?abc=xyz",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?name=value&abc=xyz"), "name",
std::nullopt)
.spec());
// Removes the name-value pair from the URL.
EXPECT_EQ("http://example.com/path?",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one"), "existing",
std::nullopt)
.spec());
// Removes the first name-value pair.
EXPECT_EQ("http://example.com/path?c=d&e=f",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?a=b&c=d&e=f"), "a", std::nullopt)
.spec());
// Removes a name-value pair in between two query params.
EXPECT_EQ(
"http://example.com/path?existing=one&hello=world",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one&replace=sure&hello=world"),
"replace", std::nullopt)
.spec());
// Removes the last name-value pair.
EXPECT_EQ("http://example.com/path?existing=one",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one&replace=sure"),
"replace", std::nullopt)
.spec());
// Removing a name-value pair with unsafe characters included. The
// unsafe characters should be escaped.
EXPECT_EQ("http://example.com/path?existing=one&hello=world",
AppendOrReplaceQueryParameter(
GURL("http://example.com/"
"path?existing=one&na+me=v.alue%3D&hello=world"),
"na me", std::nullopt)
.spec());
// Does nothing if the provided query param key does not exist.
EXPECT_EQ("http://example.com/path?existing=one&name=old",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?existing=one&name=old"), "old",
std::nullopt)
.spec());
// Remove the value of first parameter with this name only.
EXPECT_EQ(
"http://example.com/path?existing=one&name=old",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?name=something&existing=one&name=old"),
"name", std::nullopt)
.spec());
// Preserve the content of the original params regardless of our failure to
// interpret them correctly.
EXPECT_EQ(
"http://example.com/path?bar&left=&"
"=right&=&&name=again",
AppendOrReplaceQueryParameter(
GURL("http://example.com/path?bar&name=old&left=&"
"=right&=&&name=again"),
"name", std::nullopt)
.spec());
}
TEST(UrlUtilTest, AppendOrReplaceRef) {
// Setting a new ref should append it.
EXPECT_EQ("http://example.com/path#ref",
AppendOrReplaceRef(GURL("http://example.com/path"), "ref").spec());
// Setting a ref over an existing one should replace it.
EXPECT_EQ("http://example.com/path#ref",
AppendOrReplaceRef(GURL("http://example.com/path#old_ref"), "ref")
.spec());
// Setting a ref on a url with existing query parameters should simply append
// it at the end
EXPECT_EQ(
"http://example.com/path?query=value#ref",
AppendOrReplaceRef(GURL("http://example.com/path?query=value#ref"), "ref")
.spec());
// Setting a ref on a url with existing query parameters and with special
// encoded characters: `special-chars?query=value#ref chars%\";'`
EXPECT_EQ(
"http://example.com/special-chars?query=value#ref%20chars%%22;'",
AppendOrReplaceRef(GURL("http://example.com/special-chars?query=value"),
"ref chars%\";'")
.spec());
// Testing adding a ref to a URL with specially encoded characters.
// `special chars%\";'?query=value#ref`
EXPECT_EQ(
"http://example.com/special%20chars%%22;'?query=value#ref",
AppendOrReplaceRef(
GURL("http://example.com/special chars%\";'?query=value"), "ref")
.spec());
}
TEST(UrlUtilTest, GetValueForKeyInQuery) {
GURL url("http://example.com/path?name=value&boolParam&"
"url=http://test.com/q?n1%3Dv1%26n2");
std::string value;
// False when getting a non-existent query param.
EXPECT_FALSE(GetValueForKeyInQuery(url, "non-exist", &value));
// True when query param exist.
EXPECT_TRUE(GetValueForKeyInQuery(url, "name", &value));
EXPECT_EQ("value", value);
EXPECT_TRUE(GetValueForKeyInQuery(url, "boolParam", &value));
EXPECT_EQ("", value);
EXPECT_TRUE(GetValueForKeyInQuery(url, "url", &value));
EXPECT_EQ("http://test.com/q?n1=v1&n2", value);
}
TEST(UrlUtilTest, GetValueForKeyInQueryInvalidURL) {
GURL url("http://%01/?test");
std::string value;
// Always false when parsing an invalid URL.
EXPECT_FALSE(GetValueForKeyInQuery(url, "test", &value));
}
TEST(UrlUtilTest, GetValueForKeyInQueryNoOutputValue) {
GURL url(
"http://example.com/path?name=value&boolParam&"
"url=http://test.com/q?n1%3Dv1%26n2");
// False when getting a non-existent query param.
EXPECT_FALSE(GetValueForKeyInQuery(url, "non-exist", nullptr));
// True when query param exists.
EXPECT_TRUE(GetValueForKeyInQuery(url, "name", nullptr));
EXPECT_TRUE(GetValueForKeyInQuery(url, "boolParam", nullptr));
EXPECT_TRUE(GetValueForKeyInQuery(url, "url", nullptr));
}
TEST(UrlUtilTest, ParseQuery) {
const GURL url("http://example.com/path?name=value&boolParam&"
"url=http://test.com/q?n1%3Dv1%26n2&"
"multikey=value1&multikey=value2&multikey");
QueryIterator it(url);
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("name", it.GetKey());
EXPECT_EQ("value", it.GetValue());
EXPECT_EQ("value", it.GetUnescapedValue());
it.Advance();
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("boolParam", it.GetKey());
EXPECT_EQ("", it.GetValue());
EXPECT_EQ("", it.GetUnescapedValue());
it.Advance();
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("url", it.GetKey());
EXPECT_EQ("http://test.com/q?n1%3Dv1%26n2", it.GetValue());
EXPECT_EQ("http://test.com/q?n1=v1&n2", it.GetUnescapedValue());
it.Advance();
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("multikey", it.GetKey());
EXPECT_EQ("value1", it.GetValue());
EXPECT_EQ("value1", it.GetUnescapedValue());
it.Advance();
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("multikey", it.GetKey());
EXPECT_EQ("value2", it.GetValue());
EXPECT_EQ("value2", it.GetUnescapedValue());
it.Advance();
ASSERT_FALSE(it.IsAtEnd());
EXPECT_EQ("multikey", it.GetKey());
EXPECT_EQ("", it.GetValue());
EXPECT_EQ("", it.GetUnescapedValue());
it.Advance();
EXPECT_TRUE(it.IsAtEnd());
}
TEST(UrlUtilTest, ParseQueryInvalidURL) {
const GURL url("http://%01/?test");
QueryIterator it(url);
EXPECT_TRUE(it.IsAtEnd());
}
TEST(UrlUtilTest, ParseHostAndPort) {
const struct {
const char* const input;
bool success;
const char* const expected_host;
int expected_port;
} tests[] = {
// Valid inputs:
{"foo:10", true, "foo", 10},
{"foo", true, "foo", -1},
{
"[1080:0:0:0:8:800:200C:4171]:11",
true,
"1080:0:0:0:8:800:200C:4171",
11
},
{
"[1080:0:0:0:8:800:200C:4171]",
true,
"1080:0:0:0:8:800:200C:4171",
-1
},
// Because no validation is done on the host, the following are accepted,
// even though they are invalid names.
{"]", true, "]", -1},
{"::1", true, ":", 1},
// Invalid inputs:
{"foo:bar", false, "", -1},
{"foo:", false, "", -1},
{":", false, "", -1},
{":80", false, "", -1},
{"", false, "", -1},
{"porttoolong:300000", false, "", -1},
{"usrname@host", false, "", -1},
{"usrname:password@host", false, "", -1},
{":password@host", false, "", -1},
{":password@host:80", false, "", -1},
{":password@host", false, "", -1},
{"@host", false, "", -1},
{"[", false, "", -1},
{"[]", false, "", -1},
};
for (const auto& test : tests) {
std::string host;
int port;
bool ok = ParseHostAndPort(test.input, &host, &port);
EXPECT_EQ(test.success, ok);
if (test.success) {
EXPECT_EQ(test.expected_host, host);
EXPECT_EQ(test.expected_port, port);
}
}
}
TEST(UrlUtilTest, GetHostAndPort) {
const struct {
GURL url;
const char* const expected_host_and_port;
} tests[] = {
{ GURL("http://www.foo.com/x"), "www.foo.com:80"},
{ GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
// For IPv6 literals should always include the brackets.
{ GURL("http://[1::2]/x"), "[1::2]:80"},
{ GURL("http://[::a]:33/x"), "[::a]:33"},
};
for (const auto& test : tests) {
std::string host_and_port = GetHostAndPort(test.url);
EXPECT_EQ(std::string(test.expected_host_and_port), host_and_port);
}
}
TEST(UrlUtilTest, GetHostAndOptionalPort) {
const struct {
GURL url;
const char* const expected_host_and_port;
} tests[] = {
{GURL("http://www.foo.com/x"), "www.foo.com"},
{GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
{GURL("http://www.foo.com:443/x"), "www.foo.com:443"},
{GURL("https://www.foo.com/x"), "www.foo.com"},
{GURL("https://www.foo.com:80/x"), "www.foo.com:80"},
// For IPv6 literals should always include the brackets.
{GURL("http://[1::2]/x"), "[1::2]"},
{GURL("http://[::a]:33/x"), "[::a]:33"},
};
for (const auto& test : tests) {
EXPECT_EQ(test.expected_host_and_port, GetHostAndOptionalPort(test.url));
// Also test the SchemeHostPort variant.
EXPECT_EQ(test.expected_host_and_port,
GetHostAndOptionalPort(url::SchemeHostPort(test.url)));
}
}
TEST(UrlUtilTest, GetHostOrSpecFromURL) {
EXPECT_EQ("example.com",
GetHostOrSpecFromURL(GURL("http://example.com/test")));
EXPECT_EQ("example.com",
GetHostOrSpecFromURL(GURL("http://example.com./test")));
EXPECT_EQ("file:///tmp/test.html",
GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
}
TEST(UrlUtilTest, GetSuperdomain) {
struct {
const char* const domain;
const char* const expected_superdomain;
} tests[] = {
// Basic cases
{"foo.bar.example", "bar.example"},
{"bar.example", "example"},
{"example", ""},
// Returned value may be an eTLD.
{"google.com", "com"},
{"google.co.uk", "co.uk"},
// Weird cases.
{"", ""},
{"has.trailing.dot.", "trailing.dot."},
{"dot.", ""},
{".has.leading.dot", "has.leading.dot"},
{".", ""},
{"..", "."},
{"127.0.0.1", "0.0.1"},
};
for (const auto& test : tests) {
EXPECT_EQ(test.expected_superdomain, GetSuperdomain(test.domain));
}
}
TEST(UrlUtilTest, IsSubdomainOf) {
struct {
const char* subdomain;
const char* superdomain;
bool is_subdomain;
} tests[] = {
{"bar.foo.com", "foo.com", true},
{"barfoo.com", "foo.com", false},
{"bar.foo.com", "com", true},
{"bar.foo.com", "other.com", false},
{"bar.foo.com", "bar.foo.com", true},
{"bar.foo.com", "baz.foo.com", false},
{"bar.foo.com", "baz.bar.foo.com", false},
{"bar.foo.com", "ar.foo.com", false},
{"foo.com", "foo.com.", false},
{"bar.foo.com", "foo.com.", false},
{"", "", true},
{"a", "", false},
{"", "a", false},
{"127.0.0.1", "0.0.1", true}, // Don't do this...
};
for (const auto& test : tests) {
EXPECT_EQ(test.is_subdomain,
IsSubdomainOf(test.subdomain, test.superdomain));
}
}
TEST(UrlUtilTest, CompliantHost) {
struct {
const char* const host;
bool expected_output;
} compliant_host_cases[] = {
{"", false},
{"a", true},
{"-", false},
{"_", false},
{".", false},
{"9", true},
{"9a", true},
{"9_", true},
{"a.", true},
{".a", false},
{"a.a", true},
{"9.a", true},
{"a.9", true},
{"_9a", false},
{"-9a", false},
{"a.a9", true},
{"_.9a", true},
{"a.-a9", false},
{"a+9a", false},
{"-a.a9", true},
{"a_.a9", true},
{"1-.a-b", true},
{"1_.a-b", true},
{"1-2.a_b", true},
{"a.b.c.d.e", true},
{"1.2.3.4.5", true},
{"1.2.3..4.5", false},
{"1.2.3.4.5.", true},
{"1.2.3.4.5..", false},
{"%20%20noodles.blorg", false},
{"noo dles.blorg ", false},
{"noo dles.blorg. ", false},
{"^noodles.blorg", false},
{"noodles^.blorg", false},
{"noo&dles.blorg", false},
{"noodles.blorg`", false},
{"www.noodles.blorg", true},
{"1www.noodles.blorg", true},
{"www.2noodles.blorg", true},
{"www.n--oodles.blorg", true},
{"www.noodl_es.blorg", true},
{"www.no-_odles.blorg", true},
{"www_.noodles.blorg", true},
{"www.noodles.blorg.", true},
{"_privet._tcp.local", true},
// 63-char label (before or without dot) allowed
{"z23456789a123456789a123456789a123456789a123456789a123456789a123", true},
{"z23456789a123456789a123456789a123456789a123456789a123456789a123.",
true},
// 64-char label (before or without dot) disallowed
{"123456789a123456789a123456789a123456789a123456789a123456789a1234",
false},
{"123456789a123456789a123456789a123456789a123456789a123456789a1234.",
false},
// 253-char host allowed
{"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abc",
true},
// 253-char+dot host allowed
{"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi."
"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abc.",
true},
// 254-char host disallowed
{"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.1234",
false},
// 254-char+dot host disallowed
{"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.1234.",
false},
};
for (const auto& compliant_host : compliant_host_cases) {
EXPECT_EQ(compliant_host.expected_output,
IsCanonicalizedHostCompliant(compliant_host.host))
<< compliant_host.host;
}
}
struct NonUniqueNameTestData {
bool is_unique;
const char* const hostname;
};
// Google Test pretty-printer.
void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
ASSERT_TRUE(data.hostname);
*os << " hostname: " << testing::PrintToString(data.hostname)
<< "; is_unique: " << testing::PrintToString(data.is_unique);
}
const NonUniqueNameTestData kNonUniqueNameTestData[] = {
// eTLDs
{true, "com"},
{true, "com."},
{true, ".com"},
{true, "co.uk"},
{true, "co.uk."},
{true, ".co.uk"},
{false, "notarealtld"},
{false, ".notarealtld"},
{false, "notarealtld."},
// Domains under ICANN-assigned domains.
{true, "google.com"},
{true, "google.co.uk"},
// Domains under private registries.
{true, "appspot.com"},
{true, "test.appspot.com"},
// Unreserved IPv4 addresses (in various forms).
{true, "8.8.8.8"},
{true, "99.64.0.0"},
{true, "212.15.0.0"},
{true, "212.15"},
{true, "212.15.0"},
{true, "3557752832"},
// Reserved IPv4 addresses (in various forms).
{false, "192.168.0.0"},
{false, "192.168.0.6"},
{false, "10.0.0.5"},
{false, "10.0"},
{false, "10.0.0"},
{false, "3232235526"},
// Unreserved IPv6 addresses.
{true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210"},
{true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210"},
// Reserved IPv6 addresses.
{false, "::192.9.5.5"},
{false, "FEED::BEEF"},
{false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210"},
// 'internal'/non-IANA assigned domains.
{false, "intranet"},
{false, "intranet."},
{false, "intranet.example"},
{false, "host.intranet.example"},
// gTLDs under discussion, but not yet assigned.
{false, "intranet.corp"},
{false, "intranet.internal"},
// Invalid host names are treated as unique - but expected to be
// filtered out before then.
{true, "junk)(£)$*!@~#"},
{true, "w$w.example.com"},
{true, "nocolonsallowed:example"},
{true, "[::4.5.6.9]"},
};
class UrlUtilNonUniqueNameTest
: public testing::TestWithParam<NonUniqueNameTestData> {
public:
~UrlUtilNonUniqueNameTest() override = default;
protected:
bool IsUnique(const std::string& hostname) {
return !IsHostnameNonUnique(hostname);
}
};
// Test that internal/non-unique names are properly identified as such, but
// that IP addresses and hosts beneath registry-controlled domains are flagged
// as unique names.
TEST_P(UrlUtilNonUniqueNameTest, IsHostnameNonUnique) {
const NonUniqueNameTestData& test_data = GetParam();
EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
}
INSTANTIATE_TEST_SUITE_P(All,
UrlUtilNonUniqueNameTest,
testing::ValuesIn(kNonUniqueNameTestData));
TEST(UrlUtilTest, IsLocalhost) {
EXPECT_TRUE(HostStringIsLocalhost("localhost"));
EXPECT_TRUE(HostStringIsLocalhost("localHosT"));
EXPECT_TRUE(HostStringIsLocalhost("localhost."));
EXPECT_TRUE(HostStringIsLocalhost("localHost."));
EXPECT_TRUE(HostStringIsLocalhost("127.0.0.1"));
EXPECT_TRUE(HostStringIsLocalhost("127.0.1.0"));
EXPECT_TRUE(HostStringIsLocalhost("127.1.0.0"));
EXPECT_TRUE(HostStringIsLocalhost("127.0.0.255"));
EXPECT_TRUE(HostStringIsLocalhost("127.0.255.0"));
EXPECT_TRUE(HostStringIsLocalhost("127.255.0.0"));
EXPECT_TRUE(HostStringIsLocalhost("::1"));
EXPECT_TRUE(HostStringIsLocalhost("0:0:0:0:0:0:0:1"));
EXPECT_TRUE(HostStringIsLocalhost("foo.localhost"));
EXPECT_TRUE(HostStringIsLocalhost("foo.localhost."));
EXPECT_TRUE(HostStringIsLocalhost("foo.localhoST"));
EXPECT_TRUE(HostStringIsLocalhost("foo.localhoST."));
EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain"));
EXPECT_FALSE(HostStringIsLocalhost("localhost.localDOMain"));
EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain."));
EXPECT_FALSE(HostStringIsLocalhost("localhost6"));
EXPECT_FALSE(HostStringIsLocalhost("localhost6."));
EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain6"));
EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain6."));
EXPECT_FALSE(HostStringIsLocalhost("localhostx"));
EXPECT_FALSE(HostStringIsLocalhost("localhost.x"));
EXPECT_FALSE(HostStringIsLocalhost("foo.localdomain"));
EXPECT_FALSE(HostStringIsLocalhost("foo.localdomain.x"));
EXPECT_FALSE(HostStringIsLocalhost("localhost6x"));
EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain6"));
EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain"));
EXPECT_FALSE(HostStringIsLocalhost("127.0.0.1.1"));
EXPECT_FALSE(HostStringIsLocalhost(".127.0.0.255"));
EXPECT_FALSE(HostStringIsLocalhost("::2"));
EXPECT_FALSE(HostStringIsLocalhost("::1:1"));
EXPECT_FALSE(HostStringIsLocalhost("0:0:0:0:1:0:0:1"));
EXPECT_FALSE(HostStringIsLocalhost("::1:1"));
EXPECT_FALSE(HostStringIsLocalhost("0:0:0:0:0:0:0:0:1"));
EXPECT_FALSE(HostStringIsLocalhost("foo.localhost.com"));
EXPECT_FALSE(HostStringIsLocalhost("foo.localhoste"));
EXPECT_FALSE(HostStringIsLocalhost("foo.localhos"));
EXPECT_FALSE(HostStringIsLocalhost("[::1]"));
GURL localhost6("http://[::1]/");
EXPECT_TRUE(IsLocalhost(localhost6));
}
TEST(UrlUtilTest, SimplifyUrlForRequest) {
struct {
const char* const input_url;
const char* const expected_simplified_url;
} tests[] = {
{
// Reference section should be stripped.
"http://www.google.com:78/foobar?query=1#hash",
"http://www.google.com:78/foobar?query=1",
},
{
// Reference section can itself contain #.
"http://192.168.0.1?query=1#hash#10#11#13#14",
"http://192.168.0.1?query=1",
},
{
// Strip username/password.
"http://user:pass@google.com",
"http://google.com/",
},
{
// Strip both the reference and the username/password.
"http://user:pass@google.com:80/sup?yo#X#X",
"http://google.com/sup?yo",
},
{
// Try an HTTPS URL -- strip both the reference and the
// username/password.
"https://user:pass@google.com:80/sup?yo#X#X",
"https://google.com:80/sup?yo",
},
{
// Try an FTP URL -- strip both the reference and the
// username/password.
"ftp://user:pass@google.com:80/sup?yo#X#X",
"ftp://google.com:80/sup?yo",
},
{
// Try a non-special URL.
"foobar://user:pass@google.com:80/sup?yo#X#X",
"foobar://google.com:80/sup?yo",
},
};
for (const auto& test : tests) {
SCOPED_TRACE(test.input_url);
GURL input_url(GURL(test.input_url));
GURL expected_url(GURL(test.expected_simplified_url));
EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
}
}
TEST(UrlUtilTest, ChangeWebSocketSchemeToHttpScheme) {
struct {
const char* const input_url;
const char* const expected_output_url;
} tests[] = {
{"ws://google.com:78/path?query=1", "http://google.com:78/path?query=1"},
{"wss://google.com:441/path?q=1", "https://google.com:441/path?q=1"}};
for (const auto& test : tests) {
GURL input_url(test.input_url);
GURL expected_output_url(test.expected_output_url);
EXPECT_EQ(expected_output_url,
ChangeWebSocketSchemeToHttpScheme(input_url));
}
}
TEST(UrlUtilTest, SchemeHasNetworkHost) {
const char kCustomSchemeWithHostPortAndUserInformation[] = "foo";
const char kCustomSchemeWithHostAndPort[] = "bar";
const char kCustomSchemeWithHost[] = "baz";
const char kCustomSchemeWithoutAuthority[] = "qux";
const char kNonStandardScheme[] = "not-registered";
url::ScopedSchemeRegistryForTests scheme_registry;
AddStandardScheme(kCustomSchemeWithHostPortAndUserInformation,
url::SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION);
AddStandardScheme(kCustomSchemeWithHostAndPort,
url::SCHEME_WITH_HOST_AND_PORT);
AddStandardScheme(kCustomSchemeWithHost, url::SCHEME_WITH_HOST);
AddStandardScheme(kCustomSchemeWithoutAuthority,
url::SCHEME_WITHOUT_AUTHORITY);
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kHttpScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kHttpsScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kWsScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kWssScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kFtpScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kFileScheme));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(
kCustomSchemeWithHostPortAndUserInformation));
EXPECT_TRUE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithHostAndPort));
EXPECT_FALSE(IsStandardSchemeWithNetworkHost(url::kFileSystemScheme));
EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithHost));
EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithoutAuthority));
EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kNonStandardScheme));
}
TEST(UrlUtilTest, GetOriginRelation) {
using enum OriginRelation;
const url::Origin kExampleOrigin =
url::Origin::Create(GURL("https://example.test"));
EXPECT_EQ(GetOriginRelation(kExampleOrigin, kExampleOrigin), kSameOrigin);
EXPECT_EQ(GetOriginRelation(
kExampleOrigin,
url::Origin::Create(GURL("https://other.example.test"))),
kSameSite);
EXPECT_EQ(
GetOriginRelation(kExampleOrigin,
url::Origin::Create(GURL("https://cross-site.test"))),
kCrossSite);
// Same-site rules about schemes are followed.
const url::Origin cross_scheme_origin =
url::Origin::Create(GURL("http://example.test"));
EXPECT_EQ(GetOriginRelation(kExampleOrigin, cross_scheme_origin), kCrossSite);
// Same-site rules about opaque origins are followed.
EXPECT_EQ(
GetOriginRelation(kExampleOrigin, kExampleOrigin.DeriveNewOpaqueOrigin()),
kCrossSite);
// Cross-port origins are same-site.
EXPECT_EQ(
GetOriginRelation(kExampleOrigin,
url::Origin::CreateFromNormalizedTuple(
kExampleOrigin.scheme(), kExampleOrigin.host(),
kExampleOrigin.port() + 1)),
kSameSite);
}
TEST(UrlUtilTest, GetIdentityFromURL) {
struct {
const char* const input_url;
const char* const expected_username;
const char* const expected_password;
} tests[] = {
{
"http://username:password@google.com",
"username",
"password",
},
{
// Test for http://crbug.com/19200
"http://username:p@ssword@google.com",
"username",
"p@ssword",
},
{
// Special URL characters should be unescaped.
"http://username:p%3fa%26s%2fs%23@google.com",
"username",
"p?a&s/s#",
},
{
// Username contains %20, password %25.
"http://use rname:password%25@google.com",
"use rname",
"password%",
},
{
// Username and password contain forward / backward slashes.
"http://username%2F:password%5C@google.com",
"username/",
"password\\",
},
{
// Keep %00 and %01 as-is, and ignore other escaped characters when
// present.
"http://use%00rname%20:pass%01word%25@google.com",
"use%00rname%20",
"pass%01word%25",
},
{
// Keep CR and LF as-is.
"http://use%0Arname:pass%0Dword@google.com",
"use%0Arname",
"pass%0Dword",
},
{
// Use a '+' in the username.
"http://use+rname:password@google.com",
"use+rname",
"password",
},
{
// Use a '&' in the password.
"http://username:p&ssword@google.com",
"username",
"p&ssword",
},
{
// These UTF-8 characters are considered unsafe to unescape by
// UnescapeURLComponent, but raise no special concerns as part of the
// identity portion of a URL.
"http://%F0%9F%94%92:%E2%80%82@google.com",
"\xF0\x9F\x94\x92",
"\xE2\x80\x82",
},
{
// Leave invalid UTF-8 alone, and leave valid UTF-8 characters alone
// if there's also an invalid character in the string - strings should
// not be partially unescaped.
"http://%81:%E2%80%82%E2%80@google.com",
"%81",
"%E2%80%82%E2%80",
},
};
for (const auto& test : tests) {
SCOPED_TRACE(test.input_url);
GURL url(test.input_url);
std::u16string username, password;
GetIdentityFromURL(url, &username, &password);
EXPECT_EQ(base::UTF8ToUTF16(test.expected_username), username);
EXPECT_EQ(base::UTF8ToUTF16(test.expected_password), password);
}
}
// Try extracting a username which was encoded with UTF8.
TEST(UrlUtilTest, GetIdentityFromURL_UTF8) {
GURL url(u"http://foo:\x4f60\x597d@blah.com");
EXPECT_EQ("foo", url.username());
EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password());
// Extract the unescaped identity.
std::u16string username, password;
GetIdentityFromURL(url, &username, &password);
// Verify that it was decoded as UTF8.
EXPECT_EQ(u"foo", username);
EXPECT_EQ(u"\x4f60\x597d", password);
}
TEST(UrlUtilTest, GoogleHost) {
struct {
GURL url;
bool expected_output;
} google_host_cases[] = {
{GURL("http://.google.com"), true},
{GURL("http://.youtube.com"), true},
{GURL("http://.gmail.com"), true},
{GURL("http://.doubleclick.net"), true},
{GURL("http://.gstatic.com"), true},
{GURL("http://.googlevideo.com"), true},
{GURL("http://.googleusercontent.com"), true},
{GURL("http://.googlesyndication.com"), true},
{GURL("http://.google-analytics.com"), true},
{GURL("http://.googleadservices.com"), true},
{GURL("http://.googleapis.com"), true},
{GURL("http://a.google.com"), true},
{GURL("http://b.youtube.com"), true},
{GURL("http://c.gmail.com"), true},
{GURL("http://google.com"), false},
{GURL("http://youtube.com"), false},
{GURL("http://gmail.com"), false},
{GURL("http://google.coma"), false},
{GURL("http://agoogle.com"), false},
{GURL("http://oogle.com"), false},
{GURL("http://google.co"), false},
{GURL("http://oggole.com"), false},
};
for (const auto& host : google_host_cases) {
EXPECT_EQ(host.expected_output, HasGoogleHost(host.url));
}
}
TEST(UrlUtilTest, IsLocalHostname) {
EXPECT_TRUE(IsLocalHostname("localhost"));
EXPECT_TRUE(IsLocalHostname("localhost."));
EXPECT_TRUE(IsLocalHostname("LOCALhost"));
EXPECT_TRUE(IsLocalHostname("LOCALhost."));
EXPECT_TRUE(IsLocalHostname("abc.localhost"));
EXPECT_TRUE(IsLocalHostname("abc.localhost."));
EXPECT_TRUE(IsLocalHostname("abc.LOCALhost"));
EXPECT_TRUE(IsLocalHostname("abc.LOCALhost."));
EXPECT_TRUE(IsLocalHostname("abc.def.localhost"));
EXPECT_FALSE(IsLocalHostname("localhost.actuallynot"));
EXPECT_FALSE(IsLocalHostname("notlocalhost"));
EXPECT_FALSE(IsLocalHostname("notlocalhost."));
EXPECT_FALSE(IsLocalHostname("still.notlocalhost"));
EXPECT_FALSE(IsLocalHostname("localhostjustkidding"));
}
TEST(UrlUtilTest, GoogleHostWithAlpnH3) {
struct {
std::string_view host;
bool expected_output;
} test_cases[] = {
{"google.com", true}, {"www.google.com", true},
{"google.CoM", true}, {"www.Google.cOm", true},
{"www.google.cat", false}, {"www.google.co.in", false},
{"www.google.co.jp", false},
};
for (const auto& host : test_cases) {
EXPECT_EQ(host.expected_output, IsGoogleHostWithAlpnH3(host.host));
}
}
} // namespace
} // namespace net