cleveragents-core/features/steps/tui_permissions_screen_steps.py

"""Step definitions for tui_permissions_screen.feature.

Tests cover:
- DiffDisplayMode, FileChangeType, PermissionDecision enums
- PermissionRequest model (unified/split/auto diffs)
- ToolPermissionRequest model (decisions, is_pending, is_allowed, is_rejected)
- PermissionRequestService (queue, decisions, session-scoped decisions)
- PermissionsScreen widget (load, navigate, cycle mode, allow/reject)
- Rendering helpers (_render_file_list, _render_diff_panel, _render_status_bar)
"""

from __future__ import annotations

from behave import given, then, when

# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _make_permission_request(path: str, before: str, after: str):
    from cleveragents.tui.permissions.models import FileChangeType, PermissionRequest

    return PermissionRequest(
        path=path,
        change_type=FileChangeType.MODIFIED,
        before_content=before,
        after_content=after,
    )


def _make_tool_request(request_id: str, tool_name: str, n_changes: int = 3):
    from cleveragents.tui.permissions.models import (
        FileChangeType,
        PermissionRequest,
        ToolPermissionRequest,
    )

    changes = [
        PermissionRequest(
            path=f"file{i}.py",
            change_type=FileChangeType.MODIFIED,
            before_content=f"old content {i}\nline2\n",
            after_content=f"new content {i}\nline2\n",
        )
        for i in range(n_changes)
    ]
    return ToolPermissionRequest(
        request_id=request_id,
        tool_name=tool_name,
        resource_name="local/api-service",
        changes=changes,
    )


# ---------------------------------------------------------------------------
# DiffDisplayMode enum
# ---------------------------------------------------------------------------


@when("I inspect the DiffDisplayMode enum")
def step_inspect_diff_display_mode(context):
    from cleveragents.tui.permissions.models import DiffDisplayMode

    context._diff_display_mode = DiffDisplayMode


@then('DiffDisplayMode should have values "unified", "split", "auto"')
def step_diff_display_mode_values(context):
    from cleveragents.tui.permissions.models import DiffDisplayMode

    assert DiffDisplayMode.UNIFIED == "unified"
    assert DiffDisplayMode.SPLIT == "split"
    assert DiffDisplayMode.AUTO == "auto"


# ---------------------------------------------------------------------------
# FileChangeType enum
# ---------------------------------------------------------------------------


@when("I inspect the FileChangeType enum")
def step_inspect_file_change_type(context):
    from cleveragents.tui.permissions.models import FileChangeType

    context._file_change_type = FileChangeType


@then('FileChangeType should have values "M", "A", "D"')
def step_file_change_type_values(context):
    from cleveragents.tui.permissions.models import FileChangeType

    assert FileChangeType.MODIFIED == "M"
    assert FileChangeType.ADDED == "A"
    assert FileChangeType.DELETED == "D"


# ---------------------------------------------------------------------------
# PermissionDecision enum
# ---------------------------------------------------------------------------


@when("I inspect the PermissionDecision enum")
def step_inspect_permission_decision(context):
    from cleveragents.tui.permissions.models import PermissionDecision

    context._permission_decision = PermissionDecision


@then(
    'PermissionDecision should have values "allow_once", "allow_always", "reject_once", "reject_always"'
)
def step_permission_decision_values(context):
    from cleveragents.tui.permissions.models import PermissionDecision

    assert PermissionDecision.ALLOW_ONCE == "allow_once"
    assert PermissionDecision.ALLOW_ALWAYS == "allow_always"
    assert PermissionDecision.REJECT_ONCE == "reject_once"
    assert PermissionDecision.REJECT_ALWAYS == "reject_always"


# ---------------------------------------------------------------------------
# PermissionRequest model
# ---------------------------------------------------------------------------

_BEFORE = "def login(self, request):\n    return self.authenticate(request)\n"
_AFTER = (
    "def login(self, request):\n"
    "    result = self.authenticate(request)\n"
    "    self.log_attempt(request, result)\n"
    "    return result\n"
)


@given('a PermissionRequest for "{path}" with before and after content')
def step_create_permission_request(context, path):
    context._perm_request = _make_permission_request(path, _BEFORE, _AFTER)


