1230 lines
30 KiB
JavaScript
1230 lines
30 KiB
JavaScript
const { AppConstants } = ChromeUtils.importESModule(
|
|
"resource://gre/modules/AppConstants.sys.mjs"
|
|
);
|
|
|
|
const kForceDNSLookup = "browser.fixup.dns_first_for_single_words";
|
|
|
|
// TODO(bug 1522134), this test should also use
|
|
// combinations of the following flags.
|
|
var flagInputs = [
|
|
Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP,
|
|
Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP |
|
|
Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT,
|
|
Services.uriFixup.FIXUP_FLAGS_MAKE_ALTERNATE_URI,
|
|
Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS,
|
|
// This should not really generate a search, but it does, see Bug 1588118.
|
|
Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS |
|
|
Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT,
|
|
];
|
|
|
|
function schemeTypoOnly(flags) {
|
|
return flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS;
|
|
}
|
|
|
|
/*
|
|
The following properties are supported for these test cases:
|
|
{
|
|
input: "", // Input string, required
|
|
fixedURI: "", // Expected fixedURI
|
|
alternateURI: "", // Expected alternateURI
|
|
keywordLookup: false, // Whether a keyword lookup is expected
|
|
protocolChange: false, // Whether a protocol change is expected
|
|
inWhitelist: false, // Whether the input host is in the whitelist
|
|
affectedByDNSForSingleWordHosts: false, // Whether the input host could be a host, but is normally assumed to be a keyword query
|
|
}
|
|
*/
|
|
var testcases = [
|
|
{
|
|
input: "about:home",
|
|
fixedURI: "about:home",
|
|
},
|
|
{
|
|
input: "http://www.mozilla.org",
|
|
fixedURI: "http://www.mozilla.org/",
|
|
},
|
|
{
|
|
input: "http://127.0.0.1/",
|
|
fixedURI: "http://127.0.0.1/",
|
|
},
|
|
{
|
|
input: "file:///foo/bar",
|
|
fixedURI: "file:///foo/bar",
|
|
},
|
|
{
|
|
input: "://www.mozilla.org",
|
|
fixedURI: "http://www.mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "www.mozilla.org",
|
|
fixedURI: "http://www.mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "http://mozilla/",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
},
|
|
{
|
|
input: "http://test./",
|
|
fixedURI: "http://test./",
|
|
alternateURI: "https://www.test./",
|
|
},
|
|
{
|
|
input: "127.0.0.1",
|
|
fixedURI: "http://127.0.0.1/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3.4/",
|
|
fixedURI: "http://1.2.3.4/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3.4/foo",
|
|
fixedURI: "http://1.2.3.4/foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3.4:8000",
|
|
fixedURI: "http://1.2.3.4:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3.4:8000/",
|
|
fixedURI: "http://1.2.3.4:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3.4:8000/foo",
|
|
fixedURI: "http://1.2.3.4:8000/foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "192.168.10.110",
|
|
fixedURI: "http://192.168.10.110/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "192.168.10.110/123",
|
|
fixedURI: "http://192.168.10.110/123",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "192.168.10.110/123foo",
|
|
fixedURI: "http://192.168.10.110/123foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "192.168.10.110:1234/123",
|
|
fixedURI: "http://192.168.10.110:1234/123",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "192.168.10.110:1234/123foo",
|
|
fixedURI: "http://192.168.10.110:1234/123foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3",
|
|
fixedURI: "http://1.2.0.3/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3/",
|
|
fixedURI: "http://1.2.0.3/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3/foo",
|
|
fixedURI: "http://1.2.0.3/foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3/123",
|
|
fixedURI: "http://1.2.0.3/123",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3:8000",
|
|
fixedURI: "http://1.2.0.3:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3:8000/",
|
|
fixedURI: "http://1.2.0.3:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3:8000/foo",
|
|
fixedURI: "http://1.2.0.3:8000/foo",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "1.2.3:8000/123",
|
|
fixedURI: "http://1.2.0.3:8000/123",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "http://1.2.3",
|
|
fixedURI: "http://1.2.0.3/",
|
|
},
|
|
{
|
|
input: "http://1.2.3/",
|
|
fixedURI: "http://1.2.0.3/",
|
|
},
|
|
{
|
|
input: "http://1.2.3/foo",
|
|
fixedURI: "http://1.2.0.3/foo",
|
|
},
|
|
{
|
|
input: "[::1]",
|
|
fixedURI: "http://[::1]/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[::1]/",
|
|
fixedURI: "http://[::1]/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[::1]:8000",
|
|
fixedURI: "http://[::1]:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[::1]:8000/",
|
|
fixedURI: "http://[::1]:8000/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[[::1]]/",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "[fe80:cd00:0:cde:1257:0:211e:729c]",
|
|
fixedURI: "http://[fe80:cd00:0:cde:1257:0:211e:729c]/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[64:ff9b::8.8.8.8]",
|
|
fixedURI: "http://[64:ff9b::808:808]/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[64:ff9b::8.8.8.8]/~moz",
|
|
fixedURI: "http://[64:ff9b::808:808]/~moz",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "[::1][::1]",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "[::1][100",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "[::1]]",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "1234",
|
|
fixedURI: "http://0.0.4.210/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "whitelisted/foo.txt",
|
|
fixedURI: "http://whitelisted/foo.txt",
|
|
alternateURI: "https://www.whitelisted.com/foo.txt",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "test.",
|
|
fixedURI: "http://test./",
|
|
alternateURI: "https://www.test./",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: ".test",
|
|
fixedURI: "http://.test/",
|
|
alternateURI: "https://www.test/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla is amazing",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "search ?mozilla",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla .com",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "what if firefox?",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "london's map",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla ",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: " mozilla ",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla \\",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla \\ foo.txt",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla \\\r foo.txt",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla\n",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla \r\n",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "moz\r\nfirefox\nos\r",
|
|
fixedURI: "http://mozfirefoxos/",
|
|
alternateURI: "https://www.mozfirefoxos.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "moz\r\n firefox\n",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "[]",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "http://whitelisted/",
|
|
fixedURI: "http://whitelisted/",
|
|
alternateURI: "https://www.whitelisted.com/",
|
|
inWhitelist: true,
|
|
},
|
|
{
|
|
input: "whitelisted",
|
|
fixedURI: "http://whitelisted/",
|
|
alternateURI: "https://www.whitelisted.com/",
|
|
protocolChange: true,
|
|
inWhitelist: true,
|
|
},
|
|
{
|
|
input: "whitelisted.",
|
|
fixedURI: "http://whitelisted./",
|
|
alternateURI: "https://www.whitelisted./",
|
|
protocolChange: true,
|
|
inWhitelist: true,
|
|
},
|
|
{
|
|
input: "mochi.test",
|
|
fixedURI: "http://mochi.test/",
|
|
alternateURI: "https://www.mochi.test/",
|
|
protocolChange: true,
|
|
inWhitelist: true,
|
|
},
|
|
// local.domain is a whitelisted suffix...
|
|
{
|
|
input: "some.local.domain",
|
|
fixedURI: "http://some.local.domain/",
|
|
protocolChange: true,
|
|
inWhitelist: true,
|
|
},
|
|
// ...but .domain is not.
|
|
{
|
|
input: "some.domain",
|
|
fixedURI: "http://some.domain/",
|
|
alternateURI: "https://www.some.domain/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "café.com",
|
|
fixedURI: "http://xn--caf-dma.com/",
|
|
alternateURI: "https://www.xn--caf-dma.com/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla.nonexistent",
|
|
fixedURI: "http://mozilla.nonexistent/",
|
|
alternateURI: "https://www.mozilla.nonexistent/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mochi.ocm",
|
|
fixedURI: "http://mochi.com/",
|
|
alternateURI: "https://www.mochi.com/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "47.6182,-122.830",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "-47.6182,-23.51",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "-22.14,23.51-",
|
|
fixedURI: "http://-22.14,23.51-/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "32.7",
|
|
fixedURI: "http://32.0.0.7/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "5+2",
|
|
fixedURI: "http://5+2/",
|
|
alternateURI: "https://www.5+2.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "5/2",
|
|
fixedURI: "http://0.0.0.5/2",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "moz ?.::%27",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla.com/?q=search",
|
|
fixedURI: "http://mozilla.com/?q=search",
|
|
alternateURI: "https://www.mozilla.com/?q=search",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla.com?q=search",
|
|
fixedURI: "http://mozilla.com/?q=search",
|
|
alternateURI: "https://www.mozilla.com/?q=search",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla.com ?q=search",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla.com.?q=search",
|
|
fixedURI: "http://mozilla.com./?q=search",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla.com'?q=search",
|
|
fixedURI: "http://mozilla.com/?q=search",
|
|
alternateURI: "https://www.mozilla.com/?q=search",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla.com':search",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "[mozilla]",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "':?",
|
|
fixedURI: "http://'/?",
|
|
alternateURI: "https://www.'.com/?",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "whitelisted?.com",
|
|
fixedURI: "http://whitelisted/?.com",
|
|
alternateURI: "https://www.whitelisted.com/?.com",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "?'.com",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: ".com",
|
|
keywordLookup: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
fixedURI: "http://.com/",
|
|
alternateURI: "https://www.com/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "' ?.com",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "?mozilla",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "??mozilla",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla/",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
protocolChange: true,
|
|
keywordLookup: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla5/2",
|
|
fixedURI: "http://mozilla5/2",
|
|
alternateURI: "https://www.mozilla5.com/2",
|
|
protocolChange: true,
|
|
keywordLookup: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla/foo",
|
|
fixedURI: "http://mozilla/foo",
|
|
alternateURI: "https://www.mozilla.com/foo",
|
|
protocolChange: true,
|
|
keywordLookup: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "mozilla\\",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "localhost",
|
|
fixedURI: "http://localhost/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "http",
|
|
fixedURI: "http://http/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "https",
|
|
fixedURI: "http://https/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "localhost:8080",
|
|
fixedURI: "http://localhost:8080/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "plonk:8080",
|
|
fixedURI: "http://plonk:8080/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "plonk:8080?test",
|
|
fixedURI: "http://plonk:8080/?test",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "plonk:8080#test",
|
|
fixedURI: "http://plonk:8080/#test",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "plonk/ #",
|
|
fixedURI: "http://plonk/%20#",
|
|
alternateURI: "https://www.plonk.com/%20#",
|
|
protocolChange: true,
|
|
keywordLookup: false,
|
|
},
|
|
{
|
|
input: "blah.com.",
|
|
fixedURI: "http://blah.com./",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input:
|
|
"\u10E0\u10D4\u10D2\u10D8\u10E1\u10E2\u10E0\u10D0\u10EA\u10D8\u10D0.\u10D2\u10D4",
|
|
fixedURI: "http://xn--lodaehvb5cdik4g.xn--node/",
|
|
alternateURI: "https://www.xn--lodaehvb5cdik4g.xn--node/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: " \t mozilla.org/\t \t ",
|
|
fixedURI: "http://mozilla.org/",
|
|
alternateURI: "https://www.mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: " moz\ti\tlla.org ",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "mozilla/",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla/ test /",
|
|
fixedURI: "http://mozilla/%20test%20/",
|
|
alternateURI: "https://www.mozilla.com/%20test%20/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "mozilla /test/",
|
|
keywordLookup: true,
|
|
},
|
|
{
|
|
input: "pserver:8080",
|
|
fixedURI: "http://pserver:8080/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "http;mozilla",
|
|
fixedURI: "http://http;mozilla/",
|
|
alternateURI: "https://www.http;mozilla.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
{
|
|
input: "http//mozilla.org",
|
|
fixedURI: "http://mozilla.org/",
|
|
shouldRunTest: flags =>
|
|
flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS,
|
|
},
|
|
{
|
|
input: "http//mozilla.org",
|
|
fixedURI: "http://http//mozilla.org",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
shouldRunTest: flags =>
|
|
!(flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS),
|
|
},
|
|
{
|
|
input: "www.mozilla",
|
|
fixedURI: "http://www.mozilla/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "https://sub.www..mozilla...org/",
|
|
fixedURI: "https://sub.www.mozilla.org/",
|
|
},
|
|
{
|
|
input: "sub.www..mozilla...org/",
|
|
fixedURI: "http://sub.www.mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "sub.www..mozilla...org",
|
|
fixedURI: "http://sub.www.mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "www...mozilla",
|
|
fixedURI: "http://www.mozilla/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
shouldRunTest: flags =>
|
|
!gSingleWordDNSLookup &&
|
|
flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP,
|
|
},
|
|
{
|
|
input: "www...mozilla",
|
|
fixedURI: "http://www.mozilla/",
|
|
protocolChange: true,
|
|
shouldRunTest: flags =>
|
|
gSingleWordDNSLookup ||
|
|
!(flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP),
|
|
},
|
|
{
|
|
input: "mozilla...org",
|
|
fixedURI: "http://mozilla.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "モジラ...org",
|
|
fixedURI: "http://xn--yck6dwa.org/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "user@localhost",
|
|
fixedURI: "http://user@localhost/",
|
|
protocolChange: true,
|
|
shouldRunTest: () => gSingleWordDNSLookup,
|
|
},
|
|
{
|
|
input: "user@localhost",
|
|
fixedURI: "http://user@localhost/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
shouldRunTest: () => !gSingleWordDNSLookup,
|
|
},
|
|
{
|
|
input: "user@192.168.0.1",
|
|
fixedURI: "http://user@192.168.0.1/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "user@dummy-host",
|
|
fixedURI: "http://user@dummy-host/",
|
|
protocolChange: true,
|
|
shouldRunTest: () => gSingleWordDNSLookup,
|
|
},
|
|
{
|
|
input: "user@dummy-host",
|
|
fixedURI: "http://user@dummy-host/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
shouldRunTest: () => !gSingleWordDNSLookup,
|
|
},
|
|
{
|
|
input: "user:pass@dummy-host",
|
|
fixedURI: "http://user:pass@dummy-host/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: ":pass@dummy-host",
|
|
fixedURI: "http://:pass@dummy-host/",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "user@dummy-host/path",
|
|
fixedURI: "http://user@dummy-host/path",
|
|
protocolChange: true,
|
|
shouldRunTest: () => gSingleWordDNSLookup,
|
|
},
|
|
{
|
|
input: "jar:file:///omni.ja!/",
|
|
fixedURI: "jar:file:///omni.ja!/",
|
|
},
|
|
{
|
|
input: "example.comm.",
|
|
fixedURI: "http://example.comm./",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "example。com。",
|
|
fixedURI: "http://example.com./",
|
|
protocolChange: true,
|
|
},
|
|
{
|
|
input: "example。comm。",
|
|
fixedURI: "http://example.comm./",
|
|
protocolChange: true,
|
|
keywordLookup: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
},
|
|
|
|
{
|
|
input: "0.0.0.0",
|
|
fixedURI: "http://127.0.0.1/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "0.0.0.0/",
|
|
fixedURI: "http://127.0.0.1/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "0.0.0.0:8080",
|
|
fixedURI: "http://127.0.0.1:8080/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "0.0.0.0:8080/blah?blah",
|
|
fixedURI: "http://127.0.0.1:8080/blah?blah",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://0.0.0.0",
|
|
fixedURI: "http://127.0.0.1/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://0.0.0.0/",
|
|
fixedURI: "http://127.0.0.1/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://0.0.0.0:8080",
|
|
fixedURI: "http://127.0.0.1:8080/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://0.0.0.0:8080/blah?blah",
|
|
fixedURI: "http://127.0.0.1:8080/blah?blah",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://0.0.0.0",
|
|
fixedURI: "https://127.0.0.1/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://0.0.0.0/",
|
|
fixedURI: "https://127.0.0.1/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://0.0.0.0:8080",
|
|
fixedURI: "https://127.0.0.1:8080/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://0.0.0.0:8080/blah?blah",
|
|
fixedURI: "https://127.0.0.1:8080/blah?blah",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
|
|
{
|
|
input: "[::]",
|
|
fixedURI: "http://[::1]/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "[::]/",
|
|
fixedURI: "http://[::1]/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "[::]:8080",
|
|
fixedURI: "http://[::1]:8080/",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "[::]:8080/blah?blah",
|
|
fixedURI: "http://[::1]:8080/blah?blah",
|
|
protocolChange: true,
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://[::]",
|
|
fixedURI: "http://[::1]/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://[::]/",
|
|
fixedURI: "http://[::1]/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://[::]:8080",
|
|
fixedURI: "http://[::1]:8080/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "http://[::]:8080/blah?blah",
|
|
fixedURI: "http://[::1]:8080/blah?blah",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://[::]",
|
|
fixedURI: "https://[::1]/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://[::]/",
|
|
fixedURI: "https://[::1]/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://[::]:8080",
|
|
fixedURI: "https://[::1]:8080/",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
{
|
|
input: "https://[::]:8080/blah?blah",
|
|
fixedURI: "https://[::1]:8080/blah?blah",
|
|
shouldRunTest: schemeTypoOnly,
|
|
},
|
|
];
|
|
|
|
if (AppConstants.platform == "win") {
|
|
testcases.push({
|
|
input: "C:\\some\\file.txt",
|
|
fixedURI: "file:///C:/some/file.txt",
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "//mozilla",
|
|
fixedURI: "http://mozilla/",
|
|
alternateURI: "https://www.mozilla.com/",
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "/a",
|
|
fixedURI: "http://a/",
|
|
alternateURI: "https://www.a.com/",
|
|
keywordLookup: true,
|
|
protocolChange: true,
|
|
affectedByDNSForSingleWordHosts: true,
|
|
});
|
|
} else {
|
|
const homeDir = Services.dirsvc.get("Home", Ci.nsIFile).path;
|
|
const homeBase = AppConstants.platform == "macosx" ? "/Users" : "/home";
|
|
|
|
testcases.push({
|
|
input: "~",
|
|
fixedURI: `file://${homeDir}`,
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "~/foo",
|
|
fixedURI: `file://${homeDir}/foo`,
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "~foo",
|
|
fixedURI: `file://${homeBase}/foo`,
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "~foo/bar",
|
|
fixedURI: `file://${homeBase}/foo/bar`,
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "/some/file.txt",
|
|
fixedURI: "file:///some/file.txt",
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "//mozilla",
|
|
fixedURI: "file:////mozilla",
|
|
protocolChange: true,
|
|
});
|
|
testcases.push({
|
|
input: "/a",
|
|
fixedURI: "file:///a",
|
|
protocolChange: true,
|
|
});
|
|
}
|
|
|
|
function sanitize(input) {
|
|
return input.replace(/\r|\n/g, "").trim();
|
|
}
|
|
|
|
add_task(async function setup() {
|
|
var prefList = [
|
|
"browser.fixup.typo.scheme",
|
|
"keyword.enabled",
|
|
"browser.fixup.domainwhitelist.whitelisted",
|
|
"browser.fixup.domainsuffixwhitelist.test",
|
|
"browser.fixup.domainsuffixwhitelist.local.domain",
|
|
"browser.search.separatePrivateDefault",
|
|
"browser.search.separatePrivateDefault.ui.enabled",
|
|
];
|
|
for (let pref of prefList) {
|
|
Services.prefs.setBoolPref(pref, true);
|
|
}
|
|
|
|
await setupSearchService();
|
|
await addTestEngines();
|
|
|
|
await Services.search.setDefault(
|
|
Services.search.getEngineByName(kSearchEngineID),
|
|
Ci.nsISearchService.CHANGE_REASON_UNKNOWN
|
|
);
|
|
await Services.search.setDefaultPrivate(
|
|
Services.search.getEngineByName(kPrivateSearchEngineID),
|
|
Ci.nsISearchService.CHANGE_REASON_UNKNOWN
|
|
);
|
|
});
|
|
|
|
var gSingleWordDNSLookup = false;
|
|
add_task(async function run_test() {
|
|
// Only keywordlookup things should be affected by requiring a DNS lookup for single-word hosts:
|
|
info(
|
|
"Check only keyword lookup testcases should be affected by requiring DNS for single hosts"
|
|
);
|
|
let affectedTests = testcases.filter(
|
|
t => !t.keywordLookup && t.affectedByDNSForSingleWordHosts
|
|
);
|
|
if (affectedTests.length) {
|
|
for (let testcase of affectedTests) {
|
|
info("Affected: " + testcase.input);
|
|
}
|
|
}
|
|
Assert.equal(affectedTests.length, 0);
|
|
await do_single_test_run();
|
|
gSingleWordDNSLookup = true;
|
|
await do_single_test_run();
|
|
gSingleWordDNSLookup = false;
|
|
await Services.search.setDefault(
|
|
Services.search.getEngineByName(kPostSearchEngineID),
|
|
Ci.nsISearchService.CHANGE_REASON_UNKNOWN
|
|
);
|
|
await do_single_test_run();
|
|
});
|
|
|
|
async function do_single_test_run() {
|
|
Services.prefs.setBoolPref(kForceDNSLookup, gSingleWordDNSLookup);
|
|
let relevantTests = gSingleWordDNSLookup
|
|
? testcases.filter(t => t.keywordLookup)
|
|
: testcases;
|
|
|
|
let engine = await Services.search.getDefault();
|
|
let engineUrl =
|
|
engine.name == kPostSearchEngineID
|
|
? kPostSearchEngineURL
|
|
: kSearchEngineURL;
|
|
let privateEngine = await Services.search.getDefaultPrivate();
|
|
let privateEngineUrl = kPrivateSearchEngineURL;
|
|
|
|
for (let {
|
|
input: testInput,
|
|
fixedURI: expectedFixedURI,
|
|
alternateURI: alternativeURI,
|
|
keywordLookup: expectKeywordLookup,
|
|
protocolChange: expectProtocolChange,
|
|
inWhitelist: inWhitelist,
|
|
affectedByDNSForSingleWordHosts: affectedByDNSForSingleWordHosts,
|
|
shouldRunTest,
|
|
} of relevantTests) {
|
|
// Explicitly force these into a boolean
|
|
expectKeywordLookup = !!expectKeywordLookup;
|
|
expectProtocolChange = !!expectProtocolChange;
|
|
inWhitelist = !!inWhitelist;
|
|
affectedByDNSForSingleWordHosts = !!affectedByDNSForSingleWordHosts;
|
|
|
|
expectKeywordLookup =
|
|
expectKeywordLookup &&
|
|
(!affectedByDNSForSingleWordHosts || !gSingleWordDNSLookup);
|
|
|
|
for (let flags of flagInputs) {
|
|
info(
|
|
'Checking "' +
|
|
testInput +
|
|
'" with flags ' +
|
|
flags +
|
|
" (DNS lookup for single words: " +
|
|
(gSingleWordDNSLookup ? "yes" : "no") +
|
|
")"
|
|
);
|
|
|
|
if (shouldRunTest && !shouldRunTest(flags)) {
|
|
continue;
|
|
}
|
|
|
|
let URIInfo;
|
|
try {
|
|
URIInfo = Services.uriFixup.getFixupURIInfo(testInput, flags);
|
|
} catch (ex) {
|
|
// Both APIs should return an error in the same cases.
|
|
info("Caught exception: " + ex);
|
|
Assert.equal(expectedFixedURI, null);
|
|
continue;
|
|
}
|
|
|
|
// Check the fixedURI:
|
|
let makeAlternativeURI =
|
|
flags & Services.uriFixup.FIXUP_FLAGS_MAKE_ALTERNATE_URI;
|
|
|
|
if (makeAlternativeURI && alternativeURI != null) {
|
|
Assert.equal(
|
|
URIInfo.fixedURI.spec,
|
|
alternativeURI,
|
|
"should have gotten alternate URI"
|
|
);
|
|
} else {
|
|
Assert.equal(
|
|
URIInfo.fixedURI && URIInfo.fixedURI.spec,
|
|
expectedFixedURI,
|
|
"should get correct fixed URI"
|
|
);
|
|
}
|
|
|
|
// Check booleans on input:
|
|
let couldDoKeywordLookup =
|
|
flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP;
|
|
Assert.equal(
|
|
!!URIInfo.keywordProviderName,
|
|
couldDoKeywordLookup && expectKeywordLookup,
|
|
"keyword lookup as expected"
|
|
);
|
|
|
|
let expectProtocolChangeAfterAlternate = false;
|
|
// If alternativeURI was created, the protocol of the URI
|
|
// might have been changed to browser.fixup.alternate.protocol
|
|
// If the protocol is not the same as what was in expectedFixedURI,
|
|
// the protocol must've changed in the fixup process.
|
|
if (
|
|
makeAlternativeURI &&
|
|
alternativeURI != null &&
|
|
!expectedFixedURI.startsWith(URIInfo.fixedURI.scheme)
|
|
) {
|
|
expectProtocolChangeAfterAlternate = true;
|
|
}
|
|
|
|
Assert.equal(
|
|
URIInfo.fixupChangedProtocol,
|
|
expectProtocolChange || expectProtocolChangeAfterAlternate,
|
|
"protocol change as expected"
|
|
);
|
|
Assert.equal(
|
|
URIInfo.fixupCreatedAlternateURI,
|
|
makeAlternativeURI && alternativeURI != null,
|
|
"alternative URI as expected"
|
|
);
|
|
|
|
// Check the preferred URI
|
|
if (couldDoKeywordLookup) {
|
|
if (expectKeywordLookup) {
|
|
if (!inWhitelist) {
|
|
let urlparamInput = encodeURIComponent(sanitize(testInput)).replace(
|
|
/%20/g,
|
|
"+"
|
|
);
|
|
// If the input starts with `?`, then URIInfo.preferredURI.spec will omit it
|
|
// In order to test this behaviour, remove `?` only if it is the first character
|
|
if (urlparamInput.startsWith("%3F")) {
|
|
urlparamInput = urlparamInput.replace("%3F", "");
|
|
}
|
|
let isPrivate =
|
|
flags & Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT;
|
|
let searchEngineUrl = isPrivate ? privateEngineUrl : engineUrl;
|
|
let searchURL = searchEngineUrl.replace(
|
|
"{searchTerms}",
|
|
urlparamInput
|
|
);
|
|
let spec = URIInfo.preferredURI.spec.replace(/%27/g, "'");
|
|
Assert.equal(spec, searchURL, "should get correct search URI");
|
|
let providerName = isPrivate ? privateEngine.name : engine.name;
|
|
Assert.equal(
|
|
URIInfo.keywordProviderName,
|
|
providerName,
|
|
"should get correct provider name"
|
|
);
|
|
// Also check keywordToURI() uses the right engine.
|
|
let kwInfo = Services.uriFixup.keywordToURI(
|
|
urlparamInput,
|
|
isPrivate
|
|
);
|
|
Assert.equal(kwInfo.providerName, URIInfo.providerName);
|
|
if (providerName == kPostSearchEngineID) {
|
|
Assert.ok(kwInfo.postData);
|
|
let submission = engine.getSubmission(urlparamInput);
|
|
let enginePostData = NetUtil.readInputStreamToString(
|
|
submission.postData,
|
|
submission.postData.available()
|
|
);
|
|
let postData = NetUtil.readInputStreamToString(
|
|
kwInfo.postData,
|
|
kwInfo.postData.available()
|
|
);
|
|
Assert.equal(postData, enginePostData);
|
|
}
|
|
} else {
|
|
Assert.equal(
|
|
URIInfo.preferredURI,
|
|
null,
|
|
"not expecting a preferred URI"
|
|
);
|
|
}
|
|
} else {
|
|
Assert.equal(
|
|
URIInfo.preferredURI.spec,
|
|
URIInfo.fixedURI.spec,
|
|
"fixed URI should match"
|
|
);
|
|
}
|
|
} else {
|
|
// In these cases, we should never be doing a keyword lookup and
|
|
// the fixed URI should be preferred:
|
|
let prefURI = URIInfo.preferredURI && URIInfo.preferredURI.spec;
|
|
let fixedURI = URIInfo.fixedURI && URIInfo.fixedURI.spec;
|
|
Assert.equal(prefURI, fixedURI, "fixed URI should be same as expected");
|
|
}
|
|
Assert.equal(
|
|
sanitize(testInput),
|
|
URIInfo.originalInput,
|
|
"should mirror original input"
|
|
);
|
|
}
|
|
}
|
|
}
|