354 lines
13 KiB
Go
354 lines
13 KiB
Go
package test
|
|
|
|
import (
|
|
"RenewCMS/api/pkg/apperr"
|
|
"RenewCMS/internal/domain/article"
|
|
"RenewCMS/internal/domain/site"
|
|
"RenewCMS/internal/infrastructure/useCases"
|
|
"bytes"
|
|
"errors"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
type seoAlwaysRacingArticleRepo struct {
|
|
*mockArticleRepo
|
|
createCalls int
|
|
}
|
|
|
|
func (r *seoAlwaysRacingArticleRepo) Create(a article.Article) (article.Article, error) {
|
|
r.createCalls++
|
|
return article.Article{}, article.ErrSlugTaken
|
|
}
|
|
|
|
func TestSeoDataCleanerUsageOrdering(t *testing.T) {
|
|
t.Run("Usage lists articles then sites, each ordered by id", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
for _, id := range []uint32{11, 9, 12, 8, 10, 19, 15, 13, 17, 14, 18, 16} {
|
|
e.seedArticle(id, "Article", siteMainID, "article-"+strconv.Itoa(int(id)))
|
|
e.updateArticle(id, func(a *article.Article) { a.CoverImageID = idPointer(5) })
|
|
}
|
|
e.sites.seed(3, "Zeta", "zeta", true)
|
|
e.sites.seed(siteMainID, "Main", "main", false)
|
|
for _, id := range []uint32{3, siteShopID, siteMainID} {
|
|
s := e.sites.sites[id]
|
|
s.DefaultSocialImageID = idPointer(5)
|
|
e.sites.sites[id] = s
|
|
}
|
|
|
|
items := e.usage(t, 5)
|
|
|
|
got := []string{}
|
|
ids := []float64{}
|
|
for _, item := range items {
|
|
got = append(got, item["type"].(string))
|
|
ids = append(ids, item["id"].(float64))
|
|
}
|
|
wantTypes := []string{}
|
|
wantIDs := []float64{}
|
|
for id := 8; id <= 19; id++ {
|
|
wantTypes = append(wantTypes, "article")
|
|
wantIDs = append(wantIDs, float64(id))
|
|
}
|
|
wantTypes = append(wantTypes, "site", "site", "site")
|
|
wantIDs = append(wantIDs, siteMainID, siteShopID, 3)
|
|
if !reflect.DeepEqual(got, wantTypes) || !reflect.DeepEqual(ids, wantIDs) {
|
|
t.Errorf("types %v ids %v", got, ids)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestSeoDataCleanerSlugRaces(t *testing.T) {
|
|
t.Run("Creating gives up after exactly five racing attempts", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
racing := &seoAlwaysRacingArticleRepo{mockArticleRepo: e.articles}
|
|
create := useCases.NewCreateArticleUseCase(racing, &fakeBodyRenderer{}, e.audit.recorder, e.sites, e.authors)
|
|
|
|
_, err := create.CreateArticle(t.Context(), useCases.CreateArticleCommand{Title: "Racing", Body: "x"})
|
|
|
|
if !errors.Is(err, article.ErrSlugTaken) || racing.createCalls != 5 {
|
|
t.Errorf("err %v after %d attempts", err, racing.createCalls)
|
|
}
|
|
})
|
|
|
|
t.Run("A race while moving to another site suggests a free slug there", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.seedSpring()
|
|
e.articles.reportSlugRace = true
|
|
|
|
rec := e.patch(t, seoSpringID, `{"site_id": 2}`)
|
|
|
|
if rec.Code != http.StatusConflict || rec.Result().Header.Get(seoSlugHeader) != "spring-release-2" {
|
|
t.Errorf("status %d suggestion %q", rec.Code, rec.Result().Header.Get(seoSlugHeader))
|
|
}
|
|
})
|
|
|
|
t.Run("Moving to a site where the slug is taken conflicts", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.seedSpring()
|
|
e.seedArticle(1, "Other", siteShopID, seoSpringSlug)
|
|
|
|
rec := e.patch(t, seoSpringID, `{"site_id": 2}`)
|
|
|
|
if rec.Code != http.StatusConflict || rec.Result().Header.Get(seoSlugHeader) != "spring-release-2" || e.stored(seoSpringID).SiteID != siteMainID {
|
|
t.Errorf("status %d suggestion %q site %d", rec.Code, rec.Result().Header.Get(seoSlugHeader), e.stored(seoSpringID).SiteID)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestSeoDataCleanerCreateErrors(t *testing.T) {
|
|
t.Run("A missing default site is a 404, not a 500", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.sites.fail.failNextWith("GetDefault", site.ErrSiteNotFound)
|
|
|
|
rec := e.owner(t, http.MethodPost, "/v1/article", `{"title": "Spring release", "body": "x"}`)
|
|
|
|
expectStatusAndText(t, rec, http.StatusNotFound, apperr.SiteNotFoundErrorMessage)
|
|
})
|
|
|
|
t.Run("Exhausted slug retries are a 409", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.articles.createAlwaysRaces = true
|
|
|
|
rec := e.owner(t, http.MethodPost, "/v1/article", `{"title": "Spring release", "body": "x"}`)
|
|
|
|
expectStatusAndText(t, rec, http.StatusConflict, seoSlugTaken)
|
|
})
|
|
|
|
t.Run("An unknown failure keeps the generic create message", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.articles.fail.failNext("Create")
|
|
|
|
rec := e.owner(t, http.MethodPost, "/v1/article", `{"title": "Spring release", "body": "x"}`)
|
|
|
|
expectStatusAndText(t, rec, http.StatusInternalServerError, "Failed to create article")
|
|
})
|
|
}
|
|
|
|
func TestSeoDataCleanerFreeSlugCap(t *testing.T) {
|
|
seedTaken := func(e *seoEnv, upTo int) {
|
|
e.seedArticle(1, "Spring release", siteMainID, seoSpringSlug)
|
|
for attempt := 2; attempt <= upTo; attempt++ {
|
|
e.seedArticle(uint32(attempt), "Spring release", siteMainID, seoSpringSlug+"-"+strconv.Itoa(attempt))
|
|
}
|
|
}
|
|
|
|
t.Run("The last attempt is still used", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
seedTaken(e, 99)
|
|
|
|
rec := e.owner(t, http.MethodPost, "/v1/article", `{"title": "Spring release", "body": "x"}`)
|
|
|
|
if rec.Code != http.StatusCreated || decodeSeoObject(t, rec)["slug"] != "spring-release-100" {
|
|
t.Errorf("status %d body %s", rec.Code, rec.Body.String())
|
|
}
|
|
})
|
|
|
|
t.Run("Creating gives up when every candidate is taken", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
seedTaken(e, 100)
|
|
|
|
rec := e.owner(t, http.MethodPost, "/v1/article", `{"title": "Spring release", "body": "x"}`)
|
|
|
|
expectStatusAndText(t, rec, http.StatusConflict, seoSlugTaken)
|
|
if rec.Result().Header.Get(seoSlugHeader) != "" || len(e.articles.articles) != 100 {
|
|
t.Errorf("suggestion %q, %d articles", rec.Result().Header.Get(seoSlugHeader), len(e.articles.articles))
|
|
}
|
|
})
|
|
|
|
t.Run("A suggestion gives up when every candidate is taken", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
seedTaken(e, 100)
|
|
e.seedArticle(500, "Other", siteMainID, "other")
|
|
|
|
rec := e.patch(t, 500, `{"slug": "spring-release"}`)
|
|
|
|
expectStatusAndText(t, rec, http.StatusConflict, seoSlugTaken)
|
|
if rec.Result().Header.Get(seoSlugHeader) != "" {
|
|
t.Errorf("suggestion %q", rec.Result().Header.Get(seoSlugHeader))
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestSeoDataCleanerSiteLengthLimits(t *testing.T) {
|
|
locale35 := "en-abcdefgh-abcdefgh-abcdefgh-abcde"
|
|
locale36 := locale35 + "f"
|
|
host := func(length int) string { return "https://" + strings.Repeat("a", length-len("https://")) }
|
|
|
|
t.Run("A locale of 35 characters is the longest accepted", func(t *testing.T) {
|
|
accepted, acceptedErr := site.NormalizeLocale(&locale35)
|
|
rejected, rejectedErr := site.NormalizeLocale(&locale36)
|
|
|
|
if len(locale35) != 35 || len(locale36) != 36 || acceptedErr != nil || *accepted != locale35 || !errors.Is(rejectedErr, site.ErrInvalidLocale) || rejected != nil {
|
|
t.Errorf("accepted %v %v, rejected %v %v", accepted, acceptedErr, rejected, rejectedErr)
|
|
}
|
|
})
|
|
|
|
t.Run("A base URL of 255 characters is the longest accepted", func(t *testing.T) {
|
|
accepted, acceptedErr := site.NormalizeBaseURL(host(255))
|
|
rejected, rejectedErr := site.NormalizeBaseURL(host(256))
|
|
|
|
if acceptedErr != nil || accepted != host(255) || !errors.Is(rejectedErr, site.ErrInvalidSiteURL) || rejected != "" {
|
|
t.Errorf("accepted %d %v, rejected %q %v", len(accepted), acceptedErr, rejected, rejectedErr)
|
|
}
|
|
})
|
|
|
|
t.Run("Over-length input is a 400 over HTTP", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
|
|
locale := e.owner(t, http.MethodPatch, "/v1/site/2", `{"locale": "`+locale36+`"}`)
|
|
baseURL := e.owner(t, http.MethodPatch, "/v1/site/2", `{"base_url": "`+host(256)+`"}`)
|
|
created := e.owner(t, http.MethodPost, "/v1/site/", `{"name": "Long", "key": "long", "base_url": "`+host(256)+`"}`)
|
|
|
|
if locale.Code != http.StatusBadRequest || baseURL.Code != http.StatusBadRequest || created.Code != http.StatusBadRequest {
|
|
t.Errorf("locale %d (%s), base_url %d (%s), create %d (%s)", locale.Code, locale.Body.String(), baseURL.Code, baseURL.Body.String(), created.Code, created.Body.String())
|
|
}
|
|
})
|
|
}
|
|
|
|
type seoFailingCompensationSites struct{ *mockSiteRepo }
|
|
|
|
func (r seoFailingCompensationSites) AssignImage([]uint32, uint32) error {
|
|
return errors.New("sites compensation down")
|
|
}
|
|
|
|
type seoFailingCompensationAuthors struct{ *mockAuthorRepo }
|
|
|
|
func (r seoFailingCompensationAuthors) AssignAvatar([]uint32, uint32) error {
|
|
return errors.New("authors compensation down")
|
|
}
|
|
|
|
type seoFailingCompensationArticles struct{ *mockArticleRepo }
|
|
|
|
func (r seoFailingCompensationArticles) RestoreImage(article.ImageReferences, uint32) error {
|
|
return errors.New("articles compensation down")
|
|
}
|
|
|
|
type seoFlakyBodyArticles struct {
|
|
*mockArticleRepo
|
|
calls int
|
|
}
|
|
|
|
func (r *seoFlakyBodyArticles) UpdateBody(id uint32, body string) (article.Article, error) {
|
|
r.calls++
|
|
if r.calls > 1 {
|
|
return article.Article{}, errors.New("body write " + strconv.Itoa(r.calls) + " down")
|
|
}
|
|
return r.mockArticleRepo.UpdateBody(id, body)
|
|
}
|
|
|
|
func captureLog(t *testing.T) *bytes.Buffer {
|
|
t.Helper()
|
|
var buffer bytes.Buffer
|
|
log.SetOutput(&buffer)
|
|
t.Cleanup(func() { log.SetOutput(os.Stderr) })
|
|
return &buffer
|
|
}
|
|
|
|
func TestSeoDataCleanerCompensationFailuresAreLogged(t *testing.T) {
|
|
t.Run("A failed delete logs every failed compensation", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.seedSpring()
|
|
e.updateArticle(seoSpringID, func(a *article.Article) { a.CoverImageID = idPointer(5) })
|
|
e.articles.fail.failNextWith("ClearImage", errors.New("clear down"))
|
|
buffer := captureLog(t)
|
|
remove := useCases.NewDeleteMediaUseCase(e.images, newMockImageStorage(), newMockVariantFileRepo(), e.audit.recorder, seoFailingCompensationSites{e.sites}, seoFailingCompensationAuthors{e.authors}, e.articles)
|
|
|
|
err := remove.Delete(t.Context(), 5)
|
|
|
|
logged := buffer.String()
|
|
if err == nil || !strings.Contains(logged, "restore site images: sites compensation down") || !strings.Contains(logged, "restore author avatars: authors compensation down") {
|
|
t.Errorf("err %v log %q", err, logged)
|
|
}
|
|
})
|
|
|
|
t.Run("A failed remove also logs the article restore", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.seedSpring()
|
|
e.updateArticle(seoSpringID, func(a *article.Article) { a.CoverImageID = idPointer(5) })
|
|
e.images.fail.failNextWith("Delete", errors.New("delete down"))
|
|
buffer := captureLog(t)
|
|
remove := useCases.NewDeleteMediaUseCase(e.images, newMockImageStorage(), newMockVariantFileRepo(), e.audit.recorder, seoFailingCompensationSites{e.sites}, seoFailingCompensationAuthors{e.authors}, seoFailingCompensationArticles{e.articles})
|
|
|
|
err := remove.Delete(t.Context(), 5)
|
|
|
|
logged := buffer.String()
|
|
if err == nil || !strings.Contains(logged, "restore site images: sites compensation down") || !strings.Contains(logged, "restore author avatars: authors compensation down") || !strings.Contains(logged, "restore article images: articles compensation down") {
|
|
t.Errorf("err %v log %q", err, logged)
|
|
}
|
|
})
|
|
|
|
t.Run("A failed merge logs the body it could not restore", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
e.seedBanner(5, "a.png", "same-hash")
|
|
e.seedBanner(6, "b.png", "same-hash")
|
|
e.seedArticle(8, "One", siteMainID, "one")
|
|
e.seedArticle(9, "Two", siteMainID, "two")
|
|
e.updateArticle(8, func(a *article.Article) { a.Body = e.bodyUsing(6) })
|
|
e.updateArticle(9, func(a *article.Article) { a.Body = e.bodyUsing(6) })
|
|
buffer := captureLog(t)
|
|
flaky := &seoFlakyBodyArticles{mockArticleRepo: e.articles}
|
|
merge := useCases.NewMergeMediaUseCase(e.images, flaky, newMockImageStorage(), newMockVariantFileRepo(), discardRecorder, e.sites, e.authors)
|
|
|
|
_, err := merge.Merge(t.Context(), 5, []uint32{6})
|
|
|
|
if err == nil || !strings.Contains(buffer.String(), "restore article body 8: body write 3 down") {
|
|
t.Errorf("err %v log %q", err, buffer.String())
|
|
}
|
|
})
|
|
}
|
|
|
|
type seoCaseInsensitiveBodyArticles struct{ *mockArticleRepo }
|
|
|
|
func (r seoCaseInsensitiveBodyArticles) FindByBodyContaining(filename string) ([]article.Article, error) {
|
|
found := []article.Article{}
|
|
for _, id := range r.sortedIds() {
|
|
stored := r.articles[id]
|
|
if strings.Contains(strings.ToLower(stored.Body), strings.ToLower(filename)) {
|
|
found = append(found, stored)
|
|
}
|
|
}
|
|
return found, nil
|
|
}
|
|
|
|
func TestSeoDataCleanerCaseInsensitiveBodyMatches(t *testing.T) {
|
|
seed := func(e *seoEnv) {
|
|
e.seedBanner(5, "a.png", "same-hash")
|
|
e.seedBanner(6, "b.png", "same-hash")
|
|
e.seedArticle(8, "Exact", siteMainID, "exact")
|
|
e.seedArticle(9, "Shouting", siteMainID, "shouting")
|
|
e.updateArticle(8, func(a *article.Article) { a.Body = e.bodyUsing(6) })
|
|
e.updateArticle(9, func(a *article.Article) { a.Body = strings.ToUpper(e.bodyUsing(6)) })
|
|
}
|
|
|
|
t.Run("Merge only counts the articles it rewrote", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
seed(e)
|
|
before := e.stored(9)
|
|
merge := useCases.NewMergeMediaUseCase(e.images, seoCaseInsensitiveBodyArticles{e.articles}, newMockImageStorage(), newMockVariantFileRepo(), discardRecorder, e.sites, e.authors)
|
|
|
|
result, err := merge.Merge(t.Context(), 5, []uint32{6})
|
|
|
|
if err != nil || result.ArticlesUpdated != 1 || !reflect.DeepEqual(result.UpdatedArticleIDs, []uint32{8}) || !reflect.DeepEqual(e.stored(9), before) {
|
|
t.Errorf("result %+v, %v", result, err)
|
|
}
|
|
})
|
|
|
|
t.Run("Usage only lists real body references", func(t *testing.T) {
|
|
e := newSeoEnv(t)
|
|
seed(e)
|
|
usage := useCases.NewGetMediaUsageUseCase(e.images, seoCaseInsensitiveBodyArticles{e.articles}, e.sites, e.authors)
|
|
|
|
items, err := usage.Usage(6)
|
|
|
|
if err != nil || len(items) != 1 || items[0].ID != 8 {
|
|
t.Errorf("items %+v, %v", items, err)
|
|
}
|
|
})
|
|
}
|