winipedia-utils 0.2.63__py3-none-any.whl → 0.6.6__py3-none-any.whl

winipedia_utils/testing/tests/base/fixtures/scopes/session.py

@@ -9,26 +9,14 @@ through pytest's autouse mechanism.
 from importlib import import_module
 from pathlib import Path
 
-from winipedia_utils.consts import _DEV_DEPENDENCIES
-from winipedia_utils.git.gitignore.gitignore import _gitignore_is_correct
-from winipedia_utils.git.pre_commit.config import (
-    _pre_commit_config_is_correct,
-)
-from winipedia_utils.git.workflows.publish import (
-    PUBLISH_WORKFLOW_PATH,
-    _publish_config_is_correct,
-)
-from winipedia_utils.git.workflows.release import _release_config_is_correct
-from winipedia_utils.modules.module import to_path
+import winipedia_utils
 from winipedia_utils.modules.package import (
     find_packages,
     get_src_package,
     walk_package,
 )
 from winipedia_utils.projects.poetry.config import (
-    _pyproject_tool_configs_are_correct,
-    get_dev_dependencies_from_pyproject_toml,
-    get_poetry_package_name,
+    PyprojectConfigFile,
 )
 from winipedia_utils.testing.assertions import assert_with_msg
 from winipedia_utils.testing.convention import (
@@ -36,13 +24,11 @@ from winipedia_utils.testing.convention import (
     make_test_obj_importpath_from_obj,
 )
 from winipedia_utils.testing.fixtures import autouse_session_fixture
-from winipedia_utils.testing.tests.base.utils.utils import (
-    _conftest_content_is_correct,
-)
+from winipedia_utils.text.config import ConfigFile
 
 
 @autouse_session_fixture
-def _test_dev_dependencies_const_correct() -> None:
+def assert_dev_dependencies_config_is_correct() -> None:
     """Verify that the dev dependencies in consts.py are correct.
 
     This fixture runs once per test session and checks that the dev dependencies
@@ -53,19 +39,22 @@ def _test_dev_dependencies_const_correct() -> None:
         AssertionError: If the dev dependencies in consts.py are not correct
 
     """
-    if get_poetry_package_name() != "winipedia_utils":
+    if PyprojectConfigFile.get_package_name() != winipedia_utils.__name__:
         # this const is only used in winipedia_utils
         # to be able to install them with setup.py
         return
-    actual_dev_dependencies = get_dev_dependencies_from_pyproject_toml()
+    actual_dev_dependencies = PyprojectConfigFile.get_dev_dependencies()
+    expected_dev_dependencies = PyprojectConfigFile.get_configs()["tool"]["poetry"][
+        "group"
+    ]["dev"]["dependencies"].keys()
     assert_with_msg(
-        set(actual_dev_dependencies) == set(_DEV_DEPENDENCIES),
+        set(actual_dev_dependencies) == set(expected_dev_dependencies),
         "Dev dependencies in consts.py are not correct",
     )
 
 
 @autouse_session_fixture
-def _test_dev_dependencies_are_in_pyproject_toml() -> None:
+def assert_config_files_are_correct() -> None:
     """Verify that the dev dependencies are installed.
 
     This fixture runs once per test session and checks that the dev dependencies
@@ -75,131 +64,12 @@ def _test_dev_dependencies_are_in_pyproject_toml() -> None:
         ImportError: If a dev dependency is not installed
 
     """
-    dev_dependencies = get_dev_dependencies_from_pyproject_toml()
-    assert_with_msg(
-        set(_DEV_DEPENDENCIES).issubset(set(dev_dependencies)),
-        "Dev dependencies in consts.py are not a subset of the ones in pyproject.toml",
-    )
-
-
-@autouse_session_fixture
-def _test_conftest_exists_and_is_correct() -> None:
-    """Verify that the conftest.py file exists and has the correct content.
-
-    This fixture runs once per test session and checks that the conftest.py file
-    exists in the tests directory and contains the correct pytest_plugins configuration.
-
-    Raises:
-        AssertionError: If the conftest.py file doesn't exist or has incorrect content
-
-    """
-    conftest_path = Path(TESTS_PACKAGE_NAME, "conftest.py")
-    assert_with_msg(
-        conftest_path.is_file(),
-        f"Expected conftest.py file at {conftest_path} but it doesn't exist",
-    )
-
-    assert_with_msg(
-        _conftest_content_is_correct(conftest_path),
-        "conftest.py has incorrect content",
-    )
-
-
-@autouse_session_fixture
-def _test_pyproject_toml_is_correct() -> None:
-    """Verify that the pyproject.toml file exists and has the correct content.
-
-    This fixture runs once per test session and checks that the pyproject.toml file
-    exists in the root directory and contains the correct content.
-
-    Raises:
-        AssertionError: If the pyproject.toml file doesn't exist
-                        or has incorrect content
-
-    """
-    pyproject_toml_path = Path("pyproject.toml")
-    assert_with_msg(
-        pyproject_toml_path.is_file(),
-        f"Expected pyproject.toml file at {pyproject_toml_path} but it doesn't exist",
-    )
-    assert_with_msg(
-        _pyproject_tool_configs_are_correct(),
-        "pyproject.toml has incorrect content.",
-    )
-
-
-@autouse_session_fixture
-def _test_pre_commit_config_yaml_is_correct() -> None:
-    """Verify that the pre-commit yaml is correctly defining winipedia utils hook.
-
-    Checks that the yaml starts with the winipedia utils hook.
-    """
-    pre_commit_config = Path(".pre-commit-config.yaml")
-
-    assert_with_msg(
-        pre_commit_config.is_file(),
-        f"Expected {pre_commit_config} to exist but it doesn't.",
-    )
-    assert_with_msg(
-        _pre_commit_config_is_correct(),
-        "Pre commit config is not correct.",
-    )
-
-
-@autouse_session_fixture
-def _test_gitignore_is_correct() -> None:
-    """Verify that the .gitignore file exists and has the correct content.
-
-    This fixture runs once per test session and checks that the .gitignore file
-    exists in the root directory and contains the correct content.
-
-    Raises:
-        AssertionError: If the .gitignore file doesn't exist
-                        or has incorrect content
-
-    """
-    gitignore_path = Path(".gitignore")
-    assert_with_msg(
-        gitignore_path.is_file(),
-        f"Expected {gitignore_path} to exist but it doesn't.",
-    )
-    assert_with_msg(
-        _gitignore_is_correct(),
-        "Gitignore is not correct.",
-    )
+    # subclasses of ConfigFile
+    ConfigFile.init_config_files()
 
 
 @autouse_session_fixture
-def _test_publish_workflow_is_correct() -> None:
-    """Verify that the publish workflow is correctly defined.
-
-    If the file does not exist, we skip this test bc not all projects necessarily
-    need to publish to pypi, e.g. they are binaries or private usage only or for profit.
-    """
-    path = PUBLISH_WORKFLOW_PATH
-    # if folder exists but the file not then we skip this test
-    if path.parent.exists() and not path.exists():
-        return
-    assert_with_msg(
-        _publish_config_is_correct(),
-        "Publish workflow is not correct.",
-    )
-
-
-@autouse_session_fixture
-def _test_release_workflow_is_correct() -> None:
-    """Verify that the release workflow is correctly defined.
-
-    This workflow is mandatory for all projects.
-    """
-    assert_with_msg(
-        _release_config_is_correct(),
-        "Release workflow is not correct.",
-    )
-
-
-@autouse_session_fixture
-def _test_no_namespace_packages() -> None:
+def assert_no_namespace_packages() -> None:
     """Verify that there are no namespace packages in the project.
 
     This fixture runs once per test session and checks that all packages in the
@@ -221,7 +91,7 @@ def _test_no_namespace_packages() -> None:
 
 
 @autouse_session_fixture
-def _test_all_src_code_in_one_package() -> None:
+def assert_all_src_code_in_one_package() -> None:
     """Verify that all source code is in a single package.
 
     This fixture runs once per test session and checks that there is only one
@@ -241,7 +111,7 @@ def _test_all_src_code_in_one_package() -> None:
 
 
 @autouse_session_fixture
-def _test_src_package_correctly_named() -> None:
+def assert_src_package_correctly_named() -> None:
     """Verify that the source package is correctly named.
 
     This fixture runs once per test session and checks that the source package
@@ -252,34 +122,17 @@ def _test_src_package_correctly_named() -> None:
 
     """
     src_package = get_src_package().__name__
+    config = PyprojectConfigFile()
+    expected_package = config.get_package_name()
     assert_with_msg(
-        src_package == get_poetry_package_name(),
-        f"Expected source package to be named {get_poetry_package_name()}, "
+        src_package == expected_package,
+        f"Expected source package to be named {expected_package}, "
         f"but it is named {src_package}",
     )
 
 
 @autouse_session_fixture
-def _test_py_typed_exists() -> None:
-    """Verify that the py.typed file exists in the source package.
-
-    This fixture runs once per test session and checks that the py.typed file
-    exists in the source package.
-
-    Raises:
-        AssertionError: If the py.typed file doesn't exist
-
-    """
-    src_package = get_src_package()
-    py_typed_path = to_path(src_package.__name__, is_package=True) / "py.typed"
-    assert_with_msg(
-        py_typed_path.exists(),
-        f"Expected py.typed file to exist at {py_typed_path}",
-    )
-
-
-@autouse_session_fixture
-def _test_project_structure_mirrored() -> None:
+def assert_project_structure_mirrored() -> None:
     """Verify that the project structure is mirrored in tests.
 
     This fixture runs once per test session and checks that for every package and
@@ -311,20 +164,18 @@ def _test_project_structure_mirrored() -> None:
 
 
 @autouse_session_fixture
-def _test_no_unitest_package_usage() -> None:
-    """Verify that the unittest package is not used in the project.
+def assert_no_unit_test_package_usage() -> None:
+    """Verify that the unit test package is not used in the project.
 
-    This fixture runs once per test session and checks that the unittest package
+    This fixture runs once per test session and checks that the unit test package
     is not used in the project.
 
     Raises:
-        AssertionError: If the unittest package is used
+        AssertionError: If the unit test package is used
 
     """
     for path in Path().rglob("*.py"):
-        if path == to_path(__name__, is_package=False):
-            continue
         assert_with_msg(
-            "unittest" not in path.read_text(encoding="utf-8"),
-            f"Found unittest usage in {path}. Use pytest instead.",
+            "UnitTest".lower() not in path.read_text(encoding="utf-8"),
+            f"Found unit test package usage in {path}. Use pytest instead.",
         )

winipedia_utils/testing/tests/base/utils/utils.py

@@ -10,11 +10,15 @@ Returns:
 """
 
 from collections.abc import Callable
-from pathlib import Path
 from types import ModuleType
 from typing import Any
 
-from winipedia_utils.modules.module import get_objs_from_obj, make_obj_importpath
+from winipedia_utils.logging.logger import get_logger
+from winipedia_utils.modules.function import is_abstractmethod
+from winipedia_utils.modules.module import (
+    get_objs_from_obj,
+    make_obj_importpath,
+)
 from winipedia_utils.testing.assertions import assert_with_msg
 from winipedia_utils.testing.convention import (
     get_obj_from_test_obj,
@@ -22,8 +26,10 @@ from winipedia_utils.testing.convention import (
     make_untested_summary_error_msg,
 )
 
+logger = get_logger(__name__)
+
 
-def _assert_no_untested_objs(
+def assert_no_untested_objs(
     test_obj: ModuleType | type | Callable[..., Any],
 ) -> None:
     """Assert that all objects in the source have corresponding test objects.
@@ -42,7 +48,15 @@ def _assert_no_untested_objs(
     test_objs = get_objs_from_obj(test_obj)
     test_objs_paths = {make_obj_importpath(o) for o in test_objs}
 
-    obj = get_obj_from_test_obj(test_obj)
+    try:
+        obj = get_obj_from_test_obj(test_obj)
+    except ImportError:
+        if isinstance(test_obj, ModuleType):
+            # we skip if module not found bc that means it has custom tests
+            # and is not part of the mirrored structure
+            logger.warning("No source module found for %s, skipping", test_obj)
+            return
+        raise
     objs = get_objs_from_obj(obj)
     supposed_test_objs_paths = {make_test_obj_importpath_from_obj(o) for o in objs}
 
@@ -51,61 +65,17 @@ def _assert_no_untested_objs(
     assert_with_msg(not untested_objs, make_untested_summary_error_msg(untested_objs))
 
 
-def _get_conftest_content() -> str:
-    """Get the content for a conftest.py file when using winipedia_utils."""
-    return '''
-"""Pytest configuration for tests.
-
-This module configures pytest plugins for the test suite, setting up the necessary
-fixtures and hooks for the different
-test scopes (function, class, module, package, session).
-It also import custom plugins from tests/base/scopes.
-This file should not be modified manually.
-"""
-
-pytest_plugins = ["winipedia_utils.testing.tests.conftest"]
-'''.strip()
-
-
-def _conftest_content_is_correct(conftest_path: Path) -> bool:
-    """Check if the conftest.py file has the correct content.
+def assert_isabstrct_method(method: Any) -> None:
+    """Assert that a method is an abstract method.
 
     Args:
-        conftest_path: The path to the conftest.py file
-
-    Returns:
-        True if the conftest.py file exists and has the correct content, False otherwise
-
-    """
-    if not conftest_path.exists():
-        return False
-    return conftest_path.read_text().startswith(_get_conftest_content())
-
+        method: The method to check
 
-def _get_test_0_content() -> str:
-    """Get the content for a test_0.py file when using winipedia_utils."""
-    return '''
-"""Contains an empty test."""
-
-
-def test_0() -> None:
-    """Empty test.
-
-    Exists so that when no tests are written yet the base fixtures are executed.
-    """
-'''.strip()
-
-
-def _test_0_content_is_correct(test_0_path: Path) -> bool:
-    """Check if the test_0.py file has the correct content.
-
-    Args:
-        test_0_path: The path to the test_0.py file
-
-    Returns:
-        True if the test_0.py file exists and has the correct content, False otherwise
+    Raises:
+        AssertionError: If the method is not an abstract method
 
     """
-    if not test_0_path.exists():
-        return False
-    return test_0_path.read_text().startswith(_get_test_0_content())
+    assert_with_msg(
+        is_abstractmethod(method),
+        f"Expected {method} to be abstract method",
+    )

winipedia_utils/text/config.py

@@ -0,0 +1,250 @@
+"""Base class for config files."""
+
+import inspect
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+import tomlkit
+import yaml
+from dotenv import dotenv_values
+
+from winipedia_utils.iterating.iterate import nested_structure_is_subset
+from winipedia_utils.modules.class_ import init_all_nonabstract_subclasses
+from winipedia_utils.modules.package import DependencyGraph, get_src_package
+from winipedia_utils.projects.poetry.poetry import (
+    get_poetry_run_module_script,
+)
+from winipedia_utils.text.string import split_on_uppercase
+
+
+class ConfigFile(ABC):
+    """Base class for config files."""
+
+    @classmethod
+    @abstractmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+
+    @classmethod
+    @abstractmethod
+    def load(cls) -> dict[str, Any] | list[Any]:
+        """Load the config file."""
+
+    @classmethod
+    @abstractmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+
+    @classmethod
+    @abstractmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+
+    @classmethod
+    @abstractmethod
+    def get_configs(cls) -> dict[str, Any] | list[Any]:
+        """Get the config."""
+
+    def __init__(self) -> None:
+        """Initialize the config file."""
+        self.get_path().parent.mkdir(parents=True, exist_ok=True)
+        if not self.get_path().exists():
+            self.get_path().touch()
+            self.dump(self.get_configs())
+
+        if not self.is_correct():
+            config = self.add_missing_configs()
+            self.dump(config)
+
+        if not self.is_correct():
+            msg = f"Config file {self.get_path()} is not correct."
+            raise ValueError(msg)
+
+    @classmethod
+    def get_path(cls) -> Path:
+        """Get the path to the config file."""
+        return (
+            cls.get_parent_path() / f"{cls.get_filename()}.{cls.get_file_extension()}"
+        )
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        name = cls.__name__
+        abstract_parents = [
+            parent.__name__ for parent in cls.__mro__ if inspect.isabstract(parent)
+        ]
+        for parent in abstract_parents:
+            name = name.removesuffix(parent)
+        return "_".join(split_on_uppercase(name)).lower()
+
+    @classmethod
+    def add_missing_configs(cls) -> dict[str, Any] | list[Any]:
+        """Add any missing configs to the config file."""
+        current_config = cls.load()
+        expected_config = cls.get_configs()
+        nested_structure_is_subset(
+            expected_config,
+            current_config,
+            cls.add_missing_dict_val,
+            cls.insert_missing_list_val,
+        )
+        return current_config
+
+    @staticmethod
+    def add_missing_dict_val(
+        expected_dict: dict[str, Any], actual_dict: dict[str, Any], key: str
+    ) -> None:
+        """Add a missing dict value."""
+        actual_dict[key] = expected_dict[key]
+
+    @staticmethod
+    def insert_missing_list_val(
+        expected_list: list[Any], actual_list: list[Any], index: int
+    ) -> None:
+        """Append a missing list value."""
+        actual_list.insert(index, expected_list[index])
+
+    @classmethod
+    def is_correct(cls) -> bool:
+        """Check if the config is correct.
+
+        If the file is empty, it is considered correct.
+        This is so bc if a user does not want a specific config file,
+        they can just make it empty and the tests will not fail.
+        """
+        return cls.is_unwanted() or cls.is_correct_recursively(
+            cls.get_configs(), cls.load()
+        )
+
+    @classmethod
+    def is_unwanted(cls) -> bool:
+        """Check if the config file is unwanted.
+
+        If the file is empty, it is considered unwanted.
+        """
+        return cls.get_path().exists() and cls.get_path().read_text() == ""
+
+    @staticmethod
+    def is_correct_recursively(
+        expected_config: dict[str, Any] | list[Any],
+        actual_config: dict[str, Any] | list[Any],
+    ) -> bool:
+        """Check if the config is correct.
+
+        Checks if expected is a subset recursively of actual.
+        If a value is Any, it is considered correct.
+
+        Args:
+            expected_config: The expected config
+            actual_config: The actual config
+
+        Returns:
+            True if the config is correct, False otherwise
+        """
+        return nested_structure_is_subset(expected_config, actual_config)
+
+    @classmethod
+    def init_config_files(cls) -> None:
+        """Initialize all subclasses."""
+        pkgs_depending_on_winipedia_utils = (
+            DependencyGraph().get_all_depending_on_winipedia_utils(
+                include_winipedia_utils=True
+            )
+        )
+        pkgs_depending_on_winipedia_utils.add(get_src_package())
+        for pkg in pkgs_depending_on_winipedia_utils:
+            init_all_nonabstract_subclasses(cls, load_package_before=pkg)
+
+    @staticmethod
+    def get_poetry_run_setup_script() -> str:
+        """Get the poetry run setup script."""
+        from winipedia_utils import setup  # noqa: PLC0415  # avoid circular import
+
+        return get_poetry_run_module_script(setup)
+
+
+class YamlConfigFile(ConfigFile):
+    """Base class for yaml config files."""
+
+    @classmethod
+    def load(cls) -> dict[str, Any] | list[Any]:
+        """Load the config file."""
+        return yaml.safe_load(cls.get_path().read_text()) or {}
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        with cls.get_path().open("w") as f:
+            yaml.safe_dump(config, f, sort_keys=False)
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "yaml"
+
+
+class TomlConfigFile(ConfigFile):
+    """Base class for toml config files."""
+
+    @classmethod
+    def load(cls) -> dict[str, Any]:
+        """Load the config file."""
+        return tomlkit.parse(cls.get_path().read_text())
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        if not isinstance(config, dict):
+            msg = f"Cannot dump {config} to toml file."
+            raise TypeError(msg)
+        with cls.get_path().open("w") as f:
+            tomlkit.dump(config, f, sort_keys=False)
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "toml"
+
+
+class DotEnvConfigFile(ConfigFile):
+    """config class for .env config files."""
+
+    @classmethod
+    def load(cls) -> dict[str, str | None]:
+        """Load the config file."""
+        return dotenv_values(cls.get_path())
+
+    @classmethod
+    def dump(cls, config: dict[str, Any] | list[Any]) -> None:
+        """Dump the config file."""
+        # is not supposed to be dumped to, so just raise error
+        if config:
+            msg = f"Cannot dump {config} to .env file."
+            raise ValueError(msg)
+
+    @classmethod
+    def get_file_extension(cls) -> str:
+        """Get the file extension of the config file."""
+        return "env"
+
+    @classmethod
+    def get_filename(cls) -> str:
+        """Get the filename of the config file."""
+        return ""  # so it builds the path .env and not env.env
+
+    @classmethod
+    def get_parent_path(cls) -> Path:
+        """Get the path to the config file."""
+        return Path()
+
+    @classmethod
+    def get_configs(cls) -> dict[str, Any]:
+        """Get the config."""
+        return {}
+
+    @classmethod
+    def is_correct(cls) -> bool:
+        """Check if the config is correct."""
+        return super().is_correct() or cls.get_path().exists()

winipedia_utils/text/string.py

@@ -7,7 +7,10 @@ These utilities simplify common string manipulation tasks throughout the applica
 
 import hashlib
 import textwrap
+from collections.abc import Callable
 from io import StringIO
+from types import ModuleType
+from typing import Any
 
 from defusedxml import ElementTree as DefusedElementTree
 
@@ -124,3 +127,30 @@ def split_on_uppercase(string: str) -> list[str]:
             current_part += letter
     parts.append(current_part)
     return parts
+
+
+def make_name_from_obj(
+    package: ModuleType | Callable[..., Any] | type,
+    split_on: str = "_",
+    join_on: str = "-",
+    *,
+    capitalize: bool = True,
+) -> str:
+    """Make a name from a package.
+
+    takes a package and makes a name from it that is readable by humans.
+
+    Args:
+        package (ModuleType): The package to make a name from
+        split_on (str, optional): what to split the package name on. Defaults to "_".
+        join_on (str, optional): what to join the package name with. Defaults to "-".
+        capitalize (bool, optional): Whether to capitalize each part. Defaults to True.
+
+    Returns:
+        str: _description_
+    """
+    package_name = package.__name__.split(".")[-1]
+    parts = package_name.split(split_on)
+    if capitalize:
+        parts = [part.capitalize() for part in parts]
+    return join_on.join(parts)