uyeia 0.1.0__tar.gz

uyeia-0.1.0/.github/workflows/lint.yml

@@ -0,0 +1,25 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+    lint:
+        if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+        runs-on: ubuntu-22.04
+        steps:
+        - name: Checkout repository
+          uses: actions/checkout@v4
+        - name: Set up Python
+          uses: actions/setup-python@v5
+          with:
+            python-version: '3.11'
+        - name: Install Rye
+          uses: eifinger/setup-rye@v4
+          with:
+              version: '0.43.0'
+        - name: Install dependencies
+          run: |
+              rye sync
+        - name: Run Linter
+          run: |
+              rye run lint

uyeia-0.1.0/.github/workflows/packaging.yml

@@ -0,0 +1,50 @@
+name: Packaging
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+    - name: Install Rye
+      uses: eifinger/setup-rye@v4
+      with:
+          version: '0.43.0'
+    - name: Install dependencies
+      run: |
+          rye sync
+    - name: Clean build directory
+      run: |
+        rye build --clean
+    - name: Build package
+      run: |
+        rye build
+    - name: Upload package
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+  publish:
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-22.04
+    needs: build
+    environment:
+      name: pypi
+      url: https://pypi.org/project/loguru/
+    permissions:
+      id-token: write
+    steps:
+    - name: Download package
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@release/v1

uyeia-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,62 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  tests:
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+        - ubuntu-22.04
+        python-version:
+        - '3.8'
+        - '3.9'
+        - '3.10'
+        - '3.11'
+        - '3.12'
+        - '3.13'
+        - pypy-3.10
+        allow-failure:
+        - false
+        include:
+        - os: ubuntu-20.04
+          python-version: '3.5'
+          allow-failure: false
+        - os: ubuntu-20.04
+          python-version: '3.6'
+          allow-failure: false
+        - os: windows-2022
+          python-version: '3.12'
+          allow-failure: false
+        - os: macos-13
+          python-version: '3.12'
+          allow-failure: false
+        - os: ubuntu-22.04
+          python-version: 3.14-dev
+          allow-failure: true
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+      env:
+        # Workaround for https://github.com/actions/setup-python/issues/866
+        PIP_TRUSTED_HOST: pypi.python.org pypi.org files.pythonhosted.org
+    - name: Install Rye
+      uses: eifinger/setup-rye@v4
+      with:
+        version: '0.43.0'
+    - name: Install dependencies
+      run: |
+        rye sync
+    - name: Run tests
+      run: |
+        rye run test
+      continue-on-error: ${{ matrix.allow-failure }}

uyeia-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv

uyeia-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12.6

uyeia-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: uyeia
+Version: 0.1.0
+Summary: Add your description here
+Author-email: dair <d.aires@easi.net>
+Requires-Python: >=3.8
+Requires-Dist: jsonschema>=4.23.0
+Description-Content-Type: text/markdown
+
+# uyeia
+
+Describe your project here.

uyeia-0.1.0/README.md

@@ -0,0 +1,3 @@
+# uyeia
+
+Describe your project here.

