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 5 days 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",
}
err := cfg.Releases.Create(rel)
require.NoError(t, err)
require.NoError(t, cfg.Releases.Create(rel))
result, err := client.Run(releaseName)
require.NoError(t, err)
@ -645,8 +644,7 @@ func TestGetMetadata_Labels(t *testing.T) {
rel.Labels = customLabels
metaGetter := NewGetMetadata(actionConfigFixture(t))
err := metaGetter.cfg.Releases.Create(rel)
require.NoError(t, err)
require.NoError(t, metaGetter.cfg.Releases.Create(rel))
metadata, err := metaGetter.Run(rel.Name)
require.NoError(t, err)

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

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

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()
require.NoError(t, err)
err = tw.WriteHeader(&tar.Header{
require.NoError(t, tw.WriteHeader(&tar.Header{
Name: filepath.Join(chartName, relPath),
Mode: int64(fStat.Mode()),
Size: fStat.Size(),
})
require.NoError(t, err)
}))
data, err := fs.ReadFile(dir, relPath)
require.NoError(t, err)
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 {
return walkErr
}
@ -71,15 +70,9 @@ func makeTestChartArchive(t *testing.T, chartName, sourceDir string) *bytes.Buff
writeFile(path)
return nil
})
if err != nil {
t.Fatal(err)
}
err = tw.Close()
require.NoError(t, err)
err = gw.Close()
require.NoError(t, err)
}))
require.NoError(t, tw.Close())
require.NoError(t, gw.Close())
return &result
}
@ -88,51 +81,33 @@ func TestExpand(t *testing.T) {
dest := t.TempDir()
reader, err := os.Open("testdata/frobnitz-1.2.3.tgz")
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
if err := Expand(dest, reader); err != nil {
t.Fatal(err)
}
require.NoError(t, Expand(dest, reader))
expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath)
if err != nil {
t.Fatal(err)
}
if !fi.IsDir() {
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
require.NoError(t, err)
require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
dir, err := os.Open(expectedChartPath)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
fis, err := dir.Readdir(0)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
expectLen := 11
if len(fis) != expectLen {
t.Errorf("Expected %d files, but got %d", expectLen, len(fis))
}
assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
// 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
// (value-4096) regardless of the size of the contents of the directory
mode := expect.Mode()
if !mode.IsDir() {
if fi.Size() != expect.Size() {
t.Errorf("Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
}
assert.Equal(t, expect.Size(), fi.Size(), "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 {
t.Run(name, func(t *testing.T) {
archive := makeTestChartArchive(t, tt.chartName, tt.chartDir)
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) {
dest := t.TempDir()
if err := ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"); err != nil {
t.Fatal(err)
}
require.NoError(t, ExpandFile(dest, "testdata/frobnitz-1.2.3.tgz"))
expectedChartPath := filepath.Join(dest, "frobnitz")
fi, err := os.Stat(expectedChartPath)
if err != nil {
t.Fatal(err)
}
if !fi.IsDir() {
t.Fatalf("expected a chart directory at %s", expectedChartPath)
}
require.NoError(t, err)
require.Truef(t, fi.IsDir(), "expected a chart directory at %s", expectedChartPath)
dir, err := os.Open(expectedChartPath)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
fis, err := dir.Readdir(0)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
expectLen := 11
if len(fis) != expectLen {
t.Errorf("Expected %d files, but got %d", expectLen, len(fis))
}
assert.Len(t, fis, expectLen, "Expected %d files, but got %d", expectLen, len(fis))
for _, fi := range fis {
expect, err := os.Stat(filepath.Join("testdata", "frobnitz", fi.Name()))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
// 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
// (value-4096) regardless of the size of the contents of the directory
mode := expect.Mode()
if !mode.IsDir() {
if fi.Size() != expect.Size() {
t.Errorf("Expected %s to have size %d, got %d", fi.Name(), expect.Size(), fi.Size())
}
assert.Equal(t, expect.Size(), fi.Size(), "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"
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/plugin"
"helm.sh/helm/v4/internal/test/ensure"
)
@ -35,13 +37,7 @@ func TestPluginVerifyCmd_NoArgs(t *testing.T) {
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{})
err := cmd.Execute()
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)
}
assert.ErrorContains(t, cmd.Execute(), "requires 1 argument", "expected 'requires 1 argument' error")
}
func TestPluginVerifyCmd_TooManyArgs(t *testing.T) {
@ -51,13 +47,7 @@ func TestPluginVerifyCmd_TooManyArgs(t *testing.T) {
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{"plugin1", "plugin2"})
err := cmd.Execute()
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)
}
assert.ErrorContains(t, cmd.Execute(), "requires 1 argument", "expected 'requires 1 argument' error")
}
func TestPluginVerifyCmd_NonexistentFile(t *testing.T) {
@ -67,10 +57,7 @@ func TestPluginVerifyCmd_NonexistentFile(t *testing.T) {
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{"/nonexistent/plugin.tgz"})
err := cmd.Execute()
if err == nil {
t.Error("expected error when plugin file doesn't exist")
}
assert.Error(t, cmd.Execute(), "expected error when plugin file doesn't exist")
}
func TestPluginVerifyCmd_MissingProvenance(t *testing.T) {
@ -84,13 +71,7 @@ func TestPluginVerifyCmd_MissingProvenance(t *testing.T) {
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginTgz})
err := cmd.Execute()
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)
}
assert.ErrorContains(t, cmd.Execute(), "could not find provenance file", "expected 'could not find provenance file' error")
}
func TestPluginVerifyCmd_InvalidProvenance(t *testing.T) {
@ -102,19 +83,14 @@ func TestPluginVerifyCmd_InvalidProvenance(t *testing.T) {
// Create invalid .prov file
provFile := pluginTgz + ".prov"
if err := os.WriteFile(provFile, []byte("invalid provenance"), 0o644); err != nil {
t.Fatal(err)
}
require.NoError(t, os.WriteFile(provFile, []byte("invalid provenance"), 0o644))
defer os.Remove(provFile)
out := &bytes.Buffer{}
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginTgz})
err := cmd.Execute()
if err == nil {
t.Error("expected error when .prov file is invalid")
}
assert.Error(t, cmd.Execute(), "expected error when .prov file is invalid")
}
func TestPluginVerifyCmd_DirectoryNotSupported(t *testing.T) {
@ -127,13 +103,7 @@ func TestPluginVerifyCmd_DirectoryNotSupported(t *testing.T) {
cmd := newPluginVerifyCmd(out)
cmd.SetArgs([]string{pluginDir})
err := cmd.Execute()
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)
}
assert.ErrorContains(t, cmd.Execute(), "directory verification not supported", "expected 'directory verification not supported' error")
}
func TestPluginVerifyCmd_KeyringFlag(t *testing.T) {
@ -157,10 +127,7 @@ func TestPluginVerifyCmd_KeyringFlag(t *testing.T) {
cmd.SetArgs([]string{"--keyring", keyring, pluginTgz})
// Should fail with keyring error but command parsing should work
err := cmd.Execute()
if err == nil {
t.Error("expected error with empty keyring")
}
assert.Error(t, cmd.Execute(), "expected error with empty keyring")
// 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
tmpDir := t.TempDir()
pluginDir := filepath.Join(tmpDir, "test-plugin")
if err := os.MkdirAll(pluginDir, 0o755); err != nil {
t.Fatalf("Failed to create plugin directory: %v", err)
}
require.NoErrorf(t, os.MkdirAll(pluginDir, 0o755), "Failed to create plugin directory")
// Use the same plugin YAML as other cmd tests
if err := os.WriteFile(filepath.Join(pluginDir, "plugin.yaml"), []byte(testPluginYAML), 0o644); err != nil {
t.Fatalf("Failed to create plugin.yaml: %v", err)
}
require.NoErrorf(t, os.WriteFile(filepath.Join(pluginDir, "plugin.yaml"), []byte(testPluginYAML), 0o644), "Failed to create plugin.yaml")
return pluginDir
}
@ -199,14 +162,10 @@ func createTestPluginTarball(t *testing.T) string {
tmpDir := filepath.Dir(pluginDir)
tgzPath := filepath.Join(tmpDir, "test-plugin-1.0.0.tgz")
tarFile, err := os.Create(tgzPath)
if err != nil {
t.Fatalf("Failed to create tarball file: %v", err)
}
require.NoError(t, err, "Failed to create tarball file")
defer tarFile.Close()
if err := plugin.CreatePluginTarball(pluginDir, "test-plugin", tarFile); err != nil {
t.Fatalf("Failed to create tarball: %v", err)
}
require.NoErrorf(t, plugin.CreatePluginTarball(pluginDir, "test-plugin", tarFile), "Failed to create tarball")
return tgzPath
}
@ -218,9 +177,7 @@ func createProvFile(t *testing.T, provFile, pluginTgz, hash string) {
if hash == "" {
// Calculate actual hash of the tarball
data, err := os.ReadFile(pluginTgz)
if err != nil {
t.Fatalf("Failed to read tarball for hashing: %v", err)
}
require.NoError(t, err, "Failed to read tarball for hashing")
hashSum := sha256.Sum256(data)
hashStr = fmt.Sprintf("sha256:%x", hashSum)
} else {
@ -243,9 +200,7 @@ Version: GnuPG v1
iQEcBAEBCAAGBQJktest...
-----END PGP SIGNATURE-----
`, hashStr)
if err := os.WriteFile(provFile, []byte(provContent), 0o644); err != nil {
t.Fatalf("Failed to create provenance file: %v", err)
}
require.NoErrorf(t, os.WriteFile(provFile, []byte(provContent), 0o644), "Failed to create provenance file")
}
func createTestKeyring(t *testing.T) string {
@ -256,9 +211,7 @@ func createTestKeyring(t *testing.T) string {
keyringPath := filepath.Join(tmpDir, "pubring.gpg")
// Create empty keyring for testing
if err := os.WriteFile(keyringPath, []byte{}, 0o644); err != nil {
t.Fatalf("Failed to create test keyring: %v", err)
}
require.NoErrorf(t, os.WriteFile(keyringPath, []byte{}, 0o644), "Failed to create test keyring")
return keyringPath
}

105
pkg/cmd/pull_test.go
Unescape View File

@ -25,6 +25,9 @@ import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/repo/v1/repotest"
)
@ -36,14 +39,10 @@ func TestPullCmd(t *testing.T) {
defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
ociSrv.Run(t)
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
require.NoError(t, srv.LinkIndices())
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" +
@ -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
if tt.existFile != "" {
file := filepath.Join(outdir, tt.existFile)
if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
t.Fatal(err)
}
_, err := os.Create(file)
if err != nil {
t.Fatal(err)
}
require.NoError(t, os.MkdirAll(filepath.Dir(file), 0o755))
_, err = os.Create(file)
require.NoError(t, err)
}
if tt.existDir != "" {
file := filepath.Join(outdir, tt.existDir)
err := os.MkdirAll(file, 0o755)
if err != nil {
t.Fatal(err)
}
require.NoError(t, os.MkdirAll(file, 0o755))
}
_, out, err := executeActionCommand(cmd)
if err != nil {
@ -257,19 +249,13 @@ func TestPullCmd(t *testing.T) {
if tt.expectVerify {
outString := helmTestKeyOut + tt.expectSha + "\n"
if out != outString {
t.Errorf("%q: expected verification output %q, got %q", tt.name, outString, out)
}
assert.Equal(t, outString, out, "%q: expected verification output %q, got %q", tt.name, outString, out)
}
ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef)
if err != nil {
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)
}
require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
assert.Equal(t, tt.expectDir, fi.IsDir(), "%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 != "" {
file := filepath.Join(outdir, tt.existFile)
_, err := os.Create(file)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
}
if tt.existDir != "" {
file := filepath.Join(outdir, tt.existDir)
err := os.MkdirAll(file, 0o755)
if err != nil {
t.Fatal(err)
}
require.NoError(t, os.MkdirAll(file, 0o755))
}
_, _, err := executeActionCommand(cmd)
if tt.wantError && err == nil {
t.Fatalf("%q: expected error but got none", tt.name)
}
if err != nil {
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
if tt.wantError {
require.Error(t, err, "%q: expected error but got none", tt.name)
if tt.wantErrorMsg != "" {
require.EqualErrorf(t, err, tt.wantErrorMsg, "Actual error '%s', not equal to expected error '%s'", err, tt.wantErrorMsg)
}
t.Fatalf("%q reported error: %s", tt.name, err)
}
ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef)
if err != nil {
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)
} else {
require.NoError(t, err, "%q reported error", tt.name)
ef := filepath.Join(outdir, tt.expectFile)
fi, err := os.Stat(ef)
require.NoError(t, err, "%q: expected a file at %s.", tt.name, ef)
assert.Equal(t, tt.expectDir, fi.IsDir(), "%q: expected directory=%t, but it's not.", tt.name, tt.expectDir)
}
})
}
@ -362,9 +334,7 @@ func TestPullWithCredentialsCmd(t *testing.T) {
}))
defer srv2.Close()
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
require.NoError(t, srv.LinkIndices())
// all flags will get "-d outdir" appended.
tests := []struct {
@ -445,14 +415,10 @@ func TestPullWithCredentialsCmdOCIRegistry(t *testing.T) {
defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
ociSrv.Run(t)
if err := srv.LinkIndices(); err != nil {
t.Fatal(err)
}
require.NoError(t, srv.LinkIndices())
// all flags will get "-d outdir" appended.
tests := []struct {
@ -517,9 +483,7 @@ func TestPullOCIWithTagAndDigest(t *testing.T) {
defer srv.Stop()
ociSrv, err := repotest.NewOCIServer(t, srv.Root())
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
result := ociSrv.RunWithReturn(t)
contentCache := t.TempDir()
@ -538,9 +502,7 @@ func TestPullOCIWithTagAndDigest(t *testing.T) {
)
_, _, err = executeActionCommand(cmd)
if err != nil {
t.Fatalf("pull with tag+digest failed: %v", err)
}
require.NoError(t, err, "pull with tag+digest failed")
// Verify the file was downloaded
// 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 {
// Try the digest-based filename; parse algorithm:hex to avoid fixed-offset assumptions
algorithm, digestPart, ok := strings.Cut(result.PushedChart.Manifest.Digest, ":")
if !ok {
t.Fatalf("digest must be in algorithm:hex format, got %q", result.PushedChart.Manifest.Digest)
}
require.True(t, ok, "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))
if _, err := os.Stat(expectedFile); err != nil {
t.Errorf("expected chart file not found: %v", err)
}
_, err := os.Stat(expectedFile)
assert.NoErrorf(t, err, "expected chart file not found")
}
}

Write Preview
Loading…
Cancel
Save