node_block.go

package sanitytest

import (
	"github.com/container-storage-interface/spec/lib/go/csi"
)

import (
	"context"
	. "github.com/onsi/gomega"
)

func isNodeCapabilitySupported(c csi.NodeClient,
	capType csi.NodeServiceCapability_RPC_Type,
) bool {

	caps, err := c.NodeGetCapabilities(
		context.Background(),
		&csi.NodeGetCapabilitiesRequest{})
	Expect(err).NotTo(HaveOccurred())
	Expect(caps).NotTo(BeNil())

	for _, cap := range caps.GetCapabilities() {
		Expect(cap.GetRpc()).NotTo(BeNil())
		if cap.GetRpc().GetType() == capType {
			return true
		}
	}
	return false
}

func isPluginCapabilitySupported(c csi.IdentityClient,
	capType csi.PluginCapability_Service_Type,
) bool {

	caps, err := c.GetPluginCapabilities(
		context.Background(),
		&csi.GetPluginCapabilitiesRequest{})
	Expect(err).NotTo(HaveOccurred())
	Expect(caps).NotTo(BeNil())
	Expect(caps.GetCapabilities()).NotTo(BeNil())

	for _, cap := range caps.GetCapabilities() {
		Expect(cap.GetService()).NotTo(BeNil())
		if cap.GetService().GetType() == capType {
			return true
		}
	}
	return false
}

