428 lines
16 KiB
Go
428 lines
16 KiB
Go
package test
|
|
|
|
import (
|
|
"RenewCMS/api/pkg/apperr"
|
|
"RenewCMS/internal/domain/article"
|
|
"RenewCMS/internal/domain/audit"
|
|
"encoding/json"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func revisionsOf(w *storyWorld, id uint32) (uint32, uint32) {
|
|
stored := w.stored(id)
|
|
return stored.EditRevision, stored.ContentRevision
|
|
}
|
|
|
|
func TestArticleEditRevisionHTTP(t *testing.T) {
|
|
t.Run("Title boundaries on PATCH, counted in runes", func(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
title string
|
|
status int
|
|
message string
|
|
stored bool
|
|
}{
|
|
{"2 ASCII characters", `"ab"`, 400, apperr.ArticleTitleErrorMessage, false},
|
|
{"3 ASCII characters", `"abc"`, 200, "", true},
|
|
{"200 ASCII characters", `"` + strings.Repeat("a", 200) + `"`, 200, "", true},
|
|
{"201 ASCII characters", `"` + strings.Repeat("a", 201) + `"`, 400, apperr.ArticleTitleErrorMessage, false},
|
|
{"200 four-byte runes", `"` + strings.Repeat("😀", 200) + `"`, 200, "", true},
|
|
{"empty", `""`, 400, apperr.ArticleTitleErrorMessage, false},
|
|
{"null", `null`, 400, apperr.BodyErrorMessage, false},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":`+c.title+`}`)
|
|
|
|
if response.Code != c.status || (c.message != "" && response.text() != c.message+"\n") {
|
|
t.Fatalf("expected %d %q, got %d %q", c.status, c.message, response.Code, response.text())
|
|
}
|
|
if changed := w.stored(10).Title != "Renovation costs"; changed != c.stored {
|
|
t.Errorf("stored title changed = %v, expected %v", changed, c.stored)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("A domain title rejection on update is a 400, not a 500", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
w.articles.fail.failNextWith("Update", article.ErrInvalidTitle)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"Valid title"}`).expect(t, 400, apperr.ArticleTitleErrorMessage)
|
|
})
|
|
|
|
t.Run("Editing the title never changes the slug", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"New title"}`)
|
|
|
|
response.expect(t, 200, "")
|
|
if stored := w.stored(10); stored.Slug != "renovation-costs" || !stored.IsOnline {
|
|
t.Errorf("slug and publication must be unchanged: %+v", stored)
|
|
}
|
|
})
|
|
|
|
t.Run("Title and body in one request", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"New title","body":"<p>x</p>"}`)
|
|
|
|
response.expect(t, 200, "")
|
|
if stored := w.stored(10); stored.Title != "New title" || stored.Body != "<p>x</p>" || stored.EditRevision != 4 {
|
|
t.Errorf("both must be stored with revision 4: %+v", stored)
|
|
}
|
|
})
|
|
|
|
t.Run("The title is editable on a single-language site", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
w.sites.seed(3, "Archive", "archive", false)
|
|
w.rows.rows[3] = storyRows("en", []string{"en"}, nil)
|
|
w.put(article.Article{ID: 60, Title: "Old archive", SiteID: 3, CreatedBy: storyWriter1, Slug: "old-archive", Lang: "en", StoryID: 60})
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/60", `{"title":"New title"}`)
|
|
|
|
response.expect(t, 200, "")
|
|
if w.stored(60).Slug != "old-archive" {
|
|
t.Errorf("the slug must be unchanged")
|
|
}
|
|
})
|
|
|
|
t.Run("Explicit slug edits", func(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
id string
|
|
body string
|
|
status int
|
|
message string
|
|
slug string
|
|
header string
|
|
}{
|
|
{"online article", "10", `{"slug":"new-address"}`, 200, "", "new-address", ""},
|
|
{"offline article", "12", `{"slug":"new-address"}`, 200, "", "new-address", ""},
|
|
{"same as current", "10", `{"slug":"renovation-costs"}`, 200, "", "renovation-costs", ""},
|
|
{"not a slug", "10", `{"slug":"Not A Slug"}`, 400, apperr.InvalidSlugErrorMessage, "renovation-costs", ""},
|
|
{"used by another language of the same story", "10", `{"slug":"couts"}`, 200, "", "couts", ""},
|
|
{"used by another en article", "10", `{"slug":"taken-en"}`, 409, apperr.ArticleSlugTakenErrorMessage, "renovation-costs", "taken-en-2"},
|
|
{"empty regenerates from the title", "10", `{"slug":""}`, 200, "", "renovation-costs", ""},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
w.put(article.Article{ID: 70, Title: "Taken", SiteID: storyJournal, CreatedBy: 1, Slug: "taken-en", Lang: "en", StoryID: 70})
|
|
id, _ := strconv.ParseUint(c.id, 10, 32)
|
|
editBefore, _ := revisionsOf(w, uint32(id))
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/"+c.id, c.body)
|
|
|
|
response.expect(t, c.status, c.message)
|
|
if got := w.stored(uint32(id)).Slug; got != c.slug {
|
|
t.Errorf("slug %q, expected %q", got, c.slug)
|
|
}
|
|
if response.header(apperr.SlugSuggestionHeader) != c.header {
|
|
t.Errorf("X-Slug-Suggestion %q, expected %q", response.header(apperr.SlugSuggestionHeader), c.header)
|
|
}
|
|
if editAfter, _ := revisionsOf(w, uint32(id)); (c.name == "same as current" || c.name == "empty regenerates from the title") && editAfter != editBefore {
|
|
t.Errorf("a no-op slug must not change the revision")
|
|
}
|
|
if w.stored(uint32(id)).IsOnline != (c.id == "10") {
|
|
t.Errorf("publication must be unchanged")
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("The same slug in two languages is not a conflict", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"slug":"couts"}`).expect(t, 200, "")
|
|
|
|
if w.stored(10).Slug != "couts" || w.stored(12).Slug != "couts" {
|
|
t.Errorf("both articles must hold the slug couts")
|
|
}
|
|
})
|
|
|
|
t.Run("Revision is exposed on every article read and write", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
requests := []struct {
|
|
method string
|
|
path string
|
|
body string
|
|
status int
|
|
}{
|
|
{http.MethodGet, "/v1/article/10", "", 200},
|
|
{http.MethodGet, "/v1/article/", "", 200},
|
|
{http.MethodPost, "/v1/article/", `{"title":"Plain draft"}`, 201},
|
|
{http.MethodPatch, "/v1/article/10", `{"body":"x"}`, 200},
|
|
{http.MethodPatch, "/v1/article/12/publish", "", 200},
|
|
{http.MethodPatch, "/v1/article/12/unpublish", "", 200},
|
|
}
|
|
for _, request := range requests {
|
|
response := w.send(storyOwner, request.method, request.path, request.body)
|
|
if response.Code != request.status {
|
|
t.Fatalf("%s %s: status %d %s", request.method, request.path, response.Code, response.text())
|
|
}
|
|
if strings.HasSuffix(request.path, "/") && request.method == http.MethodGet {
|
|
for _, item := range decodeArticleItems(t, response.Body.Bytes()) {
|
|
assertPositiveRevision(t, item)
|
|
}
|
|
continue
|
|
}
|
|
fields := response.fields(t)
|
|
assertPositiveRevision(t, fields)
|
|
for _, key := range legacyArticleKeys {
|
|
if _, present := fields[key]; !present {
|
|
t.Errorf("%s %s: legacy key %q missing", request.method, request.path, key)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
fieldCases := []struct {
|
|
field string
|
|
body string
|
|
content bool
|
|
setup func(*storyWorld)
|
|
}{
|
|
{"title", `{"title":"Changed title"}`, true, nil},
|
|
{"body", `{"body":"<p>changed</p>"}`, true, nil},
|
|
{"excerpt", `{"excerpt":"changed"}`, true, nil},
|
|
{"slug", `{"slug":"new-address"}`, true, nil},
|
|
{"cover_image_alt", `{"cover_image_alt":"changed"}`, true, nil},
|
|
{"seo_title", `{"seo_title":"changed"}`, true, nil},
|
|
{"seo_description", `{"seo_description":"changed"}`, true, nil},
|
|
{"social_title", `{"social_title":"changed"}`, true, nil},
|
|
{"social_description", `{"social_description":"changed"}`, true, nil},
|
|
{"author_ids", `{"author_ids":[2]}`, false, nil},
|
|
{"cover_image_id", `{"cover_image_id":7}`, false, nil},
|
|
{"social_image_id", `{"social_image_id":8}`, false, nil},
|
|
{"canonical_url", `{"canonical_url":"https://journal.example/other"}`, false, nil},
|
|
{"noindex", `{"noindex":false}`, false, nil},
|
|
{"seo_dismissed", `{"seo_dismissed":["cover_alt"]}`, false, nil},
|
|
}
|
|
t.Run("What raises revision and content_revision", func(t *testing.T) {
|
|
for _, c := range fieldCases {
|
|
t.Run(c.field, func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", c.body).expect(t, 200, "")
|
|
|
|
edit, content := revisionsOf(w, 10)
|
|
wantContent := uint32(4)
|
|
if c.content {
|
|
wantContent = 5
|
|
}
|
|
if edit != 4 || content != wantContent {
|
|
t.Errorf("revision %d and content_revision %d, expected 4 and %d", edit, content, wantContent)
|
|
}
|
|
})
|
|
}
|
|
t.Run("site_id of a single-version story", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
w.put(article.Article{ID: 60, Title: "Alone", CreatedBy: storyWriter1, Slug: "alone", Lang: "en", StoryID: 60, EditRevision: 3, ContentRevision: 4})
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/60", `{"site_id":2}`).expect(t, 200, "")
|
|
|
|
if edit, content := revisionsOf(w, 60); edit != 4 || content != 4 {
|
|
t.Errorf("revision %d and content_revision %d, expected 4 and 4", edit, content)
|
|
}
|
|
})
|
|
})
|
|
|
|
t.Run("Several content fields in one PATCH raise each counter once", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"Changed title","body":"<p>b</p>","excerpt":"e"}`).expect(t, 200, "")
|
|
|
|
if edit, content := revisionsOf(w, 10); edit != 4 || content != 5 {
|
|
t.Errorf("revision %d and content_revision %d, expected 4 and 5", edit, content)
|
|
}
|
|
})
|
|
|
|
t.Run("A PATCH that changes nothing leaves both counters alone", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"Renovation costs","body":"<p>Costs</p>","noindex":true}`).expect(t, 200, "")
|
|
|
|
if edit, content := revisionsOf(w, 10); edit != 3 || content != 4 {
|
|
t.Errorf("revision %d and content_revision %d, expected 3 and 4", edit, content)
|
|
}
|
|
})
|
|
|
|
t.Run("Publishing and unpublishing do not touch revisions", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
editBefore, contentBefore := revisionsOf(w, 12)
|
|
|
|
w.send(storyOwner, http.MethodPatch, "/v1/article/12/publish", "").expect(t, 200, "")
|
|
w.send(storyOwner, http.MethodPatch, "/v1/article/12/unpublish", "").expect(t, 200, "")
|
|
|
|
if edit, content := revisionsOf(w, 12); edit != editBefore || content != contentBefore {
|
|
t.Errorf("revisions changed to %d and %d", edit, content)
|
|
}
|
|
})
|
|
|
|
t.Run("if_revision matches", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":3}`)
|
|
|
|
response.expect(t, 200, "")
|
|
if string(response.fields(t)["revision"]) != "4" {
|
|
t.Errorf("the response revision must be 4: %s", response.text())
|
|
}
|
|
})
|
|
|
|
t.Run("if_revision is stale", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
stored := w.stored(10)
|
|
stored.EditRevision = 4
|
|
w.articles.articles[10] = stored
|
|
before := w.snapshot()
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":3}`)
|
|
|
|
response.expect(t, 409, apperr.RevisionConflictErrorMessage)
|
|
if response.header(apperr.CurrentRevisionHeader) != "4" {
|
|
t.Errorf("X-Current-Revision %q", response.header(apperr.CurrentRevisionHeader))
|
|
}
|
|
w.expectUnchanged(before)
|
|
for _, event := range w.eventsOf(audit.ActionArticleEdit) {
|
|
if event.Outcome == audit.OutcomeSuccess {
|
|
t.Errorf("no successful edit event expected: %+v", event)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("A stale if_revision wins over a no-op PATCH", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
stored := w.stored(10)
|
|
stored.EditRevision = 4
|
|
w.articles.articles[10] = stored
|
|
|
|
response := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"Renovation costs","if_revision":3}`)
|
|
|
|
response.expect(t, 409, apperr.RevisionConflictErrorMessage)
|
|
})
|
|
|
|
t.Run("Overwrite uses the revision the conflict dialog showed", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
stored := w.stored(10)
|
|
stored.EditRevision = 4
|
|
w.articles.articles[10] = stored
|
|
|
|
overwrite := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"mine","if_revision":4}`)
|
|
|
|
overwrite.expect(t, 200, "")
|
|
if string(overwrite.fields(t)["revision"]) != "5" {
|
|
t.Errorf("revision must be 5: %s", overwrite.text())
|
|
}
|
|
w.articles.beforeUpdate = func() {
|
|
saved := w.stored(10)
|
|
saved.EditRevision = 6
|
|
saved.Body = "theirs"
|
|
w.articles.articles[10] = saved
|
|
}
|
|
|
|
raced := w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"again","if_revision":5}`)
|
|
|
|
raced.expect(t, 409, apperr.RevisionConflictErrorMessage)
|
|
if raced.header(apperr.CurrentRevisionHeader) != "6" || w.stored(10).Body != "theirs" {
|
|
t.Errorf("the then-current revision 6 and their body expected: %q %q", raced.header(apperr.CurrentRevisionHeader), w.stored(10).Body)
|
|
}
|
|
})
|
|
|
|
t.Run("Without if_revision the last write wins", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"x"}`).expect(t, 200, "")
|
|
|
|
if edit, _ := revisionsOf(w, 10); edit != 4 {
|
|
t.Errorf("revision still rises by 1, got %d", edit)
|
|
}
|
|
})
|
|
|
|
t.Run("Invalid if_revision", func(t *testing.T) {
|
|
for _, value := range []string{`0`, `-1`, `"3"`, `1.5`, `null`} {
|
|
t.Run(value, func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":`+value+`}`).expect(t, 400, apperr.BodyErrorMessage)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("if_revision alone is not an update", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"if_revision":3}`).expect(t, 400, apperr.BodyErrorMessage)
|
|
})
|
|
|
|
t.Run("Other languages are untouched by an overwrite", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
before := w.stored(12)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":3}`).expect(t, 200, "")
|
|
|
|
if !articlesEqual(before, w.stored(12)) {
|
|
t.Errorf("article 12 changed")
|
|
}
|
|
})
|
|
|
|
t.Run("Permissions are unchanged", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
w.send(storyReader, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":1}`).expect(t, 403, apperr.MissingPermissionErrorMessage)
|
|
w.send(storyAnon, http.MethodPatch, "/v1/article/10", `{"body":"x","if_revision":1}`).expect(t, 401, "")
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/9999", `{"body":"x"}`).expect(t, 404, apperr.ArticleNotFoundErrorMessage)
|
|
before := w.snapshot()
|
|
hidden := w.send(storyPartial, http.MethodPatch, "/v1/article/11", `{"body":"x","if_revision":99}`)
|
|
hidden.expect(t, 404, apperr.ArticleNotFoundErrorMessage)
|
|
if hidden.header("X-Current-Revision") != "" {
|
|
t.Errorf("a caller who cannot read the article must not learn its revision")
|
|
}
|
|
w.send(storyPartial, http.MethodPatch, "/v1/article/11", `{"body":"x"}`).expect(t, 404, apperr.ArticleNotFoundErrorMessage)
|
|
w.expectUnchanged(before)
|
|
})
|
|
|
|
t.Run("Editing an online article without content.publish changes the live page right away", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"New title"}`).expect(t, 200, "")
|
|
|
|
public := w.send(storyAnon, http.MethodGet, "/v1/article/10", "")
|
|
public.expect(t, 200, "")
|
|
if string(public.fields(t)["title"]) != `"New title"` {
|
|
t.Errorf("the public read must show the new title: %s", public.text())
|
|
}
|
|
})
|
|
|
|
t.Run("Title and slug edits are recorded", func(t *testing.T) {
|
|
w := newStoryWorld(t)
|
|
|
|
w.send(storyUpdater, http.MethodPatch, "/v1/article/10", `{"title":"New title","slug":"new-address"}`).expect(t, 200, "")
|
|
|
|
events := w.eventsOf(audit.ActionArticleEdit)
|
|
if len(events) != 1 {
|
|
t.Fatalf("one edit event expected, got %d", len(events))
|
|
}
|
|
fields := []string{}
|
|
for _, change := range events[0].Changes {
|
|
fields = append(fields, change.Field)
|
|
}
|
|
if !strings.Contains(strings.Join(fields, ","), audit.FieldTitle) || !strings.Contains(strings.Join(fields, ","), audit.FieldSlug) || events[0].Params[audit.ParamLang] != "en" {
|
|
t.Errorf("title, slug and lang expected: %v %v", fields, events[0].Params)
|
|
}
|
|
})
|
|
}
|
|
|
|
func assertPositiveRevision(t *testing.T, fields map[string]json.RawMessage) {
|
|
t.Helper()
|
|
value, err := strconv.Atoi(string(fields["revision"]))
|
|
if err != nil || value < 1 {
|
|
t.Errorf("revision must be a positive integer: %s", fields["revision"])
|
|
}
|
|
}
|