Migrate Wikipedia-API from unittest to pytest (#514)

* Switch to pytest

* Fix tox config

* Fix failing test for MacOS and Python 3.10

* Convert few more files

* Migrate test files from unittest to pytest

- Migrated 11 test files from unittest to pytest
- Converted unittest.TestCase classes to plain classes with pytest fixtures
- Replaced all self.assert* methods with standard assert statements
- Fixed pytest.raises usage and exception access patterns
- All tests passing successfully

Files migrated:
- query_errors_test.py
- query_submodules_test.py
- async_http_client_test.py
- async_wikipedia_page_test.py
- http_client_test.py
- wikipedia_test.py
- wikipedia_page_test.py
- wikipedia_page_section_test.py
- extract_wiki_format_test.py
- extract_html_format_test.py
- search_enums_test.py

* convert few more files

* fix another batch

Author: martin-majlis

AGENTS.md

@@ -219,9 +219,9 @@ make html
 make run-tests
 ```
 
-This command runs both the unit tests and the CLI verification tests.
+This command runs both the unit tests and CLI verification tests.
 
-- The unit tests are executed via `python3 -m unittest discover tests/ '*test.py'`. All test files are in the `tests/` directory and follow the `*test.py` naming pattern.
+- The unit tests are executed via `uv run pytest tests/`. All test files are in the `tests/` directory and follow the `*_test.py` naming pattern.
 - The CLI verification tests are run using `./tests/cli/test_cli.sh verify`.
 
 ### CLI Tests
@@ -240,7 +240,7 @@ You can run the CLI tests independently.
 make run-coverage
 ```
 
-Produces a coverage report and `coverage.xml` for the `wikipediaapi` package.
+Produces a coverage report and `coverage.xml` for the `wikipediaapi` package using pytest and pytest-cov.
 
 ### Code Coverage Requirements
 

CONTRIBUTING.rst

@@ -62,7 +62,7 @@ The main test command runs both unit tests and CLI verification tests::
 
     make run-tests
 
-* The unit tests are executed via ``python3 -m unittest discover tests/ '*test.py'``. All test files are in the ``tests/`` directory and follow the ``*test.py`` naming pattern.
+* The unit tests are executed via ``uv run pytest tests/``. All test files are in the ``tests/`` directory and follow the ``*_test.py`` naming pattern.
 * The CLI verification tests are run using ``./tests/cli/test_cli.sh verify``.
 
 CLI Tests
@@ -83,6 +83,8 @@ Run tests with coverage to generate a coverage report and ``coverage.xml`` for t
 
     make run-coverage
 
+This uses pytest with pytest-cov to generate coverage reports.
+
 Multi-Python Testing
 ~~~~~~~~~~~~~~~~~~~~~
 

DEVELOPMENT.rst

@@ -1,20 +1,21 @@
 Development
 ===========
 
-Prerequisities
+Prerequisites
 --------------
+
 * Make
-* Python3.10+
+* Python 3.10+
 * Pip
 
 Makefile targets
-----------------
+-----------------
 * ``make run-pre-commit`` - lints source code
 * ``make requirements-all`` - install all requirements
   * ``make requirements`` - install package requirements
   * ``make requirements-dev`` - install development requirements
-* ``make run-tests`` - run unit tests
-* ``make run-coverage`` - run code coverage
+* ``make run-tests`` - run unit tests (pytest)
+* ``make run-coverage`` - run code coverage (pytest-cov)
 * ``make pypi-html`` - generates single HTML documentation into ``pypi-doc.html``
 * ``make html`` - generates HTML documentation similar to RTFD into folder ``_build/html/``
 * ``make release`` - creates new release as well as git tag

Makefile

@@ -27,7 +27,7 @@ run-pre-commit:
 run-tests: run-tests-unit run-test-cli-verify run-tests-cli-unit
 
 run-tests-unit:
-	uv run python -m unittest discover tests/ '*test.py'
+	uv run pytest tests/
 
 run-test-cli-verify:
 	uv run ./tests/cli/test_cli.sh verify
@@ -36,7 +36,7 @@ run-test-cli-record:
 	uv run ./tests/cli/test_cli.sh record
 
 run-tests-cli-unit:
-	uv run python -m unittest tests.cli_test -v
+	uv run pytest tests/cli_test.py -v
 
 run-type-check:
 	uv run mypy ./wikipediaapi
@@ -53,9 +53,7 @@ run-tox-ci:
 	uv run tox -e py
 
 run-coverage:
-	uv run coverage run --source=wikipediaapi -m unittest discover tests/ '*test.py'
-	uv run coverage report -m
-	uv run coverage xml
+	uv run pytest --cov=wikipediaapi --cov-report=term-missing --cov-report=xml tests/
 
 run-validate-attributes-mappping:
 	uv run python ./validate_attributes_mapping.py

pyproject.toml

@@ -50,6 +50,9 @@ dev = [
     "pre-commit==4.5.1",
     "pygments==2.19.2",
     "pyupgrade==3.21.2",
+    "pytest==8.3.5",
+    "pytest-asyncio==0.26.0",
+    "pytest-cov==6.1.0",
     "tox==4.50.3",
     "anyio[trio]==4.13.0",
     "respx==0.22.0",
@@ -151,3 +154,23 @@ source = ["wikipediaapi"]
 
 [tool.coverage.report]
 show_missing = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["*_test.py", "test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+filterwarnings = [
+    "ignore::DeprecationWarning:pytest_asyncio.plugin:",
+    "ignore::pytest.PytestDeprecationWarning:asyncio_default_fixture_loop_scope",
+]
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "--verbose",
+]
+asyncio_mode = "auto"
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "integration: marks tests as integration tests",
+]

