admin/mcp-nextcloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9614c0b361e34cef35e8348ce77efe7cb56b46b9
mcp-nextcloud/tests/client/talk/test_talk_api.py
T
Chris CoutinhoandClaude Opus 4.7 9614c0b361 test(talk): cover include_status + malformed-header paths; drop Content-Type from default headers 
Addresses the missing-test and Content-Type points from the latest
PR #741 review:

- client/talk.py _talk_headers(): drop the manual `Content-Type:
  application/json`. httpx sets it automatically on requests that pass
  `json=`, and we no longer leak it onto bodyless GETs and DELETEs.
- tests/client/talk/test_talk_api.py:
  - new `test_talk_list_participants_with_include_status` asserting
    `includeStatus=true` is forwarded.
  - new `test_talk_get_messages_invalid_last_given_header` covering
    the defensive try/except around the `X-Chat-Last-Given` parse —
    asserts the fallback `last_given=None` and that a warning is
    logged.
  - existing `test_talk_list_participants` extended to assert that
    `includeStatus` is *absent* by default.

Unit tests: 13 → 15. Integration tests still 7/7.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-04-30 00:47:20 +02:00

426 lines
14 KiB
Python
Raw Blame History

"""Unit tests for the Nextcloud Talk (spreed) HTTP client."""
import logging
import httpx
import pytest
from nextcloud_mcp_server.client.talk import TalkClient
from nextcloud_mcp_server.models.talk import (
TalkConversation,
TalkMessage,
TalkParticipant,
)
from tests.client.conftest import (
create_mock_error_response,
create_mock_response,
create_mock_talk_message_response,
create_mock_talk_room_response,
)
logger = logging.getLogger(__name__)
pytestmark = pytest.mark.unit
# Conversation tests
async def test_talk_list_conversations(mocker):
"""list_conversations parses the OCS-wrapped room list."""
mock_response = create_mock_response(
status_code=200,
json_data={
"ocs": {
"meta": {"status": "ok"},
"data": [
{
"id": 1,
"token": "abc",
"type": 2,
"name": "Group 1",
"displayName": "Group 1",
"lastMessage": [],
},
{
"id": 2,
"token": "def",
"type": 3,
"name": "Public Room",
"displayName": "Public Room",
"lastMessage": [],
},
],
}
},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
rooms = await client.list_conversations()
assert len(rooms) == 2
assert all(isinstance(r, TalkConversation) for r in rooms)
assert rooms[0].token == "abc"
assert rooms[1].type == 3
mock_make_request.assert_called_once()
call_args = mock_make_request.call_args
assert call_args[0][0] == "GET"
assert call_args[0][1] == "/ocs/v2.php/apps/spreed/api/v4/room"
# noStatusUpdate defaults to True
assert call_args[1]["params"]["noStatusUpdate"] == 1
async def test_talk_list_conversations_with_modified_since(mocker):
"""modifiedSince and includeStatus are forwarded as query params."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.list_conversations(modified_since=1700000000, include_status=True)
params = mock_make_request.call_args[1]["params"]
assert params["modifiedSince"] == 1700000000
assert params["includeStatus"] == "true"
async def test_talk_get_conversation(mocker):
"""get_conversation parses the OCS-wrapped room object."""
mock_response = create_mock_talk_room_response(
conversation_id=42, token="xyz", name="My Room"
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
room = await client.get_conversation("xyz")
assert isinstance(room, TalkConversation)
assert room.id == 42
assert room.token == "xyz"
assert room.name == "My Room"
assert mock_make_request.call_args[0][0] == "GET"
assert "/api/v4/room/xyz" in mock_make_request.call_args[0][1]
async def test_talk_get_conversation_not_found(mocker):
"""A 404 from spreed propagates as HTTPStatusError."""
error_response = create_mock_error_response(404, "Conversation not found")
mock_make_request = mocker.patch.object(TalkClient, "_make_request")
mock_make_request.side_effect = httpx.HTTPStatusError(
"404 Not Found",
request=httpx.Request("GET", "http://test.local"),
response=error_response,
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
with pytest.raises(httpx.HTTPStatusError) as excinfo:
await client.get_conversation("nope")
assert excinfo.value.response.status_code == 404
async def test_talk_create_conversation(mocker):
"""create_conversation builds the right POST body."""
mock_response = create_mock_talk_room_response(
conversation_id=10, token="new", name="New Room"
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
room = await client.create_conversation(room_name="New Room")
assert room.token == "new"
call_args = mock_make_request.call_args
assert call_args[0][0] == "POST"
assert call_args[1]["json"] == {"roomType": 2, "roomName": "New Room"}
async def test_talk_delete_conversation(mocker):
"""delete_conversation issues DELETE on the room URL."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.delete_conversation("doomed")
call_args = mock_make_request.call_args
assert call_args[0][0] == "DELETE"
assert "/api/v4/room/doomed" in call_args[0][1]
# Chat tests
async def test_talk_get_messages(mocker):
"""get_messages parses the OCS-wrapped message list."""
mock_response = create_mock_response(
status_code=200,
headers={"X-Chat-Last-Given": "100"},
json_data={
"ocs": {
"meta": {"status": "ok"},
"data": [
{
"id": 101,
"token": "abc",
"actorType": "users",
"actorId": "alice",
"actorDisplayName": "Alice",
"timestamp": 1700000000,
"messageType": "comment",
"message": "Hi",
},
{
"id": 102,
"token": "abc",
"actorType": "users",
"actorId": "bob",
"actorDisplayName": "Bob",
"timestamp": 1700000010,
"messageType": "comment",
"message": "Hello",
},
],
}
},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
messages, last_given = await client.get_messages("abc", limit=20)
assert len(messages) == 2
assert all(isinstance(m, TalkMessage) for m in messages)
assert messages[0].id == 101
assert messages[1].actorId == "bob"
assert last_given == 100
call_args = mock_make_request.call_args
assert call_args[0][0] == "GET"
assert "/chat/abc" in call_args[0][1]
params = call_args[1]["params"]
assert params["limit"] == 20
# Defaults: not look_into_future, not set_read_marker
assert params["lookIntoFuture"] == 0
assert params["setReadMarker"] == 0
async def test_talk_get_messages_pagination_cursor(mocker):
"""last_known_message_id is forwarded as the spreed cursor param."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
messages, last_given = await client.get_messages(
"abc", last_known_message_id=500, include_last_known=True
)
assert messages == []
assert last_given is None # No header on this response
params = mock_make_request.call_args[1]["params"]
assert params["lastKnownMessageId"] == 500
assert params["includeLastKnown"] == 1
async def test_talk_get_messages_invalid_last_given_header(mocker, caplog):
"""A non-numeric X-Chat-Last-Given falls back to None and logs a warning."""
mock_response = create_mock_response(
status_code=200,
headers={"X-Chat-Last-Given": "not-a-number"},
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mocker.patch.object(TalkClient, "_make_request", return_value=mock_response)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
with caplog.at_level(logging.WARNING, logger="nextcloud_mcp_server.client.talk"):
messages, last_given = await client.get_messages("abc")
assert messages == []
assert last_given is None
assert any(
"Invalid X-Chat-Last-Given" in record.message for record in caplog.records
), "Expected a warning log for the malformed header"
async def test_talk_send_message(mocker):
"""send_message posts the message text and parses the response."""
mock_response = create_mock_talk_message_response(
message_id=999, token="abc", text="Posted from MCP"
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
posted = await client.send_message("abc", "Posted from MCP")
assert isinstance(posted, TalkMessage)
assert posted.id == 999
assert posted.message == "Posted from MCP"
call_args = mock_make_request.call_args
assert call_args[0][0] == "POST"
assert "/chat/abc" in call_args[0][1]
body = call_args[1]["json"]
assert body["message"] == "Posted from MCP"
# Optional fields are not sent unless explicitly set
assert "replyTo" not in body
assert "referenceId" not in body
assert "silent" not in body
async def test_talk_send_message_with_reference_id_and_reply(mocker):
"""send_message forwards reply_to, reference_id, silent."""
mock_response = create_mock_talk_message_response(
message_id=1000, token="abc", text="A reply"
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.send_message(
"abc",
"A reply",
reply_to=999,
reference_id="dedupe-token",
silent=True,
)
body = mock_make_request.call_args[1]["json"]
assert body == {
"message": "A reply",
"replyTo": 999,
"referenceId": "dedupe-token",
"silent": True,
}
async def test_talk_mark_as_read_no_message(mocker):
"""mark_as_read with no message ID sends an empty body."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.mark_as_read("abc")
call_args = mock_make_request.call_args
assert call_args[0][0] == "POST"
assert "/chat/abc/read" in call_args[0][1]
assert call_args[1]["json"] == {}
async def test_talk_mark_as_read_with_message(mocker):
"""mark_as_read sends lastReadMessage when provided."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.mark_as_read("abc", last_read_message=500)
assert mock_make_request.call_args[1]["json"] == {"lastReadMessage": 500}
# Participant tests
async def test_talk_list_participants(mocker):
"""list_participants parses the OCS-wrapped participant list."""
mock_response = create_mock_response(
status_code=200,
json_data={
"ocs": {
"meta": {"status": "ok"},
"data": [
{
"attendeeId": 1,
"actorType": "users",
"actorId": "alice",
"displayName": "Alice",
"participantType": 1,
"inCall": 0,
"lastPing": 1700000000,
},
{
"attendeeId": 2,
"actorType": "users",
"actorId": "bob",
"displayName": "Bob",
"participantType": 3,
"inCall": 0,
"lastPing": 1700000000,
},
],
}
},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
participants = await client.list_participants("abc")
assert len(participants) == 2
assert all(isinstance(p, TalkParticipant) for p in participants)
assert participants[0].actorId == "alice"
assert participants[1].participantType == 3
call_args = mock_make_request.call_args
assert call_args[0][0] == "GET"
assert "/api/v4/room/abc/participants" in call_args[0][1]
# Default: include_status off → no includeStatus param
assert "includeStatus" not in call_args[1].get("params", {})
async def test_talk_list_participants_with_include_status(mocker):
"""include_status=True forwards includeStatus=true as a query param."""
mock_response = create_mock_response(
status_code=200,
json_data={"ocs": {"meta": {"status": "ok"}, "data": []}},
)
mock_make_request = mocker.patch.object(
TalkClient, "_make_request", return_value=mock_response
)
client = TalkClient(mocker.AsyncMock(spec=httpx.AsyncClient), "testuser")
await client.list_participants("abc", include_status=True)
params = mock_make_request.call_args[1]["params"]
assert params["includeStatus"] == "true"
Reference in New Issue View Git Blame Copy Permalink