working tests

api/types/storage.go

@@ -18,6 +18,6 @@ type BucketOptions struct {
 
 type Object struct {
 	ObjectName string `json:"object_name,omitempty"`
-	BucketName string `json:"bucket_name,omitempty"`
+	Bucket     Bucket `json:"bucket,omitempty"`
 	FilePath   string `json:"file_path,omitempty"`
 }

storage/minio/bucket_exists_test.go

@@ -1,15 +1,3 @@
-//package minio
-//
-//import (
-//	"context"
-//	"net/http"
-//	"net/http/httptest"
-//	"testing"
-//
-//	api "github.com/go-vela/server/api/types"
-//)
-//
-
 package minio
 
 import (
@@ -19,7 +7,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
-	"time"
 )
 
 func TestMinioClient_BucketExists(t *testing.T) {
@@ -30,20 +17,30 @@ func TestMinioClient_BucketExists(t *testing.T) {
 	_, engine := gin.CreateTestContext(resp)
 
 	// setup mock server
+	// mock create bucket call
+	engine.PUT("/foo/", func(c *gin.Context) {
+		c.Header("Content-Type", "application/json")
+		c.Status(http.StatusOK)
+	})
+	// mock bucket exists call
 	engine.HEAD("/foo/", func(c *gin.Context) {
 		c.Status(http.StatusOK)
 	})
 
 	fake := httptest.NewServer(engine)
 	defer fake.Close()
 	ctx := context.TODO()
-	b := new(api.Bucket)
-	b.BucketName = "foo"
 
 	client, _ := NewTest(fake.URL, "miniokey", "miniosecret", false)
 
+	// create bucket
+	err := client.CreateBucket(ctx, &api.Bucket{BucketName: "foo"})
+	if err != nil {
+		t.Errorf("CreateBucket returned err: %v", err)
+	}
+
 	// run test
-	exists, err := client.BucketExists(ctx, b)
+	exists, err := client.BucketExists(ctx, &api.Bucket{BucketName: "foo"})
 	if resp.Code != http.StatusOK {
 		t.Errorf("BucketExists returned %v, want %v", resp.Code, http.StatusOK)
 	}
@@ -57,64 +54,35 @@ func TestMinioClient_BucketExists(t *testing.T) {
 	}
 }
 
-func TestMinioClient_BucketExists_Success(t *testing.T) {
+func TestMinioClient_BucketExists_Failure(t *testing.T) {
 	// setup context
-	//gin.SetMode(gin.TestMode)
-	//
-	//resp := httptest.NewRecorder()
-	//_, engine := gin.CreateTestContext(resp)
-	//
-	//// setup mock server
-	//engine.GET("/api/v3/orgs/:org", func(c *gin.Context) {
-	//	c.Header("Content-Type", "application/json")
-	//	c.Status(http.StatusOK)
-	//	c.File("testdata/get_org.json")
-	//})
-	//
-	//s := httptest.NewServer(engine)
-	//defer s.Close()
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Last-Modified", time.DateTime)
-		w.Header().Set("Content-Length", "5")
-
-		// Write less bytes than the content length.
-		w.Write([]byte("12345"))
-	}))
-	defer srv.Close()
-
-	//// New - instantiate minio client with options
-	//clnt, err := New(srv.Listener.Addr().String(), &Options{
-	//	Region: "us-east-1",
-	//})
-	//if err != nil {
-	//	t.Fatal(err)
-	//}
-	// setup types
-	u := new(api.Bucket)
-	u.BucketName = "foo"
-
-	//want := "minio"
-
-	client, err := New(srv.URL, WithAccessKey("accessKey"), WithSecretKey("secretKey"), WithSecure(false))
-	if err != nil {
-		t.Fatal(err)
-	}
+	gin.SetMode(gin.TestMode)
+
+	resp := httptest.NewRecorder()
+	_, engine := gin.CreateTestContext(resp)
+
+	// setup mock server
+	engine.HEAD("/foo/", func(c *gin.Context) {
+		c.Status(http.StatusOK)
+	})
+
+	fake := httptest.NewServer(engine)
+	defer fake.Close()
+	ctx := context.TODO()
+
+	client, _ := NewTest(fake.URL, "miniokey", "miniosecret", false)
+
 	// run test
-	got, err := client.BucketExists(context.TODO(), u)
-	t.Logf("got: %v", got)
-	// We expect an error when reading back.
-	if got {
-		t.Errorf("BucketExists returned %v, want %v", got, false)
-		t.Errorf("BucketExists returned err: %v", err)
+	exists, err := client.BucketExists(ctx, &api.Bucket{BucketName: "bar"})
+	if resp.Code != http.StatusOK {
+		t.Errorf("BucketExists returned %v, want %v", resp.Code, http.StatusOK)
 	}
 
-	//
-	//if err != nil {
-	//	t.Errorf("GetOrgName returned err: %v", err)
-	//}
-	//
-	//if !reflect.DeepEqual(got, want) {
-	//	t.Errorf("GetOrgName is %v, want %v", got, want)
-	//}
+	if err != nil {
+		t.Errorf("BucketExists returned err: %v", err)
+	}
 
+	if exists {
+		t.Errorf("BucketExists returned %v, want %v", exists, false)
+	}
 }

storage/minio/delete.go

@@ -8,9 +8,9 @@ import (
 
 // Delete deletes an object in a bucket in MinIO.
 func (c *MinioClient) Delete(ctx context.Context, object *api.Object) error {
-	c.Logger.Tracef("deleting objectName: %s from bucketName: %s", object.ObjectName, object.BucketName)
+	c.Logger.Tracef("deleting objectName: %s from bucketName: %s", object.ObjectName, object.Bucket.BucketName)
 
-	err := c.client.RemoveObject(ctx, object.BucketName, object.ObjectName, minio.RemoveObjectOptions{})
+	err := c.client.RemoveObject(ctx, object.Bucket.BucketName, object.ObjectName, minio.RemoveObjectOptions{})
 	if err != nil {
 		return err
 	}

storage/minio/delete_bucket_test.go

@@ -0,0 +1,86 @@
+package minio
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	api "github.com/go-vela/server/api/types"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestMinioClient_Bucket_Delete_Success(t *testing.T) {
+	// setup context
+	gin.SetMode(gin.TestMode)
+
+	resp := httptest.NewRecorder()
+	_, engine := gin.CreateTestContext(resp)
+
+	// setup mock server
+	// mock create bucket call
+	engine.PUT("/foo/", func(c *gin.Context) {
+		c.Header("Content-Type", "application/json")
+		c.Status(http.StatusOK)
+	})
+
+	// mock delete bucket call
+	engine.DELETE("/foo/", func(c *gin.Context) {
+		c.Status(http.StatusOK)
+	})
+
+	fake := httptest.NewServer(engine)
+	defer fake.Close()
+	ctx := context.TODO()
+	b := new(api.Bucket)
+	b.BucketName = "foo"
+	client, _ := NewTest(fake.URL, "miniokey", "miniosecret", false)
+
+	// create bucket
+	err := client.CreateBucket(ctx, b)
+	if err != nil {
+		t.Errorf("CreateBucket returned err: %v", err)
+	}
+
+	// run test
+	err = client.DeleteBucket(ctx, b)
+	if resp.Code != http.StatusOK {
+		t.Errorf("DeleteBucket returned %v, want %v", resp.Code, http.StatusOK)
+	}
+
+	// in Minio SDK, removeBucket returns status code 200 OK as error if a bucket is deleted successfully
+	if err != nil && err.Error() != "200 OK" {
+		t.Errorf("DeleteBucket returned err: %v", err)
+	}
+
+}
+
+func TestMinioClient_Bucket_Delete_BucketNotFound(t *testing.T) {
+	// setup context
+	gin.SetMode(gin.TestMode)
+
+	resp := httptest.NewRecorder()
+	_, engine := gin.CreateTestContext(resp)
+
+	// mock delete bucket call
+	engine.DELETE("/foo/", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "The specified bucket does not exist"})
+	})
+
+	fake := httptest.NewServer(engine)
+	defer fake.Close()
+	ctx := context.TODO()
+	b := new(api.Bucket)
+	b.BucketName = "foo"
+	client, _ := NewTest(fake.URL, "miniokey", "miniosecret", false)
+
+	// run test
+	err := client.DeleteBucket(ctx, b)
+	if resp.Code != http.StatusOK {
+		t.Errorf("DeleteBucket returned %v, want %v", resp.Code, http.StatusOK)
+	}
+
+	if err == nil {
+		t.Errorf("DeleteBucket expected error, got nil")
+	}
+
+}

