fix fakeClientset for unit tests + add e2e tests

Author: hungnguyen243

pkg/cloud_provider/clientset/fake.go

@@ -19,13 +19,19 @@ package clientset
 
 import (
 	"context"
+	"strconv"
 
 	"github.com/googlecloudplatform/gcs-fuse-csi-driver/pkg/webhook"
 	authenticationv1 "k8s.io/api/authentication/v1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+type FakeNodeConfig struct {
+	IsWorkloadIdentityEnabled bool
+	MachineType               string
+}
+
 type FakeClientset struct {
 	fakePod  *corev1.Pod
 	fakeNode *corev1.Node
@@ -35,7 +41,7 @@ func NewFakeClientset() *FakeClientset {
 	fakeClientSet := &FakeClientset{}
 	// Default setting for most unit tests is pod doesn't use host network & workload identity is enabled on the node
 	fakeClientSet.CreatePod( /*hostNetworkEnabled */ false)
-	fakeClientSet.CreateNode( /* isWorkloadIdentityEnabledOnNode */ true)
+	fakeClientSet.CreateNode(FakeNodeConfig{IsWorkloadIdentityEnabled: true})
 
 	return fakeClientSet
 }
@@ -74,16 +80,18 @@ func (c *FakeClientset) CreatePod(hostNetworkEnabled bool) {
 	}
 }
 
-func (c *FakeClientset) CreateNode(isWorkloadIdentityEnabled bool) {
+func (c *FakeClientset) CreateNode(nodeConfig FakeNodeConfig) {
 	c.fakeNode = &corev1.Node{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:   "",
 			Labels: map[string]string{},
 		},
 	}
 
-	if isWorkloadIdentityEnabled {
-		c.fakeNode.Labels[GkeMetaDataServerKey] = "true"
+	c.fakeNode.Labels[GkeMetaDataServerKey] = strconv.FormatBool(nodeConfig.IsWorkloadIdentityEnabled)
+	c.fakeNode.Labels[MachineTypeKey] = nodeConfig.MachineType
+	if c.fakeNode.Labels[MachineTypeKey] == "" {
+		c.fakeNode.Labels[MachineTypeKey] = "e2-medium"
 	}
 }
 

pkg/csi_driver/node.go

@@ -183,15 +183,16 @@ func (s *nodeServer) NodePublishVolume(ctx context.Context, req *csi.NodePublish
 		}
 	}
 
-	machineType, ok := node.Labels[clientset.MachineTypeKey]
 	shouldDisableAutoConfig := s.driver.config.DisableAutoconfig
-
-	flagMap := map[string]string{"machine-type": machineType, "disable-autoconfig": strconv.FormatBool(shouldDisableAutoConfig)}
-
+	machineType, ok := node.Labels[clientset.MachineTypeKey]
+	// TODO: Add check for whether sidecar is managed and >= minimum version with compatible gcsfuse
 	if ok {
+		flagMap := map[string]string{"machine-type": machineType, "disable-autoconfig": strconv.FormatBool(shouldDisableAutoConfig)}
 		if err := PutFlagsFromDriverToTargetPath(flagMap, targetPath, FlagFileForDefaultingPath); err != nil {
 			return nil, status.Error(codes.Internal, err.Error())
 		}
+	} else {
+		klog.Warningf("Unable to fetch node %v's machine type", node.Name)
 	}
 
 	// Check if there is any error from the gcsfuse

pkg/csi_driver/node_test.go

