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 16

Browse Source 
#### Description

refactor: convert tests to testify assert/require in pkg/cmd
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/32432/head
Matthieu MOREL 2 months ago
parent 3f1f55c4c8
commit 0fa9f7d427
5 changed files with 120 additions and 282 deletions
Show Stats Download Patch File Download Diff File

6
pkg/action/get_metadata_test.go
Unescape View File

@ -65,8 +65,7 @@ func TestGetMetadata_Run_BasicMetadata(t *testing.T) {
Namespace: "default", Namespace: "default",
} }
err := cfg.Releases.Create(rel) require.NoError(t, cfg.Releases.Create(rel))
require.NoError(t, err)
result, err := client.Run(releaseName) result, err := client.Run(releaseName)
require.NoError(t, err) require.NoError(t, err)
@ -645,8 +644,7 @@ func TestGetMetadata_Labels(t *testing.T) {
rel.Labels = customLabels rel.Labels = customLabels
metaGetter := NewGetMetadata(actionConfigFixture(t)) metaGetter := NewGetMetadata(actionConfigFixture(t))
err := metaGetter.cfg.Releases.Create(rel) require.NoError(t, metaGetter.cfg.Releases.Create(rel))
require.NoError(t, err)
metadata, err := metaGetter.Run(rel.Name) metadata, err := metaGetter.Run(rel.Name)
require.NoError(t, err) require.NoError(t, err)

116
pkg/chart/common/values_test.go
Unescape View File

@ -21,6 +21,9 @@ import (
"fmt" "fmt"
"testing" "testing"
"text/template" "text/template"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func TestReadValues(t *testing.T) { func TestReadValues(t *testing.T) {
@ -46,29 +49,21 @@ water:
` `
data, err := ReadValues([]byte(doc)) data, err := ReadValues([]byte(doc))
if err != nil { require.NoErrorf(t, err, "Error parsing bytes")
t.Fatalf("Error parsing bytes: %s", err)
}
matchValues(t, data) matchValues(t, data)
tests := []string{`poet: "Coleridge"`, "# Just a comment", ""} tests := []string{`poet: "Coleridge"`, "# Just a comment", ""}
for _, tt := range tests { for _, tt := range tests {
data, err = ReadValues([]byte(tt)) data, err = ReadValues([]byte(tt))
if err != nil { require.NoErrorf(t, err, "Error parsing bytes (%s)", tt)
t.Fatalf("Error parsing bytes (%s): %s", tt, err) require.NotNilf(t, data, `YAML string "%s" gave a nil map`, tt)
}
if data == nil {
t.Errorf(`YAML string "%s" gave a nil map`, tt)
}
} }
} }
func TestReadValuesFile(t *testing.T) { func TestReadValuesFile(t *testing.T) {
data, err := ReadValuesFile("./testdata/coleridge.yaml") data, err := ReadValuesFile("./testdata/coleridge.yaml")
if err != nil { require.NoErrorf(t, err, "Error reading YAML file")
t.Fatalf("Error reading YAML file: %s", err)
}
matchValues(t, data) matchValues(t, data)
} }
@ -108,56 +103,40 @@ chapter:
title: "The Spouter Inn" title: "The Spouter Inn"
` `
d, err := ReadValues([]byte(doc)) d, err := ReadValues([]byte(doc))
if err != nil { require.NoErrorf(t, err, "Failed to parse the White Whale")
t.Fatalf("Failed to parse the White Whale: %s", err)
}
if _, err := d.Table("title"); err == nil { _, err = d.Table("title")
t.Fatal("Title is not a table.") require.Error(t, err, "Title is not a table.")
}
if _, err := d.Table("chapter"); err != nil { _, err = d.Table("chapter")
t.Fatalf("Failed to get the chapter table: %s\n%v", err, d) require.NoErrorf(t, err, "Failed to get the chapter table: %v", d)
}
if v, err := d.Table("chapter.one"); err != nil { v, err := d.Table("chapter.one")
t.Errorf("Failed to get chapter.one: %s", err) require.NoErrorf(t, err, "Failed to get chapter.one")
} else if v["title"] != "Loomings" { assert.Equalf(t, "Loomings", v["title"], "Unexpected title: %s", v["title"])
t.Errorf("Unexpected title: %s", v["title"])
}
if _, err := d.Table("chapter.three"); err != nil { _, err = d.Table("chapter.three")
t.Errorf("Chapter three is missing: %s\n%v", err, d) require.NoErrorf(t, err, "Chapter three is missing: %v", d)
}
if _, err := d.Table("chapter.OneHundredThirtySix"); err == nil { _, err = d.Table("chapter.OneHundredThirtySix")
t.Error("I think you mean 'Epilogue'") assert.Error(t, err, "I think you mean 'Epilogue'")
}
} }
func matchValues(t *testing.T, data map[string]any) { func matchValues(t *testing.T, data map[string]any) {
t.Helper() t.Helper()
if data["poet"] != "Coleridge" { assert.Equalf(t, "Coleridge", data["poet"], "Unexpected poet: %s", data["poet"])
t.Errorf("Unexpected poet: %s", data["poet"])
}
if o, err := ttpl("{{len .stanza}}", data); err != nil { o, err := ttpl("{{len .stanza}}", data)
t.Errorf("len stanza: %s", err) require.NoErrorf(t, err, "len stanza")
} else if o != "6" { assert.Equalf(t, "6", o, "Expected 6, got %s", o)
t.Errorf("Expected 6, got %s", o)
}
if o, err := ttpl("{{.mariner.shot}}", data); err != nil { o, err = ttpl("{{.mariner.shot}}", data)
t.Errorf(".mariner.shot: %s", err) require.NoErrorf(t, err, ".mariner.shot")
} else if o != "ALBATROSS" { assert.Equal(t, "ALBATROSS", o, "Expected that mariner shot ALBATROSS")
t.Error("Expected that mariner shot ALBATROSS")
}
if o, err := ttpl("{{.water.water.where}}", data); err != nil { o, err = ttpl("{{.water.water.where}}", data)
t.Errorf(".water.water.where: %s", err) require.NoErrorf(t, err, ".water.water.where")
} else if o != "everywhere" { assert.Equal(t, "everywhere", o, "Expected water water everywhere")
t.Error("Expected water water everywhere")
}
} }
func ttpl(tpl string, v map[string]any) (string, error) { func ttpl(tpl string, v map[string]any) (string, error) {
@ -179,27 +158,18 @@ chapter:
title: "The Spouter Inn" title: "The Spouter Inn"
` `
d, err := ReadValues([]byte(doc)) d, err := ReadValues([]byte(doc))
if err != nil { require.NoErrorf(t, err, "Failed to parse the White Whale")
t.Fatalf("Failed to parse the White Whale: %s", err)
} v, err := d.PathValue("chapter.one.title")
require.NoErrorf(t, err, "Got error instead of title: %v", d)
if v, err := d.PathValue("chapter.one.title"); err != nil { assert.Equalf(t, "Loomings", v, "No error but got wrong value for title: %v", d)
t.Errorf("Got error instead of title: %s\n%v", err, d) _, err = d.PathValue("chapter.one.doesnotexist")
} else if v != "Loomings" { require.Errorf(t, err, "Non-existent key should return error: %v", d)
t.Errorf("No error but got wrong value for title: %s\n%v", err, d) _, err = d.PathValue("chapter.doesnotexist.one")
} require.Errorf(t, err, "Non-existent key in middle of path should return error: %v", d)
if _, err := d.PathValue("chapter.one.doesnotexist"); err == nil { _, err = d.PathValue("")
t.Errorf("Non-existent key should return error: %s\n%v", err, d) require.Error(t, err, "Asking for the value from an empty path should yield an error")
} v, err = d.PathValue("title")
if _, err := d.PathValue("chapter.doesnotexist.one"); err == nil { require.NoErrorf(t, err, "Failed to get title: %v", d)
t.Errorf("Non-existent key in middle of path should return error: %s\n%v", err, d) assert.Equalf(t, "Moby Dick", v, "Failed to return values for root key title: got %s\n%v", v, d)
}
if _, err := d.PathValue(""); err == nil {
t.Error("Asking for the value from an empty path should yield an error")
}
if v, err := d.PathValue("title"); err == nil {
if v != "Moby Dick" {
t.Error("Failed to return values for root key title")
}
}
} }

