arena-pytest 5.2.0__py3-none-win_amd64.whl

arena_pytest/__init__.py

@@ -0,0 +1,178 @@
+from arena_pytest.ffi._ffi import (
+    ArenaBindingError,
+    ArenaLogLevel,
+    ArenaNativeLib,
+    register_dispatcher_logging_target_for_logger,
+    unregister_dispatcher_logging_target,
+)
+from arena_pytest.arena import (
+    OpenArena,
+    arena,
+    arena_ffi,
+    closed_arena,
+)
+from arena_pytest.closed_arena import ClosedArena
+from arena_pytest.match import Match, MatchBuilder
+from arena_pytest.exec.containerized_component import (
+    ContainerizedComponent,
+    ContainerizedComponentBuilder,
+)
+from arena_pytest.exec.executable_component import (
+    BuildTool,
+    ExecutableComponent,
+    ExecutableComponentBuilder,
+)
+from arena_pytest.playbook import (
+    ActiveHttpPlaybook,
+    ActiveLocalstackPlaybook,
+    ActiveMssqlPlaybook,
+    ActivePlaybook,
+    ManagedPlaybook,
+    Playbook,
+    UnmanagedPlaybook,
+    playbook,
+)
+from arena_pytest.dep.http import (
+    ActiveHttpPlaybookBuilder,
+    HttpDependency,
+    HttpDependencyBuilder,
+    HttpHeaderPattern,
+    HttpMappingBuilder,
+    HttpMappingExpect,
+    HttpPlaybookBuilder,
+    HttpResponse,
+    HttpSequenceBuilder,
+    ManagedHttpPlaybook,
+    created,
+    no_content,
+    ok,
+    ok_json,
+    server_error,
+    status,
+)
+from arena_pytest.dep.kafka import (
+    KAFKA_INTERNAL_DOCKER_PORT,
+    KafkaDependency,
+    KafkaDependencyBuilder,
+    KafkaFlavor,
+)
+from arena_pytest.dep.localstack import (
+    LOCALSTACK_DEFAULT_ACCOUNT_ID,
+    LOCALSTACK_DEFAULT_REGION,
+    LOCALSTACK_INTERNAL_DOCKER_PORT,
+    EventBusSpec,
+    EventRuleSpec,
+    EventRuleTarget,
+    EventTargetKind,
+    LambdaSpec,
+    LambdaTarget,
+    LocalstackDependency,
+    LocalstackDependencyBuilder,
+    ManagedLocalstackPlaybook,
+    QueueSpec,
+    SqsQueueTarget,
+)
+from arena_pytest.dep.mssql import (
+    ManagedMssqlPlaybook,
+    MssqlDependency,
+    MssqlDependencyBuilder,
+    MssqlEncryption,
+)
+from arena_pytest.oauth import (
+    DEFAULT_OAUTH_PORT,
+    OAUTH_ISSUER,
+    OauthDependency,
+    OauthDependencyBuilder,
+    oauth_issuer_host_is_non_loopback,
+    oauth_loopback_tls_pem_pair,
+)
+from arena_pytest.dep.postgres import (
+    ManagedPostgresPlaybook,
+    PostgresDependency,
+    PostgresDependencyBuilder,
+)
+from arena_pytest.dep.smtp import SmtpDependency, SmtpDependencyBuilder
+from arena_pytest.dep.temporal import TemporalDependency, TemporalDependencyBuilder
+from arena_pytest.readiness import HttpReadinessCheck, ReadinessCheck, TcpReadinessCheck
+
+__all__ = [
+    "ArenaBindingError",
+    "ArenaLogLevel",
+    "ArenaNativeLib",
+    "ClosedArena",
+    "register_dispatcher_logging_target_for_logger",
+    "unregister_dispatcher_logging_target",
+    "ContainerizedComponent",
+    "ContainerizedComponentBuilder",
+    "Match",
+    "MatchBuilder",
+    "BuildTool",
+    "ExecutableComponent",
+    "ExecutableComponentBuilder",
+    "HttpDependency",
+    "HttpDependencyBuilder",
+    "HttpMappingExpect",
+    "HttpHeaderPattern",
+    "HttpMappingBuilder",
+    "HttpResponse",
+    "HttpSequenceBuilder",
+    "ActiveHttpPlaybookBuilder",
+    "HttpPlaybookBuilder",
+    "ok",
+    "ok_json",
+    "status",
+    "server_error",
+    "created",
+    "no_content",
+    "ActiveHttpPlaybook",
+    "ActiveLocalstackPlaybook",
+    "ActiveMssqlPlaybook",
+    "ActivePlaybook",
+    "ManagedHttpPlaybook",
+    "ManagedMssqlPlaybook",
+    "ManagedPlaybook",
+    "Playbook",
+    "UnmanagedPlaybook",
+    "KAFKA_INTERNAL_DOCKER_PORT",
+    "KafkaDependency",
+    "KafkaDependencyBuilder",
+    "KafkaFlavor",
+    "LOCALSTACK_DEFAULT_ACCOUNT_ID",
+    "LOCALSTACK_DEFAULT_REGION",
+    "LOCALSTACK_INTERNAL_DOCKER_PORT",
+    "EventBusSpec",
+    "EventRuleSpec",
+    "EventRuleTarget",
+    "EventTargetKind",
+    "LambdaSpec",
+    "LambdaTarget",
+    "LocalstackDependency",
+    "LocalstackDependencyBuilder",
+    "ManagedLocalstackPlaybook",
+    "QueueSpec",
+    "SqsQueueTarget",
+    "MssqlDependency",
+    "MssqlDependencyBuilder",
+    "MssqlEncryption",
+    "DEFAULT_OAUTH_PORT",
+    "OAUTH_ISSUER",
+    "OauthDependency",
+    "OauthDependencyBuilder",
+    "oauth_issuer_host_is_non_loopback",
+    "oauth_loopback_tls_pem_pair",
+    "ManagedPostgresPlaybook",
+    "PostgresDependency",
+    "PostgresDependencyBuilder",
+    "TemporalDependency",
+    "TemporalDependencyBuilder",
+    "SmtpDependency",
+    "SmtpDependencyBuilder",
+    "HttpReadinessCheck",
+    "TcpReadinessCheck",
+    "ReadinessCheck",
+    "arena",
+    "arena_ffi",
+    "playbook",
+    "closed_arena",
+    "OpenArena",
+]

