Merge pull request #2617 from kubernetes-sigs/fix-golint-1.31

andyzhangx · web-flow · commit bf0f7ff0655a · 2025-06-15T09:16:02.000+03:00
[release-1.31] test: fix golint errors
diff --git a/.github/workflows/static.yaml b/.github/workflows/static.yaml
@@ -15,5 +15,5 @@ jobs:
             - name: Run linter
               uses: golangci/golangci-lint-action@v6
               with:
-                  version: v1.60
-                  args: -E=gofmt,unused,ineffassign,revive,misspell,copyloopvar,asciicheck,bodyclose,depguard,dogsled,dupl,durationcheck,errname,forbidigo -D=staticcheck --timeout=30m0s
+                  version: v1.64
+                  args: -E=gofmt,unused,ineffassign,revive,misspell,copyloopvar,asciicheck,bodyclose,dogsled,dupl,durationcheck,errname,forbidigo -D=staticcheck --timeout=30m0s
diff --git a/pkg/azurefile/controllerserver.go b/pkg/azurefile/controllerserver.go
@@ -1353,16 +1353,16 @@ func isValidVolumeCapabilities(volCaps []*csi.VolumeCapability) error {
 	if len(volCaps) == 0 {
 		return fmt.Errorf("CreateVolume Volume capabilities must be provided")
 	}
-	hasSupport := func(cap *csi.VolumeCapability) error {
-		if blk := cap.GetBlock(); blk != nil {
+	hasSupport := func(capability *csi.VolumeCapability) error {
+		if blk := capability.GetBlock(); blk != nil {
 			return fmt.Errorf("driver does not support block volumes")
 		}
 		for _, c := range volumeCaps {
-			if c.GetMode() == cap.AccessMode.GetMode() {
+			if c.GetMode() == capability.AccessMode.GetMode() {
 				return nil
 			}
 		}
-		return fmt.Errorf("driver does not support access mode %v", cap.AccessMode.GetMode())
+		return fmt.Errorf("driver does not support access mode %v", capability.AccessMode.GetMode())
 	}
 
 	for _, c := range volCaps {
diff --git a/pkg/csi-common/driver.go b/pkg/csi-common/driver.go
@@ -65,8 +65,8 @@ func (d *CSIDriver) ValidateControllerServiceRequest(c csi.ControllerServiceCapa
 		return nil
 	}
 
-	for _, cap := range d.Cap {
-		if c == cap.GetRpc().GetType() {
+	for _, capability := range d.Cap {
+		if c == capability.GetRpc().GetType() {
 			return nil
 		}
 	}
@@ -78,8 +78,8 @@ func (d *CSIDriver) ValidateNodeServiceRequest(c csi.NodeServiceCapability_RPC_T
 		return nil
 	}
 
-	for _, cap := range d.NSCap {
-		if c == cap.GetRpc().GetType() {
+	for _, capability := range d.NSCap {
+		if c == capability.GetRpc().GetType() {
 			return nil
 		}
 	}
diff --git a/pkg/csi-common/utils.go b/pkg/csi-common/utils.go
@@ -67,21 +67,21 @@ func NewVolumeCapabilityAccessMode(mode csi.VolumeCapability_AccessMode_Mode) *c
 	return &csi.VolumeCapability_AccessMode{Mode: mode}
 }
 
-func NewControllerServiceCapability(cap csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {
+func NewControllerServiceCapability(c csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {
 	return &csi.ControllerServiceCapability{
 		Type: &csi.ControllerServiceCapability_Rpc{
 			Rpc: &csi.ControllerServiceCapability_RPC{
-				Type: cap,
+				Type: c,
 			},
 		},
 	}
 }
 
-func NewNodeServiceCapability(cap csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {
+func NewNodeServiceCapability(c csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {
 	return &csi.NodeServiceCapability{
 		Type: &csi.NodeServiceCapability_Rpc{
 			Rpc: &csi.NodeServiceCapability_RPC{
-				Type: cap,
+				Type: c,
 			},
 		},
 	}
diff --git a/pkg/csi-common/utils_test.go b/pkg/csi-common/utils_test.go
@@ -218,52 +218,52 @@ func TestNewVolumeCapabilityAccessMode(t *testing.T) {
 
 func TestNewControllerServiceCapability(t *testing.T) {
 	tests := []struct {
-		cap csi.ControllerServiceCapability_RPC_Type
+		c csi.ControllerServiceCapability_RPC_Type
 	}{
 		{
-			cap: csi.ControllerServiceCapability_RPC_UNKNOWN,
+			c: csi.ControllerServiceCapability_RPC_UNKNOWN,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,
+			c: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_GET_CAPACITY,
+			c: csi.ControllerServiceCapability_RPC_GET_CAPACITY,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,
 		},
 	}
 	for _, test := range tests {
-		resp := NewControllerServiceCapability(test.cap)
+		resp := NewControllerServiceCapability(test.c)
 		assert.NotNil(t, resp)
 	}
 }
 
 func TestNewNodeServiceCapability(t *testing.T) {
 	tests := []struct {
-		cap csi.NodeServiceCapability_RPC_Type
+		c csi.NodeServiceCapability_RPC_Type
 	}{
 		{
-			cap: csi.NodeServiceCapability_RPC_UNKNOWN,
+			c: csi.NodeServiceCapability_RPC_UNKNOWN,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
+			c: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
+			c: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
+			c: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
 		},
 	}
 	for _, test := range tests {
-		resp := NewNodeServiceCapability(test.cap)
+		resp := NewNodeServiceCapability(test.c)
 		assert.NotNil(t, resp)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -1353,16 +1353,16 @@ func isValidVolumeCapabilities(volCaps []*csi.VolumeCapability) error {`
`1353`	`1353`	`if len(volCaps) == 0 {`
`1354`	`1354`	`return fmt.Errorf("CreateVolume Volume capabilities must be provided")`
`1355`	`1355`	`}`
`1356`		`- hasSupport := func(cap *csi.VolumeCapability) error {`
`1357`		`- if blk := cap.GetBlock(); blk != nil {`
	`1356`	`+ hasSupport := func(capability *csi.VolumeCapability) error {`
	`1357`	`+ if blk := capability.GetBlock(); blk != nil {`
`1358`	`1358`	`return fmt.Errorf("driver does not support block volumes")`
`1359`	`1359`	`}`
`1360`	`1360`	`for _, c := range volumeCaps {`
`1361`		`- if c.GetMode() == cap.AccessMode.GetMode() {`
	`1361`	`+ if c.GetMode() == capability.AccessMode.GetMode() {`
`1362`	`1362`	`return nil`
`1363`	`1363`	`}`
`1364`	`1364`	`}`
`1365`		`- return fmt.Errorf("driver does not support access mode %v", cap.AccessMode.GetMode())`
	`1365`	`+ return fmt.Errorf("driver does not support access mode %v", capability.AccessMode.GetMode())`
`1366`	`1366`	`}`
`1367`	`1367`
`1368`	`1368`	`for _, c := range volCaps {`
Original file line number	Diff line number	Diff line change
`@@ -65,8 +65,8 @@ func (d *CSIDriver) ValidateControllerServiceRequest(c csi.ControllerServiceCapa`
`65`	`65`	`return nil`
`66`	`66`	`}`
`67`	`67`
`68`		`- for _, cap := range d.Cap {`
`69`		`- if c == cap.GetRpc().GetType() {`
	`68`	`+ for _, capability := range d.Cap {`
	`69`	`+ if c == capability.GetRpc().GetType() {`
`70`	`70`	`return nil`
`71`	`71`	`}`
`72`	`72`	`}`
`@@ -78,8 +78,8 @@ func (d *CSIDriver) ValidateNodeServiceRequest(c csi.NodeServiceCapability_RPC_T`
`78`	`78`	`return nil`
`79`	`79`	`}`
`80`	`80`
`81`		`- for _, cap := range d.NSCap {`
`82`		`- if c == cap.GetRpc().GetType() {`
	`81`	`+ for _, capability := range d.NSCap {`
	`82`	`+ if c == capability.GetRpc().GetType() {`
`83`	`83`	`return nil`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,21 +67,21 @@ func NewVolumeCapabilityAccessMode(mode csi.VolumeCapability_AccessMode_Mode) *c`
`67`	`67`	`return &csi.VolumeCapability_AccessMode{Mode: mode}`
`68`	`68`	`}`
`69`	`69`
`70`		`-func NewControllerServiceCapability(cap csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {`
	`70`	`+func NewControllerServiceCapability(c csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {`
`71`	`71`	`return &csi.ControllerServiceCapability{`
`72`	`72`	`Type: &csi.ControllerServiceCapability_Rpc{`
`73`	`73`	`Rpc: &csi.ControllerServiceCapability_RPC{`
`74`		`- Type: cap,`
	`74`	`+ Type: c,`
`75`	`75`	`},`
`76`	`76`	`},`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`		`-func NewNodeServiceCapability(cap csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {`
	`80`	`+func NewNodeServiceCapability(c csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {`
`81`	`81`	`return &csi.NodeServiceCapability{`
`82`	`82`	`Type: &csi.NodeServiceCapability_Rpc{`
`83`	`83`	`Rpc: &csi.NodeServiceCapability_RPC{`
`84`		`- Type: cap,`
	`84`	`+ Type: c,`
`85`	`85`	`},`
`86`	`86`	`},`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -218,52 +218,52 @@ func TestNewVolumeCapabilityAccessMode(t *testing.T) {`
`218`	`218`
`219`	`219`	`func TestNewControllerServiceCapability(t *testing.T) {`
`220`	`220`	`tests := []struct {`
`221`		`- cap csi.ControllerServiceCapability_RPC_Type`
	`221`	`+ c csi.ControllerServiceCapability_RPC_Type`
`222`	`222`	`}{`
`223`	`223`	`{`
`224`		`- cap: csi.ControllerServiceCapability_RPC_UNKNOWN,`
	`224`	`+ c: csi.ControllerServiceCapability_RPC_UNKNOWN,`
`225`	`225`	`},`
`226`	`226`	`{`
`227`		`- cap: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,`
	`227`	`+ c: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,`
`228`	`228`	`},`
`229`	`229`	`{`
`230`		`- cap: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,`
	`230`	`+ c: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,`
`231`	`231`	`},`
`232`	`232`	`{`
`233`		`- cap: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,`
	`233`	`+ c: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,`
`234`	`234`	`},`
`235`	`235`	`{`
`236`		`- cap: csi.ControllerServiceCapability_RPC_GET_CAPACITY,`
	`236`	`+ c: csi.ControllerServiceCapability_RPC_GET_CAPACITY,`
`237`	`237`	`},`
`238`	`238`	`{`
`239`		`- cap: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,`
	`239`	`+ c: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,`
`240`	`240`	`},`
`241`	`241`	`}`
`242`	`242`	`for _, test := range tests {`
`243`		`- resp := NewControllerServiceCapability(test.cap)`
	`243`	`+ resp := NewControllerServiceCapability(test.c)`
`244`	`244`	`assert.NotNil(t, resp)`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`func TestNewNodeServiceCapability(t *testing.T) {`
`249`	`249`	`tests := []struct {`
`250`		`- cap csi.NodeServiceCapability_RPC_Type`
	`250`	`+ c csi.NodeServiceCapability_RPC_Type`
`251`	`251`	`}{`
`252`	`252`	`{`
`253`		`- cap: csi.NodeServiceCapability_RPC_UNKNOWN,`
	`253`	`+ c: csi.NodeServiceCapability_RPC_UNKNOWN,`
`254`	`254`	`},`
`255`	`255`	`{`
`256`		`- cap: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,`
	`256`	`+ c: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,`
`257`	`257`	`},`
`258`	`258`	`{`
`259`		`- cap: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,`
	`259`	`+ c: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,`
`260`	`260`	`},`
`261`	`261`	`{`
`262`		`- cap: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,`
	`262`	`+ c: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,`
`263`	`263`	`},`
`264`	`264`	`}`
`265`	`265`	`for _, test := range tests {`
`266`		`- resp := NewNodeServiceCapability(test.cap)`
	`266`	`+ resp := NewNodeServiceCapability(test.c)`
`267`	`267`	`assert.NotNil(t, resp)`
`268`	`268`	`}`
`269`	`269`	`}`