Enable testifylint linter (#2044)

* chore: Enable testifylint linter

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

* chore: fix flaky IP lookup test

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

---------

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

12 files changed, 96 insertions, 94 deletions

diff --git a/internal/funcs/coll_test.go b/internal/funcs/coll_test.go
index 71900a59..1a0d6859 100644
--- a/internal/funcs/coll_test.go
+++ b/internal/funcs/coll_test.go
@@ -33,10 +33,10 @@ func TestFlatten(t *testing.T) {
 	c := CollFuncs{}
 
 	_, err := c.Flatten()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Flatten(42)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	out, err := c.Flatten([]interface{}{1, []interface{}{[]int{2}, 3}})
 	require.NoError(t, err)
@@ -53,19 +53,19 @@ func TestPick(t *testing.T) {
 	c := &CollFuncs{}
 
 	_, err := c.Pick()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Pick("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Pick("foo", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Pick("foo", "bar")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Pick(map[string]interface{}{}, "foo", "bar", map[string]interface{}{})
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	in := map[string]interface{}{
 		"foo": "bar",
@@ -102,19 +102,19 @@ func TestOmit(t *testing.T) {
 	c := &CollFuncs{}
 
 	_, err := c.Omit()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Omit("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Omit("foo", nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Omit("foo", "bar")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.Omit(map[string]interface{}{}, "foo", "bar", map[string]interface{}{})
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	in := map[string]interface{}{
 		"foo": "bar",
@@ -152,16 +152,16 @@ func TestGoSlice(t *testing.T) {
 
 	in := reflect.ValueOf(nil)
 	_, err := c.GoSlice(in)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	in = reflect.ValueOf(42)
 	_, err = c.GoSlice(in)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// invalid index type
 	in = reflect.ValueOf([]interface{}{1})
 	_, err = c.GoSlice(in, reflect.ValueOf([]interface{}{[]int{2}}))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	// valid slice, no slicing
 	in = reflect.ValueOf([]int{1})
diff --git a/internal/funcs/crypto_test.go b/internal/funcs/crypto_test.go
index 4d1b5660..e2b15415 100644
--- a/internal/funcs/crypto_test.go
+++ b/internal/funcs/crypto_test.go
@@ -44,7 +44,7 @@ func TestPBKDF2(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = c.PBKDF2(nil, nil, nil, nil, "bogus")
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestWPAPSK(t *testing.T) {
@@ -115,7 +115,7 @@ func TestBcrypt(t *testing.T) {
 		t.Parallel()
 
 		_, err := c.Bcrypt()
-		assert.Error(t, err)
+		require.Error(t, err)
 	})
 }
 
@@ -124,10 +124,10 @@ func TestRSAGenerateKey(t *testing.T) {
 
 	c := testCryptoNS()
 	_, err := c.RSAGenerateKey(0)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.RSAGenerateKey(0, "foo", true)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	key, err := c.RSAGenerateKey(2048)
 	require.NoError(t, err)
@@ -140,10 +140,10 @@ func TestRSAGenerateKey(t *testing.T) {
 func TestECDSAGenerateKey(t *testing.T) {
 	c := testCryptoNS()
 	_, err := c.ECDSAGenerateKey("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.ECDSAGenerateKey(0, "P-999", true)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	key, err := c.ECDSAGenerateKey("P-256")
 	require.NoError(t, err)
@@ -157,7 +157,7 @@ func TestECDSADerivePublicKey(t *testing.T) {
 	c := testCryptoNS()
 
 	_, err := c.ECDSADerivePublicKey("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	key, _ := c.ECDSAGenerateKey("P-256")
 	pub, err := c.ECDSADerivePublicKey(key)
@@ -184,12 +184,12 @@ func TestEd25519GenerateKeyFromSeed(t *testing.T) {
 	enc := ""
 	seed := ""
 	_, err := c.Ed25519GenerateKeyFromSeed(enc, seed)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	enc = "base64"
 	seed = "0000000000000000000000000000000" // 31 bytes, instead of wanted 32.
 	_, err = c.Ed25519GenerateKeyFromSeed(enc, seed)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	seed += "0" // 32 bytes.
 	b64seed := base64.StdEncoding.EncodeToString([]byte(seed))
@@ -206,7 +206,7 @@ func TestEd25519DerivePublicKey(t *testing.T) {
 	c := testCryptoNS()
 
 	_, err := c.Ed25519DerivePublicKey("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	key, _ := c.Ed25519GenerateKey()
 	pub, err := c.Ed25519DerivePublicKey(key)
@@ -249,10 +249,10 @@ func TestAESCrypt(t *testing.T) {
 	in := "hello world"
 
 	_, err := c.EncryptAES(key, 1, 2, 3, 4)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = c.DecryptAES(key, 1, 2, 3, 4)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	enc, err := c.EncryptAES(key, in)
 	require.NoError(t, err)
diff --git a/internal/funcs/file_test.go b/internal/funcs/file_test.go
index d9fe5ccc..0c2babda 100644
--- a/internal/funcs/file_test.go
+++ b/internal/funcs/file_test.go
@@ -108,7 +108,7 @@ func TestReadDir(t *testing.T) {
 	assert.Equal(t, []string{"bar", "baz", "foo", "qux"}, actual)
 
 	_, err = ff.ReadDir("/tmp/foo")
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestWrite(t *testing.T) {
@@ -138,12 +138,12 @@ func TestWrite(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = f.Write("/foo", []byte("Hello world"))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	rel, err := filepath.Rel(newwd, badwd)
 	require.NoError(t, err)
 	_, err = f.Write(rel, []byte("Hello world"))
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	foopath := filepath.Join(newwd, "foo")
 	_, err = f.Write(foopath, []byte("Hello world"))
diff --git a/internal/funcs/math_test.go b/internal/funcs/math_test.go
index 45681e21..50b05784 100644
--- a/internal/funcs/math_test.go
+++ b/internal/funcs/math_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateMathFuncs(t *testing.T) {
@@ -35,7 +36,7 @@ func TestAdd(t *testing.T) {
 	assert.Equal(t, int64(2), m.Add(1, 1))
 	assert.Equal(t, int64(1), m.Add(1))
 	assert.Equal(t, int64(0), m.Add(-5, 5))
-	assert.InDelta(t, float64(5.1), m.Add(4.9, "0.2"), 0.000000001)
+	assert.InEpsilon(t, float64(5.1), m.Add(4.9, "0.2"), 1e-12)
 }
 
 func TestMul(t *testing.T) {
@@ -47,7 +48,7 @@ func TestMul(t *testing.T) {
 	assert.Equal(t, int64(1), m.Mul(1))
 	assert.Equal(t, int64(-25), m.Mul("-5", 5))
 	assert.Equal(t, int64(28), m.Mul(14, "2"))
-	assert.Equal(t, float64(0.5), m.Mul("-1", -0.5))
+	assert.InEpsilon(t, float64(0.5), m.Mul("-1", -0.5), 1e-12)
 }
 
 func TestSub(t *testing.T) {
@@ -57,7 +58,7 @@ func TestSub(t *testing.T) {
 	assert.Equal(t, int64(0), m.Sub(1, 1))
 	assert.Equal(t, int64(-10), m.Sub(-5, 5))
 	assert.Equal(t, int64(-41), m.Sub(true, "42"))
-	assert.InDelta(t, -5.3, m.Sub(10, 15.3), 0.000000000000001)
+	assert.InEpsilon(t, -5.3, m.Sub(10, 15.3), 1e-12)
 }
 
 func mustDiv(a, b interface{}) interface{} {
@@ -74,11 +75,11 @@ func TestDiv(t *testing.T) {
 
 	m := MathFuncs{}
 	_, err := m.Div(1, 0)
-	assert.Error(t, err)
-	assert.Equal(t, 1., mustDiv(1, 1))
-	assert.Equal(t, -1., mustDiv(-5, 5))
-	assert.Equal(t, 1./42, mustDiv(true, "42"))
-	assert.InDelta(t, 0.5, mustDiv(1, 2), 1e-12)
+	require.Error(t, err)
+	assert.InEpsilon(t, 1., mustDiv(1, 1), 1e-12)
+	assert.InEpsilon(t, -1., mustDiv(-5, 5), 1e-12)
+	assert.InEpsilon(t, 1./42, mustDiv(true, "42"), 1e-12)
+	assert.InEpsilon(t, 0.5, mustDiv(1, 2), 1e-12)
 }
 
 func TestRem(t *testing.T) {
@@ -94,7 +95,7 @@ func TestPow(t *testing.T) {
 
 	m := MathFuncs{}
 	assert.Equal(t, int64(4), m.Pow(2, "2"))
-	assert.Equal(t, 2.25, m.Pow(1.5, 2))
+	assert.InEpsilon(t, 2.25, m.Pow(1.5, 2), 1e-12)
 }
 
 func mustSeq(t *testing.T, n ...interface{}) []int64 {
@@ -116,7 +117,7 @@ func TestSeq(t *testing.T) {
 	assert.EqualValues(t, []int64{0, 2, 4}, mustSeq(t, 0, 5, 2))
 	assert.EqualValues(t, []int64{0}, mustSeq(t, 0, 5, 8))
 	_, err := m.Seq()
-	assert.Error(t, err)
+	require.Error(t, err)
 }
 
 func TestIsIntFloatNum(t *testing.T) {
diff --git a/internal/funcs/net_test.go b/internal/funcs/net_test.go
index 7c3afffe..018b75e5 100644
--- a/internal/funcs/net_test.go
+++ b/internal/funcs/net_test.go
@@ -42,7 +42,7 @@ func TestParseIP(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParseIP("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	ip, err := n.ParseIP("2001:470:20::2")
 	require.NoError(t, err)
@@ -59,10 +59,10 @@ func TestParseIPPrefix(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParseIPPrefix("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = n.ParseIPPrefix("1.1.1.1")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	ipprefix, err := n.ParseIPPrefix("192.168.0.2/28")
 	require.NoError(t, err)
@@ -74,10 +74,10 @@ func TestParseIPRange(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParseIPRange("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = n.ParseIPRange("1.1.1.1")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	iprange, err := n.ParseIPRange("192.168.0.2-192.168.23.255")
 	require.NoError(t, err)
@@ -89,7 +89,7 @@ func TestParseAddr(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParseAddr("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	ip, err := n.ParseAddr("2001:470:20::2")
 	require.NoError(t, err)
@@ -106,10 +106,10 @@ func TestParsePrefix(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParsePrefix("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = n.ParsePrefix("1.1.1.1")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	ipprefix, err := n.ParsePrefix("192.168.0.2/28")
 	require.NoError(t, err)
@@ -121,10 +121,10 @@ func TestParseRange(t *testing.T) {
 
 	n := testNetNS()
 	_, err := n.ParseRange("not an IP")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = n.ParseRange("1.1.1.1")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	iprange, err := n.ParseRange("192.168.0.2-192.168.23.255")
 	require.NoError(t, err)
@@ -204,7 +204,7 @@ func TestCIDRSubnets(t *testing.T) {
 	network := netip.MustParsePrefix("10.0.0.0/16")
 
 	subnets, err := n.CIDRSubnets(-1, network)
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, subnets)
 
 	subnets, err = n.CIDRSubnets(2, network)
@@ -220,19 +220,19 @@ func TestCIDRSubnetSizes(t *testing.T) {
 	n := testNetNS()
 
 	subnets, err := n.CIDRSubnetSizes(netip.MustParsePrefix("10.1.0.0/16"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, subnets)
 
 	subnets, err = n.CIDRSubnetSizes(32, netip.MustParsePrefix("10.1.0.0/16"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, subnets)
 
 	subnets, err = n.CIDRSubnetSizes(127, netip.MustParsePrefix("ffff::/48"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, subnets)
 
 	subnets, err = n.CIDRSubnetSizes(-1, netip.MustParsePrefix("10.1.0.0/16"))
-	assert.Error(t, err)
+	require.Error(t, err)
 	assert.Nil(t, subnets)
 
 	network := netip.MustParsePrefix("8000::/1")
diff --git a/internal/funcs/random_test.go b/internal/funcs/random_test.go
index 7f166ffc..c26c8ea7 100644
--- a/internal/funcs/random_test.go
+++ b/internal/funcs/random_test.go
@@ -86,10 +86,10 @@ func TestToCodePoints(t *testing.T) {
 	assert.Equal(t, 'b', u)
 
 	_, _, err = toCodePoints("foo", "bar")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, _, err = toCodePoints("0755", "bar")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	l, u, err = toCodePoints("0xD700", "0x0001FFFF")
 	require.NoError(t, err)
@@ -124,7 +124,7 @@ func TestString(t *testing.T) {
 	assert.Len(t, out, 42)
 
 	_, err = f.String(0)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	out, err = f.String(8, "[a-z]")
 	require.NoError(t, err)
@@ -157,10 +157,10 @@ func TestItem(t *testing.T) {
 
 	f := RandomFuncs{}
 	_, err := f.Item(nil)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = f.Item("foo")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	i, err := f.Item([]string{"foo"})
 	require.NoError(t, err)
@@ -186,7 +186,7 @@ func TestNumber(t *testing.T) {
 	assert.True(t, 0 <= n && n <= 100, n)
 
 	_, err = f.Number(-1)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	n, err = f.Number(0)
 	require.NoError(t, err)
diff --git a/internal/funcs/regexp_test.go b/internal/funcs/regexp_test.go
index 181c74df..47a80fca 100644
--- a/internal/funcs/regexp_test.go
+++ b/internal/funcs/regexp_test.go
@@ -49,7 +49,7 @@ func TestFind(t *testing.T) {
 	assert.Equal(t, "foo", f)
 
 	_, err = re.Find(`[a-`, "")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	f, err = re.Find("4", 42)
 	require.NoError(t, err)
@@ -73,13 +73,13 @@ func TestFindAll(t *testing.T) {
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.FindAll(`[a-`, "")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = re.FindAll("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = re.FindAll("", "", "", "")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	f, err = re.FindAll(`[a-z]+`, 0, `foo bar baz`)
 	require.NoError(t, err)
@@ -111,13 +111,13 @@ func TestSplit(t *testing.T) {
 	assert.EqualValues(t, []string{"foo", "bar", "baz"}, f)
 
 	_, err = re.Split(`[a-`, "")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = re.Split("")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = re.Split("", "", "", "")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	f, err = re.Split(` `, 0, `foo bar baz`)
 	require.NoError(t, err)
diff --git a/internal/funcs/semver_test.go b/internal/funcs/semver_test.go
index f10aad5c..0d52a955 100644
--- a/internal/funcs/semver_test.go
+++ b/internal/funcs/semver_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSemverFuncs_MatchConstraint(t *testing.T) {
@@ -51,9 +52,9 @@ func TestSemverFuncs_MatchConstraint(t *testing.T) {
 			}
 			got, err := s.CheckConstraint(tt.constraint, tt.in)
 			if tt.wantErr {
-				assert.Errorf(t, err, "SemverFuncs.CheckConstraint() error = %v, wantErr %v", err, tt.wantErr)
+				require.Errorf(t, err, "SemverFuncs.CheckConstraint() error = %v, wantErr %v", err, tt.wantErr)
 			} else {
-				assert.NoErrorf(t, err, "SemverFuncs.CheckConstraint() error = %v, wantErr %v", err, tt.wantErr)
+				require.NoErrorf(t, err, "SemverFuncs.CheckConstraint() error = %v, wantErr %v", err, tt.wantErr)
 				assert.Equal(t, tt.want, got)
 			}
 		})
diff --git a/internal/funcs/strings_test.go b/internal/funcs/strings_test.go
index fdc64a47..e1561a0c 100644
--- a/internal/funcs/strings_test.go
+++ b/internal/funcs/strings_test.go
@@ -105,10 +105,10 @@ func TestAbbrev(t *testing.T) {
 
 	sf := &StringFuncs{}
 	_, err := sf.Abbrev()
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = sf.Abbrev("foo")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	s, err := sf.Abbrev(3, "foo")
 	require.NoError(t, err)
diff --git a/internal/funcs/test_test.go b/internal/funcs/test_test.go
index 397e9698..98ae6753 100644
--- a/internal/funcs/test_test.go
+++ b/internal/funcs/test_test.go
@@ -31,7 +31,7 @@ func TestAssert(t *testing.T) {
 
 	f := TestFuncs{ctx: context.Background()}
 	_, err := f.Assert(false)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, err = f.Assert(true)
 	require.NoError(t, err)
@@ -40,7 +40,7 @@ func TestAssert(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = f.Assert("foo", "false")
-	assert.EqualError(t, err, "assertion failed: foo")
+	require.EqualError(t, err, "assertion failed: foo")
 }
 
 func TestRequired(t *testing.T) {
@@ -49,43 +49,43 @@ func TestRequired(t *testing.T) {
 	f := TestFuncs{ctx: context.Background()}
 	errMsg := "can not render template: a required value was not set"
 	v, err := f.Required("")
-	assert.Error(t, err)
-	assert.EqualError(t, err, errMsg)
+	require.Error(t, err)
+	require.EqualError(t, err, errMsg)
 	assert.Nil(t, v)
 
 	v, err = f.Required(nil)
-	assert.Error(t, err)
-	assert.EqualError(t, err, errMsg)
+	require.Error(t, err)
+	require.EqualError(t, err, errMsg)
 	assert.Nil(t, v)
 
 	errMsg = "hello world"
 	v, err = f.Required(errMsg, nil)
-	assert.Error(t, err)
-	assert.EqualError(t, err, errMsg)
+	require.Error(t, err)
+	require.EqualError(t, err, errMsg)
 	assert.Nil(t, v)
 
 	v, err = f.Required(42, nil)
-	assert.Error(t, err)
-	assert.EqualError(t, err, "at <1>: expected string; found int")
+	require.Error(t, err)
+	require.EqualError(t, err, "at <1>: expected string; found int")
 	assert.Nil(t, v)
 
 	v, err = f.Required()
-	assert.Error(t, err)
-	assert.EqualError(t, err, "wrong number of args: want 1 or 2, got 0")
+	require.Error(t, err)
+	require.EqualError(t, err, "wrong number of args: want 1 or 2, got 0")
 	assert.Nil(t, v)
 
 	v, err = f.Required("", 2, 3)
-	assert.Error(t, err)
-	assert.EqualError(t, err, "wrong number of args: want 1 or 2, got 3")
+	require.Error(t, err)
+	require.EqualError(t, err, "wrong number of args: want 1 or 2, got 3")
 	assert.Nil(t, v)
 
 	v, err = f.Required(0)
 	require.NoError(t, err)
-	assert.Equal(t, v, 0)
+	assert.Zero(t, v)
 
 	v, err = f.Required("foo")
 	require.NoError(t, err)
-	assert.Equal(t, v, "foo")
+	assert.Equal(t, "foo", v)
 }
 
 func TestTernary(t *testing.T) {
diff --git a/internal/funcs/time_test.go b/internal/funcs/time_test.go
index 8b2d6e4a..8d229025 100644
--- a/internal/funcs/time_test.go
+++ b/internal/funcs/time_test.go
@@ -64,16 +64,16 @@ func TestParseNum(t *testing.T) {
 	assert.Equal(t, int64(789000000), f)
 
 	_, _, err := parseNum("bogus.9223372036854775807")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, _, err = parseNum("bogus")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, _, err = parseNum("1.2.3")
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	_, _, err = parseNum(1.1)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	i, f, err = parseNum(nil)
 	assert.Zero(t, i)
diff --git a/internal/funcs/uuid_test.go b/internal/funcs/uuid_test.go
index 0f586d5e..57d5c63b 100644
--- a/internal/funcs/uuid_test.go
+++ b/internal/funcs/uuid_test.go
@@ -93,11 +93,11 @@ func TestParse(t *testing.T) {
 	u := UUIDFuncs{ctx: context.Background()}
 	in := interface{}(false)
 	_, err := u.Parse(in)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	in = 12345
 	_, err = u.Parse(in)
-	assert.Error(t, err)
+	require.Error(t, err)
 
 	in = "12345678-1234-1234-1234-1234567890ab"
 	testdata := []interface{}{