@given('a PermissionRequest for "{path}" with identical before and after content')
def step_create_identical_permission_request(context, path):
    same = "def foo():\n    pass\n"
    context._perm_request = _make_permission_request(path, same, same)


@when('I render the diff in "{mode}" mode')
def step_render_diff(context, mode):
    from cleveragents.tui.permissions.models import DiffDisplayMode

    mode_enum = DiffDisplayMode(mode)
    context._rendered_diff = context._perm_request.render_diff(mode_enum)


@then('the rendered diff should contain "{text}"')
def step_rendered_diff_contains(context, text):
    assert text in context._rendered_diff, (
        f"Expected {text!r} in diff:\n{context._rendered_diff}"
    )


@then("the rendered diff should be empty")
def step_rendered_diff_empty(context):
    assert context._rendered_diff == "", (
        f"Expected empty diff, got:\n{context._rendered_diff}"
    )


@when("I call split_diff on the request")
def step_call_split_diff(context):
    context._sbs_left, context._sbs_right = context._perm_request.split_diff()


@then("both sides should have the same number of lines")
def step_split_same_length(context):
    assert len(context._sbs_left) == len(context._sbs_right), (
        f"Left: {len(context._sbs_left)}, Right: {len(context._sbs_right)}"
    )


# ---------------------------------------------------------------------------
# ToolPermissionRequest model
# ---------------------------------------------------------------------------


@given("a ToolPermissionRequest with no decision")
def step_create_tool_permission_request(context):
    context._tool_request = _make_tool_request("req-0", "local/file-write")
    context._original_request = context._tool_request


@then("the request should be pending")
def step_request_is_pending(context):
    assert context._tool_request.is_pending


@then("the request should not be allowed")
def step_request_not_allowed(context):
    assert not context._tool_request.is_allowed


@then("the request should not be rejected")
def step_request_not_rejected(context):
    assert not context._tool_request.is_rejected


@when('I apply decision "{decision}" to the request')
def step_apply_decision(context, decision):
    from cleveragents.tui.permissions.models import PermissionDecision

    context._decided_request = context._tool_request.apply_decision(
        PermissionDecision(decision)
    )
    # Update context._tool_request to the decided version for subsequent steps
    context._tool_request = context._decided_request


@then("the request should be allowed")
def step_request_is_allowed(context):
    assert context._tool_request.is_allowed


@then("the request should be rejected")
def step_request_is_rejected(context):
    assert context._tool_request.is_rejected


@then("the request should not be pending")
def step_request_not_pending(context):
    assert not context._tool_request.is_pending


@then("the original request should still be pending")
def step_original_request_still_pending(context):
    assert context._original_request.is_pending


# ---------------------------------------------------------------------------
# PermissionRequestService
# ---------------------------------------------------------------------------


@given("a fresh PermissionRequestService")
def step_create_service(context):
    from cleveragents.tui.permissions.service import PermissionRequestService

    context._service = PermissionRequestService()
    context._clear_result = None
    context._decision_result = None


@when('I enqueue a request with id "{request_id}" for tool "{tool_name}"')
def step_enqueue_request(context, request_id, tool_name):
    req = _make_tool_request(request_id, tool_name)
    context._service.enqueue(req)
    context._last_request_id = request_id


@when('I record decision "{decision}" for request "{request_id}"')
def step_record_decision(context, decision, request_id):
    from cleveragents.tui.permissions.models import PermissionDecision

    context._decision_result = context._service.record_decision(
        request_id, PermissionDecision(decision)
    )


@then("the service should have {count:d} pending request")
def step_service_pending_count_singular(context, count):
    assert len(context._service.pending_requests()) == count, (
        f"Expected {count} pending, got {len(context._service.pending_requests())}"
    )


@then("the service should have {count:d} pending requests")
def step_service_pending_count(context, count):
    assert len(context._service.pending_requests()) == count, (
        f"Expected {count} pending, got {len(context._service.pending_requests())}"
    )


@then("the service should have {count:d} total requests")
def step_service_total_count(context, count):
    assert len(context._service.all_requests()) == count, (
        f"Expected {count} total, got {len(context._service.all_requests())}"
    )


