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

chore(pkg): refactor: convert tests to testify assert/require part 4

Browse Source 
refactor: convert tests to testify assert/require in pkg
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32418/head
Matthieu MOREL 4 days ago
parent 06978bd8c5
commit 658a8fac15
2 changed files with 116 additions and 299 deletions
Show Stats Download Patch File Download Diff File

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

@ -31,6 +31,7 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/chart/common"
@ -40,13 +41,9 @@ import (
func TestLoadDir(t *testing.T) {
l, err := Loader("testdata/frobnitz")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyFrobnitz(t, c)
verifyChart(t, c)
verifyDependencies(t, c)
@ -59,33 +56,24 @@ func TestLoadDirWithDevNull(t *testing.T) {
}
l, err := Loader("testdata/frobnitz_with_dev_null")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
if _, err := l.Load(); err == nil {
t.Error("packages with an irregular file (/dev/null) should not load")
}
require.NoError(t, err, "Failed to load testdata")
_, err = l.Load()
assert.Error(t, err, "packages with an irregular file (/dev/null) should not load")
}
func TestLoadDirWithSymlink(t *testing.T) {
sym := filepath.Join("..", "LICENSE")
link := filepath.Join("testdata", "frobnitz_with_symlink", "LICENSE")
if err := os.Symlink(sym, link); err != nil {
t.Fatal(err)
}
require.NoError(t, os.Symlink(sym, link))
defer os.Remove(link)
l, err := Loader("testdata/frobnitz_with_symlink")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyFrobnitz(t, c)
verifyChart(t, c)
verifyDependencies(t, c)
@ -102,18 +90,13 @@ func TestBomTestData(t *testing.T) {
}
archive, err := os.ReadFile("testdata/frobnitz_with_bom.tgz")
if err != nil {
t.Fatalf("Error reading archive frobnitz_with_bom.tgz: %s", err)
}
require.NoError(t, err, "Error reading archive frobnitz_with_bom.tgz")
unzipped, err := gzip.NewReader(bytes.NewReader(archive))
if err != nil {
t.Fatalf("Error reading archive frobnitz_with_bom.tgz: %s", err)
}
require.NoError(t, err, "Error reading archive frobnitz_with_bom.tgz")
defer unzipped.Close()
for _, testFile := range testFiles {
data := make([]byte, 3)
err := unzipped.Reset(bytes.NewReader(archive))
require.NoErrorf(t, err, "Error reading archive frobnitz_with_bom.tgz")
require.NoErrorf(t, unzipped.Reset(bytes.NewReader(archive)), "Error reading archive frobnitz_with_bom.tgz")
tr := tar.NewReader(unzipped)
for {
file, err := tr.Next()
@ -135,13 +118,9 @@ func TestBomTestData(t *testing.T) {
func TestLoadDirWithUTFBOM(t *testing.T) {
l, err := Loader("testdata/frobnitz_with_bom")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyFrobnitz(t, c)
verifyChart(t, c)
verifyDependencies(t, c)
@ -151,13 +130,9 @@ func TestLoadDirWithUTFBOM(t *testing.T) {
func TestLoadArchiveWithUTFBOM(t *testing.T) {
l, err := Loader("testdata/frobnitz_with_bom.tgz")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyFrobnitz(t, c)
verifyChart(t, c)
verifyDependencies(t, c)
@ -167,39 +142,27 @@ func TestLoadArchiveWithUTFBOM(t *testing.T) {
func TestLoadV1(t *testing.T) {
l, err := Loader("testdata/frobnitz.v1")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyDependencies(t, c)
verifyDependenciesLock(t, c)
}
func TestLoadFileV1(t *testing.T) {
l, err := Loader("testdata/frobnitz.v1.tgz")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyDependencies(t, c)
verifyDependenciesLock(t, c)
}
func TestLoadFile(t *testing.T) {
l, err := Loader("testdata/frobnitz-1.2.3.tgz")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyFrobnitz(t, c)
verifyChart(t, c)
verifyDependencies(t, c)
@ -223,12 +186,8 @@ func TestLoadFiles_BadCases(t *testing.T) {
expectError: "validation: chart.metadata.apiVersion is required"},
} {
_, err := LoadFiles(tt.bufferedFiles)
if err == nil {
t.Fatal("expected error when load illegal files")
}
if !strings.Contains(err.Error(), tt.expectError) {
t.Errorf("Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.name)
}
require.Error(t, err, "expected error when load illegal files")
assert.ErrorContains(t, err, tt.expectError, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.name)
}
}
@ -280,36 +239,16 @@ icon: https://example.com/64x64.png
}
c, err := LoadFiles(goodFiles)
if err != nil {
t.Errorf("Expected good files to be loaded, got %v", err)
}
if c.Name() != "frobnitz" {
t.Errorf("Expected chart name to be 'frobnitz', got %s", c.Name())
}
if c.Values["var"] != "some values" {
t.Error("Expected chart values to be populated with default values")
}
if len(c.Raw) != 5 {
t.Errorf("Expected %d files, got %d", 5, len(c.Raw))
}
if !bytes.Equal(c.Schema, []byte("type: Values")) {
t.Error("Expected chart schema to be populated with default values")
}
if len(c.Templates) != 2 {
t.Errorf("Expected number of templates == 2, got %d", len(c.Templates))
}
if _, err = LoadFiles([]*archive.BufferedFile{}); err == nil {
t.Fatal("Expected err to be non-nil")
}
if err.Error() != "Chart.yaml file is missing" {
t.Errorf("Expected chart metadata missing error, got '%s'", err.Error())
}
require.NoError(t, err, "Expected good files to be loaded")
assert.Equal(t, "frobnitz", c.Name(), "Expected chart name to be 'frobnitz', got %s", c.Name())
assert.Equal(t, "some values", c.Values["var"], "Expected chart values to be populated with default values")
assert.Len(t, c.Raw, 5, "Expected %d files, got %d", 5, len(c.Raw))
assert.True(t, bytes.Equal(c.Schema, []byte("type: Values")), "Expected chart schema to be populated with default values")
assert.Len(t, c.Templates, 2, "Expected number of templates == 2, got %d", len(c.Templates))
_, err = LoadFiles([]*archive.BufferedFile{})
require.Error(t, err, "Expected err to be non-nil")
assert.EqualError(t, err, "Chart.yaml file is missing")
}
// Test the order of file loading. The Chart.yaml file needs to come first for
@ -365,9 +304,7 @@ icon: https://example.com/64x64.png
// Capture stderr to make sure message about Chart.yaml handle dependencies
// is not present
r, w, err := os.Pipe()
if err != nil {
t.Fatalf("Unable to create pipe: %s", err)
}
require.NoError(t, err, "Unable to create pipe")
stderr := log.Writer()
log.SetOutput(w)
defer func() {
@ -375,25 +312,19 @@ icon: https://example.com/64x64.png
}()
_, err = LoadFiles(goodFiles)
if err != nil {
t.Errorf("Expected good files to be loaded, got %v", err)
}
require.NoError(t, err, "Expected good files to be loaded")
w.Close()
var text bytes.Buffer
io.Copy(&text, r)
if text.String() != "" {
t.Errorf("Expected no message to Stderr, got %s", text.String())
}
assert.Empty(t, text.String(), "Expected no message to Stderr, got %s", text.String())
}
// Packaging the chart on a Windows machine will produce an
// archive that has \\ as delimiters. Test that we support these archives
func TestLoadFileBackslash(t *testing.T) {
c, err := Load("testdata/frobnitz_backslash-1.2.3.tgz")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyChartFileAndTemplate(t, c, "frobnitz_backslash")
verifyChart(t, c)
verifyDependencies(t, c)
@ -401,13 +332,9 @@ func TestLoadFileBackslash(t *testing.T) {
func TestLoadV2WithReqs(t *testing.T) {
l, err := Loader("testdata/frobnitz.v2.reqs")
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
c, err := l.Load()
if err != nil {
t.Fatalf("Failed to load testdata: %s", err)
}
require.NoError(t, err, "Failed to load testdata")
verifyDependencies(t, c)
verifyDependenciesLock(t, c)
}
@ -417,9 +344,7 @@ func TestLoadInvalidArchive(t *testing.T) {
writeTar := func(filename, internalPath string, body []byte) {
dest, err := os.Create(filename)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
zipper := gzip.NewWriter(dest)
tw := tar.NewWriter(zipper)
@ -429,12 +354,9 @@ func TestLoadInvalidArchive(t *testing.T) {
Size: int64(len(body)),
ModTime: time.Now(),
}
if err := tw.WriteHeader(h); err != nil {
t.Fatal(err)
}
if _, err := tw.Write(body); err != nil {
t.Fatal(err)
}
require.NoError(t, tw.WriteHeader(h))
_, err = tw.Write(body)
require.NoError(t, err)
tw.Close()
zipper.Close()
dest.Close()
@ -466,37 +388,27 @@ func TestLoadInvalidArchive(t *testing.T) {
illegalChart := filepath.Join(tmpdir, tt.chartname)
writeTar(illegalChart, tt.internal, []byte("hello: world"))
_, err := Load(illegalChart)
if err == nil {
t.Fatal("expected error when unpacking illegal files")
}
if !strings.Contains(err.Error(), tt.expectError) {
t.Errorf("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, "Expected error to contain %q, got %q for %s", tt.expectError, err.Error(), tt.chartname)
}
// Make sure that absolute path gets interpreted as relative
illegalChart := filepath.Join(tmpdir, "abs-path.tgz")
writeTar(illegalChart, "/Chart.yaml", []byte("hello: world"))
_, err := Load(illegalChart)
if err.Error() != "validation: chart.metadata.name is required" {
t.Error(err)
}
require.EqualError(t, err, "validation: chart.metadata.name is required")
// And just to validate that the above was not spurious
illegalChart = filepath.Join(tmpdir, "abs-path2.tgz")
writeTar(illegalChart, "files/whatever.yaml", []byte("hello: world"))
_, err = Load(illegalChart)
if err.Error() != "Chart.yaml file is missing" {
t.Errorf("Unexpected error message: %s", err)
}
require.EqualError(t, err, "Chart.yaml file is missing")
// Finally, test that drive letter gets stripped off on Windows
illegalChart = filepath.Join(tmpdir, "abs-winpath.tgz")
writeTar(illegalChart, "c:\\Chart.yaml", []byte("hello: world"))
_, err = Load(illegalChart)
if err.Error() != "validation: chart.metadata.name is required" {
t.Error(err)
}
assert.EqualError(t, err, "validation: chart.metadata.name is required")
}
func TestLoadValues(t *testing.T) {
@ -543,12 +455,8 @@ foo:
for testName, testCase := range testCases {
t.Run(testName, func(tt *testing.T) {
values, err := LoadValues(bytes.NewReader(testCase.data))
if err != nil {
tt.Fatal(err)
}
if !reflect.DeepEqual(values, testCase.expctedValues) {
tt.Errorf("Expected values: %v, got %v", testCase.expctedValues, values)
}
require.NoError(tt, err)
assert.Truef(t, reflect.DeepEqual(values, testCase.expctedValues), "Expected values: %v, got %v", testCase.expctedValues, values)
})
}
}
@ -577,21 +485,15 @@ func TestMergeValuesV2(t *testing.T) {
testMap := MergeMaps(flatMap, nestedMap)
equal := reflect.DeepEqual(testMap, nestedMap)
if !equal {
t.Errorf("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)
if !equal {
t.Errorf("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)
if !equal {
t.Errorf("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{
@ -603,20 +505,14 @@ func TestMergeValuesV2(t *testing.T) {
},
}
equal = reflect.DeepEqual(testMap, expectedMap)
if !equal {
t.Errorf("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) {
t.Helper()
if c.Name() == "" {
t.Fatalf("No chart metadata found on %v", c)
}
require.NotEmpty(t, c.Name(), "No chart metadata found on %v", c)
t.Logf("Verifying chart %s", c.Name())
if len(c.Templates) != 1 {
t.Errorf("Expected 1 template, got %d", len(c.Templates))
}
assert.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
numfiles := 6
if len(c.Files) != numfiles {
@ -643,62 +539,40 @@ func verifyChart(t *testing.T, c *chart.Chart) {
}
for _, dep := range c.Dependencies() {
if dep.Metadata == nil {
t.Fatalf("expected metadata on dependency: %v", dep)
}
require.NotNil(t, dep.Metadata, "expected metadata on dependency: %v", dep)
exp, ok := expect[dep.Name()]
if !ok {
t.Fatalf("Unknown dependency %s", dep.Name())
}
if exp["version"] != dep.Metadata.Version {
t.Errorf("Expected %s version %s, got %s", dep.Name(), exp["version"], dep.Metadata.Version)
}
require.True(t, ok, "Unknown dependency %s", dep.Name())
assert.Equal(t, dep.Metadata.Version, exp["version"], "Expected %s version %s, got %s", dep.Name(), exp["version"], dep.Metadata.Version)
}
}
func verifyDependencies(t *testing.T, c *chart.Chart) {
t.Helper()
if len(c.Metadata.Dependencies) != 2 {
t.Errorf("Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
}
assert.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"},
}
for i, tt := range tests {
d := c.Metadata.Dependencies[i]
if d.Name != tt.Name {
t.Errorf("Expected dependency named %q, got %q", tt.Name, d.Name)
}
if d.Version != tt.Version {
t.Errorf("Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
}
if d.Repository != tt.Repository {
t.Errorf("Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
assert.Equal(t, tt.Name, d.Name, "Expected dependency named %q, got %q", tt.Name, d.Name)
assert.Equal(t, tt.Version, d.Version, "Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
assert.Equal(t, tt.Repository, d.Repository, "Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
}
func verifyDependenciesLock(t *testing.T, c *chart.Chart) {
t.Helper()
if len(c.Metadata.Dependencies) != 2 {
t.Errorf("Expected 2 dependencies, got %d", len(c.Metadata.Dependencies))
}
assert.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"},
}
for i, tt := range tests {
d := c.Metadata.Dependencies[i]
if d.Name != tt.Name {
t.Errorf("Expected dependency named %q, got %q", tt.Name, d.Name)
}
if d.Version != tt.Version {
t.Errorf("Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
}
if d.Repository != tt.Repository {
t.Errorf("Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
assert.Equal(t, tt.Name, d.Name, "Expected dependency named %q, got %q", tt.Name, d.Name)
assert.Equal(t, tt.Version, d.Version, "Expected dependency named %q to have version %q, got %q", tt.Name, tt.Version, d.Version)
assert.Equal(t, tt.Repository, d.Repository, "Expected dependency named %q to have repository %q, got %q", tt.Name, tt.Repository, d.Repository)
}
}
@ -709,53 +583,25 @@ func verifyFrobnitz(t *testing.T, c *chart.Chart) {
func verifyChartFileAndTemplate(t *testing.T, c *chart.Chart, name string) {
t.Helper()
if c.Metadata == nil {
t.Fatal("Metadata is nil")
}
if c.Name() != name {
t.Errorf("Expected %s, got %s", name, c.Name())
}
if len(c.Templates) != 1 {
t.Fatalf("Expected 1 template, got %d", len(c.Templates))
}
if c.Templates[0].Name != "templates/template.tpl" {
t.Errorf("Unexpected template: %s", c.Templates[0].Name)
}
if len(c.Templates[0].Data) == 0 {
t.Error("No template data.")
}
if len(c.Files) != 6 {
t.Fatalf("Expected 6 Files, got %d", len(c.Files))
}
if len(c.Dependencies()) != 2 {
t.Fatalf("Expected 2 Dependency, got %d", len(c.Dependencies()))
}
if len(c.Metadata.Dependencies) != 2 {
t.Fatalf("Expected 2 Dependencies.Dependency, got %d", len(c.Metadata.Dependencies))
}
if len(c.Lock.Dependencies) != 2 {
t.Fatalf("Expected 2 Lock.Dependency, got %d", len(c.Lock.Dependencies))
}
require.NotNil(t, c.Metadata, "Metadata is nil")
assert.Equal(t, name, c.Name(), "Expected %s, got %s", name, c.Name())
require.Len(t, c.Templates, 1, "Expected 1 template, got %d", len(c.Templates))
assert.Equal(t, "templates/template.tpl", c.Templates[0].Name, "Unexpected template: %s", c.Templates[0].Name)
assert.NotEmpty(t, c.Templates[0].Data, "No template data.")
require.Len(t, c.Files, 6, "Expected 6 Files, got %d", len(c.Files))
require.Len(t, c.Dependencies(), 2, "Expected 2 Dependency, got %d", len(c.Dependencies()))
require.Len(t, c.Metadata.Dependencies, 2, "Expected 2 Dependencies.Dependency, got %d", len(c.Metadata.Dependencies))
require.Len(t, c.Lock.Dependencies, 2, "Expected 2 Lock.Dependency, got %d", len(c.Lock.Dependencies))
for _, dep := range c.Dependencies() {
switch dep.Name() {
case "mariner":
case "alpine":
if len(dep.Templates) != 1 {
t.Fatalf("Expected 1 template, got %d", len(dep.Templates))
}
if dep.Templates[0].Name != "templates/alpine-pod.yaml" {
t.Errorf("Unexpected template: %s", dep.Templates[0].Name)
}
if len(dep.Templates[0].Data) == 0 {
t.Error("No template data.")
}
if len(dep.Files) != 1 {
t.Fatalf("Expected 1 Files, got %d", len(dep.Files))
}
if len(dep.Dependencies()) != 2 {
t.Fatalf("Expected 2 Dependency, got %d", len(dep.Dependencies()))
}
require.Len(t, dep.Templates, 1, "Expected 1 template, got %d", len(dep.Templates))
assert.Equal(t, "templates/alpine-pod.yaml", dep.Templates[0].Name, "Unexpected template: %s", dep.Templates[0].Name)
assert.NotEmpty(t, dep.Templates[0].Data, "No template data.")
require.Len(t, dep.Files, 1, "Expected 1 Files, got %d", len(dep.Files))
require.Len(t, dep.Dependencies(), 2, "Expected 2 Dependency, got %d", len(dep.Dependencies()))
default:
t.Errorf("Unexpected dependency %s", dep.Name())
}
@ -765,8 +611,6 @@ func verifyChartFileAndTemplate(t *testing.T, c *chart.Chart, name string) {
func verifyBomStripped(t *testing.T, files []*common.File) {
t.Helper()
for _, file := range files {
if bytes.HasPrefix(file.Data, utf8bom) {
t.Errorf("Byte Order Mark still present in processed file %s", file.Name)
}
assert.Falsef(t, bytes.HasPrefix(file.Data, utf8bom), "Byte Order Mark still present in processed file %s", file.Name)
}
}

93
pkg/storage/driver/memory_test.go
Unescape View File

@ -21,6 +21,7 @@ import (
"reflect"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/release"
@ -29,9 +30,8 @@ import (
)
func TestMemoryName(t *testing.T) {
if mem := NewMemory(); mem.Name() != MemoryDriverName {
t.Errorf("Expected name to be %q, got %q", MemoryDriverName, mem.Name())
}
mem := NewMemory()
assert.Equalf(t, MemoryDriverName, mem.Name(), "Expected name to be %q, got %q", MemoryDriverName, mem.Name())
}
func TestMemoryCreate(t *testing.T) {
@ -66,13 +66,12 @@ func TestMemoryCreate(t *testing.T) {
for _, tt := range tests {
key := testKey(tt.rls.Name, tt.rls.Version)
rls := tt.rls
err := ts.Create(key, rls)
if err := ts.Create(key, rls); err != nil {
if !tt.err {
t.Fatalf("failed to create %q: %s", tt.desc, err)
}
} else if tt.err {
t.Fatalf("Did not get expected error for %q\n", tt.desc)
if tt.err {
require.Error(t, err, "Did not get expected error for %q\n", tt.desc)
} else {
require.NoError(t, err, "failed to create %q", tt.desc)
}
}
}
@ -93,12 +92,11 @@ func TestMemoryGet(t *testing.T) {
ts := tsFixtureMemory(t)
for _, tt := range tests {
ts.SetNamespace(tt.namespace)
if _, err := ts.Get(tt.key); err != nil {
if !tt.err {
t.Fatalf("Failed %q to get '%s': %q\n", tt.desc, tt.key, err)
}
} else if tt.err {
t.Fatalf("Did not get expected error for %q '%s'\n", tt.desc, tt.key)
_, err := ts.Get(tt.key)
if tt.err {
require.Error(t, err, "Did not get expected error for %q '%s'\n", tt.desc, tt.key)
} else {
require.NoError(t, err, "Failed %q to get '%s'", tt.desc, tt.key)
}
}
}
@ -113,12 +111,8 @@ func TestMemoryList(t *testing.T) {
return rls.Info.Status == common.StatusDeployed
})
// check
if err != nil {
t.Errorf("Failed to list deployed releases: %s", err)
}
if len(dpl) != 2 {
t.Errorf("Expected 2 deployed, got %d", len(dpl))
}
require.NoError(t, err, "Failed to list deployed releases")
assert.Len(t, dpl, 2, "Expected 2 deployed, got %d", len(dpl))
// list all superseded releases
ssd, err := ts.List(func(rel release.Releaser) bool {
@ -126,12 +120,8 @@ func TestMemoryList(t *testing.T) {
return rls.Info.Status == common.StatusSuperseded
})
// check
if err != nil {
t.Errorf("Failed to list superseded releases: %s", err)
}
if len(ssd) != 6 {
t.Errorf("Expected 6 superseded, got %d", len(ssd))
}
require.NoError(t, err, "Failed to list superseded releases")
assert.Len(t, ssd, 6, "Expected 6 superseded, got %d", len(ssd))
// list all deleted releases
del, err := ts.List(func(rel release.Releaser) bool {
@ -139,12 +129,8 @@ func TestMemoryList(t *testing.T) {
return rls.Info.Status == common.StatusUninstalled
})
// check
if err != nil {
t.Errorf("Failed to list deleted releases: %s", err)
}
if len(del) != 0 {
t.Errorf("Expected 0 deleted, got %d", len(del))
}
require.NoError(t, err, "Failed to list deleted releases")
assert.Empty(t, del, "Expected 0 deleted, got %d", len(del))
}
func TestMemoryQuery(t *testing.T) {
@ -172,13 +158,9 @@ func TestMemoryQuery(t *testing.T) {
for _, tt := range tests {
ts.SetNamespace(tt.namespace)
l, err := ts.Query(tt.lbs)
if err != nil {
t.Fatalf("Failed to query: %s\n", err)
}
require.NoError(t, err, "Failed to query")
if tt.xlen != len(l) {
t.Fatalf("Expected %d results, actual %d\n", tt.xlen, len(l))
}
require.Equal(t, len(l), tt.xlen, "Expected %d results, actual %d\n", tt.xlen, len(l))
}
}
@ -217,23 +199,18 @@ func TestMemoryUpdate(t *testing.T) {
ts := tsFixtureMemory(t)
for _, tt := range tests {
if err := ts.Update(tt.key, tt.rls); err != nil {
if !tt.err {
t.Fatalf("Failed %q: %s\n", tt.desc, err)
}
continue
} else if tt.err {
t.Fatalf("Did not get expected error for %q '%s'\n", tt.desc, tt.key)
}
err := ts.Update(tt.key, tt.rls)
ts.SetNamespace(tt.rls.Namespace)
r, err := ts.Get(tt.key)
if err != nil {
t.Fatalf("Failed to get: %s\n", err)
}
if tt.err {
require.Error(t, err, "Did not get expected error for %q '%s'\n", tt.desc, tt.key)
} else {
require.NoError(t, err, "Failed %q", tt.desc)
ts.SetNamespace(tt.rls.Namespace)
if !reflect.DeepEqual(r, tt.rls) {
t.Fatalf("Expected %v, actual %v\n", tt.rls, r)
r, err := ts.Get(tt.key)
require.NoError(t, err, "Failed to get")
require.Truef(t, reflect.DeepEqual(r, tt.rls), "Expected %v, actual %v\n", tt.rls, r)
}
}
}
@ -256,9 +233,7 @@ func TestMemoryDelete(t *testing.T) {
ts := tsFixtureMemory(t)
ts.SetNamespace("")
start, err := ts.Query(map[string]string{"status": "deployed"})
if err != nil {
t.Errorf("Query failed: %s", err)
}
require.NoError(t, err, "Query failed")
startLen := len(start)
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
@ -280,9 +255,7 @@ func TestMemoryDelete(t *testing.T) {
// Make sure that the deleted records are gone.
ts.SetNamespace("")
end, err := ts.Query(map[string]string{"status": "deployed"})
if err != nil {
t.Errorf("Query failed: %s", err)
}
require.NoError(t, err, "Query failed")
endLen := len(end)
if startLen-2 != endLen {

Write Preview
Loading…
Cancel
Save