mirror/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2025-08-27 22:09:53 +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

268
resources/image_test.go
View File

@@ -20,11 +20,13 @@ import (
"strconv"
"testing"
"github.com/gohugoio/hugo/htesting/hqt"
"github.com/disintegration/imaging"
"sync"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestParseImageConfig(t *testing.T) {
@@ -59,107 +61,107 @@ func TestParseImageConfig(t *testing.T) {
func TestImageTransformBasic(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
image := fetchSunset(assert)
image := fetchSunset(c)
fileCache := image.spec.FileCaches.ImageCache().Fs
assert.Equal("/a/sunset.jpg", image.RelPermalink())
assert.Equal("image", image.ResourceType())
c.Assert(image.RelPermalink(), qt.Equals, "/a/sunset.jpg")
c.Assert(image.ResourceType(), qt.Equals, "image")
resized, err := image.Resize("300x200")
assert.NoError(err)
assert.True(image != resized)
assert.True(image.genericResource != resized.genericResource)
assert.True(image.sourceFilename != resized.sourceFilename)
c.Assert(err, qt.IsNil)
c.Assert(image != resized, qt.Equals, true)
c.Assert(image.genericResource != resized.genericResource, qt.Equals, true)
c.Assert(image.sourceFilename != resized.sourceFilename, qt.Equals, true)
resized0x, err := image.Resize("x200")
assert.NoError(err)
assert.Equal(320, resized0x.Width())
assert.Equal(200, resized0x.Height())
c.Assert(err, qt.IsNil)
c.Assert(resized0x.Width(), qt.Equals, 320)
c.Assert(resized0x.Height(), qt.Equals, 200)
assertFileCache(assert, fileCache, resized0x.RelPermalink(), 320, 200)
assertFileCache(c, fileCache, resized0x.RelPermalink(), 320, 200)
resizedx0, err := image.Resize("200x")
assert.NoError(err)
assert.Equal(200, resizedx0.Width())
assert.Equal(125, resizedx0.Height())
assertFileCache(assert, fileCache, resizedx0.RelPermalink(), 200, 125)
c.Assert(err, qt.IsNil)
c.Assert(resizedx0.Width(), qt.Equals, 200)
c.Assert(resizedx0.Height(), qt.Equals, 125)
assertFileCache(c, fileCache, resizedx0.RelPermalink(), 200, 125)
resizedAndRotated, err := image.Resize("x200 r90")
assert.NoError(err)
assert.Equal(125, resizedAndRotated.Width())
assert.Equal(200, resizedAndRotated.Height())
assertFileCache(assert, fileCache, resizedAndRotated.RelPermalink(), 125, 200)
c.Assert(err, qt.IsNil)
c.Assert(resizedAndRotated.Width(), qt.Equals, 125)
c.Assert(resizedAndRotated.Height(), qt.Equals, 200)
assertFileCache(c, fileCache, resizedAndRotated.RelPermalink(), 125, 200)
assert.Equal("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_300x200_resize_q68_linear.jpg", resized.RelPermalink())
assert.Equal(300, resized.Width())
assert.Equal(200, resized.Height())
c.Assert(resized.RelPermalink(), qt.Equals, "/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_300x200_resize_q68_linear.jpg")
c.Assert(resized.Width(), qt.Equals, 300)
c.Assert(resized.Height(), qt.Equals, 200)
fitted, err := resized.Fit("50x50")
assert.NoError(err)
assert.Equal("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_625708021e2bb281c9f1002f88e4753f.jpg", fitted.RelPermalink())
assert.Equal(50, fitted.Width())
assert.Equal(33, fitted.Height())
c.Assert(err, qt.IsNil)
c.Assert(fitted.RelPermalink(), qt.Equals, "/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_625708021e2bb281c9f1002f88e4753f.jpg")
c.Assert(fitted.Width(), qt.Equals, 50)
c.Assert(fitted.Height(), qt.Equals, 33)
// Check the MD5 key threshold
fittedAgain, _ := fitted.Fit("10x20")
fittedAgain, err = fittedAgain.Fit("10x20")
assert.NoError(err)
assert.Equal("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_3f65ba24dc2b7fba0f56d7f104519157.jpg", fittedAgain.RelPermalink())
assert.Equal(10, fittedAgain.Width())
assert.Equal(6, fittedAgain.Height())
c.Assert(err, qt.IsNil)
c.Assert(fittedAgain.RelPermalink(), qt.Equals, "/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_3f65ba24dc2b7fba0f56d7f104519157.jpg")
c.Assert(fittedAgain.Width(), qt.Equals, 10)
c.Assert(fittedAgain.Height(), qt.Equals, 6)
filled, err := image.Fill("200x100 bottomLeft")
assert.NoError(err)
assert.Equal("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_200x100_fill_q68_linear_bottomleft.jpg", filled.RelPermalink())
assert.Equal(200, filled.Width())
assert.Equal(100, filled.Height())
assertFileCache(assert, fileCache, filled.RelPermalink(), 200, 100)
c.Assert(err, qt.IsNil)
c.Assert(filled.RelPermalink(), qt.Equals, "/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_200x100_fill_q68_linear_bottomleft.jpg")
c.Assert(filled.Width(), qt.Equals, 200)
c.Assert(filled.Height(), qt.Equals, 100)
assertFileCache(c, fileCache, filled.RelPermalink(), 200, 100)
smart, err := image.Fill("200x100 smart")
assert.NoError(err)
assert.Equal(fmt.Sprintf("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_200x100_fill_q68_linear_smart%d.jpg", smartCropVersionNumber), smart.RelPermalink())
assert.Equal(200, smart.Width())
assert.Equal(100, smart.Height())
assertFileCache(assert, fileCache, smart.RelPermalink(), 200, 100)
c.Assert(err, qt.IsNil)
c.Assert(smart.RelPermalink(), qt.Equals, fmt.Sprintf("/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_200x100_fill_q68_linear_smart%d.jpg", smartCropVersionNumber))
c.Assert(smart.Width(), qt.Equals, 200)
c.Assert(smart.Height(), qt.Equals, 100)
assertFileCache(c, fileCache, smart.RelPermalink(), 200, 100)
// Check cache
filledAgain, err := image.Fill("200x100 bottomLeft")
assert.NoError(err)
assert.True(filled == filledAgain)
assert.True(filled.sourceFilename == filledAgain.sourceFilename)
assertFileCache(assert, fileCache, filledAgain.RelPermalink(), 200, 100)
c.Assert(err, qt.IsNil)
c.Assert(filled == filledAgain, qt.Equals, true)
c.Assert(filled.sourceFilename == filledAgain.sourceFilename, qt.Equals, true)
assertFileCache(c, fileCache, filledAgain.RelPermalink(), 200, 100)
}
// https://github.com/gohugoio/hugo/issues/4261
func TestImageTransformLongFilename(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
image := fetchImage(assert, "1234567890qwertyuiopasdfghjklzxcvbnm5to6eeeeee7via8eleph.jpg")
assert.NotNil(image)
image := fetchImage(c, "1234567890qwertyuiopasdfghjklzxcvbnm5to6eeeeee7via8eleph.jpg")
c.Assert(image, qt.Not(qt.IsNil))
resized, err := image.Resize("200x")
assert.NoError(err)
assert.NotNil(resized)
assert.Equal(200, resized.Width())
assert.Equal("/a/_hu59e56ffff1bc1d8d122b1403d34e039f_90587_65b757a6e14debeae720fe8831f0a9bc.jpg", resized.RelPermalink())
c.Assert(err, qt.IsNil)
c.Assert(resized, qt.Not(qt.IsNil))
c.Assert(resized.Width(), qt.Equals, 200)
c.Assert(resized.RelPermalink(), qt.Equals, "/a/_hu59e56ffff1bc1d8d122b1403d34e039f_90587_65b757a6e14debeae720fe8831f0a9bc.jpg")
resized, err = resized.Resize("100x")
assert.NoError(err)
assert.NotNil(resized)
assert.Equal(100, resized.Width())
assert.Equal("/a/_hu59e56ffff1bc1d8d122b1403d34e039f_90587_c876768085288f41211f768147ba2647.jpg", resized.RelPermalink())
c.Assert(err, qt.IsNil)
c.Assert(resized, qt.Not(qt.IsNil))
c.Assert(resized.Width(), qt.Equals, 100)
c.Assert(resized.RelPermalink(), qt.Equals, "/a/_hu59e56ffff1bc1d8d122b1403d34e039f_90587_c876768085288f41211f768147ba2647.jpg")
}
// Issue 6137
func TestImageTransformUppercaseExt(t *testing.T) {
assert := require.New(t)
image := fetchImage(assert, "sunrise.JPG")
c := qt.New(t)
image := fetchImage(c, "sunrise.JPG")
resized, err := image.Resize("200x")
assert.NoError(err)
assert.NotNil(resized)
assert.Equal(200, resized.Width())
c.Assert(err, qt.IsNil)
c.Assert(resized, qt.Not(qt.IsNil))
c.Assert(resized.Width(), qt.Equals, 200)
}
// https://github.com/gohugoio/hugo/issues/5730
@@ -172,29 +174,29 @@ func TestImagePermalinkPublishOrder(t *testing.T) {
t.Run(name, func(t *testing.T) {
assert := require.New(t)
spec := newTestResourceOsFs(assert)
c := qt.New(t)
spec := newTestResourceOsFs(c)
check1 := func(img *Image) {
resizedLink := "/a/sunset_hu59e56ffff1bc1d8d122b1403d34e039f_90587_100x50_resize_q75_box.jpg"
assert.Equal(resizedLink, img.RelPermalink())
assertImageFile(assert, spec.PublishFs, resizedLink, 100, 50)
c.Assert(img.RelPermalink(), qt.Equals, resizedLink)
assertImageFile(c, spec.PublishFs, resizedLink, 100, 50)
}
check2 := func(img *Image) {
assert.Equal("/a/sunset.jpg", img.RelPermalink())
assertImageFile(assert, spec.PublishFs, "a/sunset.jpg", 900, 562)
c.Assert(img.RelPermalink(), qt.Equals, "/a/sunset.jpg")
assertImageFile(c, spec.PublishFs, "a/sunset.jpg", 900, 562)
}
orignal := fetchImageForSpec(spec, assert, "sunset.jpg")
assert.NotNil(orignal)
orignal := fetchImageForSpec(spec, c, "sunset.jpg")
c.Assert(orignal, qt.Not(qt.IsNil))
if checkOriginalFirst {
check2(orignal)
}
resized, err := orignal.Resize("100x50")
assert.NoError(err)
c.Assert(err, qt.IsNil)
check1(resized)
@@ -210,11 +212,11 @@ func TestImageTransformConcurrent(t *testing.T) {
var wg sync.WaitGroup
assert := require.New(t)
c := qt.New(t)
spec := newTestResourceOsFs(assert)
spec := newTestResourceOsFs(c)
image := fetchImageForSpec(spec, assert, "sunset.jpg")
image := fetchImageForSpec(spec, c, "sunset.jpg")
for i := 0; i < 4; i++ {
wg.Add(1)
@@ -252,7 +254,7 @@ func TestImageTransformConcurrent(t *testing.T) {
}
func TestDecodeImaging(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
m := map[string]interface{}{
"quality": 42,
"resampleFilter": "NearestNeighbor",
@@ -261,46 +263,46 @@ func TestDecodeImaging(t *testing.T) {
imaging, err := decodeImaging(m)
assert.NoError(err)
assert.Equal(42, imaging.Quality)
assert.Equal("nearestneighbor", imaging.ResampleFilter)
assert.Equal("topleft", imaging.Anchor)
c.Assert(err, qt.IsNil)
c.Assert(imaging.Quality, qt.Equals, 42)
c.Assert(imaging.ResampleFilter, qt.Equals, "nearestneighbor")
c.Assert(imaging.Anchor, qt.Equals, "topleft")
m = map[string]interface{}{}
imaging, err = decodeImaging(m)
assert.NoError(err)
assert.Equal(defaultJPEGQuality, imaging.Quality)
assert.Equal("box", imaging.ResampleFilter)
assert.Equal("smart", imaging.Anchor)
c.Assert(err, qt.IsNil)
c.Assert(imaging.Quality, qt.Equals, defaultJPEGQuality)
c.Assert(imaging.ResampleFilter, qt.Equals, "box")
c.Assert(imaging.Anchor, qt.Equals, "smart")
_, err = decodeImaging(map[string]interface{}{
"quality": 123,
})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = decodeImaging(map[string]interface{}{
"resampleFilter": "asdf",
})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = decodeImaging(map[string]interface{}{
"anchor": "asdf",
})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
imaging, err = decodeImaging(map[string]interface{}{
"anchor": "Smart",
})
assert.NoError(err)
assert.Equal("smart", imaging.Anchor)
c.Assert(err, qt.IsNil)
c.Assert(imaging.Anchor, qt.Equals, "smart")
}
func TestImageWithMetadata(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
image := fetchSunset(assert)
image := fetchSunset(c)
var meta = []map[string]interface{}{
{
@@ -310,89 +312,89 @@ func TestImageWithMetadata(t *testing.T) {
},
}
assert.NoError(AssignMetadata(meta, image))
assert.Equal("Sunset #1", image.Name())
c.Assert(AssignMetadata(meta, image), qt.IsNil)
c.Assert(image.Name(), qt.Equals, "Sunset #1")
resized, err := image.Resize("200x")
assert.NoError(err)
assert.Equal("Sunset #1", resized.Name())
c.Assert(err, qt.IsNil)
c.Assert(resized.Name(), qt.Equals, "Sunset #1")
}
func TestImageResize8BitPNG(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
image := fetchImage(assert, "gohugoio.png")
image := fetchImage(c, "gohugoio.png")
assert.Equal(imaging.PNG, image.format)
assert.Equal("/a/gohugoio.png", image.RelPermalink())
assert.Equal("image", image.ResourceType())
c.Assert(image.format, qt.Equals, imaging.PNG)
c.Assert(image.RelPermalink(), qt.Equals, "/a/gohugoio.png")
c.Assert(image.ResourceType(), qt.Equals, "image")
resized, err := image.Resize("800x")
assert.NoError(err)
assert.Equal(imaging.PNG, resized.format)
assert.Equal("/a/gohugoio_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_800x0_resize_linear_2.png", resized.RelPermalink())
assert.Equal(800, resized.Width())
c.Assert(err, qt.IsNil)
c.Assert(resized.format, qt.Equals, imaging.PNG)
c.Assert(resized.RelPermalink(), qt.Equals, "/a/gohugoio_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_800x0_resize_linear_2.png")
c.Assert(resized.Width(), qt.Equals, 800)
}
func TestImageResizeInSubPath(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
image := fetchImage(assert, "sub/gohugoio2.png")
image := fetchImage(c, "sub/gohugoio2.png")
fileCache := image.spec.FileCaches.ImageCache().Fs
assert.Equal(imaging.PNG, image.format)
assert.Equal("/a/sub/gohugoio2.png", image.RelPermalink())
assert.Equal("image", image.ResourceType())
c.Assert(image.format, qt.Equals, imaging.PNG)
c.Assert(image.RelPermalink(), qt.Equals, "/a/sub/gohugoio2.png")
c.Assert(image.ResourceType(), qt.Equals, "image")
resized, err := image.Resize("101x101")
assert.NoError(err)
assert.Equal(imaging.PNG, resized.format)
assert.Equal("/a/sub/gohugoio2_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_101x101_resize_linear_2.png", resized.RelPermalink())
assert.Equal(101, resized.Width())
c.Assert(err, qt.IsNil)
c.Assert(resized.format, qt.Equals, imaging.PNG)
c.Assert(resized.RelPermalink(), qt.Equals, "/a/sub/gohugoio2_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_101x101_resize_linear_2.png")
c.Assert(resized.Width(), qt.Equals, 101)
assertFileCache(assert, fileCache, resized.RelPermalink(), 101, 101)
assertFileCache(c, fileCache, resized.RelPermalink(), 101, 101)
publishedImageFilename := filepath.Clean(resized.RelPermalink())
assertImageFile(assert, image.spec.BaseFs.PublishFs, publishedImageFilename, 101, 101)
assert.NoError(image.spec.BaseFs.PublishFs.Remove(publishedImageFilename))
assertImageFile(c, image.spec.BaseFs.PublishFs, publishedImageFilename, 101, 101)
c.Assert(image.spec.BaseFs.PublishFs.Remove(publishedImageFilename), qt.IsNil)
// Cleare mem cache to simulate reading from the file cache.
resized.spec.imageCache.clear()
resizedAgain, err := image.Resize("101x101")
assert.NoError(err)
assert.Equal("/a/sub/gohugoio2_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_101x101_resize_linear_2.png", resizedAgain.RelPermalink())
assert.Equal(101, resizedAgain.Width())
assertFileCache(assert, fileCache, resizedAgain.RelPermalink(), 101, 101)
assertImageFile(assert, image.spec.BaseFs.PublishFs, publishedImageFilename, 101, 101)
c.Assert(err, qt.IsNil)
c.Assert(resizedAgain.RelPermalink(), qt.Equals, "/a/sub/gohugoio2_hu0e1b9e4a4be4d6f86c7b37b9ccce3fbc_73886_101x101_resize_linear_2.png")
c.Assert(resizedAgain.Width(), qt.Equals, 101)
assertFileCache(c, fileCache, resizedAgain.RelPermalink(), 101, 101)
assertImageFile(c, image.spec.BaseFs.PublishFs, publishedImageFilename, 101, 101)
}
func TestSVGImage(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
svg := fetchResourceForSpec(spec, assert, "circle.svg")
assert.NotNil(svg)
c := qt.New(t)
spec := newTestResourceSpec(c)
svg := fetchResourceForSpec(spec, c, "circle.svg")
c.Assert(svg, qt.Not(qt.IsNil))
}
func TestSVGImageContent(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
svg := fetchResourceForSpec(spec, assert, "circle.svg")
assert.NotNil(svg)
c := qt.New(t)
spec := newTestResourceSpec(c)
svg := fetchResourceForSpec(spec, c, "circle.svg")
c.Assert(svg, qt.Not(qt.IsNil))
content, err := svg.Content()
assert.NoError(err)
assert.IsType("", content)
assert.Contains(content.(string), `<svg height="100" width="100">`)
c.Assert(err, qt.IsNil)
c.Assert(content, hqt.IsSameType, "")
c.Assert(content.(string), qt.Contains, `<svg height="100" width="100">`)
}
func BenchmarkResizeParallel(b *testing.B) {
assert := require.New(b)
img := fetchSunset(assert)
c := qt.New(b)
img := fetchSunset(c)
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {

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)
}

108
resources/resource_metadata_test.go
View File

@@ -19,12 +19,12 @@ import (
"github.com/gohugoio/hugo/media"
"github.com/gohugoio/hugo/resources/resource"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestAssignMetadata(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
var foo1, foo2, foo3, logo1, logo2, logo3 resource.Resource
var resources resource.Resources
@@ -40,9 +40,9 @@ func TestAssignMetadata(t *testing.T) {
"src": "*",
},
}, func(err error) {
assert.Equal("My Resource", logo1.Title())
assert.Equal("My Name", logo1.Name())
assert.Equal("My Name", foo2.Name())
c.Assert(logo1.Title(), qt.Equals, "My Resource")
c.Assert(logo1.Name(), qt.Equals, "My Name")
c.Assert(foo2.Name(), qt.Equals, "My Name")
}},
{[]map[string]interface{}{
@@ -56,12 +56,12 @@ func TestAssignMetadata(t *testing.T) {
"src": "*",
},
}, func(err error) {
assert.Equal("My Logo", logo1.Title())
assert.Equal("My Logo", logo2.Title())
assert.Equal("My Name", logo1.Name())
assert.Equal("My Name", foo2.Name())
assert.Equal("My Name", foo3.Name())
assert.Equal("My Resource", foo3.Title())
c.Assert(logo1.Title(), qt.Equals, "My Logo")
c.Assert(logo2.Title(), qt.Equals, "My Logo")
c.Assert(logo1.Name(), qt.Equals, "My Name")
c.Assert(foo2.Name(), qt.Equals, "My Name")
c.Assert(foo3.Name(), qt.Equals, "My Name")
c.Assert(foo3.Title(), qt.Equals, "My Resource")
}},
{[]map[string]interface{}{
@@ -82,9 +82,9 @@ func TestAssignMetadata(t *testing.T) {
},
},
}, func(err error) {
assert.NoError(err)
assert.Equal("My Logo", logo1.Title())
assert.Equal("My Resource", foo3.Title())
c.Assert(err, qt.IsNil)
c.Assert(logo1.Title(), qt.Equals, "My Logo")
c.Assert(foo3.Title(), qt.Equals, "My Resource")
_, p1 := logo2.Params()["param1"]
_, p2 := foo2.Params()["param2"]
_, p1_2 := foo2.Params()["param1"]
@@ -93,15 +93,15 @@ func TestAssignMetadata(t *testing.T) {
icon1 := logo2.Params()["icon"]
icon2 := foo2.Params()["icon"]
assert.True(p1)
assert.True(p2)
c.Assert(p1, qt.Equals, true)
c.Assert(p2, qt.Equals, true)
// Check merge
assert.True(p2_2)
assert.False(p1_2)
c.Assert(p2_2, qt.Equals, true)
c.Assert(p1_2, qt.Equals, false)
assert.Equal("logo", icon1)
assert.Equal("resource", icon2)
c.Assert(icon1, qt.Equals, "logo")
c.Assert(icon2, qt.Equals, "resource")
}},
{[]map[string]interface{}{
@@ -115,17 +115,17 @@ func TestAssignMetadata(t *testing.T) {
"src": "*",
},
}, func(err error) {
assert.NoError(err)
assert.Equal("Resource #2", logo2.Title())
assert.Equal("Logo Name #1", logo2.Name())
assert.Equal("Resource #4", logo1.Title())
assert.Equal("Logo Name #2", logo1.Name())
assert.Equal("Resource #1", foo2.Title())
assert.Equal("Resource #3", foo1.Title())
assert.Equal("Name #2", foo1.Name())
assert.Equal("Resource #5", foo3.Title())
c.Assert(err, qt.IsNil)
c.Assert(logo2.Title(), qt.Equals, "Resource #2")
c.Assert(logo2.Name(), qt.Equals, "Logo Name #1")
c.Assert(logo1.Title(), qt.Equals, "Resource #4")
c.Assert(logo1.Name(), qt.Equals, "Logo Name #2")
c.Assert(foo2.Title(), qt.Equals, "Resource #1")
c.Assert(foo1.Title(), qt.Equals, "Resource #3")
c.Assert(foo1.Name(), qt.Equals, "Name #2")
c.Assert(foo3.Title(), qt.Equals, "Resource #5")
assert.Equal(logo2, resources.GetMatch("logo name #1*"))
c.Assert(resources.GetMatch("logo name #1*"), qt.Equals, logo2)
}},
{[]map[string]interface{}{
@@ -139,13 +139,13 @@ func TestAssignMetadata(t *testing.T) {
"src": "logo*",
},
}, func(err error) {
assert.NoError(err)
assert.Equal("Third Logo #1", logo3.Title())
assert.Equal("Name #3", logo3.Name())
assert.Equal("Other Logo #1", logo2.Title())
assert.Equal("Name #1", logo2.Name())
assert.Equal("Other Logo #2", logo1.Title())
assert.Equal("Name #2", logo1.Name())
c.Assert(err, qt.IsNil)
c.Assert(logo3.Title(), qt.Equals, "Third Logo #1")
c.Assert(logo3.Name(), qt.Equals, "Name #3")
c.Assert(logo2.Title(), qt.Equals, "Other Logo #1")
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Other Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
}},
{[]map[string]interface{}{
@@ -159,13 +159,13 @@ func TestAssignMetadata(t *testing.T) {
"src": "logo*",
},
}, func(err error) {
assert.NoError(err)
assert.Equal("Third Logo", logo3.Title())
assert.Equal("Name #3", logo3.Name())
assert.Equal("Other Logo #1", logo2.Title())
assert.Equal("Name #1", logo2.Name())
assert.Equal("Other Logo #2", logo1.Title())
assert.Equal("Name #2", logo1.Name())
c.Assert(err, qt.IsNil)
c.Assert(logo3.Title(), qt.Equals, "Third Logo")
c.Assert(logo3.Name(), qt.Equals, "Name #3")
c.Assert(logo2.Title(), qt.Equals, "Other Logo #1")
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Other Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
}},
{[]map[string]interface{}{
@@ -179,13 +179,13 @@ func TestAssignMetadata(t *testing.T) {
"src": "logo*",
},
}, func(err error) {
assert.NoError(err)
assert.Equal("Logo #3", logo3.Title())
assert.Equal("third-logo", logo3.Name())
assert.Equal("Logo #1", logo2.Title())
assert.Equal("Name #1", logo2.Name())
assert.Equal("Logo #2", logo1.Title())
assert.Equal("Name #2", logo1.Name())
c.Assert(err, qt.IsNil)
c.Assert(logo3.Title(), qt.Equals, "Logo #3")
c.Assert(logo3.Name(), qt.Equals, "third-logo")
c.Assert(logo2.Title(), qt.Equals, "Logo #1")
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
}},
{[]map[string]interface{}{
@@ -194,7 +194,7 @@ func TestAssignMetadata(t *testing.T) {
},
}, func(err error) {
// Missing src
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}},
{[]map[string]interface{}{
@@ -204,7 +204,7 @@ func TestAssignMetadata(t *testing.T) {
},
}, func(err error) {
// Invalid pattern
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}},
} {

152
resources/resource_test.go
View File

@@ -27,38 +27,38 @@ import (
"github.com/gohugoio/hugo/media"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestGenericResource(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
r := spec.newGenericResource(nil, nil, nil, "/a/foo.css", "foo.css", media.CSSType)
assert.Equal("https://example.com/foo.css", r.Permalink())
assert.Equal("/foo.css", r.RelPermalink())
assert.Equal("css", r.ResourceType())
c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo.css")
c.Assert(r.RelPermalink(), qt.Equals, "/foo.css")
c.Assert(r.ResourceType(), qt.Equals, "css")
}
func TestGenericResourceWithLinkFacory(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
factory := newTargetPaths("/foo")
r := spec.newGenericResource(nil, factory, nil, "/a/foo.css", "foo.css", media.CSSType)
assert.Equal("https://example.com/foo/foo.css", r.Permalink())
assert.Equal("/foo/foo.css", r.RelPermalink())
assert.Equal("foo.css", r.Key())
assert.Equal("css", r.ResourceType())
c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo/foo.css")
c.Assert(r.RelPermalink(), qt.Equals, "/foo/foo.css")
c.Assert(r.Key(), qt.Equals, "foo.css")
c.Assert(r.ResourceType(), qt.Equals, "css")
}
func TestNewResourceFromFilename(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
writeSource(t, spec.Fs, "content/a/b/logo.png", "image")
writeSource(t, spec.Fs, "content/a/b/data.json", "json")
@@ -67,26 +67,26 @@ func TestNewResourceFromFilename(t *testing.T) {
r, err := spec.New(ResourceSourceDescriptor{Fs: bfs, SourceFilename: "a/b/logo.png"})
assert.NoError(err)
assert.NotNil(r)
assert.Equal("image", r.ResourceType())
assert.Equal("/a/b/logo.png", r.RelPermalink())
assert.Equal("https://example.com/a/b/logo.png", r.Permalink())
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(r.ResourceType(), qt.Equals, "image")
c.Assert(r.RelPermalink(), qt.Equals, "/a/b/logo.png")
c.Assert(r.Permalink(), qt.Equals, "https://example.com/a/b/logo.png")
r, err = spec.New(ResourceSourceDescriptor{Fs: bfs, SourceFilename: "a/b/data.json"})
assert.NoError(err)
assert.NotNil(r)
assert.Equal("json", r.ResourceType())
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(r.ResourceType(), qt.Equals, "json")
cloned := r.(resource.Cloner).WithNewBase("aceof")
assert.Equal(r.ResourceType(), cloned.ResourceType())
assert.Equal("/aceof/a/b/data.json", cloned.RelPermalink())
c.Assert(cloned.ResourceType(), qt.Equals, r.ResourceType())
c.Assert(cloned.RelPermalink(), qt.Equals, "/aceof/a/b/data.json")
}
func TestNewResourceFromFilenameSubPathInBaseURL(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpecForBaseURL(assert, "https://example.com/docs")
c := qt.New(t)
spec := newTestResourceSpecForBaseURL(c, "https://example.com/docs")
writeSource(t, spec.Fs, "content/a/b/logo.png", "image")
bfs := afero.NewBasePathFs(spec.Fs.Source, "content")
@@ -94,35 +94,35 @@ func TestNewResourceFromFilenameSubPathInBaseURL(t *testing.T) {
fmt.Println()
r, err := spec.New(ResourceSourceDescriptor{Fs: bfs, SourceFilename: filepath.FromSlash("a/b/logo.png")})
assert.NoError(err)
assert.NotNil(r)
assert.Equal("image", r.ResourceType())
assert.Equal("/docs/a/b/logo.png", r.RelPermalink())
assert.Equal("https://example.com/docs/a/b/logo.png", r.Permalink())
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(r.ResourceType(), qt.Equals, "image")
c.Assert(r.RelPermalink(), qt.Equals, "/docs/a/b/logo.png")
c.Assert(r.Permalink(), qt.Equals, "https://example.com/docs/a/b/logo.png")
img := r.(*Image)
assert.Equal(filepath.FromSlash("/a/b/logo.png"), img.targetFilenames()[0])
c.Assert(img.targetFilenames()[0], qt.Equals, filepath.FromSlash("/a/b/logo.png"))
}
var pngType, _ = media.FromStringAndExt("image/png", "png")
func TestResourcesByType(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
resources := resource.Resources{
spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/a/logo.png", "logo.css", pngType),
spec.newGenericResource(nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType)}
assert.Len(resources.ByType("css"), 3)
assert.Len(resources.ByType("image"), 1)
c.Assert(len(resources.ByType("css")), qt.Equals, 3)
c.Assert(len(resources.ByType("image")), qt.Equals, 1)
}
func TestResourcesGetByPrefix(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
resources := resource.Resources{
spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
@@ -130,28 +130,28 @@ func TestResourcesGetByPrefix(t *testing.T) {
spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)}
assert.Nil(resources.GetMatch("asdf*"))
assert.Equal("/logo1.png", resources.GetMatch("logo*").RelPermalink())
assert.Equal("/logo1.png", resources.GetMatch("loGo*").RelPermalink())
assert.Equal("/Logo2.png", resources.GetMatch("logo2*").RelPermalink())
assert.Equal("/foo2.css", resources.GetMatch("foo2*").RelPermalink())
assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
assert.Nil(resources.GetMatch("asdfasdf*"))
c.Assert(resources.GetMatch("asdf*"), qt.IsNil)
c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png")
c.Assert(resources.GetMatch("loGo*").RelPermalink(), qt.Equals, "/logo1.png")
c.Assert(resources.GetMatch("logo2*").RelPermalink(), qt.Equals, "/Logo2.png")
c.Assert(resources.GetMatch("foo2*").RelPermalink(), qt.Equals, "/foo2.css")
c.Assert(resources.GetMatch("foo1*").RelPermalink(), qt.Equals, "/foo1.css")
c.Assert(resources.GetMatch("foo1*").RelPermalink(), qt.Equals, "/foo1.css")
c.Assert(resources.GetMatch("asdfasdf*"), qt.IsNil)
assert.Equal(2, len(resources.Match("logo*")))
assert.Equal(1, len(resources.Match("logo2*")))
c.Assert(len(resources.Match("logo*")), qt.Equals, 2)
c.Assert(len(resources.Match("logo2*")), qt.Equals, 1)
logo := resources.GetMatch("logo*")
assert.NotNil(logo.Params())
assert.Equal("logo1.png", logo.Name())
assert.Equal("logo1.png", logo.Title())
c.Assert(logo.Params(), qt.Not(qt.IsNil))
c.Assert(logo.Name(), qt.Equals, "logo1.png")
c.Assert(logo.Title(), qt.Equals, "logo1.png")
}
func TestResourcesGetMatch(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
c := qt.New(t)
spec := newTestResourceSpec(c)
resources := resource.Resources{
spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
@@ -163,35 +163,35 @@ func TestResourcesGetMatch(t *testing.T) {
spec.newGenericResource(nil, nil, nil, "/b/c/d/foo6.css", "c/d/foo6.css", media.CSSType),
}
assert.Equal("/logo1.png", resources.GetMatch("logo*").RelPermalink())
assert.Equal("/logo1.png", resources.GetMatch("loGo*").RelPermalink())
assert.Equal("/Logo2.png", resources.GetMatch("logo2*").RelPermalink())
assert.Equal("/foo2.css", resources.GetMatch("foo2*").RelPermalink())
assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
assert.Equal("/c/foo4.css", resources.GetMatch("*/foo*").RelPermalink())
c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png")
c.Assert(resources.GetMatch("loGo*").RelPermalink(), qt.Equals, "/logo1.png")
c.Assert(resources.GetMatch("logo2*").RelPermalink(), qt.Equals, "/Logo2.png")
c.Assert(resources.GetMatch("foo2*").RelPermalink(), qt.Equals, "/foo2.css")
c.Assert(resources.GetMatch("foo1*").RelPermalink(), qt.Equals, "/foo1.css")
c.Assert(resources.GetMatch("foo1*").RelPermalink(), qt.Equals, "/foo1.css")
c.Assert(resources.GetMatch("*/foo*").RelPermalink(), qt.Equals, "/c/foo4.css")
assert.Nil(resources.GetMatch("asdfasdf"))
c.Assert(resources.GetMatch("asdfasdf"), qt.IsNil)
assert.Equal(2, len(resources.Match("Logo*")))
assert.Equal(1, len(resources.Match("logo2*")))
assert.Equal(2, len(resources.Match("c/*")))
c.Assert(len(resources.Match("Logo*")), qt.Equals, 2)
c.Assert(len(resources.Match("logo2*")), qt.Equals, 1)
c.Assert(len(resources.Match("c/*")), qt.Equals, 2)
assert.Equal(6, len(resources.Match("**.css")))
assert.Equal(3, len(resources.Match("**/*.css")))
assert.Equal(1, len(resources.Match("c/**/*.css")))
c.Assert(len(resources.Match("**.css")), qt.Equals, 6)
c.Assert(len(resources.Match("**/*.css")), qt.Equals, 3)
c.Assert(len(resources.Match("c/**/*.css")), qt.Equals, 1)
// Matches only CSS files in c/
assert.Equal(3, len(resources.Match("c/**.css")))
c.Assert(len(resources.Match("c/**.css")), qt.Equals, 3)
// Matches all CSS files below c/ (including in c/d/)
assert.Equal(3, len(resources.Match("c/**.css")))
c.Assert(len(resources.Match("c/**.css")), qt.Equals, 3)
// Patterns beginning with a slash will not match anything.
// We could maybe consider trimming that slash, but let's be explicit about this.
// (it is possible for users to do a rename)
// This is analogous to standing in a directory and doing "ls *.*".
assert.Equal(0, len(resources.Match("/c/**.css")))
c.Assert(len(resources.Match("/c/**.css")), qt.Equals, 0)
}
@@ -212,8 +212,8 @@ func BenchmarkResourcesMatch(b *testing.B) {
// I don't expect Hugo users to "stumble upon" this problem, so this is more to satisfy
// my own curiosity.
func BenchmarkResourcesMatchA100(b *testing.B) {
assert := require.New(b)
spec := newTestResourceSpec(assert)
c := qt.New(b)
spec := newTestResourceSpec(c)
a100 := strings.Repeat("a", 100)
pattern := "a*a*a*a*a*a*a*a*b"
@@ -227,8 +227,8 @@ func BenchmarkResourcesMatchA100(b *testing.B) {
}
func benchResources(b *testing.B) resource.Resources {
assert := require.New(b)
spec := newTestResourceSpec(assert)
c := qt.New(b)
spec := newTestResourceSpec(c)
var resources resource.Resources
for i := 0; i < 30; i++ {
@@ -251,8 +251,8 @@ func benchResources(b *testing.B) resource.Resources {
}
func BenchmarkAssignMetadata(b *testing.B) {
assert := require.New(b)
spec := newTestResourceSpec(assert)
c := qt.New(b)
spec := newTestResourceSpec(c)
for i := 0; i < b.N; i++ {
b.StopTimer()

12
resources/resource_transformers/integrity/integrity_test.go
View File

@@ -16,7 +16,7 @@ package integrity
import (
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestHashFromAlgo(t *testing.T) {
@@ -33,14 +33,14 @@ func TestHashFromAlgo(t *testing.T) {
} {
t.Run(algo.name, func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
h, err := newHash(algo.name)
if algo.bits > 0 {
assert.NoError(err)
assert.Equal(algo.bits/8, h.Size())
c.Assert(err, qt.IsNil)
c.Assert(h.Size(), qt.Equals, algo.bits/8)
} else {
assert.Error(err)
assert.Contains(err.Error(), "use either md5, sha256, sha384 or sha512")
c.Assert(err, qt.Not(qt.IsNil))
c.Assert(err.Error(), qt.Contains, "use either md5, sha256, sha384 or sha512")
}
})

12
resources/resource_transformers/postcss/postcss_test.go
View File

@@ -16,24 +16,24 @@ package postcss
import (
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
// Issue 6166
func TestDecodeOptions(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
opts1, err := DecodeOptions(map[string]interface{}{
"no-map": true,
})
assert.NoError(err)
assert.True(opts1.NoMap)
c.Assert(err, qt.IsNil)
c.Assert(opts1.NoMap, qt.Equals, true)
opts2, err := DecodeOptions(map[string]interface{}{
"noMap": true,
})
assert.NoError(err)
assert.True(opts2.NoMap)
c.Assert(err, qt.IsNil)
c.Assert(opts2.NoMap, qt.Equals, true)
}

64
resources/testhelpers_test.go
View File

@@ -4,6 +4,8 @@ import (
"path/filepath"
"testing"
"github.com/gohugoio/hugo/htesting/hqt"
"image"
"io"
"io/ioutil"
@@ -14,6 +16,7 @@ import (
"github.com/gohugoio/hugo/langs"
"github.com/gohugoio/hugo/modules"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/cache/filecache"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugofs"
@@ -23,11 +26,10 @@ import (
"github.com/gohugoio/hugo/resources/resource"
"github.com/spf13/afero"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
func newTestResourceSpec(assert *require.Assertions) *Spec {
return newTestResourceSpecForBaseURL(assert, "https://example.com/")
func newTestResourceSpec(c *qt.C) *Spec {
return newTestResourceSpecForBaseURL(c, "https://example.com/")
}
func createTestCfg() *viper.Viper {
@@ -52,7 +54,7 @@ func createTestCfg() *viper.Viper {
}
func newTestResourceSpecForBaseURL(assert *require.Assertions, baseURL string) *Spec {
func newTestResourceSpecForBaseURL(c *qt.C, baseURL string) *Spec {
cfg := createTestCfg()
cfg.Set("baseURL", baseURL)
@@ -67,13 +69,13 @@ func newTestResourceSpecForBaseURL(assert *require.Assertions, baseURL string) *
fs := hugofs.NewMem(cfg)
s, err := helpers.NewPathSpec(fs, cfg, nil)
assert.NoError(err)
c.Assert(err, qt.IsNil)
filecaches, err := filecache.NewCaches(s)
assert.NoError(err)
c.Assert(err, qt.IsNil)
spec, err := NewSpec(s, filecaches, nil, output.DefaultFormats, media.DefaultTypes)
assert.NoError(err)
c.Assert(err, qt.IsNil)
return spec
}
@@ -86,7 +88,7 @@ func newTargetPaths(link string) func() page.TargetPaths {
}
}
func newTestResourceOsFs(assert *require.Assertions) *Spec {
func newTestResourceOsFs(c *qt.C) *Spec {
cfg := createTestCfg()
cfg.Set("baseURL", "https://example.com")
@@ -104,66 +106,66 @@ func newTestResourceOsFs(assert *require.Assertions) *Spec {
fs.Destination = &afero.MemMapFs{}
s, err := helpers.NewPathSpec(fs, cfg, nil)
assert.NoError(err)
c.Assert(err, qt.IsNil)
filecaches, err := filecache.NewCaches(s)
assert.NoError(err)
c.Assert(err, qt.IsNil)
spec, err := NewSpec(s, filecaches, nil, output.DefaultFormats, media.DefaultTypes)
assert.NoError(err)
c.Assert(err, qt.IsNil)
return spec
}
func fetchSunset(assert *require.Assertions) *Image {
return fetchImage(assert, "sunset.jpg")
func fetchSunset(c *qt.C) *Image {
return fetchImage(c, "sunset.jpg")
}
func fetchImage(assert *require.Assertions, name string) *Image {
spec := newTestResourceSpec(assert)
return fetchImageForSpec(spec, assert, name)
func fetchImage(c *qt.C, name string) *Image {
spec := newTestResourceSpec(c)
return fetchImageForSpec(spec, c, name)
}
func fetchImageForSpec(spec *Spec, assert *require.Assertions, name string) *Image {
r := fetchResourceForSpec(spec, assert, name)
assert.IsType(&Image{}, r)
func fetchImageForSpec(spec *Spec, c *qt.C, name string) *Image {
r := fetchResourceForSpec(spec, c, name)
c.Assert(r, hqt.IsSameType, &Image{})
return r.(*Image)
}
func fetchResourceForSpec(spec *Spec, assert *require.Assertions, name string) resource.ContentResource {
func fetchResourceForSpec(spec *Spec, c *qt.C, name string) resource.ContentResource {
src, err := os.Open(filepath.FromSlash("testdata/" + name))
assert.NoError(err)
c.Assert(err, qt.IsNil)
out, err := helpers.OpenFileForWriting(spec.Fs.Source, name)
assert.NoError(err)
c.Assert(err, qt.IsNil)
_, err = io.Copy(out, src)
out.Close()
src.Close()
assert.NoError(err)
c.Assert(err, qt.IsNil)
factory := newTargetPaths("/a")
r, err := spec.New(ResourceSourceDescriptor{Fs: spec.Fs.Source, TargetPaths: factory, LazyPublish: true, SourceFilename: name})
assert.NoError(err)
c.Assert(err, qt.IsNil)
return r.(resource.ContentResource)
}
func assertImageFile(assert *require.Assertions, fs afero.Fs, filename string, width, height int) {
func assertImageFile(c *qt.C, fs afero.Fs, filename string, width, height int) {
filename = filepath.Clean(filename)
f, err := fs.Open(filename)
assert.NoError(err)
c.Assert(err, qt.IsNil)
defer f.Close()
config, _, err := image.DecodeConfig(f)
assert.NoError(err)
c.Assert(err, qt.IsNil)
assert.Equal(width, config.Width)
assert.Equal(height, config.Height)
c.Assert(config.Width, qt.Equals, width)
c.Assert(config.Height, qt.Equals, height)
}
func assertFileCache(assert *require.Assertions, fs afero.Fs, filename string, width, height int) {
assertImageFile(assert, fs, filepath.Clean(filename), width, height)
func assertFileCache(c *qt.C, fs afero.Fs, filename string, width, height int) {
assertImageFile(c, fs, filepath.Clean(filename), width, height)
}
func writeSource(t testing.TB, fs *hugofs.Fs, filename, content string) {

6
resources/transform_test.go
View File

@@ -16,7 +16,7 @@ package resources
import (
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
type testStruct struct {
@@ -31,6 +31,6 @@ func TestResourceTransformationKey(t *testing.T) {
// We really need this key to be portable across OSes.
key := NewResourceTransformationKey("testing",
testStruct{Name: "test", V1: int64(10), V2: int32(20), V3: 30, V4: uint64(40)})
assert := require.New(t)
assert.Equal(key.key(), "testing_518996646957295636")
c := qt.New(t)
c.Assert("testing_518996646957295636", qt.Equals, key.key())
}