@then('the request "{request_id}" should have decision "{decision}"')
def step_request_has_decision(context, request_id, decision):
    req = context._service.get(request_id)
    assert req is not None, f"Request {request_id!r} not found"
    assert req.decision is not None
    assert req.decision == decision, f"Expected {decision!r}, got {req.decision!r}"


@then('the session decision for "{tool_name}" should be None')
def step_session_decision_none(context, tool_name):
    result = context._service.get_session_decision(tool_name)
    assert result is None, f"Expected None, got {result!r}"


@then('the session decision for "{tool_name}" should be "{decision}"')
def step_session_decision_value(context, tool_name, decision):
    result = context._service.get_session_decision(tool_name)
    assert result == decision, f"Expected {decision!r}, got {result!r}"


@when('I clear the session decision for "{tool_name}"')
def step_clear_session_decision(context, tool_name):
    context._clear_result = context._service.clear_session_decision(tool_name)


@then("the clear result should be False")
def step_clear_result_false(context):
    assert context._clear_result is False


@then("the decision result should be None")
def step_decision_result_none(context):
    assert context._decision_result is None


@then('getting request "{request_id}" should return None')
def step_get_request_none(context, request_id):
    result = context._service.get(request_id)
    assert result is None


@when("I clear all requests")
def step_clear_all(context):
    context._service.clear_all()


# ---------------------------------------------------------------------------
# PermissionsScreen widget
# ---------------------------------------------------------------------------


@given("a fresh PermissionsScreen")
def step_create_permissions_screen(context):
    from cleveragents.tui.permissions.screen import PermissionsScreen

    context._screen = PermissionsScreen()


@when("I load a ToolPermissionRequest with {n:d} file changes")
def step_load_tool_request(context, n):
    req = _make_tool_request("req-screen", "local/file-write", n_changes=n)
    context._screen.load_request(req)


@then('the screen text should contain "{text}"')
def step_screen_text_contains(context, text):
    assert text in context._screen._text, (
        f"Expected {text!r} in screen text:\n{context._screen._text}"
    )


@then("the screen text should be empty")
def step_screen_text_empty(context):
    assert context._screen._text == "", (
        f"Expected empty screen text, got:\n{context._screen._text}"
    )


@then("the selected index should be {index:d}")
def step_selected_index(context, index):
    assert context._screen.selected_index == index, (
        f"Expected index {index}, got {context._screen.selected_index}"
    )


@when("I navigate next on the screen")
def step_navigate_next(context):
    context._screen.navigate_next()


@when("I navigate prev on the screen")
def step_navigate_prev(context):
    context._screen.navigate_prev()


@then('the diff mode should be "{mode}"')
def step_diff_mode(context, mode):
    assert context._screen.diff_mode == mode, (
        f"Expected mode {mode!r}, got {context._screen.diff_mode!r}"
    )


@when("I cycle the diff mode")
def step_cycle_diff_mode(context):
    context._screen.cycle_diff_mode()


@when('I set the diff mode to "{mode}"')
def step_set_diff_mode(context, mode):
    from cleveragents.tui.permissions.models import DiffDisplayMode

    context._screen.set_diff_mode(DiffDisplayMode(mode))


@when("I press allow_once on the screen")
def step_press_allow_once(context):
    context._screen.allow_once()


@when("I press allow_always on the screen")
def step_press_allow_always(context):
    context._screen.allow_always()


@when("I press reject_once on the screen")
def step_press_reject_once(context):
    context._screen.reject_once()


@when("I press reject_always on the screen")
def step_press_reject_always(context):
    context._screen.reject_always()


@then('the screen decision should be "{decision}"')
def step_screen_decision(context, decision):
    assert context._screen.decision == decision, (
        f"Expected decision {decision!r}, got {context._screen.decision!r}"
    )


@then("the screen decision should be None")
def step_screen_decision_none(context):
    assert context._screen.decision is None, (
        f"Expected None, got {context._screen.decision!r}"
    )


@when("I clear the screen")
def step_clear_screen(context):
    context._screen.clear()


