nixevol/MemRelay
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 导入 MemRelay 初始源码

Browse Source
This commit is contained in:
Nixevol
2026-09-23 21:40:46 +08:00
commit 0ade3bb318
167 changed files with 53511 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/tests/test_mcp.py
+631
View File
@@ -0,0 +1,631 @@
import asyncio
import json
import socket
import threading
import time
from datetime import UTC, datetime
from typing import Any
from unittest.mock import patch
import httpx
import uvicorn
from fastapi.testclient import TestClient
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport
from sqlalchemy import select
from memrelay.models import CurationChange, UsageProfile
from tests.conftest import csrf_headers
from tests.fakes import FakeBasicMemory
from tests.test_vault import FakeBwRunner, configure_vault, install_fake_vault
def create_mcp_token(client: TestClient, name: str, access_mode: str) -> dict[str, Any]:
response = client.post(
"/api/v1/tokens",
json={"name": name, "access_mode": access_mode},
headers=csrf_headers(client),
)
assert response.status_code == 201
return response.json()
def asgi_transport(app, token: str) -> StreamableHttpTransport: # type: ignore[no-untyped-def]
def factory(**kwargs) -> httpx.AsyncClient: # type: ignore[no-untyped-def]
headers = dict(kwargs.get("headers") or {})
headers["Authorization"] = f"Bearer {token}"
return httpx.AsyncClient(
transport=httpx.ASGITransport(app=app),
base_url="http://testserver",
headers=headers,
timeout=kwargs.get("timeout"),
follow_redirects=True,
)
return StreamableHttpTransport(
"http://testserver/mcp", auth=token, httpx_client_factory=factory
)
def result_data(result) -> Any: # type: ignore[no-untyped-def]
data = result.data
return data.model_dump(mode="json") if hasattr(data, "model_dump") else data
def test_mcp_get_sse_stream_returns_405_not_404(initialized_client: TestClient) -> None:
# 客户端 initialize 后会 GET /mcp 尝试打开服务端主动 SSE 流；无状态模式不支持，
# 规范要求 405（客户端静默容忍）。若落入 SPA 兜底返回 404，客户端会把它当作
# 会话失效并在连续重试后禁用整个连接。
response = initialized_client.get("/mcp", headers={"Accept": "text/event-stream"})
assert response.status_code == 405
assert "POST" in response.headers.get("allow", "")
def test_mcp_requires_token(initialized_client: TestClient) -> None:
response = initialized_client.post(
"/mcp",
headers={"Accept": "application/json, text/event-stream"},
json={
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": {"name": "test", "version": "1"},
},
},
)
assert response.status_code == 401
def test_streamable_http_mcp_operates_over_a_real_tcp_server(
initialized_client: TestClient,
) -> None:
client = initialized_client
token = create_mcp_token(client, "TCP MCP", "read_write")
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(("127.0.0.1", 0))
listener.listen(128)
port = int(listener.getsockname()[1])
server = uvicorn.Server(
uvicorn.Config(
client.app,
host="127.0.0.1",
port=port,
log_level="error",
lifespan="off",
)
)
thread = threading.Thread(target=lambda: server.run(sockets=[listener]), daemon=True)
thread.start()
deadline = time.monotonic() + 10
while not server.started and thread.is_alive() and time.monotonic() < deadline:
time.sleep(0.01)
assert server.started
async def exercise() -> None:
transport = StreamableHttpTransport(
f"http://127.0.0.1:{port}/mcp",
auth=token["token"],
)
async with Client(transport) as mcp:
names = {tool.name for tool in await mcp.list_tools()}
assert {
"capabilities_get",
"curation_status",
"curation_history",
"curated_document_get",
"curation_run",
} <= names
capabilities = result_data(await mcp.call_tool("capabilities_get", {}))
assert capabilities["curation_enabled"] is False
status = result_data(await mcp.call_tool("curation_status", {}))
assert status["settings"]["enabled"] is False
history = result_data(await mcp.call_tool("curation_history", {"limit": 5}))
assert history == []
resources = await mcp.list_resources()
assert {str(item.uri) for item in resources} >= {
"memrelay://guide",
"memrelay://capabilities",
"memrelay://projects",
}
try:
asyncio.run(exercise())
finally:
server.should_exit = True
thread.join(timeout=10)
listener.close()
assert not thread.is_alive()
def test_mcp_tools_resources_and_scope_enforcement(initialized_client: TestClient) -> None:
client = initialized_client
client.app.state.basic_memory = FakeBasicMemory()
project = client.post(
"/api/v1/projects",
json={"name": "MCP Project"},
headers=csrf_headers(client),
).json()
stored_file = client.app.state.settings.files_dir / "mcp-metadata.txt"
stored_file.write_text("MCP metadata", encoding="utf-8")
client.post("/api/v1/files/scan", headers=csrf_headers(client))
file_record = client.get(
"/api/v1/files", params={"query": "mcp-metadata.txt"}
).json()[0]
client.patch(
f"/api/v1/files/{file_record['id']}",
json={
"description": "Original MCP description",
"version": "1.0",
"purpose": "reference",
"tags": ["mcp", "stable"],
"project_id": project["id"],
},
headers=csrf_headers(client),
)
read_token = create_mcp_token(client, "Reader", "read_only")
write_token = create_mcp_token(client, "Writer", "read_write")
verified = asyncio.run(client.app.state.mcp_server.auth.verify_token(read_token["token"]))
assert verified is not None
assert verified.scopes == ["read"]
authenticated_probe = client.post(
"/mcp",
headers={
"Accept": "application/json, text/event-stream",
"Authorization": f"Bearer {read_token['token']}",
},
json={
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": {"name": "test", "version": "1"},
},
},
)
assert authenticated_probe.status_code != 401, authenticated_probe.text
async def exercise() -> None:
async with Client(asgi_transport(client.app, read_token["token"])) as reader:
names = {tool.name for tool in await reader.list_tools()}
expected_read = {
"capabilities_get",
"project_resolve",
"project_list",
"project_export_prepare",
"context_get",
"memory_list",
"memory_search",
"memory_get",
"checkpoint_get",
"secret_capabilities",
"secret_list",
"secret_item_get",
"secret_search",
"secret_get",
"secret_totp",
"file_search",
"file_list",
"file_get",
"file_upload_status",
"curation_status",
"curation_history",
"curated_document_list",
"curated_document_get",
"curated_document_history",
"curated_document_diff",
"curation_settings_get",
"curation_schedule_list",
"curation_schedule_preview",
"curation_model_connection_status",
"curation_model_list",
"usage_profile_list",
"git_connection_get",
"git_mode_migration_preview",
"memory_repository_list",
"memory_repository_status",
"memory_repository_history",
"memory_repository_diff",
"memory_version_get",
"memory_repository_remote_inspect",
"dashboard_get",
"system_settings_get",
"token_list",
}
write_tools = {
"project_create",
"project_resolve_or_create",
"project_update",
"project_archive",
"project_delete",
"memory_save",
"memory_archive",
"memory_delete",
"checkpoint_save",
"checkpoint_delete",
"secret_sync",
"secret_resolve",
"secret_save",
"secret_delete",
"file_directory_create",
"file_upload_prepare",
"file_metadata_update",
"file_move",
"file_delete",
"file_scan",
"curation_run",
"curation_source_submit",
"curated_document_update",
"curated_document_revert",
"curation_cancel",
"curation_retry",
"curation_settings_update",
"curation_schedule_save",
"curation_schedule_delete",
"curation_schedule_reset_defaults",
"curation_model_connection_save",
"curation_model_connection_test",
"usage_profile_save",
"usage_profile_token_bind",
"usage_profile_delete",
"git_connection_save",
"git_mode_migration_execute",
"git_connection_test",
"git_connection_delete",
"memory_repository_create",
"memory_repository_sync",
"memory_version_restore",
"memory_snapshot_restore",
"memory_remote_import",
"memory_remote_bootstrap",
"memory_repository_unbind",
"memory_repository_archive_purge",
"system_settings_update",
"token_create",
"token_reveal",
"token_revoke",
"token_delete",
}
assert expected_read <= names
assert names.isdisjoint(write_tools)
capabilities = result_data(await reader.call_tool("capabilities_get", {}))
assert capabilities["memory"] is True
assert capabilities["vault"] is False
assert capabilities["semantic_search"]["status"] == "available"
dashboard = result_data(await reader.call_tool("dashboard_get", {}))
assert "curation" in dashboard
assert "memory_git" in dashboard
assert "database" in dashboard
resolved = result_data(
await reader.call_tool("project_resolve", {"name": "MCP Project"})
)
assert resolved["id"] == project["id"]
read_only_directory = "D:/ReadOnly/MCP Project"
resolved_with_directory = result_data(
await reader.call_tool(
"project_resolve",
{"name": "MCP Project", "directory": read_only_directory},
)
)
assert resolved_with_directory["id"] == project["id"]
assert read_only_directory.casefold() not in resolved_with_directory["aliases"]
try:
await reader.call_tool(
"memory_save",
{
"request_id": "denied",
"scope": "global",
"memory_type": "rule",
"title": "Denied",
"content": "Must not write.",
},
)
except Exception as exc:
message = str(exc).casefold()
assert "authorization" in message or "scope" in message or "unknown tool" in message
else:
raise AssertionError("Read-only token unexpectedly called a write tool")
guide = await reader.read_resource("memrelay://guide")
assert "不把猜测" in guide[0].text
assert "project_resolve_or_create" in guide[0].text
assert "AI 自动整理" not in guide[0].text
assert "记忆版本历史" not in guide[0].text
status_with_timestamp = client.app.state.curation.model_status()
status_with_timestamp["last_check_at"] = datetime.now(UTC)
with patch.object(
client.app.state.curation,
"model_status",
return_value=status_with_timestamp,
):
capabilities_resource = await reader.read_resource("memrelay://capabilities")
resource_data = json.loads(capabilities_resource[0].text)
assert resource_data["semantic_search"]["status"] == "available"
assert resource_data["tools"] == capabilities["tools"]
assert resource_data["curation"]["model"]["last_check_at"].endswith("+00:00")
async with Client(asgi_transport(client.app, write_token["token"])) as writer:
writer_names = {tool.name for tool in await writer.list_tools()}
assert write_tools <= writer_names
saved = result_data(
await writer.call_tool(
"memory_save",
{
"request_id": "mcp-save-1",
"scope": "project",
"project_id": project["id"],
"memory_type": "decision",
"title": "MCP contract",
"content": "Use Streamable HTTP.",
},
)
)
assert saved["revision"] == 1
context = result_data(
await writer.call_tool(
"context_get", {"project_id": project["id"], "query": "HTTP"}
)
)
assert saved["id"] in context["included_memory_ids"]
upload = result_data(
await writer.call_tool("file_upload_prepare", {"path": "mcp/file.txt", "size": 4})
)
assert upload["upload_url"].startswith("http://testserver/")
async with httpx.AsyncClient(
transport=httpx.ASGITransport(app=client.app),
base_url="http://testserver",
) as uploader:
uploaded = await uploader.put(upload["upload_url"], content=b"mcp!")
assert uploaded.status_code == 200, uploaded.text
partial_metadata = result_data(
await writer.call_tool(
"file_metadata_update",
{
"file_id": file_record["id"],
"description": "Updated through MCP",
},
)
)
assert partial_metadata["description"] == "Updated through MCP"
assert partial_metadata["version"] == "1.0"
assert partial_metadata["purpose"] == "reference"
assert partial_metadata["tags"] == ["mcp", "stable"]
assert partial_metadata["project_id"] == project["id"]
cleared_metadata = result_data(
await writer.call_tool(
"file_metadata_update",
{
"file_id": file_record["id"],
"clear_version": True,
"clear_project": True,
"tags": [],
},
)
)
assert cleared_metadata["version"] is None
assert cleared_metadata["project_id"] is None
assert cleared_metadata["purpose"] == "reference"
assert cleared_metadata["tags"] == []
created_project = result_data(
await writer.call_tool(
"project_create",
{
"name": "Created by MCP",
"git_remote": "https://example.com/team/repo.git",
"aliases": ["C:/code/repo"],
},
)
)
updated_project = result_data(
await writer.call_tool(
"project_update",
{"project_id": created_project["id"], "name": "Updated by MCP"},
)
)
assert updated_project["name"] == "Updated by MCP"
resolved_or_created = result_data(
await writer.call_tool(
"project_resolve_or_create",
{
"git_remote": "git@example.test:team/created-from-workflow.git",
"directory": "E:/Projects/CreatedFromWorkflow",
},
)
)
assert resolved_or_created["created"] is True
assert resolved_or_created["project"]["name"] == "created-from-workflow"
assert "e:/projects/createdfromworkflow" in resolved_or_created["project"]["aliases"]
resolved_again = result_data(
await writer.call_tool(
"project_resolve_or_create",
{
"name": "A different local folder name",
"git_remote": "https://example.test/team/created-from-workflow.git",
"directory": "F:/Projects/CreatedFromWorkflow",
},
)
)
assert resolved_again["created"] is False
assert resolved_again["project"]["id"] == resolved_or_created["project"]["id"]
assert "f:/projects/createdfromworkflow" in resolved_again["project"]["aliases"]
checkpoint = result_data(
await writer.call_tool(
"checkpoint_save",
{
"project_id": project["id"],
"request_id": "mcp-checkpoint-1",
"content": "## Completed\n\nVerified the complete MCP workflow.",
},
)
)
export = result_data(
await writer.call_tool("project_export_prepare", {"project_id": project["id"]})
)
assert export["url"].startswith("http://testserver/")
assert "aidocs/" in export["powershell_command"]
listed_memories = result_data(
await writer.call_tool("memory_list", {"project_id": project["id"]})
)
assert saved["id"] in {item["id"] for item in listed_memories}
# Checkpoints leave the pending bucket and get their own lifecycle filter.
assert checkpoint["id"] not in {item["id"] for item in listed_memories}
listed_checkpoints = result_data(
await writer.call_tool(
"memory_list",
{"project_id": project["id"], "lifecycle": "checkpoint"},
)
)
assert checkpoint["id"] in {item["id"] for item in listed_checkpoints}
assert result_data(await writer.call_tool("dashboard_get", {}))["checkpoints"] == 1
await writer.call_tool("checkpoint_delete", {"checkpoint_id": checkpoint["id"]})
generated_token = result_data(
await writer.call_tool(
"token_create", {"name": "Generated token", "access_mode": "read_only"}
)
)
assert generated_token["token"].startswith("mcp_")
profile = result_data(
await writer.call_tool(
"usage_profile_save",
{"name": "MCP profile", "description": "Bound through MCP"},
)
)
bound = result_data(
await writer.call_tool(
"usage_profile_token_bind",
{"profile_id": profile["id"], "token_ids": [generated_token["id"]]},
)
)
assert bound["token_count"] == 1
schedules = result_data(await writer.call_tool("curation_schedule_reset_defaults", {}))
assert {item["trigger_type"] for item in schedules} == {
"workspace_quiet",
"workspace_fallback",
"global_curation",
}
await writer.call_tool(
"usage_profile_token_bind",
{"profile_id": profile["id"], "token_ids": []},
)
await writer.call_tool("usage_profile_delete", {"profile_id": profile["id"]})
await writer.call_tool("token_delete", {"token_id": generated_token["id"]})
await writer.call_tool(
"project_archive", {"project_id": created_project["id"], "archived": True}
)
await writer.call_tool("project_delete", {"project_id": created_project["id"]})
asyncio.run(exercise())
with client.app.state.session_factory() as db:
shared = db.scalar(select(UsageProfile).where(UsageProfile.is_shared.is_(True)))
agent_changes = db.scalars(
select(CurationChange).where(
CurationChange.project_id == project["id"],
CurationChange.origin == "agent",
)
).all()
assert shared is not None and agent_changes
assert {item.usage_profile_id for item in agent_changes} == {shared.id}
def test_mcp_password_vault_management(initialized_client: TestClient) -> None:
client = initialized_client
runner = FakeBwRunner()
install_fake_vault(client, runner)
configure_vault(client)
token = create_mcp_token(client, "Vault manager", "read_write")
async def exercise() -> None:
async with Client(asgi_transport(client.app, token["token"])) as mcp:
listed = result_data(await mcp.call_tool("secret_list", {}))
assert len(listed["results"]) == 2
assert "git-password" not in str(listed)
detail = result_data(await mcp.call_tool("secret_item_get", {"item_id": "item-1"}))
assert detail["password"] == "git-password"
saved = result_data(
await mcp.call_tool(
"secret_save",
{
"name": "AI Created Credential",
"username": "automation",
"password": "generated-password",
"uris": ["https://automation.example.com"],
"fields": [
{"name": "api_token", "value": "generated-token", "hidden": True}
],
"lookup_key": "automation-service",
},
)
)
assert saved["created"] is True
assert saved["item"]["password"] == "generated-password"
deleted = result_data(
await mcp.call_tool("secret_delete", {"item_id": saved["item"]["id"]})
)
assert deleted == {"deleted": True}
asyncio.run(exercise())
def test_all_profiles_token_includes_profiles_created_later(
initialized_client: TestClient,
) -> None:
client = initialized_client
client.app.state.basic_memory = FakeBasicMemory()
token_response = client.post(
"/api/v1/tokens",
json={"name": "All profiles", "access_mode": "read_write", "all_profiles": True},
headers=csrf_headers(client),
)
assert token_response.status_code == 201
token = token_response.json()
future_profile = client.post(
"/api/v1/curation/profiles",
json={"name": "Created after token"},
headers=csrf_headers(client),
).json()
future_memory = client.post(
"/api/v1/memories",
json={
"request_id": "future-profile-memory",
"scope": "global",
"usage_profile_id": future_profile["id"],
"memory_type": "preference",
"title": "Future profile preference",
"content": "This profile was created after the MCP token.",
"tags": [],
},
headers=csrf_headers(client),
).json()
async def exercise() -> None:
async with Client(asgi_transport(client.app, token["token"])) as mcp:
listed = result_data(await mcp.call_tool("memory_list", {"scope": "global"}))
assert future_memory["id"] in {item["id"] for item in listed}
saved = result_data(
await mcp.call_tool(
"memory_save",
{
"request_id": "all-profile-targeted-write",
"scope": "global",
"usage_profile_id": future_profile["id"],
"memory_type": "task_list",
"title": "Future profile tasks",
"content": "- [ ] Verify all-profile access",
},
)
)
assert saved["usage_profile_id"] == future_profile["id"]
assert saved["memory_type"] == "task_list"
asyncio.run(exercise())