tests/async_http_client_test.py

@@ -1,6 +1,5 @@
-import unittest
-
 import httpx
+import pytest
 import respx
 
 from tests.mock_data import user_agent
@@ -10,97 +9,98 @@
 API_URL = "https://en.wikipedia.org/w/api.php"
 
 
-class TestAsyncHTTPClientInit(unittest.TestCase):
+class TestAsyncHTTPClientInit:
     """Tests for AsyncHTTPClient initialisation."""
 
     def test_user_agent_set_in_client_headers(self):
         client = AsyncHTTPClient(user_agent, "en")
-        self.assertIn(user_agent, client._client.headers.get("User-Agent"))
+        assert user_agent in client._client.headers.get("User-Agent")
 
     def test_user_agent_appends_library_agent(self):
         client = AsyncHTTPClient(user_agent, "en")
         header = client._client.headers.get("User-Agent")
-        self.assertIn(wikipediaapi.USER_AGENT, header)
+        assert wikipediaapi.USER_AGENT in header
 
     def test_language_set(self):
         client = AsyncHTTPClient(user_agent, "de")
-        self.assertEqual(client.language, "de")
+        assert client.language == "de"
 
     def test_variant_set(self):
         client = AsyncHTTPClient(user_agent, "zh", variant="zh-tw")
-        self.assertEqual(client.variant, "zh-tw")
+        assert client.variant == "zh-tw"
 
     def test_max_retries_stored(self):
         client = AsyncHTTPClient(user_agent, "en", max_retries=5)
-        self.assertEqual(client._max_retries, 5)
+        assert client._max_retries == 5
 
     def test_retry_wait_stored(self):
         client = AsyncHTTPClient(user_agent, "en", retry_wait=2.5)
-        self.assertEqual(client._retry_wait, 2.5)
+        assert client._retry_wait == 2.5
 
     def test_missing_user_agent_raises(self):
-        with self.assertRaises(AssertionError):
+        with pytest.raises(AssertionError):
             AsyncHTTPClient("en")
 
 
-class TestAsyncHTTPClientGet(unittest.IsolatedAsyncioTestCase):
+class TestAsyncHTTPClientGet:
     """Tests for AsyncHTTPClient._get."""
 
-    def setUp(self):
+    def setup_method(self):
         self.client = AsyncHTTPClient(user_agent, "en", max_retries=0, retry_wait=0.0)
 
     @respx.mock
+    @pytest.mark.asyncio
     async def test_successful_get_returns_json(self):
         data = {"query": {"pages": {"1": {"title": "Test"}}}}
         respx.get(API_URL).mock(return_value=httpx.Response(200, json=data))
         result = await self.client._get("en", {"action": "query"})
