github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-01 07:47:56 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #72483 from bart0sh/PR0055-kubeadm-rest-app-use-T.Run

Browse Source 
kubeadm: use T.Run API in app/
This commit is contained in:
Kubernetes Prow Robot 2019-01-02 21:10:57 -08:00 committed by GitHub
commit 98b3e42127
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 205 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
cmd/kubeadm/app/componentconfigs/validation_test.go
View File

@ -31,11 +31,13 @@ import (
func TestValidateKubeProxyConfiguration(t *testing.T) { func TestValidateKubeProxyConfiguration(t *testing.T) {
var tests = []struct { var tests = []struct {
name string
clusterConfig *kubeadm.ClusterConfiguration clusterConfig *kubeadm.ClusterConfiguration
msg string msg string
expectErr bool expectErr bool
}{ }{
{ {
name: "valid config",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -67,6 +69,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: false, expectErr: false,
}, },
{ {
name: "invalid BindAddress",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -100,6 +103,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: true, expectErr: true,
}, },
{ {
name: "invalid HealthzBindAddress",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -133,6 +137,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: true, expectErr: true,
}, },
{ {
name: "invalid MetricsBindAddress",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -166,6 +171,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: true, expectErr: true,
}, },
{ {
name: "invalid ClusterCIDR",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -199,6 +205,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: true, expectErr: true,
}, },
{ {
name: "invalid UDPIdleTimeout",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -232,6 +239,7 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
expectErr: true, expectErr: true,
}, },
{ {
name: "invalid ConfigSyncPeriod",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{ KubeProxy: &kubeproxyconfig.KubeProxyConfiguration{
@ -266,22 +274,26 @@ func TestValidateKubeProxyConfiguration(t *testing.T) {
}, },
} }
for i, rt := range tests { for i, rt := range tests {
err := ValidateKubeProxyConfiguration(rt.clusterConfig, nil).ToAggregate() t.Run(rt.name, func(t *testing.T) {
if (err != nil) != rt.expectErr { err := ValidateKubeProxyConfiguration(rt.clusterConfig, nil).ToAggregate()
t.Errorf("%d failed ValidateKubeProxyConfiguration: expected error %t, got error %t", i, rt.expectErr, err != nil) if (err != nil) != rt.expectErr {
} t.Errorf("%d failed ValidateKubeProxyConfiguration: expected error %t, got error %t", i, rt.expectErr, err != nil)
if err != nil && !strings.Contains(err.Error(), rt.msg) { }
t.Errorf("%d failed ValidateKubeProxyConfiguration: unexpected error: %v, expected: %s", i, err, rt.msg) if err != nil && !strings.Contains(err.Error(), rt.msg) {
} t.Errorf("%d failed ValidateKubeProxyConfiguration: unexpected error: %v, expected: %s", i, err, rt.msg)
}
})
} }
} }
func TestValidateKubeletConfiguration(t *testing.T) { func TestValidateKubeletConfiguration(t *testing.T) {
var tests = []struct { var tests = []struct {
name string
clusterConfig *kubeadm.ClusterConfiguration clusterConfig *kubeadm.ClusterConfiguration
expectErr bool expectErr bool
}{ }{
{ {
name: "valid configuration",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
Kubelet: &kubeletconfig.KubeletConfiguration{ Kubelet: &kubeletconfig.KubeletConfiguration{
@ -314,6 +326,7 @@ func TestValidateKubeletConfiguration(t *testing.T) {
expectErr: false, expectErr: false,
}, },
{ {
name: "invalid configuration",
clusterConfig: &kubeadm.ClusterConfiguration{ clusterConfig: &kubeadm.ClusterConfiguration{
ComponentConfigs: kubeadm.ComponentConfigs{ ComponentConfigs: kubeadm.ComponentConfigs{
Kubelet: &kubeletconfig.KubeletConfiguration{ Kubelet: &kubeletconfig.KubeletConfiguration{
@ -345,9 +358,11 @@ func TestValidateKubeletConfiguration(t *testing.T) {
}, },
} }
for i, rt := range tests { for i, rt := range tests {
err := ValidateKubeletConfiguration(rt.clusterConfig, nil).ToAggregate() t.Run(rt.name, func(t *testing.T) {
if (err != nil) != rt.expectErr { err := ValidateKubeletConfiguration(rt.clusterConfig, nil).ToAggregate()
t.Errorf("%d failed ValidateKubeletConfiguration: expected error %t, got error %t", i, rt.expectErr, err != nil) if (err != nil) != rt.expectErr {
} t.Errorf("%d failed ValidateKubeletConfiguration: expected error %t, got error %t", i, rt.expectErr, err != nil)
}
})
} }
} }

98
cmd/kubeadm/app/constants/constants_test.go
View File

@ -100,14 +100,16 @@ func TestGetStaticPodFilepath(t *testing.T) {
}, },
} }
for _, rt := range tests { for _, rt := range tests {
actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir) t.Run(rt.componentName, func(t *testing.T) {
if actual != rt.expected { actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir)
t.Errorf( if actual != rt.expected {
"failed GetStaticPodFilepath:\n\texpected: %s\n\t actual: %s", t.Errorf(
rt.expected, "failed GetStaticPodFilepath:\n\texpected: %s\n\t actual: %s",
actual, rt.expected,
) actual,
} )
}
})
} }
} }
@ -133,14 +135,16 @@ func TestAddSelfHostedPrefix(t *testing.T) {
}, },
} }
for _, rt := range tests { for _, rt := range tests {
actual := AddSelfHostedPrefix(rt.componentName) t.Run(rt.componentName, func(t *testing.T) {
if actual != rt.expected { actual := AddSelfHostedPrefix(rt.componentName)
t.Errorf( if actual != rt.expected {
"failed AddSelfHostedPrefix:\n\texpected: %s\n\t actual: %s", t.Errorf(
rt.expected, "failed AddSelfHostedPrefix:\n\texpected: %s\n\t actual: %s",
actual, rt.expected,
) actual,
} )
}
})
} }
} }
@ -182,28 +186,30 @@ func TestEtcdSupportedVersion(t *testing.T) {
}, },
} }
for _, rt := range tests { for _, rt := range tests {
actualVersion, actualError := EtcdSupportedVersion(rt.kubernetesVersion) t.Run(rt.kubernetesVersion, func(t *testing.T) {
if actualError != nil { actualVersion, actualError := EtcdSupportedVersion(rt.kubernetesVersion)
if rt.expectedError == nil { if actualError != nil {
t.Errorf("failed EtcdSupportedVersion:\n\texpected no error, but got: %v", actualError) if rt.expectedError == nil {
} else if actualError.Error() != rt.expectedError.Error() { t.Errorf("failed EtcdSupportedVersion:\n\texpected no error, but got: %v", actualError)
t.Errorf( } else if actualError.Error() != rt.expectedError.Error() {
"failed EtcdSupportedVersion:\n\texpected error: %v\n\t actual error: %v", t.Errorf(
rt.expectedError, "failed EtcdSupportedVersion:\n\texpected error: %v\n\t actual error: %v",
actualError, rt.expectedError,
) actualError,
)
}
} else {
if rt.expectedError != nil {
t.Errorf("failed EtcdSupportedVersion:\n\texpected error: %v, but got no error", rt.expectedError)
} else if strings.Compare(actualVersion.String(), rt.expectedVersion.String()) != 0 {
t.Errorf(
"failed EtcdSupportedVersion:\n\texpected version: %s\n\t actual version: %s",
rt.expectedVersion.String(),
actualVersion.String(),
)
}
} }
} else { })
if rt.expectedError != nil {
t.Errorf("failed EtcdSupportedVersion:\n\texpected error: %v, but got no error", rt.expectedError)
} else if strings.Compare(actualVersion.String(), rt.expectedVersion.String()) != 0 {
t.Errorf(
"failed EtcdSupportedVersion:\n\texpected version: %s\n\t actual version: %s",
rt.expectedVersion.String(),
actualVersion.String(),
)
}
}
} }
} }
@ -222,13 +228,15 @@ func TestGetKubeDNSVersion(t *testing.T) {
}, },
} }
for _, rt := range tests { for _, rt := range tests {
actualDNSVersion := GetDNSVersion(rt.dns) t.Run(string(rt.dns), func(t *testing.T) {
if actualDNSVersion != rt.expected { actualDNSVersion := GetDNSVersion(rt.dns)
t.Errorf( if actualDNSVersion != rt.expected {
"failed GetDNSVersion:\n\texpected: %s\n\t actual: %s", t.Errorf(
rt.expected, "failed GetDNSVersion:\n\texpected: %s\n\t actual: %s",
actualDNSVersion, rt.expected,
) actualDNSVersion,
} )
}
})
} }
} }

