Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

10.6 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package model

import (
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"

	"github.com/88250/lute/ast"
	"github.com/88250/lute/parse"
	"github.com/siyuan-note/siyuan/kernel/conf"
	"github.com/siyuan-note/siyuan/kernel/filesys"
	"github.com/siyuan-note/siyuan/kernel/util"
)

func TestExportAssetCopyFailureReturnsNoOutput(t *testing.T) {
	fixture := setupFileOperationTest(t)
	originalWorkspaceDir := util.WorkspaceDir
	util.WorkspaceDir = filepath.Dir(util.DataDir)
	t.Cleanup(func() { util.WorkspaceDir = originalWorkspaceDir })
	Conf.Editor.Store(conf.NewEditor())
	Conf.Export.Store(conf.NewExport())
	Conf.Appearance.Store(conf.NewAppearance())
	Conf.Search.Store(conf.NewSearch())
	Conf.System.Store(conf.NewSystem())
	assetPath := "assets/export-20260905000000-abcdefg.html"
	absPath := filepath.Join(util.DataDir, assetPath)
	if err := os.MkdirAll(filepath.Dir(absPath), 0755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(absPath, []byte("asset content"), 0644); err != nil {
		t.Fatal(err)
	}
	tree := addFileOperationTestDoc(t, fixture, "20260905000001-abcdefg", "Export copy failure", false)
	tree.Root.AppendChild(&ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="` + assetPath + `"></iframe>`)})
	if _, err := filesys.WriteTree(tree); err != nil {
		t.Fatal(err)
	}

	savePath := t.TempDir()
	if err := os.WriteFile(filepath.Join(savePath, "assets"), []byte("blocks asset directory"), 0644); err != nil {
		t.Fatal(err)
	}
	for _, docx := range []bool{false, true} {
		name, dom, err := exportMarkdownHTML(tree.ID, savePath, docx, false)
		if err == nil || !strings.Contains(err.Error(), "assets") {
			t.Fatalf("expected asset copy failure for docx=%v, got %v", docx, err)
		}
		if name != "" || dom != "" {
			t.Fatalf("failed markdown HTML export returned output: name=%q, dom=%q", name, dom)
		}
	}
	if name, dom := ExportMarkdownHTML(tree.ID, savePath, false, false); name != "" || dom != "" {
		t.Fatalf("failed public markdown HTML export returned output: name=%q, dom=%q", name, dom)
	}
	if name, dom, node := ExportHTMLWithTitle(tree.ID, savePath, false, false, false, false, ""); name != "" || dom != "" || node != nil {
		t.Fatalf("failed HTML export returned output: name=%q, dom=%q, node=%v", name, dom, node)
	}
}

func TestResolveExportAssetPaths(t *testing.T) {
	const (
		imageAsset  = "assets/image%20file-20260724150608-42z1qwz.png"
		videoAsset  = "assets/video file-20260724150608-42z1qwz.webm"
		audioAsset  = "assets/audio file-20260724150608-42z1qwz.wav?box=20260724163822-tfrplrg"
		iframeAsset = "assets/frame file-20260724150608-42z1qwz.html"
		pdfAsset    = "assets/document-20260724150608-42z1qwz.pdf?dataPath=/docs/a.sy#page=3"
	)

	tests := []struct {
		name     string
		removeID bool
		expected map[string][2]string
	}{
		{
			name: "preserve asset IDs",
			expected: map[string][2]string{
				imageAsset:  {imageAsset, imageAsset},
				videoAsset:  {videoAsset, videoAsset},
				audioAsset:  {audioAsset, audioAsset},
				iframeAsset: {iframeAsset, iframeAsset},
				pdfAsset:    {pdfAsset, pdfAsset},
			},
		},
		{
			name:     "remove asset IDs",
			removeID: true,
			expected: map[string][2]string{
				"assets/image%20file.png": {imageAsset, "assets/image%20file.png"},
				"assets/video file.webm":  {videoAsset, "assets/video file.webm"},
				"assets/audio file.wav?box=20260724163822-tfrplrg": {
					audioAsset,
					"assets/audio file.wav?box=20260724163822-tfrplrg",
				},
				"assets/frame file.html": {iframeAsset, "assets/frame file.html"},
				"assets/document.pdf?dataPath=/docs/a.sy#page=3": {
					pdfAsset, "assets/document.pdf?dataPath=/docs/a.sy#page=3",
				},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			originalConf := Conf
			Conf = NewAppConf()
			Conf.Export.Store(conf.NewExport())
			Conf.Export.Load().RemoveAssetsID = test.removeID
			t.Cleanup(func() {
				Conf = originalConf
			})

			root := &ast.Node{Type: ast.NodeDocument}
			root.AppendChild(&ast.Node{Type: ast.NodeLinkDest, Tokens: []byte(imageAsset)})
			root.AppendChild(&ast.Node{Type: ast.NodeLinkDest, Tokens: []byte(pdfAsset)})
			root.AppendChild(&ast.Node{Type: ast.NodeVideo, Tokens: []byte(`<video src="` + videoAsset + `"></video>`)})
			root.AppendChild(&ast.Node{Type: ast.NodeAudio, Tokens: []byte(`<audio src="` + audioAsset + `"></audio>`)})
			root.AppendChild(&ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="` + iframeAsset + `"></iframe>`)})

			assetsOldNew, assetsNewOld := map[string]string{}, map[string]string{}
			tree := &parse.Tree{Root: root}
			removeAssetsID(tree, assetsOldNew, assetsNewOld, Conf.Export.Load().RemoveAssetsID)

			assets := getAssetsLinkDests(root, false)
			if len(assets) != len(test.expected) {
				t.Fatalf("got %d rendered assets, want %d", len(assets), len(test.expected))
			}
			for _, asset := range assets {
				oldAsset, newAsset := resolveExportAssetPaths(asset, assetsOldNew, assetsNewOld)
				expected, ok := test.expected[asset]
				if !ok {
					t.Fatalf("unexpected rendered asset [%s]", asset)
				}
				if oldAsset != expected[0] || newAsset != expected[1] {
					t.Fatalf("resolve asset [%s]: got [%s, %s], want [%s, %s]",
						asset, oldAsset, newAsset, expected[0], expected[1])
				}
			}
			if test.removeID {
				oldAsset, newAsset := resolveExportAssetPaths(iframeAsset, assetsOldNew, assetsNewOld)
				if oldAsset != iframeAsset || newAsset != "assets/frame file.html" {
					t.Fatalf("original HTML URL must still resolve through the rename map: %s, %s", oldAsset, newAsset)
				}
			}
		})
	}
}

