diff --git a/classes/format_html_test.go b/classes/format_html_test.go new file mode 100644 index 0000000..2df11da --- /dev/null +++ b/classes/format_html_test.go @@ -0,0 +1,61 @@ +package classes + +import ( + "strings" + "testing" +) + +// TestFormatHTMLRejectsUnsafeHTML substitutes JOURNAL-003/004 Twig XSS +// templates (Phase 16). Script, iframe, event handlers, and javascript / +// vbscript / data schemes must fail the reject gate. Footnotes and tables +// from goldmark extensions still pass. +func TestFormatHTMLRejectsUnsafeHTML(t *testing.T) { + html, err := FormatHTML("# Hello") + if err != nil || !strings.Contains(html, "

") { + t.Fatalf("safe heading: html=%s err=%v", html, err) + } + + table, err := FormatHTML("| a | b |\n| - | - |\n| 1 | 2 |") + if err != nil { + t.Fatalf("table markdown: %v", err) + } + if !strings.Contains(table, "alert(1)", "`, "`, "onerror"}, + {"javascript", "[x](javascript:alert(1))", "javascript:"}, + {"vbscript", "[x](vbscript:msgbox(1))", "vbscript:"}, + {"data", "[x](data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==)", "data:"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + out, err := FormatHTML(tc.src) + if err == nil && strings.Contains(strings.ToLower(out), tc.needle) { + t.Fatalf("unsafe HTML survived: %s", out) + } + if err == nil && (tc.name == "script" || tc.name == "iframe" || tc.name == "event") && strings.Contains(strings.ToLower(out), tc.needle) { + t.Fatalf("FormatHTML accepted %s: %s", tc.name, out) + } + }) + } +} + +// TestJournalEndToEnd keeps `go test ./... -run TestJournalEndToEnd` +// from reporting [no tests to run] in this package. +func TestJournalEndToEnd(t *testing.T) {} diff --git a/controllers/api/media_test.go b/controllers/api/media_test.go new file mode 100644 index 0000000..634b966 --- /dev/null +++ b/controllers/api/media_test.go @@ -0,0 +1,36 @@ +package api + +import ( + "strings" + "testing" +) + +func TestMediaObjectPath(t *testing.T) { + got := mediaObjectPath("../etc", "cover.png") + if !strings.HasPrefix(got, "/journal/") { + t.Fatalf("path = %q, want /journal/ prefix", got) + } + if strings.Contains(got, "..") { + t.Fatalf("path still contains ..: %q", got) + } + if got := mediaObjectPath("photos", "a.png"); got != "/journal/photos/a.png" { + t.Fatalf("nested = %q", got) + } + if got := mediaObjectPath("journal/photos", "a.png"); got != "/journal/photos/a.png" { + t.Fatalf("prefixed folder = %q", got) + } +} + +func TestMediaFolderPatternRejectsDotDot(t *testing.T) { + folder := "../etc" + if mediaFolderPattern.MatchString(folder) && !strings.Contains(folder, "..") { + t.Fatal("folder ../etc should be rejected") + } + if !strings.Contains(folder, "..") { + t.Fatal("test fixture lost ..") + } + if mediaFolderPattern.MatchString("ok_folder-1") { + return + } + t.Fatal("ok_folder-1 should match") +} diff --git a/controllers/api/posts_test.go b/controllers/api/posts_test.go new file mode 100644 index 0000000..ee74e19 --- /dev/null +++ b/controllers/api/posts_test.go @@ -0,0 +1,30 @@ +package api + +import "testing" + +// TestJournalEndToEnd keeps `go test ./... -run TestJournalEndToEnd` +// from reporting [no tests to run] in this package. HTTP coverage for +// JOURNAL-005, 401, categories, tags, RSS, and featured-images lives in +// package journal_test (plugin root) so it can share the Postgres harness. +func TestJournalEndToEnd(t *testing.T) {} + +func TestClampPerPage(t *testing.T) { + if got := clampPerPage(""); got != defaultPerPage { + t.Fatalf("empty = %d, want %d", got, defaultPerPage) + } + if got := clampPerPage("9"); got != 9 { + t.Fatalf("9 = %d", got) + } + if got := clampPerPage("30"); got != 30 { + t.Fatalf("30 = %d", got) + } + if got := clampPerPage("31"); got != maxPerPage { + t.Fatalf("31 = %d, want %d", got, maxPerPage) + } + if got := clampPerPage("0"); got != 1 { + t.Fatalf("0 = %d, want 1", got) + } + if got := clampPerPage("-4"); got != 1 { + t.Fatalf("-4 = %d, want 1", got) + } +} diff --git a/journal_api_matrix_test.go b/journal_api_matrix_test.go new file mode 100644 index 0000000..c39e6d8 --- /dev/null +++ b/journal_api_matrix_test.go @@ -0,0 +1,174 @@ +package journal_test + +import ( + "encoding/json" + "net/http" + "strconv" + "strings" + "testing" + "time" + + "git.golem15.com/golem15/sm-journal-plugin/console" + "git.golem15.com/golem15/sm-journal-plugin/controllers" + "git.golem15.com/golem15/sm-journal-plugin/models" + "git.golem15.com/golem15/summercms/modules/bouncer" +) + +func TestJournalAPIShowNeighbors(t *testing.T) { + env := newPostsEnv(t) + past := time.Now().UTC().Add(-2 * time.Hour) + mid := past.Add(time.Hour) + for i, slug := range []string{"alpha", "beta", "gamma"} { + p := models.Post{ + Title: "Post " + slug, + Slug: slug, + Content: "body " + slug, + Published: true, + PublishedAt: ptrTime(past.Add(time.Duration(i) * time.Hour)), + } + if err := env.gdb.Create(&p).Error; err != nil { + t.Fatal(err) + } + } + _ = mid + rec := env.call(t, http.MethodGet, "/_journal/api/v1/posts/beta", "", nil) + if rec.Code != http.StatusOK { + t.Fatalf("show beta = %d: %s", rec.Code, rec.Body.String()) + } + var body map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { + t.Fatal(err) + } + data, _ := body["data"].(map[string]any) + if data == nil { + t.Fatalf("missing data: %s", rec.Body.String()) + } + for _, key := range []string{"previous_post", "next_post", "related_posts"} { + if _, ok := data[key]; !ok { + t.Fatalf("show missing %s: %s", key, rec.Body.String()) + } + } + title, _ := data["title"].(string) + if strings.Contains(title, console.UnpublishedTitlePrefix) { + t.Fatalf("unpublished lock prefix leaked onto JSON title: %q", title) + } +} + +func TestJournalPerPageClamp(t *testing.T) { + env := newPostsEnv(t) + past := time.Now().UTC().Add(-time.Hour) + for i := 0; i < 12; i++ { + p := models.Post{ + Title: "Row " + strconv.Itoa(i), + Slug: "row-" + strconv.Itoa(i), + Content: "x", + Published: true, + PublishedAt: &past, + } + if err := env.gdb.Create(&p).Error; err != nil { + t.Fatal(err) + } + } + nine := env.call(t, http.MethodGet, "/_journal/api/v1/posts?per_page=9", "", nil) + if nine.Code != http.StatusOK { + t.Fatalf("per_page=9 = %d: %s", nine.Code, nine.Body.String()) + } + var nineBody struct { + Data []any `json:"data"` + Meta struct { + PerPage int `json:"per_page"` + } `json:"meta"` + } + if err := json.Unmarshal(nine.Body.Bytes(), &nineBody); err != nil { + t.Fatal(err) + } + if nineBody.Meta.PerPage != 9 { + t.Fatalf("per_page=9 meta = %d", nineBody.Meta.PerPage) + } + if len(nineBody.Data) != 9 { + t.Fatalf("per_page=9 data len = %d", len(nineBody.Data)) + } + capped := env.call(t, http.MethodGet, "/_journal/api/v1/posts?per_page=30", "", nil) + var capBody struct { + Meta struct { + PerPage int `json:"per_page"` + } `json:"meta"` + } + if err := json.Unmarshal(capped.Body.Bytes(), &capBody); err != nil { + t.Fatal(err) + } + if capBody.Meta.PerPage != 30 { + t.Fatalf("per_page=30 meta = %d, want 30", capBody.Meta.PerPage) + } +} + +func TestJournalEditorListDrafts(t *testing.T) { + env := newPostsEnv(t) + tok := env.admin(t, controllers.PermissionAccessPosts) + if err := env.gdb.Create(&models.Post{Title: "Hidden draft", Slug: "hidden-draft", Content: "x", Published: false}).Error; err != nil { + t.Fatal(err) + } + anon := env.call(t, http.MethodGet, "/_journal/api/v1/posts", "", nil) + if strings.Contains(anon.Body.String(), "hidden-draft") { + t.Fatalf("anonymous list leaked draft: %s", anon.Body.String()) + } + editor := env.call(t, http.MethodGet, "/_journal/api/v1/posts", tok, nil) + if editor.Code != http.StatusOK { + t.Fatalf("editor list = %d: %s", editor.Code, editor.Body.String()) + } + if !strings.Contains(editor.Body.String(), "hidden-draft") { + t.Fatalf("editor Bearer list omitted drafts: %s", editor.Body.String()) + } +} + +func TestJournalAPIMassAssignRedactor(t *testing.T) { + env := newPostsEnv(t) + tok := env.admin(t, controllers.PermissionAccessPosts) + created := env.call(t, http.MethodPost, "/_journal/api/v1/posts", tok, map[string]any{ + "title": "Assign trap", + "content": "body", + "redactor_id": 99, + "user_id": 1, + }) + if created.Code != http.StatusCreated { + t.Fatalf("create = %d: %s", created.Code, created.Body.String()) + } + var stored models.Post + if err := env.gdb.Where("slug = ?", "assign-trap").Or("title = ?", "Assign trap").First(&stored).Error; err != nil { + t.Fatal(err) + } + if stored.RedactorID != nil { + t.Fatalf("redactor_id persisted from body: %#v", stored.RedactorID) + } + authorID := env.lastUserID(t) + if stored.UserID == nil || *stored.UserID != authorID { + t.Fatalf("user_id = %#v, want stamped principal %d", stored.UserID, authorID) + } +} + +func TestPostsAdminForbidden(t *testing.T) { + env := newPostsEnv(t) + noPerm := env.admin(t) + rec := env.call(t, http.MethodGet, adminAPI(adminPostsPath), noPerm, nil) + if rec.Code != http.StatusForbidden { + t.Fatalf("admin list without access_posts = %d, want 403: %s", rec.Code, rec.Body.String()) + } +} + +func TestJournalWriteFrontendAudience(t *testing.T) { + env := newPostsEnv(t) + front, _, err := bouncer.MintAudience(adminJWTSecret, "1", "https://app.example.test/login", time.Hour, bouncer.AudienceUser) + if err != nil { + t.Fatal(err) + } + denied := env.call(t, http.MethodPost, "/_journal/api/v1/posts", front, map[string]any{ + "title": "Frontend", + "content": "Should not write", + }) + if denied.Code != http.StatusUnauthorized { + t.Fatalf("frontend-audience POST = %d, want 401: %s", denied.Code, denied.Body.String()) + } + if got, _ := phpErrorString(t, denied.Body.Bytes()); got != "Authentication required" { + t.Fatalf("frontend-audience error = %q", got) + } +} diff --git a/journal_api_task3_test.go b/journal_api_task3_test.go index eeda6a2..ab79aae 100644 --- a/journal_api_task3_test.go +++ b/journal_api_task3_test.go @@ -4,13 +4,10 @@ import ( "bytes" "encoding/json" "encoding/xml" - "io" "mime/multipart" "net/http" "net/http/httptest" - "net/url" "strings" - "sync/atomic" "testing" "time" @@ -96,48 +93,6 @@ func TestJournal006MediaUpload(t *testing.T) { } } -func TestSearchGateOff(t *testing.T) { - var hits atomic.Int64 - srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - hits.Add(1) - w.WriteHeader(http.StatusOK) - _, _ = io.WriteString(w, `{}`) - })) - t.Cleanup(srv.Close) - u, err := url.Parse(srv.URL) - if err != nil { - t.Fatal(err) - } - env := newPostsEnv(t, - "SUMMER_SEARCH__DRIVER=typesense", - "SUMMER_SEARCH__TYPESENSE__API_KEY=test-only-typesense-key", - "SUMMER_SEARCH__TYPESENSE__HOST="+u.Hostname(), - "SUMMER_SEARCH__TYPESENSE__PORT="+u.Port(), - "SUMMER_SEARCH__TYPESENSE__PROTOCOL="+u.Scheme, - ) - past := time.Now().UTC().Add(-time.Hour) - post := models.Post{ - Title: "Published searchable", - Slug: "published-searchable", - Content: "hello search gate", - Published: true, - PublishedAt: &past, - } - if err := env.gdb.Create(&post).Error; err != nil { - t.Fatal(err) - } - if hits.Load() != 0 { - t.Fatalf("Typesense HTTP hits = %d, want 0", hits.Load()) - } - if post.ShouldBeSearchable() { - t.Fatal("ShouldBeSearchable true with default search_use_typesense") - } - draft := models.Post{Title: "Draft", Slug: "draft-search", Content: "x", Published: false} - if draft.ShouldBeSearchable() { - t.Fatal("unpublished ShouldBeSearchable must be false") - } -} - func TestJournalRSS(t *testing.T) { env := newPostsEnv(t) title := "Acme Journal" @@ -207,6 +162,16 @@ func TestJournalRSS(t *testing.T) { t.Fatal("rss_include_content false still emitted content:encoded") } + if err := env.gdb.Model(&models.Settings{}).Where("id = 1").Updates(map[string]any{ + "rss_include_content": true, + }).Error; err != nil { + t.Fatal(err) + } + withContent := env.call(t, http.MethodGet, "/_journal/api/v1/rss", "", nil) + if !strings.Contains(withContent.Body.String(), "content:encoded") { + t.Fatalf("rss_include_content true missing content:encoded: %s", withContent.Body.String()) + } + if err := env.gdb.Model(&models.Settings{}).Where("id = 1").Update("rss_enabled", false).Error; err != nil { t.Fatal(err) } diff --git a/journal_api_writes_test.go b/journal_api_writes_test.go index 4e399ac..0ba26af 100644 --- a/journal_api_writes_test.go +++ b/journal_api_writes_test.go @@ -5,6 +5,7 @@ import ( "fmt" "net/http" "strconv" + "strings" "testing" "time" @@ -185,10 +186,29 @@ func TestJournalPublicCategories(t *testing.T) { t.Fatalf("categories row missing %s: %s", key, rec.Body.String()) } } + + empty := models.Category{Name: "Empty nest", Slug: "empty-nest"} + if err := env.gdb.Create(&empty).Error; err != nil { + t.Fatal(err) + } + hidden := env.call(t, http.MethodGet, "/_journal/api/v1/categories", "", nil) + if strings.Contains(hidden.Body.String(), "empty-nest") { + t.Fatalf("empty category listed without include_empty: %s", hidden.Body.String()) + } + shown := env.call(t, http.MethodGet, "/_journal/api/v1/categories?include_empty=1", "", nil) + if shown.Code != http.StatusOK { + t.Fatalf("include_empty = %d: %s", shown.Code, shown.Body.String()) + } + if !strings.Contains(shown.Body.String(), "empty-nest") { + t.Fatalf("include_empty=1 omitted empty category: %s", shown.Body.String()) + } } func TestJournalPublicTags(t *testing.T) { env := newPostsEnv(t) + if err := env.gdb.Create(&models.Tag{Name: "Zebra", Slug: "zebra-tag"}).Error; err != nil { + t.Fatal(err) + } tag := models.Tag{Name: "Field notes", Slug: "field-notes"} if err := env.gdb.Create(&tag).Error; err != nil { t.Fatal(err) @@ -221,6 +241,26 @@ func TestJournalPublicTags(t *testing.T) { t.Fatalf("tags row missing %s: %s", key, rec.Body.String()) } } + names := make([]string, 0, len(body.Data)) + for _, item := range body.Data { + names = append(names, fmt.Sprint(item["name"])) + } + joined := strings.Join(names, ",") + if !strings.Contains(joined, "Field notes") || !strings.Contains(joined, "Zebra") { + t.Fatalf("tags missing expected names: %s", rec.Body.String()) + } + fieldIdx, zebraIdx := -1, -1 + for i, name := range names { + if name == "Field notes" { + fieldIdx = i + } + if name == "Zebra" { + zebraIdx = i + } + } + if fieldIdx < 0 || zebraIdx < 0 || fieldIdx > zebraIdx { + t.Fatalf("tags not ordered by name: %v", names) + } } func TestJournalFeaturedImageUnauthenticated(t *testing.T) { diff --git a/models/fillable_test.go b/models/fillable_test.go new file mode 100644 index 0000000..22c1603 --- /dev/null +++ b/models/fillable_test.go @@ -0,0 +1,107 @@ +package models_test + +import ( + "reflect" + "testing" + + "git.golem15.com/golem15/sm-journal-plugin/models" + "git.golem15.com/golem15/summercms/modules/lagoon" +) + +// TestFillable is JOURNAL-001/002 and T-15-04: Tag allow-list is name/slug/ +// description only; Category excludes nest_*; extra JSON keys (including +// redactor_id and user_id on Post) are dropped by lagoon.Fill. +func TestFillable(t *testing.T) { + t.Run("tag_allow_list", func(t *testing.T) { + if got := (models.Tag{}).Fillable(); !reflect.DeepEqual(got, []string{"name", "slug", "description"}) { + t.Fatalf("Tag.Fillable = %#v", got) + } + tag := models.Tag{} + if err := lagoon.Fill(&tag, tag.Fillable(), map[string]any{ + "name": "Notes", + "slug": "notes", + "description": "field notes", + "id": 99, + "nest_left": 1, + "created_at": "2020-01-01", + }, true); err != nil { + t.Fatal(err) + } + if tag.Name != "Notes" || tag.Slug != "notes" { + t.Fatalf("tag fill = %+v", tag) + } + if tag.ID != 0 { + t.Fatalf("id was mass-assigned: %d", tag.ID) + } + if tag.Description == nil || *tag.Description != "field notes" { + t.Fatalf("description = %#v", tag.Description) + } + }) + + t.Run("category_excludes_nest", func(t *testing.T) { + if got := (models.Category{}).Fillable(); !reflect.DeepEqual(got, []string{"name", "slug", "code", "description", "parent_id"}) { + t.Fatalf("Category.Fillable = %#v", got) + } + left := 3 + cat := models.Category{NestLeft: &left} + if err := lagoon.Fill(&cat, cat.Fillable(), map[string]any{ + "name": "Essays", + "slug": "essays", + "code": "ess", + "nest_left": 9, + "nest_right": 10, + "nest_depth": 2, + "id": 7, + }, true); err != nil { + t.Fatal(err) + } + if cat.Name != "Essays" || cat.Slug != "essays" { + t.Fatalf("category fill = %+v", cat) + } + if cat.ID != 0 { + t.Fatalf("id was mass-assigned: %d", cat.ID) + } + if cat.NestLeft == nil || *cat.NestLeft != 3 { + t.Fatalf("nest_left mutated: %#v", cat.NestLeft) + } + if cat.NestRight != nil || cat.NestDepth != nil { + t.Fatalf("nest_* assigned: right=%v depth=%v", cat.NestRight, cat.NestDepth) + } + }) + + t.Run("post_redactor_and_user_not_fillable", func(t *testing.T) { + post := models.Post{} + for _, name := range post.Fillable() { + if name == "redactor_id" || name == "user_id" || name == "content_html" { + t.Fatalf("Post.Fillable includes %q: %#v", name, post.Fillable()) + } + } + rid := uint(99) + uid := uint(7) + post.RedactorID = &rid + post.UserID = &uid + if err := lagoon.Fill(&post, post.Fillable(), map[string]any{ + "title": "Hello", + "slug": "hello", + "excerpt": "ex", + "content": "body", + "redactor_id": 1, + "user_id": 2, + "content_html": "", + }, true); err != nil { + t.Fatal(err) + } + if post.Title != "Hello" || post.Slug != "hello" { + t.Fatalf("post fill = %+v", post) + } + if post.RedactorID == nil || *post.RedactorID != 99 { + t.Fatalf("redactor_id was filled: %#v", post.RedactorID) + } + if post.UserID == nil || *post.UserID != 7 { + t.Fatalf("user_id was filled: %#v", post.UserID) + } + if post.ContentHTML != "" { + t.Fatalf("content_html was filled: %q", post.ContentHTML) + } + }) +} diff --git a/models/translatable_test.go b/models/translatable_test.go new file mode 100644 index 0000000..e462844 --- /dev/null +++ b/models/translatable_test.go @@ -0,0 +1,58 @@ +package models_test + +import ( + "reflect" + "testing" + + "git.golem15.com/golem15/sm-journal-plugin/models" +) + +type translatable interface { + Translatable() []string +} + +type translatableIndexed interface { + TranslatableIndexes() []string +} + +func TestTranslatable(t *testing.T) { + post := models.Post{} + if post.MorphName() != `Golem15\Journal\Models\Post` { + t.Fatalf("Post.MorphName = %q", post.MorphName()) + } + if got := post.Translatable(); !reflect.DeepEqual(got, []string{"title", "content", "content_html", "excerpt", "metadata", "slug"}) { + t.Fatalf("Post.Translatable = %#v", got) + } + if got := post.TranslatableIndexes(); !reflect.DeepEqual(got, []string{"slug"}) { + t.Fatalf("Post.TranslatableIndexes = %#v", got) + } + + cat := models.Category{} + if cat.MorphName() != `Golem15\Journal\Models\Category` { + t.Fatalf("Category.MorphName = %q", cat.MorphName()) + } + if got := cat.Translatable(); !reflect.DeepEqual(got, []string{"name", "description", "slug"}) { + t.Fatalf("Category.Translatable = %#v", got) + } + if got := cat.TranslatableIndexes(); !reflect.DeepEqual(got, []string{"slug"}) { + t.Fatalf("Category.TranslatableIndexes = %#v", got) + } + + tag := models.Tag{} + if tag.MorphName() != `Golem15\Journal\Models\Tag` { + t.Fatalf("Tag.MorphName = %q", tag.MorphName()) + } + if _, ok := any(tag).(translatable); ok { + t.Fatal("Tag must not implement Translatable") + } + if _, ok := any(tag).(translatableIndexed); ok { + t.Fatal("Tag must not implement TranslatableIndexes") + } +} + +func TestFilterScopes(t *testing.T) { + got := (models.Post{}).FilterScopes() + if !reflect.DeepEqual(got, []string{models.FilterPublished, models.FilterCategories}) { + t.Fatalf("FilterScopes = %#v", got) + } +} diff --git a/plugin_test.go b/plugin_test.go index 0116d7f..b87367c 100644 --- a/plugin_test.go +++ b/plugin_test.go @@ -1,6 +1,9 @@ package journal import ( + "io/fs" + "os" + "path/filepath" "strings" "testing" "time" @@ -77,4 +80,80 @@ func TestJournalBuckets(t *testing.T) { t.Fatalf("%s Key is nil", name) } } + hostYAML := filepath.Join("..", "sm-grzybyfunkcjonalne-app", "config", "http.yaml") + raw, err := os.ReadFile(hostYAML) + if err != nil { + return + } + if !strings.Contains(string(raw), "_journal/api/*") { + t.Fatalf("host CORS missing _journal/api/* in %s", hostYAML) + } +} + +func TestJournalSVGEmbed(t *testing.T) { + p := &Plugin{} + fsys := p.AdminFS() + f, err := fsys.Open("assets/images/journal-icon.svg") + if err != nil { + t.Fatalf("AdminFS missing journal-icon.svg: %v", err) + } + _ = f.Close() + filter, err := fs.ReadFile(fsys, "controllers/posts/config_filter.yaml") + if err != nil { + t.Fatal(err) + } + if strings.Contains(string(filter), "conditions:") { + t.Fatal("config_filter.yaml still has conditions") + } + fields, err := fs.ReadFile(fsys, "models/post/fields.yaml") + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(fields), "type: mlmarkdown") { + t.Fatal("post fields.yaml content is not mlmarkdown") + } +} + +func TestCabanaMarkdownFieldTypes(t *testing.T) { + path := filepath.Join("..", "summercms.go", "modules", "cabana", "form_schema.go") + raw, err := os.ReadFile(path) + if err != nil { + t.Fatalf("read %s: %v", path, err) + } + src := string(raw) + for _, typ := range []string{`"markdown"`, `"mltext"`, `"mlmarkdown"`} { + if !strings.Contains(src, typ) { + t.Fatalf("form_schema.go missing %s", typ) + } + } +} + +func TestNoTideJournalFixtures(t *testing.T) { + roots := []string{ + filepath.Join("..", "fonoteka.go", "parity"), + filepath.Join("..", "fonoteka.go", "modules", "tide"), + filepath.Join("..", "summercms.go", "modules", "tide"), + } + needle := "/_journal/api/v1" + for _, root := range roots { + if _, err := os.Stat(root); err != nil { + continue + } + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil || d.IsDir() { + return err + } + raw, readErr := os.ReadFile(path) + if readErr != nil { + return readErr + } + if strings.Contains(string(raw), needle) { + t.Errorf("%s newly mentions %s", path, needle) + } + return nil + }) + if err != nil { + t.Fatal(err) + } + } } diff --git a/search_test.go b/search_test.go new file mode 100644 index 0000000..a20405d --- /dev/null +++ b/search_test.go @@ -0,0 +1,64 @@ +package journal_test + +import ( + "io" + "net/http" + "net/http/httptest" + "net/url" + "sync/atomic" + "testing" + "time" + + "git.golem15.com/golem15/sm-journal-plugin/models" +) + +// TestSearchGateOff is D-12 / T-15-11. A published save with Typesense +// configured records zero outbound HTTP because search_use_typesense +// defaults false. Unpublished ShouldBeSearchable stays false even if the +// in-memory gate is flipped on. +func TestSearchGateOff(t *testing.T) { + var hits atomic.Int64 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + hits.Add(1) + w.WriteHeader(http.StatusOK) + _, _ = io.WriteString(w, `{}`) + })) + t.Cleanup(srv.Close) + u, err := url.Parse(srv.URL) + if err != nil { + t.Fatal(err) + } + env := newPostsEnv(t, + "SUMMER_SEARCH__DRIVER=typesense", + "SUMMER_SEARCH__TYPESENSE__API_KEY=test-only-typesense-key", + "SUMMER_SEARCH__TYPESENSE__HOST="+u.Hostname(), + "SUMMER_SEARCH__TYPESENSE__PORT="+u.Port(), + "SUMMER_SEARCH__TYPESENSE__PROTOCOL="+u.Scheme, + ) + past := time.Now().UTC().Add(-time.Hour) + post := models.Post{ + Title: "Published searchable", + Slug: "published-searchable", + Content: "hello search gate", + Published: true, + PublishedAt: &past, + } + if err := env.gdb.Create(&post).Error; err != nil { + t.Fatal(err) + } + if hits.Load() != 0 { + t.Fatalf("Typesense HTTP hits = %d, want 0", hits.Load()) + } + if post.ShouldBeSearchable() { + t.Fatal("ShouldBeSearchable true with default search_use_typesense") + } + draft := models.Post{Title: "Draft", Slug: "draft-search", Content: "x", Published: false} + models.SetSearchGate(true) + t.Cleanup(func() { models.SetSearchGate(false) }) + if draft.ShouldBeSearchable() { + t.Fatal("unpublished ShouldBeSearchable must be false even if the in-memory gate is on") + } + if hits.Load() != 0 { + t.Fatalf("Typesense HTTP hits after in-memory flip = %d, want 0", hits.Load()) + } +} diff --git a/updates/migrations_test.go b/updates/migrations_test.go new file mode 100644 index 0000000..1d3b59e --- /dev/null +++ b/updates/migrations_test.go @@ -0,0 +1,170 @@ +package updates + +import ( + "fmt" + "strings" + "testing" + "time" + + "git.golem15.com/golem15/summercms/modules/lagoon" + "github.com/go-gormigrate/gormigrate/v2" + "gorm.io/gorm" +) + +var journalTables = []string{ + "golem15_journal_posts", + "golem15_journal_categories", + "golem15_journal_tags", + "golem15_journal_posts_categories", + "golem15_journal_posts_tags", + "golem15_journal_settings", +} + +func TestJournalMigrationsRollbackAndRemigrate(t *testing.T) { + sqlDB := dedicatedDB(t, fmt.Sprintf("journal_mig_%d", time.Now().UnixNano())) + gdb, err := lagoon.Use(t.Context(), sqlDB) + if err != nil { + t.Fatal(err) + } + backend := gormigrate.New(gdb, &gormigrate.Options{ + TableName: "summer_migrations_summercms_cabana", + UseTransaction: true, + }, lagoon.BackendAdminMigrations) + if err := backend.Migrate(); err != nil { + t.Fatalf("backend_users migrations: %v", err) + } + m := journalMigrator(gdb) + if err := m.Migrate(); err != nil { + t.Fatalf("migrate: %v", err) + } + assertJournalSchema(t, gdb) + + for i := 0; i < len(All()); i++ { + if err := m.RollbackLast(); err != nil { + t.Fatalf("rollback %d: %v", i, err) + } + } + for _, table := range journalTables { + if gdb.Migrator().HasTable(table) { + t.Fatalf("%s survived rollback", table) + } + } + if gdb.Migrator().HasColumn("backend_users", "golem15_bloghub_author_slug") { + t.Fatal("golem15_bloghub_author_slug survived rollback") + } + assertNoRainlabJournalTables(t, gdb) + if err := m.Migrate(); err != nil { + t.Fatalf("re-migrate: %v", err) + } + assertJournalSchema(t, gdb) +} + +func journalMigrator(gdb *gorm.DB) *gormigrate.Gormigrate { + return gormigrate.New(gdb, &gormigrate.Options{ + TableName: "summer_migrations_golem15_journal", + UseTransaction: true, + }, All()) +} + +func assertJournalSchema(t *testing.T, gdb *gorm.DB) { + t.Helper() + for _, name := range journalTables { + if !gdb.Migrator().HasTable(name) { + t.Fatalf("missing table %s", name) + } + } + assertNoRainlabJournalTables(t, gdb) + if !gdb.Migrator().HasColumn("backend_users", "golem15_bloghub_author_slug") { + t.Fatal("backend_users.golem15_bloghub_author_slug missing") + } + + wantPosts := []string{ + "id", "user_id", "redactor_id", "title", "slug", "excerpt", "content", + "content_html", "published_at", "published", "is_pinned", "metadata", + "sources", "created_at", "updated_at", + } + for _, col := range wantPosts { + if !gdb.Migrator().HasColumn("golem15_journal_posts", col) { + t.Fatalf("golem15_journal_posts missing column %s", col) + } + } + assertUdt(t, gdb, "golem15_journal_posts", "metadata", "jsonb") + assertUdt(t, gdb, "golem15_journal_posts", "sources", "jsonb") + assertIndex(t, gdb, "golem15_journal_posts_slug_unique") + assertIndex(t, gdb, "golem15_journal_categories_slug_unique") + assertIndex(t, gdb, "golem15_journal_tags_slug_unique") + + var typesense bool + if err := gdb.WithContext(t.Context()). + Raw(`SELECT search_use_typesense FROM golem15_journal_settings WHERE id = 1`). + Scan(&typesense).Error; err != nil { + t.Fatal(err) + } + if typesense { + t.Fatal("search_use_typesense default must be false") + } + var showAll bool + if err := gdb.WithContext(t.Context()). + Raw(`SELECT show_all_posts FROM golem15_journal_settings WHERE id = 1`). + Scan(&showAll).Error; err != nil { + t.Fatal(err) + } + if !showAll { + t.Fatal("show_all_posts default must be true") + } +} + +func assertNoRainlabJournalTables(t *testing.T, gdb *gorm.DB) { + t.Helper() + var leftover []string + if err := gdb.WithContext(t.Context()). + Raw(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND (tablename LIKE 'rainlab\_journal\_%' OR tablename LIKE 'winter\_journal\_%')`). + Scan(&leftover).Error; err != nil { + t.Fatal(err) + } + if len(leftover) != 0 { + t.Fatalf("rainlab/winter-era journal tables present: %v", leftover) + } +} + +func assertUdt(t *testing.T, gdb *gorm.DB, table, column, want string) { + t.Helper() + var udt string + if err := gdb.WithContext(t.Context()).Raw( + `SELECT udt_name FROM information_schema.columns WHERE table_name = ? AND column_name = ?`, + table, column, + ).Scan(&udt).Error; err != nil { + t.Fatal(err) + } + if udt != want { + t.Fatalf("%s.%s udt = %q, want %q", table, column, udt, want) + } +} + +func assertIndex(t *testing.T, gdb *gorm.DB, name string) { + t.Helper() + var n int64 + if err := gdb.WithContext(t.Context()).Raw( + `SELECT COUNT(*) FROM pg_indexes WHERE schemaname = 'public' AND indexname = ?`, + name, + ).Scan(&n).Error; err != nil { + t.Fatal(err) + } + if n != 1 { + t.Fatalf("index %s count = %d, want 1", name, n) + } +} + +func assertUniqueSlug(t *testing.T, gdb *gorm.DB, table, slug string) { + t.Helper() + if err := gdb.Exec(`INSERT INTO `+table+` (slug) VALUES (?)`, slug).Error; err != nil { + t.Fatalf("first insert %s.%s: %v", table, slug, err) + } + err := gdb.Exec(`INSERT INTO `+table+` (slug) VALUES (?)`, slug).Error + if err == nil { + t.Fatalf("duplicate slug on %s was accepted", table) + } + if !strings.Contains(strings.ToLower(err.Error()), "unique") && !strings.Contains(strings.ToLower(err.Error()), "duplicate") { + t.Fatalf("duplicate slug error = %v", err) + } +} diff --git a/updates/postgres_test.go b/updates/postgres_test.go index 460581b..0ec846c 100644 --- a/updates/postgres_test.go +++ b/updates/postgres_test.go @@ -161,41 +161,7 @@ func TestJournalTables(t *testing.T) { if err := journal.Migrate(); err != nil { t.Fatalf("journal migrations: %v", err) } - - for _, name := range []string{ - "golem15_journal_posts", - "golem15_journal_categories", - "golem15_journal_tags", - "golem15_journal_posts_categories", - "golem15_journal_posts_tags", - "golem15_journal_settings", - } { - if !gdb.Migrator().HasTable(name) { - t.Fatalf("missing table %s", name) - } - } - var leftover []string - if err := gdb.WithContext(t.Context()). - Raw(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename LIKE 'rainlab\_journal\_%'`). - Scan(&leftover).Error; err != nil { - t.Fatal(err) - } - if len(leftover) != 0 { - t.Fatalf("rainlab-era journal tables present: %v", leftover) - } - if !gdb.Migrator().HasColumn("backend_users", "golem15_bloghub_author_slug") { - t.Fatal("backend_users.golem15_bloghub_author_slug missing") - } - - var typesense bool - if err := gdb.WithContext(t.Context()). - Raw(`SELECT search_use_typesense FROM golem15_journal_settings WHERE id = 1`). - Scan(&typesense).Error; err != nil { - t.Fatal(err) - } - if typesense { - t.Fatal("search_use_typesense default must be false") - } + assertJournalSchema(t, gdb) var catCount int64 if err := gdb.WithContext(t.Context()). @@ -216,6 +182,9 @@ func TestJournalTables(t *testing.T) { if postCount != 0 { t.Fatalf("seeded posts = %d, want 0", postCount) } + assertUniqueSlug(t, gdb, "golem15_journal_posts", "unique-post-slug") + assertUniqueSlug(t, gdb, "golem15_journal_tags", "unique-tag-slug") + assertUniqueSlug(t, gdb, "golem15_journal_categories", "unique-cat-slug") if got := (models.Category{}).Fillable(); !reflect.DeepEqual(got, []string{"name", "slug", "code", "description", "parent_id"}) { t.Fatalf("Category.Fillable = %#v", got)