Files
ssw-ontology/server/integration_test.go
T
adminandClaude Code d14440a3ed feat(server): v1.8.0 本体导入 + 分区 + 行级归属 + 认证位 + 结构 diff + 分页 + 进度回报
一次收口 2026-11-06 的九项能力(CHANGELOG 1.5.4 → 1.8.0):

- 自检探针(readiness.go):check_readiness / check_answerable 两个只读探针,把
  「本体里没有」「我没权限看」「模型没抽全」三种空结果原因拆开
- 读路径语义钉死(scope.go):标记与分级的可见范围统一由 Scope 产出,实例分级
  为空时继承类型默认级(fail-closed),列表与详情口径一致
- 行级可改性轴(object_owner.go):归属只收窄不宽于 grants,所有对象写路径统一
  走 canWriteObject,归属查询失败即拒绝
- 公理第 6 类 certification:认证位保护人工策展内容,AI 重摄取不再覆盖已认证条目
- 跨版本结构 diff(schema_diff.go):schema_snapshots 全量快照 + diff 端点,机器
  事实与人工策展分组呈现
- 分区维度 zone:分区绑类型、命中任一即可见,读路径一律带 zone 条件
- 统一分页信封(pagination.go):列表回包统一 count/total/limit/offset/has_more/
  truncated,total 与 items 同源
- MCP 长任务进度(mcp_progress.go):客户端带 progressToken 才走 SSE 进度帧
- 本体 schema 导入(ontology_import.go):Turtle 导入 + 四道 fail-fast 闸门 +
  整事务 + (source, external_id) 幂等 + IRI 往返不变式

MCP 工具清单并入单一注册表(mcp_registry.go),对外声明与实际可调不再各说各话;
工具数 42 → 54(只读 27 / 写入 27),注册表与分发 case 的双向漂移由 AST 单测拦截。

CHANGELOG 编号整理:新「认证位 + 行级归属」条目由 1.6.0 改为 1.5.6(1.6.x 留给
分区与结构 diff),2026-09-20 的 GB/T 规划稿改标「规划稿·未发布」——该能力已并入
v1.5.1,避免与正式发布的版本号重复。

Co-Authored-By: Claude Code <[email protected]>
2026-11-06 13:51:48 +08:00

