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

51
tpl/tplimpl/shortcodes_test.go
View File

@@ -14,38 +14,37 @@
package tplimpl
import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestShortcodesTemplate(t *testing.T) {
t.Run("isShortcode", func(t *testing.T) {
assert := require.New(t)
assert.True(isShortcode("shortcodes/figures.html"))
assert.True(isShortcode("_internal/shortcodes/figures.html"))
assert.False(isShortcode("shortcodes\\figures.html"))
assert.False(isShortcode("myshortcodes"))
c := qt.New(t)
c.Assert(isShortcode("shortcodes/figures.html"), qt.Equals, true)
c.Assert(isShortcode("_internal/shortcodes/figures.html"), qt.Equals, true)
c.Assert(isShortcode("shortcodes\\figures.html"), qt.Equals, false)
c.Assert(isShortcode("myshortcodes"), qt.Equals, false)
})
t.Run("variantsFromName", func(t *testing.T) {
assert := require.New(t)
assert.Equal([]string{"", "html", "html"}, templateVariants("figure.html"))
assert.Equal([]string{"no", "no", "html"}, templateVariants("figure.no.html"))
assert.Equal([]string{"no", "amp", "html"}, templateVariants("figure.no.amp.html"))
assert.Equal([]string{"amp", "amp", "html"}, templateVariants("figure.amp.html"))
c := qt.New(t)
c.Assert(templateVariants("figure.html"), qt.DeepEquals, []string{"", "html", "html"})
c.Assert(templateVariants("figure.no.html"), qt.DeepEquals, []string{"no", "no", "html"})
c.Assert(templateVariants("figure.no.amp.html"), qt.DeepEquals, []string{"no", "amp", "html"})
c.Assert(templateVariants("figure.amp.html"), qt.DeepEquals, []string{"amp", "amp", "html"})
name, variants := templateNameAndVariants("figure.html")
assert.Equal("figure", name)
assert.Equal([]string{"", "html", "html"}, variants)
c.Assert(name, qt.Equals, "figure")
c.Assert(variants, qt.DeepEquals, []string{"", "html", "html"})
})
t.Run("compareVariants", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
var s *shortcodeTemplates
tests := []struct {
@@ -62,15 +61,15 @@ func TestShortcodesTemplate(t *testing.T) {
{"One with output format, one without", "figure.amp.html", "figure.html", -1},
}
for i, test := range tests {
for _, test := range tests {
w := s.compareVariants(templateVariants(test.name1), templateVariants(test.name2))
assert.Equal(test.expected, w, fmt.Sprintf("[%d] %s", i, test.name))
c.Assert(w, qt.Equals, test.expected)
}
})
t.Run("indexOf", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
s := &shortcodeTemplates{
variants: []shortcodeVariant{
@@ -79,20 +78,20 @@ func TestShortcodesTemplate(t *testing.T) {
},
}
assert.Equal(0, s.indexOf([]string{"a", "b", "c"}))
assert.Equal(1, s.indexOf([]string{"a", "b", "d"}))
assert.Equal(-1, s.indexOf([]string{"a", "b", "x"}))
c.Assert(s.indexOf([]string{"a", "b", "c"}), qt.Equals, 0)
c.Assert(s.indexOf([]string{"a", "b", "d"}), qt.Equals, 1)
c.Assert(s.indexOf([]string{"a", "b", "x"}), qt.Equals, -1)
})
t.Run("Name", func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
assert.Equal("foo.html", templateBaseName(templateShortcode, "shortcodes/foo.html"))
assert.Equal("foo.html", templateBaseName(templateShortcode, "_internal/shortcodes/foo.html"))
assert.Equal("test/foo.html", templateBaseName(templateShortcode, "shortcodes/test/foo.html"))
c.Assert(templateBaseName(templateShortcode, "shortcodes/foo.html"), qt.Equals, "foo.html")
c.Assert(templateBaseName(templateShortcode, "_internal/shortcodes/foo.html"), qt.Equals, "foo.html")
c.Assert(templateBaseName(templateShortcode, "shortcodes/test/foo.html"), qt.Equals, "test/foo.html")
assert.True(true)
c.Assert(true, qt.Equals, true)
})
}

185
tpl/tplimpl/template_ast_transformers_test.go
View File

