Finishing all the test case support for ACL and other fixes

pkg/api/api_bucket_handlers.go

@@ -25,6 +25,35 @@ import (
 	"github.com/minio-io/minio/pkg/utils/log"
 )
 
+func (server *minioAPI) isValidOp(w http.ResponseWriter, req *http.Request, acceptsContentType contentType) bool {
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+
+	bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
+	switch iodine.ToError(err).(type) {
+	case drivers.BucketNotFound:
+		{
+			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case drivers.BucketNameInvalid:
+		{
+			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case nil:
+		if stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate() {
+			writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+			return false
+		}
+		if bucketMetadata.ACL.IsPublicRead() && req.Method == "PUT" {
+			writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+			return false
+		}
+	}
+	return true
+}
+
 // GET Bucket (List Objects)
 // -------------------------
 // This implementation of the GET operation returns some or all (up to 1000)
@@ -37,6 +66,10 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 		writeErrorResponse(w, req, NotAcceptable, acceptsContentType, req.URL.Path)
 		return
 	}
+	// verify if bucket allows this operation
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
 
 	resources := getBucketResources(req.URL.Query())
 	if resources.Maxkeys == 0 {
@@ -46,16 +79,8 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 
-	// Enable this after tests supports them
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	objects, resources, err := server.driver.ListObjects(bucket, resources)
-	switch err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil: // success
 		{
 			// write headers
@@ -66,13 +91,9 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
 			w.Write(encodedSuccessResponse)
 		}
-	case drivers.BucketNotFound:
+	case drivers.ObjectNotFound:
 		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 		}
 	case drivers.ObjectNameInvalid:
 		{
@@ -99,7 +120,7 @@ func (server *minioAPI) listBucketsHandler(w http.ResponseWriter, req *http.Requ
 
 	buckets, err := server.driver.ListBuckets()
 	// cannot fallthrough in (type) switch :(
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		{
 			response := generateBucketsListResult(buckets)
@@ -138,7 +159,7 @@ func (server *minioAPI) putBucketHandler(w http.ResponseWriter, req *http.Reques
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 	err := server.driver.CreateBucket(bucket, getACLTypeString(aclType))
-	switch err.(type) {
+	switch iodine.ToError(err).(type) {
 	case nil:
 		{
 			w.Header().Set("Server", "Minio")
@@ -174,37 +195,13 @@ func (server *minioAPI) headBucketHandler(w http.ResponseWriter, req *http.Reque
 		return
 	}
 
-	vars := mux.Vars(req)
-	bucket := vars["bucket"]
-
-	// Enable this after tests supports them
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
-	_, err := server.driver.GetBucketMetadata(bucket)
-	switch err.(type) {
-	case nil:
-		{
-			w.Header().Set("Server", "Minio")
-			w.Header().Set("Connection", "close")
-			w.WriteHeader(http.StatusOK)
-		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
-	default:
-		{
-			log.Error.Println(iodine.New(err, nil))
-			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
-		}
+	// verify if bucket allows this operation
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
 	}
+
+	// Always a success if isValidOp succeeds
+	w.Header().Set("Server", "Minio")
+	w.Header().Set("Connection", "close")
+	w.WriteHeader(http.StatusOK)
 }

pkg/api/api_generic_handlers.go

@@ -56,43 +56,49 @@ func validateHandler(conf config.Config, h http.Handler) http.Handler {
 
 // Validate handler ServeHTTP() wrapper
 func (h vHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	accessKey := stripAccessKey(r)
 	acceptsContentType := getContentType(r)
 	if acceptsContentType == unknownContentType {
 		writeErrorResponse(w, r, NotAcceptable, acceptsContentType, r.URL.Path)
 		return
 	}
-	switch true {
-	case accessKey != "":
-		if err := h.conf.ReadConfig(); err != nil {
-			writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
-			return
+	// success
+	h.handler.ServeHTTP(w, r)
+
+	// Enable below only when webcli is ready
+
+	/*
+		switch true {
+		case accessKey != "":
+			if err := h.conf.ReadConfig(); err != nil {
+				writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path)
+				return
+			}
+			user, ok := h.conf.Users[accessKey]
+			if !ok {
+				writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path)
+				return
+			}
+			ok, _ = ValidateRequest(user, r)
+			if !ok {
+				writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path)
+				return
+			}
+			// Success
+			h.handler.ServeHTTP(w, r)
+		default:
+			// Control reaches when no access key is found, ideally we would
+			// like to throw back `403`. But for now with our tests lacking
+			// this functionality it is better for us to be serving anonymous
+			// requests as well.
+			// We should remove this after adding tests to support signature request
+			h.handler.ServeHTTP(w, r)
+			// ## Uncommented below links of code after disabling anonymous requests
+			// error := errorCodeError(AccessDenied)
+			// errorResponse := getErrorResponse(error, "")
+			// w.WriteHeader(error.HTTPStatusCode)
+			// w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
 		}
-		user, ok := h.conf.Users[accessKey]
-		if !ok {
-			writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path)
-			return
-		}
-		ok, _ = ValidateRequest(user, r)
-		if !ok {
-			writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path)
-			return
-		}
-		// Success
-		h.handler.ServeHTTP(w, r)
-	default:
-		// Control reaches when no access key is found, ideally we would
-		// like to throw back `403`. But for now with our tests lacking
-		// this functionality it is better for us to be serving anonymous
-		// requests as well.
-		// We should remove this after adding tests to support signature request
-		h.handler.ServeHTTP(w, r)
-		// ## Uncommented below links of code after disabling anonymous requests
-		// error := errorCodeError(AccessDenied)
-		// errorResponse := getErrorResponse(error, "")
-		// w.WriteHeader(error.HTTPStatusCode)
-		// w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
-	}
+	*/
 }
 
 // Ignore resources handler is wrapper handler used for API request resource validation

pkg/api/api_object_handlers.go

@@ -36,22 +36,17 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// Enable this after tests supports them
-
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	metadata, err := server.driver.GetObjectMetadata(bucket, object, "")
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil: // success
 		{
 			httpRange, err := getRequestedRange(req, metadata.Size)
@@ -80,18 +75,10 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques
 		{
 			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
 	case drivers.ObjectNameInvalid:
 		{
 			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
 	default:
 		{
 			log.Error.Println(iodine.New(err, nil))
@@ -110,21 +97,17 @@ func (server *minioAPI) headObjectHandler(w http.ResponseWriter, req *http.Reque
 		return
 	}
 
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// verify for if bucket is private or public
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	metadata, err := server.driver.GetObjectMetadata(bucket, object, "")
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		{
 			setObjectHeaders(w, metadata)
@@ -156,19 +139,16 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
+	// handle PublicRead ACL here
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// verify for if bucket is private or public
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) || bucketMetadtata.ACL.IsPublicRead() {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	// get Content-MD5 sent by client and verify if valid
 	md5 := req.Header.Get("Content-MD5")
 	if !isValidMD5(md5) {
@@ -176,24 +156,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 	err := server.driver.CreateObject(bucket, object, "", md5, req.Body)
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		w.Header().Set("Server", "Minio")
 		w.Header().Set("Connection", "close")
 		w.WriteHeader(http.StatusOK)
-	case drivers.ImplementationError:
-		{
-			log.Error.Println(err)
-			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
 	case drivers.ObjectExists:
 		{
 			writeErrorResponse(w, req, NotImplemented, acceptsContentType, req.URL.Path)
@@ -206,6 +173,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		{
 			writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
 		}
+	case drivers.ImplementationError:
+		{
+			log.Error.Println(err)
+			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+		}
 	default:
 		{
 			log.Error.Println(err)

pkg/api/api_test.go

@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 
-package api_test
+package api
 
 import (
 	"bytes"
+	"crypto/hmac"
+	"crypto/sha1"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
@@ -28,11 +31,11 @@ import (
 	"testing"
 	"time"
 
+	"encoding/base64"
 	"encoding/xml"
 	"net/http"
 	"net/http/httptest"
 
-	"github.com/minio-io/minio/pkg/api"
 	"github.com/minio-io/minio/pkg/storage/drivers"
 	"github.com/minio-io/minio/pkg/storage/drivers/donut"
 	"github.com/minio-io/minio/pkg/storage/drivers/memory"
@@ -107,7 +110,20 @@ func (s *MySuite) TearDownTest(c *C) {
 	s.Root = ""
 }
 
-func (s *MySuite) TestNonExistantObject(c *C) {
+func setAuthHeader(req *http.Request) {
+	hm := hmac.New(sha1.New, []byte("H+AVh8q5G7hEH2r3WxFP135+Q19Aw8yXWel8IGh/HrEjZyTNx/n4Xw=="))
+	ss := getStringToSign(req)
+	io.WriteString(hm, ss)
+
+	authHeader := new(bytes.Buffer)
+	fmt.Fprintf(authHeader, "AWS %s:", "AC5NH40NQLTL4D2W92PM")
+	encoder := base64.NewEncoder(base64.StdEncoding, authHeader)
+	encoder.Write(hm.Sum(nil))
+	encoder.Close()
+	req.Header.Set("Authorization", authHeader.String())
+}
+
+func (s *MySuite) TestNonExistantBucket(c *C) {
 	switch driver := s.Driver.(type) {
 	case *mocks.Driver:
 		{
@@ -115,12 +131,17 @@ func (s *MySuite) TestNonExistantObject(c *C) {
 		}
 	}
 	driver := s.Driver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
-	s.MockDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	s.MockDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once()
+	request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusNotFound)
 }
@@ -144,10 +165,11 @@ func (s *MySuite) TestEmptyObject(c *C) {
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once()
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -155,7 +177,12 @@ func (s *MySuite) TestEmptyObject(c *C) {
 	driver.CreateBucket("bucket", "private")
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -180,17 +207,23 @@ func (s *MySuite) TestBucket(c *C) {
 	metadata := drivers.BucketMetadata{
 		Name:    "bucket",
 		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	driver.CreateBucket("bucket", "private")
 
-	response, err := http.Head(testServer.URL + "/bucket")
+	request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 }
@@ -214,11 +247,12 @@ func (s *MySuite) TestObject(c *C) {
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Twice()
 	typedDriver.SetGetObjectWriter("bucket", "object", []byte("hello world"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -226,7 +260,12 @@ func (s *MySuite) TestObject(c *C) {
 	driver.CreateBucket("bucket", "private")
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -272,7 +311,7 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 		Md5:         "5eb63bbbe01eeed093cb22bb8f5acdc3", // TODO correct md5
 		Size:        11,
 	}
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -290,20 +329,34 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 	driver.CreateObject("bucket", "object3", "", "", buffer3)
 
 	// test non-existant object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
+	c.Assert(err, IsNil)
+
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 	//// test object 1
 
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object1", []byte("hello one"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object1").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object1")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object1", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once()
 	metadata, err := driver.GetObjectMetadata("bucket", "object1", "")
 	c.Assert(err, IsNil)
@@ -320,13 +373,20 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 
 	// test object 2
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object2", []byte("hello two"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object2").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object2")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object2", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once()
 	metadata, err = driver.GetObjectMetadata("bucket", "object2", "")
 	c.Assert(err, IsNil)
@@ -343,15 +403,23 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 
 	// test object 3
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object3", []byte("hello three"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object3").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object3")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object3", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once()
 	metadata, err = driver.GetObjectMetadata("bucket", "object3", "")
+
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -373,11 +441,16 @@ func (s *MySuite) TestNotImplemented(c *C) {
 		}
 	}
 	driver := s.Driver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
-	response, err := http.Get(testServer.URL + "/bucket/object?acl")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object?acl", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusNotImplemented)
 
@@ -393,19 +466,33 @@ func (s *MySuite) TestHeader(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 	typedDriver.AssertExpectations(c)
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	driver.CreateBucket("bucket", "private")
-
-	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	err := driver.CreateBucket("bucket", "private")
 	c.Assert(err, IsNil)
+
+	bucketMetadata := drivers.BucketMetadata{
+		Name:    "bucket",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
+	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
+	c.Assert(err, IsNil)
+
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
 	buffer := bytes.NewBufferString("hello world")
+	typedDriver.On("GetBucketMetadata", "foo").Return(bucketMetadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
@@ -418,13 +505,20 @@ func (s *MySuite) TestHeader(c *C) {
 		Size:        11,
 	}
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once()
 	typedDriver.SetGetObjectWriter("", "", []byte("hello world"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once()
 	metadata, err := driver.GetObjectMetadata("bucket", "object", "")
 	c.Assert(err, IsNil)
@@ -441,7 +535,7 @@ func (s *MySuite) TestPutBucket(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -454,6 +548,7 @@ func (s *MySuite) TestPutBucket(c *C) {
 	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
@@ -477,7 +572,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -486,7 +581,9 @@ func (s *MySuite) TestPutObject(c *C) {
 	resources.Maxkeys = 1000
 	resources.Prefix = ""
 
-	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
+	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{},
+		drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
 	objects, resources, err := driver.ListObjects("bucket", resources)
 	c.Assert(len(objects), Equals, 0)
 	c.Assert(resources.IsTruncated, Equals, false)
@@ -498,9 +595,10 @@ func (s *MySuite) TestPutObject(c *C) {
 
 	// Put Bucket before - Put Object into a bucket
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString(""))
+	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", nil)
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
@@ -510,6 +608,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once()
 	request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world"))
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -529,6 +628,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	resources.Maxkeys = 1000
 	resources.Prefix = ""
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{{}}, drivers.BucketResourcesMetadata{}, nil).Once()
 	objects, resources, err = driver.ListObjects("bucket", resources)
 	c.Assert(len(objects), Equals, 1)
@@ -561,13 +661,17 @@ func (s *MySuite) TestListBuckets(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{}, nil).Once()
-	response, err := http.Get(testServer.URL + "/")
-	defer response.Body.Close()
+	request, err := http.NewRequest("GET", testServer.URL+"/", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -583,8 +687,12 @@ func (s *MySuite) TestListBuckets(c *C) {
 		{Name: "foo", Created: time.Now()},
 	}
 	typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once()
-	response, err = http.Get(testServer.URL + "/")
-	defer response.Body.Close()
+	request, err = http.NewRequest("GET", testServer.URL+"/", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -603,8 +711,12 @@ func (s *MySuite) TestListBuckets(c *C) {
 	}
 
 	typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once()
-	response, err = http.Get(testServer.URL + "/")
-	defer response.Body.Close()
+	request, err = http.NewRequest("GET", testServer.URL+"/", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -616,8 +728,8 @@ func (s *MySuite) TestListBuckets(c *C) {
 	c.Assert(listResponse.Buckets.Bucket[1].Name, Equals, "foo")
 }
 
-func readListBucket(reader io.Reader) (api.BucketListResponse, error) {
-	var results api.BucketListResponse
+func readListBucket(reader io.Reader) (BucketListResponse, error) {
+	var results BucketListResponse
 	decoder := xml.NewDecoder(reader)
 	err := decoder.Decode(&results)
 	return results, err
@@ -687,7 +799,7 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -696,14 +808,13 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 	c.Assert(err, IsNil)
 
 	typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{{Name: "foo", Created: time.Now()}}, nil)
-	request, err := http.NewRequest("GET", testServer.URL+"/", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/", nil)
 	c.Assert(err, IsNil)
-
 	request.Header.Add("Accept", "application/json")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
-
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -721,7 +832,7 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -729,15 +840,25 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 	err := driver.CreateBucket("foo", "private")
 	c.Assert(err, IsNil)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
-	c.Assert(err, IsNil)
+	resources := drivers.BucketResourcesMetadata{}
+	resources.Maxkeys = 1000
+	resources.Prefix = ""
 
+	metadata := drivers.BucketMetadata{
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
+	typedDriver.On("ListObjects", "foo", resources).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
 	request.Header.Add("Accept", "application/json")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
-
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -756,7 +877,7 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -764,11 +885,19 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 	err := driver.CreateBucket("bucket", "private")
 	c.Assert(err, IsNil)
 
-	client := http.Client{}
+	metadata := drivers.BucketMetadata{
+		Name:    "bucket",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "one", "", "", mock.Anything).Return(nil).Once()
 	request, err := http.NewRequest("PUT", testServer.URL+"/bucket/one", bytes.NewBufferString("hello world"))
 	delete(request.Header, "Content-Type")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
@@ -782,25 +911,39 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 		Md5:         "d41d8cd98f00b204e9800998ecf8427e",
 		Size:        0,
 	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once()
-	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", bytes.NewBufferString(""))
+	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
 	// test get object
 	typedDriver.SetGetObjectWriter("bucket", "once", []byte(""))
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "one").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/one")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/one", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
+	c.Assert(response.StatusCode, Equals, http.StatusOK)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once()
 	request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world"))
 	delete(request.Header, "Content-Type")
 	request.Header.Add("Content-Type", "application/json")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
@@ -814,17 +957,26 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 		Md5:  "d41d8cd98f00b204e9800998ecf8427e",
 		Size: 0,
 	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once()
-	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", bytes.NewBufferString(""))
+	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
 	// test get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "two").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/two")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/two", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 }
 
@@ -838,7 +990,7 @@ func (s *MySuite) TestPartialContent(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -860,14 +1012,18 @@ func (s *MySuite) TestPartialContent(c *C) {
 
 	// prepare for GET on range request
 	typedDriver.SetGetObjectWriter("foo", "bar", []byte("hello world"))
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once()
 	typedDriver.On("GetPartialObject", mock.Anything, "foo", "bar", int64(6), int64(2)).Return(int64(2), nil).Once()
 
 	// prepare request
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
 	request.Header.Add("Accept", "application/json")
 	request.Header.Add("Range", "bytes=6-7")
+	setAuthHeader(request)
+
 	client := http.Client{}
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
@@ -892,35 +1048,54 @@ func (s *MySuite) TestListObjectsHandlerErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
-
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
-	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
-
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
-	c.Assert(err, IsNil)
-	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNotFound{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
+	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BackendCorrupted{}).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -940,14 +1115,24 @@ func (s *MySuite) TestListBucketsErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	metadata := drivers.BucketMetadata{
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0),
+		drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -967,7 +1152,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
@@ -976,6 +1161,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err := http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
@@ -985,6 +1171,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -994,6 +1181,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -1003,6 +1191,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "unknown")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -1023,42 +1212,60 @@ func (s *MySuite) TestGetObjectErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
+	metadata := drivers.BucketMetadata{
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest)
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BackendCorrupted{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -1078,7 +1285,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
@@ -1093,10 +1300,13 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 		Size:        11,
 	}
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	request.Header.Add("Range", "bytes=7-6")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidRange", "The requested range cannot be satisfied.", http.StatusRequestedRangeNotSatisfiable)
@@ -1105,7 +1315,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 func verifyError(c *C, response *http.Response, code, description string, statusCode int) {
 	data, err := ioutil.ReadAll(response.Body)
 	c.Assert(err, IsNil)
-	errorResponse := api.ErrorResponse{}
+	errorResponse := ErrorResponse{}
 	err = xml.Unmarshal(data, &errorResponse)
 	c.Assert(err, IsNil)
 	c.Assert(errorResponse.Code, Equals, code)

pkg/api/utils.go

@@ -6,6 +6,9 @@ import (
 )
 
 func isValidMD5(md5 string) bool {
+	if md5 == "" {
+		return true
+	}
 	_, err := base64.StdEncoding.DecodeString(strings.TrimSpace(md5))
 	if err != nil {
 		return false