An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
package treenode
import (
"database/sql"
"errors"
"path/filepath"
"reflect"
"strings"
"testing"
"github.com/88250/lute/parse"
)
func withDocumentMetadataDB(t *testing.T, encrypted bool) string {
t.Helper()
const boxID = "20261023000000-metabox"
dsn := filepath.Join(t.TempDir(), "blocktree.db")
if encrypted {
dsn += "?_key=x'000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f'"
}
database, err := sql.Open("sqlite3_extended", dsn)
if err != nil {
t.Fatal(err)
}
previousDB := db
if encrypted {
if err = initEncryptedBlockTreeTables(database); err != nil {
t.Fatal(err)
}
encryptedBlockTreeDBs.Store(boxID, database)
} else {
db = database
initDBTables()
}
t.Cleanup(func() {
if encrypted {
CloseEncryptedBlockTreeDB(boxID)
} else {
db = previousDB
database.Close()
}
})
return boxID
}
func TestDocumentMetadataReadsUseIdentityIndex(t *testing.T) {
for _, encrypted := range []bool{false, true} {
t.Run(map[bool]string{false: "plain", true: "encrypted"}[encrypted], func(t *testing.T) {
box := withDocumentMetadataDB(t, encrypted)
rows, err := queryForBox(box, "EXPLAIN QUERY PLAN "+documentMetadataByIDQuery, box, "doc")
if err != nil {
t.Fatal(err)
}
defer rows.Close()
var plan strings.Builder
for rows.Next() {
var id, parent, unused int
var detail string
if err = rows.Scan(&id, &parent, &unused, &detail); err != nil {
t.Fatal(err)
}
plan.WriteString(detail + "\n")
}
if err = rows.Err(); err != nil {
t.Fatal(err)
}
if !strings.Contains(plan.String(), "SEARCH b USING INDEX idx_blocktrees_id (id=?)") ||
!strings.Contains(plan.String(), "SEARCH m USING INDEX sqlite_autoindex_document_metadata_1 (box_id=? AND id=?)") {
t.Fatalf("single document lookup scans unrelated documents: %s", plan.String())
}
})
}
}
func TestDocumentMetadataIdentityAndTitle(t *testing.T) {
for _, encrypted := range []bool{false, true} {
t.Run(map[bool]string{false: "plain", true: "encrypted"}[encrypted], func(t *testing.T) {
box := withDocumentMetadataDB(t, encrypted)
root := NewTree(box, "/20261023000001-root001.sy", "/A", "A")
child := NewTree(box, "/20261023000001-root001/20261023000002-child01.sy", "/A/B", "B")
slash := NewTree(box, "/20261023000003-slash01.sy", "/A/B", "A/B")
for _, tree := range []*parse.Tree{root, child, slash} {
UpsertBlockTree(tree)
}
get := func(tree *parse.Tree) *DocumentPath {
t.Helper()
ret, err := GetDocumentPath(box, tree.ID, "", 1)
if err != nil {
t.Fatal(err)
}
return ret
}
childPath, slashPath := get(child), get(slash)
if childPath.DisplayPath != slashPath.DisplayPath || childPath.Depth != 2 || slashPath.Depth != 1 ||
childPath.ParentID == nil || *childPath.ParentID != root.ID || slashPath.ParentID != nil {
t.Fatalf("display path changed identity: %+v, %+v", childPath, slashPath)
}
previousRevision := childPath.Revision
root.Root.SetIALAttr("title", "**A/%2F&**")
root.HPath = "/**A/%2F&**"
if err := RefreshDocHPaths(root); err != nil {
t.Fatal(err)
}
childPath = get(child)
if childPath.Revision == previousRevision || childPath.Segments[0].Text != "**A/%2F&**" ||
GetBlockTreeInExactBox(child.ID, box).HPath != "/**A/%2F&**/B" {
t.Fatalf("rename did not retain literal title or revision: %+v", childPath)
}
// 空标题标志在秒级更新时间未变时也更新,实际占位文字不被抹掉。
child.Root.SetIALAttr(DocumentTitleEmptyAttr, "true")
UpsertBlockTree(child)
childPath = get(child)
if !childPath.Title.Empty || childPath.Title.Text != "B" || !childPath.Segments[1].Empty {
t.Fatalf("lost empty title flag: %+v", childPath)
}
// 移动与删除都同步清理父身份,不留下可再次匹配的旧行。
RemoveBlockTreesByRootID(box, child.ID)
child.Path = "/" + child.ID + ".sy"
child.HPath = "/B"
UpsertBlockTree(child)
if moved := get(child); moved.Depth != 1 || moved.ParentID != nil {
t.Fatalf("move retained old parent: %+v", moved)
}
RemoveBlockTree(box, child.ID)
if _, err := GetDocumentMetadata(box, child.ID); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("delete retained metadata: %v", err)
}
if _, err := GetDocumentPath("20261023000009-other01", root.ID, "", 1); err == nil {
t.Fatal("read crossed notebook ownership")
}
})
}
}
func TestDocumentMetadataMissingAndNotebookRoot(t *testing.T) {
box := withDocumentMetadataDB(t, false)
tree := NewTree(box, "/"+box+".sy", "/Notebook", "Notebook")
UpsertBlockTree(tree)
root, err := GetDocumentPath(box, tree.ID, box, 1)
if err != nil || root.Depth != 0 || len(root.Segments) != 0 || root.DisplayPath != "/" {
t.Fatalf("notebook document is not logical root: %+v, %v", root, err)
}
if _, err = db.Exec("DELETE FROM document_metadata"); err != nil {
t.Fatal(err)
}
missing, err := MissingDocumentMetadata(box)
if err != nil || len(missing) != 1 || missing[0].ID != box {
t.Fatalf("missing metadata not discoverable: %+v, %v", missing, err)
}
if err = RecoverDocumentMetadata(tree); err != nil {
t.Fatal(err)
}
meta, err := GetDocumentMetadata(box, tree.ID)
if err != nil || !reflect.DeepEqual(meta.Title, ReadDocumentTitle(tree.Root)) || meta.SourceSpec != tree.Root.Spec {
t.Fatalf("recovery lost source fields: %+v, %v", meta, err)
}
// 恢复任务读取后发生的新编辑优先,不能用旧源摘要覆盖。
tree.Root.SetIALAttr("title", "Edited")
UpsertBlockTree(tree)
tree.Root.SetIALAttr("title", "Old snapshot")
if err = RecoverDocumentMetadata(tree); err != nil {
t.Fatal(err)
}
meta, _ = GetDocumentMetadata(box, tree.ID)
if meta.Title.Text != "Edited" {
t.Fatalf("recovery overwrote concurrent edit: %+v", meta)
}
}
func TestDocumentMetadataPendingWrite(t *testing.T) {
for _, encrypted := range []bool{false, true} {
t.Run(map[bool]string{false: "plain", true: "encrypted"}[encrypted], func(t *testing.T) {
box := withDocumentMetadataDB(t, encrypted)
tree := NewTree(box, "/20261023000001-root001.sy", "/Saved", "Saved")
UpsertBlockTree(tree)
if err := SetDocumentMetadataState(box, "ready"); err != nil {
t.Fatal(err)
}
tree.Root.SetIALAttr("title", "Not yet saved")
UpsertBlockTreePending(tree)
meta, err := GetDocumentMetadata(box, tree.ID)
if err != nil || meta.Title.Text != "Saved" {
t.Fatalf("editing transaction published an uncommitted title: %+v, %v", meta, err)
}
pending, err := BeginDocumentMetadataWrite(tree)
if err != nil || !pending || DocumentMetadataState(box) != "building" {
t.Fatalf("missing durable write intent: pending=%v err=%v", pending, err)
}
if err = SetDocumentMetadataState(box, "ready"); !errors.Is(err, ErrDocumentMetadataUnavailable) {
t.Fatal("pending source write was advertised as ready", err)
}
intents, err := PendingDocumentMetadata(box)
if err != nil || len(intents) != 1 || intents[0].Path != tree.Path {
t.Fatalf("write cannot be recovered: %+v, %v", intents, err)
}
if err = CommitDocumentMetadataWrite(tree); err != nil {
t.Fatal(err)
}
meta, err = GetDocumentMetadata(box, tree.ID)
if err != nil || meta.Title.Text != "Not yet saved" || DocumentMetadataState(box) != "ready" {
t.Fatalf("successful save did not publish its source: %+v, %v", meta, err)
}
if pending, err = BeginDocumentMetadataWrite(tree); err != nil || pending {
t.Fatal("unchanged title writes an unnecessary intent", pending, err)
}
})
}
}