167 lines
4.8 KiB
Python
167 lines
4.8 KiB
Python
"""Tests for editor integration with the shell and command system."""
|
|
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
from mudlib import commands
|
|
from mudlib.commands.edit import cmd_edit
|
|
from mudlib.editor import Editor
|
|
from mudlib.player import Player
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_writer():
|
|
writer = MagicMock()
|
|
writer.write = MagicMock()
|
|
writer.drain = AsyncMock()
|
|
return writer
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_reader():
|
|
return MagicMock()
|
|
|
|
|
|
@pytest.fixture
|
|
def player(mock_reader, mock_writer):
|
|
return Player(name="TestPlayer", x=5, y=5, reader=mock_reader, writer=mock_writer)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_edit_command_enters_editor_mode(player):
|
|
"""Test that edit command sets up editor mode."""
|
|
assert player.mode == "normal"
|
|
assert player.editor is None
|
|
|
|
await cmd_edit(player, "")
|
|
|
|
assert player.mode == "editor"
|
|
assert player.editor is not None
|
|
assert isinstance(player.editor, Editor)
|
|
assert player.mode_stack == ["normal", "editor"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_edit_command_sends_welcome_message(player, mock_writer):
|
|
"""Test that edit command sends welcome message."""
|
|
await cmd_edit(player, "")
|
|
|
|
assert mock_writer.write.called
|
|
output = "".join([call[0][0] for call in mock_writer.write.call_args_list])
|
|
assert "editor" in output.lower()
|
|
assert ":h" in output
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_edit_command_sets_save_callback(player):
|
|
"""Test that edit command sets up a save callback."""
|
|
await cmd_edit(player, "")
|
|
|
|
assert player.editor is not None
|
|
assert player.editor.save_callback is not None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_editor_handle_input_preserves_whitespace(player):
|
|
"""Test that editor receives input with whitespace preserved."""
|
|
await cmd_edit(player, "")
|
|
|
|
# Simulate code with indentation
|
|
response = await player.editor.handle_input(" def foo():")
|
|
|
|
assert player.editor.buffer == [" def foo():"]
|
|
assert response.done is False
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_editor_done_clears_editor_and_pops_mode(player):
|
|
"""Test that when editor returns done=True, mode is popped and editor cleared."""
|
|
await cmd_edit(player, "")
|
|
|
|
assert player.mode == "editor"
|
|
assert player.editor is not None
|
|
|
|
# Quit the editor
|
|
response = await player.editor.handle_input(":q")
|
|
assert response.done is True
|
|
|
|
# Simulate what the shell loop should do
|
|
player.editor = None
|
|
player.mode_stack.pop()
|
|
|
|
assert player.mode == "normal"
|
|
assert player.editor is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_editor_save_callback_sends_message(player, mock_writer):
|
|
"""Test that save callback sends confirmation to player."""
|
|
await cmd_edit(player, "")
|
|
mock_writer.reset_mock()
|
|
|
|
await player.editor.handle_input("test line")
|
|
response = await player.editor.handle_input(":w")
|
|
|
|
assert response.saved is True
|
|
# Save callback should have sent a message
|
|
assert mock_writer.write.called
|
|
output = "".join([call[0][0] for call in mock_writer.write.call_args_list])
|
|
assert "saved" in output.lower()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_edit_command_only_works_in_normal_mode(player):
|
|
"""Test that edit command has mode='normal' restriction."""
|
|
# Push a different mode onto the stack
|
|
player.mode_stack.append("combat")
|
|
|
|
# Try to invoke edit command through dispatch
|
|
await commands.dispatch(player, "edit")
|
|
|
|
# Should be blocked by mode check
|
|
assert player.mode == "combat"
|
|
assert player.editor is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_mode_stack_push_and_pop(player):
|
|
"""Test mode stack mechanics for editor mode."""
|
|
assert player.mode_stack == ["normal"]
|
|
assert player.mode == "normal"
|
|
|
|
# Enter editor mode
|
|
player.mode_stack.append("editor")
|
|
assert player.mode == "editor"
|
|
assert player.mode_stack == ["normal", "editor"]
|
|
|
|
# Exit editor mode
|
|
player.mode_stack.pop()
|
|
assert player.mode == "normal"
|
|
assert player.mode_stack == ["normal"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_empty_input_allowed_in_editor(player):
|
|
"""Test that empty lines are valid in editor mode (for blank lines in code)."""
|
|
await cmd_edit(player, "")
|
|
|
|
# Empty line should be appended to buffer
|
|
response = await player.editor.handle_input("")
|
|
assert response.done is False
|
|
assert player.editor.buffer == [""]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_editor_prompt_uses_cursor(player):
|
|
"""Test that editor prompt should show line number from cursor."""
|
|
await cmd_edit(player, "")
|
|
|
|
# Add some lines
|
|
await player.editor.handle_input("line 1")
|
|
await player.editor.handle_input("line 2")
|
|
|
|
# After appending, cursor should be at the last line (1 in 0-indexed)
|
|
# This test verifies the cursor field exists and can be used for prompts
|
|
assert player.editor.cursor == 1
|
|
# Shell loop prompt: f" {player.editor.cursor + 1}> " = " 2> "
|