forked from HAL9000/cleveragents-core
freemo
2e24483947
Add Markdown export format for sessions alongside the existing JSON export. Implement TUI slash command routing for /session:export and /session:import. - Add Session.as_export_markdown() domain method producing a human-readable Markdown transcript (lossy, not importable — for sharing/documentation) - Extend CLI 'agents session export' with --format flag (json|md) - Extend TuiCommandRouter._session_command() to handle 'export' and 'import' subcommands, delegating to the session service via the DI container - Add 16 Behave scenarios covering domain model, CLI, and TUI command paths Closes #1004
404 lines
13 KiB
Python
404 lines
13 KiB
Python
"""Step definitions for tui_session_export_import.feature.
|
|
|
|
Tests for:
|
|
- Session.as_export_markdown() domain method
|
|
- CLI export --format md flag
|
|
- TUI TuiCommandRouter /session export and /session import commands
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import tempfile
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from behave import given, then, when
|
|
from behave.runner import Context
|
|
from typer.testing import CliRunner
|
|
from ulid import ULID
|
|
|
|
from cleveragents.cli.commands import session as session_mod
|
|
from cleveragents.cli.commands.session import app as session_app
|
|
from cleveragents.domain.models.core.session import (
|
|
MessageRole,
|
|
Session,
|
|
SessionMessage,
|
|
SessionTokenUsage,
|
|
)
|
|
from cleveragents.tui.commands import TuiCommandRouter
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _make_session(
|
|
*,
|
|
session_id: str | None = None,
|
|
actor_name: str | None = None,
|
|
messages: list[SessionMessage] | None = None,
|
|
linked_plan_ids: list[str] | None = None,
|
|
) -> Session:
|
|
return Session(
|
|
session_id=session_id or str(ULID()),
|
|
actor_name=actor_name,
|
|
namespace="local",
|
|
messages=messages or [],
|
|
linked_plan_ids=linked_plan_ids or [],
|
|
token_usage=SessionTokenUsage(
|
|
input_tokens=10,
|
|
output_tokens=5,
|
|
estimated_cost=0.001,
|
|
),
|
|
created_at=datetime(2026, 1, 1, 12, 0, 0),
|
|
updated_at=datetime(2026, 1, 1, 12, 30, 0),
|
|
)
|
|
|
|
|
|
def _make_message(
|
|
role: MessageRole = MessageRole.USER,
|
|
content: str = "Hello",
|
|
sequence: int = 0,
|
|
) -> SessionMessage:
|
|
return SessionMessage(
|
|
message_id=str(ULID()),
|
|
role=role,
|
|
content=content,
|
|
sequence=sequence,
|
|
timestamp=datetime(2026, 1, 1, 12, sequence, 0),
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class FakePersona:
|
|
name: str
|
|
|
|
|
|
@dataclass
|
|
class FakePersonaRegistry:
|
|
_personas: list[FakePersona] = field(default_factory=list)
|
|
personas_dir: Path = field(default_factory=lambda: Path("/tmp/fake-personas"))
|
|
|
|
def list_personas(self) -> list[FakePersona]:
|
|
return list(self._personas)
|
|
|
|
|
|
@dataclass
|
|
class FakePersonaState:
|
|
_active: dict[str, FakePersona] = field(default_factory=dict)
|
|
|
|
def set_active_persona(self, session_id: str, name: str) -> FakePersona:
|
|
persona = FakePersona(name=name)
|
|
self._active[session_id] = persona
|
|
return persona
|
|
|
|
def active_name(self, session_id: str) -> str | None:
|
|
p = self._active.get(session_id)
|
|
return p.name if p else None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Domain model: as_export_markdown()
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("a session with two messages for markdown export")
|
|
def step_session_two_messages(context: Context) -> None:
|
|
msgs = [
|
|
_make_message(MessageRole.USER, "Hello from user", 0),
|
|
_make_message(MessageRole.ASSISTANT, "Hello from assistant", 1),
|
|
]
|
|
context.md_session = _make_session(messages=msgs)
|
|
|
|
|
|
@given("a session with no messages for markdown export")
|
|
def step_session_no_messages(context: Context) -> None:
|
|
context.md_session = _make_session()
|
|
|
|
|
|
@given('a session with actor "{actor}" for markdown export')
|
|
def step_session_with_actor(context: Context, actor: str) -> None:
|
|
context.md_session = _make_session(actor_name=actor)
|
|
|
|
|
|
@given("a session with linked plans for markdown export")
|
|
def step_session_with_linked_plans(context: Context) -> None:
|
|
context.md_session = _make_session(linked_plan_ids=[str(ULID()), str(ULID())])
|
|
|
|
|
|
@when("I call as_export_markdown on the session")
|
|
def step_call_as_export_markdown(context: Context) -> None:
|
|
context.md_output = context.md_session.as_export_markdown()
|
|
|
|
|
|
@then('the markdown output should start with "{prefix}"')
|
|
def step_md_starts_with(context: Context, prefix: str) -> None:
|
|
assert context.md_output.startswith(prefix), (
|
|
f"Expected markdown to start with {prefix!r}, got: {context.md_output[:80]!r}"
|
|
)
|
|
|
|
|
|
@then('the markdown output should contain "{text}"')
|
|
def step_md_contains(context: Context, text: str) -> None:
|
|
assert text in context.md_output, (
|
|
f"Expected {text!r} in markdown output.\nGot:\n{context.md_output[:500]}"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# CLI export: --format md
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@given("there is a mocked session for markdown export")
|
|
def step_mocked_session_for_md_export(context: Context) -> None:
|
|
context.runner = CliRunner()
|
|
context.mock_service = MagicMock()
|
|
session_id = str(ULID())
|
|
context.session_id = session_id
|
|
|
|
msgs = [
|
|
_make_message(MessageRole.USER, "Test user message", 0),
|
|
_make_message(MessageRole.ASSISTANT, "Test assistant reply", 1),
|
|
]
|
|
session = _make_session(session_id=session_id, messages=msgs)
|
|
export_data = session.as_export_dict()
|
|
|
|
context.mock_service.export_session.return_value = export_data
|
|
context.mock_service.get.return_value = session
|
|
|
|
session_mod._service = context.mock_service
|
|
|
|
|
|
def _teardown_mock_service(context: Context) -> None:
|
|
session_mod._service = None
|
|
|
|
|
|
@when("I run session CLI export with --format md and no output file")
|
|
def step_export_md_stdout(context: Context) -> None:
|
|
context.result = context.runner.invoke(
|
|
session_app, ["export", context.session_id, "--format", "md"]
|
|
)
|
|
_teardown_mock_service(context)
|
|
|
|
|
|
@when("I run session CLI export with --format md to a temp file")
|
|
def step_export_md_to_file(context: Context) -> None:
|
|
fd, path = tempfile.mkstemp(suffix=".md")
|
|
os.close(fd)
|
|
os.unlink(path) # Remove so export can create it
|
|
context.export_md_path = path
|
|
context.result = context.runner.invoke(
|
|
session_app,
|
|
["export", context.session_id, "--format", "md", "--output", path],
|
|
)
|
|
_teardown_mock_service(context)
|
|
|
|
|
|
@when("I run session CLI export with no format flag")
|
|
def step_export_default_format(context: Context) -> None:
|
|
context.result = context.runner.invoke(session_app, ["export", context.session_id])
|
|
_teardown_mock_service(context)
|
|
|
|
|
|
@when("I run session CLI export with --format xml")
|
|
def step_export_invalid_format(context: Context) -> None:
|
|
context.result = context.runner.invoke(
|
|
session_app, ["export", context.session_id, "--format", "xml"]
|
|
)
|
|
_teardown_mock_service(context)
|
|
|
|
|
|
@then("the md export CLI result code should be zero")
|
|
def step_cli_md_export_succeeds(context: Context) -> None:
|
|
assert context.result.exit_code == 0, (
|
|
f"Expected exit code 0, got {context.result.exit_code}.\n"
|
|
f"Output: {context.result.output}"
|
|
)
|
|
|
|
|
|
@then("the md export CLI result code should be nonzero")
|
|
def step_cli_md_exit_with_error(context: Context) -> None:
|
|
assert context.result.exit_code != 0, (
|
|
f"Expected non-zero exit code, got {context.result.exit_code}.\n"
|
|
f"Output: {context.result.output}"
|
|
)
|
|
|
|
|
|
@then('the md export CLI output should include "{text}"')
|
|
def step_cli_md_output_contains(context: Context, text: str) -> None:
|
|
assert text in context.result.output, (
|
|
f"Expected {text!r} in CLI output.\nGot: {context.result.output}"
|
|
)
|
|
|
|
|
|
@then("the md export CLI output should be parseable as JSON")
|
|
def step_cli_md_output_valid_json(context: Context) -> None:
|
|
try:
|
|
json.loads(context.result.output)
|
|
except json.JSONDecodeError as exc:
|
|
raise AssertionError(
|
|
f"CLI output is not valid JSON: {exc}\nOutput: {context.result.output}"
|
|
) from exc
|
|
|
|
|
|
@then("the exported markdown file should exist")
|
|
def step_exported_md_file_exists(context: Context) -> None:
|
|
assert os.path.exists(context.export_md_path), (
|
|
f"Markdown export file not found: {context.export_md_path}"
|
|
)
|
|
|
|
|
|
@then('the exported markdown file should contain "{text}"')
|
|
def step_exported_md_file_contains(context: Context, text: str) -> None:
|
|
content = Path(context.export_md_path).read_text(encoding="utf-8")
|
|
assert text in content, (
|
|
f"Expected {text!r} in exported markdown file.\nGot: {content[:500]}"
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# TUI command router: /session export and /session import
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _make_tui_router_with_export_mock(
|
|
session_id: str,
|
|
export_data: dict,
|
|
session_obj: Session,
|
|
) -> tuple[TuiCommandRouter, MagicMock]:
|
|
"""Build a TuiCommandRouter with a mocked container/service for export."""
|
|
mock_service = MagicMock()
|
|
mock_service.export_session.return_value = export_data
|
|
mock_service.get.return_value = session_obj
|
|
|
|
mock_container = MagicMock()
|
|
mock_container.session_service.return_value = mock_service
|
|
|
|
registry = FakePersonaRegistry()
|
|
state = FakePersonaState()
|
|
router = TuiCommandRouter(persona_registry=registry, persona_state=state)
|
|
return router, mock_container
|
|
|
|
|
|
@given("a TUI command router with mocked session service for export")
|
|
def step_tui_router_for_export(context: Context) -> None:
|
|
session_id = str(ULID())
|
|
context.tui_session_id = session_id
|
|
|
|
msgs = [
|
|
_make_message(MessageRole.USER, "TUI user message", 0),
|
|
_make_message(MessageRole.ASSISTANT, "TUI assistant reply", 1),
|
|
]
|
|
session = _make_session(session_id=session_id, messages=msgs)
|
|
export_data = session.as_export_dict()
|
|
|
|
router, mock_container = _make_tui_router_with_export_mock(
|
|
session_id, export_data, session
|
|
)
|
|
context.tui_router = router
|
|
context.tui_mock_container = mock_container
|
|
|
|
|
|
@given("a TUI command router with mocked session service for import")
|
|
def step_tui_router_for_import(context: Context) -> None:
|
|
session_id = str(ULID())
|
|
context.tui_session_id = session_id
|
|
|
|
imported_session = _make_session(session_id=str(ULID()))
|
|
mock_service = MagicMock()
|
|
mock_service.import_session.return_value = imported_session
|
|
|
|
mock_container = MagicMock()
|
|
mock_container.session_service.return_value = mock_service
|
|
|
|
registry = FakePersonaRegistry()
|
|
state = FakePersonaState()
|
|
router = TuiCommandRouter(persona_registry=registry, persona_state=state)
|
|
context.tui_router = router
|
|
context.tui_mock_container = mock_container
|
|
context.tui_imported_session = imported_session
|
|
|
|
|
|
@given("there is a valid JSON export file for TUI import")
|
|
def step_valid_json_export_for_tui(context: Context) -> None:
|
|
msgs = [_make_message(MessageRole.USER, "Import test", 0)]
|
|
session = _make_session(messages=msgs)
|
|
export_data = session.as_export_dict()
|
|
|
|
fd, path = tempfile.mkstemp(suffix=".json")
|
|
with os.fdopen(fd, "w") as fh:
|
|
json.dump(export_data, fh, default=str)
|
|
context.tui_import_path = path
|
|
|
|
|
|
@given("there is an invalid JSON file for TUI import")
|
|
def step_invalid_json_for_tui(context: Context) -> None:
|
|
fd, path = tempfile.mkstemp(suffix=".json")
|
|
with os.fdopen(fd, "w") as fh:
|
|
fh.write("{ not valid json }")
|
|
context.tui_invalid_json_path = path
|
|
|
|
|
|
@when('I call TUI handle with "{command}" for the current session')
|
|
def step_tui_handle_command(context: Context, command: str) -> None:
|
|
with patch(
|
|
"cleveragents.tui.commands.get_container",
|
|
return_value=context.tui_mock_container,
|
|
):
|
|
context.tui_result = context.tui_router.handle(
|
|
command, session_id=context.tui_session_id
|
|
)
|
|
|
|
|
|
@when('I call TUI handle with "session import <path>" for the import file')
|
|
def step_tui_handle_import_valid(context: Context) -> None:
|
|
command = f"session import {context.tui_import_path}"
|
|
with patch(
|
|
"cleveragents.tui.commands.get_container",
|
|
return_value=context.tui_mock_container,
|
|
):
|
|
context.tui_result = context.tui_router.handle(
|
|
command, session_id=context.tui_session_id
|
|
)
|
|
|
|
|
|
@when('I call TUI handle with "session import <invalid_path>" for the import file')
|
|
def step_tui_handle_import_invalid(context: Context) -> None:
|
|
command = f"session import {context.tui_invalid_json_path}"
|
|
with patch(
|
|
"cleveragents.tui.commands.get_container",
|
|
return_value=context.tui_mock_container,
|
|
):
|
|
context.tui_result = context.tui_router.handle(
|
|
command, session_id=context.tui_session_id
|
|
)
|
|
|
|
|
|
@then('the TUI handle result should contain "{text}"')
|
|
def step_tui_result_contains(context: Context, text: str) -> None:
|
|
assert text in context.tui_result, (
|
|
f"Expected {text!r} in TUI result.\nGot: {context.tui_result!r}"
|
|
)
|
|
|
|
|
|
@then('the TUI handle result should be "{text}"')
|
|
def step_tui_result_equals(context: Context, text: str) -> None:
|
|
assert context.tui_result == text, (
|
|
f"Expected TUI result {text!r}.\nGot: {context.tui_result!r}"
|
|
)
|
|
|
|
|
|
@then('the tui exported file "{path}" should exist')
|
|
def step_tui_file_exists(context: Context, path: str) -> None:
|
|
import contextlib
|
|
|
|
assert os.path.exists(path), f"Expected file to exist: {path}"
|
|
# Cleanup
|
|
with contextlib.suppress(OSError):
|
|
os.unlink(path)
|