cleveractors-core/features/steps/validate_dict_steps.py

"""
Shared Then-step definitions for validate_dict BDD feature.

These assertion steps are used across all scenarios in validate_dict.feature.
"""

from __future__ import annotations

from behave import then
from behave.runner import Context


@then("no exception is raised")
def step_no_exception(context: Context) -> None:
    if context.raised_exception is not None:
        raise AssertionError(
            f"Expected no exception, but got: {context.raised_exception!r}"
        )


@then("a ConfigurationError is raised")
def step_configuration_error_raised(context: Context) -> None:
    assert context.raised_exception is not None, (
        "Expected a ConfigurationError to be raised, but none was."
    )
    assert isinstance(context.raised_exception, context.ConfigurationError), (
        f"Expected ConfigurationError, got {type(context.raised_exception).__name__}: "
        f"{context.raised_exception!r}"
    )


@then('the error message mentions "agents"')
def step_error_mentions_agents(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "agents" in msg, (
        f"Expected error message to mention 'agents', got: {context.raised_exception!r}"
    )


@then('the error message mentions "routes"')
def step_error_mentions_routes(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "routes" in msg, (
        f"Expected error message to mention 'routes', got: {context.raised_exception!r}"
    )


@then("the error message mentions agent type validation")
def step_error_mentions_agent_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "unknown agent type" in msg, (
        f"Expected error message to mention unknown agent type, got: {context.raised_exception!r}"
    )


@then("the error message mentions provider validation")
def step_error_mentions_provider(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "provider" in msg and "allowed-providers" in msg, (
        f"Expected error message to mention provider and allowed-providers, got: {context.raised_exception!r}"
    )


@then("the error message mentions edge field names")
def step_error_mentions_edge_fields(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert (
        "'from' is not accepted" in msg
        or "'to' is not accepted" in msg
        or ("source" in msg and "target" in msg)
    ), (
        f"Expected error message to mention edge field names, got: {context.raised_exception!r}"
    )


@then("the error message mentions node type validation")
def step_error_mentions_node_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "unknown node type" in msg, (
        f"Expected error message to mention unknown node type, got: {context.raised_exception!r}"
    )


@then("the error message mentions operator type validation")
def step_error_mentions_operator(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "unknown operator type" in msg, (
        f"Expected error message to mention unknown operator type, got: {context.raised_exception!r}"
    )


@then("the error message mentions graph depth")
def step_error_mentions_depth(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "max_graph_depth" in msg, (
        f"Expected error message to mention max_graph_depth, got: {context.raised_exception!r}"
    )


@then("the error message mentions total nodes")
def step_error_mentions_total_nodes(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "max_total_nodes" in msg, (
        f"Expected error message to mention max_total_nodes, got: {context.raised_exception!r}"
    )


@then("the error message mentions subgraph depth")
def step_error_mentions_subgraph_depth(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "max_subgraph_depth" in msg, (
        f"Expected error message to mention max_subgraph_depth, got: {context.raised_exception!r}"
    )


@then("the function returns the config dict unchanged")
def step_returns_dict_unchanged(context: Context) -> None:
    assert context.result == context.config_dict, (
        f"Expected the returned dict to equal the input dict.\n"
        f"Input:  {context.config_dict!r}\n"
        f"Output: {context.result!r}"
    )


@then("the returned dict is the same object as the input dict")
def step_returns_same_object(context: Context) -> None:
    assert context.result is context.config_dict, (
        "Expected the returned dict to be the same object (identity) as the input dict, "
        "but validate_dict returned a different object."
    )


@then("the error message mentions source and target fields")
def step_error_mentions_source_target(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "source" in msg and "target" in msg, (
        f"Expected error message to mention source and target fields, got: {context.raised_exception!r}"
    )


@then('the error message mentions "nodes"')
def step_error_mentions_nodes(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "nodes" in msg, (
        f"Expected error message to mention 'nodes', got: {context.raised_exception!r}"
    )


@then('the error message mentions "edges"')
def step_error_mentions_edges(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "edges" in msg, (
        f"Expected error message to mention 'edges', got: {context.raised_exception!r}"
    )


@then("the error message mentions missing type")
def step_error_mentions_missing_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "missing" in msg and "type" in msg, (
        f"Expected error message to mention missing type, got: {context.raised_exception!r}"
    )


@then("the error message mentions platform_limits type validation")
def step_error_mentions_limits_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "platform_limits" in msg, (
        f"Expected error message to mention platform_limits, got: {context.raised_exception!r}"
    )


@then("the error message mentions allowed_providers type validation")
def step_error_mentions_allowed_providers(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "allowed_providers" in msg, (
        f"Expected error message to mention allowed_providers, got: {context.raised_exception!r}"
    )


@then("the error message mentions non-string provider")
def step_error_mentions_non_string_provider(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "provider" in msg and "string" in msg, (
        f"Expected error message to mention non-string provider, got: {context.raised_exception!r}"
    )


@then("the error message mentions non-string node type")
def step_error_mentions_non_string_node_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "node type" in msg and "string" in msg, (
        f"Expected error message to mention non-string node type, got: {context.raised_exception!r}"
    )


@then("the error message mentions entry_point not found")
def step_error_mentions_entry_point(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "entry_point" in msg and "does not match any declared node" in msg, (
        f"Expected error message to mention entry_point not found, got: {context.raised_exception!r}"
    )


@then("the error message mentions subgraph reference")
def step_error_mentions_subgraph_reference(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "subgraph" in msg, (
        f"Expected error message to mention subgraph, got: {context.raised_exception!r}"
    )


@then('the error message mentions "type"')
def step_error_mentions_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "type" in msg, (
        f"Expected error message to mention 'type', got: {context.raised_exception!r}"
    )


@then("the error message mentions non-string agent type")
def step_error_mentions_non_string_agent_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "type" in msg and "string" in msg and "agent" in msg, (
        f"Expected error message to mention non-string agent type, got: {context.raised_exception!r}"
    )


@then("the error message mentions non-string route type")
def step_error_mentions_non_string_route_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "type" in msg and "string" in msg and "route" in msg, (
        f"Expected error message to mention non-string route type, got: {context.raised_exception!r}"
    )


@then('the error message mentions "entry_point"')
def step_error_mentions_entry_point_keyword(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "entry_point" in msg, (
        f"Expected error message to mention 'entry_point', got: {context.raised_exception!r}"
    )


@then("the error message mentions non-string operator type")
def step_error_mentions_non_string_op_type(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "operator type" in msg and "string" in msg, (
        f"Expected error message to mention non-string operator type, got: {context.raised_exception!r}"
    )


@then("the error message mentions config_dict and dict")
def step_error_mentions_config_dict_is_dict(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "config_dict" in msg and "dict" in msg, (
        f"Expected error message to mention config_dict and dict, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions platform_limits and dict")
def step_error_mentions_platform_limits_is_dict(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "platform_limits" in msg and "dict" in msg, (
        f"Expected error message to mention platform_limits and dict, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions edge must be a mapping")
def step_error_mentions_edge_mapping(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "edge" in msg and "mapping" in msg, (
        f"Expected error message to mention edge mapping, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions operator must be a mapping")
def step_error_mentions_operator_mapping(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "operator" in msg and "mapping" in msg, (
        f"Expected error message to mention operator mapping, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions too complex to validate depth")
def step_error_mentions_too_complex_depth(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "too complex to validate" in msg and "depth" in msg, (
        f"Expected error message to mention 'too complex to validate depth', "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions too complex to validate")
def step_error_mentions_too_complex(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "too complex to validate" in msg, (
        f"Expected error message to mention 'too complex to validate', "
        f"got: {context.raised_exception!r}"
    )


@then('the error message mentions "must be >= 0"')
def step_error_mentions_must_be_ge_zero(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "must be >= 0" in msg, (
        f"Expected error message to mention 'must be >= 0', "
        f"got: {context.raised_exception!r}"
    )


@then('the error message mentions "must be an integer"')
def step_error_mentions_must_be_integer(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "must be an integer" in msg, (
        f"Expected error message to mention 'must be an integer', "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions edge endpoint not declared")
def step_error_mentions_edge_endpoint_not_declared(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "not declared in 'nodes'" in msg, (
        f"Expected error message to mention edge endpoint not declared, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions config must be a mapping")
def step_error_mentions_config_mapping(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "config" in msg and "mapping" in msg, (
        f"Expected error message to mention config mapping, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions reserved agent name")
def step_error_mentions_reserved_agent(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "reserved" in msg and "agent" in msg, (
        f"Expected error message to mention reserved agent name, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions reserved route name")
def step_error_mentions_reserved_route(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "reserved" in msg and "route" in msg, (
        f"Expected error message to mention reserved route name, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions agent key must be a string")
def step_error_mentions_agent_key_string(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "agent key" in msg and "string" in msg, (
        f"Expected error message to mention agent key must be a string, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions route key must be a string")
def step_error_mentions_route_key_string(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "route key" in msg and "string" in msg, (
        f"Expected error message to mention route key must be a string, "
        f"got: {context.raised_exception!r}"
    )


@then("the error message mentions node key must be a string")
def step_error_mentions_node_key_string(context: Context) -> None:
    msg = str(context.raised_exception).lower()
    assert "node key" in msg and "string" in msg, (
        f"Expected error message to mention node key must be a string, "
        f"got: {context.raised_exception!r}"
    )