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

refactor(pkg/cli): convert tests to testify assert/require

Browse Source 
Replace native Go testing patterns (t.Errorf, t.Fatalf, t.Error,
t.Fatal) with github.com/stretchr/testify equivalents (assert.X,
require.X) for improved test readability and error messages.

Signed-off-by: George Jenkins <gvjenkins@gmail.com>
pull/32259/head
George Jenkins 3 months ago
parent ac4f8a6c22
commit 16b0760dfd
2 changed files with 37 additions and 86 deletions
Show Stats Download Patch File Download Diff File

62
pkg/cli/environment_test.go
Unescape View File

@ -23,6 +23,8 @@ import (
"testing" "testing"
"github.com/spf13/pflag" "github.com/spf13/pflag"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/internal/version" "helm.sh/helm/v4/internal/version"
) )
@ -30,14 +32,10 @@ import (
func TestSetNamespace(t *testing.T) { func TestSetNamespace(t *testing.T) {
settings := New() settings := New()
if settings.namespace != "" { assert.Empty(t, settings.namespace)
t.Errorf("Expected empty namespace, got %s", settings.namespace)
}
settings.SetNamespace("testns") settings.SetNamespace("testns")
if settings.namespace != "testns" { assert.Equal(t, "testns", settings.namespace)
t.Errorf("Expected namespace testns, got %s", settings.namespace)
}
} }
func TestEnvSettings(t *testing.T) { func TestEnvSettings(t *testing.T) {
@ -134,36 +132,16 @@ func TestEnvSettings(t *testing.T) {
settings.AddFlags(flags) settings.AddFlags(flags)
flags.Parse(strings.Split(tt.args, " ")) flags.Parse(strings.Split(tt.args, " "))
if settings.Debug != tt.debug { assert.Equal(t, tt.debug, settings.Debug, "debug")
t.Errorf("expected debug %t, got %t", tt.debug, settings.Debug) assert.Equal(t, tt.ns, settings.Namespace(), "namespace")
} assert.Equal(t, tt.kcontext, settings.KubeContext, "kube-context")
if settings.Namespace() != tt.ns { assert.Equal(t, tt.maxhistory, settings.MaxHistory, "maxHistory")
t.Errorf("expected namespace %q, got %q", tt.ns, settings.Namespace()) assert.Equal(t, tt.kubeAsUser, settings.KubeAsUser, "kubeAsUser")
} assert.True(t, reflect.DeepEqual(tt.kubeAsGroups, settings.KubeAsGroups), "kubeAsGroups")
if settings.KubeContext != tt.kcontext { assert.Equal(t, tt.kubeCaFile, settings.KubeCaFile, "kubeCaFile")
t.Errorf("expected kube-context %q, got %q", tt.kcontext, settings.KubeContext) assert.Equal(t, tt.burstLimit, settings.BurstLimit, "burstLimit")
} assert.Equal(t, tt.kubeInsecure, settings.KubeInsecureSkipTLSVerify, "kubeInsecure")
if settings.MaxHistory != tt.maxhistory { assert.Equal(t, tt.kubeTLSServer, settings.KubeTLSServerName, "kubeTLSServer")
t.Errorf("expected maxHistory %d, got %d", tt.maxhistory, settings.MaxHistory)
}
if tt.kubeAsUser != settings.KubeAsUser {
t.Errorf("expected kAsUser %q, got %q", tt.kubeAsUser, settings.KubeAsUser)
}
if !reflect.DeepEqual(tt.kubeAsGroups, settings.KubeAsGroups) {
t.Errorf("expected kAsGroups %+v, got %+v", len(tt.kubeAsGroups), len(settings.KubeAsGroups))
}
if tt.kubeCaFile != settings.KubeCaFile {
t.Errorf("expected kCaFile %q, got %q", tt.kubeCaFile, settings.KubeCaFile)
}
if tt.burstLimit != settings.BurstLimit {
t.Errorf("expected BurstLimit %d, got %d", tt.burstLimit, settings.BurstLimit)
}
if tt.kubeInsecure != settings.KubeInsecureSkipTLSVerify {
t.Errorf("expected kubeInsecure %t, got %t", tt.kubeInsecure, settings.KubeInsecureSkipTLSVerify)
}
if tt.kubeTLSServer != settings.KubeTLSServerName {
t.Errorf("expected kubeTLSServer %q, got %q", tt.kubeTLSServer, settings.KubeTLSServerName)
}
}) })
} }
} }
@ -235,9 +213,7 @@ func TestEnvOrBool(t *testing.T) {
t.Setenv(tt.env, tt.val) t.Setenv(tt.env, tt.val)
} }
actual := envBoolOr(tt.env, tt.def) actual := envBoolOr(tt.env, tt.def)
if actual != tt.expected { assert.Equal(t, tt.expected, actual)
t.Errorf("expected result %t, got %t", tt.expected, actual)
}
}) })
} }
} }
@ -247,14 +223,10 @@ func TestUserAgentHeaderInK8sRESTClientConfig(t *testing.T) {
settings := New() settings := New()
restConfig, err := settings.RESTClientGetter().ToRESTConfig() restConfig, err := settings.RESTClientGetter().ToRESTConfig()
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
expectedUserAgent := version.GetUserAgent() expectedUserAgent := version.GetUserAgent()
if restConfig.UserAgent != expectedUserAgent { assert.Equal(t, expectedUserAgent, restConfig.UserAgent)
t.Errorf("expected User-Agent header %q in K8s REST client config, got %q", expectedUserAgent, restConfig.UserAgent)
}
} }
func resetEnv() func() { func resetEnv() func() {

61
pkg/cli/values/options_test.go
Unescape View File

@ -22,9 +22,11 @@ import (
"os" "os"
"path/filepath" "path/filepath"
"reflect" "reflect"
"strings"
"testing" "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"helm.sh/helm/v4/pkg/getter" "helm.sh/helm/v4/pkg/getter"
) )
@ -90,10 +92,7 @@ func TestReadFile(t *testing.T) {
tmpDir := t.TempDir() tmpDir := t.TempDir()
filePath := filepath.Join(tmpDir, "test.txt") filePath := filepath.Join(tmpDir, "test.txt")
content := []byte("local file content") content := []byte("local file content")
err := os.WriteFile(filePath, content, 0644) require.NoError(t, os.WriteFile(filePath, content, 0644))
if err != nil {
t.Fatal(err)
}
return filePath, func() {} // cleanup handled by t.TempDir() return filePath, func() {} // cleanup handled by t.TempDir()
}, },
expectError: false, expectError: false,
@ -154,10 +153,7 @@ func TestReadFile(t *testing.T) {
fileName := "ftp_file.txt" // Valid filename for filesystem fileName := "ftp_file.txt" // Valid filename for filesystem
filePath := filepath.Join(tmpDir, fileName) filePath := filepath.Join(tmpDir, fileName)
content := []byte("local fallback content") content := []byte("local fallback content")
err := os.WriteFile(filePath, content, 0644) require.NoError(t, os.WriteFile(filePath, content, 0644))
if err != nil {
t.Fatal(err)
}
return filePath, func() {} return filePath, func() {}
}, },
expectError: false, expectError: false,
@ -202,9 +198,7 @@ func TestReadFile(t *testing.T) {
// Create a pipe for stdin // Create a pipe for stdin
r, w, err := os.Pipe() r, w, err := os.Pipe()
if err != nil { require.NoError(t, err)
t.Fatal(err)
}
defer r.Close() defer r.Close()
defer w.Close() defer w.Close()
@ -220,28 +214,21 @@ func TestReadFile(t *testing.T) {
// Test the function // Test the function
got, err := readFile(actualFilePath, tt.providers) got, err := readFile(actualFilePath, tt.providers)
if err != nil { assert.NoError(t, err, "readFile() expected no error for stdin")
t.Errorf("readFile() error = %v, expected no error for stdin", err) assert.Equal(t, testData, got)
return
}
if !bytes.Equal(got, testData) {
t.Errorf("readFile() = %v, want %v", got, testData)
}
return return
} }
// Regular test cases // Regular test cases
got, err := readFile(actualFilePath, tt.providers) got, err := readFile(actualFilePath, tt.providers)
if (err != nil) != tt.expectError { if tt.expectError {
t.Errorf("readFile() error = %v, expectError %v", err, tt.expectError) assert.Error(t, err)
return return
} }
assert.NoError(t, err)
if !tt.expectError && tt.expectedData != nil { if tt.expectedData != nil {
if !bytes.Equal(got, tt.expectedData) { assert.Equal(t, tt.expectedData, got)
t.Errorf("readFile() = %v, want %v", got, tt.expectedData)
}
} }
}) })
} }
@ -272,13 +259,8 @@ func TestReadFileErrorMessages(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
_, err := readFile(tt.filePath, tt.providers) _, err := readFile(tt.filePath, tt.providers)
if err == nil { require.Error(t, err)
t.Errorf("readFile() expected error containing %q, got nil", tt.wantErr) assert.Contains(t, err.Error(), tt.wantErr)
return
}
if !strings.Contains(err.Error(), tt.wantErr) {
t.Errorf("readFile() error = %v, want error containing %q", err, tt.wantErr)
}
}) })
} }
} }
@ -288,9 +270,7 @@ func TestReadFileOriginal(t *testing.T) {
var p getter.Providers var p getter.Providers
filePath := "%a.txt" filePath := "%a.txt"
_, err := readFile(filePath, p) _, err := readFile(filePath, p)
if err == nil { assert.Error(t, err, "Expected error when has special strings")
t.Error("Expected error when has special strings")
}
} }
func TestMergeValuesCLI(t *testing.T) { func TestMergeValuesCLI(t *testing.T) {
@ -376,13 +356,12 @@ func TestMergeValuesCLI(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
got, err := tt.opts.MergeValues(getter.Providers{}) got, err := tt.opts.MergeValues(getter.Providers{})
if (err != nil) != tt.wantErr { if tt.wantErr {
t.Errorf("MergeValues() error = %v, wantErr %v", err, tt.wantErr) assert.Error(t, err)
return return
} }
if !tt.wantErr && !reflect.DeepEqual(got, tt.expected) { assert.NoError(t, err)
t.Errorf("MergeValues() = %v, want %v", got, tt.expected) assert.True(t, reflect.DeepEqual(got, tt.expected), "MergeValues() = %v, want %v", got, tt.expected)
}
}) })
} }
} }

Write Preview
Loading…
Cancel
Save