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 server
import (
"bytes"
"image"
"image/color"
"image/png"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/dejavu"
"github.com/siyuan-note/dejavu/entity"
"github.com/siyuan-note/siyuan/kernel/conf"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/tiffpreview"
"github.com/siyuan-note/siyuan/kernel/util"
"golang.org/x/image/tiff"
)
func tiffSource(t *testing.T) []byte {
t.Helper()
img := image.NewGray16(image.Rect(0, 0, 3, 1))
for x, value := range []uint16{120, 1960, 3800} {
img.SetGray16(x, 0, color.Gray16{Y: value})
}
var buffer bytes.Buffer
if err := tiff.Encode(&buffer, img, &tiff.Options{Compression: tiff.Deflate}); err != nil {
t.Fatal(err)
}
return buffer.Bytes()
}
func tiffTestEngine(t *testing.T) *gin.Engine {
t.Helper()
originalData, originalTemp, originalHistory, originalConf := util.DataDir, util.TempDir, util.HistoryDir, model.Conf
originalWorkspace := util.WorkspaceDir
originalRepo, originalConfDir := util.RepoDir, util.ConfDir
root := filepath.Join(t.TempDir(), "notes#1")
util.WorkspaceDir = root
util.DataDir, util.TempDir, util.HistoryDir = filepath.Join(root, "data"), filepath.Join(root, "temp"), filepath.Join(root, "history")
util.RepoDir, util.ConfDir = filepath.Join(root, "repo"), filepath.Join(root, "conf")
model.Conf = model.NewAppConf()
t.Cleanup(func() {
util.DataDir, util.TempDir, util.HistoryDir, model.Conf = originalData, originalTemp, originalHistory, originalConf
util.WorkspaceDir = originalWorkspace
util.RepoDir, util.ConfDir = originalRepo, originalConfDir
})
engine := gin.New()
engine.Use(func(c *gin.Context) {
c.Set(model.RoleContextKey, model.RoleAdministrator)
c.Next()
})
serveAssets(engine)
serveRepoDiff(engine)
return engine
}
// openTIFFSnapshots 从真实仓库文件元数据走快照预览生产链路,不预先构造临时预览文件。
func openTIFFSnapshots(t *testing.T, paths ...string) map[string]string {
t.Helper()
model.Conf.Repo.Store(conf.NewRepo())
model.Conf.Repo.Load().Key = []byte("0123456789abcdef0123456789abcdef")
if model.Conf.System.Load() == nil {
model.Conf.System.Store(conf.NewSystem())
}
if model.Conf.Sync.Load() == nil {
model.Conf.Sync.Store(conf.NewSync())
}
model.Conf.Sync.Load().Provider = conf.ProviderLocal
model.Conf.Sync.Load().Local = &conf.Local{Endpoint: filepath.Join(util.WorkspaceDir, "cloud")}
model.Conf.Sync.Load().CloudName = "tiff-test"
util.RepoDir = filepath.Join(util.WorkspaceDir, "repo")
for _, directory := range []string{util.ConfDir, util.TempDir, util.HistoryDir} {
if err := os.MkdirAll(directory, 0700); err != nil {
t.Fatal(err)
}
}
repo, err := dejavu.NewRepo(util.DataDir, util.RepoDir, util.HistoryDir, util.TempDir,
"tiff-test", "tiff-test", "windows", model.Conf.Repo.Load().Key, nil, nil)
if err != nil {
t.Fatal(err)
}
index, err := repo.Index("TIFF preview", true, nil)
if err != nil {
t.Fatal(err)
}
files := map[string]string{}
if err = repo.GetFilesIter(index, func(file *entity.File) error {
files[strings.TrimPrefix(file.Path, "/")] = file.ID
return nil
}); err != nil {
t.Fatal(err)
}
previews := map[string]string{}
for _, path := range paths {
id := files[path]
if id == "" {
t.Fatalf("TIFF missing from snapshot: %s", path)
}
_, content, _, _, err := model.OpenRepoSnapshotFile(id)
if err != nil {
t.Fatal(err)
}
if content != "repo/diff/"+path {
t.Fatalf("TIFF snapshot preview missing: %q", content)
}
previews[path] = "/" + content
}
return previews
}
func TestServeTIFFRealRepoSnapshots(t *testing.T) {
engine := tiffTestEngine(t)
source := tiffSource(t)
paths := []string{"assets/image.tif", "assets/image.TIFF"}
for _, path := range paths {
writeTIFFTestFile(t, filepath.Join(util.DataDir, filepath.FromSlash(path)), source)
}
previews := openTIFFSnapshots(t, paths...)
for _, path := range paths {
staged, err := os.ReadFile(filepath.Join(util.TempDir, "repo", "diff", filepath.FromSlash(path)))
if err != nil || !bytes.Equal(staged, source) {
t.Fatalf("snapshot preview source was not staged: %v", err)
}
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, previews[path], nil))
assertTIFFPreview(t, recorder)
}
}
func TestServeTIFFWorkspaceWithHash(t *testing.T) {
engine := tiffTestEngine(t)
if !strings.Contains(util.WorkspaceDir, "#") {
t.Fatal("test workspace must contain a hash")
}
source := tiffSource(t)
for _, test := range []struct{ url, path string }{
{"/assets/image.tif", filepath.Join(util.DataDir, "assets", "image.tif")},
{"/history/2026-10-21-120000-update/assets/image.tif", filepath.Join(util.HistoryDir, "2026-10-21-120000-update", "assets", "image.tif")},
{"/repo/diff/assets/image.tif", filepath.Join(util.TempDir, "repo", "diff", "assets", "image.tif")},
} {
writeTIFFTestFile(t, test.path, source)
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, test.url+"?style=thumb", nil))
assertTIFFPreview(t, recorder)
}
}
func writeTIFFTestFile(t *testing.T, path string, data []byte) {
t.Helper()
if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, data, 0600); err != nil {
t.Fatal(err)
}
}
func assertTIFFPreview(t *testing.T, recorder *httptest.ResponseRecorder) {
t.Helper()
if recorder.Code != http.StatusOK || recorder.Header().Get("Content-Type") != "image/png" {
t.Fatalf("preview returned %d, %s", recorder.Code, recorder.Header().Get("Content-Type"))
}
img, err := png.Decode(bytes.NewReader(recorder.Body.Bytes()))
if err != nil {
t.Fatal(err)
}
if img.Bounds() != image.Rect(0, 0, 3, 1) {
t.Fatalf("preview bounds = %v", img.Bounds())
}
if got := color.GrayModel.Convert(img.At(2, 0)).(color.Gray).Y; got != 255 {
t.Fatalf("16-bit preview remains dark: brightest pixel = %d", got)
}
}
func TestServeTIFFRoutesPreviewAndOriginalDownload(t *testing.T) {
engine := tiffTestEngine(t)
// 超过通用缩略图阈值,验证 download 与 style=thumb 同时出现时仍下载原件。
source := append(tiffSource(t), make([]byte, 1024*1024)...)
for _, test := range []struct{ url, path string }{
{"/assets/image.TIF", filepath.Join(util.DataDir, "assets", "image.TIF")},
{"/history/2026-10-21-120000-update/assets/image.tiff", filepath.Join(util.HistoryDir, "2026-10-21-120000-update", "assets", "image.tiff")},
{"/repo/diff/assets/image.tif", filepath.Join(util.TempDir, "repo", "diff", "assets", "image.tif")},
} {
t.Run(test.url, func(t *testing.T) {
writeTIFFTestFile(t, test.path, source)
var etag string
for _, query := range []string{"", "?style=thumb"} {
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, test.url+query, nil))
assertTIFFPreview(t, recorder)
if recorder.Header().Get("X-Content-Type-Options") != "nosniff" {
t.Fatal("missing nosniff header")
}
if query == "" {
etag = recorder.Header().Get("ETag")
}
}
if etag == "" {
t.Fatal("missing preview ETag")
}
request := httptest.NewRequest(http.MethodGet, test.url, nil)
request.Header.Set("If-None-Match", etag)
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, request)
if recorder.Code != http.StatusNotModified {
t.Fatalf("cached preview = %d", recorder.Code)
}
for _, query := range []string{"?download=true", "?style=thumb&download=TRUE"} {
recorder = httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, test.url+query, nil))
if recorder.Code != http.StatusOK || !bytes.Equal(recorder.Body.Bytes(), source) {
t.Fatalf("original download changed: status %d", recorder.Code)
}
}
preserved, err := os.ReadFile(test.path)
if err != nil || !bytes.Equal(preserved, source) {
t.Fatal("preview rewrote the source TIFF")
}
})
}
}
func TestServeTIFFRejectsCorruptAndOversizedSources(t *testing.T) {
engine := tiffTestEngine(t)
path := filepath.Join(util.DataDir, "assets", "bad.tif")
writeTIFFTestFile(t, path, []byte("corrupt TIFF"))
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/assets/bad.tif", nil))
if recorder.Code != http.StatusUnprocessableEntity {
t.Fatalf("corrupt preview = %d", recorder.Code)
}
file, err := os.OpenFile(path, os.O_WRONLY, 0600)
if err != nil {
t.Fatal(err)
}
err = file.Truncate(tiffpreview.MaxInputBytes + 1)
file.Close()
if err != nil {
t.Fatal(err)
}
recorder = httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/assets/bad.tif", nil))
if recorder.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("oversized preview = %d", recorder.Code)
}
}
func TestServeTIFFLockedNotebook(t *testing.T) {
engine := tiffTestEngine(t)
const boxID = "20261021000000-tifflck"
writeTIFFTestFile(t, filepath.Join(util.DataDir, boxID, ".siyuan", "conf.json"), []byte(`{"encrypted":true}`))
writeTIFFTestFile(t, filepath.Join(util.DataDir, boxID, "assets", "image.tif"), []byte("SYAE"))
writeTIFFTestFile(t, filepath.Join(util.HistoryDir, "2026-10-21-120000-update", boxID, "assets", "image.tif"), []byte("SYAE"))
writeTIFFTestFile(t, filepath.Join(util.TempDir, "repo", "diff", boxID, "assets", "image.tif"), []byte("SYAE"))
for _, url := range []string{
"/assets/image.tif?box=" + boxID,
"/history/2026-10-21-120000-update/" + boxID + "/assets/image.tif",
"/repo/diff/" + boxID + "/assets/image.tif",
} {
recorder := httptest.NewRecorder()
engine.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, url, nil))
if recorder.Code != http.StatusForbidden {
t.Fatalf("locked notebook GET %s = %d", url, recorder.Code)
}
}
if _, err := os.Stat(filepath.Join(util.TempDir, "assets-cache", "tiff")); !os.IsNotExist(err) {
t.Fatal("locked notebook created a preview cache")
}
}