From 8368ef6a448c0c9fcad61c18c06ded1c356ae5d5 Mon Sep 17 00:00:00 2001 From: chentao1596 Date: Wed, 25 Oct 2017 17:54:58 +0800 Subject: [PATCH] Adding unit tests to methods of netsh --- pkg/util/netsh/BUILD | 14 ++ pkg/util/netsh/netsh_test.go | 440 +++++++++++++++++++++++++++++++++++ 2 files changed, 454 insertions(+) create mode 100644 pkg/util/netsh/netsh_test.go diff --git a/pkg/util/netsh/BUILD b/pkg/util/netsh/BUILD index bd305a7296..88c4ef7de7 100644 --- a/pkg/util/netsh/BUILD +++ b/pkg/util/netsh/BUILD @@ -3,6 +3,7 @@ package(default_visibility = ["//visibility:public"]) load( "@io_bazel_rules_go//go:def.bzl", "go_library", + "go_test", ) go_library( @@ -33,3 +34,16 @@ filegroup( ], tags = ["automanaged"], ) + +go_test( + name = "go_default_test", + srcs = ["netsh_test.go"], + importpath = "k8s.io/kubernetes/pkg/util/netsh", + library = ":go_default_library", + deps = [ + "//vendor/github.com/pkg/errors:go_default_library", + "//vendor/github.com/stretchr/testify/assert:go_default_library", + "//vendor/k8s.io/utils/exec:go_default_library", + "//vendor/k8s.io/utils/exec/testing:go_default_library", + ], +) diff --git a/pkg/util/netsh/netsh_test.go b/pkg/util/netsh/netsh_test.go new file mode 100644 index 0000000000..ac832b72a5 --- /dev/null +++ b/pkg/util/netsh/netsh_test.go @@ -0,0 +1,440 @@ +/* +Copyright 2017 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package netsh + +import ( + "net" + "os" + "testing" + + "k8s.io/utils/exec" + fakeexec "k8s.io/utils/exec/testing" + + "github.com/pkg/errors" + "github.com/stretchr/testify/assert" +) + +func fakeCommonRunner() *runner { + fakeCmd := fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Success + func() ([]byte, error) { + return []byte{}, nil + }, + // utilexec.ExitError exists, and status is not 0 + func() ([]byte, error) { + return nil, &fakeexec.FakeExitError{Status: 1} + }, + // utilexec.ExitError exists, and status is 0 + func() ([]byte, error) { + return nil, &fakeexec.FakeExitError{Status: 0} + }, + // other error exists + func() ([]byte, error) { + return nil, errors.New("not ExitError") + }, + }, + } + + return &runner{ + exec: &fakeexec.FakeExec{ + CommandScript: []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + }, + }, + } +} + +func TestEnsurePortProxyRule(t *testing.T) { + runner := fakeCommonRunner() + + tests := []struct { + name string + arguments []string + expectedResult bool + expectedError bool + }{ + {"Success", []string{"ensure-port-proxy-rule"}, true, false}, + {"utilexec.ExitError exists, and status is not 0", []string{"ensure-port-proxy-rule"}, false, false}, + {"utilexec.ExitError exists, and status is 0", []string{"ensure-port-proxy-rule"}, false, true}, + {"other error exists", []string{"ensure-port-proxy-rule"}, false, true}, + } + + for _, test := range tests { + result, err := runner.EnsurePortProxyRule(test.arguments) + if test.expectedError { + assert.Errorf(t, err, "Failed to test: %s", test.name) + } else { + if err != nil { + assert.NoErrorf(t, err, "Failed to test: %s", test.name) + } else { + assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name) + } + } + } + +} + +func TestDeletePortProxyRule(t *testing.T) { + runner := fakeCommonRunner() + + tests := []struct { + name string + arguments []string + expectedError bool + }{ + {"Success", []string{"delete-port-proxy-rule"}, false}, + {"utilexec.ExitError exists, and status is not 0", []string{"delete-port-proxy-rule"}, true}, + {"utilexec.ExitError exists, and status is 0", []string{"delete-port-proxy-rule"}, false}, + {"other error exists", []string{"delete-port-proxy-rule"}, true}, + } + + for _, test := range tests { + err := runner.DeletePortProxyRule(test.arguments) + if test.expectedError { + assert.Errorf(t, err, "Failed to test: %s", test.name) + } else { + assert.NoErrorf(t, err, "Failed to test: %s", test.name) + } + } +} + +func TestEnsureIPAddress(t *testing.T) { + tests := []struct { + name string + arguments []string + ip net.IP + fakeCmdAction []fakeexec.FakeCommandAction + expectedError bool + expectedResult bool + }{ + { + "IP address exists", + []string{"delete-port-proxy-rule"}, + net.IPv4(10, 10, 10, 20), + []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil + }, + }, + }, cmd, args...) + }, + }, + false, + true, + }, + + { + "IP address not exists, but set successful(find it in the second time)", + []string{"ensure-ip-address"}, + net.IPv4(10, 10, 10, 20), + []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Success to set ip + func() ([]byte, error) { + return []byte(""), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address still not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil + }, + }, + }, cmd, args...) + }, + }, + false, + true, + }, + { + "IP address not exists, utilexec.ExitError exists, but status is not 0)", + []string{"ensure-ip-address"}, + net.IPv4(10, 10, 10, 20), + []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Failed to set ip, utilexec.ExitError exists, and status is not 0 + func() ([]byte, error) { + return nil, &fakeexec.FakeExitError{Status: 1} + }, + }, + }, cmd, args...) + }, + }, + false, + false, + }, + { + "IP address not exists, utilexec.ExitError exists, and status is 0)", + []string{"ensure-ip-address"}, + net.IPv4(10, 10, 10, 20), + []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Failed to set ip, utilexec.ExitError exists, and status is 0 + func() ([]byte, error) { + return nil, &fakeexec.FakeExitError{Status: 0} + }, + }, + }, cmd, args...) + }, + }, + true, + false, + }, + { + "IP address not exists, and error is not utilexec.ExitError)", + []string{"ensure-ip-address"}, + net.IPv4(10, 10, 10, 20), + []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // IP address not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + }, + }, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Failed to set ip, other error exists + func() ([]byte, error) { + return nil, errors.New("not ExitError") + }, + }, + }, cmd, args...) + }, + }, + true, + false, + }, + } + + for _, test := range tests { + runner := New(&fakeexec.FakeExec{CommandScript: test.fakeCmdAction}) + result, err := runner.EnsureIPAddress(test.arguments, test.ip) + if test.expectedError { + assert.Errorf(t, err, "Failed to test: %s", test.name) + } else { + if err != nil { + assert.NoErrorf(t, err, "Failed to test: %s", test.name) + } else { + assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name) + } + } + } +} + +func TestDeleteIPAddress(t *testing.T) { + runner := fakeCommonRunner() + + tests := []struct { + name string + arguments []string + expectedError bool + }{ + {"Success", []string{"delete-ip-address"}, false}, + {"utilexec.ExitError exists, and status is not 0", []string{"delete-ip-address"}, true}, + {"utilexec.ExitError exists, and status is 0", []string{"delete-ip-address"}, false}, + {"other error exists", []string{"delete-ip-address"}, true}, + } + + for _, test := range tests { + err := runner.DeleteIPAddress(test.arguments) + if test.expectedError { + assert.Errorf(t, err, "Failed to test: %s", test.name) + } else { + assert.NoErrorf(t, err, "Failed to test: %s", test.name) + } + } +} + +func TestGetInterfaceToAddIP(t *testing.T) { + // backup env 'INTERFACE_TO_ADD_SERVICE_IP' + backupValue := os.Getenv("INTERFACE_TO_ADD_SERVICE_IP") + // recover env + defer os.Setenv("INTERFACE_TO_ADD_SERVICE_IP", backupValue) + + tests := []struct { + name string + envToBeSet string + expectedResult string + }{ + {"env_value_is_empty", "", "vEthernet (HNS Internal NIC)"}, + {"env_value_is_not_empty", "eth0", "eth0"}, + } + + fakeExec := fakeexec.FakeExec{ + CommandScript: []fakeexec.FakeCommandAction{}, + } + netsh := New(&fakeExec) + + for _, test := range tests { + os.Setenv("INTERFACE_TO_ADD_SERVICE_IP", test.envToBeSet) + result := netsh.GetInterfaceToAddIP() + + assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name) + } +} + +func TestRestore(t *testing.T) { + runner := New(&fakeexec.FakeExec{ + CommandScript: []fakeexec.FakeCommandAction{}, + }) + + result := runner.Restore([]string{}) + assert.NoErrorf(t, result, "The return value must be nil") +} + +func TestCheckIPExists(t *testing.T) { + fakeCmd := fakeexec.FakeCmd{ + CombinedOutputScript: []fakeexec.FakeCombinedOutputAction{ + // Error exists + func() ([]byte, error) { + return nil, &fakeexec.FakeExitError{Status: 1} + }, + // IP address string is empty + func() ([]byte, error) { + return []byte(""), nil + }, + // "IP Address:" field not exists + func() ([]byte, error) { + return []byte("10.10.10.10"), nil + }, + // IP not exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10"), nil + }, + // IP exists + func() ([]byte, error) { + return []byte("IP Address:10.10.10.10\nIP Address:10.10.10.20"), nil + }, + }, + } + fakeExec := fakeexec.FakeExec{ + CommandScript: []fakeexec.FakeCommandAction{ + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + func(cmd string, args ...string) exec.Cmd { + return fakeexec.InitFakeCmd(&fakeCmd, cmd, args...) + }, + }, + } + fakeRunner := &runner{ + exec: &fakeExec, + } + + tests := []struct { + name string + ipToCheck string + arguments []string + expectedError bool + expectedResult bool + }{ + {"Error exists", "10.10.10.20", []string{"check-IP-exists"}, true, false}, + {"IP address string is empty", "10.10.10.20", []string{"check-IP-exists"}, false, false}, + {"'IP Address:' field not exists", "10.10.10.20", []string{"check-IP-exists"}, false, false}, + {"IP not exists", "10.10.10.20", []string{"check-IP-exists"}, false, false}, + {"IP exists", "10.10.10.20", []string{"check-IP-exists"}, false, true}, + } + + for _, test := range tests { + result, err := checkIPExists(test.ipToCheck, test.arguments, fakeRunner) + if test.expectedError { + assert.Errorf(t, err, "Failed to test: %s", test.name) + } else { + assert.EqualValuesf(t, test.expectedResult, result, "Failed to test: %s", test.name) + } + } +}