maximem-synap-integrations-common 0.1.0__tar.gz

maximem_synap_integrations_common-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: maximem-synap-integrations-common
+Version: 0.1.0
+Summary: Shared utilities for Synap framework integrations
+Author: Synap Team
+License-Expression: Apache-2.0
+Keywords: synap,memory,ai,agents,integrations
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: maximem-synap>=0.2.0
+Requires-Dist: nest_asyncio>=1.5
+Provides-Extra: testing
+Requires-Dist: pytest>=7.0; extra == "testing"
+Requires-Dist: pytest-asyncio>=0.21; extra == "testing"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+
+# maximem-synap-integrations-common
+
+Shared utilities used across Synap framework integrations (LangChain, LlamaIndex,
+CrewAI, Haystack, AutoGen, Google ADK, OpenAI Agents, Pydantic AI, Semantic
+Kernel).
+
+This package exists so that every integration converges on one implementation
+of:
+
+- `run_async` — the sync-to-async bridge required because most agent
+  frameworks expose **sync** protocol methods while the Synap SDK is async.
+- `SynapIntegrationError` + `wrap_sdk_errors` — uniform error handling so
+  integrations don't silently swallow SDK failures.
+- `default_scope` — consistent scope-path construction
+  (`/<customer_id>/<user_id>` vs `/<user_id>`).
+- `synap_integrations_common.testing` — shared pytest fixtures and response
+  factories, previously duplicated across each integration's `_helpers.py`.
+
+Not intended for direct end-user use. Pin as a runtime dependency of each
+integration package.

maximem_synap_integrations_common-0.1.0/README.md

@@ -0,0 +1,20 @@
+# maximem-synap-integrations-common
+
+Shared utilities used across Synap framework integrations (LangChain, LlamaIndex,
+CrewAI, Haystack, AutoGen, Google ADK, OpenAI Agents, Pydantic AI, Semantic
+Kernel).
+
+This package exists so that every integration converges on one implementation
+of:
+
+- `run_async` — the sync-to-async bridge required because most agent
+  frameworks expose **sync** protocol methods while the Synap SDK is async.
+- `SynapIntegrationError` + `wrap_sdk_errors` — uniform error handling so
+  integrations don't silently swallow SDK failures.
+- `default_scope` — consistent scope-path construction
+  (`/<customer_id>/<user_id>` vs `/<user_id>`).
+- `synap_integrations_common.testing` — shared pytest fixtures and response
+  factories, previously duplicated across each integration's `_helpers.py`.
+
+Not intended for direct end-user use. Pin as a runtime dependency of each
+integration package.

maximem_synap_integrations_common-0.1.0/maximem_synap_integrations_common.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: maximem-synap-integrations-common
+Version: 0.1.0
+Summary: Shared utilities for Synap framework integrations
+Author: Synap Team
+License-Expression: Apache-2.0
+Keywords: synap,memory,ai,agents,integrations
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: maximem-synap>=0.2.0
+Requires-Dist: nest_asyncio>=1.5
+Provides-Extra: testing
+Requires-Dist: pytest>=7.0; extra == "testing"
+Requires-Dist: pytest-asyncio>=0.21; extra == "testing"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+
+# maximem-synap-integrations-common
+
+Shared utilities used across Synap framework integrations (LangChain, LlamaIndex,
+CrewAI, Haystack, AutoGen, Google ADK, OpenAI Agents, Pydantic AI, Semantic
+Kernel).
+
+This package exists so that every integration converges on one implementation
+of:
+
+- `run_async` — the sync-to-async bridge required because most agent
+  frameworks expose **sync** protocol methods while the Synap SDK is async.
+- `SynapIntegrationError` + `wrap_sdk_errors` — uniform error handling so
+  integrations don't silently swallow SDK failures.
+- `default_scope` — consistent scope-path construction
+  (`/<customer_id>/<user_id>` vs `/<user_id>`).
+- `synap_integrations_common.testing` — shared pytest fixtures and response
+  factories, previously duplicated across each integration's `_helpers.py`.
+
+Not intended for direct end-user use. Pin as a runtime dependency of each
+integration package.