@@ -23,7 +23,7 @@ import (
"github.com/spf13/cast"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
var (
@@ -175,77 +175,78 @@ PARAMS SITE GLOBAL3: {{ $site.Params.LOWER }}
func TestParamsKeysToLower(t *testing.T) {
t.Parallel()
c := qt.New(t)
_, err := applyTemplateTransformers(templateUndefined, nil, nil)
require.Error(t, err)
c.Assert(err, qt.Not(qt.IsNil))
templ, err := template.New("foo").Funcs(testFuncs).Parse(paramsTempl)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
c := newTemplateContext(createParseTreeLookup(templ))
ctx := newTemplateContext(createParseTreeLookup(templ))
require.Equal(t, -1, c.decl.indexOfReplacementStart([]string{}))
c.Assert(ctx.decl.indexOfReplacementStart([]string{}), qt.Equals, -1)
c.applyTransformations(templ.Tree.Root)
ctx.applyTransformations(templ.Tree.Root)
var b bytes.Buffer
require.NoError(t, templ.Execute(&b, paramsData))
c.Assert(templ.Execute(&b, paramsData), qt.IsNil)
result := b.String()
require.Contains(t, result, "P1: P1L")
require.Contains(t, result, "P1_2: P1L")
require.Contains(t, result, "P1_3: P1L")
require.Contains(t, result, "P1_4: P1L")
require.Contains(t, result, "P2: P2L")
require.Contains(t, result, "P2_2: P2L")
require.Contains(t, result, "P2_3: P2L")
require.Contains(t, result, "P2_4: P2L")
require.Contains(t, result, "P22: P22L")
require.Contains(t, result, "P22_nested: P22L_nested")
require.Contains(t, result, "P3: P3H")
require.Contains(t, result, "P3_2: P3H")
require.Contains(t, result, "P3_3: P3H")
require.Contains(t, result, "P3_4: P3H")
require.Contains(t, result, "P4: 13")
require.Contains(t, result, "P5: P1L")
require.Contains(t, result, "P5_2: P2L")
c.Assert(result, qt.Contains, "P1: P1L")
c.Assert(result, qt.Contains, "P1_2: P1L")
c.Assert(result, qt.Contains, "P1_3: P1L")
c.Assert(result, qt.Contains, "P1_4: P1L")
c.Assert(result, qt.Contains, "P2: P2L")
c.Assert(result, qt.Contains, "P2_2: P2L")
c.Assert(result, qt.Contains, "P2_3: P2L")
c.Assert(result, qt.Contains, "P2_4: P2L")
c.Assert(result, qt.Contains, "P22: P22L")
c.Assert(result, qt.Contains, "P22_nested: P22L_nested")
c.Assert(result, qt.Contains, "P3: P3H")
c.Assert(result, qt.Contains, "P3_2: P3H")
c.Assert(result, qt.Contains, "P3_3: P3H")
c.Assert(result, qt.Contains, "P3_4: P3H")
c.Assert(result, qt.Contains, "P4: 13")
c.Assert(result, qt.Contains, "P5: P1L")
c.Assert(result, qt.Contains, "P5_2: P2L")
require.Contains(t, result, "IF: P1L")
require.Contains(t, result, "ELSE: P1L")
c.Assert(result, qt.Contains, "IF: P1L")
c.Assert(result, qt.Contains, "ELSE: P1L")
require.Contains(t, result, "WITH: P1L")
c.Assert(result, qt.Contains, "WITH: P1L")
require.Contains(t, result, "RANGE: 3: P1L")
c.Assert(result, qt.Contains, "RANGE: 3: P1L")
require.Contains(t, result, "Hi There")
c.Assert(result, qt.Contains, "Hi There")
// Issue #2740
require.Contains(t, result, "F1: themes/P2L-theme")
require.Contains(t, result, "F2: themes/P2L-theme")
require.Contains(t, result, "F3: themes/P2L-theme")
c.Assert(result, qt.Contains, "F1: themes/P2L-theme")
c.Assert(result, qt.Contains, "F2: themes/P2L-theme")
c.Assert(result, qt.Contains, "F3: themes/P2L-theme")
require.Contains(t, result, "PSLICE: PSLICE1|PSLICE3|")
require.Contains(t, result, "PARAMS STRING: foo:.Params.toc_hide:[!= true]")
require.Contains(t, result, "PARAMS STRING2: foo:.Params.toc_hide:[!= true]")
require.Contains(t, result, "PARAMS STRING3: .Params.TOC_HIDE:!=:[P1L]")
c.Assert(result, qt.Contains, "PSLICE: PSLICE1|PSLICE3|")
c.Assert(result, qt.Contains, "PARAMS STRING: foo:.Params.toc_hide:[!= true]")
c.Assert(result, qt.Contains, "PARAMS STRING2: foo:.Params.toc_hide:[!= true]")
c.Assert(result, qt.Contains, "PARAMS STRING3: .Params.TOC_HIDE:!=:[P1L]")
// Issue #5094
require.Contains(t, result, "PARAMS COMPOSITE: [1 3]")
c.Assert(result, qt.Contains, "PARAMS COMPOSITE: [1 3]")
// Issue #5068
require.Contains(t, result, "PCurrentSection: pcurrentsection")
c.Assert(result, qt.Contains, "PCurrentSection: pcurrentsection")
// Issue #5541
require.Contains(t, result, "PARAMS TIME: 1972-02-28")
require.Contains(t, result, "PARAMS TIME2: 1972-02-28")
c.Assert(result, qt.Contains, "PARAMS TIME: 1972-02-28")
c.Assert(result, qt.Contains, "PARAMS TIME2: 1972-02-28")
// Issue ##5615
require.Contains(t, result, "PARAMS SITE GLOBAL1: global-site")
require.Contains(t, result, "PARAMS SITE GLOBAL2: global-site")
require.Contains(t, result, "PARAMS SITE GLOBAL3: global-site")
c.Assert(result, qt.Contains, "PARAMS SITE GLOBAL1: global-site")
c.Assert(result, qt.Contains, "PARAMS SITE GLOBAL2: global-site")
c.Assert(result, qt.Contains, "PARAMS SITE GLOBAL3: global-site")
}
@@ -275,8 +276,10 @@ func BenchmarkTemplateParamsKeysToLower(b *testing.B) {
func TestParamsKeysToLowerVars(t *testing.T) {
t.Parallel()
c := qt.New(t)
var (
ctx = map[string]interface{}{
data = map[string]interface{}{
"Params": map[string]interface{}{
"colors": map[string]interface{}{
"blue": "Amber",
@@ -304,31 +307,32 @@ Pretty First3: {{ $__amber_4.COLORS.PRETTY.FIRST}}
templ, err := template.New("foo").Parse(paramsTempl)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
c := newTemplateContext(createParseTreeLookup(templ))
ctx := newTemplateContext(createParseTreeLookup(templ))
c.applyTransformations(templ.Tree.Root)
ctx.applyTransformations(templ.Tree.Root)
var b bytes.Buffer
require.NoError(t, templ.Execute(&b, ctx))
c.Assert(templ.Execute(&b, data), qt.IsNil)
result := b.String()
require.Contains(t, result, "Color: Amber")
require.Contains(t, result, "Blue: Amber")
require.Contains(t, result, "Pretty First1: Indigo")
require.Contains(t, result, "Pretty First2: Indigo")
require.Contains(t, result, "Pretty First3: Indigo")
c.Assert(result, qt.Contains, "Color: Amber")
c.Assert(result, qt.Contains, "Blue: Amber")
c.Assert(result, qt.Contains, "Pretty First1: Indigo")
c.Assert(result, qt.Contains, "Pretty First2: Indigo")
c.Assert(result, qt.Contains, "Pretty First3: Indigo")
}
func TestParamsKeysToLowerInBlockTemplate(t *testing.T) {
t.Parallel()
c := qt.New(t)
var (
ctx = map[string]interface{}{
data = map[string]interface{}{
"Params": map[string]interface{}{
"lower": "P1L",
},
@@ -344,28 +348,29 @@ P2: {{ .Params.LOWER }}
)
masterTpl, err := template.New("foo").Parse(master)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
overlayTpl, err := template.Must(masterTpl.Clone()).Parse(overlay)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
overlayTpl = overlayTpl.Lookup(overlayTpl.Name())
c := newTemplateContext(createParseTreeLookup(overlayTpl))
ctx := newTemplateContext(createParseTreeLookup(overlayTpl))
c.applyTransformations(overlayTpl.Tree.Root)
ctx.applyTransformations(overlayTpl.Tree.Root)
var b bytes.Buffer
require.NoError(t, overlayTpl.Execute(&b, ctx))
c.Assert(overlayTpl.Execute(&b, data), qt.IsNil)
result := b.String()
require.Contains(t, result, "P1: P1L")
require.Contains(t, result, "P2: P1L")
c.Assert(result, qt.Contains, "P1: P1L")
c.Assert(result, qt.Contains, "P2: P1L")
}
// Issue #2927
func TestTransformRecursiveTemplate(t *testing.T) {
c := qt.New(t)
recursive := `
{{ define "menu-nodes" }}
@@ -378,10 +383,10 @@ func TestTransformRecursiveTemplate(t *testing.T) {
`
templ, err := template.New("foo").Parse(recursive)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
c := newTemplateContext(createParseTreeLookup(templ))
c.applyTransformations(templ.Tree.Root)
ctx := newTemplateContext(createParseTreeLookup(templ))
ctx.applyTransformations(templ.Tree.Root)
}
@@ -399,7 +404,7 @@ func (T) Method0() {
func TestInsertIsZeroFunc(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
var (
ctx = map[string]interface{}{
@@ -434,33 +439,33 @@ func TestInsertIsZeroFunc(t *testing.T) {
`
)
d := newD(assert)
d := newD(c)
h := d.Tmpl.(tpl.TemplateHandler)
// HTML templates
assert.NoError(h.AddTemplate("mytemplate.html", templ1))
assert.NoError(h.AddTemplate("othertemplate.html", templ2))
c.Assert(h.AddTemplate("mytemplate.html", templ1), qt.IsNil)
c.Assert(h.AddTemplate("othertemplate.html", templ2), qt.IsNil)
// Text templates
assert.NoError(h.AddTemplate("_text/mytexttemplate.txt", templ1))
assert.NoError(h.AddTemplate("_text/myothertexttemplate.txt", templ2))
c.Assert(h.AddTemplate("_text/mytexttemplate.txt", templ1), qt.IsNil)
c.Assert(h.AddTemplate("_text/myothertexttemplate.txt", templ2), qt.IsNil)
assert.NoError(h.MarkReady())
c.Assert(h.MarkReady(), qt.IsNil)
for _, name := range []string{"mytemplate.html", "mytexttemplate.txt"} {
tt, _ := d.Tmpl.Lookup(name)
result, err := tt.(tpl.TemplateExecutor).ExecuteToString(ctx)
assert.NoError(err)
c.Assert(err, qt.IsNil)
assert.Contains(result, ".True: TRUE")
assert.Contains(result, ".TimeZero1: FALSE")
assert.Contains(result, ".TimeZero2: FALSE")
assert.Contains(result, ".TimeZero3: TRUE")
assert.Contains(result, ".Now: TRUE")
assert.Contains(result, "TimeZero1 with: FALSE")
assert.Contains(result, ".TimeZero1: mytemplate: FALSE")
assert.Contains(result, ".TimeZero1: other-file-template: FALSE")
assert.Contains(result, ".NonEmptyInterfaceTypedNil: FALSE")
c.Assert(result, qt.Contains, ".True: TRUE")
c.Assert(result, qt.Contains, ".TimeZero1: FALSE")
c.Assert(result, qt.Contains, ".TimeZero2: FALSE")
c.Assert(result, qt.Contains, ".TimeZero3: TRUE")
c.Assert(result, qt.Contains, ".Now: TRUE")
c.Assert(result, qt.Contains, "TimeZero1 with: FALSE")
c.Assert(result, qt.Contains, ".TimeZero1: mytemplate: FALSE")
c.Assert(result, qt.Contains, ".TimeZero1: other-file-template: FALSE")
c.Assert(result, qt.Contains, ".NonEmptyInterfaceTypedNil: FALSE")
}
}
@@ -492,16 +497,16 @@ func TestCollectInfo(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
templ, err := template.New("foo").Funcs(funcs).Parse(test.tplString)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
c := newTemplateContext(createParseTreeLookup(templ))
c.typ = templateShortcode
c.applyTransformations(templ.Tree.Root)
ctx := newTemplateContext(createParseTreeLookup(templ))
ctx.typ = templateShortcode
ctx.applyTransformations(templ.Tree.Root)
assert.Equal(test.expected, c.Info)
c.Assert(ctx.Info, qt.Equals, test.expected)
})
}
@@ -534,16 +539,16 @@ func TestPartialReturn(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
templ, err := template.New("foo").Funcs(funcs).Parse(test.tplString)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
_, err = applyTemplateTransformers(templatePartial, templ.Tree, createParseTreeLookup(templ))
// Just check that it doesn't fail in this test. We have functional tests
// in hugoblib.
assert.NoError(err)
c.Assert(err, qt.IsNil)
})
}

30
tpl/tplimpl/template_funcs_test.go
View File

@@ -25,6 +25,7 @@ import (
"github.com/gohugoio/hugo/resources/page"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/common/hugo"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
@@ -37,7 +38,6 @@ import (
"github.com/gohugoio/hugo/tpl/partials"
"github.com/spf13/afero"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
var (
@@ -80,6 +80,7 @@ func newDepsConfig(cfg config.Provider) deps.DepsCfg {
func TestTemplateFuncsExamples(t *testing.T) {
t.Parallel()
c := qt.New(t)
workingDir := "/home/hugo"
@@ -99,7 +100,7 @@ func TestTemplateFuncsExamples(t *testing.T) {
depsCfg := newDepsConfig(v)
depsCfg.Fs = fs
d, err := deps.New(depsCfg)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
var data struct {
Title string
@@ -119,15 +120,15 @@ func TestTemplateFuncsExamples(t *testing.T) {
for i, example := range mm.Examples {
in, expected := example[0], example[1]
d.WithTemplate = func(templ tpl.TemplateHandler) error {
require.NoError(t, templ.AddTemplate("test", in))
require.NoError(t, templ.AddTemplate("partials/header.html", "<title>Hugo Rocks!</title>"))
c.Assert(templ.AddTemplate("test", in), qt.IsNil)
c.Assert(templ.AddTemplate("partials/header.html", "<title>Hugo Rocks!</title>"), qt.IsNil)
return nil
}
require.NoError(t, d.LoadResources())
c.Assert(d.LoadResources(), qt.IsNil)
var b bytes.Buffer
templ, _ := d.Tmpl.Lookup("test")
require.NoError(t, templ.Execute(&b, &data))
c.Assert(templ.Execute(&b, &data), qt.IsNil)
if b.String() != expected {
t.Fatalf("%s[%d]: got %q expected %q", ns.Name, i, b.String(), expected)
}
@@ -141,7 +142,7 @@ func TestTemplateFuncsExamples(t *testing.T) {
func TestPartialCached(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
partial := `Now: {{ now.UnixNano }}`
name := "testing"
@@ -163,25 +164,25 @@ func TestPartialCached(t *testing.T) {
}
de, err := deps.New(config)
assert.NoError(err)
assert.NoError(de.LoadResources())
c.Assert(err, qt.IsNil)
c.Assert(de.LoadResources(), qt.IsNil)
ns := partials.New(de)
res1, err := ns.IncludeCached(name, &data)
assert.NoError(err)
c.Assert(err, qt.IsNil)
for j := 0; j < 10; j++ {
time.Sleep(2 * time.Nanosecond)
res2, err := ns.IncludeCached(name, &data)
assert.NoError(err)
c.Assert(err, qt.IsNil)
if !reflect.DeepEqual(res1, res2) {
t.Fatalf("cache mismatch")
}
res3, err := ns.IncludeCached(name, &data, fmt.Sprintf("variant%d", j))
assert.NoError(err)
c.Assert(err, qt.IsNil)
if reflect.DeepEqual(res1, res3) {
t.Fatalf("cache mismatch")
@@ -205,6 +206,7 @@ func BenchmarkPartialCached(b *testing.B) {
}
func doBenchmarkPartial(b *testing.B, f func(ns *partials.Namespace) error) {
c := qt.New(b)
config := newDepsConfig(viper.New())
config.WithTemplate = func(templ tpl.TemplateHandler) error {
err := templ.AddTemplate("partials/bench1", `{{ shuffle (seq 1 10) }}`)
@@ -216,8 +218,8 @@ func doBenchmarkPartial(b *testing.B, f func(ns *partials.Namespace) error) {
}
de, err := deps.New(config)
require.NoError(b, err)
require.NoError(b, de.LoadResources())
c.Assert(err, qt.IsNil)
c.Assert(de.LoadResources(), qt.IsNil)
ns := partials.New(de)

21
tpl/tplimpl/template_info_test.go
View File

@@ -15,38 +15,39 @@ package tplimpl
import (
"testing"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/tpl"
"github.com/stretchr/testify/require"
)
func TestTemplateInfoShortcode(t *testing.T) {
assert := require.New(t)
d := newD(assert)
c := qt.New(t)
d := newD(c)
h := d.Tmpl.(tpl.TemplateHandler)
assert.NoError(h.AddTemplate("shortcodes/mytemplate.html", `
c.Assert(h.AddTemplate("shortcodes/mytemplate.html", `
{{ .Inner }}
`))
`), qt.IsNil)
tt, found, _ := d.Tmpl.LookupVariant("mytemplate", tpl.TemplateVariants{})
assert.True(found)
c.Assert(found, qt.Equals, true)
tti, ok := tt.(tpl.TemplateInfoProvider)
assert.True(ok)
assert.True(tti.TemplateInfo().IsInner)
c.Assert(ok, qt.Equals, true)
c.Assert(tti.TemplateInfo().IsInner, qt.Equals, true)
}
// TODO(bep) move and use in other places
func newD(assert *require.Assertions) *deps.Deps {
func newD(c *qt.C) *deps.Deps {
v := newTestConfig()
fs := hugofs.NewMem(v)
depsCfg := newDepsConfig(v)
depsCfg.Fs = fs
d, err := deps.New(depsCfg)
assert.NoError(err)
c.Assert(err, qt.IsNil)
provider := DefaultTemplateProvider
provider.Update(d)