def test_import_file_increments_invalid_counter(tmpdir):
"""
Test that correct counters values are returned
when a text file of host entries is imported
Existing host file has: 1 ipv4 entry
Import file has: 2 ipv4 entries plus 1 invalid entry
Add should return 2
Dedupe will find a single duplicate
Add will return 1 as invalid
Write will write 1 new entry plus the existing entry (1 + 1 = 2)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
import_file = tmpdir.mkdir("input").join("infile")
import_file.write(
"example\n\n10.10.10.10\thello.com\n82.132.132.132\texample.com\texample\n"
)
hosts_entries = Hosts(path=hosts_file.strpath)
import_file_result = hosts_entries.import_file(import_file.strpath)
assert not import_file_result.get('result') == 'failed'
import_file_write_result = import_file_result.get('write_result')
assert import_file_result.get('invalid_count') == 1
assert import_file_write_result.get('ipv4_entries_written') == 2
assert import_file_write_result.get('total_written') == 2
def test_file_import_fails_when_not_readable(tmpdir):
"""
Test import fails if file to import is not readable
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample")
hosts_entries = Hosts(path=hosts_file.strpath)
result = hosts_entries.import_file('/invalid_file')
assert result.get('result') == 'failed'
def test_file_import_fails_when_not_readable(tmpdir):
"""
Test import fails if file to import is not readable
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample")
hosts_entries = Hosts(path=hosts_file.strpath)
result = hosts_entries.import_file('/invalid_file')
assert result.get('result') == 'failed'
def test_add_single_ipv4_host(tmpdir):
"""
Test the addition of an ipv4 host succeeds
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("127.0.0.1\tlocalhost\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='123.123.123.123', names=['test.example.com'])
hosts.add(entries=[new_entry])
assert hosts.exists(address='123.123.123.123')
def test_add_single_ipv6_host(tmpdir):
"""
Test addition of an ipv6 entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("127.0.0.1\tlocalhost\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv6', address='::1', names=['localhost6.localdomain6', 'localhost6'])
hosts_entries.add(entries=[new_entry], force=False)
assert hosts_entries.exists(address='::1')
def test_addition_of_ipv4_entry_where_matching_exists(tmpdir):
"""
Test replacement of an ipv4 entry where just the address differs
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts_entries.add(entries=[new_entry], force=False)
assert hosts_entries.exists(address='82.132.132.132')
def test_import_from_url_without_force(tmpdir):
"""
Test that a bare import from URL does not replace names in existing entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\texample1.com example2.com example3.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts_win3"
hosts.import_url(url=import_url)
assert hosts.exists(names=['example3.com'])
def test_import_from_url_with_force(tmpdir):
"""
Test that a bare import from URL does replace names in existing entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\texample1.com example2.com example3.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://dl.dropboxusercontent.com/u/167103/hosts_win3"
hosts.import_url(url=import_url, force=True)
assert not hosts.exists(names=['example3.com'])
def test_add_single_ipv4_host(tmpdir):
"""
Test the addition of an ipv4 host succeeds
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("127.0.0.1\tlocalhost\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='123.123.123.123', names=['test.example.com'])
hosts.add(entries=[new_entry])
assert hosts.exists(address='123.123.123.123')
def test_import_from_url_with_force(tmpdir):
"""
Test that a bare import from URL does replace names in existing entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\texample1.com example2.com example3.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts_win3"
hosts.import_url(url=import_url, force=True)
assert not hosts.exists(names=['example3.com'])
def test_add_single_ipv6_host(tmpdir):
"""
Test addition of an ipv6 entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("127.0.0.1\tlocalhost\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv6', address='::1', names=['localhost6.localdomain6', 'localhost6'])
hosts_entries.add(entries=[new_entry], force=False)
assert hosts_entries.exists(address='::1')
def test_addition_of_ipv4_entry_where_matching_exists(tmpdir):
"""
Test replacement of an ipv4 entry where just the address differs
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts_entries.add(entries=[new_entry], force=False)
assert hosts_entries.exists(address='82.132.132.132')
def test_remove_all_matching_multiple(tmpdir):
"""
Test removal of multiple entries with a common alias
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\tfoo-1 foo\n"
"2.3.4.5\tfoo-2 foo\n")
hosts = Hosts(path=hosts_file.strpath)
hosts.remove_all_matching(name="foo")
hosts.write()
assert not hosts_file.read()
def test_remove_all_matching_failure(tmpdir):
"""
Test removal of multiple entries with a common alias
"""
with pytest.raises(ValueError):
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\tfoo-1 foo\n"
"2.3.4.5\tfoo-2 foo\n")
hosts = Hosts(path=hosts_file.strpath)
hosts.remove_all_matching()
hosts.write()
def test_replace_ipv4_host_where_name_differs(tmpdir):
"""
Test replacement of an ipv4 entry where just the name differs
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['example2.com', 'example'])
hosts_entries.add(entries=[new_entry], force=True)
assert hosts_entries.exists(address='82.132.132.132')
assert hosts_entries.exists(names=['example2.com', 'example'])
def test_add_adblock_entry_without_force_multiple_names(tmpdir):
"""
Test that addition of an adblock entry does not succeed if force is not set
and there is a matching name
"""
ipv4_line = '0.0.0.0 example2.com example3.com'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry.str_to_hostentry('0.0.0.0 example.com example3.com')
hosts_entries.add(entries=[new_entry], force=False)
assert hosts_entries.exists(names=['example2.com'])
def test_add_adblock_entry_without_force_with_target_having_multiple_names(tmpdir):
"""
Test that addition of an adblock entry does not succeed if force is not set
and there is a matching name (matching names)
"""
ipv4_line = '0.0.0.0 example.com'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='0.0.0.0')
new_entry = HostsEntry.str_to_hostentry('0.0.0.0 example.com')
hosts_entries.add(entries=[new_entry])
def test_add_adblock_entry_with_force_single_name(tmpdir):
"""
Test that an addition of an adblock entry replaces one with a matching name
if force is True
"""
ipv4_line = '0.0.0.0 example2.com example3.com'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry.str_to_hostentry('0.0.0.0 example.com example3.com')
hosts_entries.add(entries=[new_entry], force=True)
assert hosts_entries.exists(names=['example.com'])
def test_add_adblock_entry_with_force_single_name(tmpdir):
"""
Test that an addition of an adblock entry replaces one with a matching name
if force is True
"""
ipv4_line = '0.0.0.0 example2.com example3.com'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry.str_to_hostentry('0.0.0.0 example.com example3.com')
hosts_entries.add(entries=[new_entry], force=True)
assert hosts_entries.exists(names=['example.com'])
def test_exception_raised_when_unable_to_write_hosts(tmpdir):
""" Test that the correct exception is raised when a hosts file
is not writeable.
"""
if get_username() != 'root':
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("127.0.0.1\tlocalhost\n")
hosts = Hosts(path=hosts_file.strpath)
os.chmod(hosts_file.strpath, 0o444)
new_entry = HostsEntry(entry_type='ipv4', address='123.123.123.123', names=['test.example.com'])
hosts.add(entries=[new_entry])
with pytest.raises(exception.UnableToWriteHosts):
hosts.write()
def test_existing_comments_and_blanks_are_preserved(tmpdir):
"""
Test that comments and newlines/blanks that exist in the file prior to
changes are preserved after a new entry is added
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n# A test comment\n\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts.add(entries=[new_entry], force=False)
write_result = hosts.write()
assert write_result.get('comments_written') == 1
assert write_result.get('blanks_written') == 1
def test_existing_comments_and_blanks_are_preserved(tmpdir):
"""
Test that comments and newlines/blanks that exist in the file prior to
changes are preserved after a new entry is added
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n# A test comment\n\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts.add(entries=[new_entry], force=False)
write_result = hosts.write()
assert write_result.get('comments_written') == 1
assert write_result.get('blanks_written') == 1
def test_existing_ipv6_addresses_are_preserved(tmpdir):
"""
Test that existing ipv6 addresses are preserved after adding
an ipv4 entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("fe80::1\tlocalhost\n6.6.6.6\texample.com\n# A test comment\n\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts.add(entries=[new_entry], force=False)
write_result = hosts.write()
assert write_result.get('ipv6_entries_written') == 1
assert write_result.get('ipv4_entries_written') == 2
assert write_result.get('comments_written') == 1
assert write_result.get('blanks_written') == 1
def test_merge_names(tmpdir):
"""
Test replacement of an ipv4 entry where just the address differs
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['another.example'])
hosts_entries.add(entries=[new_entry], merge_names=True)
assert hosts_entries.count() == 1
print(hosts_entries)
assert len(hosts_entries.entries[0].names) == 3
assert 'example.com' in hosts_entries.entries[0].names
assert 'example' in hosts_entries.entries[0].names
assert 'another.example' in hosts_entries.entries[0].names
def test_existing_ipv6_addresses_are_preserved(tmpdir):
"""
Test that existing ipv6 addresses are preserved after adding
an ipv4 entry
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("fe80::1\tlocalhost\n6.6.6.6\texample.com\n# A test comment\n\n")
hosts = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.132', names=['something.com', 'example'])
hosts.add(entries=[new_entry], force=False)
write_result = hosts.write()
assert write_result.get('ipv6_entries_written') == 1
assert write_result.get('ipv4_entries_written') == 2
assert write_result.get('comments_written') == 1
assert write_result.get('blanks_written') == 1
def test_hosts_str(tmpdir):
""" Test that the str method returns an accurate, user readable output
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
assert (str(hosts)) == "hosts_path={0}, TYPE=ipv4, ADDR=6.6.6.6, NAMES=example.com".format(hosts_file.strpath)
def test_import_file_returns_duplicate_correctly(tmpdir):
"""
Test that adding an entry that exists will return a duplicate count of 1
and a write count of 2 (where existing 82.132.132.132 is written along with
new 10.10.10.10 entry)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
import_file = tmpdir.mkdir("input").join("infile")
import_file.write("10.10.10.10\thello.com\n82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
feedback = hosts_entries.import_file(import_file_path=import_file.strpath)
add_result = feedback.get('add_result')
write_result = feedback.get('write_result')
assert add_result.get('duplicate_count') == 1
assert write_result.get('ipv4_entries_written') == 2
def test_windows_platform_detection():
"""
Test that specifying platform 'windows' returns the default windows
path to the hosts file
"""
assert Hosts.determine_hosts_path(
platform='windows') == r'c:\windows\system32\drivers\etc\hosts'
def test_replacement_of_ipv4_entry_where_address_differs(tmpdir):
"""
Test replacement of an ipv4 entry where just the address differs
Add:
82.132.132.132 example.com example
Then add (with force):
82.132.132.133 example.com example
The second addition should replace the former as there is an address match
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv4', address='82.132.132.133', names=['example.com', 'example'])
hosts_entries.add(entries=[new_entry], force=True)
assert hosts_entries.exists(address='82.132.132.133')
assert hosts_entries.exists(names=['example.com', 'example'])
def test_import_file_returns_duplicate_correctly(tmpdir):
"""
Test that adding an entry that exists will return a duplicate count of 1
and a write count of 2 (where existing 82.132.132.132 is written along with
new 10.10.10.10 entry)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
import_file = tmpdir.mkdir("input").join("infile")
import_file.write("10.10.10.10\thello.com\n82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
feedback = hosts_entries.import_file(import_file_path=import_file.strpath)
add_result = feedback.get('add_result')
write_result = feedback.get('write_result')
assert add_result.get('duplicate_count') == 1
assert write_result.get('ipv4_entries_written') == 2
def test_import_from_url_counters_for_part_success(tmpdir):
"""
Test that correct counters are returned when there is at least a
single successful imported host entry
There will be a single entry written before import.
Importing file will include three valid IPV4 entries and an invalid entry.
One of the three valid import lines will include a duplicate set of names.
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts"
result = hosts.import_url(url=import_url)
add_result = result.get('add_result')
write_result = result.get('write_result')
assert add_result.get('ipv4_count') == 4
assert write_result.get('total_written') == 5
def test_line_break_identified_as_blank(tmpdir):
"""
Test that a new line is identified as a blank
"""
new_line = "\n"
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(new_line)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.entries[0].entry_type == 'blank'
def test_import_from_url_counters_for_part_success(tmpdir):
"""
Test that correct counters are returned when there is at least a
single successful imported host entry
There will be a single entry written before import.
Importing file will include three valid IPV4 entries and an invalid entry.
One of the three valid import lines will include a duplicate set of names.
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts"
result = hosts.import_url(url=import_url)
add_result = result.get('add_result')
write_result = result.get('write_result')
assert add_result.get('ipv4_count') == 4
assert write_result.get('total_written') == 5
def write_hosts(ip_address, domain_name, alias_name):
if platform.system() == 'Windows':
hosts_path="C:\\Windows\\System32\\drivers\\etc\\hosts"
else:
hosts_path="/etc/hosts"
hosts = Hosts(path=hosts_path)
hosts.remove_all_matching(name=domain_name)
new_entry = HostsEntry(entry_type='ipv4', address=ip_address, names=[domain_name, alias_name])
hosts.add([new_entry])
hosts.write()
def test_hosts_write_to_custom_path(tmpdir):
""" Test that the hosts file can be written to a different path to the one it was read from
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
alternate_hosts_file = tmpdir.mkdir("tmp").join("hosts2")
hosts.write(path=alternate_hosts_file.strpath)
alternate_hosts = Hosts(path=alternate_hosts_file.strpath)
assert alternate_hosts.count() == 1
assert hosts.exists(address='6.6.6.6', names=['example.com'])
def test_write_will_create_path_if_missing():
"""
Test that the hosts file declared when constructing a Hosts instance will
be created if it doesn't exist
"""
now = datetime.datetime.now()
timestamp = now.strftime('%Y%m%d%H%M%S')
hosts_path = '/tmp/testwrite.{0}'.format(timestamp)
hosts = Hosts(path=hosts_path)
entry = HostsEntry.str_to_hostentry('1.2.3.4 example.com example.org')
hosts.add(entries=[entry])
hosts.write()
hosts2 = Hosts(path=hosts_path)
os.remove(hosts_path)
assert hosts2.exists(address='1.2.3.4')
def test_remove_existing_entry_using_name_only(tmpdir):
"""
Test removal of an existing entry using name only
"""
entries = '1.2.3.4 example.com example\n# this is a comment\n\n3.4.5.6 random.com' # two newlines intentionally follow, see issue #11
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(entries)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(name='example.com')
assert not hosts_entries.exists(names=['example.com'])
hosts_entries.write()
assert '# this is a comment\n' in open(hosts_file.strpath).read()
assert '3.4.5.6\trandom.com' in open(hosts_file.strpath).read()
def test_remove_existing_ipv4_address_using_hostsentry(tmpdir):
"""
Test removal of an existing ip4 address
"""
ipv4_line = '1.2.3.4 example.com example'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(address='1.2.3.4', name='example.com')
assert not hosts_entries.exists(address='1.2.3.4')
assert not hosts_entries.exists(names=['example.com'])
def test_hosts_repr(tmpdir):
""" Test that the repr method returns a useful representation of the hosts object
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
assert (repr(hosts)) == "Hosts(hosts_path='{0}', " \
"entries=[HostsEntry(entry_type='ipv4', " \
"address='6.6.6.6', " \
"comment=None, " \
"names=['example.com'])])".format(hosts_file.strpath)
def test_import_from_url(tmpdir):
"""
Test that correct counters values are returned
when a text file of host entries is imported via url
Existing host file has: 1 entry
URL has: 24 entries with 1 duplicate
Add should return 23 ipv4 (to add) and 1 duplicate
Write will write new 23 plus existing 1 (23 + 1 = 24)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts_win"
import_url_result = hosts.import_url(url=import_url)
import_url_add_result = import_url_result.get('add_result')
import_url_write_result = import_url_result.get('write_result')
assert not import_url_result == 'failed'
assert import_url_add_result.get('ipv4_count') == 24
assert import_url_write_result.get('ipv4_entries_written') == 25
assert import_url_write_result.get('total_written') == 25
def test_import_from_url(tmpdir):
"""
Test that correct counters values are returned
when a text file of host entries is imported via url
Existing host file has: 1 entry
URL has: 24 entries with 1 duplicate
Add should return 23 ipv4 (to add) and 1 duplicate
Write will write new 23 plus existing 1 (23 + 1 = 24)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
import_url = "https://raw.githubusercontent.com/jonhadfield/python-hosts/devel/test_files/hosts_win"
import_url_result = hosts.import_url(url=import_url)
import_url_add_result = import_url_result.get('add_result')
import_url_write_result = import_url_result.get('write_result')
assert not import_url_result == 'failed'
assert import_url_add_result.get('ipv4_count') == 24
assert import_url_write_result.get('ipv4_entries_written') == 25
assert import_url_write_result.get('total_written') == 25
def cli(ctx):
"""
A simple tool for blocking access to distracting websites, such as social media websites,
news webistes, streaming services etc. This tools relies on modifying the hosts file.
It is not meant to be bullet-proof, but to provide easy way to break annoying habits
and increase productivity.
Example usage for blocking all available webistes:
block-hosts block-all
"""
ctx.obj = Hosts(find_hosts_path())
def test_remove_existing_entry_using_name_only(tmpdir):
"""
Test removal of an existing entry using name only
"""
entries = '1.2.3.4 example.com example\n# this is a comment\n\n3.4.5.6 random.com' # two newlines intentionally follow, see issue #11
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(entries)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(name='example.com')
assert not hosts_entries.exists(names=['example.com'])
hosts_entries.write()
assert '# this is a comment\n' in open(hosts_file.strpath).read()
assert '3.4.5.6\trandom.com' in open(hosts_file.strpath).read()
def test_remove_existing_entry_using_address_only(tmpdir):
"""
Test removal of an existing entry using ip4 address only
"""
entries = '1.2.3.4 example.com example\n# this is a comment'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(entries)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(address='1.2.3.4')
assert not hosts_entries.exists(address='1.2.3.4')
def test_import_file_increments_invalid_counter(tmpdir):
"""
Test that correct counters values are returned
when a text file of host entries is imported
Existing host file has: 1 ipv4 entry
Import file has: 2 ipv4 entries plus 1 invalid entry
Add should return 2
Dedupe will find a single duplicate
Add will return 1 as invalid
Write will write 1 new entry plus the existing entry (1 + 1 = 2)
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("82.132.132.132\texample.com\texample\n")
import_file = tmpdir.mkdir("input").join("infile")
import_file.write("example\n\n10.10.10.10\thello.com\n82.132.132.132\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
import_file_result = hosts_entries.import_file(import_file.strpath)
assert not import_file_result.get('result') == 'failed'
import_file_write_result = import_file_result.get('write_result')
assert import_file_result.get('invalid_count') == 1
assert import_file_write_result.get('ipv4_entries_written') == 2
assert import_file_write_result.get('total_written') == 2
def test_remove_existing_ipv4_address_using_hostsentry(tmpdir):
"""
Test removal of an existing ip4 address
"""
ipv4_line = '1.2.3.4 example.com example'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(ipv4_line)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(address='1.2.3.4', name='example.com')
assert not hosts_entries.exists(address='1.2.3.4')
assert not hosts_entries.exists(names=['example.com'])
def test_remove_all_matching_failure(tmpdir):
"""
Test removal of multiple entries with a common alias
"""
with pytest.raises(ValueError):
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\tfoo-1 foo\n" "2.3.4.5\tfoo-2 foo\n")
hosts = Hosts(path=hosts_file.strpath)
hosts.remove_all_matching()
hosts.write()
def set_hosts(domains):
try:
hosts = Hosts()
hosts.add([
HostsEntry(entry_type='ipv4', address='127.0.0.1', names=domains)
])
hosts.write()
except UnableToWriteHosts:
raise ClickException(
'Unable to write to hosts file. Please call command with "sudo".')
def test_remove_all_matching_multiple(tmpdir):
"""
Test removal of multiple entries with a common alias
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("1.2.3.4\tfoo-1 foo\n" "2.3.4.5\tfoo-2 foo\n")
hosts = Hosts(path=hosts_file.strpath)
hosts.remove_all_matching(name="foo")
hosts.write()
assert not hosts_file.read()
def test_gke():
project_id = "wn-cloud-275704"
zone = "us-central1-c"
cluster_id = "wn-cloud-portal-qa"
# Use a service account configured in GCP console,
# authenticating with a JSON key
credentials = service_account.Credentials \
.from_service_account_file('wn-cloud-275704-24c84de6f442.json')
print('Authentication done------------------------------>')
# Get cluster details
cluster_manager_client = ClusterManagerClient(credentials=credentials)
cluster = cluster_manager_client.get_cluster(project_id=project_id,
zone=zone,
cluster_id=cluster_id)
print('cluster info received------------------------------>')
# Save cluster certificate for SSL verification
cert = base64.b64decode(cluster.master_auth.cluster_ca_certificate)
cert_filename = 'cluster_ca_cert'
cert_file = open(cert_filename, 'w')
cert_file.write(cert)
cert_file.close()
# Configure hostname for SSL verification
hosts = Hosts()
hosts.add([
HostsEntry(entry_type='ipv4',
address=cluster.endpoint,
names=['kubernetes'])
])
hosts.write()
# Get a token with the scopes required by GKE
kubeconfig_creds = credentials.with_scopes([
'https://www.googleapis.com/auth/cloud-platform',
'https://www.googleapis.com/auth/userinfo.email'
])
auth_req = google.auth.transport.requests.Request()
kubeconfig_creds.refresh(auth_req)
configuration = client.Configuration()
configuration.host = "https://kubernetes"
configuration.ssl_ca_cert = cert_filename
kubeconfig_creds.apply(configuration.api_key)
client.Configuration.set_default(configuration)
v1 = client.CoreV1Api()
print("Listing pods with their IPs:")
pods = v1.list_pod_for_all_namespaces(watch=False)
for i in pods.items:
print("%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name))
def test_hosts_write_to_custom_path(tmpdir):
""" Test that the hosts file can be written to a different path to the one it was read from
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("6.6.6.6\texample.com\n")
hosts = Hosts(path=hosts_file.strpath)
alternate_hosts_file = tmpdir.mkdir("tmp").join("hosts2")
hosts.write(path=alternate_hosts_file.strpath)
alternate_hosts = Hosts(path=alternate_hosts_file.strpath)
assert alternate_hosts.count() == 1
assert hosts.exists(address='6.6.6.6', names=['example.com'])
def test_write_will_create_path_if_missing():
"""
Test that the hosts file declared when constructing a Hosts instance will
be created if it doesn't exist
"""
now = datetime.datetime.now()
timestamp = now.strftime('%Y%m%d%H%M%S')
hosts_path = '/tmp/testwrite.{0}'.format(timestamp)
hosts = Hosts(path=hosts_path)
entry = HostsEntry.str_to_hostentry('1.2.3.4 example.com example.org')
hosts.add(entries=[entry])
hosts.write()
hosts2 = Hosts(path=hosts_path)
os.remove(hosts_path)
assert hosts2.exists(address='1.2.3.4')
def test_remove_existing_entry_using_address_only(tmpdir):
"""
Test removal of an existing entry using ip4 address only
"""
entries = '1.2.3.4 example.com example\n# this is a comment'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(entries)
hosts_entries = Hosts(path=hosts_file.strpath)
assert hosts_entries.exists(address='1.2.3.4')
assert hosts_entries.exists(names=['example.com'])
hosts_entries.remove_all_matching(address='1.2.3.4')
assert not hosts_entries.exists(address='1.2.3.4')
def test_addition_of_ipv6_entry_where_matching_name_exists_and_force_false(tmpdir):
"""
Test no replacement of an ipv6 entry where the address is different
but there is a matching name and force is false
"""
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write("fe80::200:f8ff:fe21:67cf\texample.com\texample\n")
hosts_entries = Hosts(path=hosts_file.strpath)
new_entry = HostsEntry(entry_type='ipv6', address='2001:db8:a0b:12f0::1',
names=['example.com', 'example'])
hosts_entries.add(entries=[new_entry], force=False)
assert not hosts_entries.exists(address='2001:db8:a0b:12f0::1')
assert hosts_entries.exists(address='fe80::200:f8ff:fe21:67cf')
assert hosts_entries.exists(names=new_entry.names)
def test_remove_all_matching_with_non_loopback_address_and_multiple_names(tmpdir):
"""
Test that a forced addition of an adblock entry with multiple names first removes 'all' matching names
"""
entries = '1.2.1.1 example.com example2.com\n# this is a comment\n\n3.4.5.6 random.com example2.com\n'
hosts_file = tmpdir.mkdir("etc").join("hosts")
hosts_file.write(entries)
hosts_entries = Hosts(path=hosts_file.strpath)
# assert hosts_entries.exists(address='0.0.0.0')
new_entry = HostsEntry.str_to_hostentry('8.9.10.11 example.com example2.com')
hosts_entries.add(entries=[new_entry], force=True)
assert hosts_entries.count() == 3 # 1 address, 1 comment and 1 blank
assert not hosts_entries.exists(address='3.4.5.6')
assert hosts_entries.exists(names=['example.com'])
def test_windows_platform_detection():
"""
Test that specifying platform 'windows' returns the default windows
path to the hosts file
"""
assert Hosts.determine_hosts_path(platform='windows') == r'c:\windows\system32\drivers\etc\hosts'
def test_osx_platform_detection():
"""
Test that specifying platform 'darwin' returns the default OSX
path to the hosts file
"""
assert Hosts.determine_hosts_path(platform='darwin') == '/etc/hosts'
def test_no_entries_if_hosts_path_does_not_exist():
"""
Test that no entries are returned if the hosts path is invalid
"""
hosts = Hosts(path="invalid")
assert hosts.count() == 0
def test_linux_platform_detection():
"""
Test that specifying platform 'linux' returns the default linux
path to the hosts file
"""
assert Hosts.determine_hosts_path(platform='linux') == '/etc/hosts'