92
pkg/chart/v2/util/expand_test.go
Unescape View File

@ -47,19 +47,18 @@ func makeTestChartArchive(t *testing.T, chartName, sourceDir string) *bytes.Buff
fStat, err := f.Stat() fStat, err := f.Stat()
require.NoError(t, err) require.NoError(t, err)
err = tw.WriteHeader(&tar.Header{ require.NoError(t, tw.WriteHeader(&tar.Header{
Name: filepath.Join(chartName, relPath), Name: filepath.Join(chartName, relPath),
Mode: int64(fStat.Mode()), Mode: int64(fStat.Mode()),
Size: fStat.Size(), Size: fStat.Size(),
}) }))
require.NoError(t, err)
data, err := fs.ReadFile(dir, relPath) data, err := fs.ReadFile(dir, relPath)
require.NoError(t, err) require.NoError(t, err)
tw.Write(data) tw.Write(data)
} }
err := fs.WalkDir(dir, ".", func(path string, d os.DirEntry, walkErr error) error { require.NoError(t, fs.WalkDir(dir, ".", func(path string, d os.DirEntry, walkErr error) error {
if walkErr != nil { if walkErr != nil {
return walkErr return walkErr
} }
@ -71,15 +70,9 @@ func makeTestChartArchive(t *testing.T, chartName, sourceDir string) *bytes.Buff
writeFile(path) writeFile(path)
return nil return nil
}) }))
if err != nil { require.NoError(t, tw.Close())
t.Fatal(err) require.NoError(t, gw.Close())
}
err = tw.Close()
require.NoError(t, err)
err = gw.Close()
require.NoError(t, err)
return &result return &result
} }
@ -88,51 +81,33 @@ func TestExpand(t *testing.T) {
dest := t.TempDir() dest := t.TempDir()
reader, err := os.Open("testdata/frobnitz-1.2.3.tgz") reader, err := os.Open("testdata/frobnitz-1.2.3.tgz")
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
if err := Expand(dest, reader); err != nil { require.NoError(t, Expand(dest, reader))
t.Fatal(err)
}
expectedChartPath := filepath.Join(dest, "frobnitz") expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath) fi, err := os.Stat(expectedChartPath)
if err != nil { require.NoError(t, err)
t.Fatal(err) require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
}
if !fi.IsDir() {
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
dir, err := os.Open(expectedChartPath) dir, err := os.Open(expectedChartPath)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
fis, err := dir.Readdir(0) fis, err := dir.Readdir(0)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expectLen := 11 expectLen := 11
if len(fis) != expectLen { assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
t.Errorf("Expected %d files, but got %d", expectLen, len(fis))
}
for _, fi := range fis { for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name())) expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
// os.Stat can return different values for directories, based on the OS // os.Stat can return different values for directories, based on the OS
// for Linux, for example, os.Stat always returns the size of the directory // for Linux, for example, os.Stat always returns the size of the directory
// (value-4096) regardless of the size of the contents of the directory // (value-4096) regardless of the size of the contents of the directory
mode := expect.Mode() mode := expect.Mode()
if !mode.IsDir() { if !mode.IsDir() {
if fi.Size() != expect.Size() { assert.Equal(t, expect.Size(), fi.Size(), "Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
t.Errorf("Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
}
} }
} }
} }
@ -151,10 +126,9 @@ func TestExpandError(t *testing.T) {
for name, tt := range tests { for name, tt := range tests {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
archive := makeTestChartArchive(t, tt.chartName, tt.chartDir) archive := makeTestChartArchive(t, tt.chartName, tt.chartDir)
dest := t.TempDir() dest := t.TempDir()
err := Expand(dest, archive)
assert.ErrorContains(t, err, tt.wantErr) assert.ErrorContains(t, Expand(dest, archive), tt.wantErr)
}) })
} }
} }
@ -162,47 +136,31 @@ func TestExpandError(t *testing.T) {
func TestExpandFile(t *testing.T) { func TestExpandFile(t *testing.T) {
dest := t.TempDir() dest := t.TempDir()
if err := ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"); err != nil { require.NoError(t, ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"))
t.Fatal(err)
}
expectedChartPath := filepath.Join(dest, "frobnitz") expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath) fi, err := os.Stat(expectedChartPath)
if err != nil { require.NoError(t, err)
t.Fatal(err) require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
}
if !fi.IsDir() {
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
dir, err := os.Open(expectedChartPath) dir, err := os.Open(expectedChartPath)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
fis, err := dir.Readdir(0) fis, err := dir.Readdir(0)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expectLen := 11 expectLen := 11
if len(fis) != expectLen { assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
t.Errorf("Expected %d files, but got %d", expectLen, len(fis))
}
for _, fi := range fis { for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name())) expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
// os.Stat can return different values for directories, based on the OS // os.Stat can return different values for directories, based on the OS
// for Linux, for example, os.Stat always returns the size of the directory // for Linux, for example, os.Stat always returns the size of the directory
// (value-4096) regardless of the size of the contents of the directory // (value-4096) regardless of the size of the contents of the directory
mode := expect.Mode() mode := expect.Mode()
if !mode.IsDir() { if !mode.IsDir() {
if fi.Size() != expect.Size() { assert.Equal(t, expect.Size(), fi.Size(), "Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
t.Errorf("Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
}
} }
} }
} }

