chore(pkg): refactor: finer tests conversions to testify part 1

refactor: finer tests conversions to testify in pkg/strvals
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

pkg/action/upgrade_test.go

@@ -252,11 +252,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 		// Now make sure it is actually upgraded
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -320,11 +317,8 @@ func TestUpgradeRelease_ReuseValues(t *testing.T) {
 		// Now get the upgraded release
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -383,11 +377,8 @@ func TestUpgradeRelease_ResetThenReuseValues(t *testing.T) {
 		// Now make sure it is actually upgraded
 		updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 		req.NoError(err)
+		req.NotNil(updatedResi, "Updated Release is nil")
 
-		if updatedResi == nil {
-			is.Fail("Updated Release is nil")
-			return
-		}
 		updatedRes, err := releaserToV1Release(updatedResi)
 		req.NoError(err)
 
@@ -523,11 +514,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
 	// Now make sure it is actually upgraded and labels were merged
 	updatedResi, err := upAction.cfg.Releases.Get(res.Name, 2)
 	req.NoError(err)
+	req.NotNil(updatedResi, "Updated Release is nil")
 
-	if updatedResi == nil {
-		is.Fail("Updated Release is nil")
-		return
-	}
 	updatedRes, err := releaserToV1Release(updatedResi)
 	req.NoError(err)
 	is.Equal(common.StatusDeployed, updatedRes.Info.Status)
@@ -536,11 +524,8 @@ func TestUpgradeRelease_Labels(t *testing.T) {
 	// Now make sure it is suppressed release still contains original labels
 	initialResi, err := upAction.cfg.Releases.Get(res.Name, 1)
 	req.NoError(err)
+	req.NotNil(initialResi, "Initial Release is nil")
 
-	if initialResi == nil {
-		is.Fail("Updated Release is nil")
-		return
-	}
 	initialRes, err := releaserToV1Release(initialResi)
 	req.NoError(err)
 	is.Equal(common.StatusSuperseded, initialRes.Info.Status)

pkg/chart/v2/lint/rules/template_test.go

@@ -171,8 +171,11 @@ func TestValidateMetadataName(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(fmt.Sprintf("%s/%s", tt.obj.Kind, tt.obj.Metadata.Name), func(t *testing.T) {
-			if err := validateMetadataName(tt.obj); (err != nil) != tt.wantErr {
+			err := validateMetadataName(tt.obj)
-				t.Errorf("validateMetadataName() error = %v, wantErr %v", err, tt.wantErr)
+			if tt.wantErr {
+				require.Error(t, err, "validateMetadataName()")
+			} else {
+				require.NoError(t, err, "validateMetadataName()")
 			}
 		})
 	}
@@ -210,12 +213,12 @@ func TestDeprecatedAPIFails(t *testing.T) {
 		namespace,
 		values,
 		TemplateLinterSkipSchemaValidation(false))
-	if l := len(linter.Messages); l != 1 {
+	if !assert.Len(t, linter.Messages, 1) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 1 lint error, got %d", l)
 	}
+	require.Len(t, linter.Messages, 1, "Expected 1 lint error")
 
 	var depErr deprecatedAPIError
 	require.ErrorAs(t, linter.Messages[0].Err, &depErr)
@@ -267,8 +270,7 @@ func TestStrictTemplateParsingMapError(t *testing.T) {
 		namespace,
 		ch.Values,
 		TemplateLinterSkipSchemaValidation(false))
-	if len(linter.Messages) != 0 {
+	if !assert.Empty(t, linter.Messages, "expected zero messages") {
-		t.Errorf("expected zero messages, got %d", len(linter.Messages))
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %q", i, msg)
 		}
@@ -358,9 +360,14 @@ func TestValidateTopIndentLevel(t *testing.T) {
 		"  apiVersion:foo":         true,
 		"\n\n  apiVersion:foo\n\n": true,
 	} {
-		if err := validateTopIndentLevel(doc); (err == nil) == shouldFail {
+		t.Run(doc, func(t *testing.T) {
-			t.Errorf("Expected %t for %q", shouldFail, doc)
+			err := validateTopIndentLevel(doc)
-		}
+			if shouldFail {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
 	}
 }
 
@@ -392,12 +399,12 @@ func TestEmptyWithCommentsManifests(t *testing.T) {
 		namespace,
 		values,
 		TemplateLinterSkipSchemaValidation(false))
-	if l := len(linter.Messages); l > 0 {
+	if !assert.Empty(t, linter.Messages) {
 		for i, msg := range linter.Messages {
 			t.Logf("Message %d: %s", i, msg)
 		}
-		t.Fatalf("Expected 0 lint errors, got %d", l)
 	}
+	require.Empty(t, linter.Messages, "Expected 0 lint errors")
 }
 func TestValidateListAnnotations(t *testing.T) {
 	md := &k8sYamlStruct{

pkg/chart/v2/loader/load_test.go

@@ -25,7 +25,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strings"
 	"testing"
@@ -385,11 +384,13 @@ func TestLoadInvalidArchive(t *testing.T) {
 		{"illegal-abspath5.tgz", "/./c://foo", "chart contains illegally named files"},
 		{"illegal-abspath6.tgz", "\\\\?\\Some\\windows\\magic", "chart illegally contains absolute paths"},
 	} {
-		illegalChart := filepath.Join(tmpdir, tt.chartname)
+		t.Run(tt.chartname, func(t *testing.T) {
-		writeTar(illegalChart, tt.internal, []byte("hello: world"))
+			illegalChart := filepath.Join(tmpdir, tt.chartname)
-		_, err := Load(illegalChart)
+			writeTar(illegalChart, tt.internal, []byte("hello: world"))
-		require.Error(t, err, "expected error when unpacking illegal files")
+			_, err := Load(illegalChart)
-		require.ErrorContains(t, err, tt.expectError, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
+			require.Error(t, err, "expected error when unpacking illegal files")
+			require.ErrorContains(t, err, tt.expectError)
+		})
 	}
 
 	// Make sure that absolute path gets interpreted as relative
@@ -456,7 +457,7 @@ foo:
 		t.Run(testName, func(tt *testing.T) {
 			values, err := LoadValues(bytes.NewReader(testCase.data))
 			require.NoError(tt, err)
-			assert.Truef(t, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
+			assert.Equal(t, testCase.expctedValues, values)
 		})
 	}
 }
@@ -484,16 +485,13 @@ func TestMergeValuesV2(t *testing.T) {
 	}
 
 	testMap := MergeMaps(flatMap, nestedMap)
-	equal := reflect.DeepEqual(testMap, nestedMap)
+	assert.Equal(t, testMap, nestedMap, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
-	assert.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
 
 	testMap = MergeMaps(nestedMap, flatMap)
-	equal = reflect.DeepEqual(testMap, flatMap)
+	assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
-	assert.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
 
 	testMap = MergeMaps(nestedMap, anotherNestedMap)
-	equal = reflect.DeepEqual(testMap, anotherNestedMap)
+	assert.Equal(t, testMap, anotherNestedMap, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
-	assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
 
 	testMap = MergeMaps(anotherFlatMap, anotherNestedMap)
 	expectedMap := map[string]any{
@@ -504,8 +502,7 @@ func TestMergeValuesV2(t *testing.T) {
 			"awesome": "stuff",
 		},
 	}
-	equal = reflect.DeepEqual(testMap, expectedMap)
+	assert.Equal(t, expectedMap, testMap, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
-	assert.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
 }
 
 func verifyChart(t *testing.T, c *chart.Chart) {
@@ -515,15 +512,13 @@ func verifyChart(t *testing.T, c *chart.Chart) {
 	assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
 
 	numfiles := 6
-	if len(c.Files) != numfiles {
+	if !assert.Len(t, c.Files, numfiles) {
-		t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
 		for _, n := range c.Files {
 			t.Logf("\t%s", n.Name)
 		}
 	}
 
-	if len(c.Dependencies()) != 2 {
+	if !assert.Len(t, c.Dependencies(), 2, "Expected 2 dependencies") {
-		t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
 		for _, d := range c.Dependencies() {
 			t.Logf("\tSubchart: %s\n", d.Name())
 		}
@@ -548,7 +543,7 @@ func verifyChart(t *testing.T, c *chart.Chart) {
 
 func verifyDependencies(t *testing.T, c *chart.Chart) {
 	t.Helper()
-	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
+	require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
 	tests := []*chart.Dependency{
 		{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
 		{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},
@@ -563,7 +558,7 @@ func verifyDependencies(t *testing.T, c *chart.Chart) {
 
 func verifyDependenciesLock(t *testing.T, c *chart.Chart) {
 	t.Helper()
-	assert.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
+	require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
 	tests := []*chart.Dependency{
 		{Name: "alpine", Version: "0.1.0", Repository: "https://example.com/charts"},
 		{Name: "mariner", Version: "4.3.2", Repository: "https://example.com/charts"},

pkg/downloader/chart_downloader_test.go

@@ -82,16 +82,15 @@ func TestResolveChartRef(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
+		t.Run(tt.name, func(t *testing.T) {
-		if err != nil {
+			_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
-			if tt.fail {
+			if err != nil {
-				continue
+				require.True(t, tt.fail)
+			} else {
+				got := u.String()
+				assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
 			}
-			t.Errorf("%s: failed with error %q", tt.name, err)
+		})
-			continue
-		}
-		got := u.String()
-		assert.Equalf(t, tt.expect, got, "%s: expected %s, got %s", tt.name, tt.expect, got)
 	}
 }
 
@@ -124,35 +123,25 @@ func TestResolveChartOpts(t *testing.T) {
 	snapshotOpts := c.Options
 
 	for _, tt := range tests {
-		// reset chart downloader options for each test case
+		t.Run(tt.name, func(t *testing.T) {
-		c.Options = snapshotOpts
+			// reset chart downloader options for each test case
-
+			c.Options = snapshotOpts
-		expect, err := getter.NewHTTPGetter(tt.expect...)
+
-		if err != nil {
+			expect, err := getter.NewHTTPGetter(tt.expect...)
-			t.Errorf("%s: failed to setup http client: %s", tt.name, err)
+			require.NoError(t, err, "failed to setup http client")
-			continue
+
-		}
+			_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
-
+			require.NoError(t, err, "failed with error")
-		_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
+
-		if err != nil {
+			got, err := getter.NewHTTPGetter(
-			t.Errorf("%s: failed with error %s", tt.name, err)
+				append(
-			continue
+					c.Options,
-		}
+					getter.WithURL(u.String()),
-
+				)...,
-		got, err := getter.NewHTTPGetter(
+			)
-			append(
+			require.NoError(t, err, "failed to create http client")
-				c.Options,
+			assert.Equal(t, expect, got)
-				getter.WithURL(u.String()),
+		})
-			)...,
-		)
-		if err != nil {
-			t.Errorf("%s: failed to create http client: %s", tt.name, err)
-			continue
-		}
-
-		if *(got.(*getter.HTTPGetter)) != *(expect.(*getter.HTTPGetter)) {
-			t.Errorf("%s: expected %s, got %s", tt.name, expect, got)
-		}
 	}
 }
 

pkg/kube/client_test.go

@@ -567,17 +567,16 @@ func TestUpdate(t *testing.T) {
 
 			// Special handling for the rollback test case
 			if name == "rollback after failed upgrade with removed resource" {
-				assert.Empty(t, result.Created, "expected 0 resource created, got %d", len(result.Created))
+				assert.Empty(t, result.Created, "expected 0 resource created")
-				assert.Len(t, result.Updated, 1, "expected 1 resource updated, got %d", len(result.Updated))
+				assert.Len(t, result.Updated, 1, "expected 1 resource updated")
-				assert.Empty(t, result.Deleted, "expected 0 resource deleted, got %d", len(result.Deleted))
+				assert.Empty(t, result.Deleted, "expected 0 resource deleted")
 			} else {
-				assert.Len(t, result.Created, 1, "expected 1 resource created, got %d", len(result.Created))
+				assert.Len(t, result.Created, 1, "expected 1 resource created")
-				assert.Len(t, result.Updated, 2, "expected 2 resource updated, got %d", len(result.Updated))
+				assert.Len(t, result.Updated, 2, "expected 2 resource updated")
-				assert.Len(t, result.Deleted, 1, "expected 1 resource deleted, got %d", len(result.Deleted))
+				assert.Len(t, result.Deleted, 1, "expected 1 resource deleted")
 			}
 
 			if tc.ExpectedError != "" {
-				require.Error(t, err)
 				require.ErrorContains(t, err, tc.ExpectedError)
 			} else {
 				require.NoError(t, err)
@@ -702,11 +701,11 @@ func TestPerform(t *testing.T) {
 			}
 
 			err = perform(infos, fn)
-			assert.Equal(t, tt.err, (err != nil), "expected error: %v", tt.err)
+			if tt.err {
-			if err != nil {
+				require.EqualError(t, err, tt.errMessage)
-				require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err)
+			} else {
+				require.NoError(t, err)
 			}
-
 			assert.Len(t, results, tt.count, "expected %d result objects, got %d", tt.count, len(results))
 		})
 	}
@@ -782,7 +781,6 @@ func TestWait(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, result.Created, 3, "expected 3 resource created, got %d", len(result.Created))
 	require.NoErrorf(t, c.Wait(resources, time.Second*30), "expected wait without error")
-
 	assert.GreaterOrEqualf(t, time.Since(*created), time.Second*5, "expected to wait at least 5 seconds before ready status was detected, but got %s", time.Since(*created))
 }
 

pkg/strvals/literal_parser_test.go

@@ -16,7 +16,6 @@ limitations under the License.
 package strvals
 
 import (
-	"bytes"
 	"fmt"
 	"strings"
 	"testing"
@@ -279,29 +278,21 @@ func TestParseLiteral(t *testing.T) {
 	}
 
 	for _, tt := range cases {
-		got, err := ParseLiteral(tt.str)
+		t.Run(tt.str, func(t *testing.T) {
-		if err != nil {
+			got, err := ParseLiteral(tt.str)
-			if !tt.err {
+			if tt.err {
-				require.NoError(t, err, tt.str)
+				require.Error(t, err)
-			}
+			} else {
-			continue
+				require.NoError(t, err)
-		}
+				y1, err := yaml.Marshal(tt.expect)
-
+				require.NoError(t, err)
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
 
-		y2, err := yaml.Marshal(got)
+				y2, err := yaml.Marshal(got)
-		if err != nil {
+				require.NoError(t, err, "Error serializing parsed value")
-			require.NoError(t, err, "Error serializing parsed value")
-		}
 
-		if !bytes.Equal(y1, y2) {
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
-			assert.Equal(t, string(y1), string(y2), tt.str)
+			}
-		}
+		})
 	}
 }
 
@@ -386,17 +377,13 @@ func TestParseLiteralInto(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if err := ParseLiteralInto(tt.input, tt.got); err != nil {
+		require.NoError(t, ParseLiteralInto(tt.input, tt.got))
-			require.NoError(t, err)
-		}
 		if tt.err {
 			assert.Fail(t, "Expected error. Got nil", tt.input)
 		}
 
 		if tt.input2 != "" {
-			if err := ParseLiteralInto(tt.input2, tt.got); err != nil {
+			require.NoError(t, ParseLiteralInto(tt.input2, tt.got))
-				require.NoError(t, err)
-			}
 			if tt.err {
 				assert.Fail(t, "Expected error. Got nil", tt.input2)
 			}
@@ -406,13 +393,9 @@ func TestParseLiteralInto(t *testing.T) {
 		require.NoError(t, err)
 
 		y2, err := yaml.Marshal(tt.got)
-		if err != nil {
+		require.NoError(t, err, "Error serializing parsed value")
-			require.NoError(t, err, "Error serializing parsed value")
-		}
 
-		if !bytes.Equal(y1, y2) {
+		assert.YAMLEq(t, string(y1), string(y2), tt.input)
-			assert.Equal(t, string(y1), string(y2), tt.input)
-		}
 	}
 }
 
@@ -447,29 +430,23 @@ func TestParseLiteralNestedLevels(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := ParseLiteral(tt.str)
+		t.Run(tt.str, func(t *testing.T) {
-		if err != nil {
+			got, err := ParseLiteral(tt.str)
 			if tt.err {
+				require.Error(t, err)
 				if tt.errStr != "" {
 					require.EqualError(t, err, tt.errStr)
 				}
-				continue
+			} else {
-			}
+				require.NoError(t, err)
-			require.NoError(t, err, tt.str)
+				y1, err := yaml.Marshal(tt.expect)
-		}
+				require.NoError(t, err)
-
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
 
-		y2, err := yaml.Marshal(got)
+				y2, err := yaml.Marshal(got)
-		require.NoError(t, err, "Error serializing parsed value")
+				require.NoError(t, err, "Error serializing parsed value")
 
-		if !bytes.Equal(y1, y2) {
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
-			assert.Equal(t, string(y1), string(y2), tt.str)
+			}
-		}
+		})
 	}
 }

pkg/strvals/parser_test.go

@@ -16,8 +16,8 @@ limitations under the License.
 package strvals
 
 import (
-	"bytes"
 	"fmt"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -383,50 +383,37 @@ func TestParseSet(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := Parse(tt.str)
+		t.Run(tt.str, func(t *testing.T) {
-		if err != nil {
+			got, err := Parse(tt.str)
 			if tt.err {
-				continue
+				require.Error(t, err)
-			}
+			} else {
-			require.NoError(t, err, tt.str)
+				require.NoError(t, err)
-		}
+				y1, err := yaml.Marshal(tt.expect)
-		if tt.err {
+				require.NoError(t, err)
-			assert.Fail(t, "Expected error. Got nil", tt.str)
+				y2, err := yaml.Marshal(got)
-		}
+				if err != nil {
-
+					require.NoError(t, err, "Error serializing parsed value")
-		y1, err := yaml.Marshal(tt.expect)
+				}
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
 
-		if !bytes.Equal(y1, y2) {
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
-			assert.Equal(t, string(y1), string(y2), tt.str)
+			}
-		}
+		})
 	}
 	for _, tt := range testsString {
-		got, err := ParseString(tt.str)
+		t.Run(tt.str, func(t *testing.T) {
-		if err != nil {
+			got, err := ParseString(tt.str)
 			if tt.err {
-				continue
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err)
+				y2, err := yaml.Marshal(got)
+				require.NoError(t, err, "Error serializing parsed value")
+				assert.YAMLEq(t, string(y1), string(y2))
 			}
-			require.NoError(t, err, tt.str)
+		})
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
-
-		y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
-
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.str)
-		}
 	}
 }
 
@@ -511,33 +498,26 @@ func TestParseInto(t *testing.T) {
 			err: false,
 		},
 	}
-	for _, tt := range tests {
+	for i, tt := range tests {
-		if err := ParseInto(tt.input, tt.got); err != nil {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			require.NoError(t, err)
+			require.NoError(t, ParseInto(tt.input, tt.got))
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.input)
-		}
-
-		if tt.input2 != "" {
-			if err := ParseInto(tt.input2, tt.got); err != nil {
-				require.NoError(t, err)
-			}
 			if tt.err {
-				assert.Fail(t, "Expected error. Got nil", tt.input2)
+				assert.Fail(t, "Expected error. Got nil", tt.input)
 			}
-		}
 
-		y1, err := yaml.Marshal(tt.expect)
+			if tt.input2 != "" {
-		require.NoError(t, err)
+				require.NoError(t, ParseInto(tt.input2, tt.got))
-		y2, err := yaml.Marshal(tt.got)
+				if tt.err {
-		if err != nil {
+					assert.Fail(t, "Expected error. Got nil", tt.input2)
-			require.NoError(t, err, "Error serializing parsed value")
+				}
-		}
+			}
 
-		if !bytes.Equal(y1, y2) {
+			y1, err := yaml.Marshal(tt.expect)
-			assert.Equal(t, string(y1), string(y2), tt.input)
+			require.NoError(t, err)
-		}
+			y2, err := yaml.Marshal(tt.got)
+			require.NoError(t, err, "Error serializing parsed value")
+			assert.YAMLEq(t, string(y1), string(y2), tt.input)
+		})
 	}
 }
 
@@ -564,13 +544,8 @@ func TestParseIntoString(t *testing.T) {
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
 	y2, err := yaml.Marshal(got)
-	if err != nil {
+	require.NoError(t, err, "Error serializing parsed value")
-		require.NoError(t, err, "Error serializing parsed value")
+	assert.YAMLEq(t, string(y1), string(y2), input)
-	}
-
-	if !bytes.Equal(y1, y2) {
-		assert.Equal(t, string(y1), string(y2), input)
-	}
 }
 
 func TestParseJSON(t *testing.T) {
@@ -650,27 +625,19 @@ func TestParseJSON(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		if err := ParseJSON(tt.input, tt.got); err != nil {
+		t.Run(tt.input, func(t *testing.T) {
+			err := ParseJSON(tt.input, tt.got)
 			if tt.err {
-				continue
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				y1, err := yaml.Marshal(tt.expect)
+				require.NoError(t, err, "Error serializing expected value")
+				y2, err := yaml.Marshal(tt.got)
+				require.NoError(t, err, "Error serializing parsed value")
+				assert.YAMLEq(t, string(y1), string(y2))
 			}
-			require.NoError(t, err, tt.input)
+		})
-		}
-		if tt.err {
-			require.Fail(t, "Expected error. Got nil", tt.input)
-		}
-		y1, err := yaml.Marshal(tt.expect)
-		if err != nil {
-			require.NoError(t, err, "Error serializing expected value")
-		}
-		y2, err := yaml.Marshal(tt.got)
-		if err != nil {
-			require.NoError(t, err, "Error serializing parsed value")
-		}
-
-		if !bytes.Equal(y1, y2) {
-			assert.Equal(t, string(y1), string(y2), tt.input)
-		}
 	}
 }
 
@@ -693,14 +660,10 @@ func TestParseFile(t *testing.T) {
 
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
-	y2, err := yaml.Marshal(got)
-	if err != nil {
-		require.NoError(t, err, "Error serializing parsed value")
-	}
 
-	if !bytes.Equal(y1, y2) {
+	y2, err := yaml.Marshal(got)
-		assert.Equal(t, string(y1), string(y2), input)
+	require.NoError(t, err, "Error serializing parsed value")
-	}
+	assert.YAMLEq(t, string(y1), string(y2), input)
 }
 
 func TestParseIntoFile(t *testing.T) {
@@ -725,13 +688,9 @@ func TestParseIntoFile(t *testing.T) {
 	y1, err := yaml.Marshal(expect)
 	require.NoError(t, err)
 	y2, err := yaml.Marshal(got)
-	if err != nil {
+	require.NoError(t, err, "Error serializing parsed value")
-		require.NoError(t, err, "Error serializing parsed value")
-	}
 
-	if !bytes.Equal(y1, y2) {
+	assert.YAMLEq(t, string(y1), string(y2), input)
-		assert.Equal(t, string(y1), string(y2), input)
-	}
 }
 
 func TestToYAML(t *testing.T) {
@@ -775,27 +734,23 @@ func TestParseSetNestedLevels(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		got, err := Parse(tt.str)
+		t.Run(tt.str, func(t *testing.T) {
-		if err != nil {
+			got, err := Parse(tt.str)
 			if tt.err {
+				require.Error(t, err)
 				if tt.errStr != "" {
 					require.EqualError(t, err, tt.errStr)
 				}
-				continue
+			} else {
-			}
+				require.NoError(t, err)
-			require.NoError(t, err, tt.str)
-		}
-		if tt.err {
-			assert.Fail(t, "Expected error. Got nil", tt.str)
-		}
 
-		y1, err := yaml.Marshal(tt.expect)
+				y1, err := yaml.Marshal(tt.expect)
-		require.NoError(t, err)
+				require.NoError(t, err)
-		y2, err := yaml.Marshal(got)
-		require.NoError(t, err, "Error serializing parsed value")
 
-		if !bytes.Equal(y1, y2) {
+				y2, err := yaml.Marshal(got)
-			assert.Equal(t, string(y1), string(y2), tt.str)
+				require.NoError(t, err, "Error serializing parsed value")
-		}
+				assert.YAMLEq(t, string(y1), string(y2), tt.str)
+			}
+		})
 	}
 }