maximem_synap_integrations_common-0.1.0/maximem_synap_integrations_common.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+maximem_synap_integrations_common.egg-info/PKG-INFO
+maximem_synap_integrations_common.egg-info/SOURCES.txt
+maximem_synap_integrations_common.egg-info/dependency_links.txt
+maximem_synap_integrations_common.egg-info/requires.txt
+maximem_synap_integrations_common.egg-info/top_level.txt
+synap_integrations_common/__init__.py
+synap_integrations_common/async_bridge.py
+synap_integrations_common/errors.py
+synap_integrations_common/scope.py
+synap_integrations_common/testing.py
+tests/test_async_bridge.py
+tests/test_errors.py
+tests/test_scope.py

maximem_synap_integrations_common-0.1.0/maximem_synap_integrations_common.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maximem_synap_integrations_common-0.1.0/maximem_synap_integrations_common.egg-info/requires.txt

@@ -0,0 +1,10 @@
+maximem-synap>=0.2.0
+nest_asyncio>=1.5
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21
+
+[testing]
+pytest>=7.0
+pytest-asyncio>=0.21

maximem_synap_integrations_common-0.1.0/maximem_synap_integrations_common.egg-info/top_level.txt

@@ -0,0 +1 @@
+synap_integrations_common

maximem_synap_integrations_common-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "maximem-synap-integrations-common"
+version = "0.1.0"
+description = "Shared utilities for Synap framework integrations"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [
+    {name = "Synap Team"}
+]
+keywords = ["synap", "memory", "ai", "agents", "integrations"]
+
+dependencies = [
+    "maximem-synap>=0.2.0",
+    "nest_asyncio>=1.5",
+]
+
+[project.optional-dependencies]
+testing = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["synap_integrations_common*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

maximem_synap_integrations_common-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maximem_synap_integrations_common-0.1.0/synap_integrations_common/__init__.py

@@ -0,0 +1,17 @@
+"""Shared utilities for Synap framework integrations."""
+
+from synap_integrations_common.async_bridge import run_async
+from synap_integrations_common.errors import (
+    SynapIntegrationError,
+    wrap_sdk_errors,
+    wrap_sdk_errors_async,
+)
+from synap_integrations_common.scope import default_scope
+
+__all__ = [
+    "run_async",
+    "SynapIntegrationError",
+    "wrap_sdk_errors",
+    "wrap_sdk_errors_async",
+    "default_scope",
+]

maximem_synap_integrations_common-0.1.0/synap_integrations_common/async_bridge.py

@@ -0,0 +1,59 @@
+"""Sync-to-async bridge for framework integrations.
+
+Most agent frameworks (CrewAI StorageBackend, Haystack @component.run,
+LangChain's sync retriever/tool protocols, Semantic Kernel kernel_function,
+Google ADK FunctionTool) expose synchronous entry points. The Synap SDK is
+async-first. Integrations therefore need to run a coroutine from sync code.
+
+The naive approach — `asyncio.run()` — fails when the caller is itself
+running inside an event loop (e.g. Haystack pipelines driven by an async
+runner). We fall back to ``nest_asyncio`` in that case, but:
+
+- ``nest_asyncio.apply()`` patches the running loop class globally. We call
+  it at most once per loop via a module-level sentinel so we don't re-patch
+  on every call.
+- If the caller is already async they should ``await`` the SDK directly;
+  ``run_async`` is the last-resort bridge, not the primary API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Awaitable, TypeVar
+
+T = TypeVar("T")
+
+_patched_loops: "set[int]" = set()
+
+
+def run_async(coro: Awaitable[T]) -> T:
+    """Run an awaitable from a synchronous context.
+
+    - When no event loop is running, uses ``asyncio.run``.
+    - When a loop is already running, applies ``nest_asyncio`` to that loop
+      (once) and drives the coroutine to completion on it.
+
+    Prefer awaiting the underlying async API directly whenever the caller
+    can — this helper exists only to satisfy sync framework protocols.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)  # type: ignore[arg-type]
+
+    loop_id = id(loop)
+    if loop_id not in _patched_loops:
+        import nest_asyncio
+
+        nest_asyncio.apply(loop)
+        _patched_loops.add(loop_id)
+
+    return loop.run_until_complete(coro)  # type: ignore[arg-type]
+
+
+def _reset_patched_loops_for_tests() -> None:
+    """Test-only hook to clear the patched-loop registry."""
+    _patched_loops.clear()
+
+
+__all__ = ["run_async"]