func TestExportHTMLMultipleAssetReferences(t *testing.T) {
	setupAppearancePackagesTest(t)
	fixture := setupFileOperationTest(t)
	originalWorkspaceDir := util.WorkspaceDir
	util.WorkspaceDir = filepath.Dir(util.DataDir)
	t.Cleanup(func() { util.WorkspaceDir = originalWorkspaceDir })
	Conf.Editor.Store(conf.NewEditor())
	Conf.Export.Store(conf.NewExport())
	Conf.Appearance.Store(conf.NewAppearance())
	Conf.Search.Store(conf.NewSearch())
	Conf.System.Store(conf.NewSystem())
	assetsDir := filepath.Join(util.DataDir, "assets")
	if err := os.MkdirAll(assetsDir, 0755); err != nil {
		t.Fatal(err)
	}
	names := []string{"first.png", "second.png", "file.pdf", "a&b.png"}
	for _, name := range names {
		if err := os.WriteFile(filepath.Join(assetsDir, name), []byte(name), 0644); err != nil {
			t.Fatal(err)
		}
	}
	tree := addFileOperationTestDoc(t, fixture, "20260918000001-abcdefg", "HTML assets", false)
	tree.Root.AppendChild(&ast.Node{Type: ast.NodeHTMLBlock, Tokens: []byte(`<div><img src="assets/first.png"><img src="assets/second.png"><a href="assets/file.pdf">download</a><img src="assets/a&amp;b.png"></div>`)})
	if _, err := filesys.WriteTree(tree); err != nil {
		t.Fatal(err)
	}
	savePath := t.TempDir()
	if _, _, err := exportMarkdownHTML(tree.ID, savePath, false, false); err != nil {
		t.Fatal(err)
	}
	for _, name := range names {
		if data, err := os.ReadFile(filepath.Join(savePath, "assets", name)); err != nil || string(data) != name {
			t.Fatalf("export omitted %s: %q, %v", name, data, err)
		}
	}
}

