Enterprise agent platform for building, deploying, and operating AI teammates.
"""Create, update and echo of a connector's signed-upload settings over HTTP."""
from __future__ import annotations
import copy
from typing import Any
import pytest
from xagent.web.models.custom_api import CustomApi, UserCustomApi
from xagent.web.models.mcp import MCPServer, UserMCPServer
from xagent.web.models.user import User
from .conftest import _admin_headers, _direct_db_session, _register_second_user, client
pytestmark = pytest.mark.usefixtures("_test_db")
URL = "https://mcp.example.test/mcp"
NAME = "upload-connector"
BAD = {"tool_name": "attach_document"}
SIGNED_UPLOADS = [
{
"tool_name": "attach_document",
"file_argument": "document_file_id",
"issuing_tool_name": "request_upload",
"allowed_upload_hosts": ["uploads.example.test"],
"upload_path_prefix": "/staged/",
"content_types": {".pdf": "application/pdf"},
}
]
TRANSPORT_DETAIL = (
"Invalid configuration: signed_uploads are supported only for the sse and "
"streamable_http transports; to use another transport, set signed_uploads "
"to [] in the same request"
)
# The errors signed_upload_settings_error gives for the values used below,
# written out so a change of wording shows up here.
MISSING_KEYS_ERROR = "signed_uploads[0] must have exactly the documented keys"
NOT_A_LIST_ERROR = "signed_uploads must be a list"
NO_HOST_ERROR = "the connection URL has no hostname"
OWNER_ONLY_DETAIL = "Only the server owner can change the shared configuration"
def _without_content_types() -> list[dict[str, Any]]:
entry = copy.deepcopy(SIGNED_UPLOADS[0])
del entry["content_types"]
return [entry]
def _invalid_detail(error: str) -> str:
return "Invalid configuration: " + error
def _user_id(username: str) -> int:
db = _direct_db_session()
try:
return int(db.query(User).filter(User.username == username).one().id)
finally:
db.close()
def _create(headers: dict[str, str], **fields: Any):
body: dict[str, Any] = {
"name": NAME,
"transport": "streamable_http",
"description": "Uploads",
"config": {"url": URL},
}
body.update(fields)
return client.post("/api/mcp/servers", json=body, headers=headers)
def _create_ok(headers: dict[str, str], **fields: Any) -> int:
resp = _create(headers, **fields)
assert resp.status_code == 201, resp.text
return int(resp.json()["id"])
def _row(server_id: int) -> dict[str, Any]:
from sqlalchemy import text
db = _direct_db_session()
try:
server = db.query(MCPServer).filter(MCPServer.id == server_id).one()
is_null = db.execute(
text("SELECT signed_uploads IS NULL FROM mcp_servers WHERE id = :id"),
{"id": server_id},
).scalar_one()
return {
"name": server.name,
"transport": server.transport,
"url": server.url,
"description": server.description,
"signed_uploads": server.signed_uploads,
"signed_uploads_is_null": bool(is_null),
}
finally:
db.close()
def _store(server_id: int, value: Any) -> None:
db = _direct_db_session()
try:
server = db.query(MCPServer).filter(MCPServer.id == server_id).one()
server.signed_uploads = value
db.commit()
finally:
db.close()
def _link_non_owner(username: str, server_id: int) -> None:
db = _direct_db_session()
try:
db.add(
UserMCPServer(
user_id=_user_id(username),
mcpserver_id=server_id,
is_owner=False,
is_active=True,
)
)
db.commit()
finally:
db.close()
def _assert_names_signed_uploads(resp) -> None:
assert any("signed_uploads" in err["loc"] for err in resp.json()["detail"])
def _server_named(items: list[dict[str, Any]], server_id: int) -> dict[str, Any]:
matches = [
item
for item in items
if item["id"] == server_id and item["transport"] != "custom_api"
]
assert len(matches) == 1
return matches[0]
_REJECT_CASES = [
"create-not-a-list",
"create-entry-not-an-object",
"create-missing-key",
"create-stdio",
"create-websocket",
"create-url-without-host",
"update-not-a-list",
"update-entry-not-an-object",
"update-missing-key",
"update-transport-to-stdio",
"update-transport-to-websocket",
"update-url-without-host",
]
def _reject_on_create(case: str, owner: dict[str, str]) -> None:
if case == "create-not-a-list":
resp = _create(owner, signed_uploads={"tool_name": "attach_document"})
assert resp.status_code == 422, resp.text
_assert_names_signed_uploads(resp)
elif case == "create-entry-not-an-object":
resp = _create(owner, signed_uploads=["attach_document"])
assert resp.status_code == 422, resp.text
_assert_names_signed_uploads(resp)
elif case == "create-missing-key":
raw = _without_content_types()
resp = _create(owner, signed_uploads=raw)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == (
"Invalid configuration: "
"signed_uploads[0] must have exactly the documented keys"
)
elif case == "create-stdio":
resp = _create(
owner,
transport="stdio",
config={"command": "python"},
signed_uploads=SIGNED_UPLOADS,
)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == TRANSPORT_DETAIL
elif case == "create-websocket":
resp = _create(
owner,
transport="websocket",
config={"url": "wss://mcp.example.test/ws"},
signed_uploads=SIGNED_UPLOADS,
)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == TRANSPORT_DETAIL
else:
no_host = "https:///mcp"
resp = _create(owner, config={"url": no_host}, signed_uploads=SIGNED_UPLOADS)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == (
"Invalid configuration: the connection URL has no hostname"
)
db = _direct_db_session()
try:
assert db.query(MCPServer).filter(MCPServer.name == NAME).count() == 0
finally:
db.close()
def _reject_on_update(case: str, owner: dict[str, str]) -> None:
server_id = _create_ok(owner, signed_uploads=SIGNED_UPLOADS)
before = _row(server_id)
assert before["signed_uploads"] == SIGNED_UPLOADS
expected_status = 400
expected_detail: str | None
if case == "update-not-a-list":
payload: dict[str, Any] = {"signed_uploads": {"tool_name": "attach_document"}}
expected_status, expected_detail = 422, None
elif case == "update-entry-not-an-object":
payload = {"signed_uploads": ["attach_document"]}
expected_status, expected_detail = 422, None
elif case == "update-missing-key":
raw = _without_content_types()
payload = {"signed_uploads": raw}
expected_detail = _invalid_detail(MISSING_KEYS_ERROR)
elif case == "update-transport-to-stdio":
payload = {"transport": "stdio", "config": {"command": "python"}}
expected_detail = TRANSPORT_DETAIL
elif case == "update-transport-to-websocket":
payload = {"transport": "websocket"}
expected_detail = TRANSPORT_DETAIL
else:
no_host = "https:///mcp"
payload = {"config": {"url": no_host}}
expected_detail = _invalid_detail(NO_HOST_ERROR)
resp = client.put(f"/api/mcp/servers/{server_id}", json=payload, headers=owner)
assert resp.status_code == expected_status, resp.text
if expected_status == 422:
_assert_names_signed_uploads(resp)
else:
assert resp.json()["detail"] == expected_detail
assert _row(server_id) == before
@pytest.mark.parametrize("case", _REJECT_CASES)
def test_save_rejects_invalid_signed_uploads(case: str) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
if case.startswith("create-"):
_reject_on_create(case, owner)
else:
_reject_on_update(case, owner)
@pytest.mark.parametrize(
"case",
[
"create-valid",
"create-valid-sse",
"create-omitted",
"update-to-stdio-clearing",
"update-clear-to-null",
],
)
def test_save_accepts_signed_uploads(case: str) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
if case in ("create-valid", "create-valid-sse"):
transport = "sse" if case == "create-valid-sse" else "streamable_http"
resp = _create(owner, transport=transport, signed_uploads=SIGNED_UPLOADS)
assert resp.status_code == 201, resp.text
body = resp.json()
assert body["transport"] == transport
assert body["signed_uploads"] == SIGNED_UPLOADS
assert body["signed_uploads_error"] is None
assert _row(body["id"])["signed_uploads"] == SIGNED_UPLOADS
elif case == "create-omitted":
server_id = _create_ok(owner)
assert _row(server_id)["signed_uploads_is_null"] is True
elif case == "update-to-stdio-clearing":
server_id = _create_ok(owner, signed_uploads=SIGNED_UPLOADS)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={
"transport": "stdio",
"config": {"command": "python"},
"signed_uploads": [],
},
headers=owner,
)
assert resp.status_code == 200, resp.text
row = _row(server_id)
assert row["transport"] == "stdio"
assert row["signed_uploads"] == []
else:
server_id = _create_ok(owner, signed_uploads=SIGNED_UPLOADS)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": None},
headers=owner,
)
assert resp.status_code == 200, resp.text
assert _row(server_id)["signed_uploads_is_null"] is True
@pytest.mark.parametrize(
("created", "switched"),
[("streamable_http", "sse"), ("sse", "streamable_http")],
)
def test_switching_between_sse_and_streamable_http_keeps_valid_settings(
created: str, switched: str
) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner, transport=created, signed_uploads=SIGNED_UPLOADS)
resp = client.put(
f"/api/mcp/servers/{server_id}", json={"transport": switched}, headers=owner
)
assert resp.status_code == 200, resp.text
assert resp.json()["signed_uploads"] == SIGNED_UPLOADS
assert resp.json()["signed_uploads_error"] is None
row = _row(server_id)
assert row["transport"] == switched
assert row["signed_uploads"] == SIGNED_UPLOADS
@pytest.mark.parametrize(
"case",
[
"owner-rename",
"owner-description",
"owner-same-transport",
"owner-same-url",
"owner-new-url",
"non-owner-personal",
"non-owner-same-description",
],
)
def test_save_checks_signed_uploads_only_when_they_or_the_connection_change(
case: str,
) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
_store(server_id, BAD)
caller = owner
if case.startswith("non-owner"):
caller = _register_second_user("carol", "carolpass1")
_link_non_owner("carol", server_id)
payloads: dict[str, dict[str, Any]] = {
"owner-rename": {"name": "upload-connector-renamed"},
"owner-description": {"description": "New description"},
"owner-same-transport": {"transport": "streamable_http"},
"owner-same-url": {"config": {"url": URL}},
"owner-new-url": {"config": {"url": "https://other.example.test/mcp"}},
"non-owner-personal": {"user_env": {"K": "v"}, "is_active": False},
"non-owner-same-description": {"description": "Uploads"},
}
resp = client.put(
f"/api/mcp/servers/{server_id}", json=payloads[case], headers=caller
)
if case == "owner-new-url":
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == _invalid_detail(NOT_A_LIST_ERROR)
assert _row(server_id)["url"] == URL
return
assert resp.status_code == 200, resp.text
row = _row(server_id)
assert row["signed_uploads"] == BAD
if case == "owner-rename":
assert row["name"] == "upload-connector-renamed"
body = resp.json()
assert body["signed_uploads"] == BAD
assert body["signed_uploads_error"] == NOT_A_LIST_ERROR
@pytest.mark.parametrize(
("stored", "requested", "expected_status"),
[
pytest.param("omit", SIGNED_UPLOADS, 403, id="set-on-empty"),
pytest.param("omit", [], 200, id="empty-list-on-null"),
pytest.param(SIGNED_UPLOADS, SIGNED_UPLOADS, 200, id="same-value"),
pytest.param([], None, 200, id="null-on-empty-list"),
pytest.param(SIGNED_UPLOADS, [], 403, id="clear-to-empty-list"),
pytest.param(SIGNED_UPLOADS, None, 403, id="clear-to-null"),
],
)
def test_non_owner_cannot_change_signed_uploads(
stored: Any, requested: Any, expected_status: int
) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
if stored == "omit":
server_id = _create_ok(owner)
else:
server_id = _create_ok(owner, signed_uploads=stored)
other = _register_second_user("carol", "carolpass1")
_link_non_owner("carol", server_id)
before = _row(server_id)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": requested},
headers=other,
)
assert resp.status_code == expected_status, resp.text
if expected_status == 403:
assert resp.json()["detail"] == OWNER_ONLY_DETAIL
assert _row(server_id) == before
def test_non_owner_resending_stored_invalid_signed_uploads_is_not_checked() -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
stored = [{"tool_name": "attach_document"}]
_store(server_id, stored)
other = _register_second_user("carol", "carolpass1")
_link_non_owner("carol", server_id)
before = _row(server_id)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": stored},
headers=other,
)
# A non-owner's copy is only compared with the stored value and never
# saved, so it is not checked. The owner sending the same value gets 400:
# test_owner_saving_the_stored_invalid_signed_uploads_is_still_checked.
assert resp.status_code == 200, resp.text
assert resp.json()["signed_uploads"] == stored
assert resp.json()["signed_uploads_error"] == MISSING_KEYS_ERROR
assert _row(server_id) == before
def test_non_owner_empty_list_against_a_stored_non_list_is_a_change() -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
_store(server_id, {})
other = _register_second_user("carol", "carolpass1")
_link_non_owner("carol", server_id)
before = _row(server_id)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": []},
headers=other,
)
# Only null and [] mean no settings. A stored {} is neither, so [] is a
# change and the non-owner is refused. The row stays as it is either way,
# because a non-owner's value is never saved.
assert resp.status_code == 403, resp.text
assert resp.json()["detail"] == OWNER_ONLY_DETAIL
assert _row(server_id) == before
@pytest.mark.parametrize("case", ["admin-valid", "admin-missing-key"])
def test_platform_admin_can_change_signed_uploads(case: str) -> None:
admin = _admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
_link_non_owner("admin", server_id)
before = _row(server_id)
assert before["signed_uploads_is_null"] is True
if case == "admin-valid":
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": SIGNED_UPLOADS},
headers=admin,
)
assert resp.status_code == 200, resp.text
assert _row(server_id)["signed_uploads"] == SIGNED_UPLOADS
else:
raw = _without_content_types()
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": raw},
headers=admin,
)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == _invalid_detail(MISSING_KEYS_ERROR)
assert _row(server_id) == before
def test_owner_saving_the_stored_invalid_signed_uploads_is_still_checked() -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
stored = [{"tool_name": "attach_document"}]
_store(server_id, stored)
before = _row(server_id)
assert before["signed_uploads"] == stored
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": stored},
headers=owner,
)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == _invalid_detail(MISSING_KEYS_ERROR)
assert _row(server_id) == before
def _add_custom_api(owner_name: str) -> None:
db = _direct_db_session()
try:
api = CustomApi(
name="lookup-api", url="https://api.example.test/lookup", method="GET"
)
db.add(api)
db.flush()
db.add(
UserCustomApi(
user_id=_user_id(owner_name),
custom_api_id=api.id,
is_owner=True,
is_active=True,
)
)
db.commit()
finally:
db.close()
@pytest.mark.parametrize(
("stored", "expected_error"),
[
({"tool_name": "attach_document"}, NOT_A_LIST_ERROR),
([{"tool_name": "attach_document"}], MISSING_KEYS_ERROR),
],
ids=["not-an-array", "missing-keys"],
)
def test_list_and_detail_echo_invalid_signed_uploads(
stored: Any, expected_error: str
) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner)
_store(server_id, stored)
_add_custom_api("bob")
listing = client.get("/api/mcp/servers", headers=owner)
assert listing.status_code == 200, listing.text
items = listing.json()
listed = _server_named(items, server_id)
assert listed["signed_uploads"] == stored
assert listed["signed_uploads_error"] == expected_error
custom = [item for item in items if item["transport"] == "custom_api"]
assert len(custom) == 1
assert custom[0]["signed_uploads"] is None
assert custom[0]["signed_uploads_error"] is None
detail = client.get(f"/api/mcp/servers/{server_id}", headers=owner)
assert detail.status_code == 200, detail.text
assert detail.json()["signed_uploads"] == listed["signed_uploads"]
assert detail.json()["signed_uploads_error"] == listed["signed_uploads_error"]
def test_list_and_detail_echo_usable_and_inert_signed_uploads() -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
usable_id = _create_ok(owner, signed_uploads=SIGNED_UPLOADS)
inert_id = _create_ok(
owner,
name="stdio-connector",
transport="stdio",
config={"command": "python"},
)
_store(inert_id, SIGNED_UPLOADS)
listing = client.get("/api/mcp/servers", headers=owner)
assert listing.status_code == 200, listing.text
items = listing.json()
for server_id in (usable_id, inert_id):
listed = _server_named(items, server_id)
assert listed["signed_uploads"] == SIGNED_UPLOADS
assert listed["signed_uploads_error"] is None
detail = client.get(f"/api/mcp/servers/{server_id}", headers=owner)
assert detail.status_code == 200, detail.text
assert detail.json()["signed_uploads"] == SIGNED_UPLOADS
assert detail.json()["signed_uploads_error"] is None
# ---------------------------------------------------------------------------
# Issuer entries
# ---------------------------------------------------------------------------
ISSUER_ENTRY = {
"issuing_tool_name": "request_upload",
"allowed_upload_hosts": ["uploads.example.test"],
"upload_path_prefix": "/staged/",
"content_types": {".pdf": "application/pdf"},
}
ISSUER_ENTRIES = [ISSUER_ENTRY]
# A replacement entry for another issuing tool, which may sit next to an issuer.
OTHER_REPLACEMENT = {**SIGNED_UPLOADS[0], "issuing_tool_name": "issue_other"}
# A replacement entry that only hides the issuing tool: its tool is one the
# connector does not list.
HIDE_ONLY_ENTRIES = [
{
**ISSUER_ENTRY,
"tool_name": "unlisted_tool",
"file_argument": "document_file_id",
}
]
def _also_a_replacement_issuer(position: int) -> str:
return _invalid_detail(
f"signed_uploads[{position}].issuing_tool_name "
"is also the issuing tool of a replacement entry"
)
@pytest.mark.parametrize(
"case",
[
"create-issuer",
"create-issuer-and-replacement",
"update-issuer-replaces-replacement",
"update-issuer-rewritten-as-hide-only",
"update-hide-only-back-to-issuer",
],
)
def test_api_accepts_issuer_entries(case: str) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
expected: list[dict[str, Any]] = ISSUER_ENTRIES
if case.startswith("create-"):
if case == "create-issuer-and-replacement":
expected = [ISSUER_ENTRY, OTHER_REPLACEMENT]
resp = _create(owner, signed_uploads=expected)
assert resp.status_code == 201, resp.text
assert resp.json()["signed_uploads"] == expected
assert resp.json()["signed_uploads_error"] is None
server_id = int(resp.json()["id"])
else:
stored: list[dict[str, Any]] = {
"update-issuer-replaces-replacement": SIGNED_UPLOADS,
"update-issuer-rewritten-as-hide-only": ISSUER_ENTRIES,
"update-hide-only-back-to-issuer": HIDE_ONLY_ENTRIES,
}[case]
if case == "update-issuer-rewritten-as-hide-only":
expected = HIDE_ONLY_ENTRIES
elif case == "update-hide-only-back-to-issuer":
expected = ISSUER_ENTRIES
server_id = _create_ok(owner, signed_uploads=stored)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": expected},
headers=owner,
)
assert resp.status_code == 200, resp.text
assert resp.json()["signed_uploads"] == expected
assert resp.json()["signed_uploads_error"] is None
assert _row(server_id)["signed_uploads"] == expected
detail = client.get(f"/api/mcp/servers/{server_id}", headers=owner)
assert detail.status_code == 200, detail.text
assert detail.json()["signed_uploads"] == expected
assert detail.json()["signed_uploads_error"] is None
_CLASHES = [
pytest.param(
[ISSUER_ENTRY, SIGNED_UPLOADS[0]],
_also_a_replacement_issuer(0),
id="issuer-first",
),
pytest.param(
[SIGNED_UPLOADS[0], ISSUER_ENTRY],
_also_a_replacement_issuer(1),
id="issuer-last",
),
]
@pytest.mark.parametrize("mode", ["create", "update"])
@pytest.mark.parametrize(("clashing", "detail"), _CLASHES)
def test_save_rejects_clashing_issuer_entries(
mode: str, clashing: Any, detail: str
) -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
if mode == "create":
resp = _create(owner, signed_uploads=clashing)
server_id = None
else:
server_id = _create_ok(owner, signed_uploads=ISSUER_ENTRIES)
before = _row(server_id)
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": clashing},
headers=owner,
)
assert resp.status_code == 400, resp.text
assert resp.json()["detail"] == detail
if server_id is not None:
assert _row(server_id) == before
else:
db = _direct_db_session()
try:
assert db.query(MCPServer).filter(MCPServer.name == NAME).count() == 0
finally:
db.close()
def test_non_owner_cannot_change_issuer_entries() -> None:
_admin_headers()
owner = _register_second_user("bob", "bobpass1")
server_id = _create_ok(owner, signed_uploads=ISSUER_ENTRIES)
other = _register_second_user("carol", "carolpass1")
_link_non_owner("carol", server_id)
before = _row(server_id)
changed = [{**ISSUER_ENTRY, "upload_path_prefix": "/other/"}]
resp = client.put(
f"/api/mcp/servers/{server_id}",
json={"signed_uploads": changed},
headers=other,
)
assert resp.status_code == 403, resp.text
assert resp.json()["detail"] == OWNER_ONLY_DETAIL
assert _row(server_id) == before