fred-core 2.0.1__tar.gz → 2.0.2__tar.gz

{fred_core-2.0.1 → fred_core-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-core
-Version: 2.0.1
+Version: 2.0.2
 Summary: Core shared utilities for Fred backends (config, storage, security, and runtime helpers).
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0

{fred_core-2.0.1 → fred_core-2.0.2}/fred_core/security/oidc.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import base64
+import getpass
 import json
 import logging
 import os
@@ -246,12 +247,15 @@ def _parse_user_uuid(user: KeycloakUser) -> UUID | None:
 def decode_jwt(token: str) -> KeycloakUser:
     """Decodes a JWT token using PyJWT and retrieves user information with rich diagnostics."""
     if not KEYCLOAK_ENABLED:
-        logger.debug("[SECURITY] Authentication is DISABLED. Returning a mock user.")
+        username = getpass.getuser()
+        logger.debug(
+            "[SECURITY] Authentication is DISABLED. Returning mock user: %s", username
+        )
         return KeycloakUser(
-            uid="admin",
-            username="admin",
+            uid=username,
+            username=username,
             roles=["admin"],
-            email="dev@localhost",
+            email=f"{username}@localhost",
             groups=["admins"],
         )
 

fred_core-2.0.2/fred_core/tests/common/test_lru_cache.py

@@ -0,0 +1,127 @@
+"""
+Offline unit tests for fred_core.common.lru_cache.ThreadSafeLRUCache.
+
+Covers get/set/delete/keys/clear/__contains__ and the LRU eviction policy.
+Thread-safety smoke: concurrent writers must not corrupt state.
+"""
+
+from __future__ import annotations
+
+import threading
+
+from fred_core.common.lru_cache import ThreadSafeLRUCache
+
+
+class TestThreadSafeLRUCacheBasicOps:
+    def test_get_missing_returns_none(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        assert cache.get("missing") is None
+
+    def test_set_and_get(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("k", 42)
+        assert cache.get("k") == 42
+
+    def test_overwrite_key(self) -> None:
+        cache: ThreadSafeLRUCache[str, str] = ThreadSafeLRUCache()
+        cache.set("k", "first")
+        cache.set("k", "second")
+        assert cache.get("k") == "second"
+
+    def test_delete_existing_returns_value(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("k", 99)
+        assert cache.delete("k") == 99
+        assert cache.get("k") is None
+
+    def test_delete_missing_returns_none(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        assert cache.delete("ghost") is None
+
+    def test_keys_empty(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        assert cache.keys() == []
+
+    def test_keys_returns_all_inserted(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("a", 1)
+        cache.set("b", 2)
+        assert set(cache.keys()) == {"a", "b"}
+
+    def test_keys_excludes_deleted(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("a", 1)
+        cache.set("b", 2)
+        cache.delete("a")
+        assert cache.keys() == ["b"]
+
+    def test_contains_present(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("k", 1)
+        assert "k" in cache
+
+    def test_contains_absent(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        assert "ghost" not in cache
+
+    def test_clear_removes_all(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache()
+        cache.set("a", 1)
+        cache.set("b", 2)
+        cache.clear()
+        assert cache.keys() == []
+        assert cache.get("a") is None
+
+
+class TestThreadSafeLRUCacheEviction:
+    def test_lru_evicts_oldest_when_full(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache(max_size=3)
+        cache.set("a", 1)
+        cache.set("b", 2)
+        cache.set("c", 3)
+        cache.set("d", 4)  # should evict "a"
+        assert cache.get("a") is None
+        assert cache.get("b") == 2
+        assert cache.get("c") == 3
+        assert cache.get("d") == 4
+
+    def test_get_promotes_to_recent(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache(max_size=3)
+        cache.set("a", 1)
+        cache.set("b", 2)
+        cache.set("c", 3)
+        cache.get("a")  # promote "a" — "b" is now the least recently used
+        cache.set("d", 4)  # should evict "b"
+        assert cache.get("b") is None
+        assert cache.get("a") == 1
+
+    def test_size_one_cache(self) -> None:
+        cache: ThreadSafeLRUCache[str, int] = ThreadSafeLRUCache(max_size=1)
+        cache.set("first", 1)
+        cache.set("second", 2)
+        assert cache.get("first") is None
+        assert cache.get("second") == 2
+
+
+class TestThreadSafeLRUCacheConcurrency:
+    def test_concurrent_writes_do_not_corrupt(self) -> None:
+        cache: ThreadSafeLRUCache[int, int] = ThreadSafeLRUCache(max_size=500)
+        errors: list[Exception] = []
+
+        def writer(start: int) -> None:
+            try:
+                for i in range(start, start + 100):
+                    cache.set(i, i * 2)
+            except Exception as exc:
+                errors.append(exc)
+
+        threads = [threading.Thread(target=writer, args=(i * 100,)) for i in range(5)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert not errors
+        # All written keys should either be present or have been evicted by LRU
+        for key in cache.keys():
+            assert cache.get(key) == key * 2

fred_core-2.0.2/fred_core/tests/kpi/test_noop_kpi_writer.py

@@ -0,0 +1,113 @@
+"""
+Offline unit tests for fred_core.kpi.noop_kpi_writer.NoOpKPIWriter.
+
+The NoOp writer is used in every unit and integration test that instruments
+code with the KPI API. If its contract is broken (timer doesn't yield a
+mutable Dims dict, timed() fails to call the function, etc.) every caller
+silently misbehaves.
+
+Focus: verify the contract is honoured, not that operations do nothing.
+"""
+
+from __future__ import annotations
+
+from fred_core.kpi.kpi_writer_structures import KPIActor
+from fred_core.kpi.noop_kpi_writer import NoOpKPIWriter
+
+ACTOR = KPIActor(type="system")
+
+
+class TestNoOpKPIWriterEmitPrimitives:
+    def setup_method(self) -> None:
+        self.writer = NoOpKPIWriter()
+
+    def test_emit_does_not_raise(self) -> None:
+        self.writer.emit(name="test.metric", type="counter", actor=ACTOR)
+
+    def test_count_does_not_raise(self) -> None:
+        self.writer.count("test.count", actor=ACTOR)
+
+    def test_gauge_does_not_raise(self) -> None:
+        self.writer.gauge("test.gauge", 3.14, actor=ACTOR)
+
+    def test_log_llm_does_not_raise(self) -> None:
+        self.writer.log_llm(model="gpt-4o", tokens=100, actor=ACTOR)
+
+    def test_doc_used_does_not_raise(self) -> None:
+        self.writer.doc_used(doc_id="d1", actor=ACTOR)
+
+    def test_api_call_does_not_raise(self) -> None:
+        self.writer.api_call(endpoint="/test", actor=ACTOR)
+
+    def test_api_error_does_not_raise(self) -> None:
+        self.writer.api_error(endpoint="/test", status=500, actor=ACTOR)
+
+    def test_record_error_does_not_raise(self) -> None:
+        self.writer.record_error(error="oops", actor=ACTOR)
+
+
+class TestNoOpKPIWriterTimerContract:
+    def setup_method(self) -> None:
+        self.writer = NoOpKPIWriter()
+
+    def test_timer_context_manager_enters_and_exits(self) -> None:
+        with self.writer.timer("test.timer", actor=ACTOR):
+            pass  # must not raise
+
+    def test_timer_yields_mutable_dims_dict(self) -> None:
+        with self.writer.timer("test.timer", actor=ACTOR) as d:
+            assert isinstance(d, dict)
+            d["agent_id"] = "test-agent"
+        # mutation must not raise
+
+    def test_timer_with_initial_dims_yields_copy(self) -> None:
+        initial = {"phase": "routing"}
+        with self.writer.timer("test.timer", dims=initial, actor=ACTOR) as d:
+            assert d["phase"] == "routing"
+            d["extra"] = "added"
+        assert "extra" not in initial  # original not mutated
+
+    def test_timer_without_dims_yields_empty_dict(self) -> None:
+        with self.writer.timer("test.timer", actor=ACTOR) as d:
+            assert d == {}
+
+    def test_timer_does_not_swallow_exceptions(self) -> None:
+        import pytest
+
+        with pytest.raises(ValueError, match="deliberate"):
+            with self.writer.timer("test.timer", actor=ACTOR):
+                raise ValueError("deliberate")
+
+
+class TestNoOpKPIWriterTimedDecorator:
+    def setup_method(self) -> None:
+        self.writer = NoOpKPIWriter()
+
+    def test_timed_calls_wrapped_function(self) -> None:
+        called: list[bool] = []
+
+        @self.writer.timed("test.timed", actor=ACTOR)
+        def my_fn() -> str:
+            called.append(True)
+            return "result"
+
+        result = my_fn()
+        assert result == "result"
+        assert called == [True]
+
+    def test_timed_propagates_return_value(self) -> None:
+        @self.writer.timed("test.timed", actor=ACTOR)
+        def add(a: int, b: int) -> int:
+            return a + b
+
+        assert add(3, 4) == 7
+
+    def test_timed_propagates_exceptions(self) -> None:
+        import pytest
+
+        @self.writer.timed("test.timed", actor=ACTOR)
+        def explode() -> None:
+            raise RuntimeError("boom")
+
+        with pytest.raises(RuntimeError, match="boom"):
+            explode()

fred_core-2.0.2/fred_core/tests/logs/test_memory_log_store.py

@@ -0,0 +1,287 @@
+"""
+Offline unit tests for fred_core.logs.memory_log_store.
+
+Covers:
+- _parse_since: relative (now-Xs/m/h) and absolute (epoch float string)
+- RamLogStore: append, bulk_index, capacity eviction, query filtering
+  (time window, level, logger, service, text_like, order, limit)
+"""
+
+from __future__ import annotations
+
+import time
+
+import pytest
+
+from fred_core.logs.log_structures import LogEventDTO, LogFilter, LogQuery
+from fred_core.logs.memory_log_store import RamLogStore, _parse_since
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _event(
+    msg: str,
+    *,
+    ts: float | None = None,
+    level: str = "INFO",
+    logger: str = "app",
+    service: str | None = None,
+) -> LogEventDTO:
+    return LogEventDTO(
+        ts=ts if ts is not None else time.time(),
+        level=level,
+        logger=logger,
+        file="test.py",
+        line=1,
+        msg=msg,
+        service=service,
+    )
+
+
+def _query(
+    *,
+    since: str = "now-1h",
+    until: str | None = None,
+    level_at_least: str | None = None,
+    logger_like: str | None = None,
+    service: str | None = None,
+    text_like: str | None = None,
+    limit: int = 500,
+    order: str = "asc",
+) -> LogQuery:
+    return LogQuery(
+        since=since,
+        until=until,
+        filters=LogFilter(
+            level_at_least=level_at_least,
+            logger_like=logger_like,
+            service=service,
+            text_like=text_like,
+        ),
+        limit=limit,
+        order=order,
+    )
+
+
+# ---------------------------------------------------------------------------
+# _parse_since
+# ---------------------------------------------------------------------------
+
+
+class TestParseSince:
+    def test_now_minus_seconds(self) -> None:
+        now = 1000.0
+        result = _parse_since("now-30s", now)
+        assert result == pytest.approx(970.0)
+
+    def test_now_minus_minutes(self) -> None:
+        now = 1000.0
+        result = _parse_since("now-2m", now)
+        assert result == pytest.approx(880.0)
+
+    def test_now_minus_hours(self) -> None:
+        now = 7200.0
+        result = _parse_since("now-1h", now)
+        assert result == pytest.approx(3600.0)
+
+    def test_epoch_float_string(self) -> None:
+        result = _parse_since("1234567890.5", 0.0)
+        assert result == pytest.approx(1234567890.5)
+
+    def test_unsupported_unit_raises(self) -> None:
+        with pytest.raises(ValueError, match="Unsupported"):
+            _parse_since("now-5d", 1000.0)
+
+
+# ---------------------------------------------------------------------------
+# RamLogStore — lifecycle
+# ---------------------------------------------------------------------------
+
+
+class TestRamLogStoreLifecycle:
+    def test_ensure_ready_does_not_raise(self) -> None:
+        store = RamLogStore()
+        store.ensure_ready()
+
+    def test_empty_store_returns_no_events(self) -> None:
+        store = RamLogStore()
+        result = store.query(_query())
+        assert result.events == []
+
+    def test_capacity_evicts_oldest(self) -> None:
+        store = RamLogStore(capacity=3)
+        base = (
+            time.time() - 300
+        )  # anchor in the past so all events are within the query window
+        for i in range(5):
+            store.index_event(_event(f"msg-{i}", ts=base + i))
+        result = store.query(_query(since="now-1h", limit=10))
+        msgs = [e.msg for e in result.events]
+        assert "msg-0" not in msgs
+        assert "msg-1" not in msgs
+        assert "msg-4" in msgs
+
+
+# ---------------------------------------------------------------------------
+# RamLogStore — writes
+# ---------------------------------------------------------------------------
+
+
+class TestRamLogStoreWrites:
+    def test_single_event_indexed(self) -> None:
+        store = RamLogStore()
+        store.index_event(_event("hello"))
+        result = store.query(_query())
+        assert len(result.events) == 1
+        assert result.events[0].msg == "hello"
+
+    def test_bulk_index(self) -> None:
+        store = RamLogStore()
+        events = [_event(f"msg-{i}") for i in range(5)]
+        store.bulk_index(events)
+        result = store.query(_query())
+        assert len(result.events) == 5
+
+    def test_bulk_index_empty_list_does_nothing(self) -> None:
+        store = RamLogStore()
+        store.bulk_index([])
+        result = store.query(_query())
+        assert result.events == []
+
+
+# ---------------------------------------------------------------------------
+# RamLogStore — query: time window
+# ---------------------------------------------------------------------------
+
+
+class TestRamLogStoreQueryTimeWindow:
+    def test_event_outside_window_excluded(self) -> None:
+        store = RamLogStore()
+        old_ts = time.time() - 7200  # 2 hours ago
+        store.index_event(_event("old", ts=old_ts))
+        result = store.query(_query(since="now-1h"))
+        assert result.events == []
+
+    def test_event_inside_window_included(self) -> None:
+        store = RamLogStore()
+        store.index_event(_event("recent", ts=time.time() - 60))
+        result = store.query(_query(since="now-1h"))
+        assert len(result.events) == 1
+
+    def test_until_excludes_future_events(self) -> None:
+        store = RamLogStore()
+        past = time.time() - 300
+        future = time.time() + 300
+        store.index_event(_event("past", ts=past))
+        store.index_event(_event("future", ts=future))
+        result = store.query(_query(since="now-1h", until="now-0s"))
+        msgs = [e.msg for e in result.events]
+        assert "past" in msgs
+        assert "future" not in msgs
+
+
+# ---------------------------------------------------------------------------
+# RamLogStore — query: filters
+# ---------------------------------------------------------------------------
+
+
+class TestRamLogStoreQueryFilters:
+    def _populated_store(self) -> RamLogStore:
+        store = RamLogStore()
+        now = time.time() - 10
+        store.bulk_index(
+            [
+                _event(
+                    "debug msg",
+                    ts=now,
+                    level="DEBUG",
+                    logger="app.debug",
+                    service="svc-a",
+                ),
+                _event(
+                    "info msg", ts=now, level="INFO", logger="app.info", service="svc-a"
+                ),
+                _event(
+                    "warn msg",
+                    ts=now,
+                    level="WARNING",
+                    logger="app.warn",
+                    service="svc-b",
+                ),
+                _event(
+                    "error msg",
+                    ts=now,
+                    level="ERROR",
+                    logger="app.error",
+                    service="svc-b",
+                ),
+            ]
+        )
+        return store
+
+    def test_level_at_least_warning_excludes_debug_info(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query(level_at_least="WARNING"))
+        levels = {e.level for e in result.events}
+        assert "DEBUG" not in levels
+        assert "INFO" not in levels
+        assert "WARNING" in levels
+        assert "ERROR" in levels
+
+    def test_level_at_least_error_keeps_only_error(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query(level_at_least="ERROR"))
+        assert all(e.level == "ERROR" for e in result.events)
+
+    def test_logger_like_substring_match(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query(logger_like="warn"))
+        assert all("warn" in e.logger for e in result.events)
+
+    def test_service_exact_match(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query(service="svc-a"))
+        assert all(e.service == "svc-a" for e in result.events)
+
+    def test_text_like_case_insensitive(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query(text_like="WARN"))
+        assert len(result.events) == 1
+        assert result.events[0].msg == "warn msg"
+
+    def test_no_filters_returns_all(self) -> None:
+        store = self._populated_store()
+        result = store.query(_query())
+        assert len(result.events) == 4
+
+
+# ---------------------------------------------------------------------------
+# RamLogStore — query: ordering and limit
+# ---------------------------------------------------------------------------
+
+
+class TestRamLogStoreQueryOrderAndLimit:
+    def _store_with_timestamps(self) -> RamLogStore:
+        store = RamLogStore()
+        base = time.time() - 100
+        store.bulk_index([_event(f"msg-{i}", ts=base + i) for i in range(5)])
+        return store
+
+    def test_asc_order(self) -> None:
+        store = self._store_with_timestamps()
+        result = store.query(_query(order="asc"))
+        ts_list = [e.ts for e in result.events]
+        assert ts_list == sorted(ts_list)
+
+    def test_desc_order(self) -> None:
+        store = self._store_with_timestamps()
+        result = store.query(_query(order="desc"))
+        ts_list = [e.ts for e in result.events]
+        assert ts_list == sorted(ts_list, reverse=True)
+
+    def test_limit_truncates_results(self) -> None:
+        store = self._store_with_timestamps()
+        result = store.query(_query(limit=3))
+        assert len(result.events) == 3

{fred_core-2.0.1 → fred_core-2.0.2}/fred_core/tests/security/test_authorization.py

@@ -12,7 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from fred_core.security.authorization import Action, Resource
+import pytest
+
+from fred_core.security.authorization import (
+    Action,
+    Resource,
+    authorize_or_raise,
+    is_authorized,
+    require_admin,
+)
+from fred_core.security.models import AuthorizationError
 from fred_core.security.rbac import RBACProvider
 from fred_core.security.structure import KeycloakUser
 
@@ -131,3 +140,37 @@ class TestRBACProvider:
         assert self.rbac.is_authorized(multi_role_user, Action.CREATE, Resource.TAGS)
         assert self.rbac.is_authorized(multi_role_user, Action.DELETE, Resource.TAGS)
         assert self.rbac.is_authorized(multi_role_user, Action.READ, Resource.TAGS)
+
+
+def _admin() -> KeycloakUser:
+    return KeycloakUser(uid="a1", username="admin", email="a@t.com", roles=["admin"])
+
+
+def _viewer() -> KeycloakUser:
+    return KeycloakUser(uid="v1", username="viewer", email="v@t.com", roles=["viewer"])
+
+
+class TestIsAuthorized:
+    def test_admin_is_authorized(self) -> None:
+        assert is_authorized(_admin(), Action.READ, Resource.TAGS) is True
+
+    def test_viewer_denied_create(self) -> None:
+        assert is_authorized(_viewer(), Action.CREATE, Resource.TAGS) is False
+
+
+class TestAuthorizeOrRaise:
+    def test_authorized_does_not_raise(self) -> None:
+        authorize_or_raise(_admin(), Action.READ, Resource.TAGS)
+
+    def test_unauthorized_raises_authorization_error(self) -> None:
+        with pytest.raises(AuthorizationError):
+            authorize_or_raise(_viewer(), Action.CREATE, Resource.TAGS)
+
+
+class TestRequireAdmin:
+    def test_admin_passes(self) -> None:
+        require_admin(_admin())
+
+    def test_non_admin_raises(self) -> None:
+        with pytest.raises(AuthorizationError):
+            require_admin(_viewer())