GoBlog/postsDb_test.go

512 lines
12 KiB
Go
Raw Normal View History

package main
import (
"testing"
"time"
2022-04-15 18:53:19 +00:00
"github.com/samber/lo"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func Test_postsDb(t *testing.T) {
is := assert.New(t)
must := require.New(t)
app := &goBlog{
cfg: createDefaultTestConfig(t),
}
app.cfg.Blogs = map[string]*configBlog{
"en": {
Sections: map[string]*configSection{
"test": {},
"micro": {},
},
},
}
2022-07-17 05:35:39 +00:00
_ = app.initConfig(false)
app.initMarkdown()
_ = app.initCache()
now := toLocalSafe(time.Now().String())
nowPlus1Hour := toLocalSafe(time.Now().Add(1 * time.Hour).String())
// Save post
err := app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC",
Published: now,
Updated: nowPlus1Hour,
Blog: "en",
Section: "test",
Status: statusDraft,
Visibility: visibilityPublic,
Parameters: map[string][]string{
"title": {"Title"},
2021-07-03 10:11:57 +00:00
"tags": {"C", "A", "B"},
"empty": {},
},
}, &postCreationOptions{new: true})
must.NoError(err)
// Check post
2021-08-05 06:09:34 +00:00
p, err := app.getPost("/test/abc")
2021-07-03 10:11:57 +00:00
must.NoError(err)
is.Equal("/test/abc", p.Path)
is.Equal("ABC", p.Content)
is.Equal(now, p.Published)
is.Equal(nowPlus1Hour, p.Updated)
is.Equal("en", p.Blog)
is.Equal("test", p.Section)
is.Equal(statusDraft, p.Status)
is.Equal("Title", p.Title())
2021-07-03 10:11:57 +00:00
is.Equal([]string{"C", "A", "B"}, p.Parameters["tags"])
// Check drafts
2021-08-05 06:09:34 +00:00
drafts, _ := app.getPosts(&postsRequestConfig{
blog: "en",
status: []postStatus{statusDraft},
})
is.Len(drafts, 1)
2021-07-03 10:11:57 +00:00
// Check by parameter
count, err := app.db.countPosts(&postsRequestConfig{parameter: "tags"})
must.NoError(err)
is.Equal(1, count)
count, err = app.db.countPosts(&postsRequestConfig{parameter: "empty"})
must.NoError(err)
is.Equal(0, count)
2021-11-13 19:19:46 +00:00
// Check by multiple parameters
count, err = app.db.countPosts(&postsRequestConfig{parameters: []string{"tags", "title"}})
must.NoError(err)
is.Equal(1, count)
2021-11-14 06:58:49 +00:00
// Check by taxonomy
count, err = app.db.countPosts(&postsRequestConfig{taxonomy: &configTaxonomy{Name: "tags"}})
must.NoError(err)
is.Equal(1, count)
// Check by taxonomy value
count, err = app.db.countPosts(&postsRequestConfig{taxonomy: &configTaxonomy{Name: "tags"}, taxonomyValue: "A"})
must.NoError(err)
is.Equal(1, count)
// Delete post
err = app.deletePost("/test/abc")
must.NoError(err)
// Check if post is marked as deleted
count, err = app.db.countPosts(&postsRequestConfig{status: []postStatus{statusDraft}})
must.NoError(err)
is.Equal(0, count)
count, err = app.db.countPosts(&postsRequestConfig{status: []postStatus{statusDraftDeleted}})
must.NoError(err)
is.Equal(1, count)
// Delete post again
err = app.deletePost("/test/abc")
must.NoError(err)
// Check that there is no post
2021-07-03 10:11:57 +00:00
count, err = app.db.countPosts(&postsRequestConfig{})
must.NoError(err)
is.Equal(0, count)
// Save published post
err = app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC",
Published: "2021-06-10 10:00:00",
Updated: "2021-06-15 10:00:00",
Blog: "en",
Section: "test",
Status: statusPublished,
Visibility: visibilityPublic,
Parameters: map[string][]string{
2021-07-03 10:11:57 +00:00
"tags": {"Test", "Blog", "A"},
},
}, &postCreationOptions{new: true})
must.NoError(err)
// Check that there is a new post
count, err = app.db.countPosts(&postsRequestConfig{})
2021-07-03 10:11:57 +00:00
must.NoError(err)
is.Equal(1, count)
// Check based on offset
count, err = app.db.countPosts(&postsRequestConfig{limit: 10, offset: 1})
must.NoError(err)
is.Equal(0, count)
// Check random post path
rp, err := app.getRandomPostPath("en")
if is.NoError(err) {
is.Equal("/test/abc", rp)
}
// Check taxonomies
tags, err := app.db.allTaxonomyValues("en", "tags")
if is.NoError(err) {
2021-07-03 10:11:57 +00:00
is.Len(tags, 3)
is.Equal([]string{"A", "Blog", "Test"}, tags)
}
// Check based on date
count, err = app.db.countPosts(&postsRequestConfig{
publishedYear: 2020,
})
if is.NoError(err) {
is.Equal(0, count)
}
count, err = app.db.countPosts(&postsRequestConfig{
publishedYear: 2021,
})
if is.NoError(err) {
is.Equal(1, count)
}
2021-07-03 10:11:57 +00:00
count, err = app.db.countPosts(&postsRequestConfig{
publishedMonth: 5,
})
if is.NoError(err) {
is.Equal(0, count)
}
count, err = app.db.countPosts(&postsRequestConfig{
publishedMonth: 6,
})
if is.NoError(err) {
is.Equal(1, count)
}
count, err = app.db.countPosts(&postsRequestConfig{
publishedDay: 15,
})
if is.NoError(err) {
is.Equal(0, count)
}
count, err = app.db.countPosts(&postsRequestConfig{
publishedDay: 10,
})
if is.NoError(err) {
is.Equal(1, count)
}
// Check based on tags
count, err = app.db.countPosts(&postsRequestConfig{
parameter: "tags",
parameterValue: "ABC",
})
if is.NoError(err) {
is.Equal(0, count)
}
count, err = app.db.countPosts(&postsRequestConfig{
parameter: "tags",
parameterValue: "Blog",
})
if is.NoError(err) {
is.Equal(1, count)
}
// Check that post is already present
err = app.db.savePost(&post{
Path: "/test/abc",
Content: "ABCD",
Published: "2021-06-10 10:00:00",
Updated: "2021-06-15 10:00:00",
Blog: "en",
Section: "test",
Status: statusPublished,
}, &postCreationOptions{new: true})
must.Error(err)
}
func Test_ftsWithoutTitle(t *testing.T) {
// Added because there was a bug where there were no search results without title
2021-06-29 16:11:42 +00:00
app := &goBlog{
cfg: createDefaultTestConfig(t),
2021-06-29 16:11:42 +00:00
}
_ = app.initConfig(false)
2021-08-05 06:09:34 +00:00
app.initMarkdown()
err := app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC",
Published: toLocalSafe(time.Now().String()),
Updated: toLocalSafe(time.Now().Add(1 * time.Hour).String()),
Blog: "en",
Section: "test",
Status: statusDraft,
}, &postCreationOptions{new: true})
require.NoError(t, err)
2021-08-05 06:09:34 +00:00
ps, err := app.getPosts(&postsRequestConfig{
search: "ABC",
})
assert.NoError(t, err)
assert.Len(t, ps, 1)
}
2021-06-29 16:11:42 +00:00
func Test_postsPriority(t *testing.T) {
// Added because there was a bug where there were no search results without title
app := &goBlog{
cfg: createDefaultTestConfig(t),
}
_ = app.initConfig(false)
2021-08-05 06:09:34 +00:00
app.initMarkdown()
err := app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC",
Published: toLocalSafe(time.Now().String()),
Blog: "en",
Section: "test",
Status: statusPublished,
}, &postCreationOptions{new: true})
require.NoError(t, err)
err = app.db.savePost(&post{
Path: "/test/def",
Content: "DEF",
Published: toLocalSafe(time.Now().String()),
Blog: "en",
Section: "test",
Status: statusPublished,
Priority: 1,
}, &postCreationOptions{new: true})
require.NoError(t, err)
2021-08-05 06:09:34 +00:00
ps, err := app.getPosts(&postsRequestConfig{
priorityOrder: true,
})
require.NoError(t, err)
if assert.Len(t, ps, 2) {
post1 := ps[0]
assert.Equal(t, "/test/def", post1.Path)
assert.Equal(t, 1, post1.Priority)
post2 := ps[1]
assert.Equal(t, "/test/abc", post2.Path)
assert.Equal(t, 0, post2.Priority)
}
}
2021-06-29 16:11:42 +00:00
func Test_usesOfMediaFile(t *testing.T) {
app := &goBlog{
cfg: createDefaultTestConfig(t),
2021-06-29 16:11:42 +00:00
}
_ = app.initConfig(false)
2021-06-29 16:11:42 +00:00
err := app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC test.jpg DEF",
Published: toLocalSafe(time.Now().String()),
Blog: "en",
Section: "test",
Status: statusDraft,
}, &postCreationOptions{new: true})
require.NoError(t, err)
err = app.db.savePost(&post{
Path: "/test/def",
Content: "ABCDEF",
Published: toLocalSafe(time.Now().String()),
Blog: "en",
Section: "test",
Status: statusDraft,
Parameters: map[string][]string{
"test": {
"https://example.com/test.jpg",
},
},
}, &postCreationOptions{new: true})
require.NoError(t, err)
err = app.db.savePost(&post{
Path: "/test/hij",
Content: "ABCDEF",
Published: toLocalSafe(time.Now().String()),
Blog: "en",
Section: "test",
Status: statusDraft,
}, &postCreationOptions{new: true})
require.NoError(t, err)
2021-07-12 17:29:32 +00:00
counts, err := app.db.usesOfMediaFile("test.jpg")
2021-06-29 16:11:42 +00:00
require.NoError(t, err)
2021-07-12 17:29:32 +00:00
assert.Len(t, counts, 1)
2022-01-27 17:17:44 +00:00
if assert.NotEmpty(t, counts) {
assert.Equal(t, 2, counts[0])
2021-07-12 17:29:32 +00:00
}
2021-06-29 16:11:42 +00:00
}
2022-04-15 18:53:19 +00:00
func Test_replaceParams(t *testing.T) {
app := &goBlog{
cfg: createDefaultTestConfig(t),
}
_ = app.initConfig(false)
2022-04-15 18:53:19 +00:00
err := app.db.savePost(&post{
Path: "/test/abc",
Content: "ABC",
Parameters: map[string][]string{
"test": {
"ABC", "DEF", "GHI",
},
},
}, &postCreationOptions{new: true})
require.NoError(t, err)
err = app.db.replacePostParam("/test/abc", "test", []string{"DEF", "123", "456"})
require.NoError(t, err)
p, err := app.getPost("/test/abc")
require.NoError(t, err)
if assert.NotNil(t, p) {
assert.Len(t, p.Parameters["test"], 3)
union := lo.Union(p.Parameters["test"], []string{"DEF", "123", "456"})
assert.Len(t, union, 3)
}
}
func Test_postDeletesParams(t *testing.T) {
app := &goBlog{
cfg: createDefaultTestConfig(t),
}
2022-07-17 05:35:39 +00:00
_ = app.initConfig(false)
app.initMarkdown()
_ = app.initCache()
err := app.createPost(&post{
Path: "/test/abc",
Content: "ABC",
Parameters: map[string][]string{
"test": {
"ABC", "DEF", "GHI",
},
},
})
require.NoError(t, err)
// Delete the first time (mark as delete)
err = app.deletePost("/test/abc")
require.NoError(t, err)
row, err := app.db.QueryRow("select count(*) from post_parameters where path = ? and parameter = ?", "/test/abc", "test")
require.NoError(t, err)
var count int
err = row.Scan(&count)
require.NoError(t, err)
assert.Equal(t, 3, count)
// Delete the second time (actually delete)
err = app.deletePost("/test/abc")
require.NoError(t, err)
row, err = app.db.QueryRow("select count(*) from post_parameters where path = ? and parameter = ?", "/test/abc", "test")
require.NoError(t, err)
err = row.Scan(&count)
require.NoError(t, err)
assert.Equal(t, 0, count)
}
func Test_checkPost(t *testing.T) {
app := &goBlog{
cfg: createDefaultTestConfig(t),
}
_ = app.initConfig(false)
t.Run("New post should get published date", func(t *testing.T) {
p := &post{}
app.checkPost(p, true)
assert.NotEmpty(t, p.Published)
})
t.Run("New post with path should get no published date", func(t *testing.T) {
p := &post{
Path: "/abc",
}
app.checkPost(p, true)
assert.Empty(t, p.Published)
})
t.Run("Updated post with past published date should get updated date", func(t *testing.T) {
p := &post{
Published: time.Now().Local().Add(-1 * time.Hour).Format(time.RFC3339),
}
app.checkPost(p, false)
assert.NotEmpty(t, p.Updated)
})
t.Run("Updated post with future published date should get no updated date", func(t *testing.T) {
p := &post{
Published: time.Now().Local().Add(time.Hour).Format(time.RFC3339),
}
app.checkPost(p, false)
assert.Empty(t, p.Updated)
})
t.Run("Updated post with updated date should get new updated date", func(t *testing.T) {
oldUpdate := time.Now().Local().Add(-1 * time.Hour).Format(time.RFC3339)
p := &post{
Published: time.Now().Local().Add(-2 * time.Hour).Format(time.RFC3339),
Updated: oldUpdate,
}
app.checkPost(p, false)
assert.NotEmpty(t, p.Updated)
assert.NotEqual(t, oldUpdate, p.Updated)
})
2022-12-25 20:06:23 +00:00
t.Run("Updated post with just updated date should get new updated date", func(t *testing.T) {
oldUpdate := time.Now().Local().Add(-1 * time.Hour).Format(time.RFC3339)
p := &post{
Updated: oldUpdate,
}
app.checkPost(p, false)
assert.Empty(t, p.Published)
assert.NotEmpty(t, p.Updated)
assert.NotEqual(t, oldUpdate, p.Updated)
})
t.Run("Invalid status should throw error", func(t *testing.T) {
p := &post{
Status: "unlisted",
}
err := app.checkPost(p, true)
assert.ErrorContains(t, err, "invalid post status")
})
t.Run("Invalid visibility should throw error", func(t *testing.T) {
p := &post{
Visibility: "published",
}
err := app.checkPost(p, true)
assert.ErrorContains(t, err, "invalid post visibility")
})
}