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

10
tpl/collections/append_test.go
View File

@@ -14,17 +14,17 @@
package collections
import (
"fmt"
"reflect"
"testing"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/stretchr/testify/require"
)
// Also see tests in common/collection.
func TestAppend(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -45,18 +45,18 @@ func TestAppend(t *testing.T) {
false},
} {
errMsg := fmt.Sprintf("[%d]", i)
errMsg := qt.Commentf("[%d]", i)
args := append(test.addend, test.start)
result, err := ns.Append(args...)
if b, ok := test.expected.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
if !reflect.DeepEqual(test.expected, result) {
t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)

13
tpl/collections/apply_test.go
View File

@@ -18,9 +18,9 @@ import (
"fmt"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl"
"github.com/stretchr/testify/require"
)
type templateFinder int
@@ -41,24 +41,25 @@ func (templateFinder) GetFuncs() map[string]interface{} {
func TestApply(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{Tmpl: new(templateFinder)})
strings := []interface{}{"a\n", "b\n"}
result, err := ns.Apply(strings, "print", "a", "b", "c")
require.NoError(t, err)
require.Equal(t, []interface{}{"abc", "abc"}, result, "testing variadic")
c.Assert(err, qt.IsNil)
c.Assert(result, qt.DeepEquals, []interface{}{"abc", "abc"})
_, err = ns.Apply(strings, "apply", ".")
require.Error(t, err)
c.Assert(err, qt.Not(qt.IsNil))
var nilErr *error
_, err = ns.Apply(nilErr, "chomp", ".")
require.Error(t, err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Apply(strings, "dobedobedo", ".")
require.Error(t, err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Apply(strings, "foo.Chomp", "c\n")
if err == nil {

146
tpl/collections/collections_test.go
View File

@@ -22,6 +22,7 @@ import (
"testing"
"time"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/deps"
@@ -29,14 +30,13 @@ import (
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/langs"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type tstNoStringer struct{}
func TestAfter(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -58,17 +58,17 @@ func TestAfter(t *testing.T) {
{1, t, false},
{1, (*string)(nil), false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.After(test.index, test.seq)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
require.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}
@@ -92,7 +92,7 @@ func (g *tstGrouper2) Group(key interface{}, items interface{}) (interface{}, er
func TestGroup(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -111,22 +111,23 @@ func TestGroup(t *testing.T) {
{"a", nil, false},
{nil, []*tstGrouper{{}, {}}, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Group(test.key, test.items)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
require.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
}
func TestDelimit(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -161,7 +162,7 @@ func TestDelimit(t *testing.T) {
{map[int]string{3: "10", 2: "20", 1: "30", 4: "40", 5: "50"}, "--", "--and--", "30--20--10--40--and--50"},
{map[float64]string{3.5: "10", 2.5: "20", 1.5: "30", 4.5: "40", 5.5: "50"}, "--", "--and--", "30--20--10--40--and--50"},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
var result template.HTML
var err error
@@ -172,13 +173,14 @@ func TestDelimit(t *testing.T) {
result, err = ns.Delimit(test.seq, test.delimiter, test.last)
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
}
func TestDictionary(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -192,22 +194,23 @@ func TestDictionary(t *testing.T) {
{[]interface{}{5, "b"}, false},
{[]interface{}{"a", "b", "c"}, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test.values)
errMsg := qt.Commentf("[%d] %v", i, test.values)
result, err := ns.Dictionary(test.values...)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}
func TestEchoParam(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -229,16 +232,17 @@ func TestEchoParam(t *testing.T) {
{map[string]interface{}{"foo": nil}, "foo", ""},
{(*[]string)(nil), "bar", ""},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result := ns.EchoParam(test.a, test.key)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
}
func TestFirst(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -260,23 +264,23 @@ func TestFirst(t *testing.T) {
{1, t, false},
{1, (*string)(nil), false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.First(test.limit, test.seq)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}
func TestIn(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -311,16 +315,16 @@ func TestIn(t *testing.T) {
{pagesVals{p3v, p2v, p3v, p2v}, p4v, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.In(test.l1, test.l2)
assert.NoError(err)
assert.Equal(test.expect, result, errMsg)
c.Assert(err, qt.IsNil)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
// Slices are not comparable
_, err := ns.In([]string{"a", "b"}, []string{"a", "b"})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}
type testPage struct {
@@ -348,6 +352,7 @@ var (
func TestIntersect(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -420,16 +425,16 @@ func TestIntersect(t *testing.T) {
{[]int{1, 1}, [][]int{{1, 2}, {1, 2}, {1, 3}}, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Intersect(test.l1, test.l2)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
assert.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
if !reflect.DeepEqual(result, test.expect) {
t.Fatalf("[%d] Got\n%v expected\n%v", i, result, test.expect)
}
@@ -438,7 +443,7 @@ func TestIntersect(t *testing.T) {
func TestIsSet(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := newTestNs()
for i, test := range []struct {
@@ -460,20 +465,21 @@ func TestIsSet(t *testing.T) {
{nil, "nil", false, false},
{[]interface{}{1, 2, 3, 5}, TstX{}, false, true},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.IsSet(test.a, test.key)
if test.isErr {
continue
}
assert.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
}
func TestLast(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -495,23 +501,23 @@ func TestLast(t *testing.T) {
{1, t, false},
{1, (*string)(nil), false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Last(test.limit, test.seq)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}
func TestQuerify(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -524,23 +530,23 @@ func TestQuerify(t *testing.T) {
{[]interface{}{5, "b"}, false},
{[]interface{}{"a", "b", "c"}, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test.params)
errMsg := qt.Commentf("[%d] %v", i, test.params)
result, err := ns.Querify(test.params...)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.Equals, test.expect, errMsg)
}
}
func TestSeq(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -568,23 +574,23 @@ func TestSeq(t *testing.T) {
{[]interface{}{tstNoStringer{}}, false},
{nil, false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Seq(test.args...)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}
func TestShuffle(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -604,27 +610,27 @@ func TestShuffle(t *testing.T) {
{t, false},
{(*string)(nil), false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Shuffle(test.seq)
if !test.success {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
resultv := reflect.ValueOf(result)
seqv := reflect.ValueOf(test.seq)
assert.Equal(t, resultv.Len(), seqv.Len(), errMsg)
c.Assert(seqv.Len(), qt.Equals, resultv.Len(), errMsg)
}
}
func TestShuffleRandomising(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
// Note that this test can fail with false negative result if the shuffle
@@ -641,21 +647,21 @@ func TestShuffleRandomising(t *testing.T) {
result, err := ns.Shuffle(test.seq)
resultv := reflect.ValueOf(result)
require.NoError(t, err)
c.Assert(err, qt.IsNil)
allSame := true
for i, v := range test.seq {
allSame = allSame && (resultv.Index(i).Interface() == v)
}
assert.False(t, allSame, "Expected sequence to be shuffled but was in the same order")
c.Assert(allSame, qt.Equals, false)
}
}
// Also see tests in commons/collection.
func TestSlice(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -668,18 +674,18 @@ func TestSlice(t *testing.T) {
{[]interface{}{5, "b"}, []interface{}{5, "b"}},
{[]interface{}{tstNoStringer{}}, []tstNoStringer{{}}},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test.args)
errMsg := qt.Commentf("[%d] %v", i, test.args)
result := ns.Slice(test.args...)
assert.Equal(t, test.expected, result, errMsg)
c.Assert(result, qt.DeepEquals, test.expected, errMsg)
}
assert.Len(t, ns.Slice(), 0)
}
func TestUnion(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -752,15 +758,15 @@ func TestUnion(t *testing.T) {
{[][]int{{1, 1}, {1, 2}}, [][]int{{2, 1}, {2, 2}}, false, true},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Union(test.l1, test.l2)
if test.isErr {
assert.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
assert.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
if !reflect.DeepEqual(result, test.expect) {
t.Fatalf("[%d] Got\n%v expected\n%v", i, result, test.expect)
}
@@ -769,7 +775,7 @@ func TestUnion(t *testing.T) {
func TestUniq(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
l interface{}
@@ -798,16 +804,16 @@ func TestUniq(t *testing.T) {
{1, 1, true},
{"foo", "fo", true},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Uniq(test.l)
if test.isErr {
assert.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
assert.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}

15
tpl/collections/complement_test.go
View File

@@ -14,13 +14,12 @@
package collections
import (
"fmt"
"reflect"
"testing"
"github.com/gohugoio/hugo/deps"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
type StructWithSlice struct {
@@ -33,7 +32,7 @@ type StructWithSlicePointers []*StructWithSlice
func TestComplement(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -69,18 +68,18 @@ func TestComplement(t *testing.T) {
{[]interface{}{[][]string{{"c", "d"}}}, []interface{}{[]string{"c", "d"}, []string{"a", "b"}}, false},
} {
errMsg := fmt.Sprintf("[%d]", i)
errMsg := qt.Commentf("[%d]", i)
args := append(test.t, test.s)
result, err := ns.Complement(args...)
if b, ok := test.expected.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
if !reflect.DeepEqual(test.expected, result) {
t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)
@@ -88,8 +87,8 @@ func TestComplement(t *testing.T) {
}
_, err := ns.Complement()
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Complement([]string{"a", "b"})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}

14
tpl/collections/index_test.go
View File

@@ -14,17 +14,15 @@
package collections
import (
"fmt"
"testing"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestIndex(t *testing.T) {
t.Parallel()
c := qt.New(t)
ns := New(&deps.Deps{})
for i, test := range []struct {
@@ -45,16 +43,16 @@ func TestIndex(t *testing.T) {
{[]int{0, 1}, []interface{}{nil}, nil, true},
{tstNoStringer{}, []interface{}{0}, nil, true},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
result, err := ns.Index(test.item, test.indices...)
if test.isErr {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
c.Assert(err, qt.IsNil, errMsg)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
}
}

9
tpl/collections/init_test.go
View File

@@ -16,12 +16,15 @@ package collections
import (
"testing"
"github.com/gohugoio/hugo/htesting/hqt"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl/internal"
"github.com/stretchr/testify/require"
)
func TestInit(t *testing.T) {
c := qt.New(t)
var found bool
var ns *internal.TemplateFuncsNamespace
@@ -33,6 +36,6 @@ func TestInit(t *testing.T) {
}
}
require.True(t, found)
require.IsType(t, &Namespace{}, ns.Context())
c.Assert(found, qt.Equals, true)
c.Assert(ns.Context(), hqt.IsSameType, &Namespace{})
}

53
tpl/collections/merge_test.go
View File

@@ -25,8 +25,8 @@ import (
"github.com/gohugoio/hugo/parser/metadecoders"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/stretchr/testify/require"
)
func TestMerge(t *testing.T) {
@@ -69,27 +69,27 @@ func TestMerge(t *testing.T) {
t.Run(test.name, func(t *testing.T) {
t.Parallel()
errMsg := fmt.Sprintf("[%d] %v", i, test)
errMsg := qt.Commentf("[%d] %v", i, test)
assert := require.New(t)
c := qt.New(t)
srcStr, dstStr := fmt.Sprint(test.src), fmt.Sprint(test.dst)
result, err := ns.Merge(test.src, test.dst)
if test.isErr {
assert.Error(err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
return
}
assert.NoError(err, errMsg)
assert.Equal(test.expect, result, errMsg)
c.Assert(err, qt.IsNil)
c.Assert(result, qt.DeepEquals, test.expect, errMsg)
// map sort in fmt was fixed in go 1.12.
if !strings.HasPrefix(runtime.Version(), "go1.11") {
// Verify that the original maps are preserved.
assert.Equal(srcStr, fmt.Sprint(test.src))
assert.Equal(dstStr, fmt.Sprint(test.dst))
c.Assert(fmt.Sprint(test.src), qt.Equals, srcStr)
c.Assert(fmt.Sprint(test.dst), qt.Equals, dstStr)
}
})
@@ -97,7 +97,7 @@ func TestMerge(t *testing.T) {
}
func TestMergeDataFormats(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
ns := New(&deps.Deps{})
toml1 := `
@@ -119,33 +119,38 @@ V22 = "v22_2"
`
meta1, err := metadecoders.Default.UnmarshalToMap([]byte(toml1), metadecoders.TOML)
assert.NoError(err)
c.Assert(err, qt.IsNil)
meta2, err := metadecoders.Default.UnmarshalToMap([]byte(toml2), metadecoders.TOML)
assert.NoError(err)
c.Assert(err, qt.IsNil)
for _, format := range []metadecoders.Format{metadecoders.JSON, metadecoders.YAML, metadecoders.TOML} {
var dataStr1, dataStr2 bytes.Buffer
err = parser.InterfaceToConfig(meta1, format, &dataStr1)
assert.NoError(err)
c.Assert(err, qt.IsNil)
err = parser.InterfaceToConfig(meta2, format, &dataStr2)
assert.NoError(err)
c.Assert(err, qt.IsNil)
dst, err := metadecoders.Default.UnmarshalToMap(dataStr1.Bytes(), format)
assert.NoError(err)
c.Assert(err, qt.IsNil)
src, err := metadecoders.Default.UnmarshalToMap(dataStr2.Bytes(), format)
assert.NoError(err)
c.Assert(err, qt.IsNil)
merged, err := ns.Merge(src, dst)
assert.NoError(err)
c.Assert(err, qt.IsNil)
assert.Equal(map[string]interface{}{"V1": "v1_1", "V2": "v2_2", "V2s": map[string]interface{}{"V21": "v21_1", "V22": "v22_2"}}, merged)
c.Assert(
merged,
qt.DeepEquals,
map[string]interface{}{
"V1": "v1_1", "V2": "v2_2",
"V2s": map[string]interface{}{"V21": "v21_1", "V22": "v22_2"}})
}
}
func TestCaseInsensitiveMapLookup(t *testing.T) {
assert := require.New(t)
c := qt.New(t)
m1 := reflect.ValueOf(map[string]interface{}{
"a": 1,
@@ -160,14 +165,14 @@ func TestCaseInsensitiveMapLookup(t *testing.T) {
var found bool
a, found := caseInsensitiveLookup(m1, reflect.ValueOf("A"))
assert.True(found)
assert.Equal(1, a.Interface())
c.Assert(found, qt.Equals, true)
c.Assert(a.Interface(), qt.Equals, 1)
b, found := caseInsensitiveLookup(m1, reflect.ValueOf("b"))
assert.True(found)
assert.Equal(2, b.Interface())
c.Assert(found, qt.Equals, true)
c.Assert(b.Interface(), qt.Equals, 2)
two, found := caseInsensitiveLookup(m2, reflect.ValueOf(2))
assert.True(found)
assert.Equal(2, two.Interface())
c.Assert(found, qt.Equals, true)
c.Assert(two.Interface(), qt.Equals, 2)
}

15
tpl/collections/symdiff_test.go
View File

@@ -14,19 +14,18 @@
package collections
import (
"fmt"
"reflect"
"testing"
"github.com/gohugoio/hugo/deps"
"github.com/stretchr/testify/require"
qt "github.com/frankban/quicktest"
)
func TestSymDiff(t *testing.T) {
t.Parallel()
assert := require.New(t)
c := qt.New(t)
ns := New(&deps.Deps{})
@@ -56,16 +55,16 @@ func TestSymDiff(t *testing.T) {
{[]int{1, 2, 3}, []string{"3", "4"}, false},
} {
errMsg := fmt.Sprintf("[%d]", i)
errMsg := qt.Commentf("[%d]", i)
result, err := ns.SymDiff(test.s2, test.s1)
if b, ok := test.expected.(bool); ok && !b {
require.Error(t, err, errMsg)
c.Assert(err, qt.Not(qt.IsNil), errMsg)
continue
}
require.NoError(t, err, errMsg)
c.Assert(err, qt.IsNil, errMsg)
if !reflect.DeepEqual(test.expected, result) {
t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)
@@ -73,8 +72,8 @@ func TestSymDiff(t *testing.T) {
}
_, err := ns.Complement()
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Complement([]string{"a", "b"})
assert.Error(err)
c.Assert(err, qt.Not(qt.IsNil))
}