@@ -247,7 +247,7 @@ func TestNodePublishVolumeWIDisabledOnNode(t *testing.T) {
 	}
 	for _, test := range cases {
 		fakeClientSet := &clientset.FakeClientset{}
-		fakeClientSet.CreateNode( /* workloadIdentityEnabled */ test.workloadIdentityEnabledOnNode)
+		fakeClientSet.CreateNode( /* workloadIdentityEnabled */ clientset.FakeNodeConfig{IsWorkloadIdentityEnabled: test.workloadIdentityEnabledOnNode})
 		fakeClientSet.CreatePod( /* hostNetworkEnabled */ test.hostNetworkEnabledOnPod)
 		testEnv := initTestNodeServerWithCustomClientset(t, fakeClientSet)
 

pkg/csi_driver/utils.go

@@ -474,20 +474,22 @@ func getSidecarContainerStatus(isInitContainer bool, pod *corev1.Pod) (*corev1.C
 }
 
 func isSidecarVersionSupportedForTokenServer(imageName string) bool {
+	return isSidecarVersionSupportedForGivenFeature(imageName, tokenServerSidecarMinVersion)
+}
+
+func isSidecarVersionSupportedForGivenFeature(imageName string, sidecarMinSupportedVersion string) bool {
 	managedSidecarPattern := `.*/gke-release(-staging)?/gcs-fuse-csi-driver-sidecar-mounter:v\d+.\d+.\d+-gke\.\d+.*`
 	re := regexp.MustCompile(managedSidecarPattern)
 	isManagedSidecar := re.MatchString(imageName)
 
 	if !isManagedSidecar {
 		klog.Infof("mountOptions should not be passed because this is a private sidecar image %q", imageName)
-
 		return false
 	}
 	imageVersion := strings.Split(strings.Split(imageName, ":")[1], "@")[0]
 	klog.Infof("sidecar image version: %v", imageVersion)
-	if semver.Compare(imageVersion, tokenServerSidecarMinVersion) >= 0 {
+	if semver.Compare(imageVersion, sidecarMinSupportedVersion) >= 0 {
 		klog.Infof("sidecar version is supported for token server")
-
 		return true
 	}
 
@@ -505,20 +507,15 @@ func PutFlagsFromDriverToTargetPath(flagMap map[string]string, targetPath string
 
 	f, err := os.Create(absolutePath)
 	if err != nil {
-		return fmt.Errorf("failed to create defaulting flag file: %w", err)
+		return fmt.Errorf("failed to create defaulting-flag file: %w", err)
 	}
 	content := prepareFileContentFromFlagMap(flagMap)
 	if _, err := f.WriteString(content); err != nil {
-		return fmt.Errorf("failed to write defaulting flag file: %w", err)
+		return fmt.Errorf("failed to write defaulting-flag file: %w", err)
 	}
 
 	f.Close()
 
-	err = os.Chown(absolutePath, webhook.NobodyUID, webhook.NobodyGID)
-	if err != nil {
-		return fmt.Errorf("failed to change ownership on the machine-type file: %w", err)
-	}
-
 	return nil
 }
 

test/e2e/specs/specs.go

@@ -86,6 +86,8 @@ const (
 	ReadAheadCustomReadAheadKb = "15360"
 	ReadAheadCustomMaxRatio    = "100"
 
+	DisableAutoconfig = "disable-autoconfig"
+
 	GoogleCloudCliImage = "gcr.io/google.com/cloudsdktool/google-cloud-cli:slim"
 	GolangImage         = "golang:1.22.7"
 	UbuntuImage         = "ubuntu:20.04"
@@ -406,6 +408,15 @@ func (t *TestPod) GetNode() string {
 	return t.pod.Spec.NodeName
 }
 
+func (t *TestPod) GetMachineType(ctx context.Context) (string, error) {
+	nodeName := t.GetNode()
+	node, err := t.client.CoreV1().Nodes().Get(ctx, nodeName, metav1.GetOptions{})
+	if err != nil {
+		return "", fmt.Errorf("error getting test node %v's machine type ", nodeName)
+	}
+	return node.ObjectMeta.Labels["node.kubernetes.io/instance-type"], nil
+}
+
 func (t *TestPod) GetCSIDriverNodePodIP(ctx context.Context) string {
 	node := t.GetNode()
 	daemonSetLabelSelector := "k8s-app=gcs-fuse-csi-driver"
@@ -1237,3 +1248,18 @@ func DeployIstioSidecar(namespace string) {
 func DeployIstioServiceEntry(namespace string) {
 	e2ekubectl.RunKubectlOrDie(namespace, "apply", "--filename", "./specs/istio-service-entry.yaml")
 }
+
+func (t *TestPod) VerifyDefaultingFlagsArePassed(namespace string, expectedMachineTypeFlag string, expectedDisableAutoconfigFlag bool) {
+	stdout, stderr, err := e2ekubectl.RunKubectlWithFullOutput(namespace, "logs", t.pod.Name, "-c", "gke-gcsfuse-sidecar")
+	framework.ExpectNoError(err,
+		"Error accessing logs from pod %v, but failed with error message %q\nstdout: %s\nstderr: %s",
+		t.pod.Name, err, stdout, stderr)
+
+	expectedDisableAutoconfigFlagString := fmt.Sprintf(`"DisableAutoconfig":%t`, expectedDisableAutoconfigFlag)
+	expectedMachineTypeFlagString := fmt.Sprintf(`"MachineType":"%s"`, expectedMachineTypeFlag)
+
+	gomega.Expect(stdout).To(gomega.ContainSubstring(expectedDisableAutoconfigFlagString),
+		"Should find DisableAutoconfig flag string %q in stdout:\n%s", expectedDisableAutoconfigFlagString, stdout)
+	gomega.Expect(stdout).To(gomega.ContainSubstring(expectedMachineTypeFlagString),
+		"Should find MachineType flag string %q in stdout:\n%s", expectedMachineTypeFlagString, stdout)
+}

test/e2e/specs/testdriver.go

@@ -239,6 +239,8 @@ func (n *GCSFuseCSITestDriver) CreateVolume(ctx context.Context, config *storage
 		case EnableMetadataPrefetchAndInvalidMountOptionsVolumePrefix:
 			mountOptions += ",file-system:kernel-list-cache-ttl-secs:-1,invalid-option"
 			v.metadataPrefetch = true
+		case DisableAutoconfig:
+			mountOptions += ",disable-autoconfig"
 		}
 
 		v.mountOptions = mountOptions

test/e2e/testsuites/mount.go

@@ -21,8 +21,12 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"slices"
 	"strconv"
 
+	"local/test/e2e/specs"
+	"local/test/e2e/utils"
+
 	"github.com/googlecloudplatform/gcs-fuse-csi-driver/pkg/webhook"
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
@@ -33,8 +37,6 @@ import (
 	e2evolume "k8s.io/kubernetes/test/e2e/framework/volume"
 	storageframework "k8s.io/kubernetes/test/e2e/storage/framework"
 	admissionapi "k8s.io/pod-security-admission/api"
-	"local/test/e2e/specs"
-	"local/test/e2e/utils"
 )
 
 type gcsFuseCSIMountTestSuite struct {
@@ -183,6 +185,40 @@ func (t *gcsFuseCSIMountTestSuite) DefineTests(driver storageframework.TestDrive
 		tPod.Cleanup(ctx)
 	}
 
+	testDefaultingFlags := func(configPrefix ...string) {
+		init(configPrefix...)
+		defer cleanup()
+
+		ginkgo.By("Configuring test pod")
+		tPod := specs.NewTestPod(f.ClientSet, f.Namespace)
+		tPod.SetupVolume(l.volumeResource, volumeName, mountPath, false)
+
+		tPod.Create(ctx)
+
+		ginkgo.By("Checking pod is running")
+		tPod.WaitForRunning(ctx)
+
+		machineType, err := tPod.GetMachineType(ctx)
+		framework.ExpectNoError(err, "error getting node's machine type")
+
+		if slices.Contains(configPrefix, specs.DisableAutoconfig) {
+			tPod.VerifyDefaultingFlagsArePassed(f.Namespace.Name, machineType /* disableAutoconfig */, true)
+		} else {
+			tPod.VerifyDefaultingFlagsArePassed(f.Namespace.Name, machineType /* disableAutoconfig */, false)
+		}
+
+		ginkgo.By("Deleting pod")
+		tPod.Cleanup(ctx)
+	}
+
+	ginkgo.It("should pass --machine-type and --disable-autoconfig=false (default driver flag) to gcsfuse ", func() {
+		testDefaultingFlags()
+	})
+
+	ginkgo.It("should pass --machine-type and --disable-autoconfig=true (overwritten as part of mountOptions) to gcsfuse", func() {
+		testDefaultingFlags(specs.DisableAutoconfig)
+	})
+
 	ginkgo.It("[read ahead config] should update read ahead config knobs", func() {
 		if pattern.VolType == storageframework.DynamicPV {
 			e2eskipper.Skipf("skip for volume type %v", storageframework.DynamicPV)