Refactor and clean-up tests

cmd/image/import/import.go

@@ -93,8 +93,7 @@ pvsadm image import -n upstream-core-lon04 -b <BUCKETNAME>  --object rhel-83-100
 		if err != nil {
 			return err
 		}
-		var accessKey string
-		var accessSecret string
+		var accessKey, accessSecret string
 
 		//Create AccessKey and SecretKey for the bucket provided if bucket access is private
 		if (opt.AccessKey == "" || opt.SecretKey == "") && (!opt.Public) {
@@ -106,7 +105,9 @@ pvsadm image import -n upstream-core-lon04 -b <BUCKETNAME>  --object rhel-83-100
 			if err != nil {
 				return fmt.Errorf("failed to list the resource instances: %v", err)
 			}
-
+			if len(workspaces.Resources) == 0 {
+				return fmt.Errorf("there are no resouces under the resource instance shared")
+			}
 			getServiceInstanceOptions := &resourcecontrollerv2.GetResourceInstanceOptions{
 				// TODO: possibility of workspaces to either be of type service_instance or composite_instance.
 				ID: workspaces.Resources[0].ID,

cmd/image/upload/upload.go

@@ -38,13 +38,6 @@ const (
 	CosResourceID = "dff97f5c-bc5e-4455-b470-411c3edbe49c"
 )
 
-// CosResourcePlanID is IBM COS plan id, can be retrieved using ibmcloud cli
-var CosResourcePlans = map[string]string{
-	"onerate":  "1e4e33e4-cfa6-4f12-9016-be594a6d5f87",
-	"lite":     "2fdf0c08-2d32-4f46-84b5-32e0c92fffd8",
-	"standard": "744bfc56-d12c-4866-88d5-dac9139e0e5d",
-}
-
 var Cmd = &cobra.Command{
 	Use:   "upload",
 	Short: "Upload the image to the IBM COS",

pkg/client/client.go

@@ -165,10 +165,7 @@ func (c *Client) CreateServiceInstance(instanceName, serviceName, resourcePlan,
 	if err != nil {
 		return nil, err
 	}
-
-	klog.Infof("Resource service Instance Details :%+v\n", resp)
-	klog.Infof("Resource service InstanceID :%v\n", resp.ID)
-
+	klog.Infof("Created service instance %s of %s-%s in %s", instanceName, serviceName, resourcePlan, region)
 	return resp, nil
 }
 

test/e2e/qcow2ova/qcow2ova.go

@@ -32,10 +32,11 @@ func runImageQcow2OvaCMD(args ...string) (int, string, string) {
 var _ = CMDDescribe("pvsadm qcow2ova tests", func() {
 	var (
 		image *os.File
+		err   error
 	)
 
 	BeforeSuite(func() {
-		var err error
+		Expect(os.Getenv("IBMCLOUD_API_KEY")).NotTo(BeEmpty(), "IBMCLOUD_API_KEY must be set before running \"make test\"")
 		image, err = os.CreateTemp("", "qcow2ova")
 		Expect(err).NotTo(HaveOccurred())
 		_, err = image.WriteString("some dummy image")
@@ -50,16 +51,16 @@ var _ = CMDDescribe("pvsadm qcow2ova tests", func() {
 		status, stdout, stderr := runImageQcow2OvaCMD(
 			"--help",
 		)
-		Expect(status).To(Equal(0))
-		Expect(stderr).To(Equal(""))
+		Expect(status).To(BeZero())
+		Expect(stderr).To(BeEmpty())
 		Expect(stdout).To(ContainSubstring("Examples:"))
 	})
 
 	framework.NegativeIt("run without image-dist", func() {
 		status, _, stderr := runImageQcow2OvaCMD(
 			"--image-url", image.Name(),
 		)
-		Expect(status).NotTo(Equal(0))
+		Expect(status).NotTo(BeZero())
 		Expect(stderr).To(ContainSubstring("image-dist is a mandatory flag"))
 	})
 })

test/e2e/sync/sync.go

@@ -40,11 +40,10 @@ import (
 
 // Test case variables
 var (
+	bxCli             *client.Client
 	APIKey            = os.Getenv("IBMCLOUD_API_KEY")
-	ObjectsFolderName = "tempFolder"
+	objectsFolderName = "tempFolder"
 	SpecFileName      = "spec/spec.yaml"
-	serviceInstance   *resourcecontrollerv2.ResourceInstance
-	bxCli             *client.Client
 )
 
 // Test case constants
@@ -53,20 +52,10 @@ const (
 	resourceGroupAPIRegion = "global"
 	servicePlan            = "standard"
 	debug                  = false
-	recursive              = false
-	instanceType           = "service_instance"
 	NoOfSources            = 2
 	NoOfTargetsPerSource   = 2
 	NoOfObjects            = 200
 	NoOfUploadWorkers      = 20
-
-	// CosResourceID is IBM COS service id, can be retrieved using ibmcloud cli
-	// ibmcloud catalog service cloud-object-storage.
-	CosResourceID = "dff97f5c-bc5e-4455-b470-411c3edbe49c"
-
-	// CosResourcePlanID is IBM COS plan id, can be retrieved using ibmcloud cli
-	// ibmcloud catalog service cloud-object-storage.
-	CosResourcePlanID = "1e4e33e4-cfa6-4f12-9016-be594a6d5f87"
 )
 
 // Run sync command
@@ -114,19 +103,8 @@ func createCOSInstance(instanceName string) (string, error) {
 
 	rmv2ListResourceGroupOpt := resourcemanagerv2.ListResourceGroupsOptions{AccountID: ptr.To(bxCli.User.Account)}
 	resourceGroupList, _, err := bxCli.ResourceManagerClient.ListResourceGroups(&rmv2ListResourceGroupOpt)
-	klog.V(4).Infof("STEP: Creating COS instance : %s", instanceName)
-	bxCli, err := client.NewClientWithEnv(APIKey, client.DefaultEnv, Debug)
-	if err != nil {
-		klog.Errorf("failed to create a session with IBM cloud, err: %v", err)
-		return err
-	}
-
-	resourceGroupQuery := management.ResourceGroupQuery{
-		AccountID: bxCli.User.Account,
-	}
-	resGrpList, err := bxCli.ResGroupAPI.List(&resourceGroupQuery)
 	if err != nil {
-		return fmt.Errorf("failed to list the reclamations instances: %v", err)
+		return "", fmt.Errorf("failed to list the reclamations instances: %v", err)
 	}
 
 	var resourceGroupNames []string
@@ -135,51 +113,30 @@ func createCOSInstance(instanceName string) (string, error) {
 	}
 	klog.V(3).Infof("Resource Group names: %v", resourceGroupNames)
 
-	serviceInstance, err = bxCli.CreateServiceInstance(instanceName, serviceType, servicePlan,
+	serviceInstance, err := bxCli.CreateServiceInstance(instanceName, serviceType, servicePlan,
 		resourceGroupNames[0], resourceGroupAPIRegion)
 	if err != nil {
 		klog.Errorf("unable to create Service Instance, err: %v", err)
-		return err
+		return "", err
 	}
-
-	return nil
+	return *serviceInstance.ID, nil
 }
 
 // Delete Cloud Object Storage Service instance
 func deleteCOSInstance(instanceId string) error {
 	klog.V(4).Infof("STEP: Deleting COS instance ID: %s", instanceId)
 	deleteServiceInstanceOpts := &resourcecontrollerv2.DeleteResourceInstanceOptions{
-		ID: serviceInstance.ID,
+		ID: ptr.To(instanceId),
 	}
 	if _, err := bxCli.ResouceControllerClient.DeleteResourceInstance(deleteServiceInstanceOpts); err != nil {
-		klog.Errorf("An error occured while deleteing service instance: %v", err)
-	klog.V(4).Infof("STEP: Deleting COS instance %s", instanceName)
-	bxCli, err := client.NewClientWithEnv(APIKey, client.DefaultEnv, Debug)
-	if err != nil {
-		klog.Errorf("failed to create a session with IBM cloud, err: %v", err)
-		return err
-	}
-
-	svcs, err := bxCli.ResourceClientV2.ListInstances(controllerv2.ServiceInstanceQuery{
-		Type: InstanceType,
-		Name: instanceName,
-	})
-	if err != nil {
-		klog.Errorf("unable to list instance, err: %v", err)
+		klog.Errorf("An error occured while deleting service instance: %v", err)
 		return err
 	}
 	return nil
 }
 
 // Create S3 bucket in the given region and storage class
 func createBucket(bucketName string, cos string, region string, storageClass string) error {
-	klog.Infof("STEP: Creating Bucket %s in region %s in COS %s storageClass %s", bucketName, region, cos, storageClass)
-	klog.V(4).Infof("STEP: Creating Bucket %s in region %s in COS %s storageClass %s", bucketName, region, cos, storageClass)
-	bxCli, err := client.NewClientWithEnv(APIKey, client.DefaultEnv, Debug)
-	if err != nil {
-		klog.Errorf("failed to create a session with IBM cloud, err: %v", err)
-		return err
-	}
 
 	s3Cli, err := client.NewS3Client(bxCli, cos, region)
 	if err != nil {
@@ -219,9 +176,9 @@ func createObjects() error {
 		return err
 	}
 
-	ObjectsFolderName = dir
+	objectsFolderName = dir
 	for i := 0; i < NoOfObjects; i++ {
-		file, err := os.CreateTemp(ObjectsFolderName, "image-sync-*.txt")
+		file, err := os.CreateTemp(objectsFolderName, "image-sync-*.txt")
 		if err != nil {
 			klog.Errorf("unable to create a temp file, err: %v", err)
 			return err
@@ -250,8 +207,8 @@ func deleteTempFiles() error {
 		klog.Errorf("error while deleting spec folder, err: %v", err)
 	}
 
-	klog.V(3).Infof("deleting object folder:%s", ObjectsFolderName)
-	err = os.RemoveAll(ObjectsFolderName)
+	klog.V(3).Infof("deleting object folder:%s", objectsFolderName)
+	err = os.RemoveAll(objectsFolderName)
 	if err != nil {
 		klog.Errorf("error while deleting object folder, err: %v", err)
 	}
@@ -276,18 +233,12 @@ func uploadWorker(s3Cli *client.S3Client, bucketName string, workerId int, filep
 func uploadObjects(src pkg.Source) error {
 	klog.V(4).Infof("STEP: Upload Objects to source Bucket %s", src.Bucket)
 	var filePath string
-	files, err := os.ReadDir(ObjectsFolderName)
+	files, err := os.ReadDir(objectsFolderName)
 	if err != nil {
 		klog.Errorf("ERROR: %v", err)
 		return err
 	}
 
-	bxCli, err := client.NewClientWithEnv(APIKey, client.DefaultEnv, Debug)
-	if err != nil {
-		klog.Errorf("failed to create a session with IBM cloud, err: %v", err)
-		return err
-	}
-
 	s3Cli, err := client.NewS3Client(bxCli, src.Cos, src.Region)
 	if err != nil {
 		klog.Errorf("unable to create S3Client, err: %v", err)
@@ -302,7 +253,7 @@ func uploadObjects(src pkg.Source) error {
 	}
 
 	for _, f := range files {
-		filePath = ObjectsFolderName + "/" + f.Name()
+		filePath = objectsFolderName + "/" + f.Name()
 		filepaths <- filePath
 	}
 	close(filepaths)
@@ -354,7 +305,7 @@ func verifyBucketObjects(tgt pkg.TargetItem, cos string, files []fs.FileInfo, re
 // Verify objects copied from source bucket to dest buckets
 func verifyObjectsCopied(spec []pkg.Spec) error {
 	klog.V(4).Info("STEP: Verify Objects Copied to dest buckets")
-	files, err := os.ReadDir(ObjectsFolderName)
+	files, err := os.ReadDir(objectsFolderName)
 	if err != nil {
 		klog.Errorf("error while reading directory, err: %v", err)
 		return err
@@ -382,50 +333,50 @@ func verifyObjectsCopied(spec []pkg.Spec) error {
 }
 
 // Create necessary resources to run the sync command
-func createResources(spec []pkg.Spec) error {
+func createResources(spec []pkg.Spec) ([]string, error) {
 	klog.V(4).Info("STEP: Create resources")
-	err := createSpecFile(spec)
-	if err != nil {
-		return err
+	cosInstances := make([]string, 0)
+	if err := createSpecFile(spec); err != nil {
+		return nil, err
 	}
 
-	err = createObjects()
-	if err != nil {
-		return err
+	if err := createObjects(); err != nil {
+		return nil, err
 	}
 
 	for _, src := range spec {
-		err = createCOSInstance(src.Cos)
+		cosInstance, err := createCOSInstance(src.Cos)
+		cosInstances = append(cosInstances, cosInstance)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		err = createBucket(src.Bucket, src.Cos, src.Region, src.StorageClass)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		err = uploadObjects(src.Source)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		for _, tgt := range src.Target {
 			err = createBucket(tgt.Bucket, src.Cos, tgt.Region, tgt.StorageClass)
 			if err != nil {
-				return err
+				return nil, err
 			}
 		}
 	}
 
-	return nil
+	return cosInstances, nil
 }
 
 // Delete the resources
-func deleteResources(spec []pkg.Spec) error {
+func deleteResources(cosInstances []string) error {
 	klog.V(4).Info("STEP: Delete resources")
-	for _, src := range spec {
-		err := deleteCOSInstance(src.Cos)
+	for _, src := range cosInstances {
+		err := deleteCOSInstance(src)
 		if err != nil {
 			return err
 		}
@@ -440,27 +391,30 @@ func deleteResources(spec []pkg.Spec) error {
 }
 
 var _ = CMDDescribe("pvsadm image sync tests", func() {
-	var err error
-	bxCli, err = client.NewClientWithEnv(APIKey, client.DefaultEnv, debug)
-	Expect(err).To(BeNil())
+	BeforeEach(func() {
+		var err error
+		bxCli, err = client.NewClientWithEnv(APIKey, client.DefaultEnv, debug)
+		Expect(err).To(BeNil())
+	})
+
 	It("run with --help option", func() {
 		status, stdout, stderr := runSyncCMD(
 			"--help",
 		)
-		Expect(status).To(Equal(0))
-		Expect(stderr).To(Equal(""))
+		Expect(status).To(BeZero())
+		Expect(stderr).To(BeEmpty())
 		Expect(stdout).To(ContainSubstring("Examples:"))
 	})
 
 	framework.NegativeIt("run without spec-file flag", func() {
 		status, _, stderr := runSyncCMD()
-		Expect(status).NotTo(Equal(0))
+		Expect(status).NotTo(BeZero())
 		Expect(stderr).To(ContainSubstring(`"spec-file" not set`))
 	})
 
 	framework.NegativeIt("run with yaml file that doesn't exist", func() {
 		status, _, stderr := runSyncCMD("--spec-file", "fakefile.yaml")
-		Expect(status).NotTo(Equal(0))
+		Expect(status).NotTo(BeZero())
 		Expect(stderr).To(ContainSubstring(`no such file or directory`))
 	})
 
@@ -470,12 +424,12 @@ var _ = CMDDescribe("pvsadm image sync tests", func() {
 			specSlice = append(specSlice, utils.GenerateSpec(NoOfTargetsPerSource))
 		}
 
-		err := createResources(specSlice)
+		instances, err := createResources(specSlice)
 		Expect(err).NotTo(HaveOccurred())
-		defer deleteResources(specSlice)
+		defer deleteResources(instances)
 
 		status, _, _ := runSyncCMD("--spec-file", SpecFileName)
-		Expect(status).To(Equal(0))
+		Expect(status).To(BeZero())
 
 		err = verifyObjectsCopied(specSlice)
 		Expect(err).NotTo(HaveOccurred())