tests: add test cases for media types

Author: CyanVoxel

src/tagstudio/core/media_types.py

@@ -3,6 +3,7 @@
 
 
 import re
+from typing import Any
 
 import structlog
 
@@ -108,6 +109,25 @@ class MediaTypes(metaclass=SanitizedAttr):
     all_groups: list[MediaTypeGroup] = []
     equivalent_exts: dict[str, set[str]] = {}
 
+    @classmethod
+    def _snapshot(cls) -> dict[str, Any]:
+        """Return a snapshot of the class's attributes. Used in tests."""
+        return {attr: getattr(cls, attr) for attr in dir(cls) if not attr.startswith("__")}
+
+    @classmethod
+    def _restore(cls, attrs: dict[str, Any]) -> None:
+        """Restore the state of the class from a snapshot. Used in tests."""
+        attrs_to_delete: list[str] = []
+        for name in cls.__dict__:
+            if not name.startswith("__"):
+                try:
+                    setattr(cls, name, attrs[name])
+                except KeyError:
+                    attrs_to_delete.append(name)
+
+        for attr in attrs_to_delete:
+            delattr(cls, attr)
+
     @classmethod
     def add_name_aliases(cls, group_key: str, names: str | list[str]) -> None:
         """Adds one or more user-facing names for a MediaTypeGroup.

tests/conftest.py

@@ -1,6 +1,9 @@
 # SPDX-FileCopyrightText: (c) TagStudio Contributors
 # SPDX-License-Identifier: GPL-3.0-only
 
+# pyright: reportPrivateUsage=false
+# pyright: reportUnusedFunction=false
+
 
 import sys
 from collections.abc import Callable, Generator
@@ -13,6 +16,7 @@
 from pytestqt.qtbot import QtBot
 
 from tagstudio.core.library.alchemy.fields import TextField
+from tagstudio.core.media_types import MediaTypes
 
 CWD = Path(__file__).parent
 # this needs to be above `src` imports
@@ -148,11 +152,25 @@ def entry_full(library: Library):
 
 
 @pytest.fixture(autouse=True)
-def _init_qtbot(qtbot: QtBot):  # pyright: ignore[reportUnusedFunction]
+def _init_qtbot(qtbot: QtBot):
     """Ensures that a QtBot is initialized for all subsequent tests, regardless of order."""
     return qtbot
 
 
+@pytest.fixture(autouse=True)
+def _reset_media_types():
+    """Snapshot the MediaTypes state before each test, then restore it after."""
+    pre_snapshop = MediaTypes._snapshot()
+
+    yield
+
+    post_snapshop = MediaTypes._snapshot()
+
+    if pre_snapshop != post_snapshop:
+        MediaTypes._restore(pre_snapshop)
+        assert pre_snapshop == MediaTypes._snapshot(), "The MediaTypes state was not restored!"
+
+
 @pytest.fixture
 def qt_driver(library: Library, library_dir: Path):
     class Args:

tests/core/test_media_types.py

@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: (c) TagStudio Contributors
+# SPDX-License-Identifier: MIT
+
+
+from pytestqt.exceptions import pytest
+
+from tagstudio.core.media_types import MediaTypes
+
+
+def test_register_and_contains():
+    MediaTypes.register("zzztest.basic", ".zzzfoo", "SEARCH")
+
+    assert MediaTypes.contains("zzztest.basic", ".zzzfoo", "SEARCH")
+    assert not MediaTypes.contains("zzztest.basic", ".zzzfoo", "RENDER")
+
+
+def test_additive_register():
+    MediaTypes.register("zzztest.additive", ".zzzfoo", "SEARCH")
+    MediaTypes.register("zzztest.additive", ".zzzbar", "SEARCH")
+
+    assert MediaTypes.contains("zzztest.additive", ".zzzfoo", "SEARCH")
+    assert MediaTypes.contains("zzztest.additive", ".zzzbar", "SEARCH")
+
+
+def test_contains_missing_group_raises_error():
+    with pytest.raises(AttributeError, match=r"is not registered"):
+        MediaTypes.contains("zzztest.does_not_exist", ".zzzfoo", "SEARCH")
+
+
+def test_dot_notation_chains_to_parents():
+    MediaTypes.register("zzztest.chain.parent.child", ".zzzchild", "SEARCH")
+
+    assert MediaTypes.contains("zzztest.chain.parent.child", ".zzzchild", "SEARCH")
+    assert MediaTypes.contains("zzztest.chain.parent", ".zzzchild", "SEARCH")
+    assert MediaTypes.contains("zzztest.chain", ".zzzchild", "SEARCH")
+
+
+def test_explicit_chain_group():
+    MediaTypes.chain_group("zzztest.composite", ["zzztest.composite_child"])
+    MediaTypes.register("zzztest.composite_child", ".zzzcomposite", "SEARCH")
+
+    assert MediaTypes.contains("zzztest.composite", ".zzzcomposite", "SEARCH")
+
+
+def test_equivalent_extensions():
+    MediaTypes.register("zzztest.equiv", [".zzzone", ".zzztwo"], "SEARCH")
+
+    assert MediaTypes.get_equivalent_exts(".zzzone") == {".zzzone", ".zzztwo"}
+    assert MediaTypes.get_equivalent_exts(".zzztwo") == {".zzzone", ".zzztwo"}
+    assert MediaTypes.contains("zzztest.equiv", ".zzzone", "SEARCH")
+    assert MediaTypes.contains("zzztest.equiv", ".zzztwo", "SEARCH")
+
+
+def test_get_equivalent_exts_defaults_to_itself():
+    assert MediaTypes.get_equivalent_exts(".zzzunregistered") == {".zzzunregistered"}
+
+
+def test_find():
+    MediaTypes.register("zzztest.find_a", ".zzzfind", "SEARCH")
+    MediaTypes.register("zzztest.find_b", ".zzzfind", "RENDER")
+
+    search_keys = {group.key for group in MediaTypes.find(".zzzfind", "SEARCH")}
+    render_keys = {group.key for group in MediaTypes.find(".zzzfind", "RENDER")}
+
+    assert "zzztest.find_a" in search_keys
+    assert "zzztest.find_a" not in render_keys
+    assert "zzztest.find_b" in render_keys
+    assert "zzztest.find_b" not in search_keys
+
+
+def test_add_name_aliases_and_lookup():
+    MediaTypes.register("zzztest.alias_target", ".zzzalias", "SEARCH")
+    MediaTypes.add_name_aliases("zzztest.alias_target", ["ZZZ Test Group", "zzztest"])
+
+    assert MediaTypes.get_group_key_from_name("ZZZ Test Group") == "zzztest.alias_target"
+    assert MediaTypes.get_group_key_from_name("zzz test group", case_sensitive=False) == (
+        "zzztest.alias_target"
+    )
+    assert (
+        MediaTypes.get_group_key_from_name(
+            "zzztestGroup", case_sensitive=False, ignore_whitespace=True
+        )
+        == "zzztest.alias_target"
+    )
+    assert MediaTypes.get_group_key_from_name("Not A Real Alias") is None