You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
484 lines
19 KiB
484 lines
19 KiB
/*
|
|
* Minio Cloud Storage, (C) 2015, 2016 Minio, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"io"
|
|
"math/rand"
|
|
"strconv"
|
|
|
|
"gopkg.in/check.v1"
|
|
)
|
|
|
|
// Return pointer to testOneByteReadEOF{}
|
|
func newTestReaderEOF(data []byte) io.Reader {
|
|
return &testOneByteReadEOF{false, data}
|
|
}
|
|
|
|
// OneByteReadEOF - implements io.Reader which returns 1 byte along with io.EOF error.
|
|
type testOneByteReadEOF struct {
|
|
eof bool
|
|
data []byte
|
|
}
|
|
|
|
func (r *testOneByteReadEOF) Read(p []byte) (n int, err error) {
|
|
if r.eof {
|
|
return 0, io.EOF
|
|
}
|
|
n = copy(p, r.data)
|
|
r.eof = true
|
|
return n, io.EOF
|
|
}
|
|
|
|
// Return pointer to testOneByteReadNoEOF{}
|
|
func newTestReaderNoEOF(data []byte) io.Reader {
|
|
return &testOneByteReadNoEOF{false, data}
|
|
}
|
|
|
|
// testOneByteReadNoEOF - implements io.Reader which returns 1 byte and nil error, but
|
|
// returns io.EOF on the next Read().
|
|
type testOneByteReadNoEOF struct {
|
|
eof bool
|
|
data []byte
|
|
}
|
|
|
|
func (r *testOneByteReadNoEOF) Read(p []byte) (n int, err error) {
|
|
if r.eof {
|
|
return 0, io.EOF
|
|
}
|
|
n = copy(p, r.data)
|
|
r.eof = true
|
|
return n, nil
|
|
}
|
|
|
|
// APITestSuite - collection of API tests.
|
|
func APITestSuite(c *check.C, execObjLayerSuiteTest func(objSuiteTest objSuiteTestType)) {
|
|
// List containing collection of all tests.
|
|
testFuncList := []func(c *check.C, obj ObjectLayer){
|
|
testMakeBucket,
|
|
testMultipartObjectCreation,
|
|
testPaging,
|
|
testObjectOverwriteWorks,
|
|
testNonExistantBucketOperations,
|
|
testBucketRecreateFails,
|
|
testPutObject,
|
|
testPutObjectInSubdir,
|
|
testListBuckets,
|
|
testListBucketsOrder,
|
|
testListObjectsTestsForNonExistantBucket,
|
|
testNonExistantObjectInBucket,
|
|
testGetDirectoryReturnsObjectNotFound,
|
|
testContentType,
|
|
testMultipartObjectAbort,
|
|
}
|
|
// iterate over list of tests and execute them.
|
|
for _, testFunc := range testFuncList {
|
|
execObjLayerSuiteTest(testFunc)
|
|
}
|
|
}
|
|
|
|
// Tests validate bucket creation.
|
|
func testMakeBucket(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket-unknown")
|
|
c.Assert(err, check.IsNil)
|
|
}
|
|
|
|
// Tests validate creation of part files during Multipart operation.
|
|
func testMultipartObjectCreation(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
uploadID, err := obj.NewMultipartUpload("bucket", "key", nil)
|
|
c.Assert(err, check.IsNil)
|
|
// Create a byte array of 5MB.
|
|
data := bytes.Repeat([]byte("0123456789abcdef"), 5*1024*1024/16)
|
|
completedParts := completeMultipartUpload{}
|
|
for i := 1; i <= 10; i++ {
|
|
hasher := md5.New()
|
|
hasher.Write(data)
|
|
expectedMD5Sumhex := hex.EncodeToString(hasher.Sum(nil))
|
|
|
|
var calculatedMD5sum string
|
|
calculatedMD5sum, err = obj.PutObjectPart("bucket", "key", uploadID, i, int64(len(data)), bytes.NewBuffer(data), expectedMD5Sumhex)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(calculatedMD5sum, check.Equals, expectedMD5Sumhex)
|
|
completedParts.Parts = append(completedParts.Parts, completePart{PartNumber: i, ETag: calculatedMD5sum})
|
|
}
|
|
md5Sum, err := obj.CompleteMultipartUpload("bucket", "key", uploadID, completedParts.Parts)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(md5Sum, check.Equals, "7d364cb728ce42a74a96d22949beefb2-10")
|
|
}
|
|
|
|
// Tests validate abortion of Multipart operation.
|
|
func testMultipartObjectAbort(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
uploadID, err := obj.NewMultipartUpload("bucket", "key", nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
parts := make(map[int]string)
|
|
metadata := make(map[string]string)
|
|
for i := 1; i <= 10; i++ {
|
|
randomPerm := rand.Perm(10)
|
|
randomString := ""
|
|
for _, num := range randomPerm {
|
|
randomString = randomString + strconv.Itoa(num)
|
|
}
|
|
|
|
hasher := md5.New()
|
|
hasher.Write([]byte(randomString))
|
|
expectedMD5Sumhex := hex.EncodeToString(hasher.Sum(nil))
|
|
|
|
metadata["md5"] = expectedMD5Sumhex
|
|
var calculatedMD5sum string
|
|
calculatedMD5sum, err = obj.PutObjectPart("bucket", "key", uploadID, i, int64(len(randomString)), bytes.NewBufferString(randomString), expectedMD5Sumhex)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(calculatedMD5sum, check.Equals, expectedMD5Sumhex)
|
|
parts[i] = expectedMD5Sumhex
|
|
}
|
|
err = obj.AbortMultipartUpload("bucket", "key", uploadID)
|
|
c.Assert(err, check.IsNil)
|
|
}
|
|
|
|
// Tests validate object creation.
|
|
func testMultipleObjectCreation(c *check.C, obj ObjectLayer) {
|
|
objects := make(map[string][]byte)
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
for i := 0; i < 10; i++ {
|
|
randomPerm := rand.Perm(100)
|
|
randomString := ""
|
|
for _, num := range randomPerm {
|
|
randomString = randomString + strconv.Itoa(num)
|
|
}
|
|
|
|
hasher := md5.New()
|
|
hasher.Write([]byte(randomString))
|
|
expectedMD5Sumhex := hex.EncodeToString(hasher.Sum(nil))
|
|
|
|
key := "obj" + strconv.Itoa(i)
|
|
objects[key] = []byte(randomString)
|
|
metadata := make(map[string]string)
|
|
metadata["md5Sum"] = expectedMD5Sumhex
|
|
var md5Sum string
|
|
md5Sum, err = obj.PutObject("bucket", key, int64(len(randomString)), bytes.NewBufferString(randomString), metadata)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(md5Sum, check.Equals, expectedMD5Sumhex)
|
|
}
|
|
|
|
for key, value := range objects {
|
|
var byteBuffer bytes.Buffer
|
|
err = obj.GetObject("bucket", key, 0, int64(len(value)), &byteBuffer)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(byteBuffer.Bytes(), check.DeepEquals, value)
|
|
|
|
objInfo, err := obj.GetObjectInfo("bucket", key)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(objInfo.Size, check.Equals, int64(len(value)))
|
|
}
|
|
}
|
|
|
|
// Tests validate creation of objects and the order of listing using various filters for ListObjects operation.
|
|
func testPaging(c *check.C, obj ObjectLayer) {
|
|
obj.MakeBucket("bucket")
|
|
result, err := obj.ListObjects("bucket", "", "", "", 0)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(result.Objects), check.Equals, 0)
|
|
c.Assert(result.IsTruncated, check.Equals, false)
|
|
// check before paging occurs.
|
|
for i := 0; i < 5; i++ {
|
|
key := "obj" + strconv.Itoa(i)
|
|
_, err = obj.PutObject("bucket", key, int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
result, err = obj.ListObjects("bucket", "", "", "", 5)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(result.Objects), check.Equals, i+1)
|
|
c.Assert(result.IsTruncated, check.Equals, false)
|
|
}
|
|
// check after paging occurs pages work.
|
|
for i := 6; i <= 10; i++ {
|
|
key := "obj" + strconv.Itoa(i)
|
|
_, err = obj.PutObject("bucket", key, int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
result, err = obj.ListObjects("bucket", "obj", "", "", 5)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(result.Objects), check.Equals, 5)
|
|
c.Assert(result.IsTruncated, check.Equals, true)
|
|
}
|
|
// check paging with prefix at end returns less objects.
|
|
{
|
|
_, err = obj.PutObject("bucket", "newPrefix", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
_, err = obj.PutObject("bucket", "newPrefix2", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
result, err = obj.ListObjects("bucket", "new", "", "", 5)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(result.Objects), check.Equals, 2)
|
|
}
|
|
|
|
// check ordering of pages.
|
|
{
|
|
result, err = obj.ListObjects("bucket", "", "", "", 1000)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(result.Objects[0].Name, check.Equals, "newPrefix")
|
|
c.Assert(result.Objects[1].Name, check.Equals, "newPrefix2")
|
|
c.Assert(result.Objects[2].Name, check.Equals, "obj0")
|
|
c.Assert(result.Objects[3].Name, check.Equals, "obj1")
|
|
c.Assert(result.Objects[4].Name, check.Equals, "obj10")
|
|
}
|
|
|
|
// check delimited results with delimiter and prefix.
|
|
{
|
|
_, err = obj.PutObject("bucket", "this/is/delimited", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
_, err = obj.PutObject("bucket", "this/is/also/a/delimited/file", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
result, err = obj.ListObjects("bucket", "this/is/", "", "/", 10)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(result.Objects), check.Equals, 1)
|
|
c.Assert(result.Prefixes[0], check.Equals, "this/is/also/")
|
|
}
|
|
|
|
// check delimited results with delimiter without prefix.
|
|
{
|
|
result, err = obj.ListObjects("bucket", "", "", "/", 1000)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(result.Objects[0].Name, check.Equals, "newPrefix")
|
|
c.Assert(result.Objects[1].Name, check.Equals, "newPrefix2")
|
|
c.Assert(result.Objects[2].Name, check.Equals, "obj0")
|
|
c.Assert(result.Objects[3].Name, check.Equals, "obj1")
|
|
c.Assert(result.Objects[4].Name, check.Equals, "obj10")
|
|
c.Assert(result.Prefixes[0], check.Equals, "this/")
|
|
}
|
|
|
|
// check results with Marker.
|
|
{
|
|
|
|
result, err = obj.ListObjects("bucket", "", "newPrefix", "", 3)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(result.Objects[0].Name, check.Equals, "newPrefix2")
|
|
c.Assert(result.Objects[1].Name, check.Equals, "obj0")
|
|
c.Assert(result.Objects[2].Name, check.Equals, "obj1")
|
|
|
|
}
|
|
// check ordering of results with prefix.
|
|
{
|
|
result, err = obj.ListObjects("bucket", "obj", "", "", 1000)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(result.Objects[0].Name, check.Equals, "obj0")
|
|
c.Assert(result.Objects[1].Name, check.Equals, "obj1")
|
|
c.Assert(result.Objects[2].Name, check.Equals, "obj10")
|
|
c.Assert(result.Objects[3].Name, check.Equals, "obj2")
|
|
c.Assert(result.Objects[4].Name, check.Equals, "obj3")
|
|
}
|
|
// check ordering of results with prefix and no paging.
|
|
{
|
|
result, err = obj.ListObjects("bucket", "new", "", "", 5)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(result.Objects[0].Name, check.Equals, "newPrefix")
|
|
c.Assert(result.Objects[1].Name, check.Equals, "newPrefix2")
|
|
}
|
|
}
|
|
|
|
// Tests validate overwriting of an existing object.
|
|
func testObjectOverwriteWorks(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
_, err = obj.PutObject("bucket", "object", int64(len("The list of parts was not in ascending order. The parts list must be specified in order by part number.")), bytes.NewBufferString("The list of parts was not in ascending order. The parts list must be specified in order by part number."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
length := int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."))
|
|
_, err = obj.PutObject("bucket", "object", length, bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
var bytesBuffer bytes.Buffer
|
|
err = obj.GetObject("bucket", "object", 0, length, &bytesBuffer)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(string(bytesBuffer.Bytes()), check.Equals, "The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")
|
|
}
|
|
|
|
// Tests validate that bucket operation on non-existent bucket fails.
|
|
func testNonExistantBucketOperations(c *check.C, obj ObjectLayer) {
|
|
_, err := obj.PutObject("bucket1", "object", int64(len("one")), bytes.NewBufferString("one"), nil)
|
|
c.Assert(err, check.Not(check.IsNil))
|
|
c.Assert(err.Error(), check.Equals, "Bucket not found: bucket1")
|
|
}
|
|
|
|
// Tests validate that recreation of the bucket fails.
|
|
func testBucketRecreateFails(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("string")
|
|
c.Assert(err, check.IsNil)
|
|
err = obj.MakeBucket("string")
|
|
c.Assert(err, check.Not(check.IsNil))
|
|
c.Assert(err.Error(), check.Equals, "Bucket exists: string")
|
|
}
|
|
|
|
// Tests validate PutObject without prefix.
|
|
func testPutObject(c *check.C, obj ObjectLayer) {
|
|
content := []byte("testcontent")
|
|
length := int64(len(content))
|
|
readerEOF := newTestReaderEOF(content)
|
|
readerNoEOF := newTestReaderNoEOF(content)
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
var bytesBuffer1 bytes.Buffer
|
|
_, err = obj.PutObject("bucket", "object", length, readerEOF, nil)
|
|
c.Assert(err, check.IsNil)
|
|
err = obj.GetObject("bucket", "object", 0, length, &bytesBuffer1)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(bytesBuffer1.Bytes()), check.Equals, len(content))
|
|
|
|
var bytesBuffer2 bytes.Buffer
|
|
_, err = obj.PutObject("bucket", "object", length, readerNoEOF, nil)
|
|
c.Assert(err, check.IsNil)
|
|
err = obj.GetObject("bucket", "object", 0, length, &bytesBuffer2)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(bytesBuffer2.Bytes()), check.Equals, len(content))
|
|
}
|
|
|
|
// Tests validate PutObject with subdirectory prefix.
|
|
func testPutObjectInSubdir(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
length := int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."))
|
|
_, err = obj.PutObject("bucket", "dir1/dir2/object", length, bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
var bytesBuffer bytes.Buffer
|
|
err = obj.GetObject("bucket", "dir1/dir2/object", 0, length, &bytesBuffer)
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(bytesBuffer.Bytes()), check.Equals, len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."))
|
|
}
|
|
|
|
// Tests validate ListBuckets.
|
|
func testListBuckets(c *check.C, obj ObjectLayer) {
|
|
// test empty list.
|
|
buckets, err := obj.ListBuckets()
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(buckets), check.Equals, 0)
|
|
|
|
// add one and test exists.
|
|
err = obj.MakeBucket("bucket1")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
buckets, err = obj.ListBuckets()
|
|
c.Assert(len(buckets), check.Equals, 1)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
// add two and test exists.
|
|
err = obj.MakeBucket("bucket2")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
buckets, err = obj.ListBuckets()
|
|
c.Assert(len(buckets), check.Equals, 2)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
// add three and test exists + prefix.
|
|
err = obj.MakeBucket("bucket22")
|
|
|
|
buckets, err = obj.ListBuckets()
|
|
c.Assert(len(buckets), check.Equals, 3)
|
|
c.Assert(err, check.IsNil)
|
|
}
|
|
|
|
// Tests validate the order of result of ListBuckets.
|
|
func testListBucketsOrder(c *check.C, obj ObjectLayer) {
|
|
// if implementation contains a map, order of map keys will vary.
|
|
// this ensures they return in the same order each time.
|
|
// add one and test exists.
|
|
err := obj.MakeBucket("bucket1")
|
|
c.Assert(err, check.IsNil)
|
|
err = obj.MakeBucket("bucket2")
|
|
c.Assert(err, check.IsNil)
|
|
buckets, err := obj.ListBuckets()
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(len(buckets), check.Equals, 2)
|
|
c.Assert(buckets[0].Name, check.Equals, "bucket1")
|
|
c.Assert(buckets[1].Name, check.Equals, "bucket2")
|
|
}
|
|
|
|
// Tests validate that ListObjects operation on a non-existent bucket fails as expected.
|
|
func testListObjectsTestsForNonExistantBucket(c *check.C, obj ObjectLayer) {
|
|
result, err := obj.ListObjects("bucket", "", "", "", 1000)
|
|
c.Assert(err, check.Not(check.IsNil))
|
|
c.Assert(result.IsTruncated, check.Equals, false)
|
|
c.Assert(len(result.Objects), check.Equals, 0)
|
|
c.Assert(err.Error(), check.Equals, "Bucket not found: bucket")
|
|
}
|
|
|
|
// Tests validate that GetObject fails on a non-existent bucket as expected.
|
|
func testNonExistantObjectInBucket(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
_, err = obj.GetObjectInfo("bucket", "dir1")
|
|
c.Assert(err, check.Not(check.IsNil))
|
|
switch err := err.(type) {
|
|
case ObjectNotFound:
|
|
c.Assert(err, check.ErrorMatches, "Object not found: bucket#dir1")
|
|
default:
|
|
c.Assert(err, check.Equals, "fails")
|
|
}
|
|
}
|
|
|
|
// Tests validate that GetObject on an existing directory fails as expected.
|
|
func testGetDirectoryReturnsObjectNotFound(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
_, err = obj.PutObject("bucket", "dir1/dir3/object", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("One or more of the specified parts could not be found. The part might not have been uploaded, or the specified entity tag might not have matched the part's entity tag."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
|
|
_, err = obj.GetObjectInfo("bucket", "dir1")
|
|
switch err := err.(type) {
|
|
case ObjectNotFound:
|
|
c.Assert(err.Bucket, check.Equals, "bucket")
|
|
c.Assert(err.Object, check.Equals, "dir1")
|
|
default:
|
|
// force a failure with a line number.
|
|
c.Assert(err, check.Equals, "ObjectNotFound")
|
|
}
|
|
|
|
_, err = obj.GetObjectInfo("bucket", "dir1/")
|
|
switch err := err.(type) {
|
|
case ObjectNameInvalid:
|
|
c.Assert(err.Bucket, check.Equals, "bucket")
|
|
c.Assert(err.Object, check.Equals, "dir1/")
|
|
default:
|
|
// force a failure with a line number.
|
|
c.Assert(err, check.Equals, "ObjectNotFound")
|
|
}
|
|
}
|
|
|
|
// Test content-type
|
|
func testContentType(c *check.C, obj ObjectLayer) {
|
|
err := obj.MakeBucket("bucket")
|
|
c.Assert(err, check.IsNil)
|
|
|
|
// Test empty.
|
|
_, err = obj.PutObject("bucket", "minio.png", int64(len("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.")), bytes.NewBufferString("The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed."), nil)
|
|
c.Assert(err, check.IsNil)
|
|
objInfo, err := obj.GetObjectInfo("bucket", "minio.png")
|
|
c.Assert(err, check.IsNil)
|
|
c.Assert(objInfo.ContentType, check.Equals, "image/png")
|
|
}
|
|
|