Modernize tests

pyproject.toml

@@ -36,6 +36,8 @@ classifiers = [
 
 [project.optional-dependencies]
 test = [
+    "pytest~=8.3",
+    "pytest-cov~=5.0",
     "pytest-httpserver>=1.0.10",
 ]
 

setup.cfg

@@ -20,10 +20,8 @@ python =
     3.12: py312,black,lint,flake8,mypy
 
 [testenv:{py38,py39,py310,py311,py312}-test]
-deps =
-    pytest-httpserver
-    pytest
-commands = pytest tests
+commands = pytest tests {posargs:--cov --cov-report=term-missing}
+extras = test
 
 [testenv:py312-black]
 deps = black

tests/database_test.py

@@ -1,14 +1,8 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from __future__ import unicode_literals
-
 import ipaddress
-import sys
-import unittest
+import re
 from unittest.mock import patch, MagicMock
 
-sys.path.append("..")
+import pytest
 
 import geoip2.database
 import geoip2.errors
@@ -20,51 +14,47 @@
     maxminddb.extension = None  # type: ignore
 
 
-class TestReader(unittest.TestCase):
+class TestReader:
     def test_language_list(self) -> None:
         reader = geoip2.database.Reader(
             "tests/data/test-data/GeoIP2-Country-Test.mmdb",
             ["xx", "ru", "pt-BR", "es", "en"],
         )
         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(
+        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:
+        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()
+        assert ei.value.network == ipaddress.ip_network("10.0.0.0/8")
+        reader.close()
 
     def test_wrong_database(self) -> None:
         reader = geoip2.database.Reader("tests/data/test-data/GeoIP2-City-Test.mmdb")
-        with self.assertRaisesRegex(
+        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"
+        with pytest.raises(
+            ValueError,
+            match="u?'invalid' does not appear to be an " "IPv4 or IPv6 address",
         ):
             reader.city("invalid")
         reader.close()
@@ -76,14 +66,14 @@ def test_anonymous_ip(self) -> None:
         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:
@@ -93,14 +83,14 @@ def test_anonymous_ip_all_set(self) -> None:
         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:
@@ -109,37 +99,33 @@ def test_asn(self) -> None:
         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")
         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()
 
@@ -151,35 +137,27 @@ def test_connection_type(self) -> None:
 
         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"
-        )
-        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)
+        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()
 
@@ -189,17 +167,14 @@ def test_domain(self) -> None:
         ip_address = "1.2.0.0"
         record = reader.domain(ip_address)
 
-        self.assertEqual(record, eval(repr(record)), "Domain repr can be eval'd")
+        assert 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"))
-
-        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()
 
@@ -209,59 +184,60 @@ def test_enterprise(self) -> None:
         ) 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:
         with geoip2.database.Reader(
             "tests/data/test-data/GeoIP2-ISP-Test.mmdb"
         ) 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:
         with geoip2.database.Reader(
             "tests/data/test-data/GeoIP2-Country-Test.mmdb"
         ) as reader:
             record = reader.country("81.2.69.160")
-            self.assertEqual(record.traits.ip_address, "81.2.69.160")
+            assert record.traits.ip_address == "81.2.69.160"
+
+    def test_metadata(self) -> None:
+        with geoip2.database.Reader(
+            "tests/data/test-data/GeoIP2-Country-Test.mmdb"
+        ) as reader:
+            meta = reader.metadata()
+            assert meta.database_type == "GeoIP2-Country"
 
     @patch("maxminddb.open_database")
     def test_modes(self, mock_open) -> None:
@@ -271,5 +247,5 @@ def test_modes(self, mock_open) -> None:
         with geoip2.database.Reader(
             path,
             mode=geoip2.database.MODE_MMAP_EXT,
-        ) as reader:
+        ):
             mock_open.assert_called_once_with(path, geoip2.database.MODE_MMAP_EXT)