Merge pull request #1721 from hairyhenderson/use-require-noerror-in-tests

Use required.NoError for faster failure in tests

11 files changed, 105 insertions, 94 deletions

diff --git a/data/data_test.go b/data/data_test.go
index 2d847a99..4bfea43e 100644
--- a/data/data_test.go
+++ b/data/data_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/ugorji/go/codec"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"os"
 
@@ -24,7 +25,7 @@ func TestUnmarshalObj(t *testing.T) {
 
 	test := func(actual map[string]interface{}, err error) {
 		t.Helper()
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected["foo"], actual["foo"], "foo")
 		assert.Equal(t, expected["one"], actual["one"], "one")
 		assert.Equal(t, expected["true"], actual["true"], "true")
@@ -72,7 +73,7 @@ func TestUnmarshalArray(t *testing.T) {
 		}}
 
 	test := func(actual []interface{}, err error) {
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, expected, actual)
 	}
 	test(JSONArray(`["foo","bar",{"baz":{"qux": true},"quux":{"42":18},"corge":{"false":"blah"}}]`))
@@ -112,7 +113,7 @@ this shouldn't be reached
     42: 18
     false: blah
 `)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t,
 		[]interface{}{
 			map[string]interface{}{
@@ -148,7 +149,7 @@ func TestMarshalObj(t *testing.T) {
 	actual, err := marshalObj(nil, func(in interface{}) ([]byte, error) {
 		return []byte("foo"), nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, actual)
 	_, err = marshalObj(nil, func(in interface{}) ([]byte, error) {
 		return nil, fmt.Errorf("fail")
@@ -159,7 +160,7 @@ func TestMarshalObj(t *testing.T) {
 func TestToJSONBytes(t *testing.T) {
 	expected := []byte("null")
 	actual, err := toJSONBytes(nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, actual)
 
 	_, err = toJSONBytes(&badObject{})
@@ -192,7 +193,7 @@ func TestToJSON(t *testing.T) {
 		},
 	}
 	out, err := ToJSON(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	_, err = ToJSON(&badObject{})
@@ -225,7 +226,7 @@ func TestToJSONPretty(t *testing.T) {
 		},
 	}
 	out, err := ToJSONPretty("  ", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	_, err = ToJSONPretty("  ", &badObject{})
@@ -256,7 +257,7 @@ key`: map[string]interface{}{
 		"d": time.Date(2006, time.January, 2, 15, 4, 5, 999999999, mst),
 	}
 	out, err := ToYAML(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 }
 
@@ -279,7 +280,7 @@ func TestCSV(t *testing.T) {
 	}
 	for _, d := range testdata {
 		out, err := CSV(d.args...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, d.out, out)
 	}
 }
@@ -316,7 +317,7 @@ func TestCSVByRow(t *testing.T) {
 	}
 	for _, d := range testdata {
 		out, err := CSVByRow(d.args...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, d.out, out)
 	}
 }
@@ -344,7 +345,7 @@ func TestCSVByColumn(t *testing.T) {
 	}
 	for _, d := range testdata {
 		out, err := CSVByColumn(d.args...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, d.out, out)
 	}
 }