maximem_synap_integrations_common-0.1.0/synap_integrations_common/errors.py

@@ -0,0 +1,112 @@
+"""Uniform error handling for Synap integrations.
+
+The pre-existing integrations were inconsistent: some swallowed every SDK
+exception as a warning (silent ingestion failures in Haystack, silent
+save failures in CrewAI), others let raw SDK exceptions propagate into
+framework internals with no context about which operation failed.
+
+This module gives every integration one shape:
+
+    with wrap_sdk_errors("crewai.asave", logger, record_id=record.id):
+        await sdk.memories.create(...)
+
+- On success: pass-through.
+- On failure: log once with the operation name and structured context,
+  then re-raise as ``SynapIntegrationError`` (preserving the original via
+  ``__cause__``).
+
+Callers decide whether to catch ``SynapIntegrationError``; the contract is
+that integration code NEVER silently discards an SDK failure.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, Iterator, AsyncIterator, Optional
+
+
+class SynapIntegrationError(RuntimeError):
+    """Raised when a Synap SDK call fails inside an integration.
+
+    The original exception is available via ``__cause__``. The ``operation``
+    and ``context`` attributes are populated so framework-level error
+    handlers can log structured data without re-parsing messages.
+    """
+
+    def __init__(
+        self,
+        operation: str,
+        message: str,
+        context: Optional[dict] = None,
+    ) -> None:
+        super().__init__(f"{operation}: {message}")
+        self.operation = operation
+        self.context = context or {}
+
+
+def _log_and_wrap(
+    operation: str,
+    logger: logging.Logger,
+    exc: BaseException,
+    context: dict,
+) -> SynapIntegrationError:
+    logger.error(
+        "Synap integration call failed: op=%s error=%s context=%s",
+        operation,
+        exc,
+        context,
+        exc_info=True,
+    )
+    wrapped = SynapIntegrationError(operation, str(exc), context)
+    wrapped.__cause__ = exc
+    return wrapped
+
+
+@contextmanager
+def wrap_sdk_errors(
+    operation: str,
+    logger: logging.Logger,
+    **context: Any,
+) -> Iterator[None]:
+    """Sync context manager that wraps SDK exceptions.
+
+    Example::
+
+        with wrap_sdk_errors("haystack.writer.run", logger, count=len(docs)):
+            run_async(sdk.memories.create(...))
+    """
+    try:
+        yield
+    except SynapIntegrationError:
+        raise
+    except Exception as exc:  # noqa: BLE001 — intentional broad catch at boundary
+        raise _log_and_wrap(operation, logger, exc, context) from exc
+
+
+@asynccontextmanager
+async def wrap_sdk_errors_async(
+    operation: str,
+    logger: logging.Logger,
+    **context: Any,
+) -> AsyncIterator[None]:
+    """Async variant of :func:`wrap_sdk_errors`.
+
+    Example::
+
+        async with wrap_sdk_errors_async("crewai.asave", logger, id=rec.id):
+            await sdk.memories.create(...)
+    """
+    try:
+        yield
+    except SynapIntegrationError:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        raise _log_and_wrap(operation, logger, exc, context) from exc
+
+
+__all__ = [
+    "SynapIntegrationError",
+    "wrap_sdk_errors",
+    "wrap_sdk_errors_async",
+]

maximem_synap_integrations_common-0.1.0/synap_integrations_common/scope.py

@@ -0,0 +1,35 @@
+"""Scope path construction for Synap integrations.
+
+Synap's scope chain narrows from WORLD -> CLIENT -> CUSTOMER -> USER. When
+an integration caches a record locally (CrewAI) or annotates a framework
+record with its origin scope (LlamaIndex, LangChain), it needs a consistent
+path string.
+
+Historically the integrations did this ad-hoc: llamaindex retriever built
+one path, llamaindex memory built another; CrewAI defaulted to ``/user``
+while LangChain left it blank. This module is the single source of truth.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def default_scope(user_id: str, customer_id: Optional[str] = None) -> str:
+    """Return the canonical default scope path for a record.
+
+    - ``default_scope("alice")`` -> ``"/alice"``
+    - ``default_scope("alice", "acme")`` -> ``"/acme/alice"``
+    - ``default_scope("alice", "")`` -> ``"/alice"`` (empty string treated as absent)
+
+    ``user_id`` is required; an empty ``user_id`` raises ``ValueError``
+    because a record with no user scope is ambiguous in Synap's model.
+    """
+    if not user_id:
+        raise ValueError("default_scope requires a non-empty user_id")
+    if customer_id:
+        return f"/{customer_id}/{user_id}"
+    return f"/{user_id}"
+
+
+__all__ = ["default_scope"]

