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_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_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_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_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_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_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_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 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 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_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 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_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_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'