test(sharing): add unit and e2e tests for update_entity_metadata

visahak · visahak · commit 4876121f7840 · 2026-04-21T16:34:45.000-04:00
Unit tests (postgres + milvus):
- Verifies native metadata merge SQL / upsert path
- Missing entity raises EvolveException
- Non-numeric ID rejected early

E2E tests (filesystem + milvus, via --run-e2e):
- publish_entity / unpublish_entity full MCP flow
- create_entity with visibility=public
- Content preserved after metadata patch
- Extracted shared mcp fixture into tests/e2e/conftest.py
  and extended params to include milvus
diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py
@@ -0,0 +1,79 @@
+import os
+import uuid
+import pytest
+from altk_evolve.config.milvus import milvus_client_settings
+
+
+@pytest.fixture(params=["filesystem", "milvus"])
+def mcp(request, tmp_path):
+    backend_type = request.param
+    os.environ["EVOLVE_NAMESPACE_ID"] = "test"
+    os.environ["EVOLVE_BACKEND"] = backend_type
+    os.environ["EVOLVE_SQLITE_PATH"] = str(tmp_path / f"test_{backend_type}.sqlite.db")
+
+    milvus_db_file = None
+    original_milvus_uri = None
+
+    if backend_type == "milvus":
+        original_milvus_uri = milvus_client_settings.uri
+        _env_uri = os.getenv("EVOLVE_URI", "")
+        if _env_uri.startswith("http"):
+            milvus_client_settings.uri = _env_uri
+        else:
+            milvus_db_file = str(tmp_path / f"test_{uuid.uuid4().hex[:8]}.db")
+            milvus_client_settings.uri = milvus_db_file
+    elif backend_type == "filesystem":
+        os.environ["EVOLVE_DATA_DIR"] = str(tmp_path)
+
+    from altk_evolve.frontend.client.evolve_client import EvolveClient
+    from altk_evolve.config.evolve import evolve_config
+
+    evolve_config.__init__()
+
+    import altk_evolve.frontend.mcp.mcp_server as mcp_server_module
+
+    mcp_server_module._client = None
+    mcp_server_module._namespace_initialized = False
+
+    evolve_client = EvolveClient()
+    try:
+        evolve_client.create_namespace("test")
+    except Exception:
+        pass
+
+    yield mcp_server_module.mcp
+
+    try:
+        evolve_client.backend.close()
+    except Exception:
+        pass
+
+    if backend_type == "milvus":
+        try:
+            from pymilvus import connections
+            for alias, _ in connections.list_connections():
+                try:
+                    connections.disconnect(alias)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+        try:
+            from milvus_lite.server_manager import server_manager_instance
+            server_manager_instance.release_all()
+        except Exception:
+            pass
+
+        if original_milvus_uri:
+            milvus_client_settings.uri = original_milvus_uri
+
+        for path in [milvus_db_file, f"{milvus_db_file}.lock"] if milvus_db_file else []:
+            if path and os.path.exists(path):
+                try:
+                    os.remove(path)
+                except Exception:
+                    pass
+
+    mcp_server_module._client = None
+    mcp_server_module._namespace_initialized = False
diff --git a/tests/e2e/test_mcp.py b/tests/e2e/test_mcp.py
@@ -1,115 +1,13 @@
-import os
 import pytest
 import json
 from fastmcp.client import Client
 from pathlib import Path
 from dotenv import load_dotenv
 
-import uuid
-from altk_evolve.config.milvus import milvus_client_settings
-
 __data__ = Path(__file__).parent.parent / "data"
 load_dotenv()
 
 