uyeia-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "uyeia"
+version = "0.1.0"
+description = "Add your description here"
+authors = [
+    { name = "dair", email = "d.aires@easi.net" }
+]
+dependencies = [
+    "jsonschema>=4.23.0",
+]
+readme = "README.md"
+requires-python = ">= 3.8"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.rye]
+managed = true
+dev-dependencies = [
+    "ruff>=0.9.6",
+    "pytest>=8.3.4",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/uyeia"]
+
+[tool.rye.scripts]
+format = 'ruff format'
+test = 'pytest'
+lint = 'ruff check src/uyeia'

uyeia-0.1.0/requirements-dev.lock

@@ -0,0 +1,35 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.
+attrs==25.1.0
+    # via jsonschema
+    # via referencing
+iniconfig==2.0.0
+    # via pytest
+jsonschema==4.23.0
+    # via uyeia
+jsonschema-specifications==2024.10.1
+    # via jsonschema
+packaging==24.2
+    # via pytest
+pluggy==1.5.0
+    # via pytest
+pytest==8.3.4
+referencing==0.36.2
+    # via jsonschema
+    # via jsonschema-specifications
+rpds-py==0.22.3
+    # via jsonschema
+    # via referencing
+ruff==0.9.6
+typing-extensions==4.12.2
+    # via referencing

uyeia-0.1.0/requirements.lock

@@ -0,0 +1,27 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.
+attrs==25.1.0
+    # via jsonschema
+    # via referencing
+jsonschema==4.23.0
+    # via uyeia
+jsonschema-specifications==2024.10.1
+    # via jsonschema
+referencing==0.36.2
+    # via jsonschema
+    # via jsonschema-specifications
+rpds-py==0.22.3
+    # via jsonschema
+    # via referencing
+typing-extensions==4.12.2
+    # via referencing

uyeia-0.1.0/src/uyeia/__init__.py

@@ -0,0 +1,278 @@
+import _pickle as cPickle
+import atexit
+import io
+import json
+import logging
+import os
+import pickle
+import threading
+from copy import deepcopy
+from datetime import datetime, timezone
+from typing import Literal
+
+import jsonschema
+
+from uyeia.exceptions import UYEIAConfigError
+from uyeia.serializers import errors_config_schema
+from uyeia.type import CommonStatus, Config, Status
+
+__all__ = ["Watcher", "set_global_config", "get_errors", "register", "reset"]
+
+_lock = threading.RLock()
+_uyeia_config: Config = Config()
+__uyeia_init__ = False
+__default_logger__ = logging.getLogger("__UYEIA__")
+__error_mapper__: dict[str, CommonStatus] = {}
+
+
+def set_global_config(config: Config):
+    global _uyeia_config
+    
+    if error := config.validate():
+        if __uyeia_init__ and config.error_config_location != _uyeia_config.error_config_location:
+            __default_logger__.warning(
+                "Error config location will be ignored. Global config has already been initialized."
+            )
+        raise UYEIAConfigError(f"Invalid UYEIA config: {error}")
+    
+    _uyeia_config = config
+    _init_uyeia_env()
+
+
+def _load_cache():
+    if os.path.exists(_uyeia_config.error_cache_location):
+        with io.open(_uyeia_config.error_cache_location, "rb") as db:
+            return cPickle.load(db)
+    return {}
+
+
+def _load_config():
+    path = _uyeia_config.error_config_location
+    if os.path.isfile(path) and os.access(path, os.R_OK):
+        try:
+            with io.open(path, "r") as db_file:
+                data = json.load(db_file)
+                jsonschema.validate(data, errors_config_schema)
+                return data
+        except (jsonschema.ValidationError, json.decoder.JSONDecodeError) as e:
+            raise UYEIAConfigError("Invalid errors config:", e)
+    
+    with io.open(path, "w") as db_file:
+        json.dump({}, db_file)
+    return {}
+
+
+def _init_uyeia_env():
+    global __uyeia_init__, __error_mapper__, __root__
+    
+    with _lock:
+        __error_mapper__ = _load_config()
+        __uyeia_init__ = True
+        __root__.load_cache()
+
+
+class Watcher:
+    def __init__(self, name: str | None = None, logger: logging.Logger | None = None):
+        self.logger = logger or __default_logger__
+        self.name = name or self.logger.name
+        self._cache: Status | None = None
+        
+        if not self.name:
+            raise ValueError("Name or logger is required for Watcher instance")
+        
+        global __root__
+        self.manager = __root__.register(self)
+        
+        if not __uyeia_init__:
+            _init_uyeia_env()
+
+    def __log(self, status: CommonStatus, config: Config):
+        level = config.status.get(status["status"])
+        if isinstance(level, str):
+            level = logging.getLevelName(level)
+
+        if level:
+            self.logger.log(level, status["message"])
+        else:
+            raise ValueError(
+                f"Invalid status: {status['status']}. Not in UYEIA config!"
+            )
+
+    def __is_empty_or_high(self, status: CommonStatus) -> bool:
+        levels = list(_uyeia_config.status.keys())
+        return not self._cache or levels.index(status["status"]) > levels.index(self._cache["status"])
+
+    def get_actual_status(self):
+        return self._cache
+
+    def register(self, error_code: str):
+        error = __error_mapper__.get(error_code)
+        if not error:
+            raise ValueError(f"Invalid error code: {error_code}. Not in UYEIA errors config!")
+        
+        if not _uyeia_config.disable_logging:
+            self.__log(error, _uyeia_config)
+        
+        with _lock:
+            if self.__is_empty_or_high(error):
+                if self._cache and self._cache["status"] != error["status"].upper():
+                    self.manager.delete_entry_cache(self.name, self._cache)
+                
+                self._cache = {
+                    "status": error["status"].upper(),
+                    "message": self.__add_timestamp(error["message"]),
+                    "solution": error.get("solution", _uyeia_config.default_solution),
+                    "escalation": 0,
+                }
+                self.manager.write_entry_cache(self.name, self._cache)
+
+    def release(self):
+        if not self._cache:
+            return
+        
+        with _lock:
+            self.manager.delete_entry_cache(self.name, self._cache)
+            self._cache = None
+
+    def __del__(self):
+        self.manager.unregister(self.name)
+
+    def __add_timestamp(self, error_log: str) -> str:
+        return f"{datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} - {error_log}"
+
+
+class Manager:
+    def __init__(self) -> None:
+        self.watcherDict: dict[str, Watcher] = {}
+        self.__cache = {}
+        
+        
+    def getWatcher(self, name: str | None = None, logger: logging.Logger | None = None):
+        if name and logger:
+            raise ValueError(
+                "Name or logger is required for Watcher instance! Not both."
+            )
+
+        rv = None
+        name = name or getattr(logger, "name", None)
+        if not name:
+            raise ValueError("Name or logger is required for Watcher instance")
+
+        with _lock:
+            if name in self.watcherDict:
+                rv = self.watcherDict[name]
+            else:
+                rv = Watcher(name, logger)
+        return rv
+    
+    def __find_data_watcher(self, watcher_name: str):
+        with _lock:
+            return next(
+                (
+                    status
+                    for entries in self.__cache.values()
+                    for name, status in entries.items()
+                    if name == watcher_name
+                ),
+                None,
+            )
+    
+    def delete_entry_cache(self, name: str, old_status: Status):
+        with _lock:
+            self.__cache.get(old_status["status"], {}).pop(name, None)
+        
+    def write_entry_cache(self, name: str, status: Status):
+        with _lock:
+            self.__cache.setdefault(status["status"], {})[name] = status
+
+    def get_cache(self):
+        return self.__cache
+
+    def set_cache(self, new_cache):
+        with _lock:
+            self.__cache = new_cache
+            for watcher in self.watcherDict.values():
+                watcher._cache = self.__find_data_watcher(watcher.name)
+
+    def load_cache(self):
+        with _lock:
+            self.__cache = _load_cache()
+
+    def clear_cache(self):
+        with _lock:
+            for watcher in self.watcherDict.values():
+                watcher.release()
+
+    def register(self, watcher: Watcher):
+        with _lock:
+            self.watcherDict[watcher.name] = watcher
+            watcher._cache = self.__find_data_watcher(watcher.name)
+            return self
+
+    def unregister(self, name: str):
+        with _lock:
+            self.watcherDict.pop(name, None)
+
+__root__ = Manager()
+
+
+def _persist_cache():
+    with _lock:
+        if __root__.get_cache():
+            with io.open(_uyeia_config.error_cache_location, "wb") as db:
+                cPickle.dump(__root__.get_cache(), db, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+def get_errors(mode: Literal["all", "hot", "cold"] = "all"):
+    cache = __root__.get_cache()
+    if not cache:
+        return None
+
+    if mode == "all":
+        return cache
+
+    if mode not in {"hot", "cold"}:
+        raise ValueError(f"Invalid mode: {mode}. Must be 'all', 'hot' or 'cold'!")
+
+    for status in (_uyeia_config.status.keys() if mode == "cold" else reversed(_uyeia_config.status.keys())):
+        if status in cache:
+            return next(iter(cache[status].values()), None)
+
+    return None
+
+
+def register(error_code: str):
+    __root__.getWatcher(logger=__default_logger__).register(error_code)
+
+
+def reset():
+    __root__.getWatcher(logger=__default_logger__).release()
+
+
+def escalate():
+    if _uyeia_config.disable_escalation:
+        __default_logger__.warning("Escalate function is disabled in config.")
+        return
+
+    cache = __root__.get_cache()
+    with _lock:
+        high_status = _uyeia_config.escalation_status or next(reversed(_uyeia_config.status))
+        first_status = next(iter(_uyeia_config.status))
+
+        new_cache = deepcopy(cache)
+        to_escalate = {}
+
+        for status, entries in cache.items():
+            if status not in {high_status, first_status}:
+                for name, entry in entries.items():
+                    entry["escalation"] += 1
+                    if entry["escalation"] >= _uyeia_config.max_escalation:
+                        to_escalate[name] = entry
+                        del new_cache[status][name]
+
+        new_cache.setdefault(high_status, {}).update(to_escalate)
+        __root__.set_cache(new_cache)
+
+
+atexit.register(_persist_cache)
+

uyeia-0.1.0/src/uyeia/exceptions.py

@@ -0,0 +1,2 @@
+class UYEIAConfigError(Exception):
+    pass

uyeia-0.1.0/src/uyeia/serializers.py

@@ -0,0 +1,32 @@
+import logging
+
+errors_config_schema = {
+    "type": "object",
+    "additionalProperties": {
+        "type": "object",
+        "properties": {
+            "status": {"type": "string"},
+            "message": {"type": "string"},
+            "solution": {"type": "string"},
+        },
+        "required": ["status", "message"],
+    },
+}
+
+
+def _validate_status_list(status_list: dict[str, int | str]):
+    try:
+        logger = logging.getLogger("root")
+        old_level = logger.getEffectiveLevel()
+        for status in status_list.values():
+            if not isinstance(status, (int, str)):
+                return f"Invalid status: {status}. Must be int or str!"
+            if isinstance(status, str):
+                logger.setLevel(status)
+            if isinstance(status, int):
+                if status not in [0, 10, 20, 30, 40, 50]:
+                    return f"Invalid logging level: {status}. Must be in [0, 10, 20, 30, 40, 50]!"
+        logger.setLevel(old_level)
+    except Exception as e:
+        logger.setLevel(old_level)
+        return str(e)

uyeia-0.1.0/src/uyeia/type.py

@@ -0,0 +1,64 @@
+import os
+from copy import deepcopy
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional, TypedDict
+
+from uyeia.serializers import _validate_status_list
+
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+class DefaultStatusEnum(str, Enum):
+    HEALTHY = "HEALTHY"
+    RESCUE = "RESCUE"
+    PENDING = "PENDING"
+    LIMITED = "LIMITED"
+    WARNING = "WARNING"
+
+
+class CommonStatus(TypedDict):
+    status: str
+    message: str
+    solution: str | None
+
+
+class Status(CommonStatus):
+    escalation: int
+
+
+@dataclass
+class Config:
+    status: dict[str, int | str] = field(
+        default_factory=lambda: {
+            "HEALTHY": 20,
+            "PENDING": 20,
+            "LIMITED": 30,
+            "WARNING": 40,
+            "RESCUE": 50,
+        }
+    )
+    escalation_status: str = DefaultStatusEnum.RESCUE.value
+    default_healthy: Optional[str] = DefaultStatusEnum.HEALTHY.value
+    default_solution: Optional[str] = "Contact your IT admin."
+    disable_escalation: bool = False
+    max_escalation: int = 5
+    disable_logging: bool = False
+    error_config_location: str = field(
+        default=os.path.join(ROOT_DIR, "uyeia.errors.json")
+    )
+    error_cache_location: str = os.path.join(ROOT_DIR, "errors_cache.db")
+
+    def __post_init__(self):
+        self.escalation_status = self.escalation_status.upper()
+        if self.default_healthy:
+            self.default_healthy = self.default_healthy.upper()
+
+        old_dict = deepcopy(self.status)
+        self.status.clear()
+        for status in old_dict:
+            self.status[status.upper()] = old_dict[status]
+
+    def validate(self):
+        if status_list := _validate_status_list(self.status):
+            return status_list

uyeia-0.1.0/tests/conftest.py

@@ -0,0 +1,35 @@
+
+
+import os
+from importlib import reload
+
+import pytest
+
+import uyeia
+
+
+@pytest.fixture(autouse=True)
+def cleanup_tests_folder():
+    def delete_file_config(path):
+        if os.path.exists(path):
+            os.remove(path)
+
+    
+    delete_file_config("./tests/uyeia.errors.json")
+    delete_file_config("./tests/errors_cache.db")
+    yield
+    delete_file_config("./tests/uyeia.errors.json")
+    delete_file_config("./tests/errors_cache.db")
+
+@pytest.fixture(autouse=True)
+def reload_package():
+    global uyeia
+    reload(uyeia)
+    yield
+    
+@pytest.fixture
+def sample_config():
+    return uyeia.Config(
+        error_config_location="./tests/samples/uyeia.errors.json",
+        error_cache_location="./tests/errors_cache.db",
+    )

uyeia-0.1.0/tests/samples/uyeia.errors.json

@@ -0,0 +1,17 @@
+{
+    "T404": {
+        "status": "WARNING",
+        "message": "Page not found",
+        "solution": "Check the URL and try again."
+    },
+    "T405": {
+        "status": "LIMITED",
+        "message": "Method not allowed",
+        "solution": "Check the HTTP method and try again."
+    },
+    "T501": {
+        "status": "LIMITED",
+        "message": "Not authorized",
+        "solution": "Check your credentials and try again."
+    }
+}

uyeia-0.1.0/tests/samples/uyeia.errors_missing_message.json

@@ -0,0 +1,6 @@
+{
+    "T404": {
+        "status": "WARNING",
+        "solution": "Check the URL and try again."
+    }
+}

uyeia-0.1.0/tests/samples/uyeia.errors_missing_status.json

@@ -0,0 +1,6 @@
+{
+    "T404": {
+        "message": "Page not found",
+        "solution": "Check the URL and try again."
+    }
+}

uyeia-0.1.0/tests/test_cache_operation.py

@@ -0,0 +1,11 @@
+import uyeia
+
+
+def test_read_cache_error():
+    config = uyeia.Config(
+        error_cache_location="./tests/samples/errors_cache.db",
+        error_config_location="./tests/samples/uyeia.errors.json",
+    )
+    uyeia.set_global_config(config)
+    errors = uyeia.get_errors()
+    assert errors and len(errors) == 2

uyeia-0.1.0/tests/test_config_validation.py

@@ -0,0 +1,45 @@
+import pytest
+
+import uyeia
+
+
+def test_error_config_missing_message():
+    config = uyeia.Config(
+        error_config_location="./tests/samples/uyeia.errors_missing_message.json",
+    )
+    with pytest.raises(uyeia.UYEIAConfigError):
+        uyeia.set_global_config(config)
+
+        uyeia.reset()
+
+
+def test_error_config_missing_status():
+    config = uyeia.Config(
+        error_config_location="./tests/samples/uyeia.errors_missing_status.json",
+    )
+    with pytest.raises(uyeia.UYEIAConfigError):
+        uyeia.set_global_config(config)
+
+        uyeia.reset()
+
+
+def test_global_config_unknow_logging_level_int():
+    config = uyeia.Config(
+        status={
+            "HEALTHY": -1,
+        }
+    )
+
+    with pytest.raises(uyeia.UYEIAConfigError):
+        uyeia.set_global_config(config)
+
+
+def test_global_config_unknow_logging_level_str():
+    config = uyeia.Config(
+        status={
+            "HEALTHY": "test",
+        }
+    )
+
+    with pytest.raises(uyeia.UYEIAConfigError):
+        uyeia.set_global_config(config)

uyeia-0.1.0/tests/test_errors_register.py

@@ -0,0 +1,54 @@
+import uyeia
+
+
+def test_errors_register(sample_config):
+    uyeia.set_global_config(sample_config)
+    watcher = uyeia.Watcher("test")
+    watcher.register("T404")
+
+    errors = uyeia.get_errors()
+    assert errors and isinstance(errors, dict) and "test" in errors.get("WARNING")  # type: ignore
+    
+    
+def test_high_errors_register(sample_config):
+    uyeia.set_global_config(sample_config)
+    watcher1 = uyeia.Watcher("test")
+    watcher2 = uyeia.Watcher("test2")
+    watcher1.register("T404")
+    watcher2.register("T405")
+
+    error = uyeia.get_errors("hot")
+    assert error and error["status"] == "WARNING"
+    
+    
+def test_low_errors_register(sample_config):
+    uyeia.set_global_config(sample_config)
+    watcher1 = uyeia.Watcher("test")
+    watcher2 = uyeia.Watcher("test2")
+    watcher1.register("T404")
+    watcher2.register("T405")
+
+    error = uyeia.get_errors("cold")
+    assert error and error["status"] == "LIMITED"
+    
+    
+def test_errors_override(sample_config):
+    uyeia.set_global_config(sample_config)
+    watcher1 = uyeia.Watcher("test")
+    watcher2 = uyeia.Watcher("test2")
+    watcher1.register("T404")
+    watcher2.register("T405")
+    watcher2.register("T501")
+
+    errors = uyeia.get_errors()
+    assert errors and isinstance(errors, dict) and len(errors["LIMITED"]) == 1  # type: ignore
+    
+def test_errors_same_level(sample_config):
+    uyeia.set_global_config(sample_config)
+    watcher1 = uyeia.Watcher("test1")
+    watcher2 = uyeia.Watcher("test2")
+    watcher1.register("T405")
+    watcher2.register("T501")
+
+    errors = uyeia.get_errors()
+    assert errors and isinstance(errors, dict) and len(errors["LIMITED"]) == 2  # type: ignore

uyeia-0.1.0/tests/test_escalation_operation.py

@@ -0,0 +1,28 @@
+import uyeia
+
+
+def test_error_escalation(sample_config):
+    sample_config.max_escalation = 1
+    uyeia.set_global_config(sample_config)
+    watcher = uyeia.Watcher("test")
+    watcher.register("T404")
+
+    uyeia.escalate()
+    errors = uyeia.get_errors()
+    assert errors and isinstance(errors, dict) and "test" in errors.get("RESCUE")  # type: ignore
+    
+    
+    
+def test_multi_errors_escalation(sample_config):
+    sample_config.max_escalation = 1
+    uyeia.set_global_config(sample_config)
+    watcher1 = uyeia.Watcher("test1")
+    watcher2 = uyeia.Watcher("test2")
+    watcher3 = uyeia.Watcher("test3")
+    watcher1.register("T404")
+    watcher2.register("T405")
+    watcher3.register("T501")
+
+    uyeia.escalate()
+    errors = uyeia.get_errors()
+    assert errors and isinstance(errors, dict) and len(errors["RESCUE"]) == 3  # type: ignore

uyeia-0.1.0/tests/test_files_creation.py

@@ -0,0 +1,26 @@
+import atexit
+import os
+
+import uyeia
+
+
+def test_errors_config_creation():
+    config = uyeia.Config(
+        error_config_location="./tests/uyeia.errors.json",
+    )
+    uyeia.set_global_config(config)
+    watcher = uyeia.Watcher("test")
+    watcher.release()
+    assert os.path.exists("./tests/uyeia.errors.json")
+
+
+def test_errors_cache_creation():
+    config = uyeia.Config(
+        error_cache_location="./tests/errors_cache.db",
+        error_config_location="./tests/samples/uyeia.errors.json",
+    )
+    uyeia.set_global_config(config)
+    watcher = uyeia.Watcher("test")
+    watcher.register("T404")
+    atexit._run_exitfuncs()
+    assert os.path.exists("./tests/errors_cache.db")