JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Avoid logging any minio error in miniogw logging wrapper (#240)

Browse Source
This commit is contained in:
Kaloyan Raev 2018-08-20 20:55:39 +03:00 committed by JT Olio
parent 49577a47f8
commit d1c508e24a
2 changed files with 255 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
pkg/miniogw/logging/logging.go
View File

@ -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 {

244
pkg/miniogw/logging/logging_test.go
View File

@ -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) {