From d1c508e24aca796748e745987c7ccc55e746dcec Mon Sep 17 00:00:00 2001 From: Kaloyan Raev Date: Mon, 20 Aug 2018 20:55:39 +0300 Subject: [PATCH] Avoid logging any minio error in miniogw logging wrapper (#240) --- pkg/miniogw/logging/logging.go | 88 +++++----- pkg/miniogw/logging/logging_test.go | 244 ++++++++++++++++++++++++---- 2 files changed, 255 insertions(+), 77 deletions(-) diff --git a/pkg/miniogw/logging/logging.go b/pkg/miniogw/logging/logging.go index b379cd6ff..aaac034f4 100644 --- a/pkg/miniogw/logging/logging.go +++ b/pkg/miniogw/logging/logging.go @@ -6,6 +6,7 @@ package logging import ( context "context" io "io" + "reflect" "time" minio "github.com/minio/minio/cmd" @@ -41,20 +42,27 @@ type olLogWrap struct { logger ErrorLogger } -// ErrorLogger logs a templated error message +// ErrorLogger logs a templated error message. type ErrorLogger interface { Errorf(template string, args ...interface{}) } -func (ol *olLogWrap) wrap(err error) error { - if err != nil { +// minioError checks if the given error is a minio error. +func minioError(err error) bool { + return reflect.TypeOf(err).ConvertibleTo(reflect.TypeOf(minio.GenericError{})) +} + +// log unexpected errors, i.e. non-minio errors. It will return the given error +// to allow method chaining. +func (ol *olLogWrap) log(err error) error { + if err != nil && !minioError(err) { ol.logger.Errorf(errTemplate, err) } return err } func (ol *olLogWrap) Shutdown(ctx context.Context) error { - return ol.wrap(ol.ol.Shutdown(ctx)) + return ol.log(ol.ol.Shutdown(ctx)) } func (ol *olLogWrap) StorageInfo(ctx context.Context) minio.StorageInfo { @@ -63,34 +71,23 @@ func (ol *olLogWrap) StorageInfo(ctx context.Context) minio.StorageInfo { func (ol *olLogWrap) MakeBucketWithLocation(ctx context.Context, bucket string, location string) error { - err := ol.ol.MakeBucketWithLocation(ctx, bucket, location) - if _, ok := err.(minio.BucketAlreadyExists); ok { - return err - } - return ol.wrap(err) + return ol.log(ol.ol.MakeBucketWithLocation(ctx, bucket, location)) } func (ol *olLogWrap) GetBucketInfo(ctx context.Context, bucket string) ( bucketInfo minio.BucketInfo, err error) { bucketInfo, err = ol.ol.GetBucketInfo(ctx, bucket) - return bucketInfo, ol.wrap(err) + return bucketInfo, ol.log(err) } func (ol *olLogWrap) ListBuckets(ctx context.Context) ( buckets []minio.BucketInfo, err error) { buckets, err = ol.ol.ListBuckets(ctx) - return buckets, ol.wrap(err) + return buckets, ol.log(err) } func (ol *olLogWrap) DeleteBucket(ctx context.Context, bucket string) error { - err := ol.ol.DeleteBucket(ctx, bucket) - if _, ok := err.(minio.BucketNotEmpty); ok { - return err - } - if _, ok := err.(minio.BucketNotFound); ok { - return err - } - return ol.wrap(err) + return ol.log(ol.ol.DeleteBucket(ctx, bucket)) } func (ol *olLogWrap) ListObjects(ctx context.Context, @@ -98,7 +95,7 @@ func (ol *olLogWrap) ListObjects(ctx context.Context, result minio.ListObjectsInfo, err error) { result, err = ol.ol.ListObjects(ctx, bucket, prefix, marker, delimiter, maxKeys) - return result, ol.wrap(err) + return result, ol.log(err) } func (ol *olLogWrap) ListObjectsV2(ctx context.Context, @@ -107,29 +104,26 @@ func (ol *olLogWrap) ListObjectsV2(ctx context.Context, err error) { result, err = ol.ol.ListObjectsV2(ctx, bucket, prefix, continuationToken, delimiter, maxKeys, fetchOwner, startAfter) - return result, ol.wrap(err) + return result, ol.log(err) } func (ol *olLogWrap) GetObject(ctx context.Context, bucket, object string, startOffset int64, length int64, writer io.Writer, etag string) (err error) { - return ol.wrap(ol.ol.GetObject(ctx, bucket, object, startOffset, length, + return ol.log(ol.ol.GetObject(ctx, bucket, object, startOffset, length, writer, etag)) } func (ol *olLogWrap) GetObjectInfo(ctx context.Context, bucket, object string) ( objInfo minio.ObjectInfo, err error) { objInfo, err = ol.ol.GetObjectInfo(ctx, bucket, object) - if _, ok := err.(minio.ObjectNotFound); ok { - return objInfo, err - } - return objInfo, ol.wrap(err) + return objInfo, ol.log(err) } func (ol *olLogWrap) PutObject(ctx context.Context, bucket, object string, data *hash.Reader, metadata map[string]string) (objInfo minio.ObjectInfo, err error) { objInfo, err = ol.ol.PutObject(ctx, bucket, object, data, metadata) - return objInfo, ol.wrap(err) + return objInfo, ol.log(err) } func (ol *olLogWrap) CopyObject(ctx context.Context, @@ -137,12 +131,12 @@ func (ol *olLogWrap) CopyObject(ctx context.Context, srcInfo minio.ObjectInfo) (objInfo minio.ObjectInfo, err error) { objInfo, err = ol.ol.CopyObject(ctx, srcBucket, srcObject, destBucket, destObject, srcInfo) - return objInfo, ol.wrap(err) + return objInfo, ol.log(err) } func (ol *olLogWrap) DeleteObject(ctx context.Context, bucket, object string) ( err error) { - return ol.wrap(ol.ol.DeleteObject(ctx, bucket, object)) + return ol.log(ol.ol.DeleteObject(ctx, bucket, object)) } func (ol *olLogWrap) ListMultipartUploads(ctx context.Context, @@ -150,14 +144,14 @@ func (ol *olLogWrap) ListMultipartUploads(ctx context.Context, result minio.ListMultipartsInfo, err error) { result, err = ol.ol.ListMultipartUploads(ctx, bucket, prefix, keyMarker, uploadIDMarker, delimiter, maxUploads) - return result, ol.wrap(err) + return result, ol.log(err) } func (ol *olLogWrap) NewMultipartUpload(ctx context.Context, bucket, object string, metadata map[string]string) (uploadID string, err error) { uploadID, err = ol.ol.NewMultipartUpload(ctx, bucket, object, metadata) - return uploadID, ol.wrap(err) + return uploadID, ol.log(err) } func (ol *olLogWrap) CopyObjectPart(ctx context.Context, @@ -166,14 +160,14 @@ func (ol *olLogWrap) CopyObjectPart(ctx context.Context, info minio.PartInfo, err error) { info, err = ol.ol.CopyObjectPart(ctx, srcBucket, srcObject, destBucket, destObject, uploadID, partID, startOffset, length, srcInfo) - return info, ol.wrap(err) + return info, ol.log(err) } func (ol *olLogWrap) PutObjectPart(ctx context.Context, bucket, object, uploadID string, partID int, data *hash.Reader) ( info minio.PartInfo, err error) { info, err = ol.ol.PutObjectPart(ctx, bucket, object, uploadID, partID, data) - return info, ol.wrap(err) + return info, ol.log(err) } func (ol *olLogWrap) ListObjectParts(ctx context.Context, @@ -181,12 +175,12 @@ func (ol *olLogWrap) ListObjectParts(ctx context.Context, result minio.ListPartsInfo, err error) { result, err = ol.ol.ListObjectParts(ctx, bucket, object, uploadID, partNumberMarker, maxParts) - return result, ol.wrap(err) + return result, ol.log(err) } func (ol *olLogWrap) AbortMultipartUpload(ctx context.Context, bucket, object, uploadID string) error { - return ol.wrap(ol.ol.AbortMultipartUpload(ctx, bucket, object, uploadID)) + return ol.log(ol.ol.AbortMultipartUpload(ctx, bucket, object, uploadID)) } func (ol *olLogWrap) CompleteMultipartUpload(ctx context.Context, @@ -194,35 +188,35 @@ func (ol *olLogWrap) CompleteMultipartUpload(ctx context.Context, objInfo minio.ObjectInfo, err error) { objInfo, err = ol.ol.CompleteMultipartUpload(ctx, bucket, object, uploadID, uploadedParts) - return objInfo, ol.wrap(err) + return objInfo, ol.log(err) } func (ol *olLogWrap) ReloadFormat(ctx context.Context, dryRun bool) error { - return ol.wrap(ol.ol.ReloadFormat(ctx, dryRun)) + return ol.log(ol.ol.ReloadFormat(ctx, dryRun)) } func (ol *olLogWrap) HealFormat(ctx context.Context, dryRun bool) ( madmin.HealResultItem, error) { rv, err := ol.ol.HealFormat(ctx, dryRun) - return rv, ol.wrap(err) + return rv, ol.log(err) } func (ol *olLogWrap) HealBucket(ctx context.Context, bucket string, dryRun bool) ([]madmin.HealResultItem, error) { rv, err := ol.ol.HealBucket(ctx, bucket, dryRun) - return rv, ol.wrap(err) + return rv, ol.log(err) } func (ol *olLogWrap) HealObject(ctx context.Context, bucket, object string, dryRun bool) (madmin.HealResultItem, error) { rv, err := ol.ol.HealObject(ctx, bucket, object, dryRun) - return rv, ol.wrap(err) + return rv, ol.log(err) } func (ol *olLogWrap) ListBucketsHeal(ctx context.Context) ( buckets []minio.BucketInfo, err error) { buckets, err = ol.ol.ListBucketsHeal(ctx) - return buckets, ol.wrap(err) + return buckets, ol.log(err) } func (ol *olLogWrap) ListObjectsHeal(ctx context.Context, @@ -230,33 +224,33 @@ func (ol *olLogWrap) ListObjectsHeal(ctx context.Context, minio.ListObjectsInfo, error) { rv, err := ol.ol.ListObjectsHeal(ctx, bucket, prefix, marker, delimiter, maxKeys) - return rv, ol.wrap(err) + return rv, ol.log(err) } func (ol *olLogWrap) ListLocks(ctx context.Context, bucket, prefix string, duration time.Duration) ([]minio.VolumeLockInfo, error) { rv, err := ol.ol.ListLocks(ctx, bucket, prefix, duration) - return rv, ol.wrap(err) + return rv, ol.log(err) } func (ol *olLogWrap) ClearLocks(ctx context.Context, lockInfos []minio.VolumeLockInfo) error { - return ol.wrap(ol.ol.ClearLocks(ctx, lockInfos)) + return ol.log(ol.ol.ClearLocks(ctx, lockInfos)) } func (ol *olLogWrap) SetBucketPolicy(ctx context.Context, n string, p *policy.Policy) error { - return ol.wrap(ol.ol.SetBucketPolicy(ctx, n, p)) + return ol.log(ol.ol.SetBucketPolicy(ctx, n, p)) } func (ol *olLogWrap) GetBucketPolicy(ctx context.Context, n string) ( *policy.Policy, error) { p, err := ol.ol.GetBucketPolicy(ctx, n) - return p, ol.wrap(err) + return p, ol.log(err) } func (ol *olLogWrap) DeleteBucketPolicy(ctx context.Context, n string) error { - return ol.wrap(ol.ol.DeleteBucketPolicy(ctx, n)) + return ol.log(ol.ol.DeleteBucketPolicy(ctx, n)) } func (ol *olLogWrap) IsNotificationSupported() bool { diff --git a/pkg/miniogw/logging/logging_test.go b/pkg/miniogw/logging/logging_test.go index 1d9f6d146..e6f3a89f8 100644 --- a/pkg/miniogw/logging/logging_test.go +++ b/pkg/miniogw/logging/logging_test.go @@ -45,6 +45,7 @@ const ( var ( ctx = context.Background() ErrTest = errors.New(testError) + ErrMinio = minio.BucketNotFound{} metadata = map[string]string{"key": "value"} ) @@ -115,7 +116,12 @@ func TestShutdown(t *testing.T) { mol.EXPECT().Shutdown(ctx).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.Shutdown(ctx) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().Shutdown(ctx).Return(ErrMinio) + err = ol.Shutdown(ctx) + assert.Error(t, err, ErrMinio.Error()) } func TestStorageInfo(t *testing.T) { @@ -147,7 +153,12 @@ func TestMakeBucketWithLocation(t *testing.T) { mol.EXPECT().MakeBucketWithLocation(ctx, bucket, location).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.MakeBucketWithLocation(ctx, bucket, location) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().MakeBucketWithLocation(ctx, bucket, location).Return(ErrMinio) + err = ol.MakeBucketWithLocation(ctx, bucket, location) + assert.Error(t, err, ErrMinio.Error()) } func TestGetBucketInfo(t *testing.T) { @@ -166,7 +177,13 @@ func TestGetBucketInfo(t *testing.T) { mol.EXPECT().GetBucketInfo(ctx, bucket).Return(minio.BucketInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.GetBucketInfo(ctx, bucket) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.BucketInfo{}, info) + + // Minio error returned + mol.EXPECT().GetBucketInfo(ctx, bucket).Return(minio.BucketInfo{}, ErrMinio) + info, err = ol.GetBucketInfo(ctx, bucket) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.BucketInfo{}, info) } @@ -186,7 +203,13 @@ func TestListBuckets(t *testing.T) { mol.EXPECT().ListBuckets(ctx).Return([]minio.BucketInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListBuckets(ctx) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, []minio.BucketInfo{}, list) + + // Minio error returned + mol.EXPECT().ListBuckets(ctx).Return([]minio.BucketInfo{}, ErrMinio) + list, err = ol.ListBuckets(ctx) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, []minio.BucketInfo{}, list) } @@ -205,7 +228,12 @@ func TestDeleteBucket(t *testing.T) { mol.EXPECT().DeleteBucket(ctx, bucket).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.DeleteBucket(ctx, bucket) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().DeleteBucket(ctx, bucket).Return(ErrMinio) + err = ol.DeleteBucket(ctx, bucket) + assert.Error(t, err, ErrMinio.Error()) } func TestListObjects(t *testing.T) { @@ -226,7 +254,14 @@ func TestListObjects(t *testing.T) { Return(minio.ListObjectsInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListObjects(ctx, bucket, prefix, marker, delimiter, maxKeys) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ListObjectsInfo{}, list) + + // Minio error returned + mol.EXPECT().ListObjects(ctx, bucket, prefix, marker, delimiter, maxKeys). + Return(minio.ListObjectsInfo{}, ErrMinio) + list, err = ol.ListObjects(ctx, bucket, prefix, marker, delimiter, maxKeys) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ListObjectsInfo{}, list) } @@ -254,7 +289,15 @@ func TestListObjectsV2(t *testing.T) { logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListObjectsV2(ctx, bucket, prefix, marker, delimiter, maxKeys, owner, startAfter) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ListObjectsV2Info{}, list) + + // Minio error returned + mol.EXPECT().ListObjectsV2(ctx, bucket, prefix, marker, delimiter, maxKeys, + owner, startAfter).Return(minio.ListObjectsV2Info{}, ErrMinio) + list, err = ol.ListObjectsV2(ctx, bucket, prefix, marker, delimiter, + maxKeys, owner, startAfter) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ListObjectsV2Info{}, list) } @@ -276,7 +319,12 @@ func TestGetObject(t *testing.T) { mol.EXPECT().GetObject(ctx, bucket, object, offset, length, w, etag).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.GetObject(ctx, bucket, object, offset, length, w, etag) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().GetObject(ctx, bucket, object, offset, length, w, etag).Return(ErrMinio) + err = ol.GetObject(ctx, bucket, object, offset, length, w, etag) + assert.Error(t, err, ErrMinio.Error()) } func TestGetObjectInfo(t *testing.T) { @@ -295,7 +343,13 @@ func TestGetObjectInfo(t *testing.T) { mol.EXPECT().GetObjectInfo(ctx, bucket, object).Return(minio.ObjectInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.GetObjectInfo(ctx, bucket, object) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ObjectInfo{}, info) + + // Minio error returned + mol.EXPECT().GetObjectInfo(ctx, bucket, object).Return(minio.ObjectInfo{}, ErrMinio) + info, err = ol.GetObjectInfo(ctx, bucket, object) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ObjectInfo{}, info) } @@ -317,7 +371,13 @@ func TestPutObject(t *testing.T) { mol.EXPECT().PutObject(ctx, bucket, object, data, metadata).Return(minio.ObjectInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.PutObject(ctx, bucket, object, data, metadata) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ObjectInfo{}, info) + + // Minio error returned + mol.EXPECT().PutObject(ctx, bucket, object, data, metadata).Return(minio.ObjectInfo{}, ErrMinio) + info, err = ol.PutObject(ctx, bucket, object, data, metadata) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ObjectInfo{}, info) } @@ -339,7 +399,14 @@ func TestCopyObject(t *testing.T) { Return(minio.ObjectInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.CopyObject(ctx, bucket, object, destBucket, destObject, objInfo) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ObjectInfo{}, info) + + // Minio error returned + mol.EXPECT().CopyObject(ctx, bucket, object, destBucket, destObject, objInfo). + Return(minio.ObjectInfo{}, ErrMinio) + info, err = ol.CopyObject(ctx, bucket, object, destBucket, destObject, objInfo) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ObjectInfo{}, info) } @@ -358,7 +425,12 @@ func TestDeleteObject(t *testing.T) { mol.EXPECT().DeleteObject(ctx, bucket, object).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.DeleteObject(ctx, bucket, object) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().DeleteObject(ctx, bucket, object).Return(ErrMinio) + err = ol.DeleteObject(ctx, bucket, object) + assert.Error(t, err, ErrMinio.Error()) } func TestListMultipartUploads(t *testing.T) { @@ -385,7 +457,15 @@ func TestListMultipartUploads(t *testing.T) { logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListMultipartUploads(ctx, bucket, prefix, marker, uidMarker, delimiter, maxKeys) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ListMultipartsInfo{}, list) + + // Minio error returned + mol.EXPECT().ListMultipartUploads(ctx, bucket, prefix, marker, uidMarker, + delimiter, maxKeys).Return(minio.ListMultipartsInfo{}, ErrMinio) + list, err = ol.ListMultipartUploads(ctx, bucket, prefix, marker, uidMarker, + delimiter, maxKeys) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ListMultipartsInfo{}, list) } @@ -405,7 +485,13 @@ func TestNewMultipartUpload(t *testing.T) { mol.EXPECT().NewMultipartUpload(ctx, bucket, object, metadata).Return("", ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) id, err = ol.NewMultipartUpload(ctx, bucket, object, metadata) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, "", id) + + // Minio error returned + mol.EXPECT().NewMultipartUpload(ctx, bucket, object, metadata).Return("", ErrMinio) + id, err = ol.NewMultipartUpload(ctx, bucket, object, metadata) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, "", id) } @@ -429,7 +515,15 @@ func TestCopyObjectPart(t *testing.T) { logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.CopyObjectPart(ctx, bucket, object, destBucket, destObject, uploadID, partID, offset, length, objInfo) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.PartInfo{}, info) + + // Minio error returned + mol.EXPECT().CopyObjectPart(ctx, bucket, object, destBucket, destObject, + uploadID, partID, offset, length, objInfo).Return(minio.PartInfo{}, ErrMinio) + info, err = ol.CopyObjectPart(ctx, bucket, object, destBucket, destObject, + uploadID, partID, offset, length, objInfo) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.PartInfo{}, info) } @@ -453,7 +547,14 @@ func TestPutObjectPart(t *testing.T) { Return(minio.PartInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.PutObjectPart(ctx, bucket, object, uploadID, partID, data) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.PartInfo{}, info) + + // Minio error returned + mol.EXPECT().PutObjectPart(ctx, bucket, object, uploadID, partID, data). + Return(minio.PartInfo{}, ErrMinio) + info, err = ol.PutObjectPart(ctx, bucket, object, uploadID, partID, data) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.PartInfo{}, info) } @@ -475,7 +576,14 @@ func TestListObjectParts(t *testing.T) { Return(minio.ListPartsInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListObjectParts(ctx, bucket, object, uploadID, partMarker, maxKeys) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ListPartsInfo{}, list) + + // Minio error returned + mol.EXPECT().ListObjectParts(ctx, bucket, object, uploadID, partMarker, maxKeys). + Return(minio.ListPartsInfo{}, ErrMinio) + list, err = ol.ListObjectParts(ctx, bucket, object, uploadID, partMarker, maxKeys) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ListPartsInfo{}, list) } @@ -494,7 +602,12 @@ func TestAbortMultipartUpload(t *testing.T) { mol.EXPECT().AbortMultipartUpload(ctx, bucket, object, uploadID).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.AbortMultipartUpload(ctx, bucket, object, uploadID) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().AbortMultipartUpload(ctx, bucket, object, uploadID).Return(ErrMinio) + err = ol.AbortMultipartUpload(ctx, bucket, object, uploadID) + assert.Error(t, err, ErrMinio.Error()) } func TestCompleteMultipartUpload(t *testing.T) { @@ -517,7 +630,14 @@ func TestCompleteMultipartUpload(t *testing.T) { Return(minio.ObjectInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) info, err = ol.CompleteMultipartUpload(ctx, bucket, object, uploadID, parts) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ObjectInfo{}, info) + + // Minio error returned + mol.EXPECT().CompleteMultipartUpload(ctx, bucket, object, uploadID, parts). + Return(minio.ObjectInfo{}, ErrMinio) + info, err = ol.CompleteMultipartUpload(ctx, bucket, object, uploadID, parts) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ObjectInfo{}, info) } @@ -536,7 +656,12 @@ func TestReloadFormat(t *testing.T) { mol.EXPECT().ReloadFormat(ctx, dryRun).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.ReloadFormat(ctx, dryRun) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().ReloadFormat(ctx, dryRun).Return(ErrMinio) + err = ol.ReloadFormat(ctx, dryRun) + assert.Error(t, err, ErrMinio.Error()) } func TestHealFormat(t *testing.T) { @@ -555,7 +680,13 @@ func TestHealFormat(t *testing.T) { mol.EXPECT().HealFormat(ctx, dryRun).Return(madmin.HealResultItem{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) item, err = ol.HealFormat(ctx, dryRun) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, madmin.HealResultItem{}, item) + + // Minio error returned + mol.EXPECT().HealFormat(ctx, dryRun).Return(madmin.HealResultItem{}, ErrMinio) + item, err = ol.HealFormat(ctx, dryRun) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, madmin.HealResultItem{}, item) } @@ -575,7 +706,13 @@ func TestHealBucket(t *testing.T) { mol.EXPECT().HealBucket(ctx, bucket, dryRun).Return([]madmin.HealResultItem{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.HealBucket(ctx, bucket, dryRun) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, []madmin.HealResultItem{}, list) + + // Minio error returned + mol.EXPECT().HealBucket(ctx, bucket, dryRun).Return([]madmin.HealResultItem{}, ErrMinio) + list, err = ol.HealBucket(ctx, bucket, dryRun) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, []madmin.HealResultItem{}, list) } @@ -595,7 +732,13 @@ func TestHealObject(t *testing.T) { mol.EXPECT().HealObject(ctx, bucket, object, dryRun).Return(madmin.HealResultItem{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) item, err = ol.HealObject(ctx, bucket, object, dryRun) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, madmin.HealResultItem{}, item) + + // Minio error returned + mol.EXPECT().HealObject(ctx, bucket, object, dryRun).Return(madmin.HealResultItem{}, ErrMinio) + item, err = ol.HealObject(ctx, bucket, object, dryRun) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, madmin.HealResultItem{}, item) } @@ -615,7 +758,13 @@ func TestListBucketsHeal(t *testing.T) { mol.EXPECT().ListBucketsHeal(ctx).Return([]minio.BucketInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListBucketsHeal(ctx) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, []minio.BucketInfo{}, list) + + // Minio error returned + mol.EXPECT().ListBucketsHeal(ctx).Return([]minio.BucketInfo{}, ErrMinio) + list, err = ol.ListBucketsHeal(ctx) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, []minio.BucketInfo{}, list) } @@ -637,7 +786,14 @@ func TestListObjectsHeal(t *testing.T) { Return(minio.ListObjectsInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListObjectsHeal(ctx, bucket, prefix, marker, delimiter, maxKeys) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, minio.ListObjectsInfo{}, list) + + // Minio error returned + mol.EXPECT().ListObjectsHeal(ctx, bucket, prefix, marker, delimiter, maxKeys). + Return(minio.ListObjectsInfo{}, ErrMinio) + list, err = ol.ListObjectsHeal(ctx, bucket, prefix, marker, delimiter, maxKeys) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, minio.ListObjectsInfo{}, list) } @@ -658,7 +814,14 @@ func TestListLocks(t *testing.T) { Return([]minio.VolumeLockInfo{}, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) list, err = ol.ListLocks(ctx, bucket, prefix, duration) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Equal(t, []minio.VolumeLockInfo{}, list) + + // Minio error returned + mol.EXPECT().ListLocks(ctx, bucket, prefix, duration). + Return([]minio.VolumeLockInfo{}, ErrMinio) + list, err = ol.ListLocks(ctx, bucket, prefix, duration) + assert.Error(t, err, ErrMinio.Error()) assert.Equal(t, []minio.VolumeLockInfo{}, list) } @@ -677,7 +840,12 @@ func TestClearLocks(t *testing.T) { mol.EXPECT().ClearLocks(ctx, lockList).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.ClearLocks(ctx, lockList) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().ClearLocks(ctx, lockList).Return(ErrMinio) + err = ol.ClearLocks(ctx, lockList) + assert.Error(t, err, ErrMinio.Error()) } func TestSetBucketPolicy(t *testing.T) { @@ -695,7 +863,12 @@ func TestSetBucketPolicy(t *testing.T) { mol.EXPECT().SetBucketPolicy(ctx, n, plcy).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.SetBucketPolicy(ctx, n, plcy) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().SetBucketPolicy(ctx, n, plcy).Return(ErrMinio) + err = ol.SetBucketPolicy(ctx, n, plcy) + assert.Error(t, err, ErrMinio.Error()) } func TestGetBucketPolicy(t *testing.T) { @@ -714,7 +887,13 @@ func TestGetBucketPolicy(t *testing.T) { mol.EXPECT().GetBucketPolicy(ctx, n).Return(nil, ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) p, err = ol.GetBucketPolicy(ctx, n) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + assert.Nil(t, p) + + // Minio error returned + mol.EXPECT().GetBucketPolicy(ctx, n).Return(nil, ErrMinio) + p, err = ol.GetBucketPolicy(ctx, n) + assert.Error(t, err, ErrMinio.Error()) assert.Nil(t, p) } @@ -733,7 +912,12 @@ func TestDeleteBucketPolicy(t *testing.T) { mol.EXPECT().DeleteBucketPolicy(ctx, n).Return(ErrTest) logger.EXPECT().Errorf(errTemplate, ErrTest) err = ol.DeleteBucketPolicy(ctx, n) - assert.Error(t, err, testError) + assert.Error(t, err, ErrTest.Error()) + + // Minio error returned + mol.EXPECT().DeleteBucketPolicy(ctx, n).Return(ErrMinio) + err = ol.DeleteBucketPolicy(ctx, n) + assert.Error(t, err, ErrMinio.Error()) } func TestIsNotificationSupported(t *testing.T) {