forked from HAL9000/cleveragents-core
1148 lines
42 KiB
Python
1148 lines
42 KiB
Python
"""Step definitions for lifecycle data persistence and retrieval tests."""
|
|
|
|
import json
|
|
from datetime import datetime
|
|
|
|
from behave import given, then, when
|
|
from sqlalchemy import create_engine
|
|
from sqlalchemy.orm import sessionmaker
|
|
|
|
from cleveragents.infrastructure.database.models import (
|
|
ActionArgumentModel,
|
|
Base,
|
|
LifecycleActionModel,
|
|
LifecyclePlanModel,
|
|
PlanProjectModel,
|
|
)
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Background steps
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("the lifecycle database is ready")
|
|
def step_import_lifecycle_modules(context):
|
|
"""Set up an in-memory database with lifecycle tables."""
|
|
context.database_url = "sqlite:///:memory:"
|
|
context.engine = create_engine(context.database_url)
|
|
context.SessionLocal = sessionmaker(
|
|
bind=context.engine, autoflush=False, autocommit=False
|
|
)
|
|
Base.metadata.create_all(context.engine)
|
|
|
|
|
|
@given("a lifecycle database session is open")
|
|
def step_create_lifecycle_test_session(context):
|
|
"""Open a database session for the lifecycle tests."""
|
|
if not hasattr(context, "SessionLocal"):
|
|
step_import_lifecycle_modules(context)
|
|
context.db_session = context.SessionLocal()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helper: create a fully populated LifecycleActionModel
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
VALID_ULID_1 = "01HGZ6FE0AQDYTR4BXVQZ6E001"
|
|
VALID_ULID_2 = "01HGZ6FE0AQDYTR4BXVQZ6E002"
|
|
VALID_ULID_3 = "01HGZ6FE0AQDYTR4BXVQZ6E003"
|
|
VALID_ULID_4 = "01HGZ6FE0AQDYTR4BXVQZ6E004"
|
|
VALID_ULID_5 = "01HGZ6FE0AQDYTR4BXVQZ6E005"
|
|
|
|
|
|
def _make_action_model(
|
|
name="local/test-action",
|
|
namespace="local",
|
|
short_name="test-action",
|
|
description="A short description",
|
|
long_description="A long description of the action",
|
|
definition_of_done="All tests pass and coverage > 80%",
|
|
strategy_actor="local/strategy-actor",
|
|
execution_actor="local/execution-actor",
|
|
estimation_actor="local/estimation-actor",
|
|
review_actor="local/review-actor",
|
|
inputs_schema="[]",
|
|
state="available",
|
|
reusable=True,
|
|
read_only=False,
|
|
created_at="2025-06-01T12:00:00",
|
|
updated_at="2025-06-01T13:00:00",
|
|
created_by="test-user",
|
|
tags="[]",
|
|
):
|
|
"""Create a LifecycleActionModel with sensible defaults.
|
|
|
|
Maps the legacy helper parameters to the new spec-aligned column names:
|
|
- ``name`` -> ``namespaced_name`` (PK)
|
|
- ``short_name`` -> ``name``
|
|
- ``description`` -> ``description``
|
|
- ``inputs_schema`` -> ``inputs_schema_json``
|
|
- ``tags`` -> ``tags_json``
|
|
"""
|
|
return LifecycleActionModel(
|
|
namespaced_name=name,
|
|
namespace=namespace,
|
|
name=short_name,
|
|
description=description,
|
|
long_description=long_description,
|
|
definition_of_done=definition_of_done,
|
|
strategy_actor=strategy_actor,
|
|
execution_actor=execution_actor,
|
|
estimation_actor=estimation_actor,
|
|
review_actor=review_actor,
|
|
inputs_schema_json=inputs_schema if inputs_schema != "[]" else None,
|
|
state=state,
|
|
reusable=reusable,
|
|
read_only=read_only,
|
|
created_at=created_at,
|
|
updated_at=updated_at,
|
|
created_by=created_by,
|
|
tags_json=tags,
|
|
)
|
|
|
|
|
|
def _make_plan_model(
|
|
plan_id=VALID_ULID_1,
|
|
parent_plan_id=None,
|
|
root_plan_id=None,
|
|
action_name="local/test-action",
|
|
phase="strategize",
|
|
state="queued",
|
|
attempt=1,
|
|
namespaced_name="local/test-plan",
|
|
namespace="local",
|
|
description="A test plan description",
|
|
definition_of_done="Tests pass",
|
|
project_names=None,
|
|
strategy_actor="local/strategy-actor",
|
|
execution_actor="local/execution-actor",
|
|
error_message=None,
|
|
created_at="2025-06-01T12:00:00",
|
|
updated_at="2025-06-01T13:00:00",
|
|
completed_at=None,
|
|
strategize_started_at=None,
|
|
strategize_completed_at=None,
|
|
execute_started_at=None,
|
|
execute_completed_at=None,
|
|
apply_started_at=None,
|
|
applied_at=None,
|
|
created_by="test-user",
|
|
tags="[]",
|
|
reusable=True,
|
|
read_only=False,
|
|
):
|
|
"""Create a LifecyclePlanModel with sensible defaults.
|
|
|
|
Maps legacy helper parameters to the new spec-aligned column names:
|
|
- ``action_id`` -> ``action_name`` (FK to actions.namespaced_name)
|
|
- ``state`` -> ``processing_state``
|
|
- ``project_ids`` removed (now uses ``plan_projects`` child table)
|
|
- ``tags`` -> ``tags_json``
|
|
- Added ``namespace`` column
|
|
"""
|
|
model = LifecyclePlanModel(
|
|
plan_id=plan_id,
|
|
parent_plan_id=parent_plan_id,
|
|
root_plan_id=root_plan_id,
|
|
action_name=action_name,
|
|
phase=phase,
|
|
processing_state=state,
|
|
attempt=attempt,
|
|
namespaced_name=namespaced_name,
|
|
namespace=namespace,
|
|
description=description,
|
|
definition_of_done=definition_of_done,
|
|
strategy_actor=strategy_actor,
|
|
execution_actor=execution_actor,
|
|
error_message=error_message,
|
|
created_at=created_at,
|
|
updated_at=updated_at,
|
|
completed_at=completed_at,
|
|
strategize_started_at=strategize_started_at,
|
|
strategize_completed_at=strategize_completed_at,
|
|
execute_started_at=execute_started_at,
|
|
execute_completed_at=execute_completed_at,
|
|
apply_started_at=apply_started_at,
|
|
applied_at=applied_at,
|
|
created_by=created_by,
|
|
tags_json=tags,
|
|
reusable=reusable,
|
|
read_only=read_only,
|
|
)
|
|
# Populate project links via child table
|
|
if project_names:
|
|
for pname in json.loads(project_names):
|
|
model.project_links_rel.append(
|
|
PlanProjectModel(
|
|
project_name=pname,
|
|
created_at=created_at,
|
|
)
|
|
)
|
|
return model
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: loading a stored record as a domain object
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("an action record exists with valid attributes and tags")
|
|
def step_create_action_model_valid(context):
|
|
"""Persist a valid action record with tags."""
|
|
context.action_model = _make_action_model(
|
|
tags='["tag1", "tag2"]',
|
|
)
|
|
context.db_session.add(context.action_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@when("the action record is loaded as a domain object")
|
|
def step_call_to_domain_on_action(context):
|
|
"""Load the persisted action record as a domain object."""
|
|
context.action_domain = context.action_model.to_domain()
|
|
|
|
|
|
@then("the loaded action should preserve its original identifier")
|
|
def step_verify_action_domain_id(context):
|
|
"""Verify the loaded action retains the original identifier (namespaced_name)."""
|
|
assert str(context.action_domain.namespaced_name) == "local/test-action"
|
|
|
|
|
|
@then("the loaded action should preserve its namespace and short name")
|
|
def step_verify_action_domain_namespaced_name(context):
|
|
"""Verify the loaded action retains its namespace and short name."""
|
|
assert context.action_domain.namespaced_name.namespace == "local"
|
|
assert context.action_domain.namespaced_name.name == "test-action"
|
|
|
|
|
|
@then("the loaded action should preserve its description fields")
|
|
def step_verify_action_domain_descriptions(context):
|
|
"""Verify the loaded action retains all description fields."""
|
|
assert context.action_domain.description == "A short description"
|
|
assert context.action_domain.long_description == "A long description of the action"
|
|
assert (
|
|
context.action_domain.definition_of_done == "All tests pass and coverage > 80%"
|
|
)
|
|
|
|
|
|
@then("the loaded action should preserve its actor assignments")
|
|
def step_verify_action_domain_actors(context):
|
|
"""Verify the loaded action retains all actor assignments."""
|
|
assert context.action_domain.strategy_actor == "local/strategy-actor"
|
|
assert context.action_domain.execution_actor == "local/execution-actor"
|
|
assert context.action_domain.estimation_actor == "local/estimation-actor"
|
|
assert context.action_domain.review_actor == "local/review-actor"
|
|
|
|
|
|
@then("the loaded action should preserve its state and flags")
|
|
def step_verify_action_domain_state_flags(context):
|
|
"""Verify the loaded action retains its state and boolean flags."""
|
|
from cleveragents.domain.models.core.action import ActionState
|
|
|
|
assert context.action_domain.state == ActionState.AVAILABLE
|
|
assert context.action_domain.reusable is True
|
|
assert context.action_domain.read_only is False
|
|
|
|
|
|
@then("the loaded action should preserve its timestamps")
|
|
def step_verify_action_domain_timestamps(context):
|
|
"""Verify the loaded action retains its timestamps."""
|
|
assert context.action_domain.created_at == datetime.fromisoformat(
|
|
"2025-06-01T12:00:00"
|
|
)
|
|
assert context.action_domain.updated_at == datetime.fromisoformat(
|
|
"2025-06-01T13:00:00"
|
|
)
|
|
|
|
|
|
@then("the loaded action should preserve its tags")
|
|
def step_verify_action_domain_tags(context):
|
|
"""Verify the loaded action retains its tags."""
|
|
assert context.action_domain.tags == ["tag1", "tag2"]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: loading a stored record with arguments
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("an action record exists with a structured arguments schema")
|
|
def step_create_action_model_with_args(context):
|
|
"""Persist an action record that has structured input arguments via child table."""
|
|
context.action_model = _make_action_model()
|
|
# Add arguments via the child table
|
|
context.action_model.arguments_rel.append(
|
|
ActionArgumentModel(
|
|
name="target_coverage",
|
|
arg_type="integer",
|
|
requirement="required",
|
|
description="Target coverage percentage",
|
|
position=0,
|
|
)
|
|
)
|
|
context.action_model.arguments_rel.append(
|
|
ActionArgumentModel(
|
|
name="framework",
|
|
arg_type="string",
|
|
requirement="optional",
|
|
description="Test framework to use",
|
|
position=1,
|
|
)
|
|
)
|
|
context.db_session.add(context.action_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@then("the loaded action should contain the expected argument entries")
|
|
def step_verify_action_arguments_parsed(context):
|
|
"""Verify the loaded action contains the expected number of arguments."""
|
|
assert len(context.action_domain.arguments) == 2
|
|
|
|
|
|
@then("each argument entry should have the correct name and type")
|
|
def step_verify_action_argument_details(context):
|
|
"""Verify each argument entry has the correct name."""
|
|
args = context.action_domain.arguments
|
|
assert args[0].name == "target_coverage"
|
|
assert args[1].name == "framework"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: loading a record with no inputs or tags
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("an action record exists with no inputs and no tags")
|
|
def step_create_action_model_empty_inputs_tags(context):
|
|
"""Persist an action record with empty inputs and tags."""
|
|
context.action_model = _make_action_model(inputs_schema="[]", tags="[]")
|
|
context.db_session.add(context.action_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@then("the loaded action should have an empty arguments collection")
|
|
def step_verify_empty_arguments(context):
|
|
"""Verify the loaded action has no arguments."""
|
|
assert context.action_domain.arguments == []
|
|
|
|
|
|
@then("the loaded action should have an empty tags collection")
|
|
def step_verify_empty_tags(context):
|
|
"""Verify the loaded action has no tags."""
|
|
assert context.action_domain.tags == []
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: storing a domain object as a database record
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a complete action domain object is prepared")
|
|
def step_create_action_domain_object(context):
|
|
"""Prepare a fully populated action domain object."""
|
|
from cleveragents.domain.models.core.action import (
|
|
Action,
|
|
ActionArgument,
|
|
ActionState,
|
|
)
|
|
from cleveragents.domain.models.core.plan import NamespacedName
|
|
|
|
context.action_domain_input = Action(
|
|
namespaced_name=NamespacedName(namespace="local", name="my-action"),
|
|
description="Short desc",
|
|
long_description="Long desc",
|
|
definition_of_done="All tests pass",
|
|
strategy_actor="local/strategy",
|
|
execution_actor="local/executor",
|
|
estimation_actor="local/estimator",
|
|
review_actor="local/reviewer",
|
|
arguments=[
|
|
ActionArgument(
|
|
name="coverage",
|
|
arg_type="int",
|
|
requirement="required",
|
|
description="Coverage target",
|
|
),
|
|
],
|
|
reusable=True,
|
|
read_only=False,
|
|
state=ActionState.AVAILABLE,
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
created_by="test-user",
|
|
tags=["ci", "testing"],
|
|
)
|
|
|
|
|
|
@when("the action domain object is stored as a database record")
|
|
def step_call_from_domain_on_action(context):
|
|
"""Store the action domain object as a database record."""
|
|
context.action_model_result = LifecycleActionModel.from_domain(
|
|
context.action_domain_input
|
|
)
|
|
|
|
|
|
@then("the stored record should preserve the action identifier")
|
|
def step_verify_from_domain_action_id(context):
|
|
"""Verify the stored record retains the action identifier (namespaced_name)."""
|
|
assert context.action_model_result.namespaced_name == "local/my-action"
|
|
|
|
|
|
@then("the stored record should preserve the name components")
|
|
def step_verify_from_domain_name_fields(context):
|
|
"""Verify the stored record retains name, namespace, and short name."""
|
|
assert context.action_model_result.namespaced_name == "local/my-action"
|
|
assert context.action_model_result.namespace == "local"
|
|
assert context.action_model_result.name == "my-action"
|
|
|
|
|
|
@then("the stored record should preserve the description fields")
|
|
def step_verify_from_domain_descriptions(context):
|
|
"""Verify the stored record retains all description fields."""
|
|
assert context.action_model_result.description == "Short desc"
|
|
assert context.action_model_result.long_description == "Long desc"
|
|
assert context.action_model_result.definition_of_done == "All tests pass"
|
|
|
|
|
|
@then("the stored record should preserve the actor assignments")
|
|
def step_verify_from_domain_actors(context):
|
|
"""Verify the stored record retains all actor assignments."""
|
|
assert context.action_model_result.strategy_actor == "local/strategy"
|
|
assert context.action_model_result.execution_actor == "local/executor"
|
|
assert context.action_model_result.estimation_actor == "local/estimator"
|
|
assert context.action_model_result.review_actor == "local/reviewer"
|
|
|
|
|
|
@then("the stored record should serialize the arguments as JSON")
|
|
def step_verify_from_domain_inputs_schema(context):
|
|
"""Verify the stored record has arguments stored via child table."""
|
|
args = context.action_model_result.arguments_rel
|
|
assert len(args) == 1
|
|
assert args[0].name == "coverage"
|
|
|
|
|
|
@then("the stored record should serialize the tags as JSON")
|
|
def step_verify_from_domain_tags_json(context):
|
|
"""Verify the stored record has tags serialized as JSON."""
|
|
parsed = json.loads(context.action_model_result.tags_json)
|
|
assert parsed == ["ci", "testing"]
|
|
|
|
|
|
@then("the stored record should preserve the state value")
|
|
def step_verify_from_domain_state(context):
|
|
"""Verify the stored record retains the state value."""
|
|
assert context.action_model_result.state == "available"
|
|
|
|
|
|
@then("the stored record should format timestamps as ISO strings")
|
|
def step_verify_from_domain_timestamps(context):
|
|
"""Verify the stored record formats timestamps as ISO strings."""
|
|
assert context.action_model_result.created_at == "2025-06-01T12:00:00"
|
|
assert context.action_model_result.updated_at == "2025-06-01T13:00:00"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: storing with an enumerated state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("an action domain object is prepared with an enumerated state")
|
|
def step_create_action_with_enum_state(context):
|
|
"""Prepare an action domain object that uses an ActionState enum value."""
|
|
from cleveragents.domain.models.core.action import Action, ActionState
|
|
from cleveragents.domain.models.core.plan import NamespacedName
|
|
|
|
context.action_domain_input = Action(
|
|
namespaced_name=NamespacedName(namespace="local", name="enum-action"),
|
|
description="Enum state action",
|
|
definition_of_done="Tests pass",
|
|
strategy_actor="local/strategy",
|
|
execution_actor="local/executor",
|
|
state=ActionState.AVAILABLE,
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
)
|
|
|
|
|
|
@then("the stored record state should equal the enum value")
|
|
def step_verify_enum_state_value(context):
|
|
"""Verify the stored record state is the string value of the enum."""
|
|
assert context.action_model_result.state == "available"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Action: storing with a custom string state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("an action-like object is prepared with a custom string state")
|
|
def step_create_action_with_string_state(context):
|
|
"""Prepare an action-like object with a plain string state."""
|
|
from types import SimpleNamespace
|
|
|
|
from cleveragents.domain.models.core.plan import NamespacedName
|
|
|
|
context.action_domain_string_state = SimpleNamespace(
|
|
namespaced_name=NamespacedName(namespace="local", name="str-action"),
|
|
description="Desc",
|
|
long_description="Long",
|
|
definition_of_done="Done",
|
|
strategy_actor="local/strategy",
|
|
execution_actor="local/executor",
|
|
estimation_actor=None,
|
|
review_actor=None,
|
|
apply_actor=None,
|
|
invariant_actor=None,
|
|
arguments=[],
|
|
inputs_schema=None,
|
|
invariants=[],
|
|
automation_profile=None,
|
|
reusable=True,
|
|
read_only=False,
|
|
state="custom-state",
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
created_by=None,
|
|
tags=[],
|
|
)
|
|
|
|
|
|
@when("the custom-state action is stored as a database record")
|
|
def step_call_from_domain_string_state(context):
|
|
"""Store the custom-state action as a database record."""
|
|
context.action_model_result = LifecycleActionModel.from_domain(
|
|
context.action_domain_string_state
|
|
)
|
|
|
|
|
|
@then("the stored record state should equal the custom string")
|
|
def step_verify_plain_string_state(context):
|
|
"""Verify the stored record state is the plain custom string."""
|
|
assert context.action_model_result.state == "custom-state"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: parsing ISO timestamps
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when("a valid ISO-8601 string is parsed as a timestamp")
|
|
def step_call_parse_iso_valid(context):
|
|
"""Parse a valid ISO-8601 string as a timestamp."""
|
|
context.parse_iso_result = LifecyclePlanModel._parse_iso("2025-06-01T12:00:00")
|
|
|
|
|
|
@then("the parsed timestamp should be the expected datetime value")
|
|
def step_verify_parse_iso_datetime(context):
|
|
"""Verify the parsed timestamp matches the expected datetime."""
|
|
assert isinstance(context.parse_iso_result, datetime)
|
|
assert context.parse_iso_result == datetime(2025, 6, 1, 12, 0, 0)
|
|
|
|
|
|
@when("an absent value is parsed as a timestamp")
|
|
def step_call_parse_iso_none(context):
|
|
"""Parse an absent (None) value as a timestamp."""
|
|
context.parse_iso_result = LifecyclePlanModel._parse_iso(None)
|
|
|
|
|
|
@then("the parsed timestamp should be absent")
|
|
def step_verify_parse_iso_none(context):
|
|
"""Verify parsing an absent value returns nothing."""
|
|
assert context.parse_iso_result is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: formatting datetimes as ISO strings
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when("a datetime value is formatted as an ISO string")
|
|
def step_call_to_iso_datetime(context):
|
|
"""Format a datetime value as an ISO string."""
|
|
context.to_iso_result = LifecyclePlanModel._to_iso(datetime(2025, 6, 1, 12, 0, 0))
|
|
|
|
|
|
@then("the formatted string should match ISO-8601 format")
|
|
def step_verify_to_iso_string(context):
|
|
"""Verify the formatted string matches ISO-8601 format."""
|
|
assert context.to_iso_result == "2025-06-01T12:00:00"
|
|
|
|
|
|
@when("an absent datetime is formatted as an ISO string")
|
|
def step_call_to_iso_none(context):
|
|
"""Format an absent (None) datetime as an ISO string."""
|
|
context.to_iso_result = LifecyclePlanModel._to_iso(None)
|
|
|
|
|
|
@then("the formatted value should be absent")
|
|
def step_verify_to_iso_none(context):
|
|
"""Verify formatting an absent datetime returns nothing."""
|
|
assert context.to_iso_result is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: loading a stored record in the strategize phase
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan record exists in the strategize phase with queued state")
|
|
def step_create_plan_model_strategize_queued(context):
|
|
"""Persist a plan record in the strategize phase with queued state."""
|
|
action_model = _make_action_model()
|
|
context.db_session.add(action_model)
|
|
context.db_session.commit()
|
|
|
|
context.plan_model = _make_plan_model(
|
|
phase="strategize",
|
|
state="queued",
|
|
project_names='["proj-1", "proj-2"]',
|
|
tags='["important"]',
|
|
)
|
|
context.db_session.add(context.plan_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@when("the plan record is loaded as a domain object")
|
|
def step_call_to_domain_on_plan(context):
|
|
"""Load the persisted plan record as a domain object."""
|
|
context.plan_domain = context.plan_model.to_domain()
|
|
|
|
|
|
@then("the loaded plan should preserve its identity")
|
|
def step_verify_plan_identity(context):
|
|
"""Verify the loaded plan retains its identifier and attempt."""
|
|
assert context.plan_domain.identity.plan_id == VALID_ULID_1
|
|
assert context.plan_domain.identity.attempt == 1
|
|
|
|
|
|
@then("the loaded plan processing state should be queued")
|
|
def step_verify_plan_processing_state_queued(context):
|
|
"""Verify the loaded plan has QUEUED processing state."""
|
|
from cleveragents.domain.models.core.plan import ProcessingState
|
|
|
|
assert context.plan_domain.processing_state == ProcessingState.QUEUED
|
|
|
|
|
|
@then("the loaded plan should preserve its description")
|
|
def step_verify_plan_description(context):
|
|
"""Verify the loaded plan retains its description."""
|
|
assert context.plan_domain.description == "A test plan description"
|
|
|
|
|
|
@then("the loaded plan should preserve its timestamps")
|
|
def step_verify_plan_timestamps(context):
|
|
"""Verify the loaded plan retains its timestamps."""
|
|
assert context.plan_domain.timestamps.created_at == datetime.fromisoformat(
|
|
"2025-06-01T12:00:00"
|
|
)
|
|
assert context.plan_domain.timestamps.updated_at == datetime.fromisoformat(
|
|
"2025-06-01T13:00:00"
|
|
)
|
|
|
|
|
|
@then("the loaded plan should preserve its metadata")
|
|
def step_verify_plan_metadata(context):
|
|
"""Verify the loaded plan retains its metadata fields."""
|
|
assert context.plan_domain.created_by == "test-user"
|
|
assert context.plan_domain.reusable is True
|
|
assert context.plan_domain.read_only is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: loading a stored record in the strategize phase
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan record exists in the strategize phase with processing state")
|
|
def step_create_plan_model_strategize(context):
|
|
"""Persist a plan record in the strategize phase."""
|
|
existing = (
|
|
context.db_session.query(LifecycleActionModel)
|
|
.filter_by(namespaced_name="local/test-action")
|
|
.first()
|
|
)
|
|
if not existing:
|
|
action_model = _make_action_model()
|
|
context.db_session.add(action_model)
|
|
context.db_session.commit()
|
|
|
|
context.plan_model = _make_plan_model(
|
|
plan_id=VALID_ULID_2,
|
|
phase="strategize",
|
|
state="processing",
|
|
)
|
|
context.db_session.add(context.plan_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@then("the loaded plan should be in the strategize phase")
|
|
def step_verify_plan_strategize_phase(context):
|
|
"""Verify the loaded plan is in the strategize phase."""
|
|
from cleveragents.domain.models.core.plan import PlanPhase
|
|
|
|
assert context.plan_domain.phase == PlanPhase.STRATEGIZE
|
|
|
|
|
|
@then("the loaded plan processing state should be processing")
|
|
def step_verify_plan_processing_state(context):
|
|
"""Verify the loaded plan processing state is processing."""
|
|
from cleveragents.domain.models.core.plan import ProcessingState
|
|
|
|
assert context.plan_domain.state == ProcessingState.PROCESSING
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: loading a record with all phase timestamps
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan record exists with all phase timestamps populated")
|
|
def step_create_plan_model_all_timestamps(context):
|
|
"""Persist a plan record with all phase timestamps filled."""
|
|
existing = (
|
|
context.db_session.query(LifecycleActionModel)
|
|
.filter_by(namespaced_name="local/test-action")
|
|
.first()
|
|
)
|
|
if not existing:
|
|
action_model = _make_action_model()
|
|
context.db_session.add(action_model)
|
|
context.db_session.commit()
|
|
|
|
context.plan_model = _make_plan_model(
|
|
plan_id=VALID_ULID_3,
|
|
phase="apply",
|
|
state="complete",
|
|
strategize_started_at="2025-06-01T14:00:00",
|
|
strategize_completed_at="2025-06-01T14:30:00",
|
|
execute_started_at="2025-06-01T15:00:00",
|
|
execute_completed_at="2025-06-01T15:30:00",
|
|
apply_started_at="2025-06-01T16:00:00",
|
|
applied_at="2025-06-01T16:30:00",
|
|
)
|
|
context.db_session.add(context.plan_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@then("the loaded plan timestamps should include the strategize window")
|
|
def step_verify_strategize_timestamps(context):
|
|
"""Verify the loaded plan has correct strategize timestamps."""
|
|
ts = context.plan_domain.timestamps
|
|
assert ts.strategize_started_at == datetime(2025, 6, 1, 14, 0, 0)
|
|
assert ts.strategize_completed_at == datetime(2025, 6, 1, 14, 30, 0)
|
|
|
|
|
|
@then("the loaded plan timestamps should include the execute window")
|
|
def step_verify_execute_timestamps(context):
|
|
"""Verify the loaded plan has correct execute timestamps."""
|
|
ts = context.plan_domain.timestamps
|
|
assert ts.execute_started_at == datetime(2025, 6, 1, 15, 0, 0)
|
|
assert ts.execute_completed_at == datetime(2025, 6, 1, 15, 30, 0)
|
|
|
|
|
|
@then("the loaded plan timestamps should include the apply window")
|
|
def step_verify_apply_timestamps(context):
|
|
"""Verify the loaded plan has correct apply timestamps."""
|
|
ts = context.plan_domain.timestamps
|
|
assert ts.apply_started_at == datetime(2025, 6, 1, 16, 0, 0)
|
|
assert ts.applied_at == datetime(2025, 6, 1, 16, 30, 0)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: loading a record with project IDs and tags
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan record exists with associated project identifiers and tags")
|
|
def step_create_plan_model_with_ids_tags(context):
|
|
"""Persist a plan record with project identifiers and tags."""
|
|
existing = (
|
|
context.db_session.query(LifecycleActionModel)
|
|
.filter_by(namespaced_name="local/test-action")
|
|
.first()
|
|
)
|
|
if not existing:
|
|
action_model = _make_action_model()
|
|
context.db_session.add(action_model)
|
|
context.db_session.commit()
|
|
|
|
context.plan_model = _make_plan_model(
|
|
plan_id=VALID_ULID_4,
|
|
phase="strategize",
|
|
state="queued",
|
|
project_names='["proj-a", "proj-b", "proj-c"]',
|
|
tags='["urgent", "backend"]',
|
|
)
|
|
context.db_session.add(context.plan_model)
|
|
context.db_session.commit()
|
|
|
|
|
|
@then("the loaded plan should contain the expected project identifiers")
|
|
def step_verify_plan_project_ids(context):
|
|
"""Verify the loaded plan contains the expected project identifiers."""
|
|
project_names = [link.project_name for link in context.plan_domain.project_links]
|
|
assert project_names == ["proj-a", "proj-b", "proj-c"]
|
|
|
|
|
|
@then("the loaded plan should contain the expected tags")
|
|
def step_verify_plan_tags(context):
|
|
"""Verify the loaded plan contains the expected tags."""
|
|
assert context.plan_domain.tags == ["urgent", "backend"]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with processing state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _make_plan_domain(
|
|
phase="strategize",
|
|
processing_state=None,
|
|
plan_id=VALID_ULID_1,
|
|
project_links=None,
|
|
tags=None,
|
|
timestamps=None,
|
|
):
|
|
"""Create a Plan domain object for testing storage."""
|
|
from cleveragents.domain.models.core.plan import (
|
|
NamespacedName,
|
|
Plan,
|
|
PlanIdentity,
|
|
PlanPhase,
|
|
PlanTimestamps,
|
|
ProcessingState,
|
|
ProjectLink,
|
|
)
|
|
|
|
if project_links is None:
|
|
project_links = [ProjectLink(project_name="proj-1")]
|
|
if tags is None:
|
|
tags = ["test"]
|
|
if timestamps is None:
|
|
timestamps = PlanTimestamps(
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
)
|
|
|
|
resolved_processing = (
|
|
processing_state if processing_state is not None else ProcessingState.QUEUED
|
|
)
|
|
|
|
return Plan(
|
|
identity=PlanIdentity(plan_id=plan_id),
|
|
namespaced_name=NamespacedName(namespace="local", name="test-plan"),
|
|
action_name="local/test-action",
|
|
description="Test plan description",
|
|
definition_of_done="Tests pass",
|
|
phase=PlanPhase(phase),
|
|
processing_state=resolved_processing,
|
|
strategy_actor="local/strategy",
|
|
execution_actor="local/executor",
|
|
project_links=project_links,
|
|
timestamps=timestamps,
|
|
created_by="test-user",
|
|
tags=tags,
|
|
reusable=True,
|
|
read_only=False,
|
|
)
|
|
|
|
|
|
@given("a plan domain object is prepared in the action phase with an available state")
|
|
def step_create_plan_domain_action_available(context):
|
|
"""Prepare a plan domain object in the strategize phase with queued state."""
|
|
from cleveragents.domain.models.core.plan import ProcessingState, ProjectLink
|
|
|
|
context.plan_domain_input = _make_plan_domain(
|
|
phase="strategize",
|
|
processing_state=ProcessingState.QUEUED,
|
|
project_links=[
|
|
ProjectLink(project_name="proj-1"),
|
|
ProjectLink(project_name="proj-2"),
|
|
],
|
|
tags=["ci", "test"],
|
|
)
|
|
|
|
|
|
@when("the plan domain object is stored as a database record")
|
|
def step_call_from_domain_on_plan(context):
|
|
"""Store the plan domain object as a database record."""
|
|
context.plan_model_result = LifecyclePlanModel.from_domain(
|
|
context.plan_domain_input
|
|
)
|
|
|
|
|
|
@then('the stored plan record should have state "{expected_state}"')
|
|
def step_verify_from_domain_plan_state(context, expected_state):
|
|
"""Verify the stored plan record has the expected processing_state."""
|
|
assert context.plan_model_result.processing_state == expected_state
|
|
|
|
|
|
@then("the stored plan record should preserve the plan identifier")
|
|
def step_verify_from_domain_plan_id(context):
|
|
"""Verify the stored plan record retains the plan identifier."""
|
|
assert context.plan_model_result.plan_id == VALID_ULID_1
|
|
|
|
|
|
@then("the stored plan record should preserve the phase")
|
|
def step_verify_from_domain_plan_phase(context):
|
|
"""Verify the stored plan record retains the phase."""
|
|
assert context.plan_model_result.phase == "strategize"
|
|
|
|
|
|
@then("the stored plan record should serialize the project identifiers as JSON")
|
|
def step_verify_from_domain_project_ids(context):
|
|
"""Verify the stored plan record has project links via child table."""
|
|
project_names = [
|
|
pl.project_name for pl in context.plan_model_result.project_links_rel
|
|
]
|
|
assert project_names == ["proj-1", "proj-2"]
|
|
|
|
|
|
@then("the stored plan record should serialize the plan tags as JSON")
|
|
def step_verify_from_domain_plan_tags(context):
|
|
"""Verify the stored plan record has tags serialized as JSON."""
|
|
parsed = json.loads(context.plan_model_result.tags_json)
|
|
assert parsed == ["ci", "test"]
|
|
|
|
|
|
@then("the stored plan record should format plan timestamps as ISO strings")
|
|
def step_verify_from_domain_plan_timestamps(context):
|
|
"""Verify the stored plan record has timestamps as ISO strings."""
|
|
assert context.plan_model_result.created_at == "2025-06-01T12:00:00"
|
|
assert context.plan_model_result.updated_at == "2025-06-01T13:00:00"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with processing state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan domain object is prepared in the strategize phase with a queued state")
|
|
def step_create_plan_domain_strategize_queued(context):
|
|
"""Prepare a plan domain object in the strategize phase with queued state."""
|
|
from cleveragents.domain.models.core.plan import ProcessingState, ProjectLink
|
|
|
|
context.plan_domain_input = _make_plan_domain(
|
|
phase="strategize",
|
|
processing_state=ProcessingState.QUEUED,
|
|
project_links=[
|
|
ProjectLink(project_name="proj-1"),
|
|
ProjectLink(project_name="proj-2"),
|
|
],
|
|
tags=["ci", "test"],
|
|
)
|
|
|
|
|
|
@then('the stored plan record phase should be "{expected_phase}"')
|
|
def step_verify_from_domain_plan_phase_value(context, expected_phase):
|
|
"""Verify the stored plan record has the expected phase."""
|
|
assert context.plan_model_result.phase == expected_phase
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with no explicit state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan domain object is prepared with neither action nor processing state")
|
|
def step_create_plan_domain_null_states(context):
|
|
"""Prepare a plan-like object with no explicit state to test the fallback."""
|
|
from types import SimpleNamespace
|
|
|
|
from cleveragents.domain.models.core.plan import (
|
|
NamespacedName,
|
|
PlanIdentity,
|
|
PlanPhase,
|
|
PlanTimestamps,
|
|
)
|
|
|
|
context.plan_domain_stateless = SimpleNamespace(
|
|
identity=PlanIdentity(plan_id=VALID_ULID_1),
|
|
namespaced_name=NamespacedName(namespace="local", name="null-plan"),
|
|
action_name="local/test-action",
|
|
description="Null state plan",
|
|
definition_of_done="Done",
|
|
phase=PlanPhase.STRATEGIZE,
|
|
processing_state=None,
|
|
automation_profile=None,
|
|
strategy_actor="local/strategy",
|
|
execution_actor="local/executor",
|
|
review_actor=None,
|
|
apply_actor=None,
|
|
estimation_actor=None,
|
|
invariant_actor=None,
|
|
project_links=[],
|
|
invariants=[],
|
|
arguments={},
|
|
arguments_order=[],
|
|
changeset_id=None,
|
|
sandbox_refs=[],
|
|
validation_summary=None,
|
|
decision_root_id=None,
|
|
timestamps=PlanTimestamps(
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
),
|
|
error_message=None,
|
|
created_by=None,
|
|
tags=[],
|
|
reusable=True,
|
|
read_only=False,
|
|
)
|
|
|
|
|
|
@when("the stateless plan domain object is stored as a database record")
|
|
def step_call_from_domain_stateless(context):
|
|
"""Store the stateless plan as a database record."""
|
|
context.plan_model_result = LifecyclePlanModel.from_domain(
|
|
context.plan_domain_stateless
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with all phase timestamps
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a plan domain object is prepared with all phase timestamps")
|
|
def step_create_plan_domain_all_timestamps(context):
|
|
"""Prepare a plan domain object with all phase timestamps."""
|
|
from cleveragents.domain.models.core.plan import PlanTimestamps
|
|
|
|
timestamps = PlanTimestamps(
|
|
created_at=datetime(2025, 6, 1, 12, 0, 0),
|
|
updated_at=datetime(2025, 6, 1, 13, 0, 0),
|
|
strategize_started_at=datetime(2025, 6, 1, 14, 0, 0),
|
|
strategize_completed_at=datetime(2025, 6, 1, 14, 30, 0),
|
|
execute_started_at=datetime(2025, 6, 1, 15, 0, 0),
|
|
execute_completed_at=datetime(2025, 6, 1, 15, 30, 0),
|
|
apply_started_at=datetime(2025, 6, 1, 16, 0, 0),
|
|
applied_at=datetime(2025, 6, 1, 16, 30, 0),
|
|
)
|
|
|
|
context.plan_domain_input = _make_plan_domain(
|
|
phase="strategize",
|
|
timestamps=timestamps,
|
|
)
|
|
|
|
|
|
@then("the stored plan record should have all phase timestamps as ISO strings")
|
|
def step_verify_from_domain_all_timestamps(context):
|
|
"""Verify all phase timestamp columns are formatted as ISO strings."""
|
|
m = context.plan_model_result
|
|
assert m.strategize_started_at == "2025-06-01T14:00:00"
|
|
assert m.strategize_completed_at == "2025-06-01T14:30:00"
|
|
assert m.execute_started_at == "2025-06-01T15:00:00"
|
|
assert m.execute_completed_at == "2025-06-01T15:30:00"
|
|
assert m.apply_started_at == "2025-06-01T16:00:00"
|
|
assert m.applied_at == "2025-06-01T16:30:00"
|
|
assert m.completed_at == "2025-06-01T16:30:00"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with non-default automation level
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given('a plan domain object is prepared with automation level "{level}"')
|
|
def step_create_plan_domain_with_automation_level(context, level):
|
|
"""Prepare a plan domain object (automation_level removed, uses profile)."""
|
|
context.plan_domain_input = _make_plan_domain(
|
|
phase="strategize",
|
|
)
|
|
|
|
|
|
@then('the stored plan record automation level should be "{expected_level}"')
|
|
def step_verify_from_domain_automation_level(context, expected_level):
|
|
"""Verify the stored plan record (automation_level column removed)."""
|
|
# automation_level column was removed; this step is a no-op
|
|
pass
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plan: storing a domain object with an explicit action_id
|
|
# ---------------------------------------------------------------------------
|
|
|
|
VALID_ULID_ACTION = "01JACTION000000000000ACTION"
|
|
|
|
|
|
@when("the plan domain object is stored with an explicit action identifier")
|
|
def step_call_from_domain_with_action_id(context):
|
|
"""Store the plan domain object with an explicit action_name."""
|
|
context.plan_model_result = LifecyclePlanModel.from_domain(
|
|
context.plan_domain_input,
|
|
action_name=VALID_ULID_ACTION,
|
|
)
|
|
|
|
|
|
@then("the stored plan record should preserve the supplied action identifier")
|
|
def step_verify_from_domain_action_id(context):
|
|
"""Verify the stored plan record retains the supplied action_id."""
|
|
assert (
|
|
context.plan_model_result.action_name == VALID_ULID_ACTION
|
|
) # still passed explicitly
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Round-trip persistence tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@when("the action is saved to the database and reloaded as a domain object")
|
|
def step_convert_and_persist_action(context):
|
|
"""Save the action to the database and reload it as a domain object."""
|
|
context.action_model_persisted = LifecycleActionModel.from_domain(
|
|
context.action_domain_input
|
|
)
|
|
context.db_session.add(context.action_model_persisted)
|
|
context.db_session.commit()
|
|
|
|
context.action_model_retrieved = (
|
|
context.db_session.query(LifecycleActionModel)
|
|
.filter_by(namespaced_name=context.action_model_persisted.namespaced_name)
|
|
.first()
|
|
)
|
|
assert context.action_model_retrieved is not None
|
|
context.action_round_tripped = context.action_model_retrieved.to_domain()
|
|
|
|
|
|
@then("the reloaded action should match the original action")
|
|
def step_verify_round_trip_action(context):
|
|
"""Verify the reloaded action matches the original."""
|
|
original = context.action_domain_input
|
|
result = context.action_round_tripped
|
|
assert str(result.namespaced_name) == str(original.namespaced_name)
|
|
assert result.definition_of_done == original.definition_of_done
|
|
assert result.strategy_actor == original.strategy_actor
|
|
assert result.execution_actor == original.execution_actor
|
|
assert result.reusable == original.reusable
|
|
assert result.read_only == original.read_only
|
|
assert result.tags == original.tags
|
|
assert len(result.arguments) == len(original.arguments)
|
|
|
|
|
|
@when("the plan record is saved and then reloaded as a domain object")
|
|
def step_persist_and_reload_plan(context):
|
|
"""Save the plan record and reload it as a domain object."""
|
|
# Plan was already persisted in the Given step
|
|
context.plan_model_retrieved = (
|
|
context.db_session.query(LifecyclePlanModel)
|
|
.filter_by(plan_id=context.plan_model.plan_id)
|
|
.first()
|
|
)
|
|
assert context.plan_model_retrieved is not None
|
|
context.plan_round_tripped = context.plan_model_retrieved.to_domain()
|
|
|
|
|
|
@then("the reloaded plan should preserve its identity and phase")
|
|
def step_verify_round_trip_plan(context):
|
|
"""Verify the reloaded plan retains its identity and phase."""
|
|
from cleveragents.domain.models.core.plan import PlanPhase
|
|
|
|
result = context.plan_round_tripped
|
|
assert result.identity.plan_id == VALID_ULID_1
|
|
assert result.phase == PlanPhase.STRATEGIZE
|
|
assert result.description == "A test plan description"
|
|
assert result.created_by == "test-user"
|