def test_get_equivalent_patterns(empty_values):
"""With multiple matching pattern, the last added should win."""
pat1 = urlmatch.UrlPattern('https://www.example.com/')
pat2 = urlmatch.UrlPattern('*://www.example.com/')
empty_values.add('pat1 value', pat1)
empty_values.add('pat2 value', pat2)
assert empty_values.get_for_pattern(pat1) == 'pat1 value'
assert empty_values.get_for_pattern(pat2) == 'pat2 value'
def test_ignore_missing_slashes():
pattern1 = urlmatch.UrlPattern("http://www.example.com/example")
pattern2 = urlmatch.UrlPattern("http://www.example.com/example/*")
url1 = QUrl('http://www.example.com/example')
url2 = QUrl('http://www.example.com/example/')
# Same patterns should match same URLs.
assert pattern1.matches(url1)
assert pattern2.matches(url1)
# The not terminated path should match the terminated pattern.
assert pattern2.matches(url1)
# The terminated path however should not match the unterminated pattern.
assert not pattern1.matches(url2)
def test_attrs(self, pattern, host, match_subdomains):
up = urlmatch.UrlPattern(pattern)
assert up._scheme == 'http'
assert up._host == host
assert up._match_subdomains == match_subdomains
assert not up._match_all
assert up._path is None
def accept(self, value=None, save=False):
self._check_save_support(save)
if value is None:
if self.question.default is None:
raise Error("No default value was set for this question!")
self.question.answer = self.question.default
elif value == 'yes':
self.question.answer = True
elif value == 'no':
self.question.answer = False
else:
raise Error("Invalid value {} - expected yes/no!".format(value))
if save:
opt = config.instance.get_opt(self.question.option)
assert isinstance(opt.typ, configtypes.Bool)
pattern = urlmatch.UrlPattern(self.question.url)
try:
config.instance.set_obj(opt.name,
self.question.answer,
pattern=pattern,
save_yaml=True)
except configexc.Error as e:
raise Error(str(e))
return True
def pattern(self, pattern: str) -> typing.Iterator[config.ConfigContainer]:
"""Get a ConfigContainer for the given pattern."""
# We need to propagate the exception so we don't need to return
# something.
urlpattern = urlmatch.UrlPattern(pattern)
container = config.ConfigContainer(config=self._config,
configapi=self,
pattern=urlpattern)
yield container
def test_set_with_pattern(self, monkeypatch, commands, config_stub):
monkeypatch.setattr(objects, 'backend', usertypes.Backend.QtWebKit)
option = 'content.javascript.enabled'
commands.set(0, option, 'false', pattern='*://example.com')
pattern = urlmatch.UrlPattern('*://example.com')
assert config_stub.get(option)
assert not config_stub.get_obj_for_pattern(option, pattern=pattern)
def test_lightweight_patterns(pattern, scheme, host, path):
"""Make sure we can leave off parts of a URL.
This is a deviation from Chromium to make patterns more user-friendly.
"""
up = urlmatch.UrlPattern(pattern)
assert up._scheme == scheme
assert up._host == host
assert up._path == path
def test_set_with_pattern(self, confpy, template):
option = 'content.javascript.enabled'
pattern = 'https://www.example.com/'
confpy.write(template.format(opt=option, pattern=pattern))
confpy.read()
assert config.instance.get_obj(option)
assert not config.instance.get_obj_for_pattern(
option, pattern=urlmatch.UrlPattern(pattern))
def matches(self, script):
"""Check whether the URL matches filtering rules of the script."""
assert self.is_greaseable
matching_includes = any(
self._match_pattern(pat) for pat in script.includes)
matching_match = any(
urlmatch.UrlPattern(pat).matches(self._url)
for pat in script.matches)
matching_excludes = any(
self._match_pattern(pat) for pat in script.excludes)
return (matching_includes or matching_match) and not matching_excludes
def _parse_pattern(
self, pattern: typing.Optional[str]
) -> typing.Optional[urlmatch.UrlPattern]:
"""Parse a pattern string argument to a pattern."""
if pattern is None:
return None
try:
return urlmatch.UrlPattern(pattern)
except urlmatch.ParseError as e:
raise cmdutils.CommandError("Error while parsing {}: {}".format(
pattern, str(e)))
def test_get_with_pattern(self, confpy):
"""Test whether we get a matching value with a pattern."""
option = 'content.javascript.enabled'
pattern = 'https://www.example.com/'
config.instance.set_obj(option,
False,
pattern=urlmatch.UrlPattern(pattern))
confpy.write(
'assert config.get({!r})'.format(option),
'assert not config.get({!r}, pattern={!r})'.format(
option, pattern))
confpy.read()
def init(args: argparse.Namespace) -> None:
"""Initialize all QWeb(Engine)Settings."""
if objects.backend == usertypes.Backend.QtWebEngine:
from glimpsebrowser.browser.webengine import webenginesettings
webenginesettings.init(args)
else:
from glimpsebrowser.browser.webkit import webkitsettings
webkitsettings.init(args)
# Make sure special URLs always get JS support
for pattern in ['file://*', 'chrome://*/*', 'glimpse://*/*']:
config.instance.set_obj('content.javascript.enabled', True,
pattern=urlmatch.UrlPattern(pattern))
def test_pattern(self):
opt = configdata.Option(name='opt',
typ=configtypes.BoolAsk(),
default='ask',
backends=[usertypes.Backend.QtWebEngine],
raw_backends=None,
description='Hello World')
options = [
(urlmatch.UrlPattern('https://www.example.com/'), opt, 'ask'),
]
writer = configfiles.ConfigPyWriter(options=options,
bindings={},
commented=False)
text = '\n'.join(writer._gen_lines())
expected = "config.set('opt', 'ask', 'https://www.example.com/')"
assert expected in text
def test_trailing_dot_domain(pattern, url):
"""Both patterns should match trailing dot and non trailing dot domains.
More information about this not obvious behavior can be found in [1].
RFC 1738 [2] specifies clearly that the <host> part of a URL is supposed to
contain a fully qualified domain name:
3.1. Common Internet Scheme Syntax
//<user>:<password>@<host>:<port>/<url-path>
host
The fully qualified domain name of a network host
[1] http://www.dns-sd.org./TrailingDotsInDomainNames.html
[2] http://www.ietf.org/rfc/rfc1738.txt
"""
assert urlmatch.UrlPattern(pattern).matches(QUrl(url))
def test_set_print(self, config_stub, commands, message_mock, pattern):
"""Run ':set -p [-u *://example.com] content.javascript.enabled false'.
Should set show the value.
"""
assert config_stub.val.content.javascript.enabled
commands.set(0,
'content.javascript.enabled',
'false',
print_=True,
pattern=pattern)
value = config_stub.get_obj_for_pattern(
'content.javascript.enabled',
pattern=None if pattern is None else urlmatch.UrlPattern(pattern))
assert not value
expected = 'content.javascript.enabled = false'
if pattern is not None:
expected += ' for {}'.format(pattern)
msg = message_mock.getmsg(usertypes.MessageLevel.info)
assert msg.text == expected
def _build_values(self, settings: typing.Mapping) -> None:
"""Build up self._values from the values in the given dict."""
errors = []
for name, yaml_values in settings.items():
if not isinstance(yaml_values, dict):
errors.append(
configexc.ConfigErrorDesc(
"While parsing {!r}".format(name),
"value is not a dict"))
continue
values = configutils.Values(configdata.DATA[name])
if 'global' in yaml_values:
values.add(yaml_values.pop('global'))
for pattern, value in yaml_values.items():
if not isinstance(pattern, str):
errors.append(
configexc.ConfigErrorDesc(
"While parsing {!r}".format(name),
"pattern is not of type string"))
continue
try:
urlpattern = urlmatch.UrlPattern(pattern)
except urlmatch.ParseError as e:
errors.append(
configexc.ConfigErrorDesc(
"While parsing pattern {!r} for {!r}".format(
pattern, name), e))
continue
values.add(value, urlpattern)
self._values[name] = values
if errors:
raise configexc.ConfigFileErrors('autoconfig.yml', errors)
def set(self, name: str, value: typing.Any, pattern: str = None) -> None:
"""Set a setting value in the config, optionally with a pattern."""
with self._handle_error('setting', name):
urlpattern = urlmatch.UrlPattern(pattern) if pattern else None
self._config.set_obj(name, value, pattern=urlpattern)
def get(self, name: str, pattern: str = None) -> typing.Any:
"""Get a setting value from the config, optionally with a pattern."""
with self._handle_error('getting', name):
urlpattern = urlmatch.UrlPattern(pattern) if pattern else None
return self._config.get_mutable_obj(name, pattern=urlpattern)
def test_equal(text1, text2, equal):
pat1 = urlmatch.UrlPattern(text1)
pat2 = urlmatch.UrlPattern(text2)
assert (pat1 == pat2) == equal
assert (hash(pat1) == hash(pat2)) == equal
def test_equal_string():
assert urlmatch.UrlPattern("<all_urls>") != '<all_urls>'
def pattern():
return urlmatch.UrlPattern('*://www.example.com/')
def test_repr():
pat = urlmatch.UrlPattern('https://www.example.com/')
expected = ("glimpsebrowser.utils.urlmatch.UrlPattern("
"pattern='https://www.example.com/')")
assert repr(pat) == expected
def test_pattern_no_configapi(self, config_stub):
pattern = urlmatch.UrlPattern('https://example.com/')
with pytest.raises(TypeError,
match="Can't use pattern without configapi!"):
config.ConfigContainer(config_stub, pattern=pattern)
def test_set_no_pattern(self, conf, method, qtbot):
meth = getattr(conf, method)
pattern = urlmatch.UrlPattern('https://www.example.com/')
with pytest.raises(configexc.NoPatternError):
with qtbot.assert_not_emitted(conf.changed):
meth('colors.statusbar.normal.bg', '#abcdef', pattern=pattern)
def test_get_obj_for_pattern_no_match(self, conf):
pattern = urlmatch.UrlPattern('*://example.com')
name = 'content.javascript.enabled'
value = conf.get_obj_for_pattern(name, pattern=pattern)
assert value is configutils.UNSET
def test_str():
text = 'https://www.example.com/'
pat = urlmatch.UrlPattern(text)
assert str(pat) == text
def test_get_for_url(self, conf):
"""Test conf.get() with a URL/pattern."""
pattern = urlmatch.UrlPattern('*://example.com/')
name = 'content.javascript.enabled'
conf.set_obj(name, False, pattern=pattern)
assert conf.get(name, url=QUrl('https://example.com/')) is False
def other_pattern():
return urlmatch.UrlPattern('https://www.example.org/')
def test_get_obj_for_pattern(self, conf):
pattern = urlmatch.UrlPattern('*://example.com')
name = 'content.javascript.enabled'
conf.set_obj(name, False, pattern=pattern)
assert conf.get_obj_for_pattern(name, pattern=pattern) is False
def test_get_multiple_matches(values):
"""With multiple matching pattern, the last added should win."""
all_pattern = urlmatch.UrlPattern('*://*/')
values.add('new value', all_pattern)
url = QUrl('https://www.example.com/')
assert values.get_for_url(url) == 'new value'