83
pkg/cmd/plugin_verify_test.go
Unescape View File

@ -21,9 +21,11 @@ import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"strings"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/plugin" "helm.sh/helm/v4/internal/plugin"
"helm.sh/helm/v4/internal/test/ensure" "helm.sh/helm/v4/internal/test/ensure"
) )
@ -35,13 +37,7 @@ func TestPluginVerifyCmd_NoArgs(t *testing.T) {
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{}) cmd.SetArgs([]string{})
err := cmd.Execute() assert.ErrorContains(t, cmd.Execute(), "requires 1 argument", "expected 'requires 1 argument' error")
if err == nil {
t.Error("expected error when no arguments provided")
}
if !strings.Contains(err.Error(), "requires 1 argument") {
t.Errorf("expected 'requires 1 argument' error, got: %v", err)
}
} }
func TestPluginVerifyCmd_TooManyArgs(t *testing.T) { func TestPluginVerifyCmd_TooManyArgs(t *testing.T) {
@ -51,13 +47,7 @@ func TestPluginVerifyCmd_TooManyArgs(t *testing.T) {
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{"plugin1", "plugin2"}) cmd.SetArgs([]string{"plugin1", "plugin2"})
err := cmd.Execute() assert.ErrorContains(t, cmd.Execute(), "requires 1 argument", "expected 'requires 1 argument' error")
if err == nil {
t.Error("expected error when too many arguments provided")
}
if !strings.Contains(err.Error(), "requires 1 argument") {
t.Errorf("expected 'requires 1 argument' error, got: %v", err)
}
} }
func TestPluginVerifyCmd_NonexistentFile(t *testing.T) { func TestPluginVerifyCmd_NonexistentFile(t *testing.T) {
@ -67,10 +57,7 @@ func TestPluginVerifyCmd_NonexistentFile(t *testing.T) {
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{"/nonexistent/plugin.tgz"}) cmd.SetArgs([]string{"/nonexistent/plugin.tgz"})
err := cmd.Execute() assert.Error(t, cmd.Execute(), "expected error when plugin file doesn't exist")
if err == nil {
t.Error("expected error when plugin file doesn't exist")
}
} }
func TestPluginVerifyCmd_MissingProvenance(t *testing.T) { func TestPluginVerifyCmd_MissingProvenance(t *testing.T) {
@ -84,13 +71,7 @@ func TestPluginVerifyCmd_MissingProvenance(t *testing.T) {
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginTgz}) cmd.SetArgs([]string{pluginTgz})
err := cmd.Execute() assert.ErrorContains(t, cmd.Execute(), "could not find provenance file", "expected 'could not find provenance file' error")
if err == nil {
t.Error("expected error when .prov file is missing")
}
if !strings.Contains(err.Error(), "could not find provenance file") {
t.Errorf("expected 'could not find provenance file' error, got: %v", err)
}
} }
func TestPluginVerifyCmd_InvalidProvenance(t *testing.T) { func TestPluginVerifyCmd_InvalidProvenance(t *testing.T) {
@ -102,19 +83,14 @@ func TestPluginVerifyCmd_InvalidProvenance(t *testing.T) {
// Create invalid .prov file // Create invalid .prov file
provFile := pluginTgz + ".prov" provFile := pluginTgz + ".prov"
if err := os.WriteFile(provFile, []byte("invalid provenance"), 0o644); err != nil { require.NoError(t, os.WriteFile(provFile, []byte("invalid provenance"), 0o644))
t.Fatal(err)
}
defer os.Remove(provFile) defer os.Remove(provFile)
out := &bytes.Buffer{} out := &bytes.Buffer{}
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginTgz}) cmd.SetArgs([]string{pluginTgz})
err := cmd.Execute() assert.Error(t, cmd.Execute(), "expected error when .prov file is invalid")
if err == nil {
t.Error("expected error when .prov file is invalid")
}
} }
func TestPluginVerifyCmd_DirectoryNotSupported(t *testing.T) { func TestPluginVerifyCmd_DirectoryNotSupported(t *testing.T) {
@ -127,13 +103,7 @@ func TestPluginVerifyCmd_DirectoryNotSupported(t *testing.T) {
cmd := newPluginVerifyCmd(out) cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginDir}) cmd.SetArgs([]string{pluginDir})
err := cmd.Execute() assert.ErrorContains(t, cmd.Execute(), "directory verification not supported", "expected 'directory verification not supported' error")
if err == nil {
t.Error("expected error when verifying directory")
}
if !strings.Contains(err.Error(), "directory verification not supported") {
t.Errorf("expected 'directory verification not supported' error, got: %v", err)
}
} }
func TestPluginVerifyCmd_KeyringFlag(t *testing.T) { func TestPluginVerifyCmd_KeyringFlag(t *testing.T) {
@ -157,10 +127,7 @@ func TestPluginVerifyCmd_KeyringFlag(t *testing.T) {
cmd.SetArgs([]string{"--keyring", keyring, pluginTgz}) cmd.SetArgs([]string{"--keyring", keyring, pluginTgz})
// Should fail with keyring error but command parsing should work // Should fail with keyring error but command parsing should work
err := cmd.Execute() assert.Error(t, cmd.Execute(), "expected error with empty keyring")
if err == nil {
t.Error("expected error with empty keyring")
}
// The important thing is that the keyring flag was parsed and used // The important thing is that the keyring flag was parsed and used
} }
@ -178,14 +145,10 @@ func createTestPluginDir(t *testing.T) string {
// Create temporary directory with plugin structure // Create temporary directory with plugin structure
tmpDir := t.TempDir() tmpDir := t.TempDir()
pluginDir := filepath.Join(tmpDir, "test-plugin") pluginDir := filepath.Join(tmpDir, "test-plugin")
if err := os.MkdirAll(pluginDir, 0o755); err != nil { require.NoErrorf(t, os.MkdirAll(pluginDir, 0o755), "Failed to create plugin directory")
t.Fatalf("Failed to create plugin directory: %v", err)
}
// Use the same plugin YAML as other cmd tests // Use the same plugin YAML as other cmd tests
if err := os.WriteFile(filepath.Join(pluginDir, "plugin.yaml"), []byte(testPluginYAML), 0o644); err != nil { require.NoErrorf(t, os.WriteFile(filepath.Join(pluginDir, "plugin.yaml"), []byte(testPluginYAML), 0o644), "Failed to create plugin.yaml")
t.Fatalf("Failed to create plugin.yaml: %v", err)
}
return pluginDir return pluginDir
} }
@ -199,14 +162,10 @@ func createTestPluginTarball(t *testing.T) string {
tmpDir := filepath.Dir(pluginDir) tmpDir := filepath.Dir(pluginDir)
tgzPath := filepath.Join(tmpDir, "test-plugin-1.0.0.tgz") tgzPath := filepath.Join(tmpDir, "test-plugin-1.0.0.tgz")
tarFile, err := os.Create(tgzPath) tarFile, err := os.Create(tgzPath)
if err != nil { require.NoError(t, err, "Failed to create tarball file")
t.Fatalf("Failed to create tarball file: %v", err)
}
defer tarFile.Close() defer tarFile.Close()
if err := plugin.CreatePluginTarball(pluginDir, "test-plugin", tarFile); err != nil { require.NoErrorf(t, plugin.CreatePluginTarball(pluginDir, "test-plugin", tarFile), "Failed to create tarball")
t.Fatalf("Failed to create tarball: %v", err)
}
return tgzPath return tgzPath
} }
@ -218,9 +177,7 @@ func createProvFile(t *testing.T, provFile, pluginTgz, hash string) {
if hash == "" { if hash == "" {
// Calculate actual hash of the tarball // Calculate actual hash of the tarball
data, err := os.ReadFile(pluginTgz) data, err := os.ReadFile(pluginTgz)
if err != nil { require.NoError(t, err, "Failed to read tarball for hashing")
t.Fatalf("Failed to read tarball for hashing: %v", err)
}
hashSum := sha256.Sum256(data) hashSum := sha256.Sum256(data)
hashStr = fmt.Sprintf("sha256:%x", hashSum) hashStr = fmt.Sprintf("sha256:%x", hashSum)
} else { } else {
@ -243,9 +200,7 @@ Version: GnuPG v1
iQEcBAEBCAAGBQJktest... iQEcBAEBCAAGBQJktest...
-----END PGP SIGNATURE----- -----END PGP SIGNATURE-----
`, hashStr) `, hashStr)
if err := os.WriteFile(provFile, []byte(provContent), 0o644); err != nil { require.NoErrorf(t, os.WriteFile(provFile, []byte(provContent), 0o644), "Failed to create provenance file")
t.Fatalf("Failed to create provenance file: %v", err)
}
} }
func createTestKeyring(t *testing.T) string { func createTestKeyring(t *testing.T) string {
@ -256,9 +211,7 @@ func createTestKeyring(t *testing.T) string {
keyringPath := filepath.Join(tmpDir, "pubring.gpg") keyringPath := filepath.Join(tmpDir, "pubring.gpg")
// Create empty keyring for testing // Create empty keyring for testing
if err := os.WriteFile(keyringPath, []byte{}, 0o644); err != nil { require.NoErrorf(t, os.WriteFile(keyringPath, []byte{}, 0o644), "Failed to create test keyring")
t.Fatalf("Failed to create test keyring: %v", err)
}
return keyringPath return keyringPath
} }

105
pkg/cmd/pull_test.go
Unescape View File

@ -25,6 +25,9 @@ import (
"strings" "strings"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/repo/v1/repotest" "helm.sh/helm/v4/pkg/repo/v1/repotest"
) )
@ -36,14 +39,10 @@ func TestPullCmd(t *testing.T) {
defer srv.Stop() defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root()) ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
ociSrv.Run(t) ociSrv.Run(t)
if err := srv.LinkIndices(); err != nil { require.NoError(t, srv.LinkIndices())
t.Fatal(err)
}
helmTestKeyOut := "Signed by: Helm Testing (This key should only be used for testing. DO NOT TRUST.) <helm-testing@helm.sh>\n" + helmTestKeyOut := "Signed by: Helm Testing (This key should only be used for testing. DO NOT TRUST.) <helm-testing@helm.sh>\n" +
"Using Key With Fingerprint: 5E615389B53CA37F0EE60BD3843BBF981FC18762\n" + "Using Key With Fingerprint: 5E615389B53CA37F0EE60BD3843BBF981FC18762\n" +
@ -229,20 +228,13 @@ func TestPullCmd(t *testing.T) {
// Create file or Dir before helm pull --untar, see: https://github.com/helm/helm/issues/7182 // Create file or Dir before helm pull --untar, see: https://github.com/helm/helm/issues/7182
if tt.existFile != "" { if tt.existFile != "" {
file := filepath.Join(outdir, tt.existFile) file := filepath.Join(outdir, tt.existFile)
if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil { require.NoError(t, os.MkdirAll(filepath.Dir(file), 0o755))
t.Fatal(err) _, err = os.Create(file)
} require.NoError(t, err)
_, err := os.Create(file)
if err != nil {
t.Fatal(err)
}
} }
if tt.existDir != "" { if tt.existDir != "" {
file := filepath.Join(outdir, tt.existDir) file := filepath.Join(outdir, tt.existDir)
err := os.MkdirAll(file, 0o755) require.NoError(t, os.MkdirAll(file, 0o755))
if err != nil {
t.Fatal(err)
}
} }
_, out, err := executeActionCommand(cmd) _, out, err := executeActionCommand(cmd)
if err != nil { if err != nil {
@ -257,19 +249,13 @@ func TestPullCmd(t *testing.T) {
if tt.expectVerify { if tt.expectVerify {
outString := helmTestKeyOut + tt.expectSha + "\n" outString := helmTestKeyOut + tt.expectSha + "\n"
if out != outString { assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
t.Errorf("%q: expected verification output %q, got %q", tt.name, outString, out)
}
} }
ef := filepath.Join(outdir, tt.expectFile) ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef) fi, err := os.Stat(ef)
if err != nil { require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
t.Errorf("%q: expected a file at %s. %s", tt.name, ef, err) assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
}
if fi.IsDir() != tt.expectDir {
t.Errorf("%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
}
}) })
} }
} }
@ -300,38 +286,24 @@ func runPullTests(t *testing.T, tests []struct {
if tt.existFile != "" { if tt.existFile != "" {
file := filepath.Join(outdir, tt.existFile) file := filepath.Join(outdir, tt.existFile)
_, err := os.Create(file) _, err := os.Create(file)
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
} }
if tt.existDir != "" { if tt.existDir != "" {
file := filepath.Join(outdir, tt.existDir) file := filepath.Join(outdir, tt.existDir)
err := os.MkdirAll(file, 0o755) require.NoError(t, os.MkdirAll(file, 0o755))
if err != nil {
t.Fatal(err)
}
} }
_, _, err := executeActionCommand(cmd) _, _, err := executeActionCommand(cmd)
if tt.wantError && err == nil { if tt.wantError {
t.Fatalf("%q: expected error but got none", tt.name) require.Error(t, err, "%q: expected error but got none", tt.name)
} if tt.wantErrorMsg != "" {
if err != nil { require.EqualErrorf(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
if tt.wantError {
if tt.wantErrorMsg != "" && tt.wantErrorMsg != err.Error() {
t.Fatalf("Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
}
return
} }
t.Fatalf("%q reported error: %s", tt.name, err) } else {
} require.NoError(t, err, "%q reported error", tt.name)
ef := filepath.Join(outdir, tt.expectFile)
ef := filepath.Join(outdir, tt.expectFile) fi, err := os.Stat(ef)
fi, err := os.Stat(ef) require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
if err != nil { assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
t.Errorf("%q: expected a file at %s. %s", tt.name, ef, err)
}
if fi.IsDir() != tt.expectDir {
t.Errorf("%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
} }
}) })
} }
@ -362,9 +334,7 @@ func TestPullWithCredentialsCmd(t *testing.T) {
})) }))
defer srv2.Close() defer srv2.Close()
if err := srv.LinkIndices(); err != nil { require.NoError(t, srv.LinkIndices())
t.Fatal(err)
}
// all flags will get "-d outdir" appended. // all flags will get "-d outdir" appended.
tests := []struct { tests := []struct {
@ -445,14 +415,10 @@ func TestPullWithCredentialsCmdOCIRegistry(t *testing.T) {
defer srv.Stop() defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root()) ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
ociSrv.Run(t) ociSrv.Run(t)
if err := srv.LinkIndices(); err != nil { require.NoError(t, srv.LinkIndices())
t.Fatal(err)
}
// all flags will get "-d outdir" appended. // all flags will get "-d outdir" appended.
tests := []struct { tests := []struct {
@ -517,9 +483,7 @@ func TestPullOCIWithTagAndDigest(t *testing.T) {
defer srv.Stop() defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root()) ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
result := ociSrv.RunWithReturn(t) result := ociSrv.RunWithReturn(t)
contentCache := t.TempDir() contentCache := t.TempDir()
@ -538,9 +502,7 @@ func TestPullOCIWithTagAndDigest(t *testing.T) {
) )
_, _, err = executeActionCommand(cmd) _, _, err = executeActionCommand(cmd)
if err != nil { require.NoError(t, err, "pull with tag+digest failed")
t.Fatalf("pull with tag+digest failed: %v", err)
}
// Verify the file was downloaded // Verify the file was downloaded
// When digest is present, the filename uses the digest format (e.g. chart@sha256-hex.tgz) // When digest is present, the filename uses the digest format (e.g. chart@sha256-hex.tgz)
@ -548,12 +510,9 @@ func TestPullOCIWithTagAndDigest(t *testing.T) {
if _, err := os.Stat(expectedFile); err != nil { if _, err := os.Stat(expectedFile); err != nil {
// Try the digest-based filename; parse algorithm:hex to avoid fixed-offset assumptions // Try the digest-based filename; parse algorithm:hex to avoid fixed-offset assumptions
algorithm, digestPart, ok := strings.Cut(result.PushedChart.Manifest.Digest, ":") algorithm, digestPart, ok := strings.Cut(result.PushedChart.Manifest.Digest, ":")
if !ok { require.True(t, ok, "digest must be in algorithm:hex format, got %q", result.PushedChart.Manifest.Digest)
t.Fatalf("digest must be in algorithm:hex format, got %q", result.PushedChart.Manifest.Digest)
}
expectedFile = filepath.Join(outdir, fmt.Sprintf("oci-dependent-chart@%s-%s.tgz", algorithm, digestPart)) expectedFile = filepath.Join(outdir, fmt.Sprintf("oci-dependent-chart@%s-%s.tgz", algorithm, digestPart))
if _, err := os.Stat(expectedFile); err != nil { _, err := os.Stat(expectedFile)
t.Errorf("expected chart file not found: %v", err) assert.NoErrorf(t, err, "expected chart file not found")
}
} }
} }

Write Preview
Loading…
Cancel
Save