func TestExportAssetEntityRename(t *testing.T) {
	originalConf := Conf
	t.Cleanup(func() { Conf = originalConf })
	Conf = NewAppConf()
	Conf.Export.Store(conf.NewExport())
	for _, removeID := range []bool{false, true} {
		Conf.Export.Load().RemoveAssetsID = removeID
		for _, typ := range []ast.NodeType{ast.NodeHTMLBlock, ast.NodeInlineHTML, ast.NodeIFrame, ast.NodeAudio, ast.NodeVideo} {
			markup := `<video src='assets/a&amp;b-20260724150608-42z1qwz.webm?x=1&#38;y=2#part' poster="assets/a&amp;amp;b-20260724150608-42z1qwz.png"><source src=assets/second-20260724150608-42z1qwz.webm></video>`
			root := &ast.Node{Type: ast.NodeDocument}
			node := &ast.Node{Type: typ, Tokens: []byte(markup)}
			root.AppendChild(node)
			oldNew, newOld := map[string]string{}, map[string]string{}
			removeAssetsID(&parse.Tree{Root: root}, oldNew, newOld, Conf.Export.Load().RemoveAssetsID)
			original := []string{"assets/a&b-20260724150608-42z1qwz.webm?x=1&y=2#part", "assets/a&amp;b-20260724150608-42z1qwz.png", "assets/second-20260724150608-42z1qwz.webm"}
			want := append([]string(nil), original...)
			if removeID {
				for i := range want {
					want[i] = strings.ReplaceAll(want[i], "-20260724150608-42z1qwz", "")
				}
			}
			if got := htmlAssetLinkDests(node.Tokens, false); !reflect.DeepEqual(got, want) {
				t.Fatalf("node %v removeID=%v: %v, want %v", typ, removeID, got, want)
			}
			markdown := "before\n\n" + markup + "\n\nafter\n"
			rewritten := rewriteExportMarkdownAssets(markdown, oldNew)
			if got := htmlAssetLinkDests([]byte(rewritten), false); !reflect.DeepEqual(got, want) {
				t.Fatalf("Markdown %v removeID=%v: %s, references %v, want %v", typ, removeID, rewritten, got, want)
			}
			if !removeID && rewritten != markdown {
				t.Fatalf("disabled renaming changed source HTML: %s", rewritten)
			}
			for i, dest := range want {
				oldPath, newPath := resolveExportAssetPaths(dest, oldNew, newOld)
				if oldPath != original[i] || newPath != dest {
					t.Fatalf("copied asset and rendered URL differ: %s, %s, want %s, %s", oldPath, newPath, original[i], dest)
				}
			}
		}
	}
}

func TestProcessHTMLFileIFrame(t *testing.T) {
	root := &ast.Node{Type: ast.NodeDocument}
	component := &ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="assets/component.html?iframe=true"></iframe>`)}
	legacyComponent := &ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="assets/legacy.html"></iframe>`)}
	external := &ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="https://example.com/component.html?iframe=true"></iframe>`)}
	nonHTML := &ast.Node{Type: ast.NodeIFrame, Tokens: []byte(`<iframe src="assets/component.svg?iframe=true"></iframe>`)}
	root.AppendChild(component)
	root.AppendChild(legacyComponent)
	root.AppendChild(external)
	root.AppendChild(nonHTML)

	processHTMLFileIFrame(&parse.Tree{Root: root})

	if component.Type != ast.NodeParagraph || component.FirstChild == nil || component.FirstChild.Type != ast.NodeLink {
		t.Fatalf("HTML file IFrame was not converted to a link: %#v", component)
	}
	if legacyComponent.Type != ast.NodeParagraph || legacyComponent.FirstChild == nil || legacyComponent.FirstChild.Type != ast.NodeLink {
		t.Fatalf("legacy HTML file IFrame was not converted to a link: %#v", legacyComponent)
	}
	if external.Type != ast.NodeIFrame || external.FirstChild != nil {
		t.Fatalf("external IFrame must remain unchanged: %#v", external)
	}
	if nonHTML.Type != ast.NodeIFrame || nonHTML.FirstChild != nil {
		t.Fatalf("non-HTML IFrame must remain unchanged: %#v", nonHTML)
	}
}