659 lines
24 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//go:build integration
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"strconv"
"strings"
"testing"
"time"
"github.com/gin-gonic/gin"
)
// testEnv 是 integration_test 共享的进程内测试环境。
// 只在 -tags=integration 时编译,避免污染默认 `go test`。
type testEnv struct {
srv *httptest.Server
typeKey string // 本次测试用的对象类型 api_name,全库唯一
}
// 用一个长随机后缀保证类型不与历史/并发测试冲突
func uniqTypeKey(prefix string) string {
return fmt.Sprintf("TestRgo_%s_%d", prefix, time.Now().UnixNano())
}
func testDSN() string {
if v := os.Getenv("TEST_DATABASE_URL"); v != "" {
return v
}
return "postgres://dacli:dacli123@localhost:15432/shangshu?sslmode=disable"
}
// setupTestEnv 启一个 httptest 服务,跑到真实 PG,并在 t.Cleanup 里清理测试类型/实例/边/clearance。
func setupTestEnv(t *testing.T) (*testEnv, *app) {
t.Helper()
if testing.Short() {
t.Skip("integration 测试需要真实 PG;跳过 -short 模式")
}
ctx := context.Background()
pool, err := initDB(ctx, testDSN())
if err != nil {
t.Skipf("无法连接测试 PG(%s): %v", testDSN(), err)
}
// 访问控制 schema 幂等建表(与 boot 同一入口)。
// 测试库是跨用例共享的存量库:新增的表不会因为「跑过一次老版本」而存在,
// 不在这里补建就会报 relation does not exist。
if err := ensureAccessControlSchema(ctx, pool); err != nil {
t.Fatalf("建访问控制 schema 失败: %v", err)
}
// 结构快照基线(version=0,与 boot 同一入口):跨版本 diff 的起点。
a0 := &app{cfg: &Config{BaseIRI: baseIRI()}, pool: pool}
a0.ensureSchemaBaseline(ctx)
// 记录起始 schema 版本:清理时把本用例产生的结构快照一并删掉
// (快照是全量 JSON,跑久了会涨库)。
var startVer int64
_ = pool.QueryRow(ctx, `SELECT COALESCE(max(version),0) FROM schema_versions`).Scan(&startVer)
cfg := &Config{
HTTPPort: 0,
DatabaseURL: testDSN(),
AIEnabled: false,
AllowCORS: false,
BaseIRI: baseIRI(), // 与 loadConfig 默认值保持一致(IRI 命名空间)
}
a := &app{cfg: cfg, pool: pool}
gin.SetMode(gin.TestMode)
r := gin.New()
registerRoutes(r, a)
srv := httptest.NewServer(r)
key := uniqTypeKey(t.Name())
env := &testEnv{srv: srv, typeKey: key}
t.Cleanup(func() {
// 清理:直接 SQL 清理本次测试创建的类型 + 残留 clearance
_, _ = pool.Exec(ctx,
`DELETE FROM objects WHERE type_api_name=$1`, key)
_, _ = pool.Exec(ctx, `DELETE FROM object_types WHERE api_name=$1`, key)
_, _ = pool.Exec(ctx,
`DELETE FROM links WHERE source_type=$1 OR target_type=$1`, key)
// 清理备份(按 name 前缀 TestRgo_)—— 跨测试共享一个 schema,物理删最干净
_, _ = pool.Exec(ctx,
`DELETE FROM backups.snapshot_runs WHERE name LIKE 'TestRgo_%'`)
// 清理本用例产生的结构快照(基线 version=0 保留)
_, _ = pool.Exec(ctx, `DELETE FROM schema_snapshots WHERE version > $1`, startVer)
// 注:analyst 共享主体不复删,由后续运行累积,最坏情况仅扩大可见集不影响正确性
invalidateClassCache()
authzCache.Range(func(k, _ any) bool { authzCache.Delete(k); return true })
srv.Close()
pool.Close()
})
return env, a
}
// ---------- 备份(v1.3.0)----------
// uniqSnapshotName 在并行 / 重跑场景下用 nanos 命名备份,便于 cleanup 物理删除。
func uniqSnapshotName(t *testing.T) string {
return fmt.Sprintf("TestRgo_snap_%d", time.Now().UnixNano())
}
// httpDo 简易 JSON POST/GET 帮手。body 为 nil 时是 GET。
// headerExtras 可选:用于「正常 headers 之外再叠加快照头/特殊头」的场景(如「写
// 路径要带 X-Snapshot-Id」组合)。
func (e *testEnv) httpDo(t *testing.T, method, path string, body any, headers map[string]string, headerExtras ...map[string]string) (int, map[string]any) {
t.Helper()
var rdr io.Reader
if body != nil {
b, err := json.Marshal(body)
if err != nil {
t.Fatalf("marshal: %v", err)
}
rdr = bytes.NewReader(b)
}
req, err := http.NewRequest(method, e.srv.URL+path, rdr)
if err != nil {
t.Fatalf("req: %v", err)
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
for k, v := range headers {
req.Header.Set(k, v)
}
// headerExtras 可叠加在 headers 之上(用于「写路径要带快照头」等组合场景)
for _, extras := range headerExtras {
for k, v := range extras {
req.Header.Set(k, v)
}
}
resp, err := e.srv.Client().Do(req)
if err != nil {
t.Fatalf("do: %v", err)
}
defer resp.Body.Close()
out := map[string]any{}
raw, _ := io.ReadAll(resp.Body)
if len(raw) > 0 {
_ = json.Unmarshal(raw, &out)
}
return resp.StatusCode, out
}
// ---------- 1. 枚举写入校验(issue #5-①,含修复后的变量遮蔽 bug)----------
func TestIntegration_EnumValidation(t *testing.T) {
env, a := setupTestEnv(t)
key := env.typeKey
h := authHeaderFor(t, a, "manager")
// 建类型 + 枚举属性
if code, body := env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": key, "display_name": "回归-枚举校验",
}, h); code != 200 && code != 201 {
t.Fatalf("create type: %d %v", code, body)
}
if code, body := env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties", map[string]any{
"api_name": "level", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L1", "L2", "L3"},
}, h); code != 200 && code != 201 {
t.Fatalf("add property: %d %v", code, body)
}
// 合法值 → 200
if code, _ := env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "ok1", "properties": map[string]any{"level": "L2"}, "via": "test",
}, h); code != 200 && code != 201 {
t.Errorf("合法枚举值 L2 应成功, got %d", code)
}
// 越界值 → 400 + 友好错误(这是修复过的变量遮蔽 bug 的回归点)
code, body := env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "bad1", "properties": map[string]any{"level": "L9"}, "via": "test",
}, h)
if code != 400 {
t.Fatalf("越界枚举值 L9 应 400, got %d, body=%v", code, body)
}
if msg, _ := body["error"].(string); !strings.Contains(msg, "enum_violation") {
t.Errorf("错误信息应包含 enum_violation, got %v", body)
}
// 越界实例不应被写入
code, _ = env.httpDo(t, "GET", "/api/v1/connector/object/"+key+"/bad1", nil, h)
if code == 200 {
t.Errorf("越界实例 bad1 不应被持久化")
}
// 空字符串 → 不校验(视作「未填」,不阻断 AI 抽取)
if code, _ := env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "empty1", "properties": map[string]any{"level": ""}, "via": "test",
}, h); code != 200 && code != 201 {
t.Errorf("空枚举值应放行, got %d", code)
}
}
// ---------- 2. 分级过滤(issue #5-③④)----------
func TestIntegration_ClassificationFilter(t *testing.T) {
env, a := setupTestEnv(t)
key := env.typeKey
// 建类型(带分级)+ 枚举属性 + 插入 analyst clearance(L0,L1)
h := authHeaderFor(t, a, "manager")
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": key, "display_name": "回归-分级过滤",
"classification_property": "level",
"classification_levels": []string{"L0", "L1", "L2", "L3"},
"classification_default": "L0",
}, h); code != 200 && code != 201 {
t.Fatal("create type failed")
}
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties", map[string]any{
"api_name": "level", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L1", "L2", "L3"},
}, h)
// 注入 analyst clearance:L0+L1(principal 名与 GET 时带的 analyst api_key 对应主体一致)
pool, _ := initDB(context.Background(), testDSN())
defer pool.Close()
_, _ = pool.Exec(context.Background(),
`INSERT INTO principal_clearances(principal,marking) VALUES($1,'L0'),($1,'L1') ON CONFLICT DO NOTHING`,
"analyst")
invalidateClassCache()
// 清掉可能残留的 authz 缓存(sync.Map 进程级,跨测试可能命中过期空集)
authzCache.Range(func(k, _ any) bool { authzCache.Delete(k); return true })
// 建 3 个实例:L0/L1/L2
for _, c := range []struct{ pk, lvl string }{
{"a_l0", "L0"}, {"a_l1", "L1"}, {"a_l2", "L2"},
} {
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": c.pk, "properties": map[string]any{"level": c.lvl}, "via": "test",
}, h)
}
// manager → 见 3 个
_, body := env.httpDo(t, "GET", "/api/v1/connector/objects/"+key+"?limit=50", nil, h)
if total, _ := body["total"].(float64); int(total) != 3 {
t.Errorf("manager 应见 3 个, got total=%v items=%v", total, body["items"])
}
// analyst(L0,L1) → 只见到 L0/L1
_, body = env.httpDo(t, "GET", "/api/v1/connector/objects/"+key+"?limit=50", nil,
authHeaderFor(t, a, "analyst"))
total := int(body["total"].(float64))
if total != 2 {
t.Errorf("analyst 应见 2 个, got %d, items=%v", total, body["items"])
}
pks := map[string]bool{}
for _, it := range body["items"].([]any) {
pks[it.(map[string]any)["pk"].(string)] = true
}
if pks["a_l2"] {
t.Errorf("analyst 不应见到 L2 实例")
}
// analyst 直取 L2 实例 → 404(fail-closed:不泄漏存在性)
code, _ := env.httpDo(t, "GET", "/api/v1/connector/object/"+key+"/a_l2", nil,
authHeaderFor(t, a, "analyst"))
if code != 404 {
t.Errorf("analyst 直取 L2 应 404, got %d", code)
}
}
// ---------- 3. 字段级分级脱敏(issue #5-②)----------
func TestIntegration_FieldSensitivity(t *testing.T) {
env, a := setupTestEnv(t)
key := env.typeKey
h := authHeaderFor(t, a, "manager")
env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": key, "display_name": "回归-字段脱敏",
"classification_property": "level",
"classification_levels": []string{"L0", "L1", "L2", "L3"},
"classification_default": "L0",
}, h)
// 一个公开属性 + 一个 secret 属性(sensitivity=L2)
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties", map[string]any{
"api_name": "public_name", "display_name": "名称", "data_type": "string",
}, h)
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties", map[string]any{
"api_name": "secret_id", "display_name": "身份证", "data_type": "string",
"sensitivity": "L2",
}, h)
// 创建实例
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "u1",
"properties": map[string]any{"level": "L1", "public_name": "张三", "secret_id": "110101199001011234"},
"via": "test",
}, h)
// 给 analyst 注入 L0+L1 clearance,并清掉 authz 缓存(sync.Map 跨测试可能命中过期空集)
pool, _ := initDB(context.Background(), testDSN())
defer pool.Close()
_, _ = pool.Exec(context.Background(),
`INSERT INTO principal_clearances(principal,marking) VALUES($1,'L0'),($1,'L1') ON CONFLICT DO NOTHING`,
"analyst")
invalidateClassCache()
authzCache.Range(func(k, _ any) bool { authzCache.Delete(k); return true })
// manager → 两个字段都见
_, body := env.httpDo(t, "GET", "/api/v1/connector/object/"+key+"/u1", nil, h)
props := body["properties"].(map[string]any)
if props["secret_id"] != "110101199001011234" {
t.Errorf("manager 应见 secret_id 原值, got %v", props["secret_id"])
}
// analyst(L0,L1) → secret_id 应被 redact 为 ***
_, body = env.httpDo(t, "GET", "/api/v1/connector/object/"+key+"/u1", nil,
authHeaderFor(t, a, "analyst"))
props = body["properties"].(map[string]any)
if props["secret_id"] != "***" {
t.Errorf("analyst 应见 secret_id='***', got %v", props["secret_id"])
}
if props["public_name"] != "张三" {
t.Errorf("公开字段不应被 redact, got %v", props["public_name"])
}
}
// ---------- 4. 删除 → 恢复关系边(issue #4)----------
func TestIntegration_RestoreEdges(t *testing.T) {
env, a := setupTestEnv(t)
key := env.typeKey
h := authHeaderFor(t, a, "manager")
pool, _ := initDB(context.Background(), testDSN())
defer pool.Close()
env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": key, "display_name": "回归-恢复边",
}, h)
env.httpDo(t, "POST", "/api/v1/ontology/link-types", map[string]any{
"api_name": key + "_rel", "display_name": "关联",
"source_type": key, "target_type": key,
}, h)
// 建两个实例 + 一条边
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "n1", "properties": map[string]any{"name": "一"}, "via": "test",
}, h)
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "n2", "properties": map[string]any{"name": "二"}, "via": "test",
}, h)
if code, body := env.httpDo(t, "POST", "/api/v1/links", map[string]any{
"type": key + "_rel", "source_type": key, "source_pk": "n1",
"target_type": key, "target_pk": "n2",
}, h); code != 200 && code != 201 {
t.Fatalf("建边失败: %d %v", code, body)
}
// 删除 n1(级联应同时删边)
if code, body := env.httpDo(t, "DELETE", "/api/v1/objects/"+key+"/n1", nil, h); code != 200 {
t.Fatalf("delete n1: %d %v", code, body)
} else if v, _ := body["links_deleted"].(float64); v != 1 {
t.Errorf("links_deleted 应为 1, got %v", body)
} else if v, _ := body["links_snapshot_saved"].(float64); v != 1 {
t.Errorf("links_snapshot_saved 应为 1, got %v", body)
}
// 验证:删除后 n1 应 404
if code, _ := env.httpDo(t, "GET", "/api/v1/connector/object/"+key+"/n1", nil, h); code != 404 {
t.Errorf("删除后 n1 应 404, got %d", code)
}
// 恢复 n1(默认 restore_edges=true)
code, body := env.httpDo(t, "POST", "/api/v1/objects/"+key+"/n1/restore", nil, h)
if code != 200 {
t.Fatalf("restore n1: %d %v", code, body)
}
if v, _ := body["edges_created"].(float64); v != 1 {
t.Errorf("edges_created 应为 1, got %v", body)
}
// 验证:边在 DB 中真重建(不靠 connObject 的边字段:单对象接口不返回 links_out)
var linkCount int
err := pool.QueryRow(context.Background(),
`SELECT count(*) FROM links WHERE link_type=$1 AND source_type=$2 AND source_pk=$3 AND target_pk=$4`,
key+"_rel", key, "n1", "n2").Scan(&linkCount)
if err != nil {
t.Fatalf("查 links: %v", err)
}
if linkCount != 1 {
t.Errorf("恢复后 n1->n2 边应存在, got %d", linkCount)
}
}
// ---------- 5. recompute 落库(issue #5-⑩)----------
func TestIntegration_RecomputeApply(t *testing.T) {
env, a := setupTestEnv(t)
key := env.typeKey
h := authHeaderFor(t, a, "manager")
env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": key, "display_name": "回归-recompute",
"classification_property": "level",
"classification_levels": []string{"L0", "L1", "L2", "L3"},
"classification_default": "L0",
}, h)
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties", map[string]any{
"api_name": "level", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L1", "L2", "L3"},
}, h)
// 先建一个分类正确的实例(用于验证「不会改对它」)
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": key, "pk": "r1", "properties": map[string]any{"level": "L3"}, "via": "test",
}, h)
// 手工把数据库里的 classification 改成错误值,模拟历史数据
pool, _ := initDB(context.Background(), testDSN())
defer pool.Close()
_, _ = pool.Exec(context.Background(),
`UPDATE objects SET classification='WRONG' WHERE type_api_name=$1`, key)
invalidateClassCache()
// dry_run=true 应返回 would_change ≥ 1(r1 应被纠正回 L3)
_, body := env.httpDo(t, "POST", "/api/v1/ontology/classification/recompute", map[string]any{
"type": key, "dry_run": true,
}, h)
would, _ := body["would_change"].(float64)
if would < 1 {
t.Errorf("dry_run 应报告至少 1 条需改, got %v", body)
}
// 此时 DB 中仍是 WRONG
var cls string
_ = pool.QueryRow(context.Background(),
`SELECT classification FROM objects WHERE type_api_name=$1 AND pk='r1'`, key).Scan(&cls)
if cls != "WRONG" {
t.Errorf("dry_run 不应落库, got cls=%q", cls)
}
// apply=true 应落库纠正
_, body = env.httpDo(t, "POST", "/api/v1/ontology/classification/recompute", map[string]any{
"type": key, "dry_run": false, "apply": true,
}, h)
if applied, _ := body["applied"].(float64); applied < 1 {
t.Errorf("apply=true 应至少修正 1 条, got %v", body)
}
_ = pool.QueryRow(context.Background(),
`SELECT classification FROM objects WHERE type_api_name=$1 AND pk='r1'`, key).Scan(&cls)
if cls != "L3" {
t.Errorf("apply 后 classification 应为 L3, got %q", cls)
}
}
// ---------- 6. 数据备份 (v1.3.0) 端到端:create → list → inspect → diff → download → delete ----------
func TestIntegration_BackupLifecycle(t *testing.T) {
env, a := setupTestEnv(t)
h := authHeaderFor(t, a, "manager")
// 当前 public 的 objects 表应有内容(>0 行),diff 才有意义
pool, _ := initDB(context.Background(), testDSN())
defer pool.Close()
var preCount int
_ = pool.QueryRow(context.Background(), `SELECT count(*) FROM objects`).Scan(&preCount)
if preCount == 0 {
t.Skip("public.objects 为空,跳过备份 diff 验证")
}
// 1) create
name := uniqSnapshotName(t)
code, body := env.httpDo(t, "POST", "/api/v1/backups", map[string]any{
"name": name, "notes": "test backup",
}, h)
if code != 201 {
t.Fatalf("创建备份失败: %d %v", code, body)
}
idF, ok := body["id"].(float64)
if !ok {
t.Fatalf("响应缺 id: %v", body)
}
id := int64(idF)
if body["principal"] != "manager" {
t.Errorf("principal 应为 manager, got %v", body["principal"])
}
tablesF, _ := body["table_count"].(float64)
if tablesF < 20 {
t.Errorf("备份应至少覆盖 20 张表, got %v", tablesF)
}
// 2) list 应能看见
code, body = env.httpDo(t, "GET", "/api/v1/backups", nil, h)
if code != 200 {
t.Fatalf("list 失败: %d", code)
}
items, _ := body["items"].([]any)
found := false
for _, it := range items {
if idF, _ := it.(map[string]any)["id"].(float64); int64(idF) == id {
found = true
break
}
}
if !found {
t.Errorf("list 应包含新备份 #%d", id)
}
// 3) inspect 应返回元信息 + schema_name(按 schema 镜像方案不再列每张表)
code, body = env.httpDo(t, "GET", "/api/v1/backups/"+strconv.FormatInt(id, 10), nil, h)
if code != 200 {
t.Fatalf("inspect 失败: %d", code)
}
schemaName, _ := body["schema_name"].(string)
if !strings.HasPrefix(schemaName, "backups_") {
t.Errorf("inspect 应返回 schema_name=backups_*, got %q", schemaName)
}
// 4) switch 应返回「切到这个快照需要的信息」
code, body = env.httpDo(t, "GET", "/api/v1/backups/"+strconv.FormatInt(id, 10)+"/switch", nil, h)
if code != 200 {
t.Fatalf("switch 失败: %d", code)
}
if body["switch_via"] != "X-Snapshot-Id" {
t.Errorf("switch_via 应为 X-Snapshot-Id, got %v", body["switch_via"])
}
// 4.5) 立即用快照头读 connector/object-types 验证「切到快照 → 见 schema」
// (不需要专门的 diff 接口:snapshot_router 中间件已是 diff 替代品)
code, body = env.httpDo(t, "GET", "/api/v1/connector/object-types",
nil, h,
map[string]string{"X-Snapshot-Id": strconv.FormatInt(id, 10)})
if code != 200 {
t.Fatalf("快照头读 connector/object-types 失败: %d", code)
}
if types, _ := body["object_types"].([]any); len(types) == 0 {
t.Errorf("快照应非空")
}
// 5) 制造改动:建测试类型 + 新实例 → 再用快照头读应见不到新增
env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": env.typeKey, "display_name": "backup-diff-probe",
}, h)
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": env.typeKey, "pk": "diff_probe",
"properties": map[string]any{"name": "diff probe"}, "via": "test",
}, h)
code, body = env.httpDo(t, "GET", "/api/v1/connector/object/"+env.typeKey+"/diff_probe",
nil, h,
map[string]string{"X-Snapshot-Id": strconv.FormatInt(id, 10)})
if code == 200 {
t.Errorf("快照应不见改后新增的 diff_probe, got 200 %v", body)
}
// 6) list 能看到刚建的快照
code, body = env.httpDo(t, "GET", "/api/v1/backups?limit=10", nil, h)
if code != 200 {
t.Fatalf("list 失败: %d", code)
}
items2, _ := body["items"].([]any)
foundSchema := false
for _, it := range items2 {
m := it.(map[string]any)
if idF, _ := m["id"].(float64); int64(idF) == id {
if s, _ := m["schema_name"].(string); strings.HasPrefix(s, "backups_") {
foundSchema = true
}
}
}
if !foundSchema {
t.Errorf("list 应包含 schema_name=backups_* 的快照 #%d", id)
}
// 7) connector 主体应被拒(managerAuth 中间件 → 401)
code, body = env.httpDo(t, "GET", "/api/v1/backups", nil,
authHeaderFor(t, a, "connector"))
if code != 401 {
t.Errorf("非 manager 应被拒 401, got %d, body=%v", code, body)
}
// 8) delete
code, body = env.httpDo(t, "DELETE", "/api/v1/backups/"+strconv.FormatInt(id, 10), nil, h)
if code != 200 {
t.Fatalf("delete 失败: %d %v", code, body)
}
code, body = env.httpDo(t, "GET", "/api/v1/backups/"+strconv.FormatInt(id, 10), nil, h)
if code != 404 {
t.Errorf("delete 后 inspect 应 404, got %d", code)
}
}
// TestIntegration_BackupDiffAfterMutation 验证「改动前/后各打一份 → diff 可见」
// 这正是「敢操作」的工作流核心。
func TestIntegration_BackupDiffAfterMutation(t *testing.T) {
env, a := setupTestEnv(t)
h := authHeaderFor(t, a, "manager")
// 创建测试类型 + 一个实例
env.httpDo(t, "POST", "/api/v1/ontology/object-types", map[string]any{
"api_name": env.typeKey, "display_name": "diff-test",
}, h)
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": env.typeKey, "pk": "before", "properties": map[string]any{"v": "1"}, "via": "test",
}, h)
// 1) before
_, bodyBefore := env.httpDo(t, "POST", "/api/v1/backups",
map[string]any{"name": uniqSnapshotName(t), "notes": "before mutation"}, h)
idBefore := int64(bodyBefore["id"].(float64))
// 2) 改:再写两个新实例 + 改一个原值
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": env.typeKey, "pk": "after1", "properties": map[string]any{"v": "1"}, "via": "test",
}, h)
env.httpDo(t, "POST", "/api/v1/objects", map[string]any{
"type": env.typeKey, "pk": "after2", "properties": map[string]any{"v": "1"}, "via": "test",
}, h)
putCode, _ := env.httpDo(t, "PUT", "/api/v1/objects/"+env.typeKey+"/before", map[string]any{
"properties": map[string]any{"v": "2"}, "via": "test",
}, h)
if putCode != 200 {
t.Logf("[warn] PUT before 返回 %d(updateObject 路径可能不同),继续验证 added", putCode)
}
// 3) 用快照头读快照:应见 before=v=1(不改前)、不见 after1/after2(改后才有)
code, snapBody := env.httpDo(t, "GET", "/api/v1/connector/object/"+env.typeKey+"/before",
nil, h,
map[string]string{"X-Snapshot-Id": strconv.FormatInt(idBefore, 10)})
if code != 200 {
t.Fatalf("快照读 before 失败: %d", code)
}
snapProps, _ := snapBody["properties"].(map[string]any)
if snapProps["v"] != "1" {
t.Errorf("快照中 before 应为 v=1, got %v", snapProps["v"])
}
// after1 在快照中不存在
code, _ = env.httpDo(t, "GET", "/api/v1/connector/object/"+env.typeKey+"/after1",
nil, h,
map[string]string{"X-Snapshot-Id": strconv.FormatInt(idBefore, 10)})
if code == 200 {
t.Errorf("快照不应见 after1, got 200")
}
// 4) 不带头读活库:before=v=2、after1/after2 都存在
_, liveBody := env.httpDo(t, "GET", "/api/v1/connector/object/"+env.typeKey+"/before", nil, h)
liveProps, _ := liveBody["properties"].(map[string]any)
if liveProps["v"] != "2" {
t.Errorf("活库 before 应为 v=2, got %v", liveProps["v"])
}
code, _ = env.httpDo(t, "GET", "/api/v1/connector/object/"+env.typeKey+"/after1", nil, h)
if code != 200 {
t.Errorf("活库 after1 应 200, got %d", code)
}
}