arena_pytest/arena.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, List, Optional, Type
+
+import pytest
+import pytest_asyncio
+
+from arena_pytest.ffi._ffi import (
+    ArenaBindingError,
+    ArenaNativeLib,
+    close_arena,
+    hard_reset as ffi_hard_reset,
+    load_ffi,
+    soft_reset as ffi_soft_reset,
+)
+from arena_pytest.playbook import (
+    PLAYBOOK_MARKER,
+    ActivePlaybook,
+    Playbook,
+    _activate_classes,
+    _class_marker_classes,
+    _drop_actives,
+    _finish_playbook_scope,
+    _matches_from_closed_arena,
+    _module_marker_classes,
+    _own_marker_classes,
+    _partition_classes,
+    _run_managed_classes,
+)
+
+
+class OpenArena:
+    def __init__(
+        self,
+        ffi: ArenaNativeLib,
+        handle: int,
+        dispatcher_logging_target_token: int = 0,
+    ):
+        self._ffi = ffi
+        self._handle = handle
+        self._dispatcher_logging_target_token = dispatcher_logging_target_token
+
+    def handle(self) -> int:
+        return self._handle
+
+    async def close(self) -> None:
+        if self._handle:
+            await asyncio.to_thread(
+                close_arena,
+                self._ffi,
+                self._handle,
+                dispatcher_logging_target_token=self._dispatcher_logging_target_token,
+            )
+            self._handle = 0
+            self._dispatcher_logging_target_token = 0
+
+    async def soft_reset(self, dependency_identifier: str) -> None:
+        await asyncio.to_thread(
+            ffi_soft_reset, self._ffi, self._handle, dependency_identifier
+        )
+
+    async def hard_reset(self, dependency_identifier: str) -> None:
+        await asyncio.to_thread(
+            ffi_hard_reset, self._ffi, self._handle, dependency_identifier
+        )
+
+
+@pytest.fixture(scope="session")
+def arena_ffi() -> ArenaNativeLib:
+    ffi = load_ffi()
+    if ffi is None:
+        pytest.skip(
+            "arena shared library not found (set ARENA_FFI_LIB or use Bazel runfiles)"
+        )
+    return ffi
+
+
+@pytest.fixture(scope="session")
+def closed_arena() -> Optional[Any]:
+    return None
+
+
+@pytest_asyncio.fixture(scope="session")
+async def arena(closed_arena) -> OpenArena:
+    if closed_arena is None:
+        pytest.skip("closed_arena fixture not overridden (no arena to open)")
+    try:
+        open_arena_obj = await closed_arena.open()
+    except ArenaBindingError as e:
+        pytest.fail(f"arena_open failed: {e}", pytrace=False)
+    yield open_arena_obj
+    await open_arena_obj.close()
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        f"{PLAYBOOK_MARKER}(klass): open one playbook identified by its Playbook "
+        "subclass for the test, class, or module scope; stack multiple "
+        "@playbook(...) decorators for more than one.",
+    )
+    if config.getini("asyncio_mode") in (None, "strict", "STRICT"):
+        config._inicache["asyncio_mode"] = "auto"
+    if not config.getini("asyncio_default_fixture_loop_scope"):
+        config._inicache["asyncio_default_fixture_loop_scope"] = "session"
+
+
+_FUNCTION_ACTIVES_ATTR = "_arena_pytest_function_actives"
+_FUNCTION_MANAGED_ATTR = "_arena_pytest_function_managed_classes"
+
+
+def active_playbooks_for_item(item: pytest.Item) -> List[ActivePlaybook]:
+    actives: Optional[List[ActivePlaybook]] = getattr(item, _FUNCTION_ACTIVES_ATTR, None)
+    return list(actives) if actives else []
+
+
+def _item_request(item: pytest.Item) -> pytest.FixtureRequest:
+    request = getattr(item, "_request", None)
+    if request is None:
+        raise pytest.UsageError(
+            "@pytest.mark.playbook requires a pytest test function with the "
+            "'arena' fixture available"
+        )
+    return request
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_runtest_setup(item: pytest.Item) -> None:
+    classes = _own_marker_classes(item)
+    if not classes:
+        return
+    unmanaged_classes, managed_classes = _partition_classes(classes)
+    setattr(item, _FUNCTION_MANAGED_ATTR, managed_classes)
+    if not unmanaged_classes:
+        return
+    request = _item_request(item)
+    arena_obj = request.getfixturevalue("arena")
+    matches = _matches_from_closed_arena(request.getfixturevalue("closed_arena"))
+    actives = _activate_classes(arena_obj, matches, unmanaged_classes)
+    setattr(item, _FUNCTION_ACTIVES_ATTR, actives)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_runtest_teardown(item: pytest.Item, nextitem: Optional[pytest.Item]) -> None:
+    actives: Optional[List[ActivePlaybook]] = getattr(item, _FUNCTION_ACTIVES_ATTR, None)
+    if actives:
+        setattr(item, _FUNCTION_ACTIVES_ATTR, None)
+        _drop_actives(actives)
+
+    managed_classes: Optional[List[Type[Playbook]]] = getattr(
+        item, _FUNCTION_MANAGED_ATTR, None
+    )
+    if managed_classes:
+        setattr(item, _FUNCTION_MANAGED_ATTR, None)
+        request = _item_request(item)
+        arena_obj = request.getfixturevalue("arena")
+        matches = _matches_from_closed_arena(request.getfixturevalue("closed_arena"))
+        _run_managed_classes(arena_obj, matches, managed_classes)
+
+
+@pytest.fixture(scope="class", autouse=True)
+def _playbook_class_scope(request: pytest.FixtureRequest):
+    cls = getattr(request, "cls", None)
+    classes = _class_marker_classes(cls)
+    if not classes:
+        yield
+        return
+    unmanaged_classes, managed_classes = _partition_classes(classes)
+    arena_obj = request.getfixturevalue("arena")
+    closed = request.getfixturevalue("closed_arena")
+    matches = _matches_from_closed_arena(closed)
+    actives = _activate_classes(arena_obj, matches, unmanaged_classes)
+    try:
+        yield
+    finally:
+        _finish_playbook_scope(arena_obj, matches, actives, managed_classes)
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _playbook_module_scope(request: pytest.FixtureRequest):
+    module = getattr(request, "module", None)
+    classes = _module_marker_classes(module)
+    if not classes:
+        yield
+        return
+    unmanaged_classes, managed_classes = _partition_classes(classes)
+    arena_obj = request.getfixturevalue("arena")
+    closed = request.getfixturevalue("closed_arena")
+    matches = _matches_from_closed_arena(closed)
+    actives = _activate_classes(arena_obj, matches, unmanaged_classes)
+    try:
+        yield
+    finally:
+        _finish_playbook_scope(arena_obj, matches, actives, managed_classes)

