Make tests not tag aware (#1133)

Co-authored-by: ItsDrike <itsdrike@protonmail.com>

Author: PerchunPak

tests/helpers.py

@@ -0,0 +1,33 @@
+import collections.abc as c
+import importlib.metadata
+from contextlib import contextmanager
+from functools import wraps
+from unittest.mock import patch
+
+from mcstatus._utils.deprecation import LIB_NAME, _get_project_version
+
+
+@contextmanager
+def patch_project_version(version: str | None) -> c.Iterator[None]:
+    """Patch the project version reported by ``importlib.metadata.version``.
+
+    This is used to simulate different project versions for testing purposes.
+    If ``version`` is ``None``, a :exc:`PackageNotFoundError` will be raised
+    when trying to get the project version.
+    """
+    orig_version_func = importlib.metadata.version
+
+    @wraps(orig_version_func)
+    def patched_version_func(distribution_name: str) -> str:
+        if distribution_name == LIB_NAME:
+            if version is None:
+                raise importlib.metadata.PackageNotFoundError
+            return version
+        return orig_version_func(distribution_name)
+
+    _get_project_version.cache_clear()
+    with patch.object(importlib.metadata, "version", new=patched_version_func):
+        try:
+            yield
+        finally:
+            _get_project_version.cache_clear()

tests/responses/test_bedrock.py

@@ -4,6 +4,7 @@
 
 from mcstatus.motd import Motd
 from mcstatus.responses import BedrockStatusPlayers, BedrockStatusResponse, BedrockStatusVersion
+from tests.helpers import patch_project_version
 from tests.responses import BaseResponseTest
 
 
@@ -99,8 +100,13 @@ def build(self, build):
         return build.version
 
     def test_deprecated_version_alias(self, build: BedrockStatusVersion):
-        with pytest.warns(
-            DeprecationWarning,
-            match=r"^BedrockStatusVersion\.version is deprecated and scheduled for removal in 13\.0\.0, use name instead\.$",
+        with (
+            patch_project_version("0.0.0"),
+            pytest.deprecated_call(
+                match=(
+                    r"^BedrockStatusVersion\.version is deprecated and scheduled for removal in 13\.0\.0, "
+                    r"use name instead\.$"
+                ),
+            ),
         ):
             assert build.version == build.name

tests/responses/test_query.py

@@ -5,6 +5,7 @@
 from mcstatus.motd import Motd
 from mcstatus.responses import QueryPlayers, QueryResponse, QuerySoftware
 from mcstatus.responses._raw import RawQueryResponse
+from tests.helpers import patch_project_version
 from tests.responses import BaseResponseTest
 
 
@@ -77,9 +78,11 @@ def test_as_dict(self, build: QueryResponse):
         }
 
     def test_deprecated_map_alias(self, build: QueryResponse):
-        with pytest.warns(
-            DeprecationWarning,
-            match=r"^QueryResponse\.map is deprecated and scheduled for removal in 13\.0\.0, use map_name instead\.$",
+        with (
+            patch_project_version("0.0.0"),
+            pytest.deprecated_call(
+                match=r"^QueryResponse\.map is deprecated and scheduled for removal in 13\.0\.0, use map_name instead\.$",
+            ),
         ):
             assert build.map == build.map_name
 
@@ -111,9 +114,14 @@ def build(self):
         )
 
     def test_deprecated_names_alias(self, build: QueryPlayers):
-        with pytest.warns(
-            DeprecationWarning,
-            match=r"^QueryPlayers\.names is deprecated and scheduled for removal in 13\.0\.0, use 'list' attribute instead\.$",
+        with (
+            patch_project_version("0.0.0"),
+            pytest.deprecated_call(
+                match=(
+                    r"^QueryPlayers\.names is deprecated and scheduled for removal in 13\.0\.0, "
+                    r"use 'list' attribute instead\.$"
+                ),
+            ),
         ):
             assert build.names == build.list
 

tests/test_compat.py

@@ -3,6 +3,7 @@
 import importlib
 import os
 import shutil
+import sys
 import tarfile
 import zipfile
 from collections.abc import Iterator
@@ -13,6 +14,8 @@
 import pytest
 from hatchling.build import build_sdist, build_wheel
 
+from tests.helpers import patch_project_version
+
 
 @contextmanager
 def _chdir(path: Path) -> Iterator[None]:
@@ -46,23 +49,30 @@ def _extractall_compat(tar: tarfile.TarFile, destination: Path) -> None:
         tar.extractall(destination)  # noqa: S202
 
 
+@pytest.mark.parametrize("raises", [False, True])
 @pytest.mark.parametrize(
     ("module", "msg_pattern"),
     [
-        ("mcstatus._compat.status_response", r"use mcstatus\.responses instead"),
         ("mcstatus._compat.forge_data", r"use mcstatus\.responses\.forge instead"),
         ("mcstatus._compat.motd_transformers", r"MOTD Transformers are no longer a part of mcstatus public API"),
+        ("mcstatus._compat.status_response", r"use mcstatus\.responses instead"),
     ],
 )
-def test_deprecated_import_path(module: str, msg_pattern: str):
+def test_deprecated_import_path(raises: bool, module: str, msg_pattern: str):
     """Test that the compatibility shims emit deprecation warnings at import time.
 
     Note that this does NOT test the actual inclusion of the compatibility modules into
     the source tree at build time. This test intentionally only uses the _compat imports,
     as the shim files are only included on build time, which means testing those directly
     would fail.
     """
-    with pytest.deprecated_call(match=msg_pattern):
+    # importlib.import_module caches module, if it didn't raise
+    sys.modules.pop(module, None)
+
+    context_manager = (
+        pytest.raises(DeprecationWarning, match=msg_pattern) if raises else pytest.deprecated_call(match=msg_pattern)
+    )
+    with patch_project_version("100.0.0" if raises else "0.0.0"), context_manager:
         importlib.import_module(module)
 
 

tests/utils/test_deprecation.py

@@ -1,117 +1,109 @@
 from __future__ import annotations
 
-import importlib.metadata
 import re
 import warnings
-from functools import wraps
 
 import pytest
 
 from mcstatus._utils.deprecation import _get_project_version, deprecated, deprecation_warn
+from tests.helpers import patch_project_version
 
 LIB_NAME = "mcstatus"
 
 
-def _patch_project_version(monkeypatch: pytest.MonkeyPatch, version: str | None):
-    """Patch the project version reported by ``importlib.metadata.version``.
-
-    This is used to simulate different project versions for testing purposes.
-    If ``version`` is ``None``, a :exc:`PackageNotFoundError` will be raised
-    when trying to get the project version.
-    """
-    orig_version_func = importlib.metadata.version
-
-    @wraps(orig_version_func)
-    def patched_version_func(distribution_name: str) -> str:
-        if distribution_name == LIB_NAME:
-            if version is None:
-                raise importlib.metadata.PackageNotFoundError
-            return version
-        return orig_version_func(distribution_name)
-
-    _get_project_version.cache_clear()
-    monkeypatch.setattr(importlib.metadata, "version", patched_version_func)
-
-
-def test_invalid_lib_version(monkeypatch: pytest.MonkeyPatch):
-    _patch_project_version(monkeypatch, "foo bar")
-
-    with pytest.warns(match=f"^Failed to parse {LIB_NAME} project version \\(foo bar\\), assuming v0\\.0\\.0$"):
+def test_invalid_lib_version():
+    with (
+        patch_project_version("foo bar"),
+        pytest.warns(match=f"^Failed to parse {LIB_NAME} project version \\(foo bar\\), assuming v0\\.0\\.0$"),
+    ):
         _get_project_version()
 
 
-def test_epoch_in_lib_version(monkeypatch: pytest.MonkeyPatch):
-    _patch_project_version(monkeypatch, "2!1.2.3")
-
-    with pytest.warns(match=f"^Failed to parse {LIB_NAME} project version, assuming v0\\.0\\.0$"):
+def test_epoch_in_lib_version():
+    with (
+        patch_project_version("2!1.2.3"),
+        pytest.warns(
+            match=f"^Failed to parse {LIB_NAME} project version, assuming v0\\.0\\.0$",
+        ),
+    ):
         _get_project_version()
 
 
 @pytest.mark.parametrize("removal_version", ["0.9.0", (0, 9, 0)])
-def test_deprecation_warn_produces_error(monkeypatch: pytest.MonkeyPatch, removal_version: str | tuple[int, int, int]):
+def test_deprecation_warn_produces_error(removal_version: str | tuple[int, int, int]):
     """Test deprecation_warn with older removal_version than current version produces exception."""
-    _patch_project_version(monkeypatch, "1.0.0")
-
-    with pytest.raises(DeprecationWarning, match=r"^test is passed its removal version \(0\.9\.0\)\.$"):
+    with (
+        patch_project_version("1.0.0"),
+        pytest.raises(
+            DeprecationWarning,
+            match=r"^test is passed its removal version \(0\.9\.0\)\.$",
+        ),
+    ):
         deprecation_warn(obj_name="test", removal_version=removal_version)
 
 
 @pytest.mark.parametrize("removal_version", ["1.0.1", (1, 0, 1)])
-def test_deprecation_warn_produces_warning(monkeypatch: pytest.MonkeyPatch, removal_version: str | tuple[int, int, int]):
+def test_deprecation_warn_produces_warning(removal_version: str | tuple[int, int, int]):
     """Test deprecation_warn with newer removal_version than current version produces warning."""
-    _patch_project_version(monkeypatch, "1.0.0")
-
-    with pytest.deprecated_call(match=r"^test is deprecated and scheduled for removal in 1\.0\.1\.$"):
+    with (
+        patch_project_version("1.0.0"),
+        pytest.deprecated_call(
+            match=r"^test is deprecated and scheduled for removal in 1\.0\.1\.$",
+        ),
+    ):
         deprecation_warn(obj_name="test", removal_version=removal_version)
 
 
-def test_deprecation_invalid_removal_version(monkeypatch: pytest.MonkeyPatch):
+def test_deprecation_invalid_removal_version():
     """Test deprecation_warn with invalid removal_version."""
-    _patch_project_version(monkeypatch, "1.0.0")
-
     pattern = re.escape(r"(\d+)\.(\d+)\.(\d+)")
-    with pytest.raises(ValueError, match=f"^removal_version must follow regex pattern of: {pattern}$"):
+    with (
+        patch_project_version("1.0.0"),
+        pytest.raises(
+            ValueError,
+            match=f"^removal_version must follow regex pattern of: {pattern}$",
+        ),
+    ):
         deprecation_warn(obj_name="test", removal_version="foo!")
 
 
-def test_deprecation_warn_unknown_version(monkeypatch: pytest.MonkeyPatch):
+def test_deprecation_warn_unknown_version():
     """Test deprecation_warn with unknown project version.
 
     This could occur if the project wasn't installed as a package. (e.g. when running directly from
     source, like via a git submodule.)
     """
-    _patch_project_version(monkeypatch, None)
-
     with (
+        patch_project_version(None),
         pytest.warns(match=f"Failed to get {LIB_NAME} project version", expected_warning=RuntimeWarning),
         pytest.deprecated_call(match=r"^test is deprecated and scheduled for removal in 1\.0\.0\.$"),
     ):
         deprecation_warn(obj_name="test", removal_version="1.0.0")
 
 
-def test_deprecation_decorator_warn(monkeypatch: pytest.MonkeyPatch):
+def test_deprecation_decorator_warn():
     """Check deprecated decorator triggers a deprecation warning."""
-    _patch_project_version(monkeypatch, "1.0.0")
+    with patch_project_version("1.0.0"):
 
-    @deprecated(display_name="func", removal_version="1.0.1")
-    def func(x: object) -> object:
-        return x
+        @deprecated(display_name="func", removal_version="1.0.1")
+        def func(x: object) -> object:
+            return x
 
-    with pytest.deprecated_call(match=r"^func is deprecated and scheduled for removal in 1\.0\.1\.$"):
-        assert func(5) == 5
+        with pytest.deprecated_call(match=r"^func is deprecated and scheduled for removal in 1\.0\.1\.$"):
+            assert func(5) == 5
 
 
-def test_deprecation_decorator_inferred_name(monkeypatch: pytest.MonkeyPatch):
+def test_deprecation_decorator_inferred_name():
     """Check deprecated decorator properly infers qualified name of decorated object shown in warning."""
-    _patch_project_version(monkeypatch, "1.0.0")
+    with patch_project_version("1.0.0"):
 
-    @deprecated(removal_version="1.0.1")
-    def func(x: object) -> object:
-        return x
+        @deprecated(removal_version="1.0.1")
+        def func(x: object) -> object:
+            return x
 
-    qualname = r"test_deprecation_decorator_inferred_name\.<locals>\.func"
-    with pytest.deprecated_call(match=rf"^{qualname} is deprecated and scheduled for removal in 1\.0\.1\.$"):
-        assert func(5) == 5
+        qualname = r"test_deprecation_decorator_inferred_name\.<locals>\.func"
+        with pytest.deprecated_call(match=rf"^{qualname} is deprecated and scheduled for removal in 1\.0\.1\.$"):
+            assert func(5) == 5
 
 
 @pytest.mark.parametrize(
@@ -130,11 +122,9 @@ def func(x: object) -> object:
         ("1.2.3rc1.post2.dev3+loc.1", (1, 2, 3)),
     ],
 )
-def test_project_version_non_normalized_parsing(monkeypatch: pytest.MonkeyPatch, version: str, expected: tuple[int, int, int]):
+def test_project_version_non_normalized_parsing(version: str, expected: tuple[int, int, int]):
     """Ensure PEP440 release versions get parsed out properly, with non-release components are ignored."""
-    _patch_project_version(monkeypatch, version)
-
-    with warnings.catch_warnings():
+    with patch_project_version(version), warnings.catch_warnings():
         warnings.simplefilter("error")  # raise warnings as errors (test there are no warnings)
 
         assert _get_project_version() == expected
@@ -157,13 +147,10 @@ def test_project_version_non_normalized_parsing(monkeypatch: pytest.MonkeyPatch,
     ids=["1.2", "1.2.3.4"],
 )
 def test_project_version_normalizes_release_components(
-    monkeypatch: pytest.MonkeyPatch,
     version: str,
     expected: tuple[int, int, int],
     warning: str,
 ):
     """Ensure release segments normalize to a 3-component version and warn."""
-    _patch_project_version(monkeypatch, version)
-
-    with pytest.warns(RuntimeWarning, match=rf"^{re.escape(warning)}$"):
+    with patch_project_version(version), pytest.warns(RuntimeWarning, match=rf"^{re.escape(warning)}$"):
         assert _get_project_version() == expected