forked from cleveragents/cleveragents-core
freemo
ec0b7631d0
Renamed src/cleveragents/acp/ to src/cleveragents/a2a/ and all 13 Acp* classes to A2a* per ADR-047 (A2A Standard Adoption). Updated all imports, structlog event names (acp.* → a2a.*), field names (acp_version → a2a_version), and test references across the entire codebase. This is a cosmetic rename only — no behavioral changes. ISSUES CLOSED: #688
448 lines
15 KiB
Python
448 lines
15 KiB
Python
"""Step definitions for server client stubs Behave scenarios."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import tempfile
|
|
|
|
from behave import given, then, use_step_matcher, when
|
|
from behave.runner import Context
|
|
from pydantic import ValidationError
|
|
|
|
from cleveragents.a2a.clients import (
|
|
AuthClient,
|
|
RemoteExecutionClient,
|
|
ServerClient,
|
|
StubAuthClient,
|
|
StubRemoteExecutionClient,
|
|
StubServerClient,
|
|
)
|
|
from cleveragents.a2a.server_config import ServerConnectionConfig
|
|
from cleveragents.application.services.config_service import _REGISTRY
|
|
|
|
use_step_matcher("re")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ServerConnectionConfig — creation
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when(r'I create a ServerConnectionConfig with url "(?P<url>[^"]+)"')
|
|
def step_create_config(context: Context, url: str) -> None:
|
|
context.server_config = ServerConnectionConfig(server_url=url)
|
|
|
|
|
|
@when(
|
|
r'I create a ServerConnectionConfig with url "(?P<url>[^"]+)" '
|
|
r'and namespace "(?P<ns>[^"]+)"'
|
|
)
|
|
def step_create_config_ns(context: Context, url: str, ns: str) -> None:
|
|
context.server_config = ServerConnectionConfig(server_url=url, namespace=ns)
|
|
|
|
|
|
@when(
|
|
r'I create a ServerConnectionConfig with url "(?P<url>[^"]+)" '
|
|
r'and auth_token_ref "(?P<ref>[^"]+)"'
|
|
)
|
|
def step_create_config_auth(context: Context, url: str, ref: str) -> None:
|
|
context.server_config = ServerConnectionConfig(server_url=url, auth_token_ref=ref)
|
|
|
|
|
|
@when(
|
|
r'I create a ServerConnectionConfig with url "(?P<url>[^"]+)" '
|
|
r"and tls_verify false"
|
|
)
|
|
def step_create_config_tls_false(context: Context, url: str) -> None:
|
|
context.server_config = ServerConnectionConfig(server_url=url, tls_verify=False)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ServerConnectionConfig — assertions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then(r'the config server_url should be "(?P<expected>[^"]+)"')
|
|
def step_config_url(context: Context, expected: str) -> None:
|
|
assert context.server_config.server_url == expected, (
|
|
f"Expected '{expected}', got '{context.server_config.server_url}'"
|
|
)
|
|
|
|
|
|
@then(r'the config namespace should be "(?P<expected>[^"]+)"')
|
|
def step_config_namespace(context: Context, expected: str) -> None:
|
|
assert context.server_config.namespace == expected, (
|
|
f"Expected '{expected}', got '{context.server_config.namespace}'"
|
|
)
|
|
|
|
|
|
@then(r'the config auth_token_ref should be "(?P<expected>[^"]+)"')
|
|
def step_config_auth_ref(context: Context, expected: str) -> None:
|
|
assert context.server_config.auth_token_ref == expected, (
|
|
f"Expected '{expected}', got '{context.server_config.auth_token_ref}'"
|
|
)
|
|
|
|
|
|
@then(r"the config tls_verify should be true")
|
|
def step_config_tls_true(context: Context) -> None:
|
|
assert context.server_config.tls_verify is True
|
|
|
|
|
|
@then(r"the config tls_verify should be false")
|
|
def step_config_tls_false(context: Context) -> None:
|
|
assert context.server_config.tls_verify is False
|
|
|
|
|
|
@then(r"the config should be immutable")
|
|
def step_config_immutable(context: Context) -> None:
|
|
cfg = context.server_config
|
|
raised = False
|
|
try:
|
|
cfg.__setattr__("server_url", "http://changed.example.com")
|
|
except (ValidationError, AttributeError, TypeError):
|
|
raised = True
|
|
assert raised, "Setting attribute on frozen model should have raised an error"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ServerConnectionConfig — validation errors
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when(r"I try to create a ServerConnectionConfig with empty url")
|
|
def step_create_config_empty_url(context: Context) -> None:
|
|
context.caught_error = None
|
|
try:
|
|
ServerConnectionConfig(server_url="")
|
|
except ValidationError as exc:
|
|
context.caught_error = exc
|
|
|
|
|
|
@when(r'I try to create a ServerConnectionConfig with url "(?P<url>[^"]+)"')
|
|
def step_create_config_invalid_url(context: Context, url: str) -> None:
|
|
context.caught_error = None
|
|
try:
|
|
ServerConnectionConfig(server_url=url)
|
|
except ValidationError as exc:
|
|
context.caught_error = exc
|
|
|
|
|
|
@when(
|
|
r'I try to create a ServerConnectionConfig with url "(?P<url>[^"]+)" '
|
|
r"and empty namespace"
|
|
)
|
|
def step_create_config_empty_ns(context: Context, url: str) -> None:
|
|
context.caught_error = None
|
|
try:
|
|
ServerConnectionConfig(server_url=url, namespace="")
|
|
except ValidationError as exc:
|
|
context.caught_error = exc
|
|
|
|
|
|
@then(r"a server config validation error should be raised")
|
|
def step_server_config_validation_error(context: Context) -> None:
|
|
assert context.caught_error is not None, "Expected a ValidationError"
|
|
assert isinstance(context.caught_error, ValidationError), (
|
|
f"Expected ValidationError, got {type(context.caught_error)}"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# StubServerClient
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given(r"a new StubServerClient")
|
|
def step_stub_server_client(context: Context) -> None:
|
|
context.stub_server = StubServerClient()
|
|
|
|
|
|
@when(r"I call health_check on the stub server client")
|
|
def step_call_health_check(context: Context) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_server.health_check()
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(r"I call get_version on the stub server client")
|
|
def step_call_get_version(context: Context) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_server.get_version()
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# StubRemoteExecutionClient
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given(r"a new StubRemoteExecutionClient")
|
|
def step_stub_exec_client(context: Context) -> None:
|
|
context.stub_exec = StubRemoteExecutionClient()
|
|
|
|
|
|
@when(
|
|
r'I call execute_plan with plan_id "(?P<plan_id>[^"]+)" '
|
|
r"on the stub execution client"
|
|
)
|
|
def step_call_execute_plan(context: Context, plan_id: str) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_exec.execute_plan(plan_id)
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(
|
|
r'I call get_plan_status with plan_id "(?P<plan_id>[^"]+)" '
|
|
r"on the stub execution client"
|
|
)
|
|
def step_call_get_plan_status(context: Context, plan_id: str) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_exec.get_plan_status(plan_id)
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(
|
|
r'I call cancel_plan with plan_id "(?P<plan_id>[^"]+)" '
|
|
r"on the stub execution client"
|
|
)
|
|
def step_call_cancel_plan(context: Context, plan_id: str) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_exec.cancel_plan(plan_id)
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(r"I call execute_plan with empty plan_id on the stub execution client")
|
|
def step_call_execute_plan_empty(context: Context) -> None:
|
|
context.caught_error = None
|
|
try:
|
|
context.stub_exec.execute_plan("")
|
|
except ValueError as exc:
|
|
context.caught_error = exc
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# StubAuthClient
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given(r"a new StubAuthClient")
|
|
def step_stub_auth_client(context: Context) -> None:
|
|
context.stub_auth = StubAuthClient()
|
|
|
|
|
|
@when(r'I call authenticate with token "(?P<token>[^"]+)" on the stub auth client')
|
|
def step_call_authenticate(context: Context, token: str) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_auth.authenticate(token)
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(r'I call validate_token with token "(?P<token>[^"]+)" on the stub auth client')
|
|
def step_call_validate_token(context: Context, token: str) -> None:
|
|
context.caught_error = None
|
|
context.ctx_error = None
|
|
try:
|
|
context.stub_auth.validate_token(token)
|
|
except NotImplementedError as exc:
|
|
context.caught_error = exc
|
|
context.ctx_error = exc
|
|
|
|
|
|
@when(r"I call authenticate with empty token on the stub auth client")
|
|
def step_call_authenticate_empty(context: Context) -> None:
|
|
context.caught_error = None
|
|
try:
|
|
context.stub_auth.authenticate("")
|
|
except ValueError as exc:
|
|
context.caught_error = exc
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# NotImplementedError and ValueError assertions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# Note: the step "a NotImplementedError should be raised with message
|
|
# containing ..." is already defined in project_context_cli_steps.py
|
|
# and looks at context.ctx_error. Our stub steps store errors in
|
|
# context.caught_error, so we bridge by also writing to ctx_error
|
|
# in each step that catches NotImplementedError.
|
|
|
|
|
|
@then(r"a ValueError should be raised for empty plan_id")
|
|
def step_value_error_plan_id(context: Context) -> None:
|
|
assert context.caught_error is not None, "Expected ValueError"
|
|
assert isinstance(context.caught_error, ValueError), (
|
|
f"Expected ValueError, got {type(context.caught_error)}"
|
|
)
|
|
|
|
|
|
@then(r"a ValueError should be raised for empty token")
|
|
def step_value_error_token(context: Context) -> None:
|
|
assert context.caught_error is not None, "Expected ValueError"
|
|
assert isinstance(context.caught_error, ValueError), (
|
|
f"Expected ValueError, got {type(context.caught_error)}"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Protocol conformance
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then(r"StubServerClient should be a runtime instance of ServerClient")
|
|
def step_server_protocol(context: Context) -> None:
|
|
assert isinstance(StubServerClient(), ServerClient)
|
|
|
|
|
|
@then(
|
|
r"StubRemoteExecutionClient should be a runtime instance of RemoteExecutionClient"
|
|
)
|
|
def step_exec_protocol(context: Context) -> None:
|
|
assert isinstance(StubRemoteExecutionClient(), RemoteExecutionClient)
|
|
|
|
|
|
@then(r"StubAuthClient should be a runtime instance of AuthClient")
|
|
def step_auth_protocol(context: Context) -> None:
|
|
assert isinstance(StubAuthClient(), AuthClient)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Config key registration
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@then(r'config key "(?P<key>[^"]+)" should be registered')
|
|
def step_config_key_registered(context: Context, key: str) -> None:
|
|
assert key in _REGISTRY, f"Config key '{key}' not found in registry"
|
|
|
|
|
|
@then(r'config key "(?P<key>[^"]+)" should have default true')
|
|
def step_config_key_default_true(context: Context, key: str) -> None:
|
|
entry = _REGISTRY[key]
|
|
assert entry.default is True, f"Expected True, got {entry.default}"
|
|
|
|
|
|
@then(r'config key "(?P<key>[^"]+)" should have default "(?P<default>[^"]+)"')
|
|
def step_config_key_default_str(context: Context, key: str, default: str) -> None:
|
|
entry = _REGISTRY[key]
|
|
assert str(entry.default) == default, f"Expected '{default}', got '{entry.default}'"
|
|
|
|
|
|
@then(r'config key "(?P<key>[^"]+)" should use env var "(?P<env_var>[^"]+)"')
|
|
def step_config_key_env_var(context: Context, key: str, env_var: str) -> None:
|
|
entry = _REGISTRY[key]
|
|
assert entry.env_var == env_var, (
|
|
f"Expected env var '{env_var}', got '{entry.env_var}'"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# CLI integration (isolated — uses a temporary HOME to avoid config bleed)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given(r"a temporary home directory for server tests")
|
|
def step_tmp_home_for_server(context: Context) -> None:
|
|
"""Set HOME to a fresh temporary directory so config writes are isolated."""
|
|
context.server_test_home = tempfile.mkdtemp()
|
|
context.server_test_old_home = os.environ.get("HOME")
|
|
os.environ["HOME"] = context.server_test_home
|
|
|
|
|
|
@when(
|
|
r'I invoke server connect with url "(?P<url>[^"]+)" '
|
|
r'and format "(?P<fmt>[^"]+)"'
|
|
)
|
|
def step_invoke_server_connect(context: Context, url: str, fmt: str) -> None:
|
|
"""Run ``server connect <url> --format <fmt>`` and capture output."""
|
|
import io
|
|
import sys
|
|
|
|
from cleveragents.cli.main import main as cli_main
|
|
|
|
captured = io.StringIO()
|
|
old_stdout = sys.stdout
|
|
sys.stdout = captured
|
|
try:
|
|
context.server_connect_exit = cli_main(
|
|
["server", "connect", url, "--format", fmt]
|
|
)
|
|
except SystemExit as exc:
|
|
context.server_connect_exit = exc.code if exc.code is not None else 0
|
|
finally:
|
|
sys.stdout = old_stdout
|
|
# Restore HOME
|
|
old_home = getattr(context, "server_test_old_home", None)
|
|
if old_home is not None:
|
|
os.environ["HOME"] = old_home
|
|
else:
|
|
os.environ.pop("HOME", None)
|
|
context.server_connect_output = captured.getvalue()
|
|
|
|
|
|
@then(r'the server connect output should contain "(?P<text>[^"]+)"')
|
|
def step_server_connect_output_contains(context: Context, text: str) -> None:
|
|
assert text in context.server_connect_output, (
|
|
f"Expected '{text}' in output: {context.server_connect_output!r}"
|
|
)
|
|
|
|
|
|
@then(r"the server connect should exit with non-zero code")
|
|
def step_server_connect_non_zero(context: Context) -> None:
|
|
assert context.server_connect_exit != 0, (
|
|
f"Expected non-zero exit, got {context.server_connect_exit}"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Server mode resolution
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given(r"no server URL is configured")
|
|
def step_no_server_url(context: Context) -> None:
|
|
# Ensure the env var is not set and use a clean temp HOME
|
|
os.environ.pop("CLEVERAGENTS_SERVER_URL", None)
|
|
context.clean_home = tempfile.mkdtemp()
|
|
context.old_home = os.environ.get("HOME")
|
|
os.environ["HOME"] = context.clean_home
|
|
|
|
|
|
@then(r'resolve_server_mode should return "(?P<mode>[^"]+)"')
|
|
def step_resolve_server_mode(context: Context, mode: str) -> None:
|
|
from cleveragents.cli.commands.server import resolve_server_mode
|
|
|
|
try:
|
|
result = resolve_server_mode()
|
|
assert result == mode, f"Expected '{mode}', got '{result}'"
|
|
finally:
|
|
old_home = getattr(context, "old_home", None)
|
|
if old_home is not None:
|
|
os.environ["HOME"] = old_home
|
|
else:
|
|
os.environ.pop("HOME", None)
|