From 411fd6011ef6ea49f6cc806ad16af3c868a8e97d Mon Sep 17 00:00:00 2001 From: Aarni Koskela Date: Tue, 27 Aug 2024 11:49:52 +0300 Subject: [PATCH 1/2] Remove no-op empty TestFDReader suite --- tests/database_test.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tests/database_test.py b/tests/database_test.py index 0974b74..de07aed 100644 --- a/tests/database_test.py +++ b/tests/database_test.py @@ -280,9 +280,5 @@ class TestMemoryReader(BaseTestReader): mode = geoip2.database.MODE_MEMORY -class TestFDReader(unittest.TestCase): - mode = geoip2.database.MODE_FD - - class TestAutoReader(BaseTestReader): mode = geoip2.database.MODE_AUTO From dbd1ce6572574dc1b2548ce420b6704eae99d9b3 Mon Sep 17 00:00:00 2001 From: Aarni Koskela Date: Tue, 27 Aug 2024 11:49:19 +0300 Subject: [PATCH 2/2] Make `database_test` actually use all of the available `mode`s --- tests/database_test.py | 357 +++++++++++++++++++++-------------------- 1 file changed, 183 insertions(+), 174 deletions(-) diff --git a/tests/database_test.py b/tests/database_test.py index de07aed..c61b417 100644 --- a/tests/database_test.py +++ b/tests/database_test.py @@ -4,281 +4,290 @@ from __future__ import unicode_literals import ipaddress +import re import sys -import unittest + +import pytest sys.path.append("..") import geoip2.database import geoip2.errors -import maxminddb try: - import maxminddb.extension -except ImportError: - maxminddb.extension = None # type: ignore - + import maxminddb.extension # noqa: F401 -class BaseTestReader(unittest.TestCase): - def test_language_list(self) -> None: + has_extension = True +except ImportError: + has_extension = False + +modes = [ + pytest.param(geoip2.database.MODE_MMAP, id="mmap"), + pytest.param(geoip2.database.MODE_FILE, id="file"), + pytest.param(geoip2.database.MODE_MEMORY, id="memory"), + pytest.param(geoip2.database.MODE_AUTO, id="auto"), + pytest.param( + geoip2.database.MODE_MMAP_EXT, + marks=[ + pytest.mark.skipif(not has_extension, reason="C extension not available") + ], + id="mmap_ext", + ), +] + + +class TestReader: + @pytest.mark.parametrize("mode", modes) + def test_language_list(self, mode: int) -> None: reader = geoip2.database.Reader( "tests/data/test-data/GeoIP2-Country-Test.mmdb", ["xx", "ru", "pt-BR", "es", "en"], + mode=mode, ) record = reader.country("81.2.69.160") - self.assertEqual(record.country.name, "Великобритания") + assert record.country.name == "Великобритания" reader.close() - def test_unknown_address(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb") - with self.assertRaisesRegex( + @pytest.mark.parametrize("mode", modes) + def test_unknown_address(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-City-Test.mmdb", mode=mode + ) + with pytest.raises( geoip2.errors.AddressNotFoundError, - "The address 10.10.10.10 is not in the " "database.", + match="The address 10.10.10.10 is not in the database.", ): reader.city("10.10.10.10") reader.close() - def test_unknown_address_network(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb") - try: + @pytest.mark.parametrize("mode", modes) + def test_unknown_address_network(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-City-Test.mmdb", mode=mode + ) + with pytest.raises(geoip2.errors.AddressNotFoundError) as ei: reader.city("10.10.10.10") - self.fail("Expected AddressNotFoundError") - except geoip2.errors.AddressNotFoundError as e: - self.assertEqual(e.network, ipaddress.ip_network("10.0.0.0/8")) - except Exception as e: - self.fail(f"Expected AddressNotFoundError, got {type(e)}: {str(e)}") - finally: - reader.close() - - def test_wrong_database(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb") - with self.assertRaisesRegex( + assert ei.value.network == ipaddress.ip_network("10.0.0.0/8") + reader.close() + + @pytest.mark.parametrize("mode", modes) + def test_wrong_database(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-City-Test.mmdb", mode=mode + ) + with pytest.raises( TypeError, - "The country method cannot be used with " "the GeoIP2-City database", + match="The country method cannot be used with the GeoIP2-City database", ): reader.country("1.1.1.1") reader.close() - def test_invalid_address(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb") - with self.assertRaisesRegex( - ValueError, "u?'invalid' does not appear to be an " "IPv4 or IPv6 address" + @pytest.mark.parametrize("mode", modes) + def test_invalid_address(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-City-Test.mmdb", mode=mode + ) + with pytest.raises( + ValueError, + match="u?'invalid' does not appear to be an " "IPv4 or IPv6 address", ): reader.city("invalid") reader.close() - def test_anonymous_ip(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_anonymous_ip(self, mode: int) -> None: reader = geoip2.database.Reader( - "tests/data/test-data/GeoIP2-Anonymous-IP-Test.mmdb" + "tests/data/test-data/GeoIP2-Anonymous-IP-Test.mmdb", + mode=mode, ) ip_address = "1.2.0.1" record = reader.anonymous_ip(ip_address) - self.assertEqual(record.is_anonymous, True) - self.assertEqual(record.is_anonymous_vpn, True) - self.assertEqual(record.is_hosting_provider, False) - self.assertEqual(record.is_public_proxy, False) - self.assertEqual(record.is_residential_proxy, False) - self.assertEqual(record.is_tor_exit_node, False) - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("1.2.0.0/16")) + assert record.is_anonymous is True + assert record.is_anonymous_vpn is True + assert record.is_hosting_provider is False + assert record.is_public_proxy is False + assert record.is_residential_proxy is False + assert record.is_tor_exit_node is False + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("1.2.0.0/16") reader.close() - def test_anonymous_ip_all_set(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_anonymous_ip_all_set(self, mode: int) -> None: reader = geoip2.database.Reader( - "tests/data/test-data/GeoIP2-Anonymous-IP-Test.mmdb" + "tests/data/test-data/GeoIP2-Anonymous-IP-Test.mmdb", + mode=mode, ) ip_address = "81.2.69.1" record = reader.anonymous_ip(ip_address) - self.assertEqual(record.is_anonymous, True) - self.assertEqual(record.is_anonymous_vpn, True) - self.assertEqual(record.is_hosting_provider, True) - self.assertEqual(record.is_public_proxy, True) - self.assertEqual(record.is_residential_proxy, True) - self.assertEqual(record.is_tor_exit_node, True) - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("81.2.69.0/24")) + assert record.is_anonymous is True + assert record.is_anonymous_vpn is True + assert record.is_hosting_provider is True + assert record.is_public_proxy is True + assert record.is_residential_proxy is True + assert record.is_tor_exit_node is True + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("81.2.69.0/24") reader.close() - def test_asn(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoLite2-ASN-Test.mmdb") + @pytest.mark.parametrize("mode", modes) + def test_asn(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoLite2-ASN-Test.mmdb", mode=mode + ) ip_address = "1.128.0.0" record = reader.asn(ip_address) - self.assertEqual(record, eval(repr(record)), "ASN repr can be eval'd") + assert record == eval(repr(record)), "ASN repr can be eval'd" - self.assertEqual(record.autonomous_system_number, 1221) - self.assertEqual(record.autonomous_system_organization, "Telstra Pty Ltd") - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("1.128.0.0/11")) + assert record.autonomous_system_number == 1221 + assert record.autonomous_system_organization == "Telstra Pty Ltd" + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("1.128.0.0/11") - self.assertRegex( - str(record), - r"geoip2.models.ASN\(.*1\.128\.0\.0.*\)", - "str representation is correct", - ) + assert re.search( + r"geoip2.models.ASN\(.*1\.128\.0\.0.*\)", str(record) + ), "str representation is correct" reader.close() - def test_city(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb") + @pytest.mark.parametrize("mode", modes) + def test_city(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-City-Test.mmdb", mode=mode + ) record = reader.city("81.2.69.160") - self.assertEqual( - record.country.name, "United Kingdom", "The default locale is en" - ) - self.assertEqual(record.country.is_in_european_union, False) - self.assertEqual( - record.location.accuracy_radius, 100, "The accuracy_radius is populated" - ) - self.assertEqual(record.registered_country.is_in_european_union, False) - self.assertFalse(record.traits.is_anycast) + assert record.country.name == "United Kingdom", "The default locale is en" + assert record.country.is_in_european_union is False + assert ( + record.location.accuracy_radius == 100 + ), "The accuracy_radius is populated" + assert record.registered_country.is_in_european_union is False + assert not record.traits.is_anycast record = reader.city("214.1.1.0") - self.assertTrue(record.traits.is_anycast) + assert record.traits.is_anycast reader.close() - def test_connection_type(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_connection_type(self, mode: int) -> None: reader = geoip2.database.Reader( - "tests/data/test-data/GeoIP2-Connection-Type-Test.mmdb" + "tests/data/test-data/GeoIP2-Connection-Type-Test.mmdb", + mode=mode, ) ip_address = "1.0.1.0" record = reader.connection_type(ip_address) - self.assertEqual( - record, eval(repr(record)), "ConnectionType repr can be eval'd" - ) - - self.assertEqual(record.connection_type, "Cellular") - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("1.0.1.0/24")) - - self.assertRegex( - str(record), - r"ConnectionType\(\{.*Cellular.*\}\)", - "ConnectionType str representation is reasonable", - ) + assert record == eval(repr(record)), "ConnectionType repr can be eval'd" + assert record.connection_type == "Cellular" + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("1.0.1.0/24") + assert re.search( + r"ConnectionType\(\{.*Cellular.*\}\)", str(record) + ), "ConnectionType str representation is reasonable" reader.close() - def test_country(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-Country-Test.mmdb") - record = reader.country("81.2.69.160") - self.assertEqual( - record.traits.ip_address, "81.2.69.160", "IP address is added to model" + @pytest.mark.parametrize("mode", modes) + def test_country(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-Country-Test.mmdb", mode=mode ) - self.assertEqual(record.traits.network, ipaddress.ip_network("81.2.69.160/27")) - self.assertEqual(record.country.is_in_european_union, False) - self.assertEqual(record.registered_country.is_in_european_union, False) - self.assertFalse(record.traits.is_anycast) + record = reader.country("81.2.69.160") + assert record.traits.ip_address == "81.2.69.160", "IP address is added to model" + assert record.traits.network == ipaddress.ip_network("81.2.69.160/27") + assert record.country.is_in_european_union is False + assert record.registered_country.is_in_european_union is False + assert not record.traits.is_anycast record = reader.country("214.1.1.0") - self.assertTrue(record.traits.is_anycast) + assert record.traits.is_anycast reader.close() - def test_domain(self) -> None: - reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-Domain-Test.mmdb") + @pytest.mark.parametrize("mode", modes) + def test_domain(self, mode: int) -> None: + reader = geoip2.database.Reader( + "tests/data/test-data/GeoIP2-Domain-Test.mmdb", mode=mode + ) ip_address = "1.2.0.0" record = reader.domain(ip_address) - self.assertEqual(record, eval(repr(record)), "Domain repr can be eval'd") - - self.assertEqual(record.domain, "maxmind.com") - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("1.2.0.0/16")) + assert record == eval(repr(record)), "Domain repr can be eval'd" - self.assertRegex( - str(record), - r"Domain\(\{.*maxmind.com.*\}\)", - "Domain str representation is reasonable", - ) + assert record.domain == "maxmind.com" + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("1.2.0.0/16") + assert re.search( + r"Domain\(\{.*maxmind.com.*\}\)", str(record) + ), "Domain str representation is reasonable" reader.close() - def test_enterprise(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_enterprise(self, mode: int) -> None: with geoip2.database.Reader( - "tests/data/test-data/GeoIP2-Enterprise-Test.mmdb" + "tests/data/test-data/GeoIP2-Enterprise-Test.mmdb", + mode=mode, ) as reader: ip_address = "74.209.24.0" record = reader.enterprise(ip_address) - self.assertEqual(record.city.confidence, 11) - self.assertEqual(record.country.confidence, 99) - self.assertEqual(record.country.geoname_id, 6252001) - self.assertEqual(record.country.is_in_european_union, False) - self.assertEqual(record.location.accuracy_radius, 27) - self.assertEqual(record.registered_country.is_in_european_union, False) - self.assertEqual(record.traits.connection_type, "Cable/DSL") - self.assertTrue(record.traits.is_legitimate_proxy) - self.assertEqual(record.traits.ip_address, ip_address) - self.assertEqual( - record.traits.network, ipaddress.ip_network("74.209.16.0/20") - ) - self.assertFalse(record.traits.is_anycast) + assert record.city.confidence == 11 + assert record.country.confidence == 99 + assert record.country.geoname_id == 6252001 + assert record.country.is_in_european_union is False + assert record.location.accuracy_radius == 27 + assert record.registered_country.is_in_european_union is False + assert record.traits.connection_type == "Cable/DSL" + assert record.traits.is_legitimate_proxy + assert record.traits.ip_address == ip_address + assert record.traits.network == ipaddress.ip_network("74.209.16.0/20") + assert not record.traits.is_anycast record = reader.enterprise("149.101.100.0") - self.assertEqual(record.traits.mobile_country_code, "310") - self.assertEqual(record.traits.mobile_network_code, "004") + assert record.traits.mobile_country_code == "310" + assert record.traits.mobile_network_code == "004" record = reader.enterprise("214.1.1.0") - self.assertTrue(record.traits.is_anycast) + assert record.traits.is_anycast - def test_isp(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_isp(self, mode: int) -> None: with geoip2.database.Reader( - "tests/data/test-data/GeoIP2-ISP-Test.mmdb" + "tests/data/test-data/GeoIP2-ISP-Test.mmdb", + mode=mode, ) as reader: ip_address = "1.128.0.0" record = reader.isp(ip_address) - self.assertEqual(record, eval(repr(record)), "ISP repr can be eval'd") - - self.assertEqual(record.autonomous_system_number, 1221) - self.assertEqual(record.autonomous_system_organization, "Telstra Pty Ltd") - self.assertEqual(record.isp, "Telstra Internet") - self.assertEqual(record.organization, "Telstra Internet") - self.assertEqual(record.ip_address, ip_address) - self.assertEqual(record.network, ipaddress.ip_network("1.128.0.0/11")) - - self.assertRegex( - str(record), - r"ISP\(\{.*Telstra.*\}\)", - "ISP str representation is reasonable", - ) - + assert record == eval(repr(record)), "ISP repr can be eval'd" + + assert record.autonomous_system_number == 1221 + assert record.autonomous_system_organization == "Telstra Pty Ltd" + assert record.isp == "Telstra Internet" + assert record.organization == "Telstra Internet" + assert record.ip_address == ip_address + assert record.network == ipaddress.ip_network("1.128.0.0/11") + assert re.search( + r"ISP\(\{.*Telstra.*\}\)", str(record) + ), "ISP str representation is reasonable" record = reader.isp("149.101.100.0") - self.assertEqual(record.mobile_country_code, "310") - self.assertEqual(record.mobile_network_code, "004") + assert record.mobile_country_code == "310" + assert record.mobile_network_code == "004" - def test_context_manager(self) -> None: + @pytest.mark.parametrize("mode", modes) + def test_context_manager(self, mode: int) -> None: with geoip2.database.Reader( - "tests/data/test-data/GeoIP2-Country-Test.mmdb" + "tests/data/test-data/GeoIP2-Country-Test.mmdb", + mode=mode, ) as reader: record = reader.country("81.2.69.160") - self.assertEqual(record.traits.ip_address, "81.2.69.160") - - -@unittest.skipUnless(maxminddb.extension, "No C extension module found. Skipping tests") -class TestExtensionReader(BaseTestReader): - mode = geoip2.database.MODE_MMAP_EXT - - -class TestMMAPReader(BaseTestReader): - mode = geoip2.database.MODE_MMAP - - -class TestFileReader(BaseTestReader): - mode = geoip2.database.MODE_FILE - - -class TestMemoryReader(BaseTestReader): - mode = geoip2.database.MODE_MEMORY - - -class TestAutoReader(BaseTestReader): - mode = geoip2.database.MODE_AUTO + assert record.traits.ip_address == "81.2.69.160"