217 lines
8.4 KiB
Python
217 lines
8.4 KiB
Python
# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
|
|
#!/usr/bin/env python3
|
|
|
|
# Copyright 2014-2015 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
|
|
#
|
|
# This file is part of qutebrowser.
|
|
#
|
|
# qutebrowser is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# qutebrowser is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with qutebrowser. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""Tests for qutebrowser.browser.adblock."""
|
|
|
|
import os
|
|
import zipfile
|
|
import shutil
|
|
|
|
import pytest
|
|
|
|
from PyQt5.QtCore import pyqtSignal, QUrl, QObject
|
|
|
|
from qutebrowser.browser import adblock
|
|
from qutebrowser.utils import objreg
|
|
|
|
|
|
UNDESIRED_HOSTS = ['badsite.org', 'verybadsite.com', 'worstsiteever.net']
|
|
|
|
|
|
class FakeDownloadItem(QObject):
|
|
"""Mock browser.downloads.DownloadItem."""
|
|
|
|
finished = pyqtSignal()
|
|
|
|
def __init__(self, fileobj):
|
|
super().__init__()
|
|
self.fileobj = fileobj
|
|
self.successful = True
|
|
|
|
|
|
class FakeDownloadManager:
|
|
"""Mock browser.downloads.DownloadManager."""
|
|
|
|
def get(self, url, fileobj, **kwargs):
|
|
"""Returns a FakeDownloadItem instance with a fileobj
|
|
copied from given fake url file."""
|
|
download_item = FakeDownloadItem(fileobj)
|
|
with open(url.path(), 'rb') as fake_url_file:
|
|
# Ensure cursors are at position 0 before copying
|
|
fake_url_file.seek(0)
|
|
download_item.fileobj.seek(0)
|
|
shutil.copyfileobj(fake_url_file, download_item.fileobj)
|
|
return download_item
|
|
|
|
@pytest.yield_fixture
|
|
def download_stub(win_registry):
|
|
"""Register a FakeDownloadManager."""
|
|
stub = FakeDownloadManager()
|
|
objreg.register('download-manager', stub,
|
|
scope='window', window='last-focused')
|
|
yield stub
|
|
objreg.delete('download-manager', scope='window', window='last-focused')
|
|
|
|
@pytest.fixture
|
|
def data_tmpdir(monkeypatch, tmpdir):
|
|
"""Use tmpdir as datadir"""
|
|
monkeypatch.setattr('qutebrowser.utils.standarddir.data',
|
|
lambda: str(tmpdir))
|
|
|
|
def create_text_files(files_names, directory):
|
|
"""Returns a list of text files created
|
|
with given names in given directory."""
|
|
directory = str(directory)
|
|
created_files = []
|
|
for file_name in files_names:
|
|
test_file = os.path.join(directory, file_name)
|
|
with open(test_file, 'w', encoding='utf-8') as current_file:
|
|
current_file.write('www.' + file_name + '.com')
|
|
created_files.append(test_file)
|
|
return created_files
|
|
|
|
def create_zipfile(files_names, directory):
|
|
"""Returns a zipfile populated with created files and its name."""
|
|
directory = str(directory)
|
|
files = create_text_files(files_names, directory)
|
|
# include created files in a ZipFile
|
|
zipfile_name = os.path.join(directory, 'test.zip')
|
|
with zipfile.ZipFile(zipfile_name, 'w') as new_zipfile:
|
|
for file_name in files:
|
|
new_zipfile.write(file_name, arcname=os.path.basename(file_name))
|
|
# Removes path from file name
|
|
return new_zipfile, zipfile_name
|
|
|
|
|
|
class TestGuessZipFilename:
|
|
"""Test function adblock.guess_zip_filename()."""
|
|
|
|
def test_with_single_file(self, tmpdir):
|
|
"""Zip provided only contains a single file."""
|
|
zf = create_zipfile(['test_a'], tmpdir)[0]
|
|
assert adblock.guess_zip_filename(zf) == 'test_a'
|
|
|
|
def test_with_multiple_files(self, tmpdir):
|
|
"""Zip provided contains multiple files including hosts."""
|
|
names = ['test_a', 'test_b', 'hosts', 'test_c']
|
|
zf = create_zipfile(names, tmpdir)[0]
|
|
assert adblock.guess_zip_filename(zf) == 'hosts'
|
|
|
|
def test_without_hosts_file(self, tmpdir):
|
|
"""Zip provided does not contain any hosts file."""
|
|
names = ['test_a', 'test_b', 'test_d', 'test_c']
|
|
zf = create_zipfile(names, tmpdir)[0]
|
|
with pytest.raises(FileNotFoundError):
|
|
adblock.guess_zip_filename(zf)
|
|
|
|
|
|
class TestGetFileObj:
|
|
"""Test Function adblock.get_fileobj()."""
|
|
|
|
def test_with_zipfile(self, tmpdir):
|
|
"""File provided is a zipfile."""
|
|
names = ['test_a', 'test_b', 'hosts', 'test_c']
|
|
zf_name = create_zipfile(names, tmpdir)[1]
|
|
zipobj = open(zf_name, 'rb')
|
|
assert adblock.get_fileobj(zipobj).read() == "www.hosts.com"
|
|
|
|
def test_with_text_file(self, tmpdir):
|
|
"""File provided is not a zipfile."""
|
|
test_file = open(create_text_files(['testfile'], tmpdir)[0], 'rb')
|
|
assert adblock.get_fileobj(test_file).read() == "www.testfile.com"
|
|
|
|
|
|
class TestIsWhitelistedHost:
|
|
"""Test function adblock.is_whitelisted_host."""
|
|
|
|
def test_without_hosts(self, config_stub):
|
|
"""No hosts are whitelisted."""
|
|
config_stub.data = {'content': {'host-blocking-whitelist': None}}
|
|
assert not adblock.is_whitelisted_host('qutebrowser.org')
|
|
|
|
def test_with_match(self, config_stub):
|
|
"""Given host is in the whitelist."""
|
|
config_stub.data = {'content':
|
|
{'host-blocking-whitelist': ['qutebrowser.org']}}
|
|
assert adblock.is_whitelisted_host('qutebrowser.org')
|
|
|
|
def test_without_match(self, config_stub):
|
|
"""Given host is not in the whitelist."""
|
|
config_stub.data = {'content':
|
|
{'host-blocking-whitelist':['qutebrowser.org']}}
|
|
assert not adblock.is_whitelisted_host('cutebrowser.org')
|
|
|
|
|
|
class TestHostBlocker:
|
|
"""Tests for class HostBlocker."""
|
|
|
|
def test_without_datadir(self, config_stub, monkeypatch):
|
|
"""No directory for data configured, no hosts file present."""
|
|
monkeypatch.setattr('qutebrowser.utils.standarddir.data',
|
|
lambda: None)
|
|
host_blocker = adblock.HostBlocker()
|
|
assert host_blocker._hosts_file is None
|
|
|
|
def test_with_datadir(self, config_stub, data_tmpdir, tmpdir):
|
|
#TODO Remove since now useless as already tested by test_update
|
|
host_blocker = adblock.HostBlocker()
|
|
hosts_file_path = os.path.join(str(tmpdir), 'blocked-hosts')
|
|
assert host_blocker._hosts_file == hosts_file_path
|
|
|
|
def test_update_with_url(self, config_stub, download_stub,
|
|
data_tmpdir, tmpdir, win_registry):
|
|
"""Test update, checked Url is in the new blocklist added by update
|
|
Remote Url is faked by a local file."""
|
|
# Create blocklist and add it to config
|
|
blocklist = QUrl(os.path.join(str(tmpdir), 'new_hosts.txt'))
|
|
with open(blocklist.path(), 'w', encoding='UTF-8') as hosts:
|
|
for path in UNDESIRED_HOSTS:
|
|
hosts.write(path + '\n')
|
|
config_stub.data = {'content':
|
|
{'host-block-lists': [blocklist],
|
|
'host-blocking-enabled': True,
|
|
'host-blocking-whitelist': None}}
|
|
host_blocker = adblock.HostBlocker()
|
|
host_blocker.adblock_update(0)
|
|
#Simulate download is finished
|
|
host_blocker._in_progress[0].finished.emit()
|
|
url_to_check = QUrl("http://verybadsite.com")
|
|
assert host_blocker.is_blocked(url_to_check)
|
|
|
|
def test_update_with_local_file(self, config_stub, download_stub,
|
|
data_tmpdir, tmpdir, win_registry):
|
|
"""Test update, checked Url is in the new blocklist added by update
|
|
Url is a local file."""
|
|
# Create blocklist
|
|
local_blocklist = QUrl(os.path.join(str(tmpdir), 'new_hosts.txt'))
|
|
# Declare the blacklist as a local file
|
|
local_blocklist.setScheme("file")
|
|
with open(local_blocklist.path(), 'w', encoding='UTF-8') as hosts:
|
|
for path in UNDESIRED_HOSTS:
|
|
hosts.write(path + '\n')
|
|
config_stub.data = {'content':
|
|
{'host-block-lists': [local_blocklist],
|
|
'host-blocking-enabled': True,
|
|
'host-blocking-whitelist': None}}
|
|
host_blocker = adblock.HostBlocker()
|
|
host_blocker.adblock_update(0)
|
|
url_to_check = QUrl("http://verybadsite.com")
|
|
assert host_blocker.is_blocked(url_to_check)
|