storage/minio/download.go

@@ -32,25 +32,25 @@ func (c *MinioClient) Download(ctx context.Context, object *api.Object) error {
 	//
 	//c.Logger.Tracef("successfully downloaded object %s to %s", object.ObjectName, object.FilePath)
 	//return nil
-	logrus.Debugf("getting object info on bucket %s from path: %s", object.BucketName, object.ObjectName)
+	logrus.Debugf("getting object info on bucket %s from path: %s", object.Bucket.BucketName, object.ObjectName)
 
 	// set a timeout on the request to the cache provider
 	//ctx, cancel := context.WithTimeout(context.Background(), r.Timeout)
 	//defer cancel()
 
 	// collect metadata on the object
-	objInfo, err := c.client.StatObject(ctx, object.BucketName, object.ObjectName, minio.StatObjectOptions{})
+	objInfo, err := c.client.StatObject(ctx, object.Bucket.BucketName, object.ObjectName, minio.StatObjectOptions{})
 	if objInfo.Key == "" {
 		logrus.Error(err)
 		return nil
 	}
 
-	logrus.Debugf("getting object in bucket %s from path: %s", object.BucketName, object.ObjectName)
+	logrus.Debugf("getting object in bucket %s from path: %s", object.Bucket.BucketName, object.ObjectName)
 
 	logrus.Infof("%s to download", humanize.Bytes(uint64(objInfo.Size)))
 
 	// retrieve the object in specified path of the bucket
-	err = c.client.FGetObject(ctx, object.BucketName, object.ObjectName, filename, minio.GetObjectOptions{})
+	err = c.client.FGetObject(ctx, object.Bucket.BucketName, object.ObjectName, filename, minio.GetObjectOptions{})
 	if err != nil {
 		return err
 	}

storage/minio/presigned_get_object.go

@@ -11,23 +11,23 @@ import (
 // TODO hide URL behind a different name
 // PresignedGetObject generates a presigned URL for downloading an object.
 func (c *MinioClient) PresignedGetObject(ctx context.Context, object *api.Object) (string, error) {
-	c.Logger.Tracef("generating presigned URL for object %s in bucket %s", object.ObjectName, object.BucketName)
+	c.Logger.Tracef("generating presigned URL for object %s in bucket %s", object.ObjectName, object.Bucket.BucketName)
 
 	// collect metadata on the object
-	objInfo, err := c.client.StatObject(ctx, object.BucketName, object.ObjectName, minio.StatObjectOptions{})
+	objInfo, err := c.client.StatObject(ctx, object.Bucket.BucketName, object.ObjectName, minio.StatObjectOptions{})
 	if objInfo.Key == "" {
-		logrus.Errorf("unable to get object info %s from bucket %s: %v", object.ObjectName, object.BucketName, err)
+		logrus.Errorf("unable to get object info %s from bucket %s: %v", object.ObjectName, object.Bucket.BucketName, err)
 		return "", err
 	}
 
-	_, err = c.client.BucketExists(ctx, object.BucketName)
+	_, err = c.client.BucketExists(ctx, object.Bucket.BucketName)
 	if err != nil {
-		logrus.Errorf("unable to check if bucket %s exists: %v", object.BucketName, err)
+		logrus.Errorf("unable to check if bucket %s exists: %v", object.Bucket.BucketName, err)
 		return "", err
 	}
 	// Generate presigned URL for downloading the object.
 	// The URL is valid for 7 days.
-	presignedURL, err := c.client.PresignedGetObject(ctx, object.BucketName, object.ObjectName, 7*24*time.Hour, nil)
+	presignedURL, err := c.client.PresignedGetObject(ctx, object.Bucket.BucketName, object.ObjectName, 7*24*time.Hour, nil)
 	if err != nil {
 		return "", err
 	}

storage/minio/stat_object.go

@@ -9,12 +9,12 @@ import (
 
 // StatObject retrieves the metadata of an object from the MinIO storage.
 func (c *MinioClient) StatObject(ctx context.Context, object *types.Object) (*types.Object, error) {
-	c.Logger.Tracef("retrieving metadata for object %s from bucket %s", object.ObjectName, object.BucketName)
+	c.Logger.Tracef("retrieving metadata for object %s from bucket %s", object.ObjectName, object.Bucket.BucketName)
 
 	// Get object info
-	info, err := c.client.StatObject(ctx, object.BucketName, object.ObjectName, minio.StatObjectOptions{})
+	info, err := c.client.StatObject(ctx, object.Bucket.BucketName, object.ObjectName, minio.StatObjectOptions{})
 	if err != nil {
-		return nil, fmt.Errorf("unable to get object info %s from bucket %s: %v", object.ObjectName, object.BucketName, err)
+		return nil, fmt.Errorf("unable to get object info %s from bucket %s: %v", object.ObjectName, object.Bucket.BucketName, err)
 	}
 
 	// Map MinIO object info to API object

storage/minio/upload.go

@@ -8,7 +8,7 @@ import (
 
 // Upload uploads an object to a bucket in MinIO.ts
 func (c *MinioClient) Upload(ctx context.Context, object *api.Object) error {
-	c.Logger.Tracef("uploading data to bucket %s", object.BucketName)
-	_, err := c.client.FPutObject(ctx, object.BucketName, object.ObjectName, object.FilePath, minio.PutObjectOptions{})
+	c.Logger.Tracef("uploading data to bucket %s", object.Bucket.BucketName)
+	_, err := c.client.FPutObject(ctx, object.Bucket.BucketName, object.ObjectName, object.FilePath, minio.PutObjectOptions{})
 	return err
 }