@@ -368,13 +369,13 @@ func TestToCSV(t *testing.T) {
 	expected := "first,second,third\r\n1,2,3\r\n4,5,6\r\n"
 
 	out, err := ToCSV(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	expected = "first;second;third\r\n1;2;3\r\n4;5;6\r\n"
 
 	out, err = ToCSV(";", in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	_, err = ToCSV(42, [][]int{{1, 2}})
@@ -389,7 +390,7 @@ func TestToCSV(t *testing.T) {
 		{"1", "2", "3"},
 		{"4", "5", "6"},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	expected = "first|second|third\r\n1|2|3\r\n4|5|6\r\n"
@@ -398,7 +399,7 @@ func TestToCSV(t *testing.T) {
 		[]interface{}{1, "2", 3},
 		[]interface{}{"4", 5, "6"},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 }
 
@@ -473,7 +474,7 @@ hosts = [
 	}
 
 	out, err := TOML(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 }
 
@@ -500,7 +501,7 @@ true = true
 		},
 	}
 	out, err := ToTOML(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 }
 
@@ -519,11 +520,11 @@ func TestDecryptEJSON(t *testing.T) {
 
 	t.Setenv("EJSON_KEY", privateKey)
 	actual, err := decryptEJSON(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, actual)
 
 	actual, err = JSON(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, actual)
 
 	tmpDir := fs.NewDir(t, "gomplate-ejsontest",
@@ -534,14 +535,14 @@ func TestDecryptEJSON(t *testing.T) {
 	os.Unsetenv("EJSON_KEY")
 	t.Setenv("EJSON_KEY_FILE", tmpDir.Join(publicKey))
 	actual, err = decryptEJSON(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, actual)
 
 	os.Unsetenv("EJSON_KEY")
 	os.Unsetenv("EJSON_KEY_FILE")
 	t.Setenv("EJSON_KEYDIR", tmpDir.Path())
 	actual, err = decryptEJSON(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, actual)
 }
 
@@ -563,7 +564,7 @@ QUX='single quotes ignore $variables'
 		"QUX":     "single quotes ignore $variables",
 	}
 	out, err := dotEnv(in)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 }
 
@@ -612,7 +613,7 @@ func TestStringifyYAMLArrayMapKeys(t *testing.T) {
 
 	for _, c := range cases {
 		err := stringifyYAMLArrayMapKeys(c.input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, c.want, c.input)
 	}
 }
@@ -654,7 +655,7 @@ func TestStringifyYAMLMapMapKeys(t *testing.T) {
 
 	for _, c := range cases {
 		err := stringifyYAMLMapMapKeys(c.input)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.EqualValues(t, c.want, c.input)
 	}
 }
diff --git a/data/datasource_aws_sm_test.go b/data/datasource_aws_sm_test.go
index f4e28a4e..17f61603 100644
--- a/data/datasource_aws_sm_test.go
+++ b/data/datasource_aws_sm_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/secretsmanager"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // DummyAWSSecretsManagerSecretGetter - test double
@@ -88,7 +89,7 @@ func TestAWSSecretsManager_ParseAWSSecretsManagerArgs(t *testing.T) {
 			args = nil
 		}
 		params, p, err := parseDatasourceURLArgs(mustParseURL(d.u), args...)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		if d.eParams == nil {
 			assert.Empty(t, params)
 		} else {
@@ -154,7 +155,7 @@ func TestAWSSecretsManager_ReadSecret(t *testing.T) {
 
 	output, err := readAWSSecretsManagerParam(context.Background(), s, "/foo/bar")
 	assert.True(t, calledOk)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("blub"), output)
 }
 
@@ -171,6 +172,6 @@ func TestAWSSecretsManager_ReadSecretBinary(t *testing.T) {
 
 	output, err := readAWSSecretsManagerParam(context.Background(), s, "/foo/bar")
 	assert.True(t, calledOk)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("supersecret"), output)
 }
diff --git a/data/datasource_awssmp_test.go b/data/datasource_awssmp_test.go
index 06d3e035..5c5e02db 100644
--- a/data/datasource_awssmp_test.go
+++ b/data/datasource_awssmp_test.go
@@ -11,6 +11,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws/request"
 	"github.com/aws/aws-sdk-go/service/ssm"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // DummyParamGetter - test double
@@ -126,7 +127,7 @@ func TestAWSSMP_listAWSSMPParams(t *testing.T) {
 		},
 	})
 	data, err := listAWSSMPParams(ctx, s, "/")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(`["a","b","c"]`), data)
 
 	s = simpleAWSSourceHelper(DummyParamGetter{
@@ -138,6 +139,6 @@ func TestAWSSMP_listAWSSMPParams(t *testing.T) {
 		},
 	})
 	data, err = listAWSSMPParams(ctx, s, "/a/")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(`["a","b","c"]`), data)
 }