-@pytest.fixture(params=["filesystem"])
-def mcp(request, tmp_path):
-    backend_type = request.param
-    os.environ["EVOLVE_NAMESPACE_ID"] = "test"
-    os.environ["EVOLVE_BACKEND"] = backend_type
-
-    # Common SQLite setup
-    os.environ["EVOLVE_SQLITE_PATH"] = str(tmp_path / f"test_{backend_type}.sqlite.db")
-
-    # Backend-specific setup
-    milvus_db_file = None
-    original_milvus_uri = None
-
-    if backend_type == "milvus":
-        original_milvus_uri = milvus_client_settings.uri
-        _env_uri = os.getenv("EVOLVE_URI", "")
-        if _env_uri.startswith("http"):
-            # Running against a real Milvus server (e.g. in CI via Docker sidecar).
-            # Use the server URI directly; skip milvus-lite local file creation.
-            milvus_db_file = None
-            milvus_client_settings.uri = _env_uri
-        else:
-            # Local dev: use a unique milvus-lite DB file per test run.
-            milvus_db_file = str(tmp_path / f"test_{uuid.uuid4().hex[:8]}.db")
-            milvus_client_settings.uri = milvus_db_file
-            # Note: currently milvus-lite creates a file, not a dir for the uri
-    elif backend_type == "filesystem":
-        os.environ["EVOLVE_DATA_DIR"] = str(tmp_path)
-
-    from altk_evolve.frontend.client.evolve_client import EvolveClient
-    from altk_evolve.config.evolve import evolve_config
-
-    # Reset loaded settings to pick up new env vars
-    evolve_config.__init__()
-
-    # Reset the MCP server client
-    import altk_evolve.frontend.mcp.mcp_server as mcp_server_module
-
-    mcp_server_module._client = None
-    mcp_server_module._namespace_initialized = False
-
-    evolve_client = EvolveClient()
-    # Create the test namespace
-    try:
-        evolve_client.create_namespace("test")
-    except Exception:
-        pass
-
-    yield mcp_server_module.mcp
-
-    # Cleanup
-    try:
-        evolve_client.backend.close()
-    except Exception:
-        pass
-
-    if backend_type == "milvus":
-        # Disconnect all pymilvus connections
-        try:
-            from pymilvus import connections
-
-            for alias, _ in connections.list_connections():
-                try:
-                    connections.disconnect(alias)
-                except Exception:
-                    pass
-        except Exception:
-            pass
-
-        # Release all Milvus Lite servers
-        try:
-            from milvus_lite.server_manager import server_manager_instance
-
-            server_manager_instance.release_all()
-        except Exception:
-            pass
-
-        # Restore original URI
-        if original_milvus_uri:
-            milvus_client_settings.uri = original_milvus_uri
-
-        # Clean up temp DB files
-        if milvus_db_file and os.path.exists(milvus_db_file):
-            try:
-                os.remove(milvus_db_file)
-            except Exception:
-                pass
-        if milvus_db_file and os.path.exists(f"{milvus_db_file}.lock"):
-            try:
-                os.remove(f"{milvus_db_file}.lock")
-            except Exception:
-                pass
-
-    # Reset the MCP server client
-    mcp_server_module._client = None
-    mcp_server_module._namespace_initialized = False
-
-
 @pytest.mark.e2e
 async def test_save_trajectory_and_retrieve_guidelines(mcp):
     async with Client(transport=mcp) as evolve_mcp:
