Merge pull request #215 from Sakuralbj/unit-test

k8s-ci-robot · web-flow · commit cc192a39010b · 2020-08-13T05:02:13.000-07:00
test: add unit-test in pkg/blob and pkg/csi-common.
diff --git a/pkg/blob/azure_test.go b/pkg/blob/azure_test.go
@@ -17,11 +17,16 @@ limitations under the License.
 package blob
 
 import (
+	"context"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"reflect"
 	"testing"
+
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/stretchr/testify/assert"
+	azure2 "k8s.io/legacy-cloud-providers/azure"
 )
 
 // TestGetCloudProvider tests the func GetCloudProvider().
@@ -139,6 +144,87 @@ users:
 	}
 }
 
+func TestGetServicePrincipalToken(t *testing.T) {
+	env := azure.Environment{
+		ActiveDirectoryEndpoint: "unit-test",
+	}
+	resource := "unit-test"
+	d := NewFakeDriver()
+	d.cloud = &azure2.Cloud{}
+	_, err := d.getServicePrincipalToken(env, resource)
+	expectedErr := fmt.Errorf("parameter 'clientID' cannot be empty")
+	if !reflect.DeepEqual(expectedErr, err) {
+		t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+	}
+	d.cloud.AADClientID = "unit-test"
+	d.cloud.AADClientSecret = "unit-test"
+	_, err = d.getServicePrincipalToken(env, resource)
+	assert.NoError(t, err)
+}
+
+func TestGetKeyvaultToken(t *testing.T) {
+	env := azure.Environment{
+		ActiveDirectoryEndpoint: "unit-test",
+		KeyVaultEndpoint:        "unit-test",
+	}
+	d := NewFakeDriver()
+	d.cloud = &azure2.Cloud{}
+	d.cloud.Environment = env
+	_, err := d.getKeyvaultToken()
+	expectedErr := fmt.Errorf("parameter 'clientID' cannot be empty")
+	if !reflect.DeepEqual(expectedErr, err) {
+		t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+	}
+	d.cloud.AADClientID = "unit-test"
+	d.cloud.AADClientSecret = "unit-test"
+	_, err = d.getKeyvaultToken()
+	assert.NoError(t, err)
+
+}
+
+func TestInitializeKvClient(t *testing.T) {
+	env := azure.Environment{
+		ActiveDirectoryEndpoint: "unit-test",
+		KeyVaultEndpoint:        "unit-test",
+	}
+	d := NewFakeDriver()
+	d.cloud = &azure2.Cloud{}
+	d.cloud.Environment = env
+	_, err := d.initializeKvClient()
+	expectedErr := fmt.Errorf("parameter 'clientID' cannot be empty")
+	if !reflect.DeepEqual(expectedErr, err) {
+		t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+	}
+	d.cloud.AADClientID = "unit-test"
+	d.cloud.AADClientSecret = "unit-test"
+	_, err = d.initializeKvClient()
+	assert.NoError(t, err)
+}
+
+func TestGetKeyVaultSecretContent(t *testing.T) {
+	env := azure.Environment{
+		ActiveDirectoryEndpoint: "unit-test",
+		KeyVaultEndpoint:        "unit-test",
+	}
+	d := NewFakeDriver()
+	d.cloud = &azure2.Cloud{}
+	d.cloud.Environment = env
+	valueURL := "unit-test"
+	secretName := "unit-test"
+	secretVersion := "v1"
+	_, err := d.getKeyVaultSecretContent(context.TODO(), valueURL, secretName, secretVersion)
+	expectedErr := fmt.Errorf("failed to get keyvaultClient: parameter 'clientID' cannot be empty")
+	if !reflect.DeepEqual(expectedErr, err) {
+		t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+	}
+	d.cloud.AADClientID = "unit-test"
+	d.cloud.AADClientSecret = "unit-test"
+	expectedErr = fmt.Errorf("failed to use vaultURL(unit-test), sercretName(unit-test), secretVersion(v1) to get secret: keyvault.BaseClient#GetSecret: Failure preparing request: StatusCode=0 -- Original Error: autorest: No scheme detected in URL unit-test")
+	_, err = d.getKeyVaultSecretContent(context.TODO(), valueURL, secretName, secretVersion)
+	if !reflect.DeepEqual(expectedErr, err) {
+		t.Errorf("actualErr: (%v), expectedErr: (%v)", err, expectedErr)
+	}
+}
 func createTestFile(path string) error {
 	f, err := os.Create(path)
 	if err != nil {
diff --git a/pkg/blob/controllerserver_test.go b/pkg/blob/controllerserver_test.go
@@ -19,19 +19,20 @@ package blob
 import (
 	"context"
 	"fmt"
+	"reflect"
+	"testing"
+
 	"github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2019-06-01/storage"
+	"github.com/container-storage-interface/spec/lib/go/csi"
 	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
 	"k8s.io/legacy-cloud-providers/azure"
 	"k8s.io/legacy-cloud-providers/azure/clients/storageaccountclient/mockstorageaccountclient"
 	"k8s.io/legacy-cloud-providers/azure/retry"
-	"reflect"
-	"testing"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-
-	"github.com/container-storage-interface/spec/lib/go/csi"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestControllerGetCapabilities(t *testing.T) {
@@ -121,6 +122,12 @@ func TestCreateVolume(t *testing.T) {
 				d.cloud = &azure.Cloud{}
 				mp := make(map[string]string)
 				mp["protocol"] = "unit-test"
+				mp["skuname"] = "unit-test"
+				mp["storageaccounttype"] = "unit-test"
+				mp["location"] = "unit-test"
+				mp["storageaccount"] = "unit-test"
+				mp["resourcegroup"] = "unit-test"
+				mp["containername"] = "unit-test"
 				req := &csi.CreateVolumeRequest{
 					Name:               "unit-test",
 					VolumeCapabilities: stdVolumeCapabilities,
@@ -165,6 +172,7 @@ func TestCreateVolume(t *testing.T) {
 				d.cloud = &azure.Cloud{}
 				mp := make(map[string]string)
 				mp["tags"] = "unit-test"
+				mp["storageaccounttype"] = "premium"
 				req := &csi.CreateVolumeRequest{
 					Name:               "unit-test",
 					VolumeCapabilities: stdVolumeCapabilities,
@@ -247,7 +255,7 @@ func TestDeleteVolume(t *testing.T) {
 			},
 		},
 		{
-			name: "invalid create volume req",
+			name: "invalid delete volume req",
 			testFunc: func(t *testing.T) {
 				d := NewFakeDriver()
 				req := &csi.DeleteVolumeRequest{
@@ -285,9 +293,10 @@ func TestDeleteVolume(t *testing.T) {
 					controllerServiceCapability,
 				}
 				req := &csi.DeleteVolumeRequest{
-					VolumeId: "unit#test#test",
+					VolumeId: "#test#test",
 				}
 				d.cloud = &azure.Cloud{}
+				d.cloud.ResourceGroup = "unit"
 				ctrl := gomock.NewController(t)
 				defer ctrl.Finish()
 				mockStorageAccountsClient := mockstorageaccountclient.NewMockInterface(ctrl)
@@ -412,10 +421,11 @@ func TestValidateVolumeCapabilities(t *testing.T) {
 					controllerServiceCapability,
 				}
 				req := &csi.ValidateVolumeCapabilitiesRequest{
-					VolumeId:           "unit#test#test",
+					VolumeId:           "#test#test",
 					VolumeCapabilities: stdVolumeCapabilities,
 				}
 				d.cloud = &azure.Cloud{}
+				d.cloud.ResourceGroup = "unit"
 				ctrl := gomock.NewController(t)
 				defer ctrl.Finish()
 				mockStorageAccountsClient := mockstorageaccountclient.NewMockInterface(ctrl)
diff --git a/pkg/blob/fake_mount.go b/pkg/blob/fake_mount.go
@@ -37,3 +37,13 @@ func (f *fakeMounter) MountSensitive(source string, target string, fstype string
 
 	return nil
 }
+
+func (f *fakeMounter) IsLikelyNotMountPoint(file string) (bool, error) {
+	if strings.Contains(file, "error_is_likely") {
+		return false, fmt.Errorf("fake IsLikelyNotMountPoint: fake error")
+	}
+	if strings.Contains(file, "false_is_likely") {
+		return false, nil
+	}
+	return true, nil
+}
diff --git a/pkg/blob/fake_mount_test.go b/pkg/blob/fake_mount_test.go
@@ -63,3 +63,38 @@ func TestMountSensitive(t *testing.T) {
 		}
 	}
 }
+
+func TestIsLikelyNotMountPoint(t *testing.T) {
+	tests := []struct {
+		desc        string
+		file        string
+		expectedErr error
+	}{
+		{
+			desc:        "[Error] Mocked file error",
+			file:        "./error_is_likely_target",
+			expectedErr: fmt.Errorf("fake IsLikelyNotMountPoint: fake error"),
+		},
+		{desc: "[Success] Successful run",
+			file:        targetTest,
+			expectedErr: nil,
+		},
+		{
+			desc:        "[Success] Successful run not a mount",
+			file:        "./false_is_likely_target",
+			expectedErr: nil,
+		},
+	}
+
+	d := NewFakeDriver()
+	fakeMounter := &fakeMounter{}
+	d.mounter = &mount.SafeFormatAndMount{
+		Interface: fakeMounter,
+	}
+	for _, test := range tests {
+		_, err := d.mounter.IsLikelyNotMountPoint(test.file)
+		if !reflect.DeepEqual(err, test.expectedErr) {
+			t.Errorf("Unexpected error: %v", err)
+		}
+	}
+}
diff --git a/pkg/blob/nodeserver_test.go b/pkg/blob/nodeserver_test.go
@@ -19,8 +19,10 @@ package blob
 import (
 	"context"
 	"errors"
+	"fmt"
 	"os"
 	"reflect"
+	"syscall"
 	"testing"
 
 	"google.golang.org/grpc/codes"
@@ -67,42 +69,54 @@ func TestNodeGetCapabilities(t *testing.T) {
 }
 
 func TestEnsureMountPoint(t *testing.T) {
-	// Setup
-	_ = makeDir(sourceTest)
-	_ = makeDir(targetTest)
-	d := NewFakeDriver()
-	d.mounter, _ = NewSafeMounter()
+	errorTarget := "./error_is_likely_target"
+	alreadyExistTarget := "./false_is_likely_exist_target"
+	azureunit := "./azure.go"
 
 	tests := []struct {
 		desc        string
 		target      string
 		expectedErr error
 	}{
 		{
-			desc:        "Not a mount point",
+			desc:        "[Error] Mocked by IsLikelyNotMountPoint",
+			target:      errorTarget,
+			expectedErr: fmt.Errorf("fake IsLikelyNotMountPoint: fake error"),
+		},
+		{
+			desc:        "[Error] Not a directory",
+			target:      azureunit,
+			expectedErr: &os.PathError{Op: "mkdir", Path: "./azure.go", Err: syscall.ENOTDIR},
+		},
+		{
+			desc:        "[Success] Successful run",
 			target:      targetTest,
 			expectedErr: nil,
 		},
 		{
-			desc:   "Error creating directory",
-			target: "./azure.go",
+			desc:        "[Success] Already existing mount",
+			target:      alreadyExistTarget,
+			expectedErr: nil,
 		},
 	}
 
+	// Setup
+	_ = makeDir(alreadyExistTarget)
+	d := NewFakeDriver()
+	fakeMounter := &fakeMounter{}
+	d.mounter = &mount.SafeFormatAndMount{
+		Interface: fakeMounter,
+	}
+
 	for _, test := range tests {
 		err := d.ensureMountPoint(test.target)
-		if test.desc == "Error creating directory" {
-			var e *os.PathError
-			if !errors.As(err, &e) {
-				t.Errorf("Unexpected Error: %v", err)
-			}
-		} else if !reflect.DeepEqual(err, test.expectedErr) {
+		if !reflect.DeepEqual(err, test.expectedErr) {
 			t.Errorf("desc: %s\n actualErr: (%v), expectedErr: (%v)", test.desc, err, test.expectedErr)
 		}
 	}
 
 	// Clean up
-	err := os.RemoveAll(sourceTest)
+	err := os.RemoveAll(alreadyExistTarget)
 	assert.NoError(t, err)
 	err = os.RemoveAll(targetTest)
 	assert.NoError(t, err)
diff --git a/pkg/csi-common/utils_test.go b/pkg/csi-common/utils_test.go
@@ -20,12 +20,13 @@ import (
 	"bytes"
 	"context"
 	"flag"
-	"github.com/container-storage-interface/spec/lib/go/csi"
-	"google.golang.org/grpc"
-	"k8s.io/klog/v2"
 	"testing"
 
+	"github.com/container-storage-interface/spec/lib/go/csi"
 	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+
+	"k8s.io/klog/v2"
 )
 
 func TestParseEndpoint(t *testing.T) {
@@ -146,7 +147,7 @@ func TestLogGRPC(t *testing.T) {
 	}
 }
 
-func TestNewNodeServiceCapability(t *testing.T) {
+func TestNewControllerServiceCapability(t *testing.T) {
 	tests := []struct {
 		cap csi.ControllerServiceCapability_RPC_Type
 	}{
@@ -172,3 +173,27 @@ func TestNewNodeServiceCapability(t *testing.T) {
 		assert.Equal(t, resp.XXX_sizecache, int32(0))
 	}
 }
+
+func TestNewNodeServiceCapability(t *testing.T) {
+	tests := []struct {
+		cap csi.NodeServiceCapability_RPC_Type
+	}{
+		{
+			cap: csi.NodeServiceCapability_RPC_UNKNOWN,
+		},
+		{
+			cap: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
+		},
+		{
+			cap: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
+		},
+		{
+			cap: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
+		},
+	}
+	for _, test := range tests {
+		resp := NewNodeServiceCapability(test.cap)
+		assert.NotNil(t, resp)
+		assert.Equal(t, resp.XXX_sizecache, int32(0))
+	}
+}