# ---------------------------------------------------------------------------
# _next_diff_mode helper
# ---------------------------------------------------------------------------


@when('I call _next_diff_mode with "{mode}"')
def step_call_next_diff_mode(context, mode):
    from cleveragents.tui.permissions.models import DiffDisplayMode
    from cleveragents.tui.permissions.screen import _next_diff_mode

    context._next_mode_result = _next_diff_mode(DiffDisplayMode(mode))


@then('the next diff mode result should be "{mode}"')
def step_next_mode_result(context, mode):
    assert context._next_mode_result == mode, (
        f"Expected {mode!r}, got {context._next_mode_result!r}"
    )


# ---------------------------------------------------------------------------
# Rendering helpers
# ---------------------------------------------------------------------------


@when("I render a file list with {n:d} files and selected index {idx:d}")
def step_render_file_list(context, n, idx):
    from cleveragents.tui.permissions.models import FileChangeType, PermissionRequest
    from cleveragents.tui.permissions.screen import _render_file_list

    changes = [
        PermissionRequest(
            path=f"file{i}.py",
            change_type=FileChangeType.MODIFIED,
            before_content="old\n",
            after_content="new\n",
        )
        for i in range(n)
    ]
    context._file_list_text = _render_file_list(changes, idx)


_ARROW = "\u276f"  # heavy right-pointing angle quotation mark ornament (U+276F)


@then(f'the file list should contain "{_ARROW}" on the second entry')
def step_file_list_arrow_second(context):
    lines = context._file_list_text.splitlines()
    # lines[0] is the header "Files (N changes):"
    # lines[1] is file0 (index 0), lines[2] is file1 (index 1)
    assert _ARROW in lines[2], f"Expected arrow in second file entry, got: {lines[2]!r}"


@when("I render a diff panel with no change")
def step_render_diff_panel_none(context):
    from cleveragents.tui.permissions.models import DiffDisplayMode
    from cleveragents.tui.permissions.screen import _render_diff_panel

    context._diff_panel_text = _render_diff_panel(None, DiffDisplayMode.UNIFIED)


@when("I render a diff panel with an identical-content change")
def step_render_diff_panel_identical(context):
    from cleveragents.tui.permissions.models import DiffDisplayMode
    from cleveragents.tui.permissions.screen import _render_diff_panel

    change = _make_permission_request("src/same.py", "same\n", "same\n")
    context._diff_panel_text = _render_diff_panel(change, DiffDisplayMode.UNIFIED)


@then('the diff panel should contain "{text}"')
def step_diff_panel_contains(context, text):
    assert text in context._diff_panel_text, (
        f"Expected {text!r} in diff panel:\n{context._diff_panel_text}"
    )


@when('I render a status bar for tool "{tool_name}" and resource "{resource_name}"')
def step_render_status_bar(context, tool_name, resource_name):
    from cleveragents.tui.permissions.models import DiffDisplayMode
    from cleveragents.tui.permissions.screen import _render_status_bar

    context._status_bar_text = _render_status_bar(
        tool_name, resource_name, DiffDisplayMode.UNIFIED
    )


@then('the status bar should contain "{text}"')
def step_status_bar_contains(context, text):
    assert text in context._status_bar_text, (
        f"Expected {text!r} in status bar:\n{context._status_bar_text}"
    )


# ---------------------------------------------------------------------------
# PermissionsScreen property accessors
# ---------------------------------------------------------------------------


@then("the screen current_request should be None")
def step_screen_current_request_none(context):
    assert context._screen.current_request is None


@then("the screen current_request should not be None")
def step_screen_current_request_not_none(context):
    assert context._screen.current_request is not None


# ---------------------------------------------------------------------------
# PermissionRequest split_diff delete/insert branches
# ---------------------------------------------------------------------------


@given("a PermissionRequest with only deleted lines")
def step_create_delete_only_request(context):
    from cleveragents.tui.permissions.models import FileChangeType, PermissionRequest

    context._perm_request = PermissionRequest(
        path="src/deleted.py",
        change_type=FileChangeType.MODIFIED,
        before_content="line1\nline2\nline3\n",
        after_content="",
    )


