sync update from LAN repo (source dhk-1 @ fc974e93)

This commit is contained in:
gozeros committed 2026-11-17 11:28:44 +08:00
1 parent a1fa13a238
commit e2fea6a801
432 files changed
+68707 -2270

No files matched your search

@@ -0,0 +1,94 @@
"""GoView image uploads and offline map tiles."""
from __future__ import annotations
from types import SimpleNamespace
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.gateway import goview_http
from app.gateway.auth_middleware import _is_goview_public_read
from app.gateway.routers import goview_assets, goview_map_tiles, goview_projects
from app.gateway.routers.goview_map_tiles import TilePathRejected, resolve_tile_file
from deerflow.persistence.goview import MemoryGoviewProjectStore
_PNG = b"\x89PNG\r\n\x1a\n" + b"\x00" * 32
def _client(monkeypatch) -> TestClient:
async def load_user(request):
return SimpleNamespace(id=request.headers.get("X-User-Id", "user-a"), system_role="user")
monkeypatch.setattr(goview_http, "load_user", load_user)
app = FastAPI()
app.include_router(goview_projects.router)
app.include_router(goview_assets.router)
app.include_router(goview_map_tiles.router)
app.state.goview_project_store = MemoryGoviewProjectStore()
return TestClient(app)
def test_asset_and_tile_reads_are_public() -> None:
assert _is_goview_public_read("GET", "/api/goview/assets/" + "a" * 32 + ".png")
assert _is_goview_public_read("GET", "/api/goview/map-tiles/default/3/1/2.png")
assert not _is_goview_public_read("GET", "/api/goview/assets/../secret.png")
assert not _is_goview_public_read("GET", "/api/goview/map-tiles/default/1/0/0.png/../../etc/passwd")
assert not _is_goview_public_read("POST", "/api/goview/project/upload")
def test_upload_rejects_non_image_oversize_and_traversal(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("DEER_FLOW_HOME", str(tmp_path))
client = _client(monkeypatch)
rejected = client.post(
"/api/goview/project/upload",
files={"object": ("note.png", b"not-an-image", "image/png")},
)
assert rejected.status_code == 422
huge = _PNG + b"0" * (10 * 1024 * 1024)
oversized = client.post(
"/api/goview/project/upload",
files={"object": ("big.png", huge, "image/png")},
)
assert oversized.status_code == 422
traversal = client.post(
"/api/goview/project/upload",
files={"object": ("../../outside.png", _PNG, "image/png")},
)
assert traversal.status_code == 422
assert not (tmp_path / "outside.png").exists()
assert list(tmp_path.rglob("outside.png")) == []
accepted = client.post(
"/api/goview/project/upload",
files={"object": ("cover.png", _PNG, "image/png")},
)
assert accepted.status_code == 200
body = accepted.json()["data"]
assert body["fileurl"] == f"/api/goview/assets/{body['fileName']}"
assert ".." not in body["fileName"]
loaded = client.get(body["fileurl"])
assert loaded.status_code == 200
assert loaded.content == _PNG
stored = list((tmp_path / "goview-assets").iterdir())
assert len(stored) == 1
assert stored[0].name == body["fileName"]
def test_tile_route_rejects_bad_style_zoom_and_serves_a_mounted_file(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("DEERFLOW_GOVIEW_TILE_ROOT", str(tmp_path))
tile = tmp_path / "default" / "0" / "0"
tile.mkdir(parents=True)
(tile / "0.png").write_bytes(_PNG)
client = _client(monkeypatch)
ok = client.get("/api/goview/map-tiles/default/0/0/0.png")
assert ok.status_code == 200
assert ok.content == _PNG
assert client.get("/api/goview/map-tiles/BadStyle/0/0/0.png").status_code == 400
assert client.get("/api/goview/map-tiles/default/23/0/0.png").status_code == 400
assert client.get("/api/goview/map-tiles/default/0/1/0.png").status_code == 400
assert client.get("/api/goview/map-tiles/missing/0/0/0.png").status_code == 404
with pytest.raises(TilePathRejected):
resolve_tile_file("..", 0, 0, 0)
with pytest.raises(TilePathRejected):
resolve_tile_file("default/../../secrets", 0, 0, 0)
@@ -0,0 +1,306 @@
"""GoView project ownership, publish, and large canvas JSON."""
from __future__ import annotations
import json
from datetime import UTC, datetime
from types import SimpleNamespace
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from sqlalchemy import create_engine, event, inspect
from sqlalchemy.dialects import mysql
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from sqlalchemy.schema import CreateTable
from app.gateway import goview_http
from app.gateway.auth_middleware import _is_goview_public_read
from app.gateway.routers import goview_assets, goview_projects
from deerflow.persistence.base import Base
from deerflow.persistence.goview import (
GoviewProjectContentRow,
GoviewProjectRow,
GoviewTemplateRow,
make_goview_project_store,
)
from deerflow.persistence.goview.project_store import MemoryGoviewProjectStore
_TABLES = [GoviewProjectRow.__table__, GoviewProjectContentRow.__table__, GoviewTemplateRow.__table__]
def _canvas(marker: object) -> str:
return json.dumps(
{
"editCanvasConfig": {"projectName": "画布", "width": 1920, "height": 1080},
"componentList": [{"id": "card", "marker": marker}],
"requestGlobalConfig": {},
},
ensure_ascii=False,
)
def _client(monkeypatch, store) -> TestClient:
async def load_user(request):
uid = request.headers.get("X-User-Id", "user-a")
if uid == "anonymous":
return None
return SimpleNamespace(id=uid, system_role=request.headers.get("X-User-Role", "user"))
monkeypatch.setattr(goview_http, "load_user", load_user)
app = FastAPI()
app.include_router(goview_projects.router)
app.include_router(goview_projects.system_router)
app.include_router(goview_assets.router)
app.state.goview_project_store = store
return TestClient(app)
def test_models_are_registered_and_old_dashboards_are_gone() -> None:
from deerflow.persistence import models
assert models.GoviewProjectRow is GoviewProjectRow
assert models.GoviewProjectContentRow is GoviewProjectContentRow
assert models.GoviewTemplateRow is GoviewTemplateRow
assert "goview_projects" in Base.metadata.tables
assert "goview_project_contents" in Base.metadata.tables
assert "goview_templates" in Base.metadata.tables
assert "visual_dashboard_projects" not in Base.metadata.tables
assert "visual_dashboard_snapshots" not in Base.metadata.tables
def test_tables_compile_for_mysql() -> None:
dialect = mysql.dialect()
content_ddl = " ".join(str(CreateTable(GoviewProjectContentRow.__table__).compile(dialect=dialect)).upper().split())
template_ddl = " ".join(str(CreateTable(GoviewTemplateRow.__table__).compile(dialect=dialect)).upper().split())
for ddl in (content_ddl, template_ddl):
assert "LONGTEXT" in ddl
assert "DATETIME NOT NULL" in ddl
assert "LONGTEXT DEFAULT" not in ddl
assert "CONTENT_JSON LONGTEXT NOT NULL" in content_ddl
assert "CONTENT_JSON LONGTEXT NOT NULL" in template_ddl
def test_sqlite_content_project_id_is_unique(tmp_path) -> None:
engine = create_engine(f"sqlite:///{tmp_path / 'goview.db'}")
Base.metadata.create_all(engine, tables=_TABLES)
inspector = inspect(engine)
pk = inspector.get_pk_constraint("goview_project_contents")["constrained_columns"]
assert pk == ["project_id"]
with engine.begin() as conn:
conn.execute(
GoviewProjectContentRow.__table__.insert(),
[{"project_id": "id_one", "content_json": "{}", "updated_at": datetime.now(UTC)}],
)
with pytest.raises(IntegrityError):
conn.execute(
GoviewProjectContentRow.__table__.insert(),
[{"project_id": "id_one", "content_json": "{\"x\":1}", "updated_at": datetime.now(UTC)}],
)
engine.dispose()
def test_published_read_is_public_and_draft_routes_are_not() -> None:
assert _is_goview_public_read("GET", "/api/goview/sys/getOssInfo")
assert _is_goview_public_read("GET", "/api/goview/sys/getOssInfo/")
assert not _is_goview_public_read("POST", "/api/goview/sys/getOssInfo")
assert not _is_goview_public_read("GET", "/api/goview/sys/other")
assert _is_goview_public_read("GET", "/api/goview/project/published/id_abc")
assert not _is_goview_public_read("POST", "/api/goview/project/published/id_abc")
assert not _is_goview_public_read("GET", "/api/goview/project/getData")
assert not _is_goview_public_read("GET", "/api/goview/project/list")
assert not _is_goview_public_read("POST", "/api/goview/project/upload")
assert not _is_goview_public_read("PUT", "/api/goview/project/publish")
def test_local_oss_info_uses_own_backend(monkeypatch) -> None:
client = _client(monkeypatch, MemoryGoviewProjectStore())
response = client.get("/api/goview/sys/getOssInfo", headers={"X-User-Id": "anonymous"})
assert response.status_code == 200
assert response.json()["data"] == {"bucketURL": ""}
def test_project_list_is_owner_scoped_and_omits_content(monkeypatch) -> None:
client = _client(monkeypatch, MemoryGoviewProjectStore())
created = client.post(
"/api/goview/project/create",
json={"projectName": "甲的项目", "remarks": None, "indexImage": None},
headers={"X-User-Id": "user-a"},
)
assert created.status_code == 200
assert created.json()["code"] == 200
project_id = created.json()["data"]["id"]
client.post(
"/api/goview/project/create",
json={"projectName": "乙的项目", "remarks": None, "indexImage": None},
headers={"X-User-Id": "user-b"},
)
listed = client.get("/api/goview/project/list", params={"page": 1, "limit": 12}, headers={"X-User-Id": "user-a"})
body = listed.json()
assert body["count"] == 1
assert body["count"] != body["data"]
assert [item["id"] for item in body["data"]] == [project_id]
assert "content" not in body["data"][0]
assert body["data"][0]["projectName"] == "甲的项目"
def test_other_user_cannot_read_save_delete_or_publish(monkeypatch) -> None:
client = _client(monkeypatch, MemoryGoviewProjectStore())
project_id = client.post(
"/api/goview/project/create",
json={"projectName": "草稿", "remarks": "说明", "indexImage": None},
headers={"X-User-Id": "user-a"},
).json()["data"]["id"]
other = {"X-User-Id": "user-b"}
assert client.get("/api/goview/project/getData", params={"projectId": project_id}, headers=other).status_code == 404
saved = client.post(
"/api/goview/project/save/data",
data={"projectId": project_id, "content": _canvas("入侵")},
headers=other,
)
assert saved.status_code == 404
assert client.put("/api/goview/project/publish", json={"id": project_id, "state": 1}, headers=other).status_code == 404
assert client.delete("/api/goview/project/delete", params={"ids": project_id}, headers=other).status_code == 404
owner = client.get("/api/goview/project/getData", params={"projectId": project_id}, headers={"X-User-Id": "user-a"})
assert owner.status_code == 200
assert owner.json()["data"]["state"] == -1
assert json.loads(owner.json()["data"]["content"])["componentList"] == []
def test_publish_link_and_unpublish_404(monkeypatch) -> None:
client = _client(monkeypatch, MemoryGoviewProjectStore())
owner = {"X-User-Id": "user-a"}
project_id = client.post(
"/api/goview/project/create",
json={"projectName": "发布项目", "remarks": None, "indexImage": None},
headers=owner,
).json()["data"]["id"]
content = _canvas("已发布")
assert client.post("/api/goview/project/save/data", data={"projectId": project_id, "content": content}, headers=owner).json()["code"] == 200
hidden = client.get(f"/api/goview/project/published/{project_id}")
assert hidden.status_code == 404
assert hidden.json()["msg"] == "项目未发布或不存在"
published = client.put("/api/goview/project/publish", json={"id": project_id, "state": 1}, headers=owner)
assert published.json()["data"]["relative_view_url"] == f"/#/chart/preview/{project_id}"
public = client.get(f"/api/goview/project/published/{project_id}")
assert public.status_code == 200
assert public.json()["data"]["content"] == content
assert client.put("/api/goview/project/publish", json={"id": project_id, "state": -1}, headers=owner).status_code == 200
assert client.get(f"/api/goview/project/published/{project_id}").status_code == 404
def test_large_canvas_roundtrip(monkeypatch) -> None:
client = _client(monkeypatch, MemoryGoviewProjectStore())
owner = {"X-User-Id": "user-a"}
project_id = client.post(
"/api/goview/project/create",
json={"projectName": "大画布", "remarks": None, "indexImage": None},
headers=owner,
).json()["data"]["id"]
content = json.dumps(
{
"editCanvasConfig": {"projectName": "大画布"},
"componentList": [{"id": str(index), "text": "字" * 200} for index in range(800)],
"requestGlobalConfig": {"requestDataPond": []},
},
ensure_ascii=False,
)
assert len(content) > 100_000
saved = client.post("/api/goview/project/save/data", data={"projectId": project_id, "content": content}, headers=owner)
assert saved.status_code == 200
loaded = client.get("/api/goview/project/getData", params={"projectId": project_id}, headers=owner)
assert loaded.json()["data"]["content"] == content
@pytest.mark.asyncio
async def test_sqlite_list_does_not_select_content_and_roundtrips(tmp_path) -> None:
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'goview.db'}")
async with engine.begin() as connection:
await connection.run_sync(lambda conn: Base.metadata.create_all(conn, tables=_TABLES))
store = make_goview_project_store(async_sessionmaker(engine, expire_on_commit=False))
created = await store.create_project(project_name="库项目", remarks=None, index_image=None, owner_id="user-a")
content = _canvas("库内原文")
await store.save_content(created["id"], "user-a", content)
statements: list[str] = []
def before(_conn, _cursor, statement, _parameters, _context, _executemany) -> None:
statements.append(statement)
event.listen(engine.sync_engine, "before_cursor_execute", before)
rows, total = await store.list_projects("user-a", page=1, limit=10)
event.remove(engine.sync_engine, "before_cursor_execute", before)
assert total == 1
assert "content" not in rows[0]
assert all("content_json" not in statement.lower() for statement in statements)
loaded = await store.get_owned(created["id"], "user-a")
assert loaded is not None
assert loaded["content"] == content
assert await store.get_owned(created["id"], "user-b") is None
await engine.dispose()
@pytest.mark.asyncio
async def test_shared_demo_projects_open_for_every_user_and_cannot_be_deleted(monkeypatch, tmp_path) -> None:
from app.gateway import goview_demo_projects
monkeypatch.setattr(goview_demo_projects, "asset_root", lambda: tmp_path)
store = MemoryGoviewProjectStore()
inserted = await goview_demo_projects.ensure_demo_projects(store)
assert inserted == [f"demo-material-{index}" for index in range(1, 7)]
assert await goview_demo_projects.ensure_demo_projects(store) == []
assert (tmp_path / goview_demo_projects.COVER_NAME).is_file()
await store.create_project(project_name="甲的私有项目", remarks=None, index_image=None, owner_id="user-a", content=_canvas("私有"))
client = _client(monkeypatch, store)
listed = client.get("/api/goview/project/list", params={"page": 1, "limit": 12}, headers={"X-User-Id": "user-b"})
body = listed.json()
assert body["count"] == 6
assert [item["id"] for item in body["data"]] == inserted
assert body["data"][0]["projectName"] == "物料1-全国运行态势"
assert body["data"][0]["state"] == 1
assert body["data"][1]["state"] == -1
assert body["data"][0]["indexImage"] == goview_demo_projects.COVER_URL
assert "content" not in body["data"][0]
loaded = client.get("/api/goview/project/getData", params={"projectId": "demo-material-1"}, headers={"X-User-Id": "user-b"})
content = json.loads(loaded.json()["data"]["content"])
assert len(content["componentList"]) > 20
keys = {item["key"] for item in content["componentList"]}
assert {"MapBase", "TableScrollBoard", "Radar", "CapsuleChart", "PieCircle", "Globe01", "Backdrop01", "HeaderTech01", "MetricCard01"} <= keys
assert not any(item["key"] == "Image" and item.get("id") == "reference-dashboard-cover" for item in content["componentList"])
assert client.get("/api/goview/project/published/demo-material-1").status_code == 200
force = client.get("/api/goview/project/published/demo-material-6")
assert force.status_code == 200
force_content = json.loads(force.json()["data"]["content"])
assert {
"FsTaskDetail",
"FsIntelligenceBriefs",
"FsImportantTargets",
"FsSituationInsight",
"FsCurrentJudgment",
"FsTaskConnection",
"FsImportantTimeNodes",
"FsVersionTimeline",
} <= {item["key"] for item in force_content["componentList"]}
assert client.get("/api/goview/project/published/demo-material-2").status_code == 404
denied = client.delete("/api/goview/project/delete", params={"ids": "demo-material-1"}, headers={"X-User-Id": "user-b"})
assert denied.status_code == 403
assert denied.json()["msg"] == "演示项目不能删除"
assert client.get("/api/goview/project/getData", params={"projectId": "demo-material-1"}, headers={"X-User-Id": "user-b"}).status_code == 200
private = client.get("/api/goview/project/list", params={"page": 1, "limit": 12}, headers={"X-User-Id": "user-a"})
assert private.json()["count"] == 7
assert private.json()["data"][0]["id"] == "demo-material-1"
assert private.json()["data"][-1]["projectName"] == "甲的私有项目"
edited = json.loads((await store.get_owned("demo-material-2", "user-b"))["content"])
edited["componentList"][0]["option"]["dataset"] = "用户改过"
await store.save_content("demo-material-2", "user-b", json.dumps(edited, ensure_ascii=False))
assert await goview_demo_projects.ensure_demo_projects(store) == []
assert "用户改过" in (await store.get_owned("demo-material-2", "user-b"))["content"]
await store.save_content("demo-material-1", "goview-demo", json.dumps({"componentList": ["id", "key"]}, ensure_ascii=False))
assert await goview_demo_projects.ensure_demo_projects(store) == ["demo-material-1"]
repaired = json.loads((await store.get_owned("demo-material-1", "user-b"))["content"])
assert all(isinstance(item, dict) for item in repaired["componentList"])
assert any(item["id"] == "m1-layout-v5" for item in repaired["componentList"])
@@ -0,0 +1,159 @@
"""GoView templates: deep copy, ownership, and builtin seed."""
from __future__ import annotations
import json
from types import SimpleNamespace
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.gateway import goview_http
from app.gateway.goview_builtin_templates import load_builtin_templates
from app.gateway.routers import goview_projects, goview_templates
from deerflow.persistence.goview import MemoryGoviewProjectStore, MemoryGoviewTemplateStore
def _client(monkeypatch) -> TestClient:
async def load_user(request):
uid = request.headers.get("X-User-Id", "user-a")
if uid == "anonymous":
return None
return SimpleNamespace(id=uid, system_role=request.headers.get("X-User-Role", "user"))
monkeypatch.setattr(goview_http, "load_user", load_user)
app = FastAPI()
app.include_router(goview_projects.router)
app.include_router(goview_templates.router)
app.state.goview_project_store = MemoryGoviewProjectStore()
app.state.goview_template_store = MemoryGoviewTemplateStore()
return TestClient(app)
def _canvas(marker: int) -> str:
return json.dumps(
{
"editCanvasConfig": {"projectName": "原项目", "nested": {"marker": marker}},
"componentList": [{"id": "n1", "marker": marker}],
"requestGlobalConfig": {},
},
ensure_ascii=False,
)
def test_builtin_seed_is_idempotent_and_does_not_overwrite(monkeypatch) -> None:
client = _client(monkeypatch)
admin = {"X-User-Id": "admin-1", "X-User-Role": "admin"}
user = {"X-User-Id": "user-a", "X-User-Role": "user"}
assert client.post("/api/goview/templates/admin/seed", headers=user).status_code == 403
first = client.post("/api/goview/templates/admin/seed", headers=admin)
assert first.status_code == 200
assert set(first.json()["data"]["inserted"]) == {item["id"] for item in load_builtin_templates()}
renamed = client.put(
"/api/goview/templates/builtin-dark-cockpit",
json={"name": "管理员改过的驾驶舱"},
headers=admin,
)
assert renamed.status_code == 200
second = client.post("/api/goview/templates/admin/seed", headers=admin)
assert second.json()["data"]["inserted"] == []
market = client.get("/api/goview/templates/market", headers=user)
names = {item["id"]: item["name"] for item in market.json()["data"]}
assert names["builtin-dark-cockpit"] == "管理员改过的驾驶舱"
assert all(item["coverImage"] for item in market.json()["data"])
assert market.json()["count"] == len(load_builtin_templates())
cockpit = client.get("/api/goview/templates/builtin-dark-cockpit", headers=user)
cockpit_canvas = json.loads(cockpit.json()["data"]["content"])
assert len(cockpit_canvas["componentList"]) >= 4
assert "content" not in market.json()["data"][0]
assert client.delete("/api/goview/templates/builtin-map-overview", headers=user).status_code == 403
assert client.delete("/api/goview/templates/builtin-map-overview", headers=admin).status_code == 403
assert client.put("/api/goview/templates/builtin-map-overview", json={"name": "用户改市场"}, headers=user).status_code == 403
detail = client.get("/api/goview/templates/builtin-map-overview", headers=user)
assert detail.status_code == 200
stored = json.loads(detail.json()["data"]["content"])
assert stored["componentList"][0]["chartConfig"]["key"] == "LeafletTileBackground"
def test_template_project_is_a_deep_copy(monkeypatch) -> None:
client = _client(monkeypatch)
owner = {"X-User-Id": "user-a"}
other = {"X-User-Id": "user-b"}
project_id = client.post(
"/api/goview/project/create",
json={"projectName": "源项目", "remarks": "备注", "indexImage": None},
headers=owner,
).json()["data"]["id"]
original = _canvas(1)
client.post("/api/goview/project/save/data", data={"projectId": project_id, "content": original}, headers=owner)
assert client.post("/api/goview/templates/from-project", json={"projectId": project_id}, headers=other).status_code == 404
created = client.post("/api/goview/templates/from-project", json={"projectId": project_id, "name": "我的模板"}, headers=owner)
template_id = created.json()["data"]["id"]
changed = _canvas(2)
client.post("/api/goview/project/save/data", data={"projectId": project_id, "content": changed}, headers=owner)
template = client.get(f"/api/goview/templates/{template_id}", headers=owner).json()["data"]["content"]
assert json.loads(template)["componentList"][0]["marker"] == 1
assert client.get(f"/api/goview/templates/{template_id}", headers=other).status_code == 404
assert client.post(
f"/api/goview/templates/{template_id}/create-project",
json={"projectName": "别人的项目"},
headers=other,
).status_code == 404
copied = client.post(f"/api/goview/templates/{template_id}/create-project", json={"projectName": "新项目"}, headers=owner)
assert copied.status_code == 200
new_id = copied.json()["data"]["id"]
client.post("/api/goview/project/save/data", data={"projectId": new_id, "content": _canvas(3)}, headers=owner)
again = json.loads(client.get(f"/api/goview/templates/{template_id}", headers=owner).json()["data"]["content"])
assert again["componentList"][0]["marker"] == 1
source = json.loads(
client.get("/api/goview/project/getData", params={"projectId": project_id}, headers=owner).json()["data"]["content"]
)
assert source["componentList"][0]["marker"] == 2
mine = client.get("/api/goview/templates/mine", headers=owner).json()
assert mine["count"] == 1
assert "content" not in mine["data"][0]
assert client.get("/api/goview/templates/mine", headers=other).json()["count"] == 0
seeded = client.post("/api/goview/templates/admin/seed", headers={"X-User-Id": "admin-1", "X-User-Role": "admin"})
assert seeded.status_code == 200
market_project = client.post(
"/api/goview/templates/builtin-dark-cockpit/create-project",
json={"projectName": "来自市场"},
headers=other,
)
assert market_project.status_code == 200
market_id = market_project.json()["data"]["id"]
copied_meta = client.get("/api/goview/project/getData", params={"projectId": market_id}, headers=other).json()["data"]
assert copied_meta["indexImage"]
client.post("/api/goview/project/save/data", data={"projectId": market_id, "content": _canvas(9)}, headers=other)
market_template = json.loads(
client.get("/api/goview/templates/builtin-dark-cockpit", headers=owner).json()["data"]["content"]
)
assert market_template["componentList"][0].get("marker") != 9
assert len(market_template["componentList"]) >= 4
def test_builtin_content_refresh_keeps_the_saved_name() -> None:
import asyncio
async def check() -> None:
store = MemoryGoviewTemplateStore()
item = next(row for row in load_builtin_templates() if row["id"] == "builtin-dark-cockpit")
assert await store.insert_if_absent(item) is True
await store.update_meta(item["id"], name="管理员改过的驾驶舱", description=None, cover_image=None, fields={"name"})
upgraded = item["content"].replace("运行总览", "画布已升级", 1)
assert await store.refresh_builtin_content(item["id"], upgraded) is True
stored = await store.get(item["id"])
assert stored is not None
assert stored["name"] == "管理员改过的驾驶舱"
assert "画布已升级" in stored["content"]
assert await store.refresh_builtin_content(item["id"], upgraded) is False
personal = await store.create_personal(
name="个人模板",
description=None,
cover_image=None,
content=item["content"],
owner_id="user-a",
)
assert await store.refresh_builtin_content(personal["id"], upgraded) is False
asyncio.run(check())
@@ -0,0 +1,50 @@
from __future__ import annotations
import pytest
from fastapi import FastAPI
from starlette.requests import Request
from app.gateway.routers import llmwiki
from deerflow.config.system_settings import SystemSettings
@pytest.mark.asyncio
async def test_local_wiki_auto_sync_settings_persist_and_rebuild_runtime(monkeypatch) -> None:
app = FastAPI()
request = Request({"type": "http", "headers": [], "app": app})
current = SystemSettings()
saved: list[SystemSettings] = []
rebuilds: list[bool] = []
async def require_admin(_request):
return "admin"
async def rebuild(_app, *, force=False):
rebuilds.append(force)
monkeypatch.setattr(llmwiki, "_require_admin", require_admin)
monkeypatch.setattr(llmwiki, "load_system_settings", lambda: current)
monkeypatch.setattr(
llmwiki,
"save_system_settings",
lambda value: saved.append(value) or value,
)
monkeypatch.setattr(
"app.gateway.llmwiki_index_runtime.rebuild_local_wiki_index_runtime",
rebuild,
)
result = await llmwiki.update_local_wiki_auto_sync_settings(
request,
llmwiki.LocalWikiAutoSyncSettingsUpdate(
enabled=True,
schedule="daily",
hour=5,
),
)
assert result.enabled is True
assert result.schedule == "daily"
assert result.hour == 5
assert saved[-1].local_wiki_auto_sync == result
assert rebuilds == [True]
@@ -13,7 +13,11 @@ from starlette.requests import Request
from app.gateway import llmwiki_index_runtime
from app.gateway.routers import llmwiki_index
from deerflow.config.llmwiki_config import LocalWikiEmbeddingConfig, LocalWikiIndexConfig
from deerflow.config.system_settings import LocalWikiEncoderSettings, SystemSettings
from deerflow.config.system_settings import (
LocalWikiAutoSyncSettings,
LocalWikiEncoderSettings,
SystemSettings,
)
from deerflow.integrations.weknora.local_index.embedding import StrictWikiEmbeddingClient, WikiEmbeddingError
@@ -59,6 +63,27 @@ def test_runtime_mode_can_switch_remote_config_to_uploaded_local_model(tmp_path:
assert local.embedding.api_key == ""
def test_runtime_auto_sync_uses_persisted_schedule_not_source_config() -> None:
configured = LocalWikiEmbeddingConfig(
provider="openai_compatible",
model="remote-embedding",
base_url="https://embedding.example.test/v1",
dimensions=1536,
)
source = _source_config(configured)
source.llmwiki.local_wiki_index.auto_sync = True
effective = llmwiki_index_runtime.resolve_effective_local_wiki_index_config(
source,
LocalWikiEncoderSettings(),
LocalWikiAutoSyncSettings(enabled=False, schedule="daily", hour=5),
)
assert effective.auto_sync is False
assert effective.auto_sync_schedule == "daily"
assert effective.auto_sync_hour == 5
def test_local_model_revision_changes_embedding_fingerprint(tmp_path: Path) -> None:
common = {
"provider": "local",
@@ -2,6 +2,7 @@ from __future__ import annotations
import asyncio
import json
from datetime import UTC, datetime
from types import SimpleNamespace
import httpx
@@ -725,3 +726,20 @@ def test_local_wiki_index_accepts_legacy_sync_flag() -> None:
assert config.auto_sync is True
assert config.sync_enabled is True
def test_local_wiki_auto_sync_calendar_slot_uses_server_local_hour() -> None:
hourly = SimpleNamespace(auto_sync_schedule="hourly", auto_sync_hour=2)
daily = SimpleNamespace(auto_sync_schedule="daily", auto_sync_hour=2)
at_two = datetime(2026, 11, 9, 2, 0, tzinfo=UTC)
assert llmwiki_index_scheduler._scheduled_auto_sync_slot(hourly, at_two) == "hourly:2026-11-09T02:00"
assert llmwiki_index_scheduler._scheduled_auto_sync_slot(daily, at_two) == "daily:2026-11-09T02:00"
assert llmwiki_index_scheduler._scheduled_auto_sync_slot(
daily,
datetime(2026, 11, 9, 3, 0, tzinfo=UTC),
) is None
assert llmwiki_index_scheduler._scheduled_auto_sync_slot(
hourly,
datetime(2026, 11, 9, 2, 1, tzinfo=UTC),
) is None
@@ -101,6 +101,56 @@ def test_load_skills_caches_parsing_and_invalidates_on_file_change(
assert calls == 2
def test_invalidate_skills_cache_reloads_before_the_check_interval(storage: LocalSkillStorage):
skill_dir = storage.get_skills_root_path() / "custom" / "adadad"
skill_dir.mkdir(parents=True)
skill_file = skill_dir / "SKILL.md"
skill_file.write_text(
"---\nname: adadad\ndescription: first version\n---\n# adadad\n",
encoding="utf-8",
)
storage._skills_cache_check_interval_seconds = 3600
assert storage.load_skills()[0].description == "first version"
skill_file.write_text(
"---\nname: adadad\ndescription: saved version\n---\n# adadad\n",
encoding="utf-8",
)
assert storage.load_skills()[0].description == "first version"
storage.invalidate_skills_cache()
assert storage.load_skills()[0].description == "saved version"
def test_request_storage_invalidation_clears_the_process_singleton(storage: LocalSkillStorage, tmp_path: Path):
from deerflow.skills import storage as storage_module
singleton_root = tmp_path / "singleton-skills"
(singleton_root / "custom").mkdir(parents=True)
skill_file = singleton_root / "custom" / "adadad" / "SKILL.md"
skill_file.parent.mkdir()
skill_file.write_text(
"---\nname: adadad\ndescription: cached\n---\n",
encoding="utf-8",
)
singleton = LocalSkillStorage(host_path=str(singleton_root))
singleton._skills_cache_check_interval_seconds = 3600
assert singleton.load_skills()[0].description == "cached"
skill_file.write_text(
"---\nname: adadad\ndescription: refreshed\n---\n",
encoding="utf-8",
)
previous = storage_module._default_skill_storage
storage_module._default_skill_storage = singleton
try:
storage.invalidate_skills_cache()
finally:
storage_module._default_skill_storage = previous
assert singleton.load_skills()[0].description == "refreshed"
# ---------- validate_skill_archive ----------
@@ -314,6 +364,10 @@ async def _attach_test_owner_names(responses):
class _UploadStorage:
def __init__(self) -> None:
self.install_calls = 0
self.cache_invalidations = 0
def invalidate_skills_cache(self) -> None:
self.cache_invalidations += 1
def validate_skill_archive(self, _path: Path) -> dict:
return {
@@ -470,6 +524,7 @@ async def test_direct_upload_owner_can_overwrite_own_skill(
assert response.success is True
assert response.overwritten is True
assert storage.install_calls == 1
assert storage.cache_invalidations == 1
@pytest.mark.asyncio
@@ -599,7 +654,48 @@ async def test_direct_upload_replaces_unclaimed_orphan(
assert response.success is True
assert response.overwritten is True
assert storage.install_calls == 1
assert storage.cache_invalidations == 1
# The orphan is adopted: the uploader becomes the registered owner.
record = await store.get_any("demo-skill")
assert record is not None
assert record["owner_user_id"] == "user-a"
@pytest.mark.asyncio
async def test_direct_upload_on_local_storage_invalidates_the_catalogue(
monkeypatch: pytest.MonkeyPatch,
storage: LocalSkillStorage,
tmp_path: Path,
) -> None:
"""Uploading a skill must not fail while clearing the parsed catalogue."""
async def _noop(*_args, **_kwargs):
return None
archive = _write_archive(tmp_path, _make_skill_zip(skill_name="adadad", description="uploaded skill"))
storage._skills_cache_check_interval_seconds = 3600
assert storage.load_skills() == []
async def _persist(_file) -> Path:
return archive
monkeypatch.setattr(skills_router, "_persist_uploaded_skill", _persist)
monkeypatch.setattr(skills_router, "get_or_new_skill_storage", lambda **_kwargs: storage)
monkeypatch.setattr(skills_router, "refresh_skills_system_prompt_cache_async", _noop)
monkeypatch.setattr(skills_router, "_sync_skill_view", _noop)
monkeypatch.setattr("deerflow.skills.installer._scan_skill_archive_contents_or_raise", _noop)
monkeypatch.setattr("deerflow.skills.versioning.skill_versioning_enabled", lambda: False)
monkeypatch.setattr("deerflow.skills.usage.mark_uploaded", lambda _name: None)
response = await skills_router.install_skill_upload(
request=_request("user-a"),
file=object(),
overwrite=False,
target_category=SkillCategory.CUSTOM,
config=object(),
skill_store=MemorySkillStore(),
)
assert response.success is True
assert response.skill_name == "adadad"
assert [skill.description for skill in storage.load_skills()] == ["uploaded skill"]
File diff suppressed because it is too large. Load diff