arena_pytest/closed_arena.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import List, Optional, Sequence
+
+from arena_pytest.arena import OpenArena
+from arena_pytest.ffi._ffi import (
+    ArenaBindingError,
+    ArenaLogLevel,
+    close_arena,
+    load_ffi,
+    open_arena as ffi_open_arena,
+    register_default_dispatcher_logging_target,
+    register_dispatcher_logging_target_for_logger,
+    set_dispatcher_component_allow_json,
+    set_dispatcher_dependency_allow_json,
+)
+
+
+def _normalize_optional_id_seq(
+    seq: Optional[Sequence[str]],
+) -> tuple[str, ...]:
+    if not seq:
+        return ()
+    return tuple(str(x).strip() for x in seq if str(x).strip())
+
+
+class ClosedArena:
+    def __init__(
+        self,
+        name: str,
+        matches: List,
+        *,
+        log_level: ArenaLogLevel = ArenaLogLevel.INFO,
+        logger: Optional[logging.Logger] = None,
+        log_component_ids: Optional[Sequence[str]] = None,
+        log_dependency_ids: Optional[Sequence[str]] = None,
+    ):
+        self.name = name
+        self._matches = matches
+        self._log_level = log_level
+        self._logger = logger
+        self._log_dependency_ids = _normalize_optional_id_seq(log_dependency_ids)
+        self._log_component_ids = _normalize_optional_id_seq(log_component_ids)
+
+    def _config(self) -> str:
+        if not self._matches:
+            return "{}"
+        a_match = self._matches[0]
+        config = a_match._for_ffi() if hasattr(a_match, "_for_ffi") else a_match
+        return json.dumps(config)
+
+    async def open(self) -> OpenArena:
+        ffi = load_ffi()
+        if ffi is None:
+            raise ArenaBindingError(
+                "arena shared library not found (set ARENA_FFI_LIB or use Bazel runfiles)"
+            )
+        config = self._config()
+        dep_json = (
+            json.dumps(list(self._log_dependency_ids))
+            if self._log_dependency_ids
+            else None
+        )
+        comp_json = (
+            json.dumps(list(self._log_component_ids))
+            if self._log_component_ids
+            else None
+        )
+        await asyncio.to_thread(set_dispatcher_dependency_allow_json, ffi, dep_json)
+        await asyncio.to_thread(set_dispatcher_component_allow_json, ffi, comp_json)
+        if self._logger is not None:
+            log_tok = await asyncio.to_thread(
+                register_dispatcher_logging_target_for_logger,
+                ffi,
+                self._logger,
+                arena_log_level=self._log_level,
+            )
+        else:
+            log_tok = await asyncio.to_thread(
+                register_default_dispatcher_logging_target,
+                ffi,
+                arena_log_level=self._log_level,
+            )
+        try:
+            handle = await asyncio.to_thread(
+                ffi_open_arena,
+                ffi,
+                self.name.encode("utf-8"),
+                config,
+                log_level=self._log_level,
+            )
+        except ArenaBindingError as e:
+            await asyncio.to_thread(
+                close_arena, ffi, 0, dispatcher_logging_target_token=log_tok
+            )
+            raise ArenaBindingError(f"arena_open failed: {e}") from e
+
+        return OpenArena(ffi, handle, log_tok)