28
cmd/kubeadm/app/discovery/discovery_test.go
View File

@ -24,11 +24,17 @@ import (
func TestFor(t *testing.T) { func TestFor(t *testing.T) {
tests := []struct { tests := []struct {
name string
d kubeadm.JoinConfiguration d kubeadm.JoinConfiguration
expect bool expect bool
}{ }{
{d: kubeadm.JoinConfiguration{}, expect: false},
{ {
name: "default Discovery",
d: kubeadm.JoinConfiguration{},
expect: false,
},
{
name: "file Discovery with a path",
d: kubeadm.JoinConfiguration{ d: kubeadm.JoinConfiguration{
Discovery: kubeadm.Discovery{ Discovery: kubeadm.Discovery{
File: &kubeadm.FileDiscovery{ File: &kubeadm.FileDiscovery{
@ -39,6 +45,7 @@ func TestFor(t *testing.T) {
expect: false, expect: false,
}, },
{ {
name: "file Discovery with an url",
d: kubeadm.JoinConfiguration{ d: kubeadm.JoinConfiguration{
Discovery: kubeadm.Discovery{ Discovery: kubeadm.Discovery{
File: &kubeadm.FileDiscovery{ File: &kubeadm.FileDiscovery{
@ -49,6 +56,7 @@ func TestFor(t *testing.T) {
expect: false, expect: false,
}, },
{ {
name: "BootstrapTokenDiscovery",
d: kubeadm.JoinConfiguration{ d: kubeadm.JoinConfiguration{
Discovery: kubeadm.Discovery{ Discovery: kubeadm.Discovery{
BootstrapToken: &kubeadm.BootstrapTokenDiscovery{ BootstrapToken: &kubeadm.BootstrapTokenDiscovery{
@ -60,13 +68,15 @@ func TestFor(t *testing.T) {
}, },
} }
for _, rt := range tests { for _, rt := range tests {
_, actual := For(&rt.d) t.Run(rt.name, func(t *testing.T) {
if (actual == nil) != rt.expect { _, actual := For(&rt.d)
t.Errorf( if (actual == nil) != rt.expect {
"failed For:\n\texpected: %t\n\t actual: %t", t.Errorf(
rt.expect, "failed For:\n\texpected: %t\n\t actual: %t",
(actual == nil), rt.expect,
) (actual == nil),
} )
}
})
} }
} }

70
cmd/kubeadm/app/features/features_test.go
View File

@ -108,20 +108,21 @@ func TestNewFeatureGate(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
t.Run(test.value, func(t *testing.T) {
r, err := NewFeatureGate(&someFeatures, test.value)
r, err := NewFeatureGate(&someFeatures, test.value) if !test.expectedError && err != nil {
t.Errorf("NewFeatureGate failed when not expected: %v", err)
return
} else if test.expectedError && err == nil {
t.Error("NewFeatureGate didn't failed when expected")
return
}
if !test.expectedError && err != nil { if !reflect.DeepEqual(r, test.expectedFeaturesGate) {
t.Errorf("NewFeatureGate failed when not expected: %v", err) t.Errorf("NewFeatureGate returned a unexpected value")
continue }
} else if test.expectedError && err == nil { })
t.Error("NewFeatureGate didn't failed when expected")
continue
}
if !reflect.DeepEqual(r, test.expectedFeaturesGate) {
t.Errorf("NewFeatureGate returned a unexpected value")
}
} }
} }
@ -132,20 +133,24 @@ func TestValidateVersion(t *testing.T) {
} }
var tests = []struct { var tests = []struct {
name string
requestedVersion string requestedVersion string
requestedFeatures map[string]bool requestedFeatures map[string]bool
expectedError bool expectedError bool
}{ }{
{ //no min version {
name: "no min version",
requestedFeatures: map[string]bool{"feature1": true}, requestedFeatures: map[string]bool{"feature1": true},
expectedError: false, expectedError: false,
}, },
{ //min version but correct value given {
name: "min version but correct value given",
requestedFeatures: map[string]bool{"feature2": true}, requestedFeatures: map[string]bool{"feature2": true},
requestedVersion: constants.MinimumControlPlaneVersion.String(), requestedVersion: constants.MinimumControlPlaneVersion.String(),
expectedError: false, expectedError: false,
}, },
{ //min version and incorrect value given {
name: "min version and incorrect value given",
requestedFeatures: map[string]bool{"feature2": true}, requestedFeatures: map[string]bool{"feature2": true},
requestedVersion: "v1.11.2", requestedVersion: "v1.11.2",
expectedError: true, expectedError: true,
@ -153,14 +158,16 @@ func TestValidateVersion(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
err := ValidateVersion(someFeatures, test.requestedFeatures, test.requestedVersion) t.Run(test.name, func(t *testing.T) {
if !test.expectedError && err != nil { err := ValidateVersion(someFeatures, test.requestedFeatures, test.requestedVersion)
t.Errorf("ValidateVersion failed when not expected: %v", err) if !test.expectedError && err != nil {
continue t.Errorf("ValidateVersion failed when not expected: %v", err)
} else if test.expectedError && err == nil { return
t.Error("ValidateVersion didn't failed when expected") } else if test.expectedError && err == nil {
continue t.Error("ValidateVersion didn't failed when expected")
} return
}
})
} }
} }
@ -185,23 +192,28 @@ func TestCheckDeprecatedFlags(t *testing.T) {
} }
var tests = []struct { var tests = []struct {
name string
features map[string]bool features map[string]bool
expectedMsg map[string]string expectedMsg map[string]string
}{ }{
{ // feature deprecated {
name: "deprecated feature",
features: map[string]bool{"deprecated": true}, features: map[string]bool{"deprecated": true},
expectedMsg: map[string]string{"deprecated": dummyMessage}, expectedMsg: map[string]string{"deprecated": dummyMessage},
}, },
{ // valid feature {
name: "valid feature",
features: map[string]bool{"feature1": true}, features: map[string]bool{"feature1": true},
expectedMsg: map[string]string{}, expectedMsg: map[string]string{},
}, },
} }
for _, test := range tests { for _, test := range tests {
msg := CheckDeprecatedFlags(&someFeatures, test.features) t.Run(test.name, func(t *testing.T) {
if !reflect.DeepEqual(test.expectedMsg, msg) { msg := CheckDeprecatedFlags(&someFeatures, test.features)
t.Error("CheckDeprecatedFlags didn't returned expected message") if !reflect.DeepEqual(test.expectedMsg, msg) {
} t.Error("CheckDeprecatedFlags didn't returned expected message")
}
})
} }
} }

85
cmd/kubeadm/app/preflight/checks_test.go
View File

@ -18,6 +18,7 @@ package preflight
import ( import (
"bytes" "bytes"
"fmt"
"io/ioutil" "io/ioutil"
"strings" "strings"
"testing" "testing"
@ -658,33 +659,33 @@ func TestKubeletVersionCheck(t *testing.T) {
} }
for _, tc := range cases { for _, tc := range cases {
fcmd := fakeexec.FakeCmd{ t.Run(tc.kubeletVersion, func(t *testing.T) {
CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ fcmd := fakeexec.FakeCmd{
func() ([]byte, error) { return []byte("Kubernetes " + tc.kubeletVersion), nil }, CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
}, func() ([]byte, error) { return []byte("Kubernetes " + tc.kubeletVersion), nil },
} },
fexec := &fakeexec.FakeExec{ }
CommandScript: []fakeexec.FakeCommandAction{ fexec := &fakeexec.FakeExec{
func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) }, CommandScript: []fakeexec.FakeCommandAction{
}, func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
} },
}
check := KubeletVersionCheck{KubernetesVersion: tc.k8sVersion, exec: fexec} check := KubeletVersionCheck{KubernetesVersion: tc.k8sVersion, exec: fexec}
warnings, errors := check.Check() warnings, errors := check.Check()
switch {
case warnings != nil && !tc.expectWarnings:
t.Errorf("KubeletVersionCheck: unexpected warnings for kubelet version %q and Kubernetes version %q. Warnings: %v", tc.kubeletVersion, tc.k8sVersion, warnings)
case warnings == nil && tc.expectWarnings:
t.Errorf("KubeletVersionCheck: expected warnings for kubelet version %q and Kubernetes version %q but got nothing", tc.kubeletVersion, tc.k8sVersion)
case errors != nil && !tc.expectErrors:
t.Errorf("KubeletVersionCheck: unexpected errors for kubelet version %q and Kubernetes version %q. errors: %v", tc.kubeletVersion, tc.k8sVersion, errors)
case errors == nil && tc.expectErrors:
t.Errorf("KubeletVersionCheck: expected errors for kubelet version %q and Kubernetes version %q but got nothing", tc.kubeletVersion, tc.k8sVersion)
}
switch {
case warnings != nil && !tc.expectWarnings:
t.Errorf("KubeletVersionCheck: unexpected warnings for kubelet version %q and Kubernetes version %q. Warnings: %v", tc.kubeletVersion, tc.k8sVersion, warnings)
case warnings == nil && tc.expectWarnings:
t.Errorf("KubeletVersionCheck: expected warnings for kubelet version %q and Kubernetes version %q but got nothing", tc.kubeletVersion, tc.k8sVersion)
case errors != nil && !tc.expectErrors:
t.Errorf("KubeletVersionCheck: unexpected errors for kubelet version %q and Kubernetes version %q. errors: %v", tc.kubeletVersion, tc.k8sVersion, errors)
case errors == nil && tc.expectErrors:
t.Errorf("KubeletVersionCheck: expected errors for kubelet version %q and Kubernetes version %q but got nothing", tc.kubeletVersion, tc.k8sVersion)
}
})
} }
} }
func TestSetHasItemOrAll(t *testing.T) { func TestSetHasItemOrAll(t *testing.T) {
@ -702,15 +703,17 @@ func TestSetHasItemOrAll(t *testing.T) {
} }
for _, rt := range tests { for _, rt := range tests {
result := setHasItemOrAll(rt.ignoreSet, rt.testString) t.Run(rt.testString, func(t *testing.T) {
if result != rt.expectedResult { result := setHasItemOrAll(rt.ignoreSet, rt.testString)
t.Errorf( if result != rt.expectedResult {
"setHasItemOrAll: expected: %v actual: %v (arguments: %q, %q)", t.Errorf(
rt.expectedResult, result, "setHasItemOrAll: expected: %v actual: %v (arguments: %q, %q)",
rt.ignoreSet, rt.expectedResult, result,
rt.testString, rt.ignoreSet,
) rt.testString,
} )
}
})
} }
} }
@ -790,12 +793,14 @@ func TestNumCPUCheck(t *testing.T) {
} }
for _, rt := range tests { for _, rt := range tests {
warnings, errors := NumCPUCheck{NumCPU: rt.numCPU}.Check() t.Run(fmt.Sprintf("number of CPUs: %d", rt.numCPU), func(t *testing.T) {
if len(warnings) != rt.numWarnings { warnings, errors := NumCPUCheck{NumCPU: rt.numCPU}.Check()
t.Errorf("expected %d warning(s) but got %d: %q", rt.numWarnings, len(warnings), warnings) if len(warnings) != rt.numWarnings {
} t.Errorf("expected %d warning(s) but got %d: %q", rt.numWarnings, len(warnings), warnings)
if len(errors) != rt.numErrors { }
t.Errorf("expected %d warning(s) but got %d: %q", rt.numErrors, len(errors), errors) if len(errors) != rt.numErrors {
} t.Errorf("expected %d warning(s) but got %d: %q", rt.numErrors, len(errors), errors)
}
})
} }
} }

42
cmd/kubeadm/app/preflight/utils_test.go
View File

@ -40,26 +40,26 @@ func TestGetKubeletVersion(t *testing.T) {
} }
for _, tc := range cases { for _, tc := range cases {
fcmd := fakeexec.FakeCmd{ t.Run(tc.output, func(t *testing.T) {
CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ fcmd := fakeexec.FakeCmd{
func() ([]byte, error) { return []byte(tc.output), tc.err }, CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{
}, func() ([]byte, error) { return []byte(tc.output), tc.err },
} },
fexec := &fakeexec.FakeExec{ }
CommandScript: []fakeexec.FakeCommandAction{ fexec := &fakeexec.FakeExec{
func(cmd string, args ...string) utilsexec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) }, CommandScript: []fakeexec.FakeCommandAction{
}, func(cmd string, args ...string) utilsexec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
} },
ver, err := GetKubeletVersion(fexec) }
switch { ver, err := GetKubeletVersion(fexec)
case err != nil && tc.valid: switch {
t.Errorf("GetKubeletVersion: unexpected error for %q. Error: %v", tc.output, err) case err != nil && tc.valid:
case err == nil && !tc.valid: t.Errorf("GetKubeletVersion: unexpected error for %q. Error: %v", tc.output, err)
t.Errorf("GetKubeletVersion: error expected for key %q, but result is %q", tc.output, ver) case err == nil && !tc.valid:
case ver != nil && ver.String() != tc.expected: t.Errorf("GetKubeletVersion: error expected for key %q, but result is %q", tc.output, ver)
t.Errorf("GetKubeletVersion: unexpected version result for key %q. Expected: %q Actual: %q", tc.output, tc.expected, ver) case ver != nil && ver.String() != tc.expected:
} t.Errorf("GetKubeletVersion: unexpected version result for key %q. Expected: %q Actual: %q", tc.output, tc.expected, ver)
}
})
} }
} }