diff --git a/data/datasource_blob_test.go b/data/datasource_blob_test.go
index 7763d8e9..b3e40e3e 100644
--- a/data/datasource_blob_test.go
+++ b/data/datasource_blob_test.go
@@ -12,6 +12,7 @@ import (
 	"github.com/johannesboyne/gofakes3/backend/s3mem"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func setupTestBucket(t *testing.T) (*httptest.Server, *url.URL) {
@@ -20,26 +21,26 @@ func setupTestBucket(t *testing.T) (*httptest.Server, *url.URL) {
 	ts := httptest.NewServer(faker.Server())
 
 	err := backend.CreateBucket("mybucket")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	c := "hello"
 	err = putFile(backend, "mybucket", "file1", "text/plain", c)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c = `{"value": "goodbye world"}`
 	err = putFile(backend, "mybucket", "file2", "application/json", c)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c = `value: what a world`
 	err = putFile(backend, "mybucket", "file3", "application/yaml", c)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c = `value: out of this world`
 	err = putFile(backend, "mybucket", "dir1/file1", "application/yaml", c)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	c = `value: foo`
 	err = putFile(backend, "mybucket", "dir1/file2", "application/yaml", c)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	u, _ := url.Parse(ts.URL)
 	return ts, u
@@ -67,12 +68,12 @@ func TestReadBlob(t *testing.T) {
 	defer os.Unsetenv("AWS_ANON")
 
 	d, err := NewData([]string{"-d", "data=s3://mybucket/file1?region=us-east-1&disableSSL=true&s3ForcePathStyle=true&type=text/plain&endpoint=" + u.Host}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	var expected interface{}
 	expected = "hello"
 	out, err := d.Datasource("data")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	os.Unsetenv("AWS_ANON")
@@ -85,27 +86,27 @@ func TestReadBlob(t *testing.T) {
 	defer os.Unsetenv("AWS_S3_ENDPOINT")
 
 	d, err = NewData([]string{"-d", "data=s3://mybucket/file2?region=us-east-1&disableSSL=true&s3ForcePathStyle=true"}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected = map[string]interface{}{"value": "goodbye world"}
 	out, err = d.Datasource("data")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, out)
 
 	d, err = NewData([]string{"-d", "data=s3://mybucket/?region=us-east-1&disableSSL=true&s3ForcePathStyle=true"}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected = []interface{}{"dir1/", "file1", "file2", "file3"}
 	out, err = d.Datasource("data")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 
 	d, err = NewData([]string{"-d", "data=s3://mybucket/dir1/?region=us-east-1&disableSSL=true&s3ForcePathStyle=true"}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	expected = []interface{}{"file1", "file2"}
 	out, err = d.Datasource("data")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.EqualValues(t, expected, out)
 }
 
diff --git a/data/datasource_env_test.go b/data/datasource_env_test.go
index c7723b3b..7a10b347 100644
--- a/data/datasource_env_test.go
+++ b/data/datasource_env_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func mustParseURL(in string) *url.URL {
@@ -26,30 +27,30 @@ func TestReadEnv(t *testing.T) {
 	source := &Source{Alias: "foo", URL: mustParseURL("env:HELLO_WORLD")}
 
 	actual, err := readEnv(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "foo", URL: mustParseURL("env:/HELLO_WORLD")}
 
 	actual, err = readEnv(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "foo", URL: mustParseURL("env:///HELLO_WORLD")}
 
 	actual, err = readEnv(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "foo", URL: mustParseURL("env:HELLO_WORLD?foo=bar")}
 
 	actual, err = readEnv(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "foo", URL: mustParseURL("env:///HELLO_WORLD?foo=bar")}
 
 	actual, err = readEnv(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 }
diff --git a/data/datasource_file_test.go b/data/datasource_file_test.go
index 8f2a7f0a..420ca380 100644
--- a/data/datasource_file_test.go
+++ b/data/datasource_file_test.go
@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/afero"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadFile(t *testing.T) {
@@ -30,7 +31,7 @@ func TestReadFile(t *testing.T) {
 	source.fs = fs
 
 	actual, err := readFile(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "bogus", URL: mustParseURL("file:///bogus")}
@@ -41,30 +42,30 @@ func TestReadFile(t *testing.T) {
 	source = &Source{Alias: "partial", URL: mustParseURL("file:///tmp/partial")}
 	source.fs = fs
 	actual, err = readFile(ctx, source, "foo.txt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 
 	source = &Source{Alias: "dir", URL: mustParseURL("file:///tmp/partial/")}
 	source.fs = fs
 	actual, err = readFile(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(`["bar.txt","baz.txt","foo.txt"]`), actual)
 
 	source = &Source{Alias: "dir", URL: mustParseURL("file:///tmp/partial/?type=application/json")}
 	source.fs = fs
 	actual, err = readFile(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(`["bar.txt","baz.txt","foo.txt"]`), actual)
 	mime, err := source.mimeType("")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "application/json", mime)
 
 	source = &Source{Alias: "dir", URL: mustParseURL("file:///tmp/partial/?type=application/json")}
 	source.fs = fs
 	actual, err = readFile(ctx, source, "foo.txt")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, content, actual)
 	mime, err = source.mimeType("")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "application/json", mime)
 }
diff --git a/data/datasource_http_test.go b/data/datasource_http_test.go
index 5d279712..a742d9e5 100644
--- a/data/datasource_http_test.go
+++ b/data/datasource_http_test.go
@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func must(r interface{}, err error) interface{} {
@@ -67,11 +68,11 @@ func TestHTTPFile(t *testing.T) {
 	}
 
 	actual, err := data.Datasource("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, must(marshalObj(expected, json.Marshal)), must(marshalObj(actual, json.Marshal)))
 
 	actual, err = data.Datasource(server.URL)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, must(marshalObj(expected, json.Marshal)), must(marshalObj(actual, json.Marshal)))
 }
 
@@ -104,7 +105,7 @@ func TestHTTPFileWithHeaders(t *testing.T) {
 		"Foo":             {"bar", "baz"},
 	}
 	actual, err := data.Datasource("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, must(marshalObj(expected, json.Marshal)), must(marshalObj(actual, json.Marshal)))
 
 	expected = http.Header{
@@ -118,7 +119,7 @@ func TestHTTPFileWithHeaders(t *testing.T) {
 		ExtraHeaders: map[string]http.Header{server.URL: expected},
 	}
 	actual, err = data.Datasource(server.URL)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, must(marshalObj(expected, json.Marshal)), must(marshalObj(actual, json.Marshal)))
 }
 
@@ -126,24 +127,24 @@ func TestBuildURL(t *testing.T) {
 	expected := "https://example.com/index.html"
 	base := mustParseURL(expected)
 	u, err := buildURL(base)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, u.String())
 
 	expected = "https://example.com/index.html"
 	base = mustParseURL("https://example.com")
 	u, err = buildURL(base, "index.html")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, u.String())
 
 	expected = "https://example.com/a/b/c/index.html"
 	base = mustParseURL("https://example.com/a/")
 	u, err = buildURL(base, "b/c/index.html")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, u.String())
 
 	expected = "https://example.com/bar/baz/index.html"
 	base = mustParseURL("https://example.com/foo")
 	u, err = buildURL(base, "bar/baz/index.html")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, u.String())
 }
diff --git a/data/datasource_merge_test.go b/data/datasource_merge_test.go
index 2d81c98a..66365f36 100644
--- a/data/datasource_merge_test.go
+++ b/data/datasource_merge_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/spf13/afero"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadMerge(t *testing.T) {
@@ -59,17 +60,17 @@ func TestReadMerge(t *testing.T) {
 	}
 
 	actual, err := d.readMerge(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, mergedContent, string(actual))
 
 	source.URL = mustParseURL("merge:bar|baz")
 	actual, err = d.readMerge(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, mergedContent, string(actual))
 
 	source.URL = mustParseURL("merge:./jsonfile.json|baz")
 	actual, err = d.readMerge(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, mergedContent, string(actual))
 
 	source.URL = mustParseURL("merge:file:///tmp/jsonfile.json")
@@ -100,7 +101,7 @@ func TestMergeData(t *testing.T) {
 		"z": "def",
 	}
 	out, err := mergeData([]map[string]interface{}{def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: true\nt: false\nz: def\n", string(out))
 
 	over := map[string]interface{}{
@@ -109,7 +110,7 @@ func TestMergeData(t *testing.T) {
 		"z": "over",
 	}
 	out, err = mergeData([]map[string]interface{}{over, def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: false\nt: true\nz: over\n", string(out))
 
 	over = map[string]interface{}{
@@ -121,14 +122,14 @@ func TestMergeData(t *testing.T) {
 		},
 	}
 	out, err = mergeData([]map[string]interface{}{over, def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\nt: true\nz: over\n", string(out))
 
 	uber := map[string]interface{}{
 		"z": "über",
 	}
 	out, err = mergeData([]map[string]interface{}{uber, over, def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\nt: true\nz: über\n", string(out))
 
 	uber = map[string]interface{}{
@@ -138,7 +139,7 @@ func TestMergeData(t *testing.T) {
 		},
 	}
 	out, err = mergeData([]map[string]interface{}{uber, over, def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm: notamap\nt: true\nz:\n  b: bbb\n", string(out))
 
 	uber = map[string]interface{}{
@@ -147,6 +148,6 @@ func TestMergeData(t *testing.T) {
 		},
 	}
 	out, err = mergeData([]map[string]interface{}{uber, over, def})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\n  b: bbb\nt: true\nz: over\n", string(out))
 }
diff --git a/data/datasource_stdin_test.go b/data/datasource_stdin_test.go
index 6cd34133..8cef6827 100644
--- a/data/datasource_stdin_test.go
+++ b/data/datasource_stdin_test.go
@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadStdin(t *testing.T) {
@@ -13,7 +14,7 @@ func TestReadStdin(t *testing.T) {
 
 	ctx = ContextWithStdin(ctx, strings.NewReader("foo"))
 	out, err := readStdin(ctx, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte("foo"), out)
 
 	ctx = ContextWithStdin(ctx, errorReader{})
diff --git a/data/datasource_test.go b/data/datasource_test.go
index 5455699e..c0d0c70a 100644
--- a/data/datasource_test.go
+++ b/data/datasource_test.go
@@ -12,31 +12,32 @@ import (
 	"github.com/spf13/afero"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const osWindows = "windows"
 
 func TestNewData(t *testing.T) {
 	d, err := NewData(nil, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Len(t, d.Sources, 0)
 
 	d, err = NewData([]string{"foo=http:///foo.json"}, nil)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "/foo.json", d.Sources["foo"].URL.Path)
 
 	d, err = NewData([]string{"foo=http:///foo.json"}, []string{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "/foo.json", d.Sources["foo"].URL.Path)
 	assert.Empty(t, d.Sources["foo"].Header)
 
 	d, err = NewData([]string{"foo=http:///foo.json"}, []string{"bar=Accept: blah"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "/foo.json", d.Sources["foo"].URL.Path)
 	assert.Empty(t, d.Sources["foo"].Header)
 
 	d, err = NewData([]string{"foo=http:///foo.json"}, []string{"foo=Accept: blah"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "/foo.json", d.Sources["foo"].URL.Path)
 	assert.Equal(t, "blah", d.Sources["foo"].Header["Accept"][0])
 }
@@ -72,7 +73,7 @@ func TestDatasource(t *testing.T) {
 		data := setup(ext, mime, contents)
 
 		actual, err := data.Datasource("foo")
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, expected, actual)
 	}
 
@@ -92,7 +93,7 @@ func TestDatasource(t *testing.T) {
 
 	d := setup("", textMimetype, nil)
 	actual, err := d.Datasource("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "", actual)
 
 	_, err = d.Datasource("bar")
@@ -174,7 +175,7 @@ func TestInclude(t *testing.T) {
 		Sources: sources,
 	}
 	actual, err := data.Include("foo")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, contents, actual)
 }
 
@@ -201,7 +202,7 @@ func TestDefineDatasource(t *testing.T) {
 	d = &Data{}
 	_, err = d.DefineDatasource("data", "foo.json")
 	s := d.Sources["data"]
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "data", s.Alias)
 	assert.Equal(t, "file", s.URL.Scheme)
 	assert.True(t, s.URL.IsAbs())
@@ -209,7 +210,7 @@ func TestDefineDatasource(t *testing.T) {
 	d = &Data{}
 	_, err = d.DefineDatasource("data", "/otherdir/foo.json")
 	s = d.Sources["data"]
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "data", s.Alias)
 	assert.Equal(t, "file", s.URL.Scheme)
 	assert.True(t, s.URL.IsAbs())
@@ -218,7 +219,7 @@ func TestDefineDatasource(t *testing.T) {
 	d = &Data{}
 	_, err = d.DefineDatasource("data", "sftp://example.com/blahblah/foo.json")
 	s = d.Sources["data"]
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "data", s.Alias)
 	assert.Equal(t, "sftp", s.URL.Scheme)
 	assert.True(t, s.URL.IsAbs())
@@ -231,17 +232,17 @@ func TestDefineDatasource(t *testing.T) {
 	}
 	_, err = d.DefineDatasource("data", "/otherdir/foo.json")
 	s = d.Sources["data"]
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "data", s.Alias)
 	assert.Nil(t, s.URL)
 
 	d = &Data{}
 	_, err = d.DefineDatasource("data", "/otherdir/foo?type=application/x-env")
 	s = d.Sources["data"]
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "data", s.Alias)
 	m, err := s.mimeType("")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "application/x-env", m)
 }
 
@@ -280,7 +281,7 @@ func TestMimeType(t *testing.T) {
 		t.Run(fmt.Sprintf("%d:%q,%q==%q", i, d.url, d.mediaType, d.expected), func(t *testing.T) {
 			s := &Source{URL: mustParseURL(d.url), mediaType: d.mediaType}
 			mt, err := s.mimeType("")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, d.expected, mt)
 		})
 	}
@@ -336,7 +337,7 @@ func TestMimeTypeWithArg(t *testing.T) {
 		t.Run(fmt.Sprintf("%d:%q,%q,%q==%q", i, d.url, d.mediaType, d.arg, d.expected), func(t *testing.T) {
 			s := &Source{URL: mustParseURL(d.url), mediaType: d.mediaType}
 			mt, err := s.mimeType(d.arg)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, d.expected, mt)
 		})
 	}
diff --git a/data/datasource_vault_test.go b/data/datasource_vault_test.go
index 0864fcb9..1c63d696 100644
--- a/data/datasource_vault_test.go
+++ b/data/datasource_vault_test.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/hairyhenderson/gomplate/v4/vault"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadVault(t *testing.T) {
@@ -24,20 +25,20 @@ func TestReadVault(t *testing.T) {
 	}
 
 	r, err := readVault(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(expected), r)
 
 	r, err = readVault(ctx, source, "bar")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(expected), r)
 
 	r, err = readVault(ctx, source, "?param=value")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(expected), r)
 
 	source.URL, _ = url.Parse("vault:///secret/foo?param1=value1&param2=value2")
 	r, err = readVault(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(expected), r)
 
 	expected = "[\"one\",\"two\"]\n"
@@ -45,6 +46,6 @@ func TestReadVault(t *testing.T) {
 	defer server.Close()
 	source.URL, _ = url.Parse("vault:///secret/foo/")
 	r, err = readVault(ctx, source)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []byte(expected), r)
 }