RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
test: audit Python SDK message management (#21676)
Sbaaoui Idrissc8e5b29936ab
diff --git a/test/testcases/test_sdk_api/test_message_management/conftest.py b/test/testcases/test_sdk_api/test_message_management/conftest.pyindex 8e374385cb..5e5197be2d 100644--- a/test/testcases/test_sdk_api/test_message_management/conftest.py+++ b/test/testcases/test_sdk_api/test_message_management/conftest.py@@ -13,150 +13,164 @@# See the License for the specific language governing permissions and# limitations under the License.#-import time-import uuid+"""Run with this folder's pytest.ini and --confcutdir to exclude live ancestor hooks."""++import json+import os+from uuid import uuid4import pytest-import random-from configs import IS_GO_PROXY+import requests+from ragflow_sdk import RAGFlow+from message_helpers import assert_identity, wait_until-MESSAGE_USER_ID = "sdk-api-test-user" if IS_GO_PROXY else ""[email protected](autouse=True)+def request_boundary(request, monkeypatch):+ send = requests.sessions.Session.request+ if request.node.get_closest_marker("integration") is None:[email protected](scope="class")-def add_empty_raw_type_memory(client, request):- def cleanup():- memory_list_res = client.list_memory()- exist_memory_ids = [memory.id for memory in memory_list_res["memory_list"]]- for _memory_id in exist_memory_ids:- client.delete_memory(_memory_id)+ def forbid_network(*args, **kwargs):+ pytest.fail("Service-free message tests must not open a network connection")- request.addfinalizer(cleanup)- payload = {"name": "test_memory_0", "memory_type": ["raw"], "embd_id": "BAAI/bge-small-en-v1.5@Builtin", "llm_id": "glm-4-flash@ZHIPU-AI"}- res = client.create_memory(**payload)- memory_id = res.id- request.cls.memory_id = memory_id- request.cls.memory_type = payload["memory_type"]- return memory_id+ monkeypatch.setattr(requests.sessions.Session, "send", forbid_network)+ def bounded_request(session, *args, **kwargs):+ kwargs.setdefault("timeout", 30)+ return send(session, *args, **kwargs)[email protected](scope="class")-def add_empty_multiple_type_memory(client, request):- def cleanup():- memory_list_res = client.list_memory()- exist_memory_ids = [memory.id for memory in memory_list_res["memory_list"]]- for _memory_id in exist_memory_ids:- client.delete_memory(_memory_id)+ monkeypatch.setattr(requests.sessions.Session, "request", bounded_request)- request.addfinalizer(cleanup)- payload = {- "name": "test_memory_0",- "memory_type": ["raw"] + random.choices(["semantic", "episodic", "procedural"], k=random.randint(1, 3)),- "embd_id": "BAAI/bge-small-en-v1.5@Builtin",- "llm_id": "glm-4-flash@ZHIPU-AI",- }- res = client.create_memory(**payload)- memory_id = res.id- request.cls.memory_id = memory_id- request.cls.memory_type = payload["memory_type"]- return memory_id--[email protected](scope="class")-def add_2_multiple_type_memory(client, request):- def cleanup():- memory_list_res = client.list_memory()- exist_memory_ids = [memory.id for memory in memory_list_res["memory_list"]]- for _memory_id in exist_memory_ids:- client.delete_memory(_memory_id)- request.addfinalizer(cleanup)- memory_ids = []- for i in range(2):- payload = {- "name": f"test_memory_{i}",- "memory_type": ["raw"] + random.choices(["semantic", "episodic", "procedural"], k=random.randint(1, 3)),- "embd_id": "BAAI/bge-small-en-v1.5@Builtin",- "llm_id": "glm-4-flash@ZHIPU-AI",- }- res = client.create_memory(**payload)- memory_ids.append(res.id)- request.cls.memory_ids = memory_ids- return memory_ids--[email protected](scope="class")-def add_memory_with_multiple_type_message_func(client, request):- def cleanup():- memory_list_res = client.list_memory()- exist_memory_ids = [mem.id for mem in memory_list_res["memory_list"]]- for _memory_id in exist_memory_ids:- client.delete_memory(_memory_id)[email protected](scope="session")+def integration_settings():+ keys = ("RAGFLOW_SDK_BASE_URL", "RAGFLOW_SDK_API_KEY", "RAGFLOW_SDK_TENANT_ID")+ if os.getenv("RAGFLOW_SDK_ISOLATED") != "1" or any(not os.getenv(key) for key in keys):+ pytest.fail(+ "Message integrations require a verified disposable Go backend and dedicated empty tenant: "+ "RAGFLOW_SDK_ISOLATED=1, " + ", ".join(keys) + ". Run service-free tests with -m 'not integration'."+ )+ if os.getenv("PYTEST_XDIST_WORKER"):+ pytest.fail("Message integrations require serial execution in a dedicated tenant")+ return dict(zip(("base_url", "api_key", "tenant_id"), (os.environ[key] for key in keys)))- request.addfinalizer(cleanup)- payload = {- "name": "test_memory_0",- "memory_type": ["raw"] + random.choices(["semantic", "episodic", "procedural"], k=random.randint(1, 3)),- "embd_id": "BAAI/bge-small-en-v1.5@Builtin",- "llm_id": "glm-4-flash@ZHIPU-AI",- }- memory = client.create_memory(**payload)- memory_id = memory.id- agent_id = uuid.uuid4().hex- message_payload = {- "memory_id": [memory_id],- "agent_id": agent_id,- "session_id": uuid.uuid4().hex,- "user_id": MESSAGE_USER_ID,- "user_input": "what is coriander?",- "agent_response": """-Coriander is a versatile herb with two main edible parts, and its name can refer to both:-1. Leaves and Stems (often called Cilantro or Fresh Coriander): These are the fresh, green, fragrant leaves and tender stems of the plant Coriandrum sativum. They have a bright, citrusy, and sometimes pungent flavor. Cilantro is widely used as a garnish or key ingredient in cuisines like Mexican, Indian, Thai, and Middle Eastern.-2. Seeds (called Coriander Seeds): These are the dried, golden-brown seeds of the same plant. When ground, they become coriander powder. The seeds have a warm, nutty, floral, and slightly citrusy taste, completely different from the fresh leaves. They are a fundamental spice in curries, stews, pickles, and baking.-Key Point of Confusion: The naming differs by region. In North America, "coriander" typically refers to the seeds, while "cilantro" refers to the fresh leaves. In the UK, Europe, and many other parts of the world, "coriander" refers to the fresh herb, and the seeds are called "coriander seeds."-""",- }- client.add_message(**message_payload)- request.cls.memory_id = memory_id- request.cls.agent_id = agent_id- time.sleep(2) # make sure refresh to index before search- return memory_id--[email protected](scope="class")-def add_memory_with_5_raw_message_func(client, request):[email protected](scope="session")+def isolated_tenant(integration_settings):+ rag = RAGFlow(integration_settings["api_key"], integration_settings["base_url"])+ response = requests.get(f"{rag.api_url}/memories", headers=rag.authorization_header, params={"page_size": 1}, timeout=30)+ response.raise_for_status()+ payload = response.json()+ assert payload["code"] == 0, payload+ result = payload["data"]+ assert result["total_count"] == 0 and result["memory_list"] == [], "Refusing integration setup: tenant has accessible memories"+ return integration_settings+++def client(isolated_tenant, monkeypatch, request):+ rag = RAGFlow(isolated_tenant["api_key"], isolated_tenant["base_url"])+ owned = []+ create = rag.create_memory+def cleanup():- memory_list_res = client.list_memory()- exist_memory_ids = [mem.id for mem in memory_list_res["memory_list"]]- for _memory_id in exist_memory_ids:- client.delete_memory(_memory_id)+ errors = []+ for memory_id in reversed(owned):+ try:+ result = rag.get(f"/memories/{memory_id}/config").json()+ if result["code"] == 0:+ rag.delete_memory(memory_id)+ else:+ assert result["code"] == 404, result+ result = rag.get(f"/memories/{memory_id}/config").json()+ assert result["code"] == 404, result+ except Exception as exc:+ errors.append(f"{memory_id}: {exc}")+ assert not errors, "Owned memory cleanup failed: " + "; ".join(errors)request.addfinalizer(cleanup)- payload = {"name": "test_memory_1", "memory_type": ["raw"], "embd_id": "BAAI/bge-small-en-v1.5@Builtin", "llm_id": "glm-4-flash@ZHIPU-AI"}- memory = client.create_memory(**payload)- memory_id = memory.id- agent_ids = [uuid.uuid4().hex for _ in range(2)]- session_ids = [uuid.uuid4().hex for _ in range(5)]- for i in range(5):- message_payload = {- "memory_id": [memory_id],- "agent_id": agent_ids[i % 2],- "session_id": session_ids[i],- "user_id": MESSAGE_USER_ID,- "user_input": "what is coriander?",- "agent_response": """-Coriander is a versatile herb with two main edible parts, and its name can refer to both:-1. Leaves and Stems (often called Cilantro or Fresh Coriander): These are the fresh, green, fragrant leaves and tender stems of the plant Coriandrum sativum. They have a bright, citrusy, and sometimes pungent flavor. Cilantro is widely used as a garnish or key ingredient in cuisines like Mexican, Indian, Thai, and Middle Eastern.-2. Seeds (called Coriander Seeds): These are the dried, golden-brown seeds of the same plant. When ground, they become coriander powder. The seeds have a warm, nutty, floral, and slightly citrusy taste, completely different from the fresh leaves. They are a fundamental spice in curries, stews, pickles, and baking.-Key Point of Confusion: The naming differs by region. In North America, "coriander" typically refers to the seeds, while "cilantro" refers to the fresh leaves. In the UK, Europe, and many other parts of the world, "coriander" refers to the fresh herb, and the seeds are called "coriander seeds."-""",- }- client.add_message(**message_payload)- request.cls.memory_id = memory_id- request.cls.agent_ids = agent_ids- request.cls.session_ids = session_ids- time.sleep(2) # make sure refresh to index before search- return memory_id+ def tracked_create(*args, **kwargs):+ memory = create(*args, **kwargs)+ owned.append(memory.id)+ assert memory.tenant_id == isolated_tenant["tenant_id"], "Created memory belongs to unexpected tenant"+ return memory++ monkeypatch.setattr(rag, "create_memory", tracked_create)+ return rag+++def memory_factory(client):+ def create(memory_type=None):+ keys = {"embd_id": "RAGFLOW_SDK_MEMORY_EMBD_ID", "llm_id": "RAGFLOW_SDK_MEMORY_LLM_ID"}+ if any(not os.getenv(key) for key in keys.values()):+ pytest.fail("Configure memory models explicitly: " + ", ".join(keys.values()))+ return client.create_memory(name=f"sdk-messages-{uuid4().hex}", memory_type=memory_type or ["raw"], **{field: os.environ[key] for field, key in keys.items()})++ return create+++def populated_memory(client, memory_factory):+ memory = memory_factory()+ namespace = uuid4().hex+ conversations = [+ ("What is coriander?", "Coriander leaves are called cilantro and used as an herb."),+ ("Which parts of coriander are edible?", "Coriander seeds are a spice; its leaves are cilantro."),+ ("What is a pineapple?", "Pineapple is a sweet tropical fruit with a spiky rind."),+ ("What does a pineapple symbolize?", "Pineapple is a symbol of hospitality and welcome."),+ ("Where is Mount Everest?", "Mount Everest is a mountain in the Himalayas."),+ ]+ payloads = []+ rows = []+ for i, (question, answer) in enumerate(conversations):+ payload = dict(+ memory_id=[memory.id], agent_id=f"{namespace}-agent-{i % 2}", session_id=f"{namespace}-session-{i}", user_id=f"{namespace}-user-{i % 2}", user_input=question, agent_response=answer+ )+ assert client.add_message(**payload) == "All add to task."+ result = wait_until(memory.list_memory_messages, lambda value: value["messages"]["total_count"] == i + 1)+ matches = [row for row in result["messages"]["message_list"] if row["session_id"] == payload["session_id"]]+ assert len(matches) == 1, result+ assert_identity(matches[0], payload, memory.id)+ payloads.append(payload)+ rows.append(matches[0])+ assert len({str(row["message_id"]) for row in rows}) == 5+ return {"memory": memory, "rows": rows, "payloads": payloads}+++def mock_api(monkeypatch):+ """Exercise actual SDK HTTP serialization without a server."""+ calls = []+ responses = []++ def respond(payload, status=200):+ responses.append((payload, status))+ return calls++ def send(session, prepared, **kwargs):+ assert kwargs["timeout"] == 30+ calls.append(prepared)+ assert responses, "Unexpected SDK HTTP request"+ payload, status = responses.pop(0)+ response = requests.Response()+ response.status_code = status+ response._content = json.dumps(payload).encode()+ response.headers["Content-Type"] = "application/json"+ response.request = prepared+ return response++ monkeypatch.setattr(requests.sessions.Session, "send", send)+ yield respond+ assert not responses, "Expected SDK requests were not sent"+++def doc_engine(client):+ result = client.get("/system/status").json()+ assert result["code"] == 0, result+ engine = result["data"]["doc_engine"]["type"].lower()+ assert engine, result+ return enginediff --git a/test/testcases/test_sdk_api/test_message_management/message_helpers.py b/test/testcases/test_sdk_api/test_message_management/message_helpers.pynew file mode 100644index 0000000000..e4f9952a43--- /dev/null+++ b/test/testcases/test_sdk_api/test_message_management/message_helpers.py@@ -0,0 +1,41 @@+#+# Copyright 2025 The InfiniFlow Authors. All Rights Reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+#+import time+++def wait_until(probe, predicate, timeout=30.0):+ """Retry incomplete results, never hide API errors behind retries."""+ deadline = time.monotonic() + timeout+ while True:+ result = probe()+ if predicate(result):+ return result+ remaining = deadline - time.monotonic()+ assert remaining > 0, f"Timed out waiting for message state; last result: {result!r}"+ time.sleep(min(0.25, remaining))+++def assert_identity(row, payload, memory_id):+ assert row["memory_id"] == memory_id, row+ assert row["message_type"] == "raw", row+ for field in ("agent_id", "session_id", "user_id"):+ assert row[field] == payload[field].strip(), row+ assert str(row["message_id"]).isdigit(), row+++def assert_content(row, payload, memory_id):+ assert_identity(row, payload, memory_id)+ assert row["content"] == f"User Input: {payload['user_input']}\nAgent Response: {payload['agent_response']}", rowdiff --git a/test/testcases/test_sdk_api/test_message_management/pytest.ini b/test/testcases/test_sdk_api/test_message_management/pytest.ininew file mode 100644index 0000000000..9a17a5e963--- /dev/null+++ b/test/testcases/test_sdk_api/test_message_management/pytest.ini@@ -0,0 +1,5 @@+[pytest]+pythonpath = ../../../../sdk/python .+addopts = --strict-markers+markers =+ integration: requires a verified disposable Go backend and dedicated empty tenantdiff --git a/test/testcases/test_sdk_api/test_message_management/test_add_message.py b/test/testcases/test_sdk_api/test_message_management/test_add_message.pyindex fc0dcd4435..18909ffbed 100644--- a/test/testcases/test_sdk_api/test_message_management/test_add_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_add_message.py@@ -13,133 +13,119 @@# See the License for the specific language governing permissions and# limitations under the License.#-import time-import uuid+from uuid import uuid4+import pytest-from ragflow_sdk import RAGFlow, Memory-from configs import HOST_ADDRESS, INVALID_API_TOKEN, IS_GO_PROXY, SDK_UNAUTHORIZED_ERROR_MESSAGE+from ragflow_sdk import RAGFlow++from message_helpers import assert_content, assert_identity, wait_until++pytestmark = pytest.mark.integration-MESSAGE_USER_ID = "sdk-api-test-user" if IS_GO_PROXY else ""[email protected]("invalid_auth", [None, "invalid-token"])+def test_auth_invalid(integration_settings, invalid_auth):+ rag = RAGFlow(invalid_auth, integration_settings["base_url"])+ with pytest.raises(Exception, match="^Invalid access token$"):+ rag.add_message(["missing"], "agent", "session", "question", "answer", user_id="external-user")-class TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],+def payload_for(memories):+ namespace = uuid4().hex+ return dict(+ memory_id=[memory.id for memory in memories],+ agent_id=f"{namespace}-agent",+ session_id=f"{namespace}-session",+ user_id="external-conversation-user",+ user_input="What is a pineapple?",+ agent_response="A pineapple is a sweet tropical fruit.",)- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- client.add_message(**{"memory_id": [""], "agent_id": "", "session_id": "", "user_id": MESSAGE_USER_ID, "user_input": "what is pineapple?", "agent_response": ""})- assert str(exception_info.value) == expected_message, str(exception_info.value)--[email protected]("add_empty_raw_type_memory")-class TestAddRawMessage:- @pytest.mark.p3- def test_add_raw_message(self, client):- memory_id = self.memory_id- agent_id = uuid.uuid4().hex- session_id = uuid.uuid4().hex- message_payload = {- "memory_id": [memory_id],- "agent_id": agent_id,- "session_id": session_id,- "user_id": MESSAGE_USER_ID,- "user_input": "what is pineapple?",- "agent_response": """-A pineapple is a tropical fruit known for its sweet, tangy flavor and distinctive, spiky appearance. Here are the key facts:-Scientific Name: Ananas comosus-Physical Description: It has a tough, spiky, diamond-patterned outer skin (rind) that is usually green, yellow, or brownish. Inside, the juicy yellow flesh surrounds a fibrous core.-Growth: Unlike most fruits, pineapples do not grow on trees. They grow from a central stem as a composite fruit, meaning they are formed from many individual berries that fuse together around the core. They grow on a short, leafy plant close to the ground.-Uses: Pineapples are eaten fresh, cooked, grilled, juiced, or canned. They are a popular ingredient in desserts, fruit salads, savory dishes (like pizzas or ham glazes), smoothies, and cocktails.-Nutrition: They are a good source of Vitamin C, manganese, and contain an enzyme called bromelain, which aids in digestion and can tenderize meat.-Symbolism: The pineapple is a traditional symbol of hospitality and welcome in many cultures.-Are you asking about the fruit itself, or its use in a specific context?-""",- }- add_res = client.add_message(**message_payload)- assert add_res == "All add to task.", str(add_res)- time.sleep(2) # make sure refresh to index before search- memory = Memory(client, {"id": memory_id})- message_res = memory.list_memory_messages(**{"agent_id": agent_id, "keywords": session_id})- assert message_res["messages"]["total_count"] > 0- for message in message_res["messages"]["message_list"]:- assert message["agent_id"] == agent_id, message- assert message["session_id"] == session_id, message--[email protected]("add_empty_multiple_type_memory")-class TestAddMultipleTypeMessage:- @pytest.mark.p1- def test_add_multiple_type_message(self, client):- memory_id = self.memory_id- agent_id = uuid.uuid4().hex- session_id = uuid.uuid4().hex- message_payload = {- "memory_id": [memory_id],- "agent_id": agent_id,- "session_id": session_id,- "user_id": MESSAGE_USER_ID,- "user_input": "what is pineapple?",- "agent_response": """-A pineapple is a tropical fruit known for its sweet, tangy flavor and distinctive, spiky appearance. Here are the key facts:-Scientific Name: Ananas comosus-Physical Description: It has a tough, spiky, diamond-patterned outer skin (rind) that is usually green, yellow, or brownish. Inside, the juicy yellow flesh surrounds a fibrous core.-Growth: Unlike most fruits, pineapples do not grow on trees. They grow from a central stem as a composite fruit, meaning they are formed from many individual berries that fuse together around the core. They grow on a short, leafy plant close to the ground.-Uses: Pineapples are eaten fresh, cooked, grilled, juiced, or canned. They are a popular ingredient in desserts, fruit salads, savory dishes (like pizzas or ham glazes), smoothies, and cocktails.-Nutrition: They are a good source of Vitamin C, manganese, and contain an enzyme called bromelain, which aids in digestion and can tenderize meat.-Symbolism: The pineapple is a traditional symbol of hospitality and welcome in many cultures.-Are you asking about the fruit itself, or its use in a specific context?-""",- }- add_res = client.add_message(**message_payload)- assert add_res == "All add to task.", str(add_res)- time.sleep(2) # make sure refresh to index before search- memory = Memory(client, {"id": memory_id})- message_res = memory.list_memory_messages(**{"agent_id": agent_id, "keywords": session_id})- assert message_res["messages"]["total_count"] > 0- for message in message_res["messages"]["message_list"]:- assert message["agent_id"] == agent_id, message- assert message["session_id"] == session_id, message--[email protected]("add_2_multiple_type_memory")-class TestAddToMultipleMemory:- @pytest.mark.p3- def test_add_to_multiple_memory(self, client):- memory_ids = self.memory_ids- agent_id = uuid.uuid4().hex- session_id = uuid.uuid4().hex- message_payload = {- "memory_id": memory_ids,- "agent_id": agent_id,- "session_id": session_id,- "user_id": MESSAGE_USER_ID,- "user_input": "what is pineapple?",- "agent_response": """-A pineapple is a tropical fruit known for its sweet, tangy flavor and distinctive, spiky appearance. Here are the key facts:-Scientific Name: Ananas comosus-Physical Description: It has a tough, spiky, diamond-patterned outer skin (rind) that is usually green, yellow, or brownish. Inside, the juicy yellow flesh surrounds a fibrous core.-Growth: Unlike most fruits, pineapples do not grow on trees. They grow from a central stem as a composite fruit, meaning they are formed from many individual berries that fuse together around the core. They grow on a short, leafy plant close to the ground.-Uses: Pineapples are eaten fresh, cooked, grilled, juiced, or canned. They are a popular ingredient in desserts, fruit salads, savory dishes (like pizzas or ham glazes), smoothies, and cocktails.-Nutrition: They are a good source of Vitamin C, manganese, and contain an enzyme called bromelain, which aids in digestion and can tenderize meat.-Symbolism: The pineapple is a traditional symbol of hospitality and welcome in many cultures.-Are you asking about the fruit itself, or its use in a specific context?-""",- }- add_res = client.add_message(**message_payload)- assert add_res == "All add to task.", str(add_res)- time.sleep(2) # make sure refresh to index before search- for memory_id in memory_ids:- memory = Memory(client, {"id": memory_id})- message_res = memory.list_memory_messages(**{"agent_id": agent_id, "keywords": session_id})- assert message_res["messages"]["total_count"] > 0- for message in message_res["messages"]["message_list"]:- assert message["agent_id"] == agent_id, message- assert message["session_id"] == session_id, message++[email protected]("types", [["raw"], ["raw", "semantic", "episodic", "procedural"]], ids=["raw", "multiple-types"])+def test_add_message(client, memory_factory, types):+ memory = memory_factory(memory_type=types)+ payload = payload_for([memory])+ assert client.add_message(**payload) == "All add to task."+ result = wait_until(memory.list_memory_messages, lambda value: value["messages"]["total_count"] == 1)+ rows = result["messages"]["message_list"]+ assert len(rows) == 1+ assert_identity(rows[0], payload, memory.id)+ assert_content(memory.get_message_content(rows[0]["message_id"]), payload, memory.id)+ recent = wait_until(lambda: client.get_recent_messages([memory.id]), lambda value: any(row["message_id"] == rows[0]["message_id"] for row in value))+ assert_content(next(row for row in recent if row["message_id"] == rows[0]["message_id"]), payload, memory.id)+++def test_add_to_multiple_memory(client, memory_factory):+ memories = [memory_factory(), memory_factory()]+ payload = payload_for(memories)+ assert client.add_message(**payload) == "All add to task."+ ids = []+ for memory in memories:+ result = wait_until(memory.list_memory_messages, lambda value: value["messages"]["total_count"] == 1)+ rows = result["messages"]["message_list"]+ assert len(rows) == 1+ assert_content(memory.get_message_content(rows[0]["message_id"]), payload, memory.id)+ ids.append(rows[0]["message_id"])+ # Each association has an independently addressable memory:message identity.+ assert len({(memory.id, str(message_id)) for memory, message_id in zip(memories, ids)}) == 2++[email protected]("field", ["memory_id", "agent_id", "session_id", "user_input", "agent_response", "user_id"])[email protected]("value", [None, "", 12])+def test_invalid_creation_fields(client, memory_factory, field, value):+ memory = memory_factory()+ payload = payload_for([memory])+ payload[field] = value+ with pytest.raises(Exception, match="body arguments is required|memory_id is required|user_id is required"):+ client.add_message(**payload)+ assert memory.list_memory_messages()["messages"] == {"total_count": 0, "message_list": []}++[email protected]("user_id", ["", " "])+def test_api_key_requires_external_user(client, memory_factory, user_id):+ memory = memory_factory()+ payload = payload_for([memory])+ payload["user_id"] = user_id+ with pytest.raises(Exception, match="^user_id is required$"):+ client.add_message(**payload)+ assert memory.list_memory_messages()["messages"]["total_count"] == 0+++def test_api_key_default_user_is_rejected(client, memory_factory):+ memory = memory_factory()+ payload = payload_for([memory])+ del payload["user_id"]+ with pytest.raises(Exception, match="^user_id is required$"):+ client.add_message(**payload)+++def test_external_user_trimmed_and_does_not_control_memory_access(client, memory_factory):+ memory = memory_factory()+ payload = payload_for([memory])+ payload["user_id"] = " external-subject "+ assert client.add_message(**payload) == "All add to task."+ result = wait_until(memory.list_memory_messages, lambda value: value["messages"]["total_count"] == 1)+ assert_content(memory.get_message_content(result["messages"]["message_list"][0]["message_id"]), payload, memory.id)+++def test_missing_memory_rejected(client):+ payload = payload_for([])+ payload["memory_id"] = [uuid4().hex]+ with pytest.raises(Exception, match="Some messages failed to add.*Memory not found"):+ client.add_message(**payload)+++def test_empty_memory_list_rejected(client):+ with pytest.raises(Exception, match="memory_id is required"):+ client.add_message(**payload_for([]))+++def test_partial_memory_failure_is_reported_and_valid_save_persists(client, memory_factory):+ memory = memory_factory()+ payload = payload_for([memory])+ payload["memory_id"] = [memory.id, uuid4().hex]+ with pytest.raises(Exception, match="Some messages failed to add"):+ client.add_message(**payload)+ result = wait_until(memory.list_memory_messages, lambda value: value["messages"]["total_count"] == 1)+ assert_content(memory.get_message_content(result["messages"]["message_list"][0]["message_id"]), payload, memory.id)diff --git a/test/testcases/test_sdk_api/test_message_management/test_forget_message.py b/test/testcases/test_sdk_api/test_message_management/test_forget_message.pyindex c3f51110ec..b6f23ebcfe 100644--- a/test/testcases/test_sdk_api/test_message_management/test_forget_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_forget_message.py@@ -13,41 +13,71 @@# See the License for the specific language governing permissions and# limitations under the License.#-import randomimport pytest-from ragflow_sdk import RAGFlow, Memory-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE+from ragflow_sdk import Memory, RAGFlow++from message_helpers import assert_content, wait_until++pytestmark = pytest.mark.integrationclass TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],- )- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- memory = Memory(client, {"id": "empty_memory_id"})- memory.forget_message(0)- assert str(exception_info.value) == expected_message, str(exception_info.value)--[email protected]("add_memory_with_5_raw_message_func")+ @pytest.mark.parametrize("invalid_auth", [None, "invalid-token"])+ def test_auth_invalid(self, populated_memory, integration_settings, invalid_auth):+ memory = populated_memory["memory"]+ rag = RAGFlow(invalid_auth, integration_settings["base_url"])+ row = populated_memory["rows"][0]+ with pytest.raises(Exception, match="^Invalid access token$"):+ Memory(rag, {"id": memory.id}).forget_message(row["message_id"])+ content = memory.get_message_content(row["message_id"])+ assert content["forget_at"] in (None, "", "None"), content+ assert_content(content, populated_memory["payloads"][0], memory.id)++class TestForgetMessage:- @pytest.mark.p3- def test_forget_message(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert len(list_res["messages"]["message_list"]) > 0-- message = random.choice(list_res["messages"]["message_list"])- res = memory.forget_message(message["message_id"])- assert res, str(res)-- forgot_message_res = memory.get_message_content(message["message_id"])- assert forgot_message_res["forget_at"] not in ["-", ""], forgot_message_res+ def test_forget_message(self, client, populated_memory):+ memory = populated_memory["memory"]+ target, *survivors = populated_memory["rows"]+ message_id = target["message_id"]+ assert memory.forget_message(message_id) is True+ forgotten = wait_until(+ lambda: memory.get_message_content(message_id),+ lambda content: content.get("forget_at") not in (None, "", "None", "-"),+ )+ assert_content(forgotten, populated_memory["payloads"][0], memory.id)+ assert forgotten["message_id"] == message_id, forgotten+ assert forgotten["status"] is True, forgotten+ recent = wait_until(+ lambda: client.get_recent_messages([memory.id]),+ lambda rows: {row["message_id"] for row in rows} == {row["message_id"] for row in survivors},+ )+ assert len(recent) == len(survivors)+ assert memory.forget_message(message_id) is True+ assert_content(memory.get_message_content(message_id), populated_memory["payloads"][0], memory.id)++ @pytest.mark.parametrize("message_id", [-1, "bad", "", "1:2"])+ def test_invalid_message_id(self, populated_memory, message_id):+ with pytest.raises(Exception, match="message_id|formatted as memory_id:message_id"):+ populated_memory["memory"].forget_message(message_id)++ def test_nonexistent_message_is_idempotent(self, populated_memory):+ memory = populated_memory["memory"]+ for _ in range(2):+ assert memory.forget_message(9223372036854775807) is True+ for row, payload in zip(populated_memory["rows"], populated_memory["payloads"], strict=True):+ content = memory.get_message_content(row["message_id"])+ assert content["forget_at"] in (None, "", "None"), content+ assert_content(content, payload, memory.id)++ def test_nonexistent_memory(self, client):+ with pytest.raises(Exception, match="^Resource not found$"):+ Memory(client, {"id": "missing-message-test-memory"}).forget_message(0)++ def test_memory_isolation(self, populated_memory, memory_factory):+ other = memory_factory()+ row = populated_memory["rows"][0]+ assert other.forget_message(row["message_id"]) is True+ memory = populated_memory["memory"]+ content = memory.get_message_content(row["message_id"])+ assert content["forget_at"] in (None, "", "None"), content+ assert_content(content, populated_memory["payloads"][0], memory.id)diff --git a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.pyindex a223da5f10..4cf01b6a11 100644--- a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py+++ b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py@@ -13,41 +13,61 @@# See the License for the specific language governing permissions and# limitations under the License.#-import random+import mathimport pytest-from ragflow_sdk import RAGFlow, Memory-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE+from ragflow_sdk import Memory, RAGFlow++from message_helpers import assert_content++pytestmark = pytest.mark.integrationclass TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],- )- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- memory = Memory(client, {"id": "empty_memory_id"})- memory.get_message_content(0)- assert str(exception_info.value) == expected_message, str(exception_info.value)--[email protected]("add_memory_with_multiple_type_message_func")+ @pytest.mark.parametrize("invalid_auth", [None, "invalid-token"])+ def test_auth_invalid(self, populated_memory, integration_settings, invalid_auth):+ memory = populated_memory["memory"]+ rag = RAGFlow(invalid_auth, integration_settings["base_url"])+ unauthorized = Memory(rag, {"id": memory.id})+ with pytest.raises(Exception, match="^Invalid access token$"):+ unauthorized.get_message_content(populated_memory["rows"][0]["message_id"])++class TestGetMessageContent:- @pytest.mark.p1- def test_get_message_content(self, client):- memory_id = self.memory_id- recent_messages = client.get_recent_messages([memory_id])- assert len(recent_messages) > 0, recent_messages- message = random.choice(recent_messages)- message_id = message["message_id"]- memory = Memory(client, {"id": memory_id})- content_res = memory.get_message_content(message_id)- for field in ["content", "content_embed"]:- assert field in content_res- assert content_res[field] is not None, content_res+ def test_get_message_content(self, populated_memory):+ memory = populated_memory["memory"]+ for row, payload in zip(populated_memory["rows"], populated_memory["payloads"], strict=True):+ content = memory.get_message_content(row["message_id"])+ assert content["message_id"] == row["message_id"], content+ assert_content(content, payload, memory.id)+ assert content["status"] is True, content++ def test_get_message_content_embedding(self, populated_memory, doc_engine):+ if doc_engine == "infinity":+ pytest.skip("Go Infinity GetChunk returns q_<dimension>_vec without mapping it to documented content_embed (internal/engine/infinity/chunk.go:1907-1911,2177).")+ memory = populated_memory["memory"]+ content = memory.get_message_content(populated_memory["rows"][0]["message_id"])+ vector = content["content_embed"]+ assert isinstance(vector, list) and vector, content+ assert all(type(value) in (int, float) and math.isfinite(value) for value in vector), content++ @pytest.mark.parametrize("message_id", [-1, "bad", "", "1:2"])+ def test_invalid_message_id(self, populated_memory, message_id):+ with pytest.raises(Exception, match="message_id|formatted as memory_id:message_id"):+ populated_memory["memory"].get_message_content(message_id)++ def test_nonexistent_message(self, populated_memory):+ with pytest.raises(Exception, match="Message .*not found"):+ populated_memory["memory"].get_message_content(9223372036854775807)++ def test_memory_isolation(self, populated_memory, memory_factory):+ other = memory_factory()+ row = populated_memory["rows"][0]+ with pytest.raises(Exception, match="Message .*not found"):+ other.get_message_content(row["message_id"])+ original = populated_memory["memory"].get_message_content(row["message_id"])+ assert_content(original, populated_memory["payloads"][0], populated_memory["memory"].id)++ def test_nonexistent_memory(self, client):+ with pytest.raises(Exception, match="^Resource not found$"):+ Memory(client, {"id": "missing-message-test-memory"}).get_message_content(0)diff --git a/test/testcases/test_sdk_api/test_message_management/test_get_recent_message.py b/test/testcases/test_sdk_api/test_message_management/test_get_recent_message.pyindex 786873c793..a3f58a8cd4 100644--- a/test/testcases/test_sdk_api/test_message_management/test_get_recent_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_get_recent_message.py@@ -13,51 +13,100 @@# See the License for the specific language governing permissions and# limitations under the License.#-import random-import pytestfrom ragflow_sdk import RAGFlow-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE++from message_helpers import assert_identity, wait_until++pytestmark = pytest.mark.integration+++def _assert_messages(messages, populated_memory, expected_rows):+ assert isinstance(messages, list), messages+ assert len(messages) == len(expected_rows), messages+ assert {str(row["message_id"]) for row in messages} == {str(row["message_id"]) for row in expected_rows}, messages+ payloads = {payload["session_id"]: payload for payload in populated_memory["payloads"]}+ for row in messages:+ payload = payloads[row["session_id"]]+ assert_identity(row, payload, populated_memory["memory"].id)+ assert row["content"] == f"User Input: {payload['user_input']}\nAgent Response: {payload['agent_response']}", row+ timestamps = [row["valid_at"] for row in messages]+ assert timestamps == sorted(timestamps, reverse=True), messagesclass TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],- )- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- client.get_recent_messages(["some_memory_id"])- assert str(exception_info.value) == expected_message, str(exception_info.value)--[email protected]("add_memory_with_5_raw_message_func")+ @pytest.mark.parametrize("invalid_auth", [None, "invalid-sdk-message-token"])+ def test_auth_invalid(self, integration_settings, invalid_auth):+ client = RAGFlow(invalid_auth, integration_settings["base_url"])+ with pytest.raises(Exception, match="^Invalid access token$"):+ client.get_recent_messages(["missing-memory"])++class TestGetRecentMessage:- @pytest.mark.p3- def test_get_recent_messages(self, client):- memory_id = self.memory_id- res = client.get_recent_messages([memory_id])- assert len(res) == 5, res-- @pytest.mark.p3- def test_filter_recent_messages_by_agent(self, client):- memory_id = self.memory_id- agent_ids = self.agent_ids- agent_id = random.choice(agent_ids)- res = client.get_recent_messages(**{"agent_id": agent_id, "memory_id": [memory_id]})- for message in res:- assert message["agent_id"] == agent_id, message-- @pytest.mark.p2- def test_filter_recent_messages_by_session(self, client):- memory_id = self.memory_id- session_ids = self.session_ids- session_id = random.choice(session_ids)- res = client.get_recent_messages(**{"session_id": session_id, "memory_id": [memory_id]})- for message in res:- assert message["session_id"] == session_id, message+ def test_get_recent_messages(self, client, populated_memory):+ result = client.get_recent_messages([populated_memory["memory"].id])+ _assert_messages(result, populated_memory, populated_memory["rows"])++ def test_filter_recent_messages_by_agent(self, client, populated_memory):+ agent_id = populated_memory["rows"][0]["agent_id"]+ result = client.get_recent_messages([populated_memory["memory"].id], agent_id=agent_id)+ expected = [row for row in populated_memory["rows"] if row["agent_id"] == agent_id]+ _assert_messages(result, populated_memory, expected)++ def test_filter_recent_messages_by_session(self, client, populated_memory):+ expected = populated_memory["rows"][2:3]+ result = client.get_recent_messages([populated_memory["memory"].id], session_id=expected[0]["session_id"])+ _assert_messages(result, populated_memory, expected)++ @pytest.mark.parametrize("limit", [1, 3, 5, 10, 100])+ def test_limit(self, client, populated_memory, limit):+ result = client.get_recent_messages([populated_memory["memory"].id], limit=limit)+ known = {str(row["message_id"]): row for row in populated_memory["rows"]}+ assert len(result) == min(limit, 5), result+ assert len({str(row["message_id"]) for row in result}) == len(result), result+ expected = [known[str(row["message_id"])] for row in result]+ _assert_messages(result, populated_memory, expected)+ # Equal timestamps do not guarantee a stable order of message IDs.+ assert [row["valid_at"] for row in result] == sorted((row["valid_at"] for row in populated_memory["rows"]), reverse=True)[:limit], result++ @pytest.mark.parametrize("filters", [{"agent_id": "missing-agent"}, {"session_id": "missing-session"}])+ def test_unmatched_filter(self, client, populated_memory, filters):+ assert client.get_recent_messages([populated_memory["memory"].id], **filters) == []++ def test_combined_filters(self, client, populated_memory):+ row = populated_memory["rows"][0]+ memory_id = populated_memory["memory"].id+ result = client.get_recent_messages([memory_id], agent_id=row["agent_id"], session_id=row["session_id"])+ _assert_messages(result, populated_memory, [row])+ assert client.get_recent_messages([memory_id], agent_id=populated_memory["rows"][1]["agent_id"], session_id=row["session_id"]) == []++ def test_memory_isolation_and_multiple_memories(self, client, populated_memory, memory_factory):+ other = memory_factory()+ assert client.get_recent_messages([other.id]) == []+ payload = dict(populated_memory["payloads"][0], memory_id=[other.id], session_id=f"{other.id}-session")+ assert client.add_message(**payload) == "All add to task."+ other_rows = wait_until(lambda: client.get_recent_messages([other.id]), lambda rows: len(rows) == 1)+ assert_identity(other_rows[0], payload, other.id)+ assert other_rows[0]["content"] == f"User Input: {payload['user_input']}\nAgent Response: {payload['agent_response']}"+ result = client.get_recent_messages([populated_memory["memory"].id])+ _assert_messages(result, populated_memory, populated_memory["rows"])+ result = client.get_recent_messages([populated_memory["memory"].id, other.id])+ assert len(result) == 6, result+ assert {(row["memory_id"], str(row["message_id"])) for row in result} == {(row["memory_id"], str(row["message_id"])) for row in populated_memory["rows"] + other_rows}, result+ timestamps = [row["valid_at"] for row in result]+ assert timestamps == sorted(timestamps, reverse=True), result+ own = [row for row in result if row["memory_id"] == populated_memory["memory"].id]+ _assert_messages(own, populated_memory, populated_memory["rows"])++ @pytest.mark.parametrize("memory_id", ["missing-memory", "0" * 32])+ def test_nonexistent_memory(self, client, memory_id):+ assert client.get_recent_messages([memory_id]) == []++ def test_empty_memory_ids(self, client):+ with pytest.raises(Exception, match="^memory_ids is required[.]$"):+ client.get_recent_messages([])++ @pytest.mark.parametrize("limit", [0, -1, 101, "invalid"])+ def test_invalid_limit(self, client, memory_factory, limit):+ with pytest.raises(Exception, match="^limit must be between 1 and 100$"):+ client.get_recent_messages([memory_factory().id], limit=limit)diff --git a/test/testcases/test_sdk_api/test_message_management/test_list_message.py b/test/testcases/test_sdk_api/test_message_management/test_list_message.pyindex 0ae2ac35db..7ee36d4d4f 100644--- a/test/testcases/test_sdk_api/test_message_management/test_list_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_list_message.py@@ -13,49 +13,41 @@# See the License for the specific language governing permissions and# limitations under the License.#-import os-import random-import pytest-from ragflow_sdk import RAGFlow, Memory-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE-from utils.engine_utils import get_doc_engine+from ragflow_sdk import Memory, RAGFlow++from message_helpers import assert_identity++pytestmark = pytest.mark.integration+++def _assert_messages(result, populated_memory, expected_rows):+ messages = result["messages"]+ rows = messages["message_list"]+ assert result["storage_type"] == populated_memory["memory"].storage_type+ assert messages["total_count"] == len(expected_rows), result+ assert len(rows) == len(expected_rows), result+ assert {str(row["message_id"]) for row in rows} == {str(row["message_id"]) for row in expected_rows}, result+ payloads = {payload["session_id"]: payload for payload in populated_memory["payloads"]}+ for row in rows:+ assert_identity(row, payloads[row["session_id"]], populated_memory["memory"].id)+ assert isinstance(row["extract"], list), row+ timestamps = [row["valid_at"] for row in rows]+ assert timestamps == sorted(timestamps, reverse=True), rowsclass TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],- )- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- memory = Memory(client, {"id": "empty_memory_id"})- memory.list_memory_messages()- assert str(exception_info.value) == expected_message, str(exception_info.value)+ @pytest.mark.parametrize("invalid_auth", [None, "invalid-sdk-message-token"])+ def test_auth_invalid(self, integration_settings, invalid_auth):+ client = RAGFlow(invalid_auth, integration_settings["base_url"])+ with pytest.raises(Exception, match="^Invalid access token$"):+ Memory(client, {"id": "missing-memory"}).list_memory_messages()[email protected]("add_memory_with_5_raw_message_func")class TestMessageList:- @pytest.mark.p3- def test_params_unset(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- res = memory.list_memory_messages()- assert len(res["messages"]["message_list"]) == 5, str(res)-- @pytest.mark.p3- def test_params_empty(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- res = memory.list_memory_messages(**{})- assert len(res["messages"]["message_list"]) == 5, str(res)-- @pytest.mark.p1+ def test_params_unset(self, populated_memory):+ _assert_messages(populated_memory["memory"].list_memory_messages(), populated_memory, populated_memory["rows"])+@pytest.mark.parametrize("params, expected_page_size",[@@ -65,38 +57,84 @@ class TestMessageList:({"page": 3, "page_size": 2}, 1),({"page": 5, "page_size": 10}, 0),],- ids=["normal_first_page", "beyond_max_page", "normal_last_partial_page", "normal_middle_page", "full_data_single_page"],+ ids=["first-full-page", "past-end", "first-small-page", "last-partial-page", "far-past-end"],+ )+ def test_page_size(self, populated_memory, params, expected_page_size):+ memory = populated_memory["memory"]+ result = memory.list_memory_messages(**params)["messages"]+ assert result["total_count"] == 5, result+ assert len(result["message_list"]) == expected_page_size, result+ known = {str(row["message_id"]): row for row in populated_memory["rows"]}+ for row in result["message_list"]:+ assert row["session_id"] == known[str(row["message_id"])]["session_id"], row+ assert row["memory_id"] == memory.id, row+ pages = [memory.list_memory_messages(page=page, page_size=2)["messages"] for page in (1, 2, 3)]+ assert [len(page["message_list"]) for page in pages] == [2, 2, 1], pages+ assert all(page["total_count"] == 5 for page in pages), pages+ rows = [row for page in pages for row in page["message_list"]]+ ids = [str(row["message_id"]) for row in rows]+ assert len(ids) == len(set(ids)) == 5, rows+ assert set(ids) == set(known), rows+ timestamps = [row["valid_at"] for row in rows]+ assert timestamps == sorted(timestamps, reverse=True), rows++ @pytest.mark.parametrize("multiple", [False, True], ids=["scalar", "multiple"])+ def test_filter_agent_id(self, populated_memory, multiple):+ agents = list(dict.fromkeys(row["agent_id"] for row in populated_memory["rows"]))+ selected = agents if multiple else agents[:1]+ result = populated_memory["memory"].list_memory_messages(agent_id=selected if multiple else selected[0])+ expected = [row for row in populated_memory["rows"] if row["agent_id"] in selected]+ _assert_messages(result, populated_memory, expected)++ def test_search_keyword(self, populated_memory):+ expected = populated_memory["rows"][2:3]+ result = populated_memory["memory"].list_memory_messages(keywords=expected[0]["session_id"])+ _assert_messages(result, populated_memory, expected)++ def test_search_keyword_substring(self, populated_memory, doc_engine):+ if doc_engine in {"infinity", "oceanbase", "seekdb"}:+ pytest.skip("Go Infinity/OceanBase session_id filters use equality, contrary to Python SDK docs' fuzzy session-ID contract (infinity/chunk.go, oceanbase/filter.go)")+ expected = populated_memory["rows"][2:3]+ keyword = expected[0]["session_id"][4:]+ assert keyword != expected[0]["session_id"]+ result = populated_memory["memory"].list_memory_messages(keywords=keyword)+ _assert_messages(result, populated_memory, expected)++ @pytest.mark.parametrize("filters", [{"agent_id": "missing-agent"}, {"keywords": "missing-session"}])+ def test_unmatched_filter(self, populated_memory, filters):+ result = populated_memory["memory"].list_memory_messages(**filters)+ _assert_messages(result, populated_memory, [])++ def test_combined_filters(self, populated_memory):+ row = populated_memory["rows"][0]+ memory = populated_memory["memory"]+ result = memory.list_memory_messages(agent_id=row["agent_id"], keywords=row["session_id"])+ _assert_messages(result, populated_memory, [row])+ result = memory.list_memory_messages(agent_id=populated_memory["rows"][1]["agent_id"], keywords=row["session_id"])+ _assert_messages(result, populated_memory, [])++ def test_memory_isolation(self, populated_memory, memory_factory):+ result = memory_factory().list_memory_messages()+ assert result["messages"] == {"message_list": [], "total_count": 0}, result+ _assert_messages(populated_memory["memory"].list_memory_messages(), populated_memory, populated_memory["rows"])++ @pytest.mark.parametrize("memory_id", ["missing-memory", "0" * 32])+ def test_nonexistent_memory(self, client, memory_id):+ with pytest.raises(Exception, match="(?i)(not found|does not exist)"):+ Memory(client, {"id": memory_id}).list_memory_messages()++ @pytest.mark.parametrize(+ "params, message",+ [+ ({"page": 0}, "page must be a positive integer"),+ ({"page": -1}, "page must be a positive integer"),+ ({"page": "invalid"}, "page must be a positive integer"),+ ({"page_size": 0}, "page_size must be a positive integer"),+ ({"page_size": -1}, "page_size must be a positive integer"),+ ({"page_size": "invalid"}, "page_size must be a positive integer"),+ ({"page_size": 101}, "page_size must be less than or equal to 100"),+ ],)- def test_page_size(self, client, params, expected_page_size):- # have added 5 messages in fixture- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- res = memory.list_memory_messages(**params)- assert len(res["messages"]["message_list"]) == expected_page_size, str(res)-- @pytest.mark.p2- def test_filter_agent_id(self, client):- memory_id = self.memory_id- agent_ids = self.agent_ids- agent_id = random.choice(agent_ids)- memory = Memory(client, {"id": memory_id})- res = memory.list_memory_messages(**{"agent_id": agent_id})- for message in res["messages"]["message_list"]:- assert message["agent_id"] == agent_id, message-- @pytest.mark.p2- @pytest.mark.skipif(os.getenv("DOC_ENGINE") == "infinity", reason="Not support.")- def test_search_keyword(self, client):- if get_doc_engine(client) == "infinity":- pytest.skip("Not support.")- memory_id = self.memory_id- session_ids = self.session_ids- session_id = random.choice(session_ids)- slice_start = random.randint(0, len(session_id) - 2)- slice_end = random.randint(slice_start + 1, len(session_id) - 1)- keyword = session_id[slice_start:slice_end]- memory = Memory(client, {"id": memory_id})- res = memory.list_memory_messages(**{"keywords": keyword})- assert len(res["messages"]["message_list"]) > 0, res- for message in res["messages"]["message_list"]:- assert keyword in message["session_id"], message+ def test_invalid_pagination(self, memory_factory, params, message):+ with pytest.raises(Exception, match=f"^{message}$"):+ memory_factory().list_memory_messages(**params)diff --git a/test/testcases/test_sdk_api/test_message_management/test_message_authorization.py b/test/testcases/test_sdk_api/test_message_management/test_message_authorization.pynew file mode 100644index 0000000000..aef286a112--- /dev/null+++ b/test/testcases/test_sdk_api/test_message_management/test_message_authorization.py@@ -0,0 +1,49 @@+"""Cross-tenant access uses a second unprivileged API key, never another tenant's data."""++import os++import pytest+from ragflow_sdk import Memory, RAGFlow++from message_helpers import assert_content++pytestmark = pytest.mark.integration+++def other_client(integration_settings):+ key = os.getenv("RAGFLOW_SDK_OTHER_API_KEY")+ tenant_id = os.getenv("RAGFLOW_SDK_OTHER_TENANT_ID")+ if not key or key == integration_settings["api_key"] or not tenant_id or tenant_id == integration_settings["tenant_id"]:+ pytest.fail("Cross-tenant checks require RAGFLOW_SDK_OTHER_API_KEY and RAGFLOW_SDK_OTHER_TENANT_ID for a separate unprivileged tenant")+ return RAGFlow(key, integration_settings["base_url"])++[email protected]("operation", ["list", "recent", "search", "content", "status", "forget", "add"])+def test_private_memory_not_accessible_to_other_tenant(other_client, populated_memory, operation):+ memory = populated_memory["memory"]+ row = populated_memory["rows"][0]+ foreign = Memory(other_client, {"id": memory.id})+ if operation == "recent":+ assert other_client.get_recent_messages([memory.id]) == []+ elif operation == "search":+ assert other_client.search_message("", [memory.id]) == []+ elif operation == "add":+ # Copying a legitimate conversation subject must not grant memory access.+ with pytest.raises(Exception, match="Some messages failed to add.*Memory not found"):+ other_client.add_message(**populated_memory["payloads"][0])+ else:+ with pytest.raises(Exception, match="^Resource not found$"):+ if operation == "list":+ foreign.list_memory_messages()+ elif operation == "content":+ foreign.get_message_content(row["message_id"])+ elif operation == "status":+ foreign.update_message_status(row["message_id"], False)+ else:+ foreign.forget_message(row["message_id"])+ content = memory.get_message_content(row["message_id"])+ assert_content(content, populated_memory["payloads"][0], memory.id)+ assert content["status"] is True+ assert content.get("forget_at") in (None, "", "-")+ assert memory.list_memory_messages()["messages"]["total_count"] == 5diff --git a/test/testcases/test_sdk_api/test_message_management/test_message_fixtures.py b/test/testcases/test_sdk_api/test_message_management/test_message_fixtures.pynew file mode 100644index 0000000000..db16067b9b--- /dev/null+++ b/test/testcases/test_sdk_api/test_message_management/test_message_fixtures.py@@ -0,0 +1,129 @@+#+# Copyright 2025 The InfiniFlow Authors. All Rights Reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+#+from inspect import unwrap+from types import SimpleNamespace++import pytest++import conftest+import message_helpers+++def lifecycle(monkeypatch, *, failing_id=None, wrong_tenant=False):+ state = {"unrelated": "tenant"}+ deleted = []+ finalizers = []++ def create(name, **kwargs):+ if name == "setup-failure":+ raise RuntimeError("creation failed")+ state[name] = "other" if wrong_tenant else "tenant"+ return SimpleNamespace(id=name, tenant_id=state[name])++ def delete(memory_id):+ deleted.append(memory_id)+ if memory_id == failing_id:+ raise RuntimeError("cleanup failed")+ del state[memory_id]++ rag = SimpleNamespace(create_memory=create, delete_memory=delete, get=lambda path: SimpleNamespace(json=lambda: {"code": 0 if path.split("/")[2] in state else 404}))+ monkeypatch.setattr(conftest, "RAGFlow", lambda *args: rag)+ settings = {"api_key": "key", "base_url": "unused", "tenant_id": "tenant"}+ client = unwrap(conftest.client)(settings, monkeypatch, SimpleNamespace(addfinalizer=finalizers.append))+ assert len(finalizers) == 1+ return client, finalizers[0], state, deleted+++def test_cleanup_only_owned_ids_after_partial_setup(monkeypatch):+ client, cleanup, state, deleted = lifecycle(monkeypatch)+ client.create_memory(name="first")+ client.create_memory(name="second")+ with pytest.raises(RuntimeError, match="creation failed"):+ client.create_memory(name="setup-failure")+ cleanup()+ assert deleted == ["second", "first"]+ assert state == {"unrelated": "tenant"}+++def test_cleanup_registered_before_ownership_assertion(monkeypatch):+ client, cleanup, state, deleted = lifecycle(monkeypatch, wrong_tenant=True)+ with pytest.raises(AssertionError, match="unexpected tenant"):+ client.create_memory(name="created")+ cleanup()+ assert deleted == ["created"]+ assert state == {"unrelated": "tenant"}+++def test_cleanup_continues_and_reports_errors(monkeypatch):+ client, cleanup, state, deleted = lifecycle(monkeypatch, failing_id="second")+ client.create_memory(name="first")+ client.create_memory(name="second")+ with pytest.raises(AssertionError, match="second: cleanup failed"):+ cleanup()+ assert deleted == ["second", "first"]+ assert state == {"unrelated": "tenant", "second": "tenant"}+++def test_cleanup_accepts_already_deleted_owned_id(monkeypatch):+ client, cleanup, state, deleted = lifecycle(monkeypatch)+ client.create_memory(name="first")+ client.delete_memory("first")+ cleanup()+ assert deleted == ["first"]+ assert state == {"unrelated": "tenant"}+++def test_polling_waits_for_condition(monkeypatch):+ results = iter([[], [{"message_id": 7}]])+ monkeypatch.setattr(message_helpers.time, "sleep", lambda _: None)+ assert message_helpers.wait_until(lambda: next(results), bool) == [{"message_id": 7}]+++def test_polling_has_a_deadline(monkeypatch):+ ticks = iter([0, 1])+ monkeypatch.setattr(message_helpers.time, "monotonic", lambda: next(ticks))+ with pytest.raises(AssertionError, match=r"last result: \[\]"):+ message_helpers.wait_until(lambda: [], bool, timeout=0.1)+++def test_polling_does_not_hide_api_errors():+ def fail():+ raise RuntimeError("model unavailable")++ with pytest.raises(RuntimeError, match="model unavailable"):+ message_helpers.wait_until(fail, bool)+++def test_unverified_integration_environment_fails_before_network(monkeypatch):+ monkeypatch.delenv("RAGFLOW_SDK_ISOLATED", raising=False)+ with pytest.raises(pytest.fail.Exception, match="verified disposable Go backend"):+ unwrap(conftest.integration_settings)()+++def test_nonempty_tenant_is_rejected_without_mutation(monkeypatch):+ def get(url, **kwargs):+ assert kwargs["timeout"] == 30+ return SimpleNamespace(+ raise_for_status=lambda: None,+ json=lambda: {+ "code": 0,+ "data": {"total_count": 1, "memory_list": ["unrelated"]},+ },+ )++ monkeypatch.setattr(conftest.requests, "get", get)+ with pytest.raises(AssertionError, match="tenant has accessible memories"):+ unwrap(conftest.isolated_tenant)({"api_key": "key", "base_url": "https://unused.invalid"})diff --git a/test/testcases/test_sdk_api/test_message_management/test_message_sdk_contract.py b/test/testcases/test_sdk_api/test_message_management/test_message_sdk_contract.pynew file mode 100644index 0000000000..be5faf8ffb--- /dev/null+++ b/test/testcases/test_sdk_api/test_message_management/test_message_sdk_contract.py@@ -0,0 +1,154 @@+#+# Copyright 2025 The InfiniFlow Authors. All Rights Reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+#+"""SDK wire contracts. These tests never require a Go server or model provider."""++import json+from urllib.parse import parse_qs, urlsplit++import pytest+import requests+from ragflow_sdk import Memory, RAGFlow+++def sdk():+ return RAGFlow("contract-key", "https://unused.invalid")+++def assert_request(calls, method, path, query=None, body=None):+ assert len(calls) == 1+ request = calls[0]+ url = urlsplit(request.url)+ assert (request.method, url.scheme, url.netloc, url.path) == (method, "https", "unused.invalid", f"/api/v1{path}")+ assert request.headers["Authorization"] == "Bearer contract-key"+ assert parse_qs(url.query, keep_blank_values=True) == (query or {})+ assert (json.loads(request.body) if request.body else None) == body++[email protected]("memory_ids", [["mem-1"], ["mem-1", "mem-2"]])[email protected]("user_id", [None, "external-user"])+def test_add_request_and_response(sdk, mock_api, memory_ids, user_id):+ calls = mock_api({"code": 0, "message": "All add to task.", "data": None})+ arguments = dict(memory_id=memory_ids, agent_id="agent", session_id="session", user_input="question", agent_response="answer")+ if user_id is not None:+ arguments["user_id"] = user_id+ assert sdk.add_message(**arguments) == "All add to task."+ assert_request(calls, "POST", "/messages", body={**arguments, "user_id": user_id or ""})++[email protected]("missing", ["memory_id", "agent_id", "session_id", "user_input", "agent_response"])+def test_add_requires_arguments(sdk, missing):+ arguments = dict(memory_id=["memory"], agent_id="agent", session_id="session", user_input="question", agent_response="answer")+ del arguments[missing]+ with pytest.raises(TypeError, match=missing):+ sdk.add_message(**arguments)+++ "filters,query",+ [+ ({}, {"page": ["1"], "page_size": ["50"]}),+ ({"agent_id": ["a1", "a2"], "keywords": "session-fragment", "page": 2, "page_size": 3}, {"agent_id": ["a1", "a2"], "keywords": ["session-fragment"], "page": ["2"], "page_size": ["3"]}),+ ],+)+def test_list_request_and_response(sdk, mock_api, filters, query):+ data = {"storage_type": "table", "messages": {"total_count": 1, "message_list": [{"message_id": 7, "extract": [], "task": {}}]}}+ calls = mock_api({"code": 0, "data": data})+ assert Memory(sdk, {"id": "memory"}).list_memory_messages(**filters) == data+ assert_request(calls, "GET", "/memories/memory", query=query)+++ "filters,query",+ [+ ({}, {"memory_id": ["m1", "m2"], "limit": ["10"]}),+ ({"agent_id": "agent", "session_id": "session", "limit": 2}, {"memory_id": ["m1", "m2"], "agent_id": ["agent"], "session_id": ["session"], "limit": ["2"]}),+ ],+)+def test_recent_request_and_response(sdk, mock_api, filters, query):+ data = [{"memory_id": "m1", "message_id": 7, "content": "stored conversation"}]+ calls = mock_api({"code": 0, "data": data})+ assert sdk.get_recent_messages(["m1", "m2"], **filters) == data+ assert_request(calls, "GET", "/messages", query=query)+++ "filters,extra",+ [+ ({}, {"similarity_threshold": ["0.2"], "keywords_similarity_weight": ["0.7"], "top_n": ["10"]}),+ (+ {"agent_id": "agent", "session_id": "session", "user_id": "user", "similarity_threshold": 0.1, "keywords_similarity_weight": 0.6, "top_n": 4},+ {"agent_id": ["agent"], "session_id": ["session"], "user_id": ["user"], "similarity_threshold": ["0.1"], "keywords_similarity_weight": ["0.6"], "top_n": ["4"]},+ ),+ ],+)+def test_search_request_and_response(sdk, mock_api, filters, extra):+ data = [{"memory_id": "m1", "message_id": 7, "content": "Coriander leaves and seeds"}]+ calls = mock_api({"code": 0, "data": data})+ assert sdk.search_message("coriander leaves?", ["m1", "m2"], **filters) == data+ assert_request(calls, "GET", "/messages/search", query={"query": ["coriander leaves?"], "memory_id": ["m1", "m2"], **extra})+++ "operation,method,path,body,data,expected",+ [+ ("content", "GET", "/messages/memory:7/content", None, {"content": "conversation", "content_embed": [0.25]}, {"content": "conversation", "content_embed": [0.25]}),+ ("forget", "DELETE", "/messages/memory:7", {}, None, True),+ ("false", "PUT", "/messages/memory:7", {"status": False}, None, True),+ ("true", "PUT", "/messages/memory:7", {"status": True}, None, True),+ ],+)+def test_composite_message_requests(sdk, mock_api, operation, method, path, body, data, expected):+ calls = mock_api({"code": 0, "data": data})+ assert invoke(sdk, operation) == expected+ assert_request(calls, method, path, body=body)+++def invoke(sdk, operation):+ memory = Memory(sdk, {"id": "memory"})+ if operation == "add":+ return sdk.add_message(["memory"], "agent", "session", "question", "answer", user_id="user")+ if operation == "list":+ return memory.list_memory_messages()+ if operation == "recent":+ return sdk.get_recent_messages(["memory"])+ if operation == "search":+ return sdk.search_message("query", ["memory"])+ if operation == "content":+ return memory.get_message_content(7)+ if operation == "forget":+ return memory.forget_message(7)+ return memory.update_message_status(7, operation == "true")++[email protected]("operation", ["add", "list", "recent", "search", "content", "forget", "false", "true"])[email protected]("code,status,message", [(401, 401, "Invalid access token"), (404, 200, "Message not found"), (500, 200, "message store unavailable")])+def test_error_propagation(sdk, mock_api, operation, code, status, message):+ calls = mock_api({"code": code, "message": message}, status=status)+ with pytest.raises(Exception) as error:+ invoke(sdk, operation)+ assert str(error.value) == message+ assert len(calls) == 1++[email protected]("operation", ["add", "list", "recent", "search", "content", "forget", "false", "true"])+def test_transport_failure_is_not_swallowed(sdk, monkeypatch, operation):+ def fail(*args, **kwargs):+ raise requests.Timeout("transport timed out")++ monkeypatch.setattr(requests.sessions.Session, "send", fail)+ with pytest.raises(requests.Timeout, match="transport timed out"):+ invoke(sdk, operation)diff --git a/test/testcases/test_sdk_api/test_message_management/test_search_message.py b/test/testcases/test_sdk_api/test_message_management/test_search_message.pyindex 2ce08e54d0..2263fb5746 100644--- a/test/testcases/test_sdk_api/test_message_management/test_search_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_search_message.py@@ -14,62 +14,184 @@# limitations under the License.#import pytest-from ragflow_sdk import RAGFlow, Memory-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE+from ragflow_sdk import RAGFlow+from message_helpers import assert_identity, wait_until++def assert_matches(messages, populated, indices):+ """Check exact identities and stored conversation content without ranking ties."""+ assert isinstance(messages, list), messages+ expected = {str(populated["rows"][i]["message_id"]): populated["payloads"][i] for i in indices}+ assert len(messages) == len(expected), messages+ assert {str(row["message_id"]) for row in messages} == set(expected), messages+ for row in messages:+ payload = expected[str(row["message_id"])]+ assert_identity(row, payload, populated["memory"].id)+ assert row["status"] is True, row+ assert row["content"] == f"User Input: {payload['user_input']}\nAgent Response: {payload['agent_response']}", row++class TestAuthorization:- @pytest.mark.p2+ @pytest.mark.parametrize("invalid_auth", [None, "invalid_key_123"])+ def test_auth_invalid(self, integration_settings, invalid_auth):+ client = RAGFlow(invalid_auth, integration_settings["base_url"])+ with pytest.raises(Exception, match="^Invalid access token$"):+ client.search_message("coriander", ["missing-memory"])+++class TestSearchMessage:+ def test_query(self, client, populated_memory):+ # Disjoint topics make query-ignoring retrieval fail without ordering tied matches.+ for query, relevant_indices in [("coriander cilantro leaves seeds", [0, 1]), ("Mount Everest Himalayas mountain", [4])]:+ relevant_ids = {str(populated_memory["rows"][i]["message_id"]) for i in relevant_indices}+ messages = wait_until(+ lambda: client.search_message(query, [populated_memory["memory"].id], top_n=1),+ lambda rows: len(rows) == 1 and str(rows[0]["message_id"]) in relevant_ids,+ )+ indices = [i for i in relevant_indices if str(populated_memory["rows"][i]["message_id"]) == str(messages[0]["message_id"])]+ assert_matches(messages, populated_memory, indices)++ def test_query_with_agent_filter(self, client, populated_memory):+ messages = wait_until(+ lambda: client.search_message(+ "coriander cilantro leaves",+ [populated_memory["memory"].id],+ agent_id=populated_memory["payloads"][0]["agent_id"],+ top_n=3,+ ),+ lambda rows: str(populated_memory["rows"][0]["message_id"]) in {str(row["message_id"]) for row in rows},+ )+ indices = [i for i in (0, 2, 4) if str(populated_memory["rows"][i]["message_id"]) in {str(row["message_id"]) for row in messages}]+ assert_matches(messages, populated_memory, indices)++ def test_query_with_not_default_params(self, client, populated_memory):+ messages = wait_until(+ lambda: client.search_message(+ "coriander cilantro leaves seeds",+ [populated_memory["memory"].id],+ similarity_threshold=0.1,+ keywords_similarity_weight=0.6,+ top_n=4,+ ),+ lambda rows: str(populated_memory["rows"][0]["message_id"]) in {str(row["message_id"]) for row in rows},+ )+ assert len(messages) <= 4+ indices = [i for i, row in enumerate(populated_memory["rows"]) if str(row["message_id"]) in {str(message["message_id"]) for message in messages}]+ assert_matches(messages, populated_memory, indices)+@pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],+ "field,index,expected",+ [("agent_id", 0, [0, 2, 4]), ("agent_id", 1, [1, 3]), ("session_id", 0, [0]), ("session_id", 4, [4]), ("user_id", 0, [0, 2, 4]), ("user_id", 1, [1, 3])],)- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- client.search_message("", ["empty_memory_id"])- assert str(exception_info.value) == expected_message, str(exception_info.value)+ def test_exact_filters(self, client, populated_memory, field, index, expected):+ # Go's TestSearchMessageFiltersAccessibleMemoryAndDefaultsStatus explicitly supports blank queries.+ messages = wait_until(+ lambda: client.search_message(+ "",+ [populated_memory["memory"].id],+ **{field: populated_memory["payloads"][index][field]},+ ),+ lambda rows: len(rows) == len(expected),+ )+ assert_matches(messages, populated_memory, expected)+ def test_combined_filters(self, client, populated_memory):+ payload = populated_memory["payloads"][1]+ filters = {field: payload[field] for field in ("agent_id", "session_id", "user_id")}+ messages = wait_until(+ lambda: client.search_message("", [populated_memory["memory"].id], **filters),+ lambda rows: len(rows) == 1,+ )+ assert_matches(messages, populated_memory, [1])+ filters["agent_id"] = populated_memory["payloads"][0]["agent_id"]+ assert client.search_message("", [populated_memory["memory"].id], **filters) == [][email protected]("add_memory_with_multiple_type_message_func")-class TestSearchMessage:- @pytest.mark.p1- def test_query(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert list_res["messages"]["total_count"] > 0-- query = "Coriander is a versatile herb with two main edible parts. What's its name can refer to?"- res = client.search_message(**{"memory_id": [memory_id], "query": query})- assert len(res) > 0-- @pytest.mark.p2- def test_query_with_agent_filter(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert list_res["messages"]["total_count"] > 0-- agent_id = self.agent_id- query = "Coriander is a versatile herb with two main edible parts. What's its name can refer to?"- res = client.search_message(**{"memory_id": [memory_id], "query": query, "agent_id": agent_id})- assert len(res) > 0- for message in res:- assert message["agent_id"] == agent_id, message-- @pytest.mark.p2- def test_query_with_not_default_params(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert list_res["messages"]["total_count"] > 0-- query = "Coriander is a versatile herb with two main edible parts. What's its name can refer to?"- params = {"similarity_threshold": 0.1, "keywords_similarity_weight": 0.6, "top_n": 4}- res = client.search_message(**{"memory_id": [memory_id], "query": query, **params})- assert len(res) > 0- assert len(res) <= params["top_n"]+ @pytest.mark.parametrize("field", ["agent_id", "session_id", "user_id"])+ def test_unknown_filter(self, client, populated_memory, field):+ assert client.search_message("", [populated_memory["memory"].id], **{field: "missing-filter"}) == []++ @pytest.mark.parametrize("top_n", [1, 3, 5, 100])+ def test_top_n(self, client, populated_memory, top_n):+ messages = wait_until(+ lambda: client.search_message("", [populated_memory["memory"].id], top_n=top_n),+ lambda rows: len(rows) == min(top_n, 5),+ )+ assert len({str(row["message_id"]) for row in messages}) == min(top_n, 5), messages+ indices = [i for i, row in enumerate(populated_memory["rows"]) if str(row["message_id"]) in {str(message["message_id"]) for message in messages}]+ assert_matches(messages, populated_memory, indices)++ @pytest.mark.parametrize("top_n", [0, -1, 101, "invalid", 1.5])+ def test_invalid_top_n(self, client, top_n):+ with pytest.raises(Exception, match="^top_n must be between 1 and 100$"):+ client.search_message("", ["missing-memory"], top_n=top_n)++ @pytest.mark.parametrize("field", ["similarity_threshold", "keywords_similarity_weight"])+ @pytest.mark.parametrize("value", [0.0, 1.0])+ def test_similarity_parameter_bounds(self, client, populated_memory, field, value):+ messages = wait_until(+ lambda: client.search_message("", [populated_memory["memory"].id], **{field: value}),+ lambda rows: len(rows) == 5,+ )+ assert_matches(messages, populated_memory, range(5))++ @pytest.mark.skip(+ reason="Go MemoryHandler.SearchMessage parses float parameters without checking errors or documented [0,1] ranges (internal/handler/memory.go); invalid values reach search instead of returning argument errors"+ )+ @pytest.mark.parametrize("field", ["similarity_threshold", "keywords_similarity_weight"])+ @pytest.mark.parametrize("value", [-0.1, 1.1, "invalid", "nan", "inf"])+ def test_invalid_similarity_parameters(self, client, populated_memory, field, value):+ response = client.get(+ "/messages/search",+ {+ "query": "",+ "memory_id": [populated_memory["memory"].id],+ field: value,+ },+ ).json()+ assert response["code"] == 101, response+ with pytest.raises(Exception):+ client.search_message("", [populated_memory["memory"].id], **{field: value})++ def test_inactive_and_forgotten_messages_are_excluded(self, client, populated_memory):+ memory = populated_memory["memory"]+ messages = wait_until(lambda: client.search_message("", [memory.id]), lambda rows: len(rows) == 5)+ assert_matches(messages, populated_memory, range(5))+ assert memory.update_message_status(populated_memory["rows"][0]["message_id"], False) is True+ messages = wait_until(lambda: client.search_message("", [memory.id]), lambda rows: len(rows) == 4)+ assert_matches(messages, populated_memory, [1, 2, 3, 4])+ assert memory.forget_message(populated_memory["rows"][1]["message_id"]) is True+ messages = wait_until(lambda: client.search_message("", [memory.id]), lambda rows: len(rows) == 3)+ assert_matches(messages, populated_memory, [2, 3, 4])++ def test_memory_isolation_and_multiple_memories(self, client, populated_memory, memory_factory):+ other = memory_factory()+ assert client.search_message("", [other.id]) == []+ payload = dict(populated_memory["payloads"][0], memory_id=[other.id], session_id=f"{other.id}-session")+ assert client.add_message(**payload) == "All add to task."+ result = wait_until(other.list_memory_messages, lambda value: value["messages"]["total_count"] == 1)+ other_row = result["messages"]["message_list"][0]+ assert_identity(other_row, payload, other.id)+ messages = wait_until(lambda: client.search_message("", [other.id]), lambda rows: len(rows) == 1)+ assert_identity(messages[0], payload, other.id)+ assert str(messages[0]["message_id"]) == str(other_row["message_id"]), messages+ expected_content = f"User Input: {payload['user_input']}\nAgent Response: {payload['agent_response']}"+ assert messages[0]["content"] == expected_content, messages+ messages = wait_until(+ lambda: client.search_message("", [populated_memory["memory"].id, other.id]),+ lambda rows: len(rows) == 6,+ )+ assert_matches([row for row in messages if row["memory_id"] == populated_memory["memory"].id], populated_memory, range(5))+ others = [row for row in messages if row["memory_id"] == other.id]+ assert len(others) == 1, messages+ assert_identity(others[0], payload, other.id)+ assert str(others[0]["message_id"]) == str(other_row["message_id"]), others+ assert others[0]["content"] == expected_content, others+ assert_matches(client.search_message("", [populated_memory["memory"].id]), populated_memory, range(5))++ @pytest.mark.parametrize("memory_ids", [[], [""], ["missing-memory"], ["../invalid-memory"]])+ def test_empty_or_inaccessible_memories(self, client, memory_ids):+ # Search intentionally returns no information about inaccessible memory IDs.+ assert client.search_message("coriander", memory_ids) == []diff --git a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.pyindex 6ce49bc45e..2850540f63 100644--- a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py+++ b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py@@ -13,60 +13,82 @@# See the License for the specific language governing permissions and# limitations under the License.#-import random-import pytest-from ragflow_sdk import RAGFlow, Memory-from configs import INVALID_API_TOKEN, HOST_ADDRESS, SDK_UNAUTHORIZED_ERROR_MESSAGE+from ragflow_sdk import Memory, RAGFlow++from message_helpers import assert_content, wait_until++pytestmark = pytest.mark.integrationclass TestAuthorization:- @pytest.mark.p2- @pytest.mark.parametrize(- "invalid_auth, expected_message",- [- (None, SDK_UNAUTHORIZED_ERROR_MESSAGE),- (INVALID_API_TOKEN, SDK_UNAUTHORIZED_ERROR_MESSAGE),- ],- )- def test_auth_invalid(self, invalid_auth, expected_message):- client = RAGFlow(invalid_auth, HOST_ADDRESS)- with pytest.raises(Exception) as exception_info:- memory = Memory(client, {"id": "empty_memory_id"})- memory.update_message_status(0, False)- assert str(exception_info.value) == expected_message, str(exception_info.value)+ @pytest.mark.parametrize("invalid_auth", [None, "invalid-token"])+ def test_auth_invalid(self, populated_memory, integration_settings, invalid_auth):+ memory = populated_memory["memory"]+ rag = RAGFlow(invalid_auth, integration_settings["base_url"])+ row = populated_memory["rows"][0]+ with pytest.raises(Exception, match="^Invalid access token$"):+ Memory(rag, {"id": memory.id}).update_message_status(row["message_id"], False)+ content = memory.get_message_content(row["message_id"])+ assert content["status"] is True, content+ assert_content(content, populated_memory["payloads"][0], memory.id)[email protected]("add_memory_with_5_raw_message_func")class TestUpdateMessageStatus:- @pytest.mark.p3- def test_update_to_false(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert len(list_res["messages"]["message_list"]) > 0, str(list_res)+ def test_update_to_false(self, populated_memory):+ memory = populated_memory["memory"]+ row = populated_memory["rows"][0]+ assert memory.update_message_status(row["message_id"], False) is True+ content = wait_until(+ lambda: memory.get_message_content(row["message_id"]),+ lambda content: content.get("status") is False,+ )+ assert_content(content, populated_memory["payloads"][0], memory.id)+ assert memory.update_message_status(row["message_id"], False) is True+ assert memory.get_message_content(row["message_id"])["status"] is False+ for survivor in populated_memory["rows"][1:]:+ assert memory.get_message_content(survivor["message_id"])["status"] is True++ def test_update_to_true(self, populated_memory):+ memory = populated_memory["memory"]+ row = populated_memory["rows"][0]+ assert memory.update_message_status(row["message_id"], False) is True+ wait_until(+ lambda: memory.get_message_content(row["message_id"]),+ lambda content: content.get("status") is False,+ )+ assert memory.update_message_status(row["message_id"], True) is True+ content = wait_until(+ lambda: memory.get_message_content(row["message_id"]),+ lambda content: content.get("status") is True,+ )+ assert_content(content, populated_memory["payloads"][0], memory.id)+ assert memory.update_message_status(row["message_id"], True) is True+ assert memory.get_message_content(row["message_id"])["status"] is True++ @pytest.mark.parametrize("status", [None, "false", "true", 0, 1, [], {}])+ def test_status_must_be_boolean(self, populated_memory, status):+ memory = populated_memory["memory"]+ row = populated_memory["rows"][0]+ with pytest.raises(Exception, match=r"^Status must be a boolean\.$"):+ memory.update_message_status(row["message_id"], status)+ content = memory.get_message_content(row["message_id"])+ assert content["status"] is True, content+ assert_content(content, populated_memory["payloads"][0], memory.id)- message = random.choice(list_res["messages"]["message_list"])- res = memory.update_message_status(message["message_id"], False)- assert res, str(res)+ @pytest.mark.parametrize("message_id", [-1, "bad", "", "1:2"])+ def test_invalid_message_id(self, populated_memory, message_id):+ with pytest.raises(Exception, match="message_id|formatted as memory_id:message_id"):+ populated_memory["memory"].update_message_status(message_id, False)- updated_message_res = memory.get_message_content(message["message_id"])- assert not updated_message_res["status"], str(updated_message_res)+ def test_nonexistent_message(self, populated_memory, doc_engine):+ if doc_engine == "infinity":+ pytest.skip("Infinity UpdateChunks discards the update result and succeeds for a missing message (internal/engine/infinity/chunk.go:743-758); status update must report missing Message.")+ if doc_engine in ("oceanbase", "seekdb"):+ pytest.skip("OceanBase UpdateChunks ignores SQL affected rows and succeeds for a missing message (internal/engine/oceanbase/crud.go:292-294); status update must report missing Message.")+ with pytest.raises(Exception, match="Message .*not found"):+ populated_memory["memory"].update_message_status(9223372036854775807, False)- @pytest.mark.p3- def test_update_to_true(self, client):- memory_id = self.memory_id- memory = Memory(client, {"id": memory_id})- list_res = memory.list_memory_messages()- assert len(list_res["messages"]["message_list"]) > 0, str(list_res)- # set 1 random message to false first- message = random.choice(list_res["messages"]["message_list"])- set_to_false_res = memory.update_message_status(message["message_id"], False)- assert set_to_false_res, str(set_to_false_res)- updated_message_res = memory.get_message_content(message["message_id"])- assert not updated_message_res["status"], updated_message_res- # set to true- set_to_true_res = memory.update_message_status(message["message_id"], True)- assert set_to_true_res, str(set_to_true_res)- res = memory.get_message_content(message["message_id"])- assert res["status"], res+ def test_nonexistent_memory(self, client):+ with pytest.raises(Exception, match="^Resource not found$"):+ Memory(client, {"id": "missing-message-test-memory"}).update_message_status(0, False)