banteg
369 lines
9.9 KiB
Python
369 lines
9.9 KiB
Python
import asyncio
|
|
|
|
from takopi.exec_bridge import (
|
|
extract_session_id,
|
|
prepare_telegram,
|
|
resolve_resume_session,
|
|
truncate_for_telegram,
|
|
)
|
|
|
|
|
|
def test_extract_session_id_finds_uuid_v7() -> None:
|
|
uuid = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
text = f"resume: `{uuid}`"
|
|
|
|
assert extract_session_id(text) == uuid
|
|
|
|
|
|
def test_extract_session_id_requires_resume_line() -> None:
|
|
uuid = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
text = f"here is a uuid {uuid}"
|
|
|
|
assert extract_session_id(text) is None
|
|
|
|
|
|
def test_extract_session_id_uses_last_resume_line() -> None:
|
|
uuid_first = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
uuid_last = "123e4567-e89b-12d3-a456-426614174000"
|
|
text = f"resume: `{uuid_first}`\n\nresume: `{uuid_last}`"
|
|
|
|
assert extract_session_id(text) == uuid_last
|
|
|
|
|
|
def test_extract_session_id_ignores_malformed_resume_line() -> None:
|
|
text = "resume: not-a-uuid"
|
|
|
|
assert extract_session_id(text) is None
|
|
|
|
|
|
def test_resolve_resume_session_prefers_message_text() -> None:
|
|
uuid_message = "123e4567-e89b-12d3-a456-426614174000"
|
|
uuid_reply = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
|
|
assert (
|
|
resolve_resume_session(
|
|
f"resume: `{uuid_message}`", f"resume: `{uuid_reply}`"
|
|
)
|
|
== uuid_message
|
|
)
|
|
|
|
|
|
def test_resolve_resume_session_uses_reply_when_missing() -> None:
|
|
uuid_reply = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
|
|
assert resolve_resume_session("no resume here", f"resume: `{uuid_reply}`") == uuid_reply
|
|
|
|
|
|
def test_truncate_for_telegram_preserves_resume_line() -> None:
|
|
uuid = "019b66fc-64c2-7a71-81cd-081c504cfeb2"
|
|
md = ("x" * 10_000) + f"\nresume: `{uuid}`"
|
|
|
|
out = truncate_for_telegram(md, 400)
|
|
|
|
assert len(out) <= 400
|
|
assert uuid in out
|
|
assert out.rstrip().endswith(f"resume: `{uuid}`")
|
|
|
|
|
|
def test_truncate_for_telegram_keeps_last_non_empty_line() -> None:
|
|
md = "intro\n\n" + ("x" * 500) + "\nlast line"
|
|
|
|
out = truncate_for_telegram(md, 120)
|
|
|
|
assert len(out) <= 120
|
|
assert out.rstrip().endswith("last line")
|
|
|
|
|
|
def test_prepare_telegram_drops_entities_on_truncate() -> None:
|
|
md = ("**bold** " * 200).strip()
|
|
|
|
rendered, entities = prepare_telegram(md, limit=40)
|
|
|
|
assert len(rendered) <= 40
|
|
assert entities is None
|
|
|
|
|
|
class _FakeBot:
|
|
def __init__(self) -> None:
|
|
self._next_id = 1
|
|
self.send_calls: list[dict] = []
|
|
self.edit_calls: list[dict] = []
|
|
self.delete_calls: list[dict] = []
|
|
|
|
async def send_message(
|
|
self,
|
|
chat_id: int,
|
|
text: str,
|
|
reply_to_message_id: int | None = None,
|
|
disable_notification: bool | None = False,
|
|
entities: list[dict] | None = None,
|
|
parse_mode: str | None = None,
|
|
) -> dict:
|
|
self.send_calls.append(
|
|
{
|
|
"chat_id": chat_id,
|
|
"text": text,
|
|
"reply_to_message_id": reply_to_message_id,
|
|
"disable_notification": disable_notification,
|
|
"entities": entities,
|
|
"parse_mode": parse_mode,
|
|
}
|
|
)
|
|
msg_id = self._next_id
|
|
self._next_id += 1
|
|
return {"message_id": msg_id}
|
|
|
|
async def edit_message_text(
|
|
self,
|
|
chat_id: int,
|
|
message_id: int,
|
|
text: str,
|
|
entities: list[dict] | None = None,
|
|
parse_mode: str | None = None,
|
|
) -> dict:
|
|
self.edit_calls.append(
|
|
{
|
|
"chat_id": chat_id,
|
|
"message_id": message_id,
|
|
"text": text,
|
|
"entities": entities,
|
|
"parse_mode": parse_mode,
|
|
}
|
|
)
|
|
return {"message_id": message_id}
|
|
|
|
async def delete_message(self, chat_id: int, message_id: int) -> bool:
|
|
self.delete_calls.append({"chat_id": chat_id, "message_id": message_id})
|
|
return True
|
|
|
|
|
|
class _FakeRunner:
|
|
def __init__(self, *, answer: str, saw_agent_message: bool = True) -> None:
|
|
self._answer = answer
|
|
self._saw_agent_message = saw_agent_message
|
|
|
|
async def run_serialized(self, *_args, **_kwargs) -> tuple[str, str, bool]:
|
|
return ("019b66fc-64c2-7a71-81cd-081c504cfeb2", self._answer, self._saw_agent_message)
|
|
|
|
|
|
class _FakeClock:
|
|
def __init__(self, start: float = 0.0) -> None:
|
|
self._now = start
|
|
|
|
def __call__(self) -> float:
|
|
return self._now
|
|
|
|
def set(self, value: float) -> None:
|
|
self._now = value
|
|
|
|
|
|
class _FakeRunnerWithEvents:
|
|
def __init__(
|
|
self,
|
|
*,
|
|
events: list[dict],
|
|
times: list[float],
|
|
clock: _FakeClock,
|
|
answer: str = "ok",
|
|
session_id: str = "019b66fc-64c2-7a71-81cd-081c504cfeb2",
|
|
) -> None:
|
|
self._events = events
|
|
self._times = times
|
|
self._clock = clock
|
|
self._answer = answer
|
|
self._session_id = session_id
|
|
|
|
async def run_serialized(self, *_args, **kwargs) -> tuple[str, str, bool]:
|
|
on_event = kwargs.get("on_event")
|
|
if on_event is not None:
|
|
for when, event in zip(self._times, self._events, strict=False):
|
|
self._clock.set(when)
|
|
await on_event(event)
|
|
await asyncio.sleep(0)
|
|
return (self._session_id, self._answer, True)
|
|
|
|
|
|
def test_final_notify_sends_loud_final_message() -> None:
|
|
from takopi.exec_bridge import BridgeConfig, _handle_message
|
|
|
|
bot = _FakeBot()
|
|
runner = _FakeRunner(answer="ok")
|
|
cfg = BridgeConfig(
|
|
bot=bot, # type: ignore[arg-type]
|
|
runner=runner, # type: ignore[arg-type]
|
|
chat_id=123,
|
|
final_notify=True,
|
|
startup_msg="",
|
|
max_concurrency=1,
|
|
)
|
|
|
|
asyncio.run(
|
|
_handle_message(
|
|
cfg,
|
|
chat_id=123,
|
|
user_msg_id=10,
|
|
text="hi",
|
|
resume_session=None,
|
|
)
|
|
)
|
|
|
|
assert len(bot.send_calls) == 2
|
|
assert bot.send_calls[0]["disable_notification"] is True
|
|
assert bot.send_calls[1]["disable_notification"] is False
|
|
|
|
|
|
def test_new_final_message_forces_notification_when_too_long_to_edit() -> None:
|
|
from takopi.exec_bridge import BridgeConfig, _handle_message
|
|
|
|
bot = _FakeBot()
|
|
runner = _FakeRunner(answer="x" * 10_000)
|
|
cfg = BridgeConfig(
|
|
bot=bot, # type: ignore[arg-type]
|
|
runner=runner, # type: ignore[arg-type]
|
|
chat_id=123,
|
|
final_notify=False,
|
|
startup_msg="",
|
|
max_concurrency=1,
|
|
)
|
|
|
|
asyncio.run(
|
|
_handle_message(
|
|
cfg,
|
|
chat_id=123,
|
|
user_msg_id=10,
|
|
text="hi",
|
|
resume_session=None,
|
|
)
|
|
)
|
|
|
|
assert len(bot.send_calls) == 2
|
|
assert bot.send_calls[0]["disable_notification"] is True
|
|
assert bot.send_calls[1]["disable_notification"] is False
|
|
|
|
|
|
def test_progress_edits_are_rate_limited() -> None:
|
|
from takopi.exec_bridge import BridgeConfig, _handle_message
|
|
|
|
bot = _FakeBot()
|
|
clock = _FakeClock()
|
|
events = [
|
|
{
|
|
"type": "item.started",
|
|
"item": {
|
|
"id": "item_0",
|
|
"type": "command_execution",
|
|
"command": "echo 1",
|
|
"status": "in_progress",
|
|
},
|
|
},
|
|
{
|
|
"type": "item.completed",
|
|
"item": {
|
|
"id": "item_0",
|
|
"type": "command_execution",
|
|
"command": "echo 1",
|
|
"exit_code": 0,
|
|
"status": "completed",
|
|
},
|
|
},
|
|
{
|
|
"type": "item.started",
|
|
"item": {
|
|
"id": "item_1",
|
|
"type": "command_execution",
|
|
"command": "echo 2",
|
|
"status": "in_progress",
|
|
},
|
|
},
|
|
]
|
|
runner = _FakeRunnerWithEvents(
|
|
events=events,
|
|
times=[0.2, 0.4, 1.2],
|
|
clock=clock,
|
|
)
|
|
cfg = BridgeConfig(
|
|
bot=bot, # type: ignore[arg-type]
|
|
runner=runner, # type: ignore[arg-type]
|
|
chat_id=123,
|
|
final_notify=True,
|
|
startup_msg="",
|
|
max_concurrency=1,
|
|
)
|
|
|
|
asyncio.run(
|
|
_handle_message(
|
|
cfg,
|
|
chat_id=123,
|
|
user_msg_id=10,
|
|
text="hi",
|
|
resume_session=None,
|
|
clock=clock,
|
|
progress_edit_every=1.0,
|
|
)
|
|
)
|
|
|
|
assert len(bot.edit_calls) == 1
|
|
|
|
|
|
def test_bridge_flow_sends_progress_edits_and_final_resume() -> None:
|
|
from takopi.exec_bridge import BridgeConfig, _handle_message
|
|
|
|
bot = _FakeBot()
|
|
clock = _FakeClock()
|
|
events = [
|
|
{
|
|
"type": "item.started",
|
|
"item": {
|
|
"id": "item_0",
|
|
"type": "command_execution",
|
|
"command": "echo ok",
|
|
"status": "in_progress",
|
|
},
|
|
},
|
|
{
|
|
"type": "item.completed",
|
|
"item": {
|
|
"id": "item_0",
|
|
"type": "command_execution",
|
|
"command": "echo ok",
|
|
"exit_code": 0,
|
|
"status": "completed",
|
|
},
|
|
},
|
|
]
|
|
session_id = "123e4567-e89b-12d3-a456-426614174000"
|
|
runner = _FakeRunnerWithEvents(
|
|
events=events,
|
|
times=[0.0, 2.1],
|
|
clock=clock,
|
|
answer="done",
|
|
session_id=session_id,
|
|
)
|
|
cfg = BridgeConfig(
|
|
bot=bot, # type: ignore[arg-type]
|
|
runner=runner, # type: ignore[arg-type]
|
|
chat_id=123,
|
|
final_notify=True,
|
|
startup_msg="",
|
|
max_concurrency=1,
|
|
)
|
|
|
|
asyncio.run(
|
|
_handle_message(
|
|
cfg,
|
|
chat_id=123,
|
|
user_msg_id=42,
|
|
text="do it",
|
|
resume_session=None,
|
|
clock=clock,
|
|
progress_edit_every=1.0,
|
|
)
|
|
)
|
|
|
|
assert bot.send_calls[0]["reply_to_message_id"] == 42
|
|
assert "working" in bot.send_calls[0]["text"]
|
|
assert len(bot.edit_calls) >= 1
|
|
assert session_id in bot.send_calls[-1]["text"]
|
|
assert "resume:" in bot.send_calls[-1]["text"].lower()
|
|
assert len(bot.delete_calls) == 1
|