diff --git a/tests/pyfunceble_tests_base.py b/tests/pyfunceble_tests_base.py index fe1cb318..b907d3f1 100644 --- a/tests/pyfunceble_tests_base.py +++ b/tests/pyfunceble_tests_base.py @@ -68,7 +68,7 @@ class PyFuncebleTestsBase(unittest.TestCase): """ - Use when you want to avoid using the network to fetch crutial datasets. + Use when you want to avoid using the network to fetch crucial datasets. """ IANA_DATASET = pyf_test_dataset.IANA_DATASETS diff --git a/tests/query/dnss/test_nameserver.py b/tests/query/dnss/test_nameserver.py index 46dcf3e2..31f9a33b 100644 --- a/tests/query/dnss/test_nameserver.py +++ b/tests/query/dnss/test_nameserver.py @@ -211,13 +211,17 @@ def test_split_nameserver_from_port_ipv6_convention_port_not_digit(self) -> None self.assertEqual(expected, actual) + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") @unittest.mock.patch.object(dns.resolver.Resolver, "resolve") - def test_get_ip_from_nameserver(self, resolver_patch) -> None: + def test_get_ip_from_nameserver( + self, resolver_patch, read_resolvconf_patch + ) -> None: """ Tests the method which let us get the IP from a nameserver. """ resolver_patch.side_effect = self.fake_resolver + read_resolvconf_patch.return_value = None given = "example.org" @@ -260,13 +264,15 @@ def test_get_ip_from_nameserver_not_valid_domain(self) -> None: self.assertEqual(expected, actual) + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") @unittest.mock.patch.object(dns.resolver.Resolver, "resolve") - def test_set_nameservers(self, resolver_patch) -> None: + def test_set_nameservers(self, resolver_patch, read_resolvconf_patch) -> None: """ Tests the method which let us set the nameserver to work with. """ resolver_patch.side_effect = self.fake_resolver + read_resolvconf_patch.return_value = None given = ["example.org:53"] @@ -291,14 +297,18 @@ def test_set_nameservers(self, resolver_patch) -> None: self.assertEqual(expected_nameserver, actual) self.assertEqual(expected_nameserver_port, actual_nameserver_port) + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") @unittest.mock.patch.object(dns.resolver.Resolver, "resolve") - def test_set_nameservers_through_init(self, resolver_patch) -> None: + def test_set_nameservers_through_init( + self, resolver_patch, read_resolvconf_patch + ) -> None: """ Tests the method which let us set the nameserver from the contributor method. """ resolver_patch.side_effect = self.fake_resolver + read_resolvconf_patch.return_value = None given = ["example.org:53"] @@ -427,13 +437,17 @@ def test_set_nameservers_empty_list(self) -> None: self.assertRaises(ValueError, lambda: Nameservers().set_nameservers(given)) + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") @unittest.mock.patch.object(dns.resolver.Resolver, "resolve") - def test_guess_and_set_nameservers(self, resolver_patch) -> None: + def test_guess_and_set_nameservers( + self, resolver_patch, read_resolvconf_patch + ) -> None: """ Tests the method which let us guess the nameserver to use. """ resolver_patch.side_effect = self.fake_resolver + read_resolvconf_patch.return_value = None given = ["example.org:53"] diff --git a/tests/query/dnss/test_query_tool.py b/tests/query/dnss/test_query_tool.py index e0e7c7ea..b057d7ba 100644 --- a/tests/query/dnss/test_query_tool.py +++ b/tests/query/dnss/test_query_tool.py @@ -62,12 +62,19 @@ import dns.query from PyFunceble.config.loader import ConfigLoader +from PyFunceble.query.dns.nameserver import Nameservers from PyFunceble.query.dns.query_tool import DNSQueryTool, DNSQueryToolRecord +try: + from pyfunceble_tests_base import PyFuncebleTestsBase +except ModuleNotFoundError: # pragma: no cover + from ...pyfunceble_tests_base import PyFuncebleTestsBase + + # pylint: disable=protected-access, too-many-lines -class TestDNSQueryTool(unittest.TestCase): +class TestDNSQueryTool(PyFuncebleTestsBase): """ Tests our DNS query tool. """ @@ -77,6 +84,8 @@ def setUp(self) -> None: Setups everything needed for the tests. """ + super().setUp() + def fake_response(data: str) -> object: return dataclasses.make_dataclass( "FakeResponse", [("address", str, dataclasses.field(default=data))] @@ -97,6 +106,20 @@ def fake_resolver(_: str, rqtype: str): self.resolve_patch = unittest.mock.patch.object( dns.resolver.Resolver, "resolve" ) + + self.nameservers_ports_patch = unittest.mock.patch.object( + Nameservers, "get_nameserver_ports" + ) + self.nameservers_ns_patch = unittest.mock.patch.object( + Nameservers, "get_nameservers" + ) + + self.mock_ns_ns = self.nameservers_ns_patch.start() + self.mock_ns_ns.return_value = ["192.168.1.1", "10.47.91.9"] + + self.mock_ns_ports = self.nameservers_ports_patch.start() + self.mock_ns_ports.return_value = {"192.168.1.1": 53, "10.47.91.9": 53} + self.udp_query_patch = unittest.mock.patch.object(dns.query, "udp") self.tcp_query_patch = unittest.mock.patch.object(dns.query, "tcp") self.https_query_patch = unittest.mock.patch.object(dns.query, "https") @@ -125,17 +148,25 @@ def tearDown(self) -> None: self.https_query_patch.stop() self.tls_query_patch.stop() + self.nameservers_ports_patch.stop() + self.nameservers_ns_patch.stop() + del self.resolve_patch del self.udp_query_patch del self.tcp_query_patch del self.https_query_patch del self.tls_query_patch + del self.nameservers_ports_patch del self.mock_resolve del self.mock_udp_query del self.mock_tcp_query del self.mock_https_query del self.mock_tls_query + del self.mock_ns_ports + del self.mock_ns_ns + + super().tearDown() @staticmethod def timout_response(*args, **kwargs) -> None: diff --git a/tests/query/dnss/test_resolver.py b/tests/query/dnss/test_resolver.py index ec391561..86f5ac78 100644 --- a/tests/query/dnss/test_resolver.py +++ b/tests/query/dnss/test_resolver.py @@ -59,8 +59,13 @@ from PyFunceble.config.loader import ConfigLoader from PyFunceble.query.dns.resolver import Resolver +try: + from pyfunceble_tests_base import PyFuncebleTestsBase +except ModuleNotFoundError: # pragma: no cover + from ...pyfunceble_tests_base import PyFuncebleTestsBase -class TestResolver(unittest.TestCase): + +class TestResolver(PyFuncebleTestsBase): """ Provides the tests of our resolver configurator. """ @@ -70,6 +75,8 @@ def setUp(self) -> None: Setups everything needed for the tests. """ + super().setUp() + def fake_response(data: str) -> object: return dataclasses.make_dataclass( "FakeResponse", [("address", str, dataclasses.field(default=data))] @@ -108,13 +115,17 @@ def tearDown(self) -> None: del self.resolver_provider - def test_set_nameservers(self) -> None: + super().tearDown() + + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") + def test_set_nameservers(self, read_resolvconf_patch) -> None: """ Tests the method which let us set the nameservers to work with. """ given = ["example.org"] + read_resolvconf_patch.return_value = None self.resolver_provider.set_nameservers(given) expected = [ @@ -137,7 +148,8 @@ def test_set_nameservers(self) -> None: self.assertEqual(expected, actual) - def test_set_nameservers_through_init(self) -> None: + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") + def test_set_nameservers_through_init(self, read_resolvconf_patch) -> None: """ Tests the method which let us set the nameservers to work with. @@ -147,6 +159,7 @@ def test_set_nameservers_through_init(self) -> None: given = ["example.org"] + read_resolvconf_patch.return_value = None resolver_provider = Resolver(nameservers=given) expected = [ @@ -225,11 +238,14 @@ def test_guess_and_set_timeout(self) -> None: self.assertEqual(expected, actual) - def test_get_resolver(self) -> None: + @unittest.mock.patch.object(dns.resolver.Resolver, "read_resolv_conf") + def test_get_resolver(self, read_resolv_conf) -> None: """ Tests the method which let us get the configured resolver. """ + read_resolv_conf.return_value = None + self.resolver_provider.set_nameservers(["example.org"]) self.resolver_provider.set_timeout(5.0) @@ -260,7 +276,3 @@ def test_get_resolver(self) -> None: the_second_resolver = self.resolver_provider.get_resolver() self.assertEqual(id(the_resolver), id(the_second_resolver)) - - -if __name__ == "__main__": - unittest.main()