msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

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

Browse Source 
refactor: finer tests conversions to testify in pkg/strvals
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32464/head
Matthieu MOREL 6 days ago
parent 39231d01e1
commit 828d01a878
7 changed files with 177 additions and 271 deletions
Show Stats Download Patch File Download Diff File

25
pkg/action/upgrade_test.go
Unescape View File

@ -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)

29
pkg/chart/v2/lint/rules/template_test.go
Unescape View File

@ -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 {
t.Errorf("validateMetadataName() error = %v, wantErr %v", err, tt.wantErr)
err := validateMetadataName(tt.obj)
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 {
t.Errorf("expected zero messages, got %d", len(linter.Messages))
if !assert.Empty(t, linter.Messages, "expected zero 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.Errorf("Expected %t for %q", shouldFail, doc)
}
t.Run(doc, func(t *testing.T) {
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{

37
pkg/chart/v2/loader/load_test.go
Unescape View File

@ -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)
writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart)
require.Error(t, err, "expected error when unpacking illegal files")
require.ErrorContains(t, err, tt.expectError, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
t.Run(tt.chartname, func(t *testing.T) {
illegalChart := filepath.Join(tmpdir, tt.chartname)
writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart)
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.True(t, equal, "Expected a nested map to overwrite a flat value. Expected: %v, got %v", nestedMap, testMap)
assert.Equal(t, testMap, nestedMap, "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.True(t, equal, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
assert.Equal(t, testMap, flatMap, "Expected a flat value to overwrite a map. Expected: %v, got %v", flatMap, testMap)
testMap = MergeMaps(nestedMap, anotherNestedMap)
equal = reflect.DeepEqual(testMap, anotherNestedMap)
assert.True(t, equal, "Expected a nested map to overwrite another nested map. Expected: %v, got %v", anotherNestedMap, testMap)
assert.Equal(t, testMap, anotherNestedMap, "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.True(t, equal, "Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
assert.Equal(t, expectedMap, testMap, "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 {
t.Errorf("Expected %d extra files, got %d", numfiles, len(c.Files))
if !assert.Len(t, c.Files, numfiles) {
for _, n := range c.Files {
t.Logf("\t%s", n.Name)
}
}
if len(c.Dependencies()) != 2 {
t.Errorf("Expected 2 dependencies, got %d (%v)", len(c.Dependencies()), c.Dependencies())
if !assert.Len(t, c.Dependencies(), 2, "Expected 2 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"},

65
pkg/downloader/chart_downloader_test.go
Unescape View File

@ -82,16 +82,15 @@ func TestResolveChartRef(t *testing.T) {
}
for _, tt := range tests {
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
if tt.fail {
continue
t.Run(tt.name, func(t *testing.T) {
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
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
c.Options = snapshotOpts
expect, err := getter.NewHTTPGetter(tt.expect...)
if err != nil {
t.Errorf("%s: failed to setup http client: %s", tt.name, err)
continue
}
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
if err != nil {
t.Errorf("%s: failed with error %s", tt.name, err)
continue
}
got, err := getter.NewHTTPGetter(
append(
c.Options,
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)
}
t.Run(tt.name, func(t *testing.T) {
// reset chart downloader options for each test case
c.Options = snapshotOpts
expect, err := getter.NewHTTPGetter(tt.expect...)
require.NoError(t, err, "failed to setup http client")
_, u, err := c.ResolveChartVersion(tt.ref, tt.version)
require.NoError(t, err, "failed with error")
got, err := getter.NewHTTPGetter(
append(
c.Options,
getter.WithURL(u.String()),
)...,
)
require.NoError(t, err, "failed to create http client")
assert.Equal(t, expect, got)
})
}
}

22
pkg/kube/client_test.go
Unescape View File

@ -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.Len(t, result.Updated, 1, "expected 1 resource updated, got %d", len(result.Updated))
assert.Empty(t, result.Deleted, "expected 0 resource deleted, got %d", len(result.Deleted))
assert.Empty(t, result.Created, "expected 0 resource created")
assert.Len(t, result.Updated, 1, "expected 1 resource updated")
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.Updated, 2, "expected 2 resource updated, got %d", len(result.Updated))
assert.Len(t, result.Deleted, 1, "expected 1 resource deleted, got %d", len(result.Deleted))
assert.Len(t, result.Created, 1, "expected 1 resource created")
assert.Len(t, result.Updated, 2, "expected 2 resource updated")
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 err != nil {
require.EqualErrorf(t, err, tt.errMessage, "expected error message: %v, got %v", tt.errMessage, err)
if tt.err {
require.EqualError(t, err, tt.errMessage)
} 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))
}

81
pkg/strvals/literal_parser_test.go
Unescape View File

@ -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)
if err != nil {
if !tt.err {
require.NoError(t, err, tt.str)
}
continue
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
t.Run(tt.str, func(t *testing.T) {
got, err := ParseLiteral(tt.str)
if tt.err {
require.Error(t, err)
} else {
require.NoError(t, err)
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")
}
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
assert.YAMLEq(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, err)
}
require.NoError(t, ParseLiteralInto(tt.input, tt.got))
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, err)
}
require.NoError(t, ParseLiteralInto(tt.input2, tt.got))
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.Equal(t, string(y1), string(y2), tt.input)
}
assert.YAMLEq(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)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := ParseLiteral(tt.str)
if tt.err {
require.Error(t, err)
if tt.errStr != "" {
require.EqualError(t, err, tt.errStr)
}
continue
}
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)
} 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")
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
}

189
pkg/strvals/parser_test.go
Unescape View File

@ -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)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := Parse(tt.str)
if tt.err {
continue
}
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")
}
require.Error(t, err)
} else {
require.NoError(t, err)
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)
}
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
for _, tt := range testsString {
got, err := ParseString(tt.str)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
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 {
if err := ParseInto(tt.input, tt.got); err != nil {
require.NoError(t, err)
}
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)
}
for i, tt := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
require.NoError(t, ParseInto(tt.input, tt.got))
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)
require.NoError(t, err)
y2, err := yaml.Marshal(tt.got)
if err != nil {
require.NoError(t, err, "Error serializing parsed value")
}
if tt.input2 != "" {
require.NoError(t, ParseInto(tt.input2, tt.got))
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.input2)
}
}
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.input)
}
y1, err := yaml.Marshal(tt.expect)
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")
}
if !bytes.Equal(y1, y2) {
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 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) {
assert.Equal(t, string(y1), string(y2), input)
}
y2, err := yaml.Marshal(got)
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.Equal(t, string(y1), string(y2), input)
}
assert.YAMLEq(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)
if err != nil {
t.Run(tt.str, func(t *testing.T) {
got, err := Parse(tt.str)
if tt.err {
require.Error(t, err)
if tt.errStr != "" {
require.EqualError(t, err, tt.errStr)
}
continue
}
require.NoError(t, err, tt.str)
}
if tt.err {
assert.Fail(t, "Expected error. Got nil", tt.str)
}
} 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")
y1, err := yaml.Marshal(tt.expect)
require.NoError(t, err)
if !bytes.Equal(y1, y2) {
assert.Equal(t, string(y1), string(y2), tt.str)
}
y2, err := yaml.Marshal(got)
require.NoError(t, err, "Error serializing parsed value")
assert.YAMLEq(t, string(y1), string(y2), tt.str)
}
})
}
}

Write Preview
Loading…
Cancel
Save