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 model
import (
"encoding/json"
"fmt"
"strings"
"testing"
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/sql"
)
func newTemplatePlanTestView(size, displays int, layout av.LayoutType) (*av.AttributeView, *av.View) {
keys := []*av.Key{av.NewKey("block", "Block", "", av.KeyTypeBlock), av.NewKey("text", "Text", "", av.KeyTypeText),
av.NewKey("source", "Source", "", av.KeyTypeTemplate), av.NewKey("required", "Required", "", av.KeyTypeTemplate)}
keys[2].Template = `.action{index . "Text"}`
keys[3].Template = `.action{printf "%s eligible" (index . "Source")}`
for i := range displays {
key := av.NewKey(fmt.Sprintf("display%d", i), fmt.Sprintf("Display%d", i), "", av.KeyTypeTemplate)
key.Template = fmt.Sprintf(`.action{printf "display%d:%%s" (index . "Required")}`, i)
keys = append(keys, key)
}
view := &av.View{ID: "view", LayoutType: layout, PageSize: 1, Table: av.NewLayoutTable(),
Filters: []*av.ViewFilter{{Column: "required", Operator: av.FilterOperatorContains,
Value: &av.Value{Type: av.KeyTypeTemplate, Template: &av.ValueTemplate{Content: "eligible"}}}},
Sorts: []*av.ViewSort{{Column: "required", Order: av.SortOrderDesc}}}
database := &av.AttributeView{ID: "av", Views: []*av.View{view}, RenderedViewables: map[string]av.Viewable{}}
for _, key := range keys {
values := &av.KeyValues{Key: key}
for i := range size {
id := fmt.Sprintf("20261019000000-%07d", i)
value := &av.Value{ID: id + "-" + key.ID, KeyID: key.ID, BlockID: id, Type: key.Type}
content := fmt.Sprintf("row%07d", i)
switch key.Type {
case av.KeyTypeBlock:
value.IsDetached, value.Block = true, &av.ValueBlock{Content: content}
view.ItemIDs = append(view.ItemIDs, id)
case av.KeyTypeText:
value.Text = &av.ValueText{Content: content}
case av.KeyTypeTemplate:
value.Template = &av.ValueTemplate{Content: key.Template}
}
values.Values = append(values.Values, value)
}
database.KeyValues = append(database.KeyValues, values)
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: key.ID}})
}
if layout == av.LayoutTypeList {
view.List, view.Table = view.Table, nil
} else if layout == av.LayoutTypeGallery {
view.Gallery = av.NewLayoutGallery()
view.Gallery.CoverFrom = av.CoverFromNone
for _, column := range view.Table.Columns {
view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: column.BaseField})
}
view.Table = nil
}
return database, view
}
func renderTemplatePlanTestView(database *av.AttributeView, view *av.View, selective bool, pageSize int) (av.Viewable, error) {
context := sql.NewAttributeViewRenderContext()
context.ReadOnly = true
var rendered av.Viewable
var plan *attributeViewTemplatePlan
if selective {
plan = planAttributeViewTemplates(database, view, "", false)
}
if plan == nil {
rendered = sql.RenderViewWithContext(database, view, "", false, context)
} else {
rendered = sql.RenderViewWithDeferredTemplatesContext(database, view, "", false, context)
sql.FillAttributeViewTemplateValuesForKeysWithContext(database, view, rendered.(av.Collection), plan.required, context)
}
if _, _, err := renderViewableInstance(rendered, view, database, 1, pageSize, false, "", context); err != nil {
return nil, err
}
if plan != nil {
sql.FillAttributeViewTemplateValuesForKeysWithContext(database, view, rendered.(av.Collection), plan.deferred, context)
}
return rendered, nil
}
func templatePlanSnapshot(t *testing.T, rendered av.Viewable) string {
t.Helper()
collection := rendered.(av.Collection)
var rows []any
for _, item := range collection.GetItems() {
var values []any
for _, value := range item.GetValues() {
values = append(values, []any{value.KeyID, value.String(true), value.RenderedContent, value.HasRenderTemplate})
}
var colors *av.ItemConditionalColors
switch row := item.(type) {
case *av.TableRow:
colors = row.ConditionalColors
case *av.GalleryCard:
colors = row.ConditionalColors
}
rows = append(rows, []any{item.GetID(), values, colors})
}
var calculations []any
for _, field := range collection.GetFields() {
if calc := field.GetCalc(); calc != nil && calc.Result != nil {
calculations = append(calculations, []string{field.GetID(), calc.Result.String(true)})
}
}
count := 0
if gallery, ok := rendered.(*av.Gallery); ok {
count = gallery.CardCount
} else {
count = av.TableFromViewable(rendered).RowCount
}
data, err := json.Marshal([]any{count, rows, calculations, rendered.GetGroupCalc()})
if err != nil {
t.Fatal(err)
}
return string(data)
}
func TestAttributeViewTemplatePlanMatchesCompleteEvaluation(t *testing.T) {
for _, layout := range []av.LayoutType{av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeGallery} {
for _, scenario := range []string{"dependencies", "rendered filter", "raw dependency", "conditional color", "calculation"} {
t.Run(string(layout)+"/"+scenario, func(t *testing.T) {
makeView := func() (*av.AttributeView, *av.View) {
database, view := newTemplatePlanTestView(3, 2, layout)
switch scenario {
case "rendered filter":
source, _ := database.GetKey("source")
source.Template = `.action{index . "Block"}`
text, _ := database.GetKey("text")
text.RenderTemplate = `.action{printf "shown:%s" .Text_raw.Text.Content}`
view.Filters = append(view.Filters, &av.ViewFilter{Column: "text", ValueSource: av.ValueSourceRendered,
Operator: av.FilterOperatorContains, Value: &av.Value{Type: av.KeyTypeText, Text: &av.ValueText{Content: "shown:"}}})
view.Sorts = []*av.ViewSort{{Column: "text", Order: av.SortOrderDesc, ValueSource: av.ValueSourceRendered}}
case "raw dependency":
key, _ := database.GetKey("display0")
key.Template = `.action{.Source_raw.Template.Content}`
case "conditional color":
view.ConditionalColors = []*av.ConditionalColorRule{{ID: "color", Target: "item", Color: &av.ValueSelect{Color: "3"},
Filter: &av.ViewFilter{Column: "display0", Operator: av.FilterOperatorContains,
Value: &av.Value{Type: av.KeyTypeTemplate, Template: &av.ValueTemplate{Content: "eligible"}}}}}
case "calculation":
if layout == av.LayoutTypeGallery {
view.Gallery.CardFields[4].Calc = &av.FieldCalc{Operator: av.CalcOperatorCountValues}
} else {
view.GetTableLayout().Columns[4].Calc = &av.FieldCalc{Operator: av.CalcOperatorCountValues}
}
view.GroupCalc = &av.GroupCalc{Field: "required", FieldCalc: &av.FieldCalc{Operator: av.CalcOperatorCountValues}}
}
return database, view
}
full, fullView := makeView()
partial, view := makeView()
plan := planAttributeViewTemplates(partial, view, "", false)
if plan == nil || !plan.required["source"] || !plan.required["required"] || !plan.deferred["display1"] {
t.Fatalf("missing transitive dependency or deferred display: %+v", plan)
}
want, err := renderTemplatePlanTestView(full, fullView, false, 1)
if err != nil {
t.Fatal(err)
}
got, err := renderTemplatePlanTestView(partial, view, true, 1)
if err != nil {
t.Fatal(err)
}
if actual, expected := templatePlanSnapshot(t, got), templatePlanSnapshot(t, want); actual != expected {
t.Fatalf("selective result differs:\ngot %s\nwant %s", actual, expected)
}
items := got.(av.Collection).GetItems()
if len(items) != 1 || items[0].GetID() != view.ItemIDs[2] || items[0].GetValue("required").Template.Content != "row0000002 eligible" {
t.Fatalf("filter, sort, or dependency output is incorrect: %+v", items)
}
values, _ := partial.GetKeyValues("display1")
for _, value := range values.Values {
if value.BlockID != items[0].GetID() && value.Template.Content != values.Key.Template {
t.Fatal("display template outside current page was evaluated")
}
}
if scenario == "rendered filter" {
value := items[0].GetValue("text")
if !value.HasRenderTemplate || value.RenderedContent != "shown:row0000002" {
t.Fatalf("late evaluation cleared required display output: %+v", value)
}
}
if scenario == "conditional color" {
var colors *av.ItemConditionalColors
switch item := items[0].(type) {
case *av.TableRow:
colors = item.ConditionalColors
case *av.GalleryCard:
colors = item.ConditionalColors
}
if colors == nil || colors.Background == nil || colors.Background.Color != "3" {
t.Fatalf("conditional color dependency was not evaluated: %+v", colors)
}
}
if scenario == "calculation" {
field, _ := got.(av.Collection).GetField("display0")
if calc := field.GetCalc(); calc == nil || calc.Result == nil || calc.Result.Number == nil || calc.Result.Number.Content != 3 {
t.Fatalf("field calculation did not include off-page rows: %+v", calc)
}
if calc := got.GetGroupCalc(); calc == nil || calc.FieldCalc == nil || calc.FieldCalc.Result == nil || calc.FieldCalc.Result.Number == nil || calc.FieldCalc.Result.Number.Content != 3 {
t.Fatalf("group calculation did not include off-page rows: %+v", calc)
}
}
})
}
}
}
func TestAttributeViewTemplatePlanEligibility(t *testing.T) {
for _, test := range []struct {
name string
configure func(*av.AttributeView, *av.View)
full bool
}{
{"nested filter", func(_ *av.AttributeView, view *av.View) { view.Filters = []*av.ViewFilter{{Filters: view.Filters}} }, false},
{"query-dependent group", func(_ *av.AttributeView, view *av.View) { view.Group = &av.ViewGroup{Field: "text"} }, true},
{"kanban", func(_ *av.AttributeView, view *av.View) { view.LayoutType = av.LayoutTypeKanban }, true},
{"calendar", func(_ *av.AttributeView, view *av.View) { view.LayoutType = av.LayoutTypeCalendar }, true},
{"branch", func(database *av.AttributeView, _ *av.View) {
database.KeyValues[4].Key.Template = `.action{if .Required}.action{.Required}.action{end}`
}, true},
{"dynamic key", func(database *av.AttributeView, _ *av.View) {
database.KeyValues[4].Key.Template = `.action{index . (print "Required")}`
}, true},
{"parse error", func(database *av.AttributeView, _ *av.View) { database.KeyValues[4].Key.Template = `.action{` }, true},
{"cycle", func(database *av.AttributeView, _ *av.View) {
database.KeyValues[2].Key.Template = `.action{.Required}`
}, true},
{"later rendered dependency", func(database *av.AttributeView, _ *av.View) { database.KeyValues[1].Key.RenderTemplate = "display" }, true},
} {
t.Run(test.name, func(t *testing.T) {
database, view := newTemplatePlanTestView(3, 2, av.LayoutTypeTable)
test.configure(database, view)
if got := planAttributeViewTemplates(database, view, "", false); (got == nil) != test.full {
t.Fatalf("unexpected plan: %+v", got)
}
})
}
database, view := newTemplatePlanTestView(3, 2, av.LayoutTypeTable)
for _, query := range []string{"search", " search "} {
if planAttributeViewTemplates(database, view, query, false) != nil {
t.Fatal("search path must evaluate all templates")
}
}
if planAttributeViewTemplates(database, view, "", true) != nil || planAttributeViewTemplates(nil, view, "", false) != nil {
t.Fatal("empty rendering must not create a template plan")
}
view.Filters, view.Sorts = nil, nil
database.KeyValues[4].Key.Template = `.action{if .Required}display.action{end}`
if plan := planAttributeViewTemplates(database, view, "", false); plan == nil || len(plan.required) != 0 || len(plan.deferred) != 4 {
t.Fatal("existing all-deferred eligibility regressed")
}
}
func TestAttributeViewTemplatePlanClearsPreviousDisplayState(t *testing.T) {
database, view := newTemplatePlanTestView(3, 2, av.LayoutTypeTable)
text, _ := database.GetKey("text")
text.RenderTemplate = `.action{printf "shown:%s" .Text_raw.Text.Content}`
// 存储值筛选只使用原始值,不读取上次渲染的显示文本。
view.Filters = []*av.ViewFilter{{Column: "text", Operator: av.FilterOperatorContains,
Value: &av.Value{Type: av.KeyTypeText, Text: &av.ValueText{Content: "row"}}}}
view.Sorts = nil
values, _ := database.GetKeyValues("text")
for _, value := range values.Values {
value.HasRenderTemplate, value.RenderedContent = true, "stale"
}
rendered, err := renderTemplatePlanTestView(database, view, true, 1)
if err != nil || rendered.(av.Collection).CountItems() != 1 {
t.Fatalf("previous display state affected pagination: %v", err)
}
if value := rendered.(av.Collection).GetItems()[0].GetValue("text"); !strings.HasPrefix(value.RenderedContent, "shown:") {
t.Fatalf("display was not recalculated: %+v", value)
}
if values.Values[1].RenderedContent != "" || values.Values[1].HasRenderTemplate {
t.Fatal("off-page previous display state was retained")
}
}
func TestRenderAttributeViewUsesTemplateDependencyPlan(t *testing.T) {
database, view := newTemplatePlanTestView(3, 2, av.LayoutTypeTable)
rendered, err := renderAttributeView(database, "", view.ID, "", "", 1, 1, nil, false, false, nil, "")
if err != nil {
t.Fatal(err)
}
items := rendered.(av.Collection).GetItems()
if len(items) != 1 || items[0].GetValue("display0").Template.Content != "display0:row0000002 eligible" {
t.Fatalf("render entry did not evaluate the visible dependency chain: %+v", items)
}
values, _ := database.GetKeyValues("display0")
for _, value := range values.Values {
if value.BlockID != items[0].GetID() && value.Template.Content != values.Key.Template {
t.Fatal("render entry evaluated an off-page display template")
}
}
}