//var _ = sanity.DescribeSanity("Block - Node Service", func(sc *sanity.SanityContext) {
//	var (
//		cl *sanity.Cleanup
//		c  csi.NodeClient
//		s  csi.ControllerClient
//
//		controllerPublishSupported bool
//		nodeStageSupported         bool
//		nodeVolumeStatsSupported   bool
//	)
//
//	BeforeEach(func() {
//		c = csi.NewNodeClient(sc.Conn)
//		s = csi.NewControllerClient(sc.Conn)
//
//		controllerPublishSupported = isControllerCapabilitySupported(
//			s,
//			csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME)
//		nodeStageSupported = isNodeCapabilitySupported(c, csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME)
//		if nodeStageSupported {
//			err := createMountTargetLocation(sc.Config.StagingPath)
//			Expect(err).NotTo(HaveOccurred())
//		}
//		nodeVolumeStatsSupported = isNodeCapabilitySupported(c, csi.NodeServiceCapability_RPC_GET_VOLUME_STATS)
//		cl = &sanity.Cleanup{
//			Context:                    sc,
//			NodeClient:                 c,
//			ControllerClient:           s,
//			ControllerPublishSupported: controllerPublishSupported,
//			NodeStageSupported:         nodeStageSupported,
//		}
//	})
//
//	AfterEach(func() {
//		cl.DeleteVolumes()
//	})
//
//	Describe("NodePublishVolume", func() {
//		It("should fail when no volume id is provided", func() {
//			_, err := c.NodePublishVolume(
//				context.Background(),
//				&csi.NodePublishVolumeRequest{
//					Secrets: sc.Secrets.NodePublishVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no target path is provided", func() {
//			_, err := c.NodePublishVolume(
//				context.Background(),
//				&csi.NodePublishVolumeRequest{
//					VolumeId: "id",
//					Secrets:  sc.Secrets.NodePublishVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no volume capability is provided", func() {
//			_, err := c.NodePublishVolume(
//				context.Background(),
//				&csi.NodePublishVolumeRequest{
//					VolumeId:   "id",
//					TargetPath: sc.Config.TargetPath + "/dev",
//					Secrets:    sc.Secrets.NodePublishVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//	})
//
//	Describe("NodeUnpublishVolume", func() {
//		It("should fail when no volume id is provided", func() {
//
//			_, err := c.NodeUnpublishVolume(
//				context.Background(),
//				&csi.NodeUnpublishVolumeRequest{})
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no target path is provided", func() {
//
//			_, err := c.NodeUnpublishVolume(
//				context.Background(),
//				&csi.NodeUnpublishVolumeRequest{
//					VolumeId: "id",
//				})
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//	})
//
//	Describe("NodeStageVolume", func() {
//		var (
//			device string
//		)
//
//		BeforeEach(func() {
//			if !nodeStageSupported {
//				Skip("NodeStageVolume not supported")
//			}
//
//			device = "/dev/mock"
//		})
//
//		It("should fail when no volume id is provided", func() {
//			_, err := c.NodeStageVolume(
//				context.Background(),
//				&csi.NodeStageVolumeRequest{
//					StagingTargetPath: sc.Config.StagingPath,
//					VolumeCapability: &csi.VolumeCapability{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//					PublishContext: map[string]string{
//						"device": device,
//					},
//					Secrets: sc.Secrets.NodeStageVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no staging target path is provided", func() {
//			_, err := c.NodeStageVolume(
//				context.Background(),
//				&csi.NodeStageVolumeRequest{
//					VolumeId: "id",
//					VolumeCapability: &csi.VolumeCapability{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//					PublishContext: map[string]string{
//						"device": device,
//					},
//					Secrets: sc.Secrets.NodeStageVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no volume capability is provided", func() {
//
//			// Create Volume First
//			By("creating a single node writer volume")
//			name := uniqueString("sanity-node-stage-nocaps")
//
//			vol, err := s.CreateVolume(
//				context.Background(),
//				&csi.CreateVolumeRequest{
//					Name: name,
//					CapacityRange: &csi.CapacityRange{
//						RequiredBytes: TestVolumeSize(sc),
//					},
//					VolumeCapabilities: []*csi.VolumeCapability{
//						{
//							AccessType: &csi.VolumeCapability_Block{
//								Block: &csi.VolumeCapability_BlockVolume{},
//							},
//							AccessMode: &csi.VolumeCapability_AccessMode{
//								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//							},
//						},
//					},
//					Secrets:    sc.Secrets.CreateVolumeSecret,
//					Parameters: sc.Config.TestVolumeParameters,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(vol).NotTo(BeNil())
//			Expect(vol.GetVolume()).NotTo(BeNil())
//			Expect(vol.GetVolume().GetVolumeId()).NotTo(BeEmpty())
//			cl.RegisterVolume(name, sanity.VolumeInfo{VolumeID: vol.GetVolume().GetVolumeId()})
//
//			_, err = c.NodeStageVolume(
//				context.Background(),
//				&csi.NodeStageVolumeRequest{
//					VolumeId:          vol.GetVolume().GetVolumeId(),
//					StagingTargetPath: sc.Config.StagingPath,
//					PublishContext: map[string]string{
//						"device": device,
//					},
//					Secrets: sc.Secrets.NodeStageVolumeSecret,
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//
//			By("cleaning up deleting the volume")
//
//			_, err = s.DeleteVolume(
//				context.Background(),
//				&csi.DeleteVolumeRequest{
//					VolumeId: vol.GetVolume().GetVolumeId(),
//					Secrets:  sc.Secrets.DeleteVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			cl.UnregisterVolume(name)
//		})
//	})
//
//	Describe("NodeUnstageVolume", func() {
//		BeforeEach(func() {
//			if !nodeStageSupported {
//				Skip("NodeUnstageVolume not supported")
//			}
//		})
//
//		It("should fail when no volume id is provided", func() {
//
//			_, err := c.NodeUnstageVolume(
//				context.Background(),
//				&csi.NodeUnstageVolumeRequest{
//					StagingTargetPath: sc.Config.StagingPath,
//				})
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no staging target path is provided", func() {
//
//			_, err := c.NodeUnstageVolume(
//				context.Background(),
//				&csi.NodeUnstageVolumeRequest{
//					VolumeId: "id",
//				})
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//	})
//
//	Describe("NodeGetVolumeStats", func() {
//		BeforeEach(func() {
//			if !nodeVolumeStatsSupported {
//				Skip("NodeGetVolume not supported")
//			}
//		})
//
//		It("should fail when no volume id is provided", func() {
//			_, err := c.NodeGetVolumeStats(
//				context.Background(),
//				&csi.NodeGetVolumeStatsRequest{
//					VolumePath: "some/path",
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when no volume path is provided", func() {
//			_, err := c.NodeGetVolumeStats(
//				context.Background(),
//				&csi.NodeGetVolumeStatsRequest{
//					VolumeId: "id",
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.InvalidArgument))
//		})
//
//		It("should fail when volume is not found", func() {
//			_, err := c.NodeGetVolumeStats(
//				context.Background(),
//				&csi.NodeGetVolumeStatsRequest{
//					VolumeId:   "id",
//					VolumePath: "some/path",
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.NotFound))
//		})
//
//		It("should fail when volume does not exist on the specified path", func() {
//			name := uniqueString("sanity-node-get-volume-stats")
//
//			By("creating a single node writer volume")
//			vol, err := s.CreateVolume(
//				context.Background(),
//				&csi.CreateVolumeRequest{
//					Name: name,
//					CapacityRange: &csi.CapacityRange{
//						RequiredBytes: TestVolumeSize(sc),
//					},
//					VolumeCapabilities: []*csi.VolumeCapability{
//						{
//							AccessType: &csi.VolumeCapability_Block{
//								Block: &csi.VolumeCapability_BlockVolume{},
//							},
//							AccessMode: &csi.VolumeCapability_AccessMode{
//								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//							},
//						},
//					},
//					Secrets:    sc.Secrets.CreateVolumeSecret,
//					Parameters: sc.Config.TestVolumeParameters,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(vol).NotTo(BeNil())
//			Expect(vol.GetVolume()).NotTo(BeNil())
//			Expect(vol.GetVolume().GetVolumeId()).NotTo(BeEmpty())
//			cl.RegisterVolume(name, sanity.VolumeInfo{VolumeID: vol.GetVolume().GetVolumeId()})
//
//			By("getting a node id")
//			nid, err := c.NodeGetInfo(
//				context.Background(),
//				&csi.NodeGetInfoRequest{})
//			Expect(err).NotTo(HaveOccurred())
//			Expect(nid).NotTo(BeNil())
//			Expect(nid.GetNodeId()).NotTo(BeEmpty())
//
//			var conpubvol *csi.ControllerPublishVolumeResponse
//			if controllerPublishSupported {
//				By("controller publishing volume")
//
//				conpubvol, err = s.ControllerPublishVolume(
//					context.Background(),
//					&csi.ControllerPublishVolumeRequest{
//						VolumeId: vol.GetVolume().GetVolumeId(),
//						NodeId:   nid.GetNodeId(),
//						VolumeCapability: &csi.VolumeCapability{
//							AccessType: &csi.VolumeCapability_Block{
//								Block: &csi.VolumeCapability_BlockVolume{},
//							},
//							AccessMode: &csi.VolumeCapability_AccessMode{
//								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//							},
//						},
//						VolumeContext: vol.GetVolume().GetVolumeContext(),
//						Readonly:      false,
//						Secrets:       sc.Secrets.ControllerPublishVolumeSecret,
//					},
//				)
//				Expect(err).NotTo(HaveOccurred())
//				cl.RegisterVolume(name, sanity.VolumeInfo{VolumeID: vol.GetVolume().GetVolumeId(), NodeID: nid.GetNodeId()})
//				Expect(conpubvol).NotTo(BeNil())
//			}
//			// NodeStageVolume
//			if nodeStageSupported {
//				By("node staging volume")
//				nodestagevol, err := c.NodeStageVolume(
//					context.Background(),
//					&csi.NodeStageVolumeRequest{
//						VolumeId: vol.GetVolume().GetVolumeId(),
//						VolumeCapability: &csi.VolumeCapability{
//							AccessType: &csi.VolumeCapability_Block{
//								Block: &csi.VolumeCapability_BlockVolume{},
//							},
//							AccessMode: &csi.VolumeCapability_AccessMode{
//								Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//							},
//						},
//						StagingTargetPath: sc.Config.StagingPath + "/dev",
//						VolumeContext:     vol.GetVolume().GetVolumeContext(),
//						PublishContext:    conpubvol.GetPublishContext(),
//						Secrets:           sc.Secrets.NodeStageVolumeSecret,
//					},
//				)
//				Expect(err).NotTo(HaveOccurred())
//				Expect(nodestagevol).NotTo(BeNil())
//			}
//			// NodePublishVolume
//			By("publishing the volume on a node")
//			var stagingPath string
//			if nodeStageSupported {
//				stagingPath = sc.Config.StagingPath + "/dev"
//			}
//			nodepubvol, err := c.NodePublishVolume(
//				context.Background(),
//				&csi.NodePublishVolumeRequest{
//					VolumeId:          vol.GetVolume().GetVolumeId(),
//					TargetPath:        sc.Config.TargetPath + "/dev",
//					StagingTargetPath: stagingPath,
//					VolumeCapability: &csi.VolumeCapability{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//					VolumeContext:  vol.GetVolume().GetVolumeContext(),
//					PublishContext: conpubvol.GetPublishContext(),
//					Secrets:        sc.Secrets.NodePublishVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(nodepubvol).NotTo(BeNil())
//
//			// NodeGetVolumeStats
//			By("Get node volume stats")
//			_, err = c.NodeGetVolumeStats(
//				context.Background(),
//				&csi.NodeGetVolumeStatsRequest{
//					VolumeId:   vol.GetVolume().GetVolumeId(),
//					VolumePath: "some/path",
//				},
//			)
//			Expect(err).To(HaveOccurred())
//
//			serverError, ok := status.FromError(err)
//			Expect(ok).To(BeTrue())
//			Expect(serverError.Code()).To(Equal(codes.NotFound))
//
//			// NodeUnpublishVolume
//			By("cleaning up calling nodeunpublish")
//			nodeunpubvol, err := c.NodeUnpublishVolume(
//				context.Background(),
//				&csi.NodeUnpublishVolumeRequest{
//					VolumeId:   vol.GetVolume().GetVolumeId(),
//					TargetPath: sc.Config.TargetPath + "/dev",
//				})
//			Expect(err).NotTo(HaveOccurred())
//			Expect(nodeunpubvol).NotTo(BeNil())
//
//			if nodeStageSupported {
//				By("cleaning up calling nodeunstage")
//				nodeunstagevol, err := c.NodeUnstageVolume(
//					context.Background(),
//					&csi.NodeUnstageVolumeRequest{
//						VolumeId:          vol.GetVolume().GetVolumeId(),
//						StagingTargetPath: sc.Config.StagingPath + "/dev",
//					},
//				)
//				Expect(err).NotTo(HaveOccurred())
//				Expect(nodeunstagevol).NotTo(BeNil())
//			}
//
//			if controllerPublishSupported {
//				By("cleaning up calling controllerunpublishing")
//
//				controllerunpubvol, err := s.ControllerUnpublishVolume(
//					context.Background(),
//					&csi.ControllerUnpublishVolumeRequest{
//						VolumeId: vol.GetVolume().GetVolumeId(),
//						NodeId:   nid.GetNodeId(),
//						Secrets:  sc.Secrets.ControllerUnpublishVolumeSecret,
//					},
//				)
//				Expect(err).NotTo(HaveOccurred())
//				Expect(controllerunpubvol).NotTo(BeNil())
//			}
//
//			By("cleaning up deleting the volume")
//
//			_, err = s.DeleteVolume(
//				context.Background(),
//				&csi.DeleteVolumeRequest{
//					VolumeId: vol.GetVolume().GetVolumeId(),
//					Secrets:  sc.Secrets.DeleteVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//
//		})
//
//	})
//
//	It("should work", func() {
//		name := uniqueString("sanity-node-full")
//
//		// Create Volume First
//		By("creating a single node writer volume")
//		vol, err := s.CreateVolume(
//			context.Background(),
//			&csi.CreateVolumeRequest{
//				Name: name,
//				CapacityRange: &csi.CapacityRange{
//					RequiredBytes: TestVolumeSize(sc),
//				},
//				VolumeCapabilities: []*csi.VolumeCapability{
//					{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//				},
//				Secrets:    sc.Secrets.CreateVolumeSecret,
//				Parameters: sc.Config.TestVolumeParameters,
//			},
//		)
//		Expect(err).NotTo(HaveOccurred())
//		Expect(vol).NotTo(BeNil())
//		Expect(vol.GetVolume()).NotTo(BeNil())
//		Expect(vol.GetVolume().GetVolumeId()).NotTo(BeEmpty())
//		cl.RegisterVolume(name, sanity.VolumeInfo{VolumeID: vol.GetVolume().GetVolumeId()})
//
//		By("getting a node id")
//		nid, err := c.NodeGetInfo(
//			context.Background(),
//			&csi.NodeGetInfoRequest{})
//		Expect(err).NotTo(HaveOccurred())
//		Expect(nid).NotTo(BeNil())
//		Expect(nid.GetNodeId()).NotTo(BeEmpty())
//
//		var conpubvol *csi.ControllerPublishVolumeResponse
//		if controllerPublishSupported {
//			By("controller publishing volume")
//
//			conpubvol, err = s.ControllerPublishVolume(
//				context.Background(),
//				&csi.ControllerPublishVolumeRequest{
//					VolumeId: vol.GetVolume().GetVolumeId(),
//					NodeId:   nid.GetNodeId(),
//					VolumeCapability: &csi.VolumeCapability{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//					VolumeContext: vol.GetVolume().GetVolumeContext(),
//					Readonly:      false,
//					Secrets:       sc.Secrets.ControllerPublishVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			cl.RegisterVolume(name, sanity.VolumeInfo{VolumeID: vol.GetVolume().GetVolumeId(), NodeID: nid.GetNodeId()})
//			Expect(conpubvol).NotTo(BeNil())
//		}
//		// NodeStageVolume
//		if nodeStageSupported {
//			By("node staging volume")
//			nodestagevol, err := c.NodeStageVolume(
//				context.Background(),
//				&csi.NodeStageVolumeRequest{
//					VolumeId: vol.GetVolume().GetVolumeId(),
//					VolumeCapability: &csi.VolumeCapability{
//						AccessType: &csi.VolumeCapability_Block{
//							Block: &csi.VolumeCapability_BlockVolume{},
//						},
//						AccessMode: &csi.VolumeCapability_AccessMode{
//							Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//						},
//					},
//					StagingTargetPath: sc.Config.StagingPath + "/dev",
//					VolumeContext:     vol.GetVolume().GetVolumeContext(),
//					PublishContext:    conpubvol.GetPublishContext(),
//					Secrets:           sc.Secrets.NodeStageVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(nodestagevol).NotTo(BeNil())
//		}
//		// NodePublishVolume
//		By("publishing the volume on a node")
//		var stagingPath string
//		if nodeStageSupported {
//			stagingPath = sc.Config.StagingPath + "/dev"
//		}
//		nodepubvol, err := c.NodePublishVolume(
//			context.Background(),
//			&csi.NodePublishVolumeRequest{
//				VolumeId:          vol.GetVolume().GetVolumeId(),
//				TargetPath:        sc.Config.TargetPath + "/dev",
//				StagingTargetPath: stagingPath,
//				VolumeCapability: &csi.VolumeCapability{
//					AccessType: &csi.VolumeCapability_Block{
//						Block: &csi.VolumeCapability_BlockVolume{},
//					},
//					AccessMode: &csi.VolumeCapability_AccessMode{
//						Mode: csi.VolumeCapability_AccessMode_SINGLE_NODE_WRITER,
//					},
//				},
//				VolumeContext:  vol.GetVolume().GetVolumeContext(),
//				PublishContext: conpubvol.GetPublishContext(),
//				Secrets:        sc.Secrets.NodePublishVolumeSecret,
//			},
//		)
//		Expect(err).NotTo(HaveOccurred())
//		Expect(nodepubvol).NotTo(BeNil())
//
//		// NodeGetVolumeStats
//		if nodeVolumeStatsSupported {
//			By("Get node volume stats")
//			statsResp, err := c.NodeGetVolumeStats(
//				context.Background(),
//				&csi.NodeGetVolumeStatsRequest{
//					VolumeId:   vol.GetVolume().GetVolumeId(),
//					VolumePath: sc.Config.TargetPath + "/dev",
//				},
//			)
//			Expect(err).ToNot(HaveOccurred())
//			Expect(statsResp.GetUsage()).ToNot(BeNil())
//		}
//
//		// NodeUnpublishVolume
//		By("cleaning up calling nodeunpublish")
//		nodeunpubvol, err := c.NodeUnpublishVolume(
//			context.Background(),
//			&csi.NodeUnpublishVolumeRequest{
//				VolumeId:   vol.GetVolume().GetVolumeId(),
//				TargetPath: sc.Config.TargetPath + "/dev",
//			})
//		Expect(err).NotTo(HaveOccurred())
//		Expect(nodeunpubvol).NotTo(BeNil())
//
//		if nodeStageSupported {
//			By("cleaning up calling nodeunstage")
//			nodeunstagevol, err := c.NodeUnstageVolume(
//				context.Background(),
//				&csi.NodeUnstageVolumeRequest{
//					VolumeId:          vol.GetVolume().GetVolumeId(),
//					StagingTargetPath: sc.Config.StagingPath + "/dev",
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(nodeunstagevol).NotTo(BeNil())
//		}
//
//		if controllerPublishSupported {
//			By("cleaning up calling controllerunpublishing")
//
//			controllerunpubvol, err := s.ControllerUnpublishVolume(
//				context.Background(),
//				&csi.ControllerUnpublishVolumeRequest{
//					VolumeId: vol.GetVolume().GetVolumeId(),
//					NodeId:   nid.GetNodeId(),
//					Secrets:  sc.Secrets.ControllerUnpublishVolumeSecret,
//				},
//			)
//			Expect(err).NotTo(HaveOccurred())
//			Expect(controllerunpubvol).NotTo(BeNil())
//		}
//
//		By("cleaning up deleting the volume")
//
//		_, err = s.DeleteVolume(
//			context.Background(),
//			&csi.DeleteVolumeRequest{
//				VolumeId: vol.GetVolume().GetVolumeId(),
//				Secrets:  sc.Secrets.DeleteVolumeSecret,
//			},
//		)
//		Expect(err).NotTo(HaveOccurred())
//	})
//})