mirror/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2025-08-25 22:00:58 +02:00
Code Issues Packages Projects Releases Wiki Activity

tests: Convert from testify to quicktest

Browse Source
This commit is contained in:
Bjørn Erik Pedersen
2019-08-10 21:05:17 +02:00
parent 6027ee1108
commit 9e57182705
195 changed files with 3919 additions and 3693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
resources/page/page_data_test.go
View File

@@ -19,15 +19,15 @@ import (
"text/template"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestPageData(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
data := make(Data)
assert.Nil(data.Pages())
c.Assert(data.Pages(), qt.IsNil)
pages := Pages{
&testPage{title: "a1"},
@@ -36,22 +36,22 @@ func TestPageData(t *testing.T) {
data["pages"] = pages
assert.Equal(pages, data.Pages())
c.Assert(data.Pages(), eq, pages)
data["pages"] = func() Pages {
return pages
}
assert.Equal(pages, data.Pages())
c.Assert(data.Pages(), eq, pages)
templ, err := template.New("").Parse(`Pages: {{ .Pages }}`)
assert.NoError(err)
c.Assert(err, qt.IsNil)
var buff bytes.Buffer
assert.NoError(templ.Execute(&buff, data))
c.Assert(templ.Execute(&buff, data), qt.IsNil)
assert.Contains(buff.String(), "Pages(2)")
c.Assert(buff.String(), qt.Contains, "Pages(2)")
}

23
resources/page/page_kinds_test.go
View File

@@ -16,22 +16,23 @@ package page
import (
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestKind(t *testing.T) {
t.Parallel()
c := qt.New(t)
// Add tests for these constants to make sure they don't change
require.Equal(t, "page", KindPage)
require.Equal(t, "home", KindHome)
require.Equal(t, "section", KindSection)
require.Equal(t, "taxonomy", KindTaxonomy)
require.Equal(t, "taxonomyTerm", KindTaxonomyTerm)
c.Assert(KindPage, qt.Equals, "page")
c.Assert(KindHome, qt.Equals, "home")
c.Assert(KindSection, qt.Equals, "section")
c.Assert(KindTaxonomy, qt.Equals, "taxonomy")
c.Assert(KindTaxonomyTerm, qt.Equals, "taxonomyTerm")
require.Equal(t, KindTaxonomyTerm, GetKind("TAXONOMYTERM"))
require.Equal(t, KindTaxonomy, GetKind("Taxonomy"))
require.Equal(t, KindPage, GetKind("Page"))
require.Equal(t, KindHome, GetKind("Home"))
require.Equal(t, KindSection, GetKind("SEction"))
c.Assert(GetKind("TAXONOMYTERM"), qt.Equals, KindTaxonomyTerm)
c.Assert(GetKind("Taxonomy"), qt.Equals, KindTaxonomy)
c.Assert(GetKind("Page"), qt.Equals, KindPage)
c.Assert(GetKind("Home"), qt.Equals, KindHome)
c.Assert(GetKind("SEction"), qt.Equals, KindSection)
}

8
resources/page/pagegroup_test.go
View File

@@ -18,8 +18,8 @@ import (
"strings"
"testing"
qt "github.com/frankban/quicktest"
"github.com/spf13/cast"
"github.com/stretchr/testify/require"
)
type pageGroupTestObject struct {
@@ -204,7 +204,7 @@ func TestGroupByParamInReverseOrder(t *testing.T) {
}
func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
testStr := "TestString"
p := newTestPage()
p.params["custom_param"] = testStr
@@ -212,8 +212,8 @@ func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
groups, err := pages.GroupByParam("custom_param")
assert.NoError(err)
assert.Equal(testStr, groups[0].Key)
c.Assert(err, qt.IsNil)
c.Assert(groups[0].Key, qt.Equals, testStr)
}

124
resources/page/pagemeta/page_frontmatter_test.go
View File

@@ -14,7 +14,6 @@
package pagemeta
import (
"fmt"
"strings"
"testing"
"time"
@@ -22,14 +21,14 @@ import (
"github.com/gohugoio/hugo/resources/resource"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestDateAndSlugFromBaseFilename(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
tests := []struct {
name string
@@ -50,15 +49,14 @@ func TestDateAndSlugFromBaseFilename(t *testing.T) {
{"asdfasdf.md", "0001-01-01", ""},
}
for i, test := range tests {
for _, test := range tests {
expecteFDate, err := time.Parse("2006-01-02", test.date)
assert.NoError(err)
c.Assert(err, qt.IsNil)
errMsg := fmt.Sprintf("Test %d", i)
gotDate, gotSlug := dateAndSlugFromBaseFilename(test.name)
assert.Equal(expecteFDate, gotDate, errMsg)
assert.Equal(test.slug, gotSlug, errMsg)
c.Assert(gotDate, qt.Equals, expecteFDate)
c.Assert(gotSlug, qt.Equals, test.slug)
}
}
@@ -73,7 +71,7 @@ func newTestFd() *FrontMatterDescriptor {
}
func TestFrontMatterNewConfig(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
cfg := viper.New()
@@ -85,20 +83,20 @@ func TestFrontMatterNewConfig(t *testing.T) {
})
fc, err := newFrontmatterConfig(cfg)
assert.NoError(err)
assert.Equal([]string{"publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
assert.Equal([]string{"publishdate", "pubdate", "published"}, fc.lastmod)
assert.Equal([]string{"lastmod", "modified"}, fc.expiryDate)
assert.Equal([]string{"date"}, fc.publishDate)
c.Assert(err, qt.IsNil)
c.Assert(fc.date, qt.DeepEquals, []string{"publishdate", "pubdate", "published", "lastmod", "modified"})
c.Assert(fc.lastmod, qt.DeepEquals, []string{"publishdate", "pubdate", "published"})
c.Assert(fc.expiryDate, qt.DeepEquals, []string{"lastmod", "modified"})
c.Assert(fc.publishDate, qt.DeepEquals, []string{"date"})
// Default
cfg = viper.New()
fc, err = newFrontmatterConfig(cfg)
assert.NoError(err)
assert.Equal([]string{"date", "publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
assert.Equal([]string{":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"}, fc.lastmod)
assert.Equal([]string{"expirydate", "unpublishdate"}, fc.expiryDate)
assert.Equal([]string{"publishdate", "pubdate", "published", "date"}, fc.publishDate)
c.Assert(err, qt.IsNil)
c.Assert(fc.date, qt.DeepEquals, []string{"date", "publishdate", "pubdate", "published", "lastmod", "modified"})
c.Assert(fc.lastmod, qt.DeepEquals, []string{":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"})
c.Assert(fc.expiryDate, qt.DeepEquals, []string{"expirydate", "unpublishdate"})
c.Assert(fc.publishDate, qt.DeepEquals, []string{"publishdate", "pubdate", "published", "date"})
// :default keyword
cfg.Set("frontmatter", map[string]interface{}{
@@ -108,16 +106,16 @@ func TestFrontMatterNewConfig(t *testing.T) {
"publishDate": []string{"d4", ":default"},
})
fc, err = newFrontmatterConfig(cfg)
assert.NoError(err)
assert.Equal([]string{"d1", "date", "publishdate", "pubdate", "published", "lastmod", "modified"}, fc.date)
assert.Equal([]string{"d2", ":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"}, fc.lastmod)
assert.Equal([]string{"d3", "expirydate", "unpublishdate"}, fc.expiryDate)
assert.Equal([]string{"d4", "publishdate", "pubdate", "published", "date"}, fc.publishDate)
c.Assert(err, qt.IsNil)
c.Assert(fc.date, qt.DeepEquals, []string{"d1", "date", "publishdate", "pubdate", "published", "lastmod", "modified"})
c.Assert(fc.lastmod, qt.DeepEquals, []string{"d2", ":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"})
c.Assert(fc.expiryDate, qt.DeepEquals, []string{"d3", "expirydate", "unpublishdate"})
c.Assert(fc.publishDate, qt.DeepEquals, []string{"d4", "publishdate", "pubdate", "published", "date"})
}
func TestFrontMatterDatesHandlers(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
for _, handlerID := range []string{":filename", ":fileModTime", ":git"} {
@@ -128,7 +126,7 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
})
handler, err := NewFrontmatterHandler(nil, cfg)
assert.NoError(err)
c.Assert(err, qt.IsNil)
d1, _ := time.Parse("2006-01-02", "2018-02-01")
d2, _ := time.Parse("2006-01-02", "2018-02-02")
@@ -143,15 +141,15 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
d.GitAuthorDate = d1
}
d.Frontmatter["date"] = d2
assert.NoError(handler.HandleDates(d))
assert.Equal(d1, d.Dates.FDate)
assert.Equal(d2, d.Params["date"])
c.Assert(handler.HandleDates(d), qt.IsNil)
c.Assert(d.Dates.FDate, qt.Equals, d1)
c.Assert(d.Params["date"], qt.Equals, d2)
d = newTestFd()
d.Frontmatter["date"] = d2
assert.NoError(handler.HandleDates(d))
assert.Equal(d2, d.Dates.FDate)
assert.Equal(d2, d.Params["date"])
c.Assert(handler.HandleDates(d), qt.IsNil)
c.Assert(d.Dates.FDate, qt.Equals, d2)
c.Assert(d.Params["date"], qt.Equals, d2)
}
}
@@ -159,7 +157,7 @@ func TestFrontMatterDatesHandlers(t *testing.T) {
func TestFrontMatterDatesCustomConfig(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
cfg := viper.New()
cfg.Set("frontmatter", map[string]interface{}{
@@ -169,10 +167,10 @@ func TestFrontMatterDatesCustomConfig(t *testing.T) {
})
handler, err := NewFrontmatterHandler(nil, cfg)
assert.NoError(err)
c.Assert(err, qt.IsNil)
testDate, err := time.Parse("2006-01-02", "2018-02-01")
assert.NoError(err)
c.Assert(err, qt.IsNil)
d := newTestFd()
d.Frontmatter["mydate"] = testDate
@@ -185,29 +183,29 @@ func TestFrontMatterDatesCustomConfig(t *testing.T) {
testDate = testDate.Add(24 * time.Hour)
d.Frontmatter["expirydate"] = testDate
assert.NoError(handler.HandleDates(d))
c.Assert(handler.HandleDates(d), qt.IsNil)
assert.Equal(1, d.Dates.FDate.Day())
assert.Equal(4, d.Dates.FLastmod.Day())
assert.Equal(4, d.Dates.FPublishDate.Day())
assert.Equal(5, d.Dates.FExpiryDate.Day())
c.Assert(d.Dates.FDate.Day(), qt.Equals, 1)
c.Assert(d.Dates.FLastmod.Day(), qt.Equals, 4)
c.Assert(d.Dates.FPublishDate.Day(), qt.Equals, 4)
c.Assert(d.Dates.FExpiryDate.Day(), qt.Equals, 5)
assert.Equal(d.Dates.FDate, d.Params["date"])
assert.Equal(d.Dates.FDate, d.Params["mydate"])
assert.Equal(d.Dates.FPublishDate, d.Params["publishdate"])
assert.Equal(d.Dates.FExpiryDate, d.Params["expirydate"])
c.Assert(d.Params["date"], qt.Equals, d.Dates.FDate)
c.Assert(d.Params["mydate"], qt.Equals, d.Dates.FDate)
c.Assert(d.Params["publishdate"], qt.Equals, d.Dates.FPublishDate)
c.Assert(d.Params["expirydate"], qt.Equals, d.Dates.FExpiryDate)
assert.False(handler.IsDateKey("date")) // This looks odd, but is configured like this.
assert.True(handler.IsDateKey("mydate"))
assert.True(handler.IsDateKey("publishdate"))
assert.True(handler.IsDateKey("pubdate"))
c.Assert(handler.IsDateKey("date"), qt.Equals, false) // This looks odd, but is configured like this.
c.Assert(handler.IsDateKey("mydate"), qt.Equals, true)
c.Assert(handler.IsDateKey("publishdate"), qt.Equals, true)
c.Assert(handler.IsDateKey("pubdate"), qt.Equals, true)
}
func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
cfg := viper.New()
@@ -217,7 +215,7 @@ func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
})
handler, err := NewFrontmatterHandler(nil, cfg)
assert.NoError(err)
c.Assert(err, qt.IsNil)
testDate, _ := time.Parse("2006-01-02", "2018-02-01")
d := newTestFd()
@@ -226,27 +224,27 @@ func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
d.Frontmatter["mypubdate"] = testDate.Add(2 * 24 * time.Hour)
d.Frontmatter["publishdate"] = testDate.Add(3 * 24 * time.Hour)
assert.NoError(handler.HandleDates(d))
c.Assert(handler.HandleDates(d), qt.IsNil)
assert.Equal(1, d.Dates.FDate.Day())
assert.Equal(2, d.Dates.FLastmod.Day())
assert.Equal(4, d.Dates.FPublishDate.Day())
assert.True(d.Dates.FExpiryDate.IsZero())
c.Assert(d.Dates.FDate.Day(), qt.Equals, 1)
c.Assert(d.Dates.FLastmod.Day(), qt.Equals, 2)
c.Assert(d.Dates.FPublishDate.Day(), qt.Equals, 4)
c.Assert(d.Dates.FExpiryDate.IsZero(), qt.Equals, true)
}
func TestExpandDefaultValues(t *testing.T) {
assert := require.New(t)
assert.Equal([]string{"a", "b", "c", "d"}, expandDefaultValues([]string{"a", ":default", "d"}, []string{"b", "c"}))
assert.Equal([]string{"a", "b", "c"}, expandDefaultValues([]string{"a", "b", "c"}, []string{"a", "b", "c"}))
assert.Equal([]string{"b", "c", "a", "b", "c", "d"}, expandDefaultValues([]string{":default", "a", ":default", "d"}, []string{"b", "c"}))
c := qt.New(t)
c.Assert(expandDefaultValues([]string{"a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"a", "b", "c", "d"})
c.Assert(expandDefaultValues([]string{"a", "b", "c"}, []string{"a", "b", "c"}), qt.DeepEquals, []string{"a", "b", "c"})
c.Assert(expandDefaultValues([]string{":default", "a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"b", "c", "a", "b", "c", "d"})
}
func TestFrontMatterDateFieldHandler(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
handlers := new(frontmatterFieldHandlers)
@@ -256,7 +254,7 @@ func TestFrontMatterDateFieldHandler(t *testing.T) {
h := handlers.newDateFieldHandler("date", func(d *FrontMatterDescriptor, t time.Time) { d.Dates.FDate = t })
handled, err := h(fd)
assert.True(handled)
assert.NoError(err)
assert.Equal(d, fd.Dates.FDate)
c.Assert(handled, qt.Equals, true)
c.Assert(err, qt.IsNil)
c.Assert(fd.Dates.FDate, qt.Equals, d)
}

21
resources/page/pages_cache_test.go
View File

@@ -19,11 +19,12 @@ import (
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
qt "github.com/frankban/quicktest"
)
func TestPageCache(t *testing.T) {
t.Parallel()
c := qt.New(t)
c1 := newPageCache()
changeFirst := func(p Pages) {
@@ -50,21 +51,21 @@ func TestPageCache(t *testing.T) {
defer wg.Done()
for k, pages := range testPageSets {
l1.Lock()
p, c := c1.get("k1", nil, pages)
assert.Equal(t, !atomic.CompareAndSwapUint64(&o1, uint64(k), uint64(k+1)), c)
p, ca := c1.get("k1", nil, pages)
c.Assert(ca, qt.Equals, !atomic.CompareAndSwapUint64(&o1, uint64(k), uint64(k+1)))
l1.Unlock()
p2, c2 := c1.get("k1", nil, p)
assert.True(t, c2)
assert.True(t, pagesEqual(p, p2))
assert.True(t, pagesEqual(p, pages))
assert.NotNil(t, p)
c.Assert(c2, qt.Equals, true)
c.Assert(pagesEqual(p, p2), qt.Equals, true)
c.Assert(pagesEqual(p, pages), qt.Equals, true)
c.Assert(p, qt.Not(qt.IsNil))
l2.Lock()
p3, c3 := c1.get("k2", changeFirst, pages)
assert.Equal(t, !atomic.CompareAndSwapUint64(&o2, uint64(k), uint64(k+1)), c3)
c.Assert(c3, qt.Equals, !atomic.CompareAndSwapUint64(&o2, uint64(k), uint64(k+1)))
l2.Unlock()
assert.NotNil(t, p3)
assert.Equal(t, p3[0].(*testPage).description, "changed")
c.Assert(p3, qt.Not(qt.IsNil))
c.Assert("changed", qt.Equals, p3[0].(*testPage).description)
}
}()
}

30
resources/page/pages_prev_next_test.go
View File

@@ -16,8 +16,8 @@ package page
import (
"testing"
qt "github.com/frankban/quicktest"
"github.com/spf13/cast"
"github.com/stretchr/testify/assert"
)
type pagePNTestObject struct {
@@ -36,18 +36,20 @@ var pagePNTestSources = []pagePNTestObject{
func TestPrev(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := preparePageGroupTestPages(t)
assert.Equal(t, pages.Prev(pages[0]), pages[4])
assert.Equal(t, pages.Prev(pages[1]), pages[0])
assert.Equal(t, pages.Prev(pages[4]), pages[3])
c.Assert(pages[4], qt.Equals, pages.Prev(pages[0]))
c.Assert(pages[0], qt.Equals, pages.Prev(pages[1]))
c.Assert(pages[3], qt.Equals, pages.Prev(pages[4]))
}
func TestNext(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := preparePageGroupTestPages(t)
assert.Equal(t, pages.Next(pages[0]), pages[1])
assert.Equal(t, pages.Next(pages[1]), pages[2])
assert.Equal(t, pages.Next(pages[4]), pages[0])
c.Assert(pages[1], qt.Equals, pages.Next(pages[0]))
c.Assert(pages[2], qt.Equals, pages.Next(pages[1]))
c.Assert(pages[0], qt.Equals, pages.Next(pages[4]))
}
func prepareWeightedPagesPrevNext(t *testing.T) WeightedPages {
@@ -68,16 +70,18 @@ func prepareWeightedPagesPrevNext(t *testing.T) WeightedPages {
func TestWeightedPagesPrev(t *testing.T) {
t.Parallel()
c := qt.New(t)
w := prepareWeightedPagesPrevNext(t)
assert.Equal(t, w.Prev(w[0].Page), w[4].Page)
assert.Equal(t, w.Prev(w[1].Page), w[0].Page)
assert.Equal(t, w.Prev(w[4].Page), w[3].Page)
c.Assert(w[4].Page, qt.Equals, w.Prev(w[0].Page))
c.Assert(w[0].Page, qt.Equals, w.Prev(w[1].Page))
c.Assert(w[3].Page, qt.Equals, w.Prev(w[4].Page))
}
func TestWeightedPagesNext(t *testing.T) {
t.Parallel()
c := qt.New(t)
w := prepareWeightedPagesPrevNext(t)
assert.Equal(t, w.Next(w[0].Page), w[1].Page)
assert.Equal(t, w.Next(w[1].Page), w[2].Page)
assert.Equal(t, w.Next(w[4].Page), w[0].Page)
c.Assert(w[1].Page, qt.Equals, w.Next(w[0].Page))
c.Assert(w[2].Page, qt.Equals, w.Next(w[1].Page))
c.Assert(w[0].Page, qt.Equals, w.Next(w[4].Page))
}

36
resources/page/pages_related_test.go
View File

@@ -19,11 +19,11 @@ import (
"github.com/gohugoio/hugo/common/types"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestRelated(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
t.Parallel()
@@ -53,28 +53,28 @@ func TestRelated(t *testing.T) {
result, err := pages.RelatedTo(types.NewKeyValuesStrings("keywords", "hugo", "rocks"))
assert.NoError(err)
assert.Len(result, 2)
assert.Equal("Page 2", result[0].Title())
assert.Equal("Page 1", result[1].Title())
c.Assert(err, qt.IsNil)
c.Assert(len(result), qt.Equals, 2)
c.Assert(result[0].Title(), qt.Equals, "Page 2")
c.Assert(result[1].Title(), qt.Equals, "Page 1")
result, err = pages.Related(pages[0])
assert.NoError(err)
assert.Len(result, 2)
assert.Equal("Page 2", result[0].Title())
assert.Equal("Page 3", result[1].Title())
c.Assert(err, qt.IsNil)
c.Assert(len(result), qt.Equals, 2)
c.Assert(result[0].Title(), qt.Equals, "Page 2")
c.Assert(result[1].Title(), qt.Equals, "Page 3")
result, err = pages.RelatedIndices(pages[0], "keywords")
assert.NoError(err)
assert.Len(result, 2)
assert.Equal("Page 2", result[0].Title())
assert.Equal("Page 3", result[1].Title())
c.Assert(err, qt.IsNil)
c.Assert(len(result), qt.Equals, 2)
c.Assert(result[0].Title(), qt.Equals, "Page 2")
c.Assert(result[1].Title(), qt.Equals, "Page 3")
result, err = pages.RelatedTo(types.NewKeyValuesStrings("keywords", "bep", "rocks"))
assert.NoError(err)
assert.Len(result, 2)
assert.Equal("Page 2", result[0].Title())
assert.Equal("Page 3", result[1].Title())
c.Assert(err, qt.IsNil)
c.Assert(len(result), qt.Equals, 2)
c.Assert(result[0].Title(), qt.Equals, "Page 2")
c.Assert(result[1].Title(), qt.Equals, "Page 3")
}
func mustParseDate(s string) time.Time {

86
resources/page/pages_sort_test.go
View File

@@ -18,14 +18,22 @@ import (
"testing"
"time"
"github.com/gohugoio/hugo/htesting/hqt"
"github.com/gohugoio/hugo/source"
"github.com/gohugoio/hugo/resources/resource"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
var eq = qt.CmpEquals(hqt.DeepAllowUnexported(
&testPage{},
&source.FileInfo{},
))
func TestDefaultSort(t *testing.T) {
t.Parallel()
c := qt.New(t)
d1 := time.Now()
d2 := d1.Add(-1 * time.Hour)
d3 := d1.Add(-2 * time.Hour)
@@ -37,31 +45,31 @@ func TestDefaultSort(t *testing.T) {
setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "c", "d"}, [4]int{4, 3, 2, 1}, p)
SortByDefault(p)
assert.Equal(t, 1, p[0].Weight())
c.Assert(p[0].Weight(), qt.Equals, 1)
// Consider zero weight, issue #2673
setSortVals([4]time.Time{d1, d2, d3, d4}, [4]string{"b", "a", "d", "c"}, [4]int{0, 0, 0, 1}, p)
SortByDefault(p)
assert.Equal(t, 1, p[0].Weight())
c.Assert(p[0].Weight(), qt.Equals, 1)
// next by date
setSortVals([4]time.Time{d3, d4, d1, d2}, [4]string{"a", "b", "c", "d"}, [4]int{1, 1, 1, 1}, p)
SortByDefault(p)
assert.Equal(t, d1, p[0].Date())
c.Assert(p[0].Date(), qt.Equals, d1)
// finally by link title
setSortVals([4]time.Time{d3, d3, d3, d3}, [4]string{"b", "c", "a", "d"}, [4]int{1, 1, 1, 1}, p)
SortByDefault(p)
assert.Equal(t, "al", p[0].LinkTitle())
assert.Equal(t, "bl", p[1].LinkTitle())
assert.Equal(t, "cl", p[2].LinkTitle())
c.Assert(p[0].LinkTitle(), qt.Equals, "al")
c.Assert(p[1].LinkTitle(), qt.Equals, "bl")
c.Assert(p[2].LinkTitle(), qt.Equals, "cl")
}
// https://github.com/gohugoio/hugo/issues/4953
func TestSortByLinkTitle(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
pages := createSortTestPages(6)
for i, p := range pages {
@@ -81,11 +89,10 @@ func TestSortByLinkTitle(t *testing.T) {
bylt := pages.ByLinkTitle()
for i, p := range bylt {
msg := fmt.Sprintf("test: %d", i)
if i < 3 {
assert.Equal(fmt.Sprintf("linkTitle%d", i+3), p.LinkTitle(), msg)
c.Assert(p.LinkTitle(), qt.Equals, fmt.Sprintf("linkTitle%d", i+3))
} else {
assert.Equal(fmt.Sprintf("title%d", i-3), p.LinkTitle(), msg)
c.Assert(p.LinkTitle(), qt.Equals, fmt.Sprintf("title%d", i-3))
}
}
}
@@ -124,30 +131,33 @@ func TestSortByN(t *testing.T) {
func TestLimit(t *testing.T) {
t.Parallel()
c := qt.New(t)
p := createSortTestPages(10)
firstFive := p.Limit(5)
assert.Equal(t, 5, len(firstFive))
c.Assert(len(firstFive), qt.Equals, 5)
for i := 0; i < 5; i++ {
assert.Equal(t, p[i], firstFive[i])
c.Assert(firstFive[i], qt.Equals, p[i])
}
assert.Equal(t, p, p.Limit(10))
assert.Equal(t, p, p.Limit(11))
c.Assert(p.Limit(10), eq, p)
c.Assert(p.Limit(11), eq, p)
}
func TestPageSortReverse(t *testing.T) {
t.Parallel()
c := qt.New(t)
p1 := createSortTestPages(10)
assert.Equal(t, 0, p1[0].(*testPage).fuzzyWordCount)
assert.Equal(t, 9, p1[9].(*testPage).fuzzyWordCount)
c.Assert(p1[0].(*testPage).fuzzyWordCount, qt.Equals, 0)
c.Assert(p1[9].(*testPage).fuzzyWordCount, qt.Equals, 9)
p2 := p1.Reverse()
assert.Equal(t, 9, p2[0].(*testPage).fuzzyWordCount)
assert.Equal(t, 0, p2[9].(*testPage).fuzzyWordCount)
c.Assert(p2[0].(*testPage).fuzzyWordCount, qt.Equals, 9)
c.Assert(p2[9].(*testPage).fuzzyWordCount, qt.Equals, 0)
// cached
assert.True(t, pagesEqual(p2, p1.Reverse()))
c.Assert(pagesEqual(p2, p1.Reverse()), qt.Equals, true)
}
func TestPageSortByParam(t *testing.T) {
t.Parallel()
c := qt.New(t)
var k interface{} = "arbitrarily.nested"
unsorted := createSortTestPages(10)
@@ -158,10 +168,10 @@ func TestPageSortByParam(t *testing.T) {
lastSetValue, _ := unsorted[8].Param(k)
unsetValue, _ := unsorted[9].Param(k)
assert.Equal(t, "xyz100", firstSetValue)
assert.Equal(t, "xyz99", secondSetValue)
assert.Equal(t, "xyz92", lastSetValue)
assert.Equal(t, nil, unsetValue)
c.Assert(firstSetValue, qt.Equals, "xyz100")
c.Assert(secondSetValue, qt.Equals, "xyz99")
c.Assert(lastSetValue, qt.Equals, "xyz92")
c.Assert(unsetValue, qt.Equals, nil)
sorted := unsorted.ByParam("arbitrarily.nested")
firstSetSortedValue, _ := sorted[0].Param(k)
@@ -169,14 +179,16 @@ func TestPageSortByParam(t *testing.T) {
lastSetSortedValue, _ := sorted[8].Param(k)
unsetSortedValue, _ := sorted[9].Param(k)
assert.Equal(t, firstSetValue, firstSetSortedValue)
assert.Equal(t, secondSetValue, lastSetSortedValue)
assert.Equal(t, lastSetValue, secondSetSortedValue)
assert.Equal(t, unsetValue, unsetSortedValue)
c.Assert(firstSetSortedValue, qt.Equals, firstSetValue)
c.Assert(lastSetSortedValue, qt.Equals, secondSetValue)
c.Assert(secondSetSortedValue, qt.Equals, lastSetValue)
c.Assert(unsetSortedValue, qt.Equals, unsetValue)
}
func TestPageSortByParamNumeric(t *testing.T) {
t.Parallel()
c := qt.New(t)
var k interface{} = "arbitrarily.nested"
n := 10
@@ -200,10 +212,10 @@ func TestPageSortByParamNumeric(t *testing.T) {
lastSetValue, _ := unsorted[8].Param(k)
unsetValue, _ := unsorted[9].Param(k)
assert.Equal(t, 100, firstSetValue)
assert.Equal(t, 99, secondSetValue)
assert.Equal(t, 92, lastSetValue)
assert.Equal(t, nil, unsetValue)
c.Assert(firstSetValue, qt.Equals, 100)
c.Assert(secondSetValue, qt.Equals, 99)
c.Assert(lastSetValue, qt.Equals, 92)
c.Assert(unsetValue, qt.Equals, nil)
sorted := unsorted.ByParam("arbitrarily.nested")
firstSetSortedValue, _ := sorted[0].Param(k)
@@ -211,10 +223,10 @@ func TestPageSortByParamNumeric(t *testing.T) {
lastSetSortedValue, _ := sorted[8].Param(k)
unsetSortedValue, _ := sorted[9].Param(k)
assert.Equal(t, 92, firstSetSortedValue)
assert.Equal(t, 93, secondSetSortedValue)
assert.Equal(t, 100, lastSetSortedValue)
assert.Equal(t, unsetValue, unsetSortedValue)
c.Assert(firstSetSortedValue, qt.Equals, 92)
c.Assert(secondSetSortedValue, qt.Equals, 93)
c.Assert(lastSetSortedValue, qt.Equals, 100)
c.Assert(unsetSortedValue, qt.Equals, unsetValue)
}
func BenchmarkSortByWeightAndReverse(b *testing.B) {

36
resources/page/pages_test.go
View File

@@ -16,7 +16,7 @@ package page
import (
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestProbablyEq(t *testing.T) {
@@ -27,50 +27,50 @@ func TestProbablyEq(t *testing.T) {
pages123 := Pages{p1, p2, p3}
t.Run("Pages", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
assert.True(pages12.ProbablyEq(pages12))
assert.False(pages123.ProbablyEq(pages12))
assert.False(pages12.ProbablyEq(pages21))
c.Assert(pages12.ProbablyEq(pages12), qt.Equals, true)
c.Assert(pages123.ProbablyEq(pages12), qt.Equals, false)
c.Assert(pages12.ProbablyEq(pages21), qt.Equals, false)
})
t.Run("PageGroup", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
assert.True(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "a", Pages: pages12}))
assert.False(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "b", Pages: pages12}))
c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "a", Pages: pages12}), qt.Equals, true)
c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "b", Pages: pages12}), qt.Equals, false)
})
t.Run("PagesGroup", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
pg1, pg2 := PageGroup{Key: "a", Pages: pages12}, PageGroup{Key: "b", Pages: pages123}
assert.True(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg1, pg2}))
assert.False(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg2, pg1}))
c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg1, pg2}), qt.Equals, true)
c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg2, pg1}), qt.Equals, false)
})
}
func TestToPages(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
p1, p2 := &testPage{title: "p1"}, &testPage{title: "p2"}
pages12 := Pages{p1, p2}
mustToPages := func(in interface{}) Pages {
p, err := ToPages(in)
assert.NoError(err)
c.Assert(err, qt.IsNil)
return p
}
assert.Equal(Pages{}, mustToPages(nil))
assert.Equal(pages12, mustToPages(pages12))
assert.Equal(pages12, mustToPages([]Page{p1, p2}))
assert.Equal(pages12, mustToPages([]interface{}{p1, p2}))
c.Assert(mustToPages(nil), eq, Pages{})
c.Assert(mustToPages(pages12), eq, pages12)
c.Assert(mustToPages([]Page{p1, p2}), eq, pages12)
c.Assert(mustToPages([]interface{}{p1, p2}), eq, pages12)
_, err := ToPages("not a page")
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}

149
resources/page/pagination_test.go
View File

@@ -20,43 +20,44 @@ import (
"github.com/spf13/viper"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/output"
"github.com/stretchr/testify/require"
)
func TestSplitPages(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := createTestPages(21)
chunks := splitPages(pages, 5)
require.Equal(t, 5, len(chunks))
c.Assert(len(chunks), qt.Equals, 5)
for i := 0; i < 4; i++ {
require.Equal(t, 5, chunks[i].Len())
c.Assert(chunks[i].Len(), qt.Equals, 5)
}
lastChunk := chunks[4]
require.Equal(t, 1, lastChunk.Len())
c.Assert(lastChunk.Len(), qt.Equals, 1)
}
func TestSplitPageGroups(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := createTestPages(21)
groups, _ := pages.GroupBy("Weight", "desc")
chunks := splitPageGroups(groups, 5)
require.Equal(t, 5, len(chunks))
c.Assert(len(chunks), qt.Equals, 5)
firstChunk := chunks[0]
// alternate weight 5 and 10
if groups, ok := firstChunk.(PagesGroup); ok {
require.Equal(t, 5, groups.Len())
c.Assert(groups.Len(), qt.Equals, 5)
for _, pg := range groups {
// first group 10 in weight
require.Equal(t, 10, pg.Key)
c.Assert(pg.Key, qt.Equals, 10)
for _, p := range pg.Pages {
require.True(t, p.FuzzyWordCount()%2 == 0) // magic test
c.Assert(p.FuzzyWordCount()%2 == 0, qt.Equals, true) // magic test
}
}
} else {
@@ -66,12 +67,12 @@ func TestSplitPageGroups(t *testing.T) {
lastChunk := chunks[4]
if groups, ok := lastChunk.(PagesGroup); ok {
require.Equal(t, 1, groups.Len())
c.Assert(groups.Len(), qt.Equals, 1)
for _, pg := range groups {
// last should have 5 in weight
require.Equal(t, 5, pg.Key)
c.Assert(pg.Key, qt.Equals, 5)
for _, p := range pg.Pages {
require.True(t, p.FuzzyWordCount()%2 != 0) // magic test
c.Assert(p.FuzzyWordCount()%2 != 0, qt.Equals, true) // magic test
}
}
} else {
@@ -82,6 +83,7 @@ func TestSplitPageGroups(t *testing.T) {
func TestPager(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := createTestPages(21)
groups, _ := pages.GroupBy("Weight", "desc")
@@ -90,64 +92,65 @@ func TestPager(t *testing.T) {
}
_, err := newPaginatorFromPages(pages, -1, urlFactory)
require.NotNil(t, err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = newPaginatorFromPageGroups(groups, -1, urlFactory)
require.NotNil(t, err)
c.Assert(err, qt.Not(qt.IsNil))
pag, err := newPaginatorFromPages(pages, 5, urlFactory)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
doTestPages(t, pag)
first := pag.Pagers()[0].First()
require.Equal(t, "Pager 1", first.String())
require.NotEmpty(t, first.Pages())
require.Empty(t, first.PageGroups())
c.Assert(first.String(), qt.Equals, "Pager 1")
c.Assert(first.Pages(), qt.Not(qt.HasLen), 0)
c.Assert(first.PageGroups(), qt.HasLen, 0)
pag, err = newPaginatorFromPageGroups(groups, 5, urlFactory)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
doTestPages(t, pag)
first = pag.Pagers()[0].First()
require.NotEmpty(t, first.PageGroups())
require.Empty(t, first.Pages())
c.Assert(first.PageGroups(), qt.Not(qt.HasLen), 0)
c.Assert(first.Pages(), qt.HasLen, 0)
}
func doTestPages(t *testing.T, paginator *Paginator) {
c := qt.New(t)
paginatorPages := paginator.Pagers()
require.Equal(t, 5, len(paginatorPages))
require.Equal(t, 21, paginator.TotalNumberOfElements())
require.Equal(t, 5, paginator.PageSize())
require.Equal(t, 5, paginator.TotalPages())
c.Assert(len(paginatorPages), qt.Equals, 5)
c.Assert(paginator.TotalNumberOfElements(), qt.Equals, 21)
c.Assert(paginator.PageSize(), qt.Equals, 5)
c.Assert(paginator.TotalPages(), qt.Equals, 5)
first := paginatorPages[0]
require.Equal(t, template.HTML("page/1/"), first.URL())
require.Equal(t, first, first.First())
require.True(t, first.HasNext())
require.Equal(t, paginatorPages[1], first.Next())
require.False(t, first.HasPrev())
require.Nil(t, first.Prev())
require.Equal(t, 5, first.NumberOfElements())
require.Equal(t, 1, first.PageNumber())
c.Assert(first.URL(), qt.Equals, template.HTML("page/1/"))
c.Assert(first.First(), qt.Equals, first)
c.Assert(first.HasNext(), qt.Equals, true)
c.Assert(first.Next(), qt.Equals, paginatorPages[1])
c.Assert(first.HasPrev(), qt.Equals, false)
c.Assert(first.Prev(), qt.IsNil)
c.Assert(first.NumberOfElements(), qt.Equals, 5)
c.Assert(first.PageNumber(), qt.Equals, 1)
third := paginatorPages[2]
require.True(t, third.HasNext())
require.True(t, third.HasPrev())
require.Equal(t, paginatorPages[1], third.Prev())
c.Assert(third.HasNext(), qt.Equals, true)
c.Assert(third.HasPrev(), qt.Equals, true)
c.Assert(third.Prev(), qt.Equals, paginatorPages[1])
last := paginatorPages[4]
require.Equal(t, template.HTML("page/5/"), last.URL())
require.Equal(t, last, last.Last())
require.False(t, last.HasNext())
require.Nil(t, last.Next())
require.True(t, last.HasPrev())
require.Equal(t, 1, last.NumberOfElements())
require.Equal(t, 5, last.PageNumber())
c.Assert(last.URL(), qt.Equals, template.HTML("page/5/"))
c.Assert(last.Last(), qt.Equals, last)
c.Assert(last.HasNext(), qt.Equals, false)
c.Assert(last.Next(), qt.IsNil)
c.Assert(last.HasPrev(), qt.Equals, true)
c.Assert(last.NumberOfElements(), qt.Equals, 1)
c.Assert(last.PageNumber(), qt.Equals, 5)
}
func TestPagerNoPages(t *testing.T) {
t.Parallel()
c := qt.New(t)
pages := createTestPages(0)
groups, _ := pages.GroupBy("Weight", "desc")
@@ -159,49 +162,50 @@ func TestPagerNoPages(t *testing.T) {
doTestPagerNoPages(t, paginator)
first := paginator.Pagers()[0].First()
require.Empty(t, first.PageGroups())
require.Empty(t, first.Pages())
c.Assert(first.PageGroups(), qt.HasLen, 0)
c.Assert(first.Pages(), qt.HasLen, 0)
paginator, _ = newPaginatorFromPageGroups(groups, 5, urlFactory)
doTestPagerNoPages(t, paginator)
first = paginator.Pagers()[0].First()
require.Empty(t, first.PageGroups())
require.Empty(t, first.Pages())
c.Assert(first.PageGroups(), qt.HasLen, 0)
c.Assert(first.Pages(), qt.HasLen, 0)
}
func doTestPagerNoPages(t *testing.T, paginator *Paginator) {
paginatorPages := paginator.Pagers()
require.Equal(t, 1, len(paginatorPages))
require.Equal(t, 0, paginator.TotalNumberOfElements())
require.Equal(t, 5, paginator.PageSize())
require.Equal(t, 0, paginator.TotalPages())
c := qt.New(t)
c.Assert(len(paginatorPages), qt.Equals, 1)
c.Assert(paginator.TotalNumberOfElements(), qt.Equals, 0)
c.Assert(paginator.PageSize(), qt.Equals, 5)
c.Assert(paginator.TotalPages(), qt.Equals, 0)
// pageOne should be nothing but the first
pageOne := paginatorPages[0]
require.NotNil(t, pageOne.First())
require.False(t, pageOne.HasNext())
require.False(t, pageOne.HasPrev())
require.Nil(t, pageOne.Next())
require.Equal(t, 1, len(pageOne.Pagers()))
require.Equal(t, 0, pageOne.Pages().Len())
require.Equal(t, 0, pageOne.NumberOfElements())
require.Equal(t, 0, pageOne.TotalNumberOfElements())
require.Equal(t, 0, pageOne.TotalPages())
require.Equal(t, 1, pageOne.PageNumber())
require.Equal(t, 5, pageOne.PageSize())
c.Assert(pageOne.First(), qt.Not(qt.IsNil))
c.Assert(pageOne.HasNext(), qt.Equals, false)
c.Assert(pageOne.HasPrev(), qt.Equals, false)
c.Assert(pageOne.Next(), qt.IsNil)
c.Assert(len(pageOne.Pagers()), qt.Equals, 1)
c.Assert(pageOne.Pages().Len(), qt.Equals, 0)
c.Assert(pageOne.NumberOfElements(), qt.Equals, 0)
c.Assert(pageOne.TotalNumberOfElements(), qt.Equals, 0)
c.Assert(pageOne.TotalPages(), qt.Equals, 0)
c.Assert(pageOne.PageNumber(), qt.Equals, 1)
c.Assert(pageOne.PageSize(), qt.Equals, 5)
}
func TestPaginationURLFactory(t *testing.T) {
t.Parallel()
c := qt.New(t)
cfg := viper.New()
cfg.Set("paginatePath", "zoo")
for _, uglyURLs := range []bool{false, true} {
t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {
c.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(c *qt.C) {
tests := []struct {
name string
@@ -231,9 +235,9 @@ func TestPaginationURLFactory(t *testing.T) {
got := factory(test.page)
if uglyURLs {
require.Equal(t, test.expectedUgly, got)
c.Assert(got, qt.Equals, test.expectedUgly)
} else {
require.Equal(t, test.expected, got)
c.Assert(got, qt.Equals, test.expected)
}
}
@@ -279,6 +283,7 @@ func TestProbablyEqualPageLists(t *testing.T) {
func TestPaginationPage(t *testing.T) {
t.Parallel()
c := qt.New(t)
urlFactory := func(page int) string {
return fmt.Sprintf("page/%d/", page)
}
@@ -298,10 +303,10 @@ func TestPaginationPage(t *testing.T) {
page21, _ := f2.page(1)
page2Nil, _ := f2.page(3)
require.Equal(t, 3, page11.FuzzyWordCount())
require.Nil(t, page1Nil)
c.Assert(page11.FuzzyWordCount(), qt.Equals, 3)
c.Assert(page1Nil, qt.IsNil)
require.NotNil(t, page21)
require.Equal(t, 3, page21.FuzzyWordCount())
require.Nil(t, page2Nil)
c.Assert(page21, qt.Not(qt.IsNil))
c.Assert(page21.FuzzyWordCount(), qt.Equals, 3)
c.Assert(page2Nil, qt.IsNil)
}

35
resources/page/permalinks_test.go
View File

@@ -19,7 +19,7 @@ import (
"testing"
"time"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
// testdataPermalinks is used by a couple of tests; the expandsTo content is
@@ -47,7 +47,7 @@ var testdataPermalinks = []struct {
func TestPermalinkExpansion(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
page := newTestPageWithFile("/test-page/index.md")
page.title = "Spf13 Vim 3.0 Release and new website"
@@ -56,10 +56,7 @@ func TestPermalinkExpansion(t *testing.T) {
page.section = "blue"
page.slug = "The Slug"
for i, item := range testdataPermalinks {
msg := fmt.Sprintf("Test %d", i)
for _, item := range testdataPermalinks {
if !item.valid {
continue
}
@@ -72,11 +69,11 @@ func TestPermalinkExpansion(t *testing.T) {
ps.Cfg.Set("permalinks", permalinksConfig)
expander, err := NewPermalinkExpander(ps)
assert.NoError(err)
c.Assert(err, qt.IsNil)
expanded, err := expander.Expand("posts", page)
assert.NoError(err)
assert.Equal(item.expandsTo, expanded, msg)
c.Assert(err, qt.IsNil)
c.Assert(expanded, qt.Equals, item.expandsTo)
}
}
@@ -84,7 +81,7 @@ func TestPermalinkExpansion(t *testing.T) {
func TestPermalinkExpansionMultiSection(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
page := newTestPage()
page.title = "Page Title"
@@ -102,22 +99,22 @@ func TestPermalinkExpansionMultiSection(t *testing.T) {
ps.Cfg.Set("permalinks", permalinksConfig)
expander, err := NewPermalinkExpander(ps)
assert.NoError(err)
c.Assert(err, qt.IsNil)
expanded, err := expander.Expand("posts", page)
assert.NoError(err)
assert.Equal("/the-slug", expanded)
c.Assert(err, qt.IsNil)
c.Assert(expanded, qt.Equals, "/the-slug")
expanded, err = expander.Expand("blog", page)
assert.NoError(err)
assert.Equal("/blue/2012", expanded)
c.Assert(err, qt.IsNil)
c.Assert(expanded, qt.Equals, "/blue/2012")
}
func TestPermalinkExpansionConcurrent(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
permalinksConfig := map[string]string{
"posts": "/:slug/",
@@ -127,7 +124,7 @@ func TestPermalinkExpansionConcurrent(t *testing.T) {
ps.Cfg.Set("permalinks", permalinksConfig)
expander, err := NewPermalinkExpander(ps)
assert.NoError(err)
c.Assert(err, qt.IsNil)
var wg sync.WaitGroup
@@ -139,8 +136,8 @@ func TestPermalinkExpansionConcurrent(t *testing.T) {
for j := 1; j < 20; j++ {
page.slug = fmt.Sprintf("slug%d", i+j)
expanded, err := expander.Expand("posts", page)
assert.NoError(err)
assert.Equal(fmt.Sprintf("/%s/", page.slug), expanded)
c.Assert(err, qt.IsNil)
c.Assert(expanded, qt.Equals, fmt.Sprintf("/%s/", page.slug))
}
}(i)
}