-        self.assertEqual(result, data)
+        assert result == data
 
     @respx.mock
     async def test_get_de_uses_de_url(self):
         de_url = "https://de.wikipedia.org/w/api.php"
         data = {"ok": True}
         route = respx.get(de_url).mock(return_value=httpx.Response(200, json=data))
         await self.client._get("de", {"action": "query"})
-        self.assertTrue(route.called)
+        assert route.called is True
 
     @respx.mock
     async def test_404_raises_http_error(self):
         respx.get(API_URL).mock(return_value=httpx.Response(404))
-        with self.assertRaises(wikipediaapi.WikiHttpError) as ctx:
+        with pytest.raises(wikipediaapi.WikiHttpError) as ctx:
             await self.client._get("en", {"action": "query"})
-        self.assertEqual(ctx.exception.status_code, 404)
+        assert ctx.value.status_code == 404
 
     @respx.mock
     async def test_429_raises_rate_limit_error(self):
         respx.get(API_URL).mock(return_value=httpx.Response(429, headers={"Retry-After": "10"}))
-        with self.assertRaises(wikipediaapi.WikiRateLimitError) as ctx:
+        with pytest.raises(wikipediaapi.WikiRateLimitError) as ctx:
             await self.client._get("en", {"action": "query"})
-        self.assertEqual(ctx.exception.retry_after, 10)
+        assert ctx.value.retry_after == 10
 
     @respx.mock
     async def test_timeout_raises_timeout_error(self):
         respx.get(API_URL).mock(side_effect=httpx.TimeoutException("timeout"))
-        with self.assertRaises(wikipediaapi.WikiHttpTimeoutError):
+        with pytest.raises(wikipediaapi.WikiHttpTimeoutError):
             await self.client._get("en", {"action": "query"})
 
     @respx.mock
     async def test_connect_error_raises_connection_error(self):
         respx.get(API_URL).mock(side_effect=httpx.ConnectError("err"))
-        with self.assertRaises(wikipediaapi.WikiConnectionError):
+        with pytest.raises(wikipediaapi.WikiConnectionError):
             await self.client._get("en", {"action": "query"})
 
     @respx.mock
     async def test_invalid_json_raises_invalid_json_error(self):
         respx.get(API_URL).mock(return_value=httpx.Response(200, content=b"not-json"))
-        with self.assertRaises(wikipediaapi.WikiInvalidJsonError):
+        with pytest.raises(wikipediaapi.WikiInvalidJsonError):
             await self.client._get("en", {"action": "query"})
 
 
-class TestAsyncHTTPClientRetry(unittest.IsolatedAsyncioTestCase):
+class TestAsyncHTTPClientRetry:
     """Tests for retry behaviour in AsyncHTTPClient."""
 
-    def setUp(self):
+    def setup_method(self):
         self.client = AsyncHTTPClient(user_agent, "en", max_retries=2, retry_wait=0.0)
 
     @respx.mock
@@ -109,21 +109,21 @@ async def test_retries_on_500(self):
         responses = iter([httpx.Response(500), httpx.Response(200, json=success)])
         route = respx.get(API_URL).mock(side_effect=lambda req: next(responses))
         result = await self.client._get("en", {"action": "query"})
-        self.assertEqual(result, success)
-        self.assertEqual(route.call_count, 2)
+        assert result == success
+        assert route.call_count == 2
 
     @respx.mock
     async def test_exhausts_retries_on_500(self):
         route = respx.get(API_URL).mock(return_value=httpx.Response(500))
-        with self.assertRaises(wikipediaapi.WikiHttpError):
+        with pytest.raises(wikipediaapi.WikiHttpError):
             await self.client._get("en", {"action": "query"})
-        self.assertEqual(route.call_count, 3)
+        assert route.call_count == 3
 
     @respx.mock
     async def test_retries_on_429(self):
         success = {"ok": True}
         responses = iter([httpx.Response(429), httpx.Response(200, json=success)])
         route = respx.get(API_URL).mock(side_effect=lambda req: next(responses))
         result = await self.client._get("en", {"action": "query"})
-        self.assertEqual(result, success)
-        self.assertEqual(route.call_count, 2)
+        assert result == success
+        assert route.call_count == 2