diff --git a/tests/e2e/test_sharing.py b/tests/e2e/test_sharing.py
@@ -0,0 +1,102 @@
+"""
+E2E tests for Phase 1B entity sharing: publish, unpublish, cross-namespace public recall.
+
+Exercises the full MCP tool stack against real backends (filesystem + milvus-lite).
+The `mcp` fixture is parameterized in conftest.py — every test here runs twice.
+"""
+
+import json
+import pytest
+from fastmcp.client import Client
+
+
+@pytest.mark.e2e
+async def test_publish_entity_makes_it_retrievable_publicly(mcp):
+    """publish_entity sets visibility=public; get_entities(include_public=True) finds it."""
+    async with Client(transport=mcp) as client:
+        # Create a private entity first
+        create_resp = await client.call_tool_mcp(
+            "create_entity",
+            {"content": "always use type hints", "entity_type": "guideline", "enable_conflict_resolution": False},
+        )
+        entity = json.loads(create_resp.content[0].text)
+        entity_id = entity["id"]
+
+        # Publish it
+        pub_resp = await client.call_tool_mcp(
+            "publish_entity", {"entity_id": entity_id, "user_id": "alice"}
+        )
+        published = json.loads(pub_resp.content[0].text)
+        assert published["metadata"]["visibility"] == "public"
+        assert published["metadata"]["owner_id"] == "alice"
+        assert "published_at" in published["metadata"]
+
+        # Should appear in a public search
+        get_resp = await client.call_tool_mcp(
+            "get_entities",
+            {"task": "type hints python", "entity_type": "guideline", "include_public": True},
+        )
+        output = get_resp.content[0].text
+        assert "type hints" in output
+
+
+@pytest.mark.e2e
+async def test_unpublish_entity_removes_it_from_public_results(mcp):
+    """unpublish_entity reverts visibility to private."""
+    async with Client(transport=mcp) as client:
+        create_resp = await client.call_tool_mcp(
+            "create_entity",
+            {"content": "prefer list comprehensions", "entity_type": "guideline", "enable_conflict_resolution": False},
+        )
+        entity_id = json.loads(create_resp.content[0].text)["id"]
+
+        await client.call_tool_mcp("publish_entity", {"entity_id": entity_id})
+
+        unpub_resp = await client.call_tool_mcp("unpublish_entity", {"entity_id": entity_id})
+        unpublished = json.loads(unpub_resp.content[0].text)
+        assert unpublished["metadata"]["visibility"] == "private"
+
+
+@pytest.mark.e2e
+async def test_publish_entity_not_found_returns_error(mcp):
+    """publish_entity on a missing entity returns an error, not a 500."""
+    async with Client(transport=mcp) as client:
+        resp = await client.call_tool_mcp("publish_entity", {"entity_id": "99999"})
+        result = json.loads(resp.content[0].text)
+        assert "error" in result
+
+
+@pytest.mark.e2e
+async def test_create_entity_with_visibility_public(mcp):
+    """create_entity(visibility=public) stores the visibility flag immediately."""
+    async with Client(transport=mcp) as client:
+        resp = await client.call_tool_mcp(
+            "create_entity",
+            {
+                "content": "document all public functions",
+                "entity_type": "guideline",
+                "visibility": "public",
+                "owner_id": "bob",
+                "enable_conflict_resolution": False,
+            },
+        )
+        result = json.loads(resp.content[0].text)
+        assert result["metadata"]["visibility"] == "public"
+        assert result["metadata"]["owner_id"] == "bob"
+
+
+@pytest.mark.e2e
+async def test_patch_metadata_preserves_content(mcp):
+    """publish_entity must not alter entity content — only metadata."""
+    original_content = "avoid mutable default arguments"
+    async with Client(transport=mcp) as client:
+        create_resp = await client.call_tool_mcp(
+            "create_entity",
+            {"content": original_content, "entity_type": "guideline", "enable_conflict_resolution": False},
+        )
+        entity_id = json.loads(create_resp.content[0].text)["id"]
+
+        pub_resp = await client.call_tool_mcp("publish_entity", {"entity_id": entity_id, "user_id": "carol"})
+        published = json.loads(pub_resp.content[0].text)
+
+        assert published["content"] == original_content
diff --git a/tests/unit/test_milvus_backend.py b/tests/unit/test_milvus_backend.py
@@ -409,6 +409,72 @@ def test_delete_entity_nonexistent_namespace(milvus_backend: MilvusEntityBackend
         milvus_backend.delete_entity_by_id(namespace_id="nonexistent_namespace", entity_id="12345")
 
 
+# ── update_entity_metadata ────────────────────────────────────────────────────
+
+
+@pytest.mark.unit
+def test_update_entity_metadata_merges_and_returns(milvus_backend: MilvusEntityBackend, monkeypatch):
+    """Fetches via milvus.query, merges patch, upserts with partial_update, returns updated entity."""
+    now_ts = int(datetime.datetime.now(datetime.UTC).timestamp())
+    raw_entity = {
+        "id": 42,
+        "type": "guideline",
+        "content": "be concise",
+        "created_at": now_ts,
+        "metadata": {"creation_mode": "manual"},
+    }
+
+    query = Mock(return_value=[raw_entity])
+    upsert = Mock(return_value={"ids": [42]})
+    flush = Mock()
+    load = Mock()
+
+    monkeypatch.setattr(milvus_backend.milvus, "has_collection", always_has_collection)
+    monkeypatch.setattr(milvus_backend.milvus, "query", query)
+    monkeypatch.setattr(milvus_backend.milvus, "upsert", upsert)
+    monkeypatch.setattr(milvus_backend.milvus, "flush", flush)
+    monkeypatch.setattr(milvus_backend.milvus, "load_collection", load)
+    monkeypatch.setattr(milvus_backend.embedding_model, "encode", arbitrary_embedding)
+
+    result = milvus_backend.update_entity_metadata(
+        "test_namespace", "42", {"visibility": "public", "owner_id": "alice"}
+    )
+
+    # query must use direct id filter, not search_entities fan-out
+    query.assert_called_once_with(
+        collection_name="test_namespace",
+        filter="id == 42",
+        output_fields=["id", "type", "content", "created_at", "metadata"],
+        limit=1,
+    )
+
+    # upsert must carry merged metadata
+    upserted_data = upsert.call_args[1]["data"]
+    assert upserted_data["metadata"]["creation_mode"] == "manual"
+    assert upserted_data["metadata"]["visibility"] == "public"
+    assert upserted_data["metadata"]["owner_id"] == "alice"
+
+    assert result.metadata["visibility"] == "public"
+    assert result.metadata["creation_mode"] == "manual"
+
+
+@pytest.mark.unit
+def test_update_entity_metadata_raises_for_missing_entity(milvus_backend: MilvusEntityBackend, monkeypatch):
+    """Raises EvolveException when milvus.query returns no results."""
+    monkeypatch.setattr(milvus_backend.milvus, "has_collection", always_has_collection)
+    monkeypatch.setattr(milvus_backend.milvus, "query", Mock(return_value=[]))
+
+    with pytest.raises(EvolveException, match="not found"):
+        milvus_backend.update_entity_metadata("test_namespace", "99", {"visibility": "public"})
+
+
+@pytest.mark.unit
+def test_update_entity_metadata_rejects_non_numeric_id(milvus_backend: MilvusEntityBackend):
+    """Raises EvolveException immediately for non-numeric entity IDs."""
+    with pytest.raises(EvolveException, match="must be numeric"):
+        milvus_backend.update_entity_metadata("test_namespace", "not-an-id", {"visibility": "public"})
+
+
 @pytest.mark.unit
 def test_parse_milvus_entity_accepts_epoch_zero_created_at():
     parsed = parse_milvus_entity(
diff --git a/tests/unit/test_postgres_backend.py b/tests/unit/test_postgres_backend.py
