Skip to content

K
k3s
Unverified Commit 55fe4ff5 authored by Derek Nola's avatar Derek Nola Committed by GitHub
Browse files
Options

Convert existing unit tests to standard layout (#3621)

* Converted parser_test.go, scrypt_test.go, types_test.go, nodeconfig_test.go Signed-off-by: 's avatardereknola <derek.nola@suse.com>
parent 238dc208
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 151 additions and 89 deletions
pkg/authenticator/hash/scrypt_test.go
View file @ 55fe4ff5
......@@ -3,28 +3,37 @@ package hash
import (
"strings"
"testing"
"github.com/stretchr/testify/assert"
)
var hasher = NewSCrypt()
func TestBasicHash(t *testing.T) {
secretKey := "hello world"
hash, err := hasher.CreateHash(secretKey)
assert.Nil(t, err)
assert.NotNil(t, hash)
assert.Nil(t, hasher.VerifyHash(hash, secretKey))
assert.NotNil(t, hasher.VerifyHash(hash, "goodbye"))
}
func TestLongKey(t *testing.T) {
secretKey := strings.Repeat("A", 720)
hash, err := hasher.CreateHash(secretKey)
assert.Nil(t, err)
assert.NotNil(t, hash)
assert.Nil(t, hasher.VerifyHash(hash, secretKey))
assert.NotNil(t, hasher.VerifyHash(hash, secretKey+":wrong!"))
func TestSCrypt_VerifyHash(t *testing.T) {
type args struct {
secretKey string
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "Basic Hash Test",
args: args{
secretKey: "hello world",
},
},
{
name: "Long Hash Test",
args: args{
secretKey: strings.Repeat("A", 720),
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
hasher := NewSCrypt()
hash, _ := hasher.CreateHash(tt.args.secretKey)
if err := hasher.VerifyHash(hash, tt.args.secretKey); (err != nil) != tt.wantErr {
t.Errorf("SCrypt.VerifyHash() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
pkg/daemons/config/types_test.go
View file @ 55fe4ff5
......@@ -6,34 +6,53 @@ import (
)
func TestGetArgsList(t *testing.T) {
argsMap := map[string]string{
"aaa": "A",
"bbb": "B",
"ccc": "C",
"ddd": "d",
"eee": "e",
"fff": "f",
"ggg": "g",
"hhh": "h",
type args struct {
argsMap map[string]string
extraArgs []string
}
extraArgs := []string{
"bbb=BB",
"ddd=DD",
"iii=II",
}
expected := []string{
"--aaa=A",
"--bbb=BB",
"--ccc=C",
"--ddd=DD",
"--eee=e",
"--fff=f",
"--ggg=g",
"--hhh=h",
"--iii=II",
tests := []struct {
name string
args args
want []string
}{
{
name: "Default Test",
args: args{
argsMap: map[string]string{
"aaa": "A",
"bbb": "B",
"ccc": "C",
"ddd": "d",
"eee": "e",
"fff": "f",
"ggg": "g",
"hhh": "h",
},
extraArgs: []string{
"bbb=BB",
"ddd=DD",
"iii=II",
},
},
want: []string{
"--aaa=A",
"--bbb=BB",
"--ccc=C",
"--ddd=DD",
"--eee=e",
"--fff=f",
"--ggg=g",
"--hhh=h",
"--iii=II",
},
},
}
actual := GetArgsList(argsMap, extraArgs)
if !reflect.DeepEqual(actual, expected) {
t.Errorf("got %v\nwant %v", actual, expected)
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := GetArgsList(tt.args.argsMap, tt.args.extraArgs); !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetArgsList() = %+v\nWant = %+v", got, tt.want)
}
})
}
}
pkg/nodeconfig/nodeconfig_test.go
View file @ 55fe4ff5
......@@ -19,6 +19,7 @@ var FakeNodeWithNoAnnotation = &corev1.Node{
},
}
var TestEnvName = version.ProgramUpper + "_NODE_NAME"
var FakeNodeWithAnnotation = &corev1.Node{
TypeMeta: metav1.TypeMeta{
Kind: "Node",
......@@ -28,40 +29,12 @@ var FakeNodeWithAnnotation = &corev1.Node{
Name: "fakeNode-with-annotation",
Annotations: map[string]string{
NodeArgsAnnotation: `["server","--no-flannel"]`,
NodeEnvAnnotation: `{"` + version.ProgramUpper + `_NODE_NAME":"fakeNode-with-annotation"}`,
NodeEnvAnnotation: `{"` + TestEnvName + `":"fakeNode-with-annotation"}`,
NodeConfigHashAnnotation: "LNQOAOIMOQIBRMEMACW7LYHXUNPZADF6RFGOSPIHJCOS47UVUJAA====",
},
},
}
func assertEqual(t *testing.T, a interface{}, b interface{}) {
if a != b {
t.Fatalf("[ %v != %v ]", a, b)
}
}
func TestSetEmptyNodeConfigAnnotations(t *testing.T) {
os.Args = []string{version.Program, "server", "--no-flannel"}
os.Setenv(version.ProgramUpper+"_NODE_NAME", "fakeNode-no-annotation")
nodeUpdated, err := SetNodeConfigAnnotations(FakeNodeWithNoAnnotation)
if err != nil {
t.Fatalf("Failed to set node config annotation: %v", err)
}
assertEqual(t, true, nodeUpdated)
expectedArgs := `["server","--no-flannel"]`
actualArgs := FakeNodeWithNoAnnotation.Annotations[NodeArgsAnnotation]
assertEqual(t, expectedArgs, actualArgs)
expectedEnv := `{"` + version.ProgramUpper + `_NODE_NAME":"fakeNode-no-annotation"}`
actualEnv := FakeNodeWithNoAnnotation.Annotations[NodeEnvAnnotation]
assertEqual(t, expectedEnv, actualEnv)
expectedHash := "MROOIJGRXUZ53BM74K76TZLRXQOLNNBNJBJOY7JJ22EAEUIBW7YA===="
actualHash := FakeNodeWithNoAnnotation.Annotations[NodeConfigHashAnnotation]
assertEqual(t, expectedHash, actualHash)
}
func TestSetExistingNodeConfigAnnotations(t *testing.T) {
// adding same config
os.Args = []string{version.Program, "server", "--no-flannel"}
......@@ -70,18 +43,79 @@ func TestSetExistingNodeConfigAnnotations(t *testing.T) {
if err != nil {
t.Fatalf("Failed to set node config annotation: %v", err)
}
assertEqual(t, false, nodeUpdated)
if nodeUpdated {
t.Errorf("TestSetExistingNodeConfigAnnotations() expected false")
}
}
func TestSetArgsWithEqual(t *testing.T) {
os.Args = []string{version.Program, "server", "--no-flannel", "--write-kubeconfig-mode=777"}
os.Setenv("K3S_NODE_NAME", "fakeNode-with-no-annotation")
nodeUpdated, err := SetNodeConfigAnnotations(FakeNodeWithNoAnnotation)
if err != nil {
t.Fatalf("Failed to set node config annotation: %v", err)
func Test_SetNodeConfigAnnotations(t *testing.T) {
type args struct {
node *corev1.Node
osArgs []string
}
setup := func(osArgs []string) error {
os.Args = osArgs
return os.Setenv(TestEnvName, "fakeNode-with-no-annotation")
}
teardown := func() error {
return os.Unsetenv(TestEnvName)
}
tests := []struct {
name string
args args
want bool
wantErr bool
wantNodeArgs string
wantNodeEnv string
wantNodeConfigHash string
}{
{
name: "Set empty NodeConfigAnnotations",
args: args{
node: FakeNodeWithAnnotation,
osArgs: []string{version.Program, "server", "--no-flannel"},
},
want: true,
wantNodeArgs: `["server","--no-flannel"]`,
wantNodeEnv: `{"` + TestEnvName + `":"fakeNode-with-no-annotation"}`,
wantNodeConfigHash: "FBV4UQYLF2N7NH7EK42GKOTU5YA24TXB4WAYZHA5ZOFNGZHC4ZPA====",
},
{
name: "Set args with equal",
args: args{
node: FakeNodeWithNoAnnotation,
osArgs: []string{version.Program, "server", "--no-flannel", "--write-kubeconfig-mode=777"},
},
want: true,
wantNodeArgs: `["server","--no-flannel","--write-kubeconfig-mode","777"]`,
wantNodeEnv: `{"` + TestEnvName + `":"fakeNode-with-no-annotation"}`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
defer teardown()
if err := setup(tt.args.osArgs); err != nil {
t.Errorf("Setup for SetNodeConfigAnnotations() failed = %v", err)
return
}
got, err := SetNodeConfigAnnotations(tt.args.node)
if (err != nil) != tt.wantErr {
t.Errorf("SetNodeConfigAnnotations() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("SetNodeConfigAnnotations() = %+v\nWantRes = %+v", got, tt.want)
}
nodeAnn := tt.args.node.Annotations
if nodeAnn[NodeArgsAnnotation] != tt.wantNodeArgs {
t.Errorf("SetNodeConfigAnnotations() = %+v\nWantAnn.nodeArgs = %+v", nodeAnn[NodeArgsAnnotation], tt.wantNodeArgs)
}
if nodeAnn[NodeEnvAnnotation] != tt.wantNodeEnv {
t.Errorf("SetNodeConfigAnnotations() = %+v\nWantAnn.nodeEnv = %+v", nodeAnn[NodeEnvAnnotation], tt.wantNodeEnv)
}
if tt.wantNodeConfigHash != "" && nodeAnn[NodeConfigHashAnnotation] != tt.wantNodeConfigHash {
t.Errorf("SetNodeConfigAnnotations() = %+v\nWantAnn.nodeConfigHash = %+v", nodeAnn[NodeConfigHashAnnotation], tt.wantNodeConfigHash)
}
})
}
assertEqual(t, true, nodeUpdated)
expectedArgs := `["server","--no-flannel","--write-kubeconfig-mode","777"]`
actualArgs := FakeNodeWithNoAnnotation.Annotations[NodeArgsAnnotation]
assertEqual(t, expectedArgs, actualArgs)
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment