dongarandClaude Opus 5.5
e351d0a74e
A pure move; behaviour unchanged. - models (L9, L7): llm, catalog, probe, render, render_anthropic, context - log (L7, L6): canonical, views - state (L8): store (was state), reconcile, worker, cancel, dump - knowledge (L10, L6.4): vault, memory - conversation (L5): transport, matrix - execution (L13): ssh (was execution), testing - authority (P3, P4, L4): actions - gitea, oplog, envfile stay at the top until each gains a second module. Every import, monkeypatch target, script and doc reference rewritten. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01J5Utyfzw7gF7UhjRDEtjTk
362 lines
12 KiB
Python
362 lines
12 KiB
Python
import json
|
|
import threading
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from nisse_core.conversation.matrix import MatrixConfig, MatrixTransport, TransportError
|
|
from nisse_core.conversation.transport import InboundMessage
|
|
|
|
CONFIG = MatrixConfig(
|
|
homeserver="https://matrix.test",
|
|
user_id="@nisse-dev:test",
|
|
token="syt_secret",
|
|
room_id="!room:test",
|
|
)
|
|
|
|
|
|
def sync_body(events: list[dict], next_batch: str) -> dict:
|
|
return {
|
|
"next_batch": next_batch,
|
|
"rooms": {"join": {"!room:test": {"timeline": {"events": events}}}},
|
|
}
|
|
|
|
|
|
def message_event(sender: str, body: str) -> dict:
|
|
return {
|
|
"type": "m.room.message",
|
|
"sender": sender,
|
|
"content": {"msgtype": "m.text", "body": body},
|
|
}
|
|
|
|
|
|
def test_send_message_puts_event_with_auth_and_unique_txn() -> None:
|
|
seen: list[httpx.Request] = []
|
|
|
|
def handler(request: httpx.Request) -> httpx.Response:
|
|
seen.append(request)
|
|
return httpx.Response(200, json={"event_id": "$e"})
|
|
|
|
transport = MatrixTransport(CONFIG, http_transport=httpx.MockTransport(handler))
|
|
transport.send_message("hello")
|
|
transport.send_approval_request("plan rev-1")
|
|
|
|
first, second = seen
|
|
assert first.headers["authorization"] == "Bearer syt_secret"
|
|
assert "/rooms/!room:test/send/m.room.message/" in str(first.url)
|
|
assert json.loads(first.content) == {"msgtype": "m.text", "body": "hello"}
|
|
assert str(first.url) != str(second.url) # txn ids must be unique
|
|
|
|
|
|
def test_send_failure_raises_transport_error() -> None:
|
|
def handler(request: httpx.Request) -> httpx.Response:
|
|
return httpx.Response(403, text="forbidden")
|
|
|
|
transport = MatrixTransport(CONFIG, http_transport=httpx.MockTransport(handler))
|
|
with pytest.raises(TransportError, match="403"):
|
|
transport.send_message("hello")
|
|
|
|
|
|
class SyncScript:
|
|
"""Serves scripted /sync responses, then endless empty ones."""
|
|
|
|
def __init__(self, responses: list[dict]) -> None:
|
|
self._responses = responses
|
|
self._i = 0
|
|
self.batches_seen: list[str | None] = []
|
|
|
|
def __call__(self, request: httpx.Request) -> httpx.Response:
|
|
assert request.url.path.endswith("/sync")
|
|
self.batches_seen.append(request.url.params.get("since"))
|
|
if self._i < len(self._responses):
|
|
body = self._responses[self._i]
|
|
self._i += 1
|
|
return httpx.Response(200, json=body)
|
|
return httpx.Response(200, json=sync_body([], f"b{self._i}"))
|
|
|
|
|
|
def collect_messages(
|
|
responses: list[dict], expected: int, timeout_s: float = 5.0
|
|
) -> list[InboundMessage]:
|
|
received: list[InboundMessage] = []
|
|
done = threading.Event()
|
|
|
|
def on_message(msg: InboundMessage) -> None:
|
|
received.append(msg)
|
|
if len(received) >= expected:
|
|
done.set()
|
|
|
|
transport = MatrixTransport(
|
|
CONFIG,
|
|
poll_timeout_ms=10,
|
|
http_transport=httpx.MockTransport(SyncScript(responses)),
|
|
)
|
|
transport.on_message(on_message)
|
|
transport.start()
|
|
done.wait(timeout_s)
|
|
transport.close()
|
|
return received
|
|
|
|
|
|
def test_listener_delivers_operator_messages() -> None:
|
|
responses = [
|
|
sync_body([message_event("@don:test", "backlog: never delivered")], "b1"),
|
|
sync_body([message_event("@don:test", "approve")], "b2"),
|
|
]
|
|
received = collect_messages(responses, expected=1)
|
|
assert received == [InboundMessage(sender="@don:test", text="approve")]
|
|
|
|
|
|
def test_own_and_non_message_events_are_filtered() -> None:
|
|
responses = [
|
|
sync_body([], "b1"),
|
|
sync_body(
|
|
[
|
|
message_event("@nisse-dev:test", "my own echo"),
|
|
{"type": "m.room.member", "sender": "@don:test", "content": {}},
|
|
message_event("@don:test", "status"),
|
|
],
|
|
"b2",
|
|
),
|
|
]
|
|
received = collect_messages(responses, expected=1)
|
|
assert received == [InboundMessage(sender="@don:test", text="status")]
|
|
|
|
|
|
def test_first_sync_learns_position_without_delivering() -> None:
|
|
script = SyncScript([sync_body([message_event("@don:test", "old")], "b1")])
|
|
transport = MatrixTransport(
|
|
CONFIG, poll_timeout_ms=10, http_transport=httpx.MockTransport(script)
|
|
)
|
|
got = threading.Event()
|
|
transport.on_message(lambda msg: got.set())
|
|
transport.start()
|
|
assert not got.wait(0.3)
|
|
transport.close()
|
|
assert script.batches_seen[0] is None # initial sync carries no since
|
|
assert "b1" in script.batches_seen # later polls resume from its batch
|
|
|
|
|
|
def test_start_without_handler_raises() -> None:
|
|
transport = MatrixTransport(
|
|
CONFIG, http_transport=httpx.MockTransport(lambda r: httpx.Response(200))
|
|
)
|
|
with pytest.raises(TransportError, match="no message handler"):
|
|
transport.start()
|
|
|
|
|
|
# --- leading mentions --------------------------------------------------------
|
|
|
|
|
|
def own_member_state(name: str) -> dict:
|
|
"""The first sync's room state, which carries the agent's display name."""
|
|
body = sync_body([], "b1")
|
|
body["rooms"]["join"]["!room:test"]["state"] = {
|
|
"events": [
|
|
{
|
|
"type": "m.room.member",
|
|
"state_key": "@nisse-dev:test",
|
|
"sender": "@nisse-dev:test",
|
|
"content": {"membership": "join", "displayname": name},
|
|
}
|
|
]
|
|
}
|
|
return body
|
|
|
|
|
|
def pill_event(sender: str, user_id: str, label: str, rest: str) -> dict:
|
|
"""A message as Element sends one that starts by mentioning user_id."""
|
|
return {
|
|
"type": "m.room.message",
|
|
"sender": sender,
|
|
"content": {
|
|
"msgtype": "m.text",
|
|
"body": f"{label}: {rest}",
|
|
"format": "org.matrix.custom.html",
|
|
"formatted_body": (
|
|
f'<a href="https://matrix.to/#/{user_id}">{label}</a>: {rest}'
|
|
),
|
|
},
|
|
}
|
|
|
|
|
|
def test_a_leading_pill_for_the_agent_is_removed_before_matching() -> None:
|
|
responses = [
|
|
sync_body([], "b1"),
|
|
sync_body(
|
|
[pill_event("@don:test", "@nisse-dev:test", "Nisse Dev", "approve")],
|
|
"b2",
|
|
),
|
|
]
|
|
[msg] = collect_messages(responses, expected=1)
|
|
assert msg.sender == "@don:test" # from the event, never from the text
|
|
assert msg.text == "approve"
|
|
assert msg.original == "Nisse Dev: approve"
|
|
|
|
|
|
def test_the_agents_display_name_typed_in_front_is_removed() -> None:
|
|
responses = [
|
|
own_member_state("Nisse Dev"),
|
|
sync_body([message_event("@don:test", "Nisse Dev: re-plan")], "b2"),
|
|
]
|
|
[msg] = collect_messages(responses, expected=1)
|
|
assert msg.text == "re-plan"
|
|
|
|
|
|
def test_the_agents_user_id_typed_in_front_is_removed() -> None:
|
|
responses = [
|
|
sync_body([], "b1"),
|
|
sync_body([message_event("@don:test", "@nisse-dev:test: status")], "b2"),
|
|
]
|
|
[msg] = collect_messages(responses, expected=1)
|
|
assert msg.text == "status"
|
|
|
|
|
|
def test_messages_addressed_to_someone_else_are_skipped() -> None:
|
|
responses = [
|
|
sync_body([], "b1"),
|
|
sync_body(
|
|
[
|
|
pill_event("@don:test", "@nisse-ops:test", "Nisse Ops", "approve"),
|
|
message_event("@don:test", "@alice:test: looks good"),
|
|
message_event("@don:test", "status"),
|
|
],
|
|
"b2",
|
|
),
|
|
]
|
|
received = collect_messages(responses, expected=1)
|
|
assert received == [InboundMessage(sender="@don:test", text="status")]
|
|
|
|
|
|
def test_a_mention_later_in_the_message_is_left_alone() -> None:
|
|
responses = [
|
|
sync_body([], "b1"),
|
|
sync_body([message_event("@don:test", "approve, cc @alice:test")], "b2"),
|
|
]
|
|
received = collect_messages(responses, expected=1)
|
|
assert received == [
|
|
InboundMessage(sender="@don:test", text="approve, cc @alice:test")
|
|
]
|
|
|
|
|
|
# --- threads (L5): a work item's conversation is a thread --------------------
|
|
|
|
|
|
def threaded_transport() -> tuple[MatrixTransport, list[dict], list[InboundMessage]]:
|
|
sent: list[dict] = []
|
|
ids = iter(f"$sent{n}" for n in range(1, 100))
|
|
|
|
def handler(request: httpx.Request) -> httpx.Response:
|
|
sent.append(json.loads(request.content))
|
|
return httpx.Response(200, json={"event_id": next(ids)})
|
|
|
|
transport = MatrixTransport(CONFIG, http_transport=httpx.MockTransport(handler))
|
|
received: list[InboundMessage] = []
|
|
transport.on_message(received.append)
|
|
return transport, sent, received
|
|
|
|
|
|
def event(event_id: str, body: str, relates: dict | None = None) -> dict:
|
|
content: dict = {"msgtype": "m.text", "body": body}
|
|
if relates is not None:
|
|
content["m.relates_to"] = relates
|
|
return {
|
|
"type": "m.room.message",
|
|
"sender": "@don:test",
|
|
"event_id": event_id,
|
|
"content": content,
|
|
}
|
|
|
|
|
|
def deliver(transport: MatrixTransport, *events: dict) -> None:
|
|
transport._deliver(sync_body(list(events), "b"))
|
|
|
|
|
|
def test_post_returns_the_event_id_and_threads_a_reply() -> None:
|
|
transport, sent, _ = threaded_transport()
|
|
root = transport.post("queued sandbox#14")
|
|
transport.post("As I understand it: ...", thread=root)
|
|
|
|
assert root == "$sent1"
|
|
assert "m.relates_to" not in sent[0]
|
|
assert sent[1]["m.relates_to"] == {
|
|
"rel_type": "m.thread",
|
|
"event_id": "$sent1",
|
|
# Clients without threads show it as a reply to the root.
|
|
"is_falling_back": True,
|
|
"m.in_reply_to": {"event_id": "$sent1"},
|
|
}
|
|
|
|
|
|
def test_a_message_in_a_thread_carries_its_root() -> None:
|
|
transport, _, received = threaded_transport()
|
|
deliver(
|
|
transport,
|
|
event("$top", "status"),
|
|
event("$in", "go", {"rel_type": "m.thread", "event_id": "$root"}),
|
|
)
|
|
assert [(m.text, m.event_id, m.thread) for m in received] == [
|
|
("status", "$top", None),
|
|
("go", "$in", "$root"),
|
|
]
|
|
|
|
|
|
def test_a_plain_reply_to_a_threaded_message_joins_its_thread() -> None:
|
|
# Clients without thread support send an ordinary reply, quoting.
|
|
transport, _, received = threaded_transport()
|
|
root = transport.post("queued sandbox#14")
|
|
in_thread = transport.post("As I understand it: ...", thread=root)
|
|
deliver(
|
|
transport,
|
|
event(
|
|
"$r1",
|
|
"> <@nisse-dev:test> As I understand it: ...\n\nyes, go",
|
|
{"m.in_reply_to": {"event_id": in_thread}},
|
|
),
|
|
event(
|
|
"$r2",
|
|
"> <@nisse-dev:test> queued sandbox#14\n\nthanks",
|
|
{"m.in_reply_to": {"event_id": root}},
|
|
),
|
|
)
|
|
assert [(m.text, m.thread) for m in received] == [
|
|
("yes, go", root), # the quote is not what was said
|
|
("thanks", root), # a reply to the root joins its thread
|
|
]
|
|
|
|
|
|
def test_a_reply_to_an_unknown_message_stays_at_top_level() -> None:
|
|
transport, _, received = threaded_transport()
|
|
deliver(
|
|
transport,
|
|
event("$r", "> <@x:test> old\n\nhm", {"m.in_reply_to": {"event_id": "$old"}}),
|
|
)
|
|
assert [(m.text, m.thread) for m in received] == [("hm", None)]
|
|
|
|
|
|
def test_a_reply_to_the_operators_own_threaded_message_joins_the_thread() -> None:
|
|
transport, _, received = threaded_transport()
|
|
deliver(
|
|
transport,
|
|
event("$t", "first", {"rel_type": "m.thread", "event_id": "$root"}),
|
|
event(
|
|
"$r",
|
|
"> <@don:test> first\n\nand also",
|
|
{"m.in_reply_to": {"event_id": "$t"}},
|
|
),
|
|
)
|
|
assert [m.thread for m in received] == ["$root", "$root"]
|
|
|
|
|
|
def test_in_memory_transport_plays_threads() -> None:
|
|
from nisse_core.conversation.transport import InMemoryTransport
|
|
|
|
transport = InMemoryTransport()
|
|
seen: list[InboundMessage] = []
|
|
transport.on_message(seen.append)
|
|
root = transport.post("queued #14")
|
|
transport.post("restated", thread=root)
|
|
reply = transport.receive("@don:test", "go", thread=root)
|
|
assert transport.outbound[-1].thread == root
|
|
assert (seen[0].thread, seen[0].event_id) == (root, reply)
|