maximem_synap_integrations_common-0.1.0/synap_integrations_common/testing.py

@@ -0,0 +1,184 @@
+"""Shared pytest fixtures and response factories for integration tests.
+
+Each integration previously kept its own ``tests/_helpers.py`` that
+re-implemented the same ``mock_sdk`` fixture and the same
+``make_fact`` / ``make_preference`` / ``make_episode`` / etc. factories.
+That duplication drifted over time and none of the helpers exercised
+SDK-failure paths.
+
+To use in an integration's ``tests/conftest.py``::
+
+    from synap_integrations_common.testing import (
+        mock_sdk,              # pytest fixture — re-export
+        failing_sdk,           # pytest fixture — SDK whose calls raise
+        make_unified_response,
+        make_fact,
+    )
+
+The individual ``make_*`` helpers are plain functions so tests can build
+custom response payloads without monkey-patching fixtures.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+try:
+    from maximem_synap import MaximemSynapSDK
+    from maximem_synap.models.context import (
+        ContextForPromptResponse,
+        Emotion,
+        Episode,
+        Fact,
+        Preference,
+        ResponseMetadata,
+        TemporalEvent,
+        UnifiedContextResponse,
+    )
+except ImportError:  # pragma: no cover — surfaces clearly in dev setups
+    MaximemSynapSDK = None  # type: ignore[assignment]
+
+
+def make_metadata(**overrides):
+    defaults = {
+        "correlation_id": "test-corr",
+        "ttl_seconds": 300,
+        "source": "cloud",
+        "retrieved_at": datetime.now(timezone.utc),
+    }
+    defaults.update(overrides)
+    return ResponseMetadata(**defaults)
+
+
+def make_fact(id="f1", content="User is an engineer", confidence=0.9):
+    return Fact(
+        id=id,
+        content=content,
+        confidence=confidence,
+        source="test",
+        extracted_at=datetime.now(timezone.utc),
+    )
+
+
+def make_preference(id="p1", content="Prefers dark mode", strength=0.8):
+    return Preference(
+        id=id,
+        category="general",
+        content=content,
+        strength=strength,
+        extracted_at=datetime.now(timezone.utc),
+    )
+
+
+def make_episode(id="e1", summary="Had a support call", significance=0.7):
+    return Episode(
+        id=id,
+        summary=summary,
+        occurred_at=datetime.now(timezone.utc),
+        significance=significance,
+    )
+
+
+def make_emotion(id="em1", emotion_type="frustrated", context="Long wait", intensity=0.6):
+    return Emotion(
+        id=id,
+        emotion_type=emotion_type,
+        intensity=intensity,
+        detected_at=datetime.now(timezone.utc),
+        context=context,
+    )
+
+
+def make_temporal_event(id="t1", content="Trial expires April 15"):
+    return TemporalEvent(
+        id=id,
+        content=content,
+        event_date=datetime.now(timezone.utc),
+        temporal_category="temporal_fact",
+        temporal_confidence=0.9,
+    )
+
+
+def make_unified_response(**overrides):
+    defaults = {
+        "facts": [make_fact()],
+        "preferences": [make_preference()],
+        "scope_map": {"f1": "user", "p1": "user"},
+        "scopes_queried": ["user"],
+        "total_items": 2,
+        "formatted_context": "## User Context\n### Facts\n- User is an engineer",
+        "metadata": make_metadata(),
+    }
+    defaults.update(overrides)
+    return UnifiedContextResponse(**defaults)
+
+
+def _build_mock_sdk():
+    sdk = MagicMock(spec=MaximemSynapSDK)
+    sdk.instance_id = "test-instance"
+    sdk._initialized = True
+
+    sdk.fetch = AsyncMock(return_value=make_unified_response())
+
+    sdk.conversation = MagicMock()
+    sdk.conversation.record_message = AsyncMock(
+        return_value={
+            "message_id": "msg-001",
+            "conversation_id": "conv-1",
+            "session_id": "sess-1",
+            "recorded_at": datetime.now(timezone.utc).isoformat(),
+        }
+    )
+    sdk.conversation.context = MagicMock()
+    sdk.conversation.context.get_context_for_prompt = AsyncMock(
+        return_value=ContextForPromptResponse(
+            formatted_context="Recent conversation summary",
+            available=True,
+        )
+    )
+
+    sdk.memories = MagicMock()
+    create_result = MagicMock()
+    create_result.ingestion_id = "ing-001"
+    sdk.memories.create = AsyncMock(return_value=create_result)
+
+    sdk.cache = MagicMock()
+    return sdk
+
+
+@pytest.fixture
+def mock_sdk():
+    """SDK mock pre-wired with successful default responses."""
+    return _build_mock_sdk()
+
+
+@pytest.fixture
+def failing_sdk():
+    """SDK mock whose every async method raises ``RuntimeError("sdk boom")``.
+
+    Use in tests that assert integrations surface SDK failures instead of
+    silently swallowing them.
+    """
+    sdk = _build_mock_sdk()
+    err = RuntimeError("sdk boom")
+    sdk.fetch = AsyncMock(side_effect=err)
+    sdk.conversation.record_message = AsyncMock(side_effect=err)
+    sdk.conversation.context.get_context_for_prompt = AsyncMock(side_effect=err)
+    sdk.memories.create = AsyncMock(side_effect=err)
+    return sdk
+
+
+__all__ = [
+    "make_metadata",
+    "make_fact",
+    "make_preference",
+    "make_episode",
+    "make_emotion",
+    "make_temporal_event",
+    "make_unified_response",
+    "mock_sdk",
+    "failing_sdk",
+]

maximem_synap_integrations_common-0.1.0/tests/test_async_bridge.py

@@ -0,0 +1,64 @@
+import asyncio
+
+import pytest
+
+from synap_integrations_common.async_bridge import (
+    _reset_patched_loops_for_tests,
+    run_async,
+)
+
+
+@pytest.fixture(autouse=True)
+def _reset_registry():
+    _reset_patched_loops_for_tests()
+    yield
+    _reset_patched_loops_for_tests()
+
+
+def test_run_async_no_running_loop_uses_asyncio_run():
+    async def work():
+        await asyncio.sleep(0)
+        return 42
+
+    assert run_async(work()) == 42
+
+
+def test_run_async_propagates_exceptions():
+    async def boom():
+        raise ValueError("nope")
+
+    with pytest.raises(ValueError, match="nope"):
+        run_async(boom())
+
+
+def test_run_async_from_within_running_loop():
+    """Simulate the frameworks-in-async-context path.
+
+    When a running loop is present we apply nest_asyncio and drive the
+    coroutine on the existing loop. This exercises the registry branch.
+    """
+
+    async def outer():
+        async def inner():
+            await asyncio.sleep(0)
+            return "inner-ok"
+
+        # Call the sync bridge from within an async context — this is the
+        # scenario frameworks like Haystack create.
+        return run_async(inner())
+
+    assert asyncio.run(outer()) == "inner-ok"
+
+
+def test_run_async_patches_each_loop_once():
+    """Second invocation on the same loop must not re-patch."""
+
+    async def outer():
+        async def inner(v):
+            return v
+
+        first = run_async(inner("a"))
+        second = run_async(inner("b"))
+        return first, second
+
+    assert asyncio.run(outer()) == ("a", "b")

maximem_synap_integrations_common-0.1.0/tests/test_errors.py

@@ -0,0 +1,72 @@
+import logging
+
+import pytest
+
+from synap_integrations_common.errors import (
+    SynapIntegrationError,
+    wrap_sdk_errors,
+    wrap_sdk_errors_async,
+)
+
+
+def test_sync_wrapper_passthrough():
+    logger = logging.getLogger("t")
+    with wrap_sdk_errors("op", logger):
+        result = 1 + 1
+    assert result == 2
+
+
+def test_sync_wrapper_wraps_and_preserves_cause():
+    logger = logging.getLogger("t")
+    original = RuntimeError("underlying")
+
+    with pytest.raises(SynapIntegrationError) as exc_info:
+        with wrap_sdk_errors("crewai.asave", logger, record_id="r1"):
+            raise original
+
+    err = exc_info.value
+    assert err.operation == "crewai.asave"
+    assert err.context == {"record_id": "r1"}
+    assert err.__cause__ is original
+    assert "crewai.asave" in str(err)
+
+
+def test_sync_wrapper_does_not_double_wrap():
+    logger = logging.getLogger("t")
+    inner = SynapIntegrationError("inner.op", "already wrapped")
+
+    with pytest.raises(SynapIntegrationError) as exc_info:
+        with wrap_sdk_errors("outer.op", logger):
+            raise inner
+
+    assert exc_info.value is inner
+
+
+def test_sync_wrapper_logs_error(caplog):
+    logger = logging.getLogger("synap.test")
+    with caplog.at_level(logging.ERROR, logger="synap.test"):
+        with pytest.raises(SynapIntegrationError):
+            with wrap_sdk_errors("op", logger, key="val"):
+                raise RuntimeError("boom")
+
+    assert any("op=op" in rec.message for rec in caplog.records)
+    assert any("key" in rec.message for rec in caplog.records)
+
+
+@pytest.mark.asyncio
+async def test_async_wrapper_wraps():
+    logger = logging.getLogger("t")
+    with pytest.raises(SynapIntegrationError) as exc_info:
+        async with wrap_sdk_errors_async("haystack.writer", logger, count=3):
+            raise RuntimeError("ingest failed")
+
+    assert exc_info.value.operation == "haystack.writer"
+    assert exc_info.value.context == {"count": 3}
+    assert isinstance(exc_info.value.__cause__, RuntimeError)
+
+
+@pytest.mark.asyncio
+async def test_async_wrapper_passthrough():
+    logger = logging.getLogger("t")
+    async with wrap_sdk_errors_async("op", logger):
+        pass  # no error -> no raise

maximem_synap_integrations_common-0.1.0/tests/test_scope.py

@@ -0,0 +1,23 @@
+import pytest
+
+from synap_integrations_common.scope import default_scope
+
+
+def test_user_only():
+    assert default_scope("alice") == "/alice"
+
+
+def test_user_and_customer():
+    assert default_scope("alice", "acme") == "/acme/alice"
+
+
+def test_empty_customer_treated_as_absent():
+    assert default_scope("alice", "") == "/alice"
+    assert default_scope("alice", None) == "/alice"
+
+
+def test_empty_user_id_raises():
+    with pytest.raises(ValueError):
+        default_scope("")
+    with pytest.raises(ValueError):
+        default_scope("", "acme")