Sakurasan
5dfa1550fb
social_links 以 JSON 数组存进 settings KV（[{label,url}]），解码容错：
空串 / 坏 JSON / 缺 label 或 url 的条目一律丢弃，前台拿到空数组时区块
自动隐藏。custom_js 原样存取——它是站主自己的代码（统计脚本等），
做转义只会把脚本洗坏。后台表单与前台展示在下一笔前端提交里。
493 lines
13 KiB
Go
493 lines
13 KiB
Go
package store
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"oneblog/internal/db"
|
|
"oneblog/internal/model"
|
|
)
|
|
|
|
func TestSlugify(t *testing.T) {
|
|
cases := map[string]string{
|
|
"Hello World": "hello-world",
|
|
" Rebuild ONE ": "rebuild-one",
|
|
"Go 语言 / 2026": "go-语言-2026",
|
|
"!!!": "",
|
|
}
|
|
for in, want := range cases {
|
|
if got := Slugify(in); got != want {
|
|
t.Errorf("Slugify(%q) = %q, want %q", in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListOptionsRebind(t *testing.T) {
|
|
// 列表查询的占位符数量必须和参数数量一致，否则在 PostgreSQL 上会直接报错
|
|
d := &db.DB{Dialect: db.Postgres}
|
|
q := d.Q(`SELECT id FROM posts WHERE kind = ? AND status = ? AND title LIKE ? LIMIT ? OFFSET ?`)
|
|
if strings.Count(q, "$") != 5 {
|
|
t.Errorf("expected 5 placeholders, got %q", q)
|
|
}
|
|
}
|
|
|
|
func TestPostInputDefaults(t *testing.T) {
|
|
in := model.PostInput{Kind: model.KindShort, ContentMd: "一句话。"}
|
|
if in.Kind != "short" {
|
|
t.Errorf("kind = %q", in.Kind)
|
|
}
|
|
if in.Status != "" {
|
|
t.Errorf("empty status means draft is applied by the API layer, got %q", in.Status)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeStatus(t *testing.T) {
|
|
cases := map[string]string{
|
|
"": model.StatusDraft,
|
|
"draft": model.StatusDraft,
|
|
"published": model.StatusPublished,
|
|
" Published ": model.StatusPublished,
|
|
"pending": model.StatusDraft, // unknown → draft
|
|
}
|
|
for in, want := range cases {
|
|
if got := NormalizeStatus(in); got != want {
|
|
t.Errorf("NormalizeStatus(%q) = %q, want %q", in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRebindBulk(t *testing.T) {
|
|
// BulkUpdateStatus uses an IN clause with len(ids) placeholders + 1 for status.
|
|
d := &db.DB{Dialect: db.Postgres}
|
|
q := d.Q(`UPDATE posts SET status=? WHERE id IN (?,?,?)`)
|
|
if got := strings.Count(q, "$"); got != 4 {
|
|
t.Errorf("expected 4 placeholders, got %d", got)
|
|
}
|
|
}
|
|
|
|
func TestSettingsThemeID(t *testing.T) {
|
|
s := openTestStore(t)
|
|
|
|
st, err := s.GetSettings()
|
|
if err != nil {
|
|
t.Fatalf("get: %v", err)
|
|
}
|
|
if st.LightSkinID != "paper" {
|
|
t.Errorf("default light_skin_id should be 'paper', got %q", st.LightSkinID)
|
|
}
|
|
|
|
st.LightSkinID = "sage"
|
|
st.SiteTitle = "ONE"
|
|
if err := s.UpdateSettings(st); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
got, err := s.GetSettings()
|
|
if err != nil {
|
|
t.Fatalf("get again: %v", err)
|
|
}
|
|
if got.LightSkinID != "sage" {
|
|
t.Errorf("light_skin_id should persist, got %q", got.LightSkinID)
|
|
}
|
|
if got.ThemeID != "sage" {
|
|
t.Errorf("legacy theme_id should mirror light_skin_id, got %q", got.ThemeID)
|
|
}
|
|
if got.SiteTitle != "ONE" {
|
|
t.Errorf("site_title should persist, got %q", got.SiteTitle)
|
|
}
|
|
}
|
|
|
|
func TestSettingsLightSkinFallback(t *testing.T) {
|
|
s := openTestStore(t)
|
|
// Simulate an older DB that only has theme_id set.
|
|
if _, err := s.db.Exec(s.db.Q(`INSERT INTO settings(key,value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`),
|
|
"theme_id", "rose"); err != nil {
|
|
t.Fatalf("seed theme_id: %v", err)
|
|
}
|
|
st, err := s.GetSettings()
|
|
if err != nil {
|
|
t.Fatalf("get: %v", err)
|
|
}
|
|
if st.LightSkinID != "rose" {
|
|
t.Errorf("expected fallback to 'rose' from legacy theme_id, got %q", st.LightSkinID)
|
|
}
|
|
}
|
|
|
|
func TestSettingsUIFallback(t *testing.T) {
|
|
s := openTestStore(t)
|
|
|
|
st, err := s.GetSettings()
|
|
if err != nil {
|
|
t.Fatalf("get: %v", err)
|
|
}
|
|
if st.UIID != UIClassic {
|
|
t.Errorf("default ui_id should be %q, got %q", UIClassic, st.UIID)
|
|
}
|
|
if st.CustomCSS == nil {
|
|
t.Error("CustomCSS should never be nil")
|
|
}
|
|
|
|
// An unknown ui_id is coerced to the default on write.
|
|
st.UIID = "bogus"
|
|
if err := s.UpdateSettings(st); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
got, _ := s.GetSettings()
|
|
if got.UIID != UIClassic {
|
|
t.Errorf("bogus ui_id should fall back to %q, got %q", UIClassic, got.UIID)
|
|
}
|
|
|
|
// A valid one persists.
|
|
st.UIID = UIVivid
|
|
if err := s.UpdateSettings(st); err != nil {
|
|
t.Fatalf("update again: %v", err)
|
|
}
|
|
got, _ = s.GetSettings()
|
|
if got.UIID != UIVivid {
|
|
t.Errorf("ui_id should persist, got %q", got.UIID)
|
|
}
|
|
}
|
|
|
|
func TestSettingsUIFallbackOnRead(t *testing.T) {
|
|
s := openTestStore(t)
|
|
// A hand-edited / legacy row must not leak an unknown UI to clients.
|
|
if _, err := s.db.Exec(s.db.Q(`INSERT INTO settings(key,value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`),
|
|
"ui_id", "neon"); err != nil {
|
|
t.Fatalf("seed ui_id: %v", err)
|
|
}
|
|
st, err := s.GetSettings()
|
|
if err != nil {
|
|
t.Fatalf("get: %v", err)
|
|
}
|
|
if st.UIID != UIClassic {
|
|
t.Errorf("expected read-side fallback to %q, got %q", UIClassic, st.UIID)
|
|
}
|
|
}
|
|
|
|
func TestSettingsCustomCSSRoundTrip(t *testing.T) {
|
|
s := openTestStore(t)
|
|
|
|
// Seeding a raw row with an unknown section + a valid one.
|
|
if _, err := s.db.Exec(s.db.Q(`INSERT INTO settings(key,value) VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`),
|
|
"custom_css", `{"home":"body{--v-accent:#f0f}","bogus":"x{}"}`); err != nil {
|
|
t.Fatalf("seed custom_css: %v", err)
|
|
}
|
|
st, _ := s.GetSettings()
|
|
if st.CustomCSS["home"] != "body{--v-accent:#f0f}" {
|
|
t.Errorf("home css not read back: %+v", st.CustomCSS)
|
|
}
|
|
if _, ok := st.CustomCSS["bogus"]; ok {
|
|
t.Error("unknown section should be dropped on read")
|
|
}
|
|
|
|
// Write side: unknown sections dropped, XML-hostile chars survive, nil clears.
|
|
st.CustomCSS = map[string]string{
|
|
"home": `a::after{content:"<&>"}`,
|
|
"bogus": "x{}",
|
|
}
|
|
if err := s.UpdateSettings(st); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
got, _ := s.GetSettings()
|
|
if got.CustomCSS["home"] != `a::after{content:"<&>"}` {
|
|
t.Errorf("css mangled in round trip: %q", got.CustomCSS["home"])
|
|
}
|
|
if len(got.CustomCSS) != 1 {
|
|
t.Errorf("unknown section should be dropped on write, got %+v", got.CustomCSS)
|
|
}
|
|
|
|
// A nil map is a full clear, and still comes back as a non-nil empty map.
|
|
got.CustomCSS = nil
|
|
if err := s.UpdateSettings(got); err != nil {
|
|
t.Fatalf("clear: %v", err)
|
|
}
|
|
after, _ := s.GetSettings()
|
|
if after.CustomCSS == nil {
|
|
t.Error("CustomCSS should be non-nil after clearing")
|
|
}
|
|
if len(after.CustomCSS) != 0 {
|
|
t.Errorf("expected cleared map, got %+v", after.CustomCSS)
|
|
}
|
|
}
|
|
|
|
func TestSettingsCustomCSSOverLongSectionDropped(t *testing.T) {
|
|
s := openTestStore(t)
|
|
st, _ := s.GetSettings()
|
|
st.CustomCSS = map[string]string{
|
|
"home": strings.Repeat("a", maxSectionCSSBytes+1),
|
|
"about": "b{color:red}",
|
|
}
|
|
if err := s.UpdateSettings(st); err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
got, _ := s.GetSettings()
|
|
if _, ok := got.CustomCSS["home"]; ok {
|
|
t.Error("over-long section should be dropped")
|
|
}
|
|
if got.CustomCSS["about"] != "b{color:red}" {
|
|
t.Errorf("valid section should survive, got %+v", got.CustomCSS)
|
|
}
|
|
}
|
|
|
|
// TestStoreSQLite runs a small integration pass on top of an in-memory SQLite
|
|
// database to exercise the new fields (cover_url, tag color) and the merge
|
|
// + bulk + dashboard paths.
|
|
func TestStoreSQLite(t *testing.T) {
|
|
s := openTestStore(t)
|
|
|
|
p1, err := s.Create(model.PostInput{
|
|
Kind: model.KindLong,
|
|
Title: "第一篇",
|
|
Slug: "first",
|
|
Summary: "first summary",
|
|
CoverURL: "https://example.com/a.png",
|
|
ContentMd: "# hi\n这是一段正文。",
|
|
Status: model.StatusPublished,
|
|
Tags: []string{"Go", "博客"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create p1: %v", err)
|
|
}
|
|
if p1.CoverURL == "" {
|
|
t.Errorf("cover_url not persisted")
|
|
}
|
|
if len(p1.Tags) != 2 {
|
|
t.Errorf("expected 2 tags, got %v", p1.Tags)
|
|
}
|
|
|
|
p2, err := s.Create(model.PostInput{
|
|
Kind: model.KindShort, ContentMd: "碎片想法。", Status: model.StatusDraft,
|
|
Tags: []string{"碎片"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create p2: %v", err)
|
|
}
|
|
|
|
// Update cover_url and tags. Frontend sends the current CoverURL back so
|
|
// the value is preserved across updates.
|
|
upd, err := s.Update(p1.ID, model.PostInput{
|
|
Kind: model.KindLong, Title: "第一篇",
|
|
CoverURL: p1.CoverURL,
|
|
ContentMd: "# hi\n这是新版本。",
|
|
Tags: []string{"Go"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("update: %v", err)
|
|
}
|
|
if upd.CoverURL != p1.CoverURL {
|
|
t.Errorf("cover_url not preserved when echoed back, got %q", upd.CoverURL)
|
|
}
|
|
|
|
// An empty CoverURL is treated as an explicit clear.
|
|
upd2, err := s.Update(p1.ID, model.PostInput{
|
|
Kind: model.KindLong, Title: "第一篇", CoverURL: "",
|
|
Tags: []string{"Go"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("update clear: %v", err)
|
|
}
|
|
if upd2.CoverURL != "" {
|
|
t.Errorf("empty cover_url should clear, got %q", upd2.CoverURL)
|
|
}
|
|
// restore for downstream tests
|
|
if _, err := s.Update(p1.ID, model.PostInput{
|
|
Kind: model.KindLong, Title: "第一篇", CoverURL: p1.CoverURL,
|
|
Tags: []string{"Go"},
|
|
}); err != nil {
|
|
t.Fatalf("restore: %v", err)
|
|
}
|
|
|
|
if len(upd.Tags) != 1 || upd.Tags[0] != "Go" {
|
|
t.Errorf("tags after update: %v", upd.Tags)
|
|
}
|
|
|
|
// BulkUpdateStatus flips drafts to published
|
|
n, err := s.BulkUpdateStatus([]int64{p2.ID}, model.StatusPublished)
|
|
if err != nil {
|
|
t.Fatalf("bulk: %v", err)
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("expected 1 updated, got %d", n)
|
|
}
|
|
|
|
// Tag merge: create two distinct slug tags, attach both to p1, merge.
|
|
if _, err := s.UpdateTag(0, "", ""); err == nil {
|
|
t.Errorf("expected error for empty name")
|
|
}
|
|
tags, err := s.ListTags()
|
|
if err != nil {
|
|
t.Fatalf("list tags: %v", err)
|
|
}
|
|
var goID int64
|
|
for _, tg := range tags {
|
|
if tg.Name == "Go" {
|
|
goID = tg.ID
|
|
}
|
|
}
|
|
if goID == 0 {
|
|
t.Fatalf("Go tag not found")
|
|
}
|
|
// Give the surviving target tag a color so we can confirm it sticks.
|
|
if _, err := s.UpdateTag(goID, "Go", "#3d7f9c"); err != nil {
|
|
t.Fatalf("color target: %v", err)
|
|
}
|
|
// CreateTagFull uses upsertTag so "GoLang" with its own slug is a fresh row.
|
|
golang, err := s.CreateTagFull("GoLang", "")
|
|
if err != nil {
|
|
t.Fatalf("create golang: %v", err)
|
|
}
|
|
if _, err := s.db.Exec(s.db.Q(`INSERT INTO post_tags(post_id, tag_id) VALUES (?, ?)`), p1.ID, golang.ID); err != nil {
|
|
t.Fatalf("attach golang: %v", err)
|
|
}
|
|
merged, err := s.MergeTags(golang.ID, goID)
|
|
if err != nil {
|
|
t.Fatalf("merge: %v", err)
|
|
}
|
|
if merged.ID != goID {
|
|
t.Errorf("merge should return target tag, got %d want %d", merged.ID, goID)
|
|
}
|
|
if merged.Color != "#3d7f9c" {
|
|
t.Errorf("target tag color lost, got %q", merged.Color)
|
|
}
|
|
|
|
// Dashboard
|
|
d, err := s.Dashboard()
|
|
if err != nil {
|
|
t.Fatalf("dashboard: %v", err)
|
|
}
|
|
if d.TotalPosts != 2 {
|
|
t.Errorf("total_posts = %d", d.TotalPosts)
|
|
}
|
|
if d.PublishedPosts != 2 {
|
|
t.Errorf("published_posts = %d", d.PublishedPosts)
|
|
}
|
|
if len(d.RecentPosts) == 0 {
|
|
t.Errorf("recent posts empty")
|
|
}
|
|
if len(d.TopTags) == 0 {
|
|
t.Errorf("top tags empty")
|
|
}
|
|
}
|
|
|
|
func openTestStore(t *testing.T) *Store {
|
|
t.Helper()
|
|
d, err := db.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatalf("open sqlite: %v", err)
|
|
}
|
|
s, err := New(d)
|
|
if err != nil {
|
|
t.Fatalf("new store: %v", err)
|
|
}
|
|
return s
|
|
}
|
|
|
|
func TestSanitizeOrder(t *testing.T) {
|
|
if got := sanitizeOrder("published_at ASC"); got != "published_at asc" {
|
|
t.Errorf("whitelisted order rejected: %q", got)
|
|
}
|
|
for _, bad := range []string{
|
|
"published_at DESC; DROP TABLE posts; --",
|
|
"(SELECT 1) DESC",
|
|
"1 DESC",
|
|
"published_at DESC, (SELECT COUNT(*) FROM sqlite_master) ASC",
|
|
} {
|
|
if got := sanitizeOrder(bad); got != "published_at desc" {
|
|
t.Errorf("sanitizeOrder(%q) = %q, want fallback", bad, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestListWithMaliciousOrderByFailsSafe(t *testing.T) {
|
|
s := openTestStore(t)
|
|
page, err := s.List(ListOptions{Status: "any", OrderBy: "published_at DESC; DROP TABLE posts; --"})
|
|
if err != nil {
|
|
t.Fatalf("List: %v", err)
|
|
}
|
|
if page.Total != 0 {
|
|
t.Errorf("unexpected total %d", page.Total)
|
|
}
|
|
}
|
|
|
|
func TestProjectCRUD(t *testing.T) {
|
|
s := openTestStore(t)
|
|
|
|
// empty list is a non-nil slice
|
|
list, err := s.ListProjects("")
|
|
if err != nil {
|
|
t.Fatalf("ListProjects: %v", err)
|
|
}
|
|
if list == nil {
|
|
t.Fatal("ListProjects returned nil slice")
|
|
}
|
|
|
|
created, err := s.CreateProject(model.ProjectInput{
|
|
Title: "Folo",
|
|
Summary: "This AI RSS reader reads the internet for you",
|
|
CoverURL: "https://folo.is/cover.webp",
|
|
URL: "https://folo.is",
|
|
RepoURL: "https://github.com/DIYgod/RSSHub-Radar",
|
|
Status: model.StatusPublished,
|
|
Position: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateProject: %v", err)
|
|
}
|
|
if created.ID == 0 {
|
|
t.Fatal("created project has no ID")
|
|
}
|
|
if created.Slug != "folo" {
|
|
t.Errorf("slug = %q, want folo", created.Slug)
|
|
}
|
|
|
|
// duplicate slug gets disambiguated
|
|
dup, err := s.CreateProject(model.ProjectInput{Title: "Folo", Status: model.StatusPublished})
|
|
if err != nil {
|
|
t.Fatalf("CreateProject dup: %v", err)
|
|
}
|
|
if dup.Slug == created.Slug {
|
|
t.Errorf("duplicate slug not disambiguated: %q", dup.Slug)
|
|
}
|
|
|
|
// public list excludes drafts; admin ("") includes them
|
|
draft, err := s.CreateProject(model.ProjectInput{Title: "Secret", Status: model.StatusDraft})
|
|
if err != nil {
|
|
t.Fatalf("CreateProject draft: %v", err)
|
|
}
|
|
pub, _ := s.ListProjects(model.StatusPublished)
|
|
if len(pub) != 2 {
|
|
t.Errorf("published list len = %d, want 2", len(pub))
|
|
}
|
|
all, _ := s.ListProjects("")
|
|
if len(all) != 3 {
|
|
t.Errorf("all list len = %d, want 3", len(all))
|
|
}
|
|
|
|
// update
|
|
upd, err := s.UpdateProject(created.ID, model.ProjectInput{Summary: "Updated summary", Position: 1})
|
|
if err != nil {
|
|
t.Fatalf("UpdateProject: %v", err)
|
|
}
|
|
if upd.Summary != "Updated summary" || upd.Position != 1 {
|
|
t.Errorf("update did not apply: %+v", upd)
|
|
}
|
|
|
|
// get
|
|
got, err := s.GetProject(draft.ID)
|
|
if err != nil {
|
|
t.Fatalf("GetProject: %v", err)
|
|
}
|
|
if got.Status != model.StatusDraft {
|
|
t.Errorf("status = %q, want draft", got.Status)
|
|
}
|
|
|
|
// delete
|
|
if err := s.DeleteProject(created.ID); err != nil {
|
|
t.Fatalf("DeleteProject: %v", err)
|
|
}
|
|
_, err = s.GetProject(created.ID)
|
|
if !errors.Is(err, ErrNotFound) {
|
|
t.Errorf("after delete: got %v, want ErrNotFound", err)
|
|
}
|
|
}
|