@given("a PermissionRequest with only inserted lines")
def step_create_insert_only_request(context):
    from cleveragents.tui.permissions.models import FileChangeType, PermissionRequest

    context._perm_request = PermissionRequest(
        path="src/inserted.py",
        change_type=FileChangeType.MODIFIED,
        before_content="",
        after_content="line1\nline2\nline3\n",
    )


@then("the left side should have non-empty lines")
def step_left_side_non_empty(context):
    left, _ = context._perm_request.split_diff()
    assert any(line.strip() for line in left), f"Expected non-empty left lines: {left}"


@then("the right side should have empty lines for deleted content")
def step_right_side_empty_for_deleted(context):
    _, right = context._perm_request.split_diff()
    # For delete-only, right side should have empty strings
    assert any(line == "" for line in right), (
        f"Expected empty right lines for deleted content: {right}"
    )


@then("the right side should have non-empty lines")
def step_right_side_non_empty(context):
    _, right = context._perm_request.split_diff()
    assert any(line.strip() for line in right), (
        f"Expected non-empty right lines: {right}"
    )


@then("the left side should have empty lines for inserted content")
def step_left_side_empty_for_inserted(context):
    left, _ = context._perm_request.split_diff()
    # For insert-only, left side should have empty strings
    assert any(line == "" for line in left), (
        f"Expected empty left lines for inserted content: {left}"
    )


# ---------------------------------------------------------------------------
# PermissionRequestService clear_session_decision return True
# ---------------------------------------------------------------------------


@then("the clear result should be True")
def step_clear_result_true(context):
    assert context._clear_result is True


# ---------------------------------------------------------------------------
# Bug #10488: PermissionsScreen base class checks
# ---------------------------------------------------------------------------


@when("I check the base class of PermissionsScreen")
def step_check_base_class(context):
    from cleveragents.tui.permissions.screen import PermissionsScreen

    context._permissions_screen_cls = PermissionsScreen


@then("PermissionsScreen should be a subclass of textual.app.Screen")
def step_permissions_screen_is_screen_subclass(context):
    import importlib

    from cleveragents.tui.permissions import screen as screen_module

    # Check the _ScreenBase variable in the module — if textual is available,
    # it should be textual.app.Screen; if not, the fallback is used.
    screen_base = getattr(screen_module, "_ScreenBase", None)
    assert screen_base is not None, (
        "Expected screen module to have _ScreenBase variable"
    )

    try:
        Screen = importlib.import_module("textual.app").Screen
        # Textual is available — verify PermissionsScreen inherits from Screen
        assert issubclass(context._permissions_screen_cls, Screen), (
            f"Expected PermissionsScreen to be a subclass of textual.app.Screen, "
            f"but its MRO is: {[c.__name__ for c in context._permissions_screen_cls.__mro__]}"
        )
        assert screen_base is Screen, (
            f"Expected _ScreenBase to be textual.app.Screen, got {screen_base!r}"
        )
    except ImportError:
        # Textual not installed — verify the module is designed to use Screen
        # by checking that _load_screen_base is defined (not _load_static_base).
        load_fn = getattr(screen_module, "_load_screen_base", None)
        assert load_fn is not None, (
            "Expected screen module to have _load_screen_base function "
            "(not _load_static_base). The module must be designed to load "
            "textual.app.Screen as the base class."
        )


@then("PermissionsScreen should have a BINDINGS class variable")
def step_permissions_screen_has_bindings(context):
    cls = context._permissions_screen_cls
    assert hasattr(cls, "BINDINGS"), (
        "Expected PermissionsScreen to have a BINDINGS class variable"
    )
    assert cls.BINDINGS, "Expected PermissionsScreen.BINDINGS to be non-empty"


@then('PermissionsScreen should have action method "{method_name}"')
def step_permissions_screen_has_action_method(context, method_name):
    cls = context._permissions_screen_cls
    assert hasattr(cls, method_name), (
        f"Expected PermissionsScreen to have action method '{method_name}'"
    )
    assert callable(getattr(cls, method_name)), (
        f"Expected PermissionsScreen.{method_name} to be callable"
    )