diff --git a/s3store/s3store.go b/s3store/s3store.go
index 9cc0b2f..fb698ce 100644
--- a/s3store/s3store.go
+++ b/s3store/s3store.go
@@ -10,7 +10,6 @@ import (
 	"bytes"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -21,34 +20,39 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go/service/s3/s3iface"
 )
 
-const MinPartSize = int64(5 * 1024 * 1024)
-
 // See the tusd.DataStore interface for documentation about the different
 // methods.
 type S3Store struct {
 	Bucket      string
-	Service     *s3.S3
+	Service     s3iface.S3API
 	MaxPartSize int64
+	MinPartSize int64
 }
 
-func New(bucket string, service *s3.S3) *S3Store {
+func New(bucket string, service s3iface.S3API) *S3Store {
 	return &S3Store{
 		Bucket:      bucket,
 		Service:     service,
 		MaxPartSize: 6 * 1024 * 1024,
+		MinPartSize: 5 * 1024 * 1024,
 	}
 }
 
 func (store S3Store) NewUpload(info tusd.FileInfo) (id string, err error) {
-	uploadId := uid.Uid()
+	var uploadId string
+	if info.ID == "" {
+		uploadId = uid.Uid()
+	} else {
+		uploadId = info.ID
+	}
 
 	infoJson, err := json.Marshal(info)
 	if err != nil {
-		return id, err
+		return "", err
 	}
 
 	// Create object on S3 containing information about the file
@@ -59,7 +63,7 @@ func (store S3Store) NewUpload(info tusd.FileInfo) (id string, err error) {
 		ContentLength: aws.Int64(int64(len(infoJson))),
 	})
 	if err != nil {
-		return id, err
+		return "", err
 	}
 
 	// Create the actual multipart upload
@@ -68,7 +72,7 @@ func (store S3Store) NewUpload(info tusd.FileInfo) (id string, err error) {
 		Key:    aws.String(uploadId),
 	})
 	if err != nil {
-		return id, err
+		return "", err
 	}
 
 	id = uploadId + "+" + *res.UploadId
@@ -88,9 +92,6 @@ func (store S3Store) WriteChunk(id string, offset int64, src io.Reader) (int64,
 	size := info.Size
 	bytesUploaded := int64(0)
 
-	fmt.Println("size:", size)
-	fmt.Println("offset:", offset)
-
 	// Get number of parts to generate next number
 	listPtr, err := store.Service.ListParts(&s3.ListPartsInput{
 		Bucket:   aws.String(store.Bucket),
@@ -103,11 +104,8 @@ func (store S3Store) WriteChunk(id string, offset int64, src io.Reader) (int64,
 
 	list := *listPtr
 	numParts := len(list.Parts)
-	fmt.Println("numParts:", numParts)
 	nextPartNum := int64(numParts + 1)
 
-	fmt.Println("nextNum:", nextPartNum)
-
 	for {
 		// Create a temporary file to store the part in it
 		file, err := ioutil.TempFile("", "tusd-s3-tmp-")
@@ -117,28 +115,20 @@ func (store S3Store) WriteChunk(id string, offset int64, src io.Reader) (int64,
 		defer os.Remove(file.Name())
 		defer file.Close()
 
-		fmt.Println("max:", store.MaxPartSize)
-
 		limitedReader := io.LimitReader(src, store.MaxPartSize)
 		n, err := io.Copy(file, limitedReader)
-		fmt.Println("err:", err)
 		if err != nil && err != io.EOF {
 			return bytesUploaded, err
 		}
 
-		fmt.Println("n:", n)
-		fmt.Println("offset:", offset)
-
-		if (size - offset) <= MinPartSize {
+		if (size - offset) <= store.MinPartSize {
 			if (size - offset) != n {
 				return bytesUploaded, nil
 			}
-		} else if n < MinPartSize {
+		} else if n < store.MinPartSize {
 			return bytesUploaded, nil
 		}
 
-		fmt.Println("upload…")
-
 		// Seek to the beginning of the file
 		file.Seek(0, 0)
 
@@ -153,17 +143,10 @@ func (store S3Store) WriteChunk(id string, offset int64, src io.Reader) (int64,
 			return bytesUploaded, err
 		}
 
-		pos, _ := file.Seek(1, 0)
-		fmt.Println("pos:", pos)
-
 		offset += bytesUploaded
 		bytesUploaded += n
 		nextPartNum += 1
 	}
-
-	fmt.Println("bytes:", bytesUploaded)
-
-	return bytesUploaded, nil
 }
 
 func (store S3Store) GetInfo(id string) (info tusd.FileInfo, err error) {
@@ -197,7 +180,6 @@ func (store S3Store) GetInfo(id string) (info tusd.FileInfo, err error) {
 		// when the multipart upload has already been completed or aborted. Since
 		// we already found the info object, we know that the upload has been
 		// completed and therefore can ensure the the offset is the size.
-		fmt.Println(err, err.(awserr.Error).Code())
 		if err, ok := err.(awserr.Error); ok && err.Code() == "NoSuchUpload" {
 			info.Offset = info.Size
 			return info, nil
@@ -238,7 +220,7 @@ func (store S3Store) GetReader(id string) (io.Reader, error) {
 
 	// Test whether the multipart upload exists to find out if the upload
 	// never existsted or just has not been finished yet
-	_, err := store.Service.ListParts(&s3.ListPartsInput{
+	_, err = store.Service.ListParts(&s3.ListPartsInput{
 		Bucket:   aws.String(store.Bucket),
 		Key:      aws.String(uploadId),
 		UploadId: aws.String(multipartId),
@@ -284,8 +266,6 @@ func (store S3Store) Terminate(id string) error {
 func (store S3Store) FinishUpload(id string) error {
 	uploadId, multipartId := splitIds(id)
 
-	println("Finish upload")
-
 	// Get uploaded parts
 	listPtr, err := store.Service.ListParts(&s3.ListPartsInput{
 		Bucket:   aws.String(store.Bucket),
diff --git a/s3store/s3store_mock_test.go b/s3store/s3store_mock_test.go
new file mode 100644
index 0000000..18a75c5
--- /dev/null
+++ b/s3store/s3store_mock_test.go
@@ -0,0 +1,1303 @@
+// Automatically generated by MockGen. DO NOT EDIT!
+// Source: github.com/aws/aws-sdk-go/service/s3/s3iface (interfaces: S3API)
+
+package s3store_test
+
+import (
+	request "github.com/aws/aws-sdk-go/aws/request"
+	s3 "github.com/aws/aws-sdk-go/service/s3"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// Mock of S3API interface
+type MockS3API struct {
+	ctrl     *gomock.Controller
+	recorder *_MockS3APIRecorder
+}
+
+// Recorder for MockS3API (not exported)
+type _MockS3APIRecorder struct {
+	mock *MockS3API
+}
+
+func NewMockS3API(ctrl *gomock.Controller) *MockS3API {
+	mock := &MockS3API{ctrl: ctrl}
+	mock.recorder = &_MockS3APIRecorder{mock}
+	return mock
+}
+
+func (_m *MockS3API) EXPECT() *_MockS3APIRecorder {
+	return _m.recorder
+}
+
+func (_m *MockS3API) AbortMultipartUpload(_param0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) {
+	ret := _m.ctrl.Call(_m, "AbortMultipartUpload", _param0)
+	ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) AbortMultipartUpload(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "AbortMultipartUpload", arg0)
+}
+
+func (_m *MockS3API) AbortMultipartUploadRequest(_param0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) {
+	ret := _m.ctrl.Call(_m, "AbortMultipartUploadRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.AbortMultipartUploadOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) AbortMultipartUploadRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "AbortMultipartUploadRequest", arg0)
+}
+
+func (_m *MockS3API) CompleteMultipartUpload(_param0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) {
+	ret := _m.ctrl.Call(_m, "CompleteMultipartUpload", _param0)
+	ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CompleteMultipartUpload(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CompleteMultipartUpload", arg0)
+}
+
+func (_m *MockS3API) CompleteMultipartUploadRequest(_param0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) {
+	ret := _m.ctrl.Call(_m, "CompleteMultipartUploadRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.CompleteMultipartUploadOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CompleteMultipartUploadRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CompleteMultipartUploadRequest", arg0)
+}
+
+func (_m *MockS3API) CopyObject(_param0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "CopyObject", _param0)
+	ret0, _ := ret[0].(*s3.CopyObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CopyObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CopyObject", arg0)
+}
+
+func (_m *MockS3API) CopyObjectRequest(_param0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) {
+	ret := _m.ctrl.Call(_m, "CopyObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.CopyObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CopyObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CopyObjectRequest", arg0)
+}
+
+func (_m *MockS3API) CreateBucket(_param0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) {
+	ret := _m.ctrl.Call(_m, "CreateBucket", _param0)
+	ret0, _ := ret[0].(*s3.CreateBucketOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CreateBucket(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateBucket", arg0)
+}
+
+func (_m *MockS3API) CreateBucketRequest(_param0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) {
+	ret := _m.ctrl.Call(_m, "CreateBucketRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.CreateBucketOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CreateBucketRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateBucketRequest", arg0)
+}
+
+func (_m *MockS3API) CreateMultipartUpload(_param0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) {
+	ret := _m.ctrl.Call(_m, "CreateMultipartUpload", _param0)
+	ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CreateMultipartUpload(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateMultipartUpload", arg0)
+}
+
+func (_m *MockS3API) CreateMultipartUploadRequest(_param0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) {
+	ret := _m.ctrl.Call(_m, "CreateMultipartUploadRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.CreateMultipartUploadOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) CreateMultipartUploadRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateMultipartUploadRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucket(_param0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucket", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucket(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucket", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketCors(_param0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketCors", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketCors(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketCors", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketCorsRequest(_param0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketCorsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketCorsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketCorsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketCorsRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketLifecycle(_param0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketLifecycle", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketLifecycle(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketLifecycle", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketLifecycleRequest(_param0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketLifecycleRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketLifecycleOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketLifecycleRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketPolicy(_param0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketPolicy", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketPolicy(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketPolicy", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketPolicyRequest(_param0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketPolicyRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketPolicyOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketPolicyRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketPolicyRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketReplication(_param0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketReplication", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketReplication(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketReplication", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketReplicationRequest(_param0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketReplicationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketReplicationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketReplicationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketReplicationRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketRequest(_param0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketTagging(_param0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketTagging", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketTagging(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketTagging", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketTaggingRequest(_param0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketTaggingRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketTaggingOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketTaggingRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketTaggingRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketWebsite(_param0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketWebsite", _param0)
+	ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketWebsite(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketWebsite", arg0)
+}
+
+func (_m *MockS3API) DeleteBucketWebsiteRequest(_param0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteBucketWebsiteRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteBucketWebsiteOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBucketWebsiteRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteObject(_param0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteObject", _param0)
+	ret0, _ := ret[0].(*s3.DeleteObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObject", arg0)
+}
+
+func (_m *MockS3API) DeleteObjectRequest(_param0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjectRequest", arg0)
+}
+
+func (_m *MockS3API) DeleteObjects(_param0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) {
+	ret := _m.ctrl.Call(_m, "DeleteObjects", _param0)
+	ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteObjects(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjects", arg0)
+}
+
+func (_m *MockS3API) DeleteObjectsRequest(_param0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) {
+	ret := _m.ctrl.Call(_m, "DeleteObjectsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.DeleteObjectsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) DeleteObjectsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteObjectsRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketAcl(_param0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketAcl", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketAclOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketAcl(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAcl", arg0)
+}
+
+func (_m *MockS3API) GetBucketAclRequest(_param0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketAclRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketAclOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketAclRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketAclRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketCors(_param0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketCors", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketCorsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketCors(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketCors", arg0)
+}
+
+func (_m *MockS3API) GetBucketCorsRequest(_param0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketCorsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketCorsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketCorsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketCorsRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketLifecycle(_param0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketLifecycle", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLifecycle(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycle", arg0)
+}
+
+func (_m *MockS3API) GetBucketLifecycleConfiguration(_param0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketLifecycleConfiguration", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleConfiguration", arg0)
+}
+
+func (_m *MockS3API) GetBucketLifecycleConfigurationRequest(_param0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketLifecycleConfigurationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketLifecycleConfigurationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleConfigurationRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketLifecycleRequest(_param0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketLifecycleRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketLifecycleOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLifecycleRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketLocation(_param0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketLocation", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketLocationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLocation(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLocation", arg0)
+}
+
+func (_m *MockS3API) GetBucketLocationRequest(_param0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketLocationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketLocationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLocationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLocationRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketLogging(_param0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketLogging", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketLoggingOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLogging(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLogging", arg0)
+}
+
+func (_m *MockS3API) GetBucketLoggingRequest(_param0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketLoggingRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketLoggingOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketLoggingRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketLoggingRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketNotification(_param0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketNotification", _param0)
+	ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketNotification(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotification", arg0)
+}
+
+func (_m *MockS3API) GetBucketNotificationConfiguration(_param0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketNotificationConfiguration", _param0)
+	ret0, _ := ret[0].(*s3.NotificationConfiguration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationConfiguration", arg0)
+}
+
+func (_m *MockS3API) GetBucketNotificationConfigurationRequest(_param0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) {
+	ret := _m.ctrl.Call(_m, "GetBucketNotificationConfigurationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.NotificationConfiguration)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationConfigurationRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketNotificationRequest(_param0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) {
+	ret := _m.ctrl.Call(_m, "GetBucketNotificationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.NotificationConfigurationDeprecated)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketNotificationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketNotificationRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketPolicy(_param0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketPolicy", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketPolicy(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketPolicy", arg0)
+}
+
+func (_m *MockS3API) GetBucketPolicyRequest(_param0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketPolicyRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketPolicyOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketPolicyRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketPolicyRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketReplication(_param0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketReplication", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketReplicationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketReplication(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketReplication", arg0)
+}
+
+func (_m *MockS3API) GetBucketReplicationRequest(_param0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketReplicationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketReplicationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketReplicationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketReplicationRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketRequestPayment(_param0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketRequestPayment", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketRequestPayment(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketRequestPayment", arg0)
+}
+
+func (_m *MockS3API) GetBucketRequestPaymentRequest(_param0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketRequestPaymentRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketRequestPaymentOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketRequestPaymentRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketTagging(_param0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketTagging", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketTaggingOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketTagging(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketTagging", arg0)
+}
+
+func (_m *MockS3API) GetBucketTaggingRequest(_param0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketTaggingRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketTaggingOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketTaggingRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketTaggingRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketVersioning(_param0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketVersioning", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketVersioningOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketVersioning(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketVersioning", arg0)
+}
+
+func (_m *MockS3API) GetBucketVersioningRequest(_param0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketVersioningRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketVersioningOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketVersioningRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketVersioningRequest", arg0)
+}
+
+func (_m *MockS3API) GetBucketWebsite(_param0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetBucketWebsite", _param0)
+	ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketWebsite(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketWebsite", arg0)
+}
+
+func (_m *MockS3API) GetBucketWebsiteRequest(_param0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) {
+	ret := _m.ctrl.Call(_m, "GetBucketWebsiteRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetBucketWebsiteOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBucketWebsiteRequest", arg0)
+}
+
+func (_m *MockS3API) GetObject(_param0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetObject", _param0)
+	ret0, _ := ret[0].(*s3.GetObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObject", arg0)
+}
+
+func (_m *MockS3API) GetObjectAcl(_param0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetObjectAcl", _param0)
+	ret0, _ := ret[0].(*s3.GetObjectAclOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObjectAcl(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectAcl", arg0)
+}
+
+func (_m *MockS3API) GetObjectAclRequest(_param0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) {
+	ret := _m.ctrl.Call(_m, "GetObjectAclRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetObjectAclOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObjectAclRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectAclRequest", arg0)
+}
+
+func (_m *MockS3API) GetObjectRequest(_param0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
+	ret := _m.ctrl.Call(_m, "GetObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectRequest", arg0)
+}
+
+func (_m *MockS3API) GetObjectTorrent(_param0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) {
+	ret := _m.ctrl.Call(_m, "GetObjectTorrent", _param0)
+	ret0, _ := ret[0].(*s3.GetObjectTorrentOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObjectTorrent(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectTorrent", arg0)
+}
+
+func (_m *MockS3API) GetObjectTorrentRequest(_param0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) {
+	ret := _m.ctrl.Call(_m, "GetObjectTorrentRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.GetObjectTorrentOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) GetObjectTorrentRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetObjectTorrentRequest", arg0)
+}
+
+func (_m *MockS3API) HeadBucket(_param0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
+	ret := _m.ctrl.Call(_m, "HeadBucket", _param0)
+	ret0, _ := ret[0].(*s3.HeadBucketOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) HeadBucket(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadBucket", arg0)
+}
+
+func (_m *MockS3API) HeadBucketRequest(_param0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) {
+	ret := _m.ctrl.Call(_m, "HeadBucketRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.HeadBucketOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) HeadBucketRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadBucketRequest", arg0)
+}
+
+func (_m *MockS3API) HeadObject(_param0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "HeadObject", _param0)
+	ret0, _ := ret[0].(*s3.HeadObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) HeadObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadObject", arg0)
+}
+
+func (_m *MockS3API) HeadObjectRequest(_param0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) {
+	ret := _m.ctrl.Call(_m, "HeadObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.HeadObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) HeadObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "HeadObjectRequest", arg0)
+}
+
+func (_m *MockS3API) ListBuckets(_param0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) {
+	ret := _m.ctrl.Call(_m, "ListBuckets", _param0)
+	ret0, _ := ret[0].(*s3.ListBucketsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListBuckets(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListBuckets", arg0)
+}
+
+func (_m *MockS3API) ListBucketsRequest(_param0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) {
+	ret := _m.ctrl.Call(_m, "ListBucketsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.ListBucketsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListBucketsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListBucketsRequest", arg0)
+}
+
+func (_m *MockS3API) ListMultipartUploads(_param0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) {
+	ret := _m.ctrl.Call(_m, "ListMultipartUploads", _param0)
+	ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListMultipartUploads(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploads", arg0)
+}
+
+func (_m *MockS3API) ListMultipartUploadsPages(_param0 *s3.ListMultipartUploadsInput, _param1 func(*s3.ListMultipartUploadsOutput, bool) bool) error {
+	ret := _m.ctrl.Call(_m, "ListMultipartUploadsPages", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockS3APIRecorder) ListMultipartUploadsPages(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploadsPages", arg0, arg1)
+}
+
+func (_m *MockS3API) ListMultipartUploadsRequest(_param0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) {
+	ret := _m.ctrl.Call(_m, "ListMultipartUploadsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.ListMultipartUploadsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListMultipartUploadsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListMultipartUploadsRequest", arg0)
+}
+
+func (_m *MockS3API) ListObjectVersions(_param0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) {
+	ret := _m.ctrl.Call(_m, "ListObjectVersions", _param0)
+	ret0, _ := ret[0].(*s3.ListObjectVersionsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListObjectVersions(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersions", arg0)
+}
+
+func (_m *MockS3API) ListObjectVersionsPages(_param0 *s3.ListObjectVersionsInput, _param1 func(*s3.ListObjectVersionsOutput, bool) bool) error {
+	ret := _m.ctrl.Call(_m, "ListObjectVersionsPages", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockS3APIRecorder) ListObjectVersionsPages(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersionsPages", arg0, arg1)
+}
+
+func (_m *MockS3API) ListObjectVersionsRequest(_param0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) {
+	ret := _m.ctrl.Call(_m, "ListObjectVersionsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.ListObjectVersionsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListObjectVersionsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectVersionsRequest", arg0)
+}
+
+func (_m *MockS3API) ListObjects(_param0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) {
+	ret := _m.ctrl.Call(_m, "ListObjects", _param0)
+	ret0, _ := ret[0].(*s3.ListObjectsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListObjects(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjects", arg0)
+}
+
+func (_m *MockS3API) ListObjectsPages(_param0 *s3.ListObjectsInput, _param1 func(*s3.ListObjectsOutput, bool) bool) error {
+	ret := _m.ctrl.Call(_m, "ListObjectsPages", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockS3APIRecorder) ListObjectsPages(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsPages", arg0, arg1)
+}
+
+func (_m *MockS3API) ListObjectsRequest(_param0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) {
+	ret := _m.ctrl.Call(_m, "ListObjectsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.ListObjectsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListObjectsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListObjectsRequest", arg0)
+}
+
+func (_m *MockS3API) ListParts(_param0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) {
+	ret := _m.ctrl.Call(_m, "ListParts", _param0)
+	ret0, _ := ret[0].(*s3.ListPartsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListParts(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListParts", arg0)
+}
+
+func (_m *MockS3API) ListPartsPages(_param0 *s3.ListPartsInput, _param1 func(*s3.ListPartsOutput, bool) bool) error {
+	ret := _m.ctrl.Call(_m, "ListPartsPages", _param0, _param1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+func (_mr *_MockS3APIRecorder) ListPartsPages(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListPartsPages", arg0, arg1)
+}
+
+func (_m *MockS3API) ListPartsRequest(_param0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) {
+	ret := _m.ctrl.Call(_m, "ListPartsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.ListPartsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) ListPartsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListPartsRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketAcl(_param0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketAcl", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketAclOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketAcl(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAcl", arg0)
+}
+
+func (_m *MockS3API) PutBucketAclRequest(_param0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketAclRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketAclOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketAclRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketAclRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketCors(_param0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketCors", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketCorsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketCors(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketCors", arg0)
+}
+
+func (_m *MockS3API) PutBucketCorsRequest(_param0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketCorsRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketCorsOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketCorsRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketCorsRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketLifecycle(_param0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketLifecycle", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLifecycle(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycle", arg0)
+}
+
+func (_m *MockS3API) PutBucketLifecycleConfiguration(_param0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketLifecycleConfiguration", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleConfiguration", arg0)
+}
+
+func (_m *MockS3API) PutBucketLifecycleConfigurationRequest(_param0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketLifecycleConfigurationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketLifecycleConfigurationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleConfigurationRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketLifecycleRequest(_param0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketLifecycleRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketLifecycleOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLifecycleRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLifecycleRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketLogging(_param0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketLogging", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketLoggingOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLogging(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLogging", arg0)
+}
+
+func (_m *MockS3API) PutBucketLoggingRequest(_param0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketLoggingRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketLoggingOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketLoggingRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketLoggingRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketNotification(_param0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketNotification", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketNotificationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketNotification(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotification", arg0)
+}
+
+func (_m *MockS3API) PutBucketNotificationConfiguration(_param0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketNotificationConfiguration", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketNotificationConfiguration(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationConfiguration", arg0)
+}
+
+func (_m *MockS3API) PutBucketNotificationConfigurationRequest(_param0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketNotificationConfigurationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketNotificationConfigurationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationConfigurationRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketNotificationRequest(_param0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketNotificationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketNotificationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketNotificationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketNotificationRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketPolicy(_param0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketPolicy", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketPolicyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketPolicy(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketPolicy", arg0)
+}
+
+func (_m *MockS3API) PutBucketPolicyRequest(_param0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketPolicyRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketPolicyOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketPolicyRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketPolicyRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketReplication(_param0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketReplication", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketReplicationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketReplication(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketReplication", arg0)
+}
+
+func (_m *MockS3API) PutBucketReplicationRequest(_param0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketReplicationRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketReplicationOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketReplicationRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketReplicationRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketRequestPayment(_param0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketRequestPayment", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketRequestPayment(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketRequestPayment", arg0)
+}
+
+func (_m *MockS3API) PutBucketRequestPaymentRequest(_param0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketRequestPaymentRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketRequestPaymentOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketRequestPaymentRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketTagging(_param0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketTagging", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketTaggingOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketTagging(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketTagging", arg0)
+}
+
+func (_m *MockS3API) PutBucketTaggingRequest(_param0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketTaggingRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketTaggingOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketTaggingRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketTaggingRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketVersioning(_param0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketVersioning", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketVersioningOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketVersioning(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketVersioning", arg0)
+}
+
+func (_m *MockS3API) PutBucketVersioningRequest(_param0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketVersioningRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketVersioningOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketVersioningRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketVersioningRequest", arg0)
+}
+
+func (_m *MockS3API) PutBucketWebsite(_param0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutBucketWebsite", _param0)
+	ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketWebsite(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketWebsite", arg0)
+}
+
+func (_m *MockS3API) PutBucketWebsiteRequest(_param0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) {
+	ret := _m.ctrl.Call(_m, "PutBucketWebsiteRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutBucketWebsiteOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutBucketWebsiteRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutBucketWebsiteRequest", arg0)
+}
+
+func (_m *MockS3API) PutObject(_param0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutObject", _param0)
+	ret0, _ := ret[0].(*s3.PutObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObject", arg0)
+}
+
+func (_m *MockS3API) PutObjectAcl(_param0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) {
+	ret := _m.ctrl.Call(_m, "PutObjectAcl", _param0)
+	ret0, _ := ret[0].(*s3.PutObjectAclOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutObjectAcl(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectAcl", arg0)
+}
+
+func (_m *MockS3API) PutObjectAclRequest(_param0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) {
+	ret := _m.ctrl.Call(_m, "PutObjectAclRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutObjectAclOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutObjectAclRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectAclRequest", arg0)
+}
+
+func (_m *MockS3API) PutObjectRequest(_param0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) {
+	ret := _m.ctrl.Call(_m, "PutObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.PutObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) PutObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutObjectRequest", arg0)
+}
+
+func (_m *MockS3API) RestoreObject(_param0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) {
+	ret := _m.ctrl.Call(_m, "RestoreObject", _param0)
+	ret0, _ := ret[0].(*s3.RestoreObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) RestoreObject(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "RestoreObject", arg0)
+}
+
+func (_m *MockS3API) RestoreObjectRequest(_param0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) {
+	ret := _m.ctrl.Call(_m, "RestoreObjectRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.RestoreObjectOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) RestoreObjectRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "RestoreObjectRequest", arg0)
+}
+
+func (_m *MockS3API) UploadPart(_param0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
+	ret := _m.ctrl.Call(_m, "UploadPart", _param0)
+	ret0, _ := ret[0].(*s3.UploadPartOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) UploadPart(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPart", arg0)
+}
+
+func (_m *MockS3API) UploadPartCopy(_param0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) {
+	ret := _m.ctrl.Call(_m, "UploadPartCopy", _param0)
+	ret0, _ := ret[0].(*s3.UploadPartCopyOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) UploadPartCopy(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartCopy", arg0)
+}
+
+func (_m *MockS3API) UploadPartCopyRequest(_param0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) {
+	ret := _m.ctrl.Call(_m, "UploadPartCopyRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.UploadPartCopyOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) UploadPartCopyRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartCopyRequest", arg0)
+}
+
+func (_m *MockS3API) UploadPartRequest(_param0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) {
+	ret := _m.ctrl.Call(_m, "UploadPartRequest", _param0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*s3.UploadPartOutput)
+	return ret0, ret1
+}
+
+func (_mr *_MockS3APIRecorder) UploadPartRequest(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCall(_mr.mock, "UploadPartRequest", arg0)
+}
diff --git a/s3store/s3store_test.go b/s3store/s3store_test.go
new file mode 100644
index 0000000..ff5fa51
--- /dev/null
+++ b/s3store/s3store_test.go
@@ -0,0 +1,444 @@
+package s3store_test
+
+import (
+	"bytes"
+	"io/ioutil"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/tus/tusd"
+	"github.com/tus/tusd/s3store"
+)
+
+//go:generate mockgen -destination=./s3store_mock_test.go -package=s3store_test github.com/aws/aws-sdk-go/service/s3/s3iface S3API
+
+func TestNewUpload(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	assert.Equal(store.Bucket, "bucket")
+	assert.Equal(store.Service, s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().PutObject(&s3.PutObjectInput{
+			Bucket:        aws.String("bucket"),
+			Key:           aws.String("uploadId.info"),
+			Body:          bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`)),
+			ContentLength: aws.Int64(int64(111)),
+		}),
+		s3obj.EXPECT().CreateMultipartUpload(&s3.CreateMultipartUploadInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId"),
+		}).Return(&s3.CreateMultipartUploadOutput{
+			UploadId: aws.String("multipartId"),
+		}, nil),
+	)
+
+	info := tusd.FileInfo{
+		ID:   "uploadId",
+		Size: 500,
+	}
+
+	id, err := store.NewUpload(info)
+	assert.Nil(err)
+	assert.Equal(id, "uploadId+multipartId")
+}
+
+func TestGetInfoNotFound(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+		Bucket: aws.String("bucket"),
+		Key:    aws.String("uploadId.info"),
+	}).Return(nil, awserr.New("NoSuchKey", "The specified key does not exist.", nil))
+
+	_, err := store.GetInfo("uploadId+multipartId")
+	assert.Equal(err, tusd.ErrNotFound)
+}
+
+func TestGetInfo(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId.info"),
+		}).Return(&s3.GetObjectOutput{
+			Body: ioutil.NopCloser(bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`))),
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(100),
+				},
+				{
+					Size: aws.Int64(200),
+				},
+			},
+		}, nil),
+	)
+
+	info, err := store.GetInfo("uploadId+multipartId")
+	assert.Nil(err)
+	assert.Equal(int64(500), info.Size)
+	assert.Equal(int64(300), info.Offset)
+}
+
+func TestGetInfoFinished(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId.info"),
+		}).Return(&s3.GetObjectOutput{
+			Body: ioutil.NopCloser(bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`))),
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(nil, awserr.New("NoSuchUpload", "The specified upload does not exist.", nil)),
+	)
+
+	info, err := store.GetInfo("uploadId+multipartId")
+	assert.Nil(err)
+	assert.Equal(int64(500), info.Size)
+	assert.Equal(int64(500), info.Offset)
+}
+
+func TestGetReader(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+		Bucket: aws.String("bucket"),
+		Key:    aws.String("uploadId"),
+	}).Return(&s3.GetObjectOutput{
+		Body: ioutil.NopCloser(bytes.NewReader([]byte(`hello world`))),
+	}, nil)
+
+	content, err := store.GetReader("uploadId+multipartId")
+	assert.Nil(err)
+	assert.Equal(content, ioutil.NopCloser(bytes.NewReader([]byte(`hello world`))))
+}
+
+func TestGetReaderNotFound(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId"),
+		}).Return(nil, awserr.New("NoSuchKey", "The specified key does not exist.", nil)),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+			MaxParts: aws.Int64(0),
+		}).Return(nil, awserr.New("NoSuchUpload", "The specified upload does not exist.", nil)),
+	)
+
+	content, err := store.GetReader("uploadId+multipartId")
+	assert.Nil(content)
+	assert.Equal(err, tusd.ErrNotFound)
+}
+
+func TestGetReaderNotFinished(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId"),
+		}).Return(nil, awserr.New("NoSuchKey", "The specified key does not exist.", nil)),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+			MaxParts: aws.Int64(0),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{},
+		}, nil),
+	)
+
+	content, err := store.GetReader("uploadId+multipartId")
+	assert.Nil(content)
+	assert.Equal(err.Error(), "cannot stream non-finished upload")
+}
+
+func TestFinishUpload(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size:       aws.Int64(100),
+					ETag:       aws.String("foo"),
+					PartNumber: aws.Int64(1),
+				},
+				{
+					Size:       aws.Int64(200),
+					ETag:       aws.String("bar"),
+					PartNumber: aws.Int64(2),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+			MultipartUpload: &s3.CompletedMultipartUpload{
+				Parts: []*s3.CompletedPart{
+					{
+						ETag:       aws.String("foo"),
+						PartNumber: aws.Int64(1),
+					},
+					{
+						ETag:       aws.String("bar"),
+						PartNumber: aws.Int64(2),
+					},
+				},
+			},
+		}).Return(nil, nil),
+	)
+
+	err := store.FinishUpload("uploadId+multipartId")
+	assert.Nil(err)
+}
+
+func TestWriteChunk(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+	store.MaxPartSize = 4
+	store.MinPartSize = 2
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId.info"),
+		}).Return(&s3.GetObjectOutput{
+			Body: ioutil.NopCloser(bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`))),
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(100),
+				},
+				{
+					Size: aws.Int64(200),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(100),
+				},
+				{
+					Size: aws.Int64(200),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().UploadPart(NewUploadPartInputMatcher(&s3.UploadPartInput{
+			Bucket:     aws.String("bucket"),
+			Key:        aws.String("uploadId"),
+			UploadId:   aws.String("multipartId"),
+			PartNumber: aws.Int64(3),
+			Body:       bytes.NewReader([]byte("1234")),
+		})).Return(nil, nil),
+		s3obj.EXPECT().UploadPart(NewUploadPartInputMatcher(&s3.UploadPartInput{
+			Bucket:     aws.String("bucket"),
+			Key:        aws.String("uploadId"),
+			UploadId:   aws.String("multipartId"),
+			PartNumber: aws.Int64(4),
+			Body:       bytes.NewReader([]byte("5678")),
+		})).Return(nil, nil),
+		s3obj.EXPECT().UploadPart(NewUploadPartInputMatcher(&s3.UploadPartInput{
+			Bucket:     aws.String("bucket"),
+			Key:        aws.String("uploadId"),
+			UploadId:   aws.String("multipartId"),
+			PartNumber: aws.Int64(5),
+			Body:       bytes.NewReader([]byte("90")),
+		})).Return(nil, nil),
+	)
+
+	bytesRead, err := store.WriteChunk("uploadId+multipartId", 300, bytes.NewReader([]byte("1234567890")))
+	assert.Nil(err)
+	assert.Equal(int64(10), bytesRead)
+}
+
+func TestWriteChunkDropTooSmall(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId.info"),
+		}).Return(&s3.GetObjectOutput{
+			Body: ioutil.NopCloser(bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`))),
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(100),
+				},
+				{
+					Size: aws.Int64(200),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(100),
+				},
+				{
+					Size: aws.Int64(200),
+				},
+			},
+		}, nil),
+	)
+
+	bytesRead, err := store.WriteChunk("uploadId+multipartId", 300, bytes.NewReader([]byte("1234567890")))
+	assert.Nil(err)
+	assert.Equal(int64(0), bytesRead)
+}
+
+func TestWriteChunkAllowTooSmallLast(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	assert := assert.New(t)
+
+	s3obj := NewMockS3API(mockCtrl)
+	store := s3store.New("bucket", s3obj)
+	store.MinPartSize = 20
+
+	gomock.InOrder(
+		s3obj.EXPECT().GetObject(&s3.GetObjectInput{
+			Bucket: aws.String("bucket"),
+			Key:    aws.String("uploadId.info"),
+		}).Return(&s3.GetObjectOutput{
+			Body: ioutil.NopCloser(bytes.NewReader([]byte(`{"ID":"uploadId","Size":500,"Offset":0,"MetaData":null,"IsPartial":false,"IsFinal":false,"PartialUploads":null}`))),
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(400),
+				},
+				{
+					Size: aws.Int64(90),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().ListParts(&s3.ListPartsInput{
+			Bucket:   aws.String("bucket"),
+			Key:      aws.String("uploadId"),
+			UploadId: aws.String("multipartId"),
+		}).Return(&s3.ListPartsOutput{
+			Parts: []*s3.Part{
+				{
+					Size: aws.Int64(400),
+				},
+				{
+					Size: aws.Int64(90),
+				},
+			},
+		}, nil),
+		s3obj.EXPECT().UploadPart(NewUploadPartInputMatcher(&s3.UploadPartInput{
+			Bucket:     aws.String("bucket"),
+			Key:        aws.String("uploadId"),
+			UploadId:   aws.String("multipartId"),
+			PartNumber: aws.Int64(3),
+			Body:       bytes.NewReader([]byte("1234567890")),
+		})).Return(nil, nil),
+	)
+
+	// 10 bytes are missing for the upload to be finished (offset at 490 for 500
+	// bytes file) but the minimum chunk size is higher (20). The chunk is
+	// still uploaded since the last part may be smaller than the minimum.
+	bytesRead, err := store.WriteChunk("uploadId+multipartId", 490, bytes.NewReader([]byte("1234567890")))
+	assert.Nil(err)
+	assert.Equal(int64(10), bytesRead)
+}
diff --git a/s3store/s3store_util_test.go b/s3store/s3store_util_test.go
new file mode 100644
index 0000000..dde80d5
--- /dev/null
+++ b/s3store/s3store_util_test.go
@@ -0,0 +1,57 @@
+package s3store_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"reflect"
+
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/golang/mock/gomock"
+)
+
+type UploadPartInputMatcher struct {
+	expect *s3.UploadPartInput
+}
+
+func NewUploadPartInputMatcher(expect *s3.UploadPartInput) gomock.Matcher {
+	return UploadPartInputMatcher{
+		expect: expect,
+	}
+}
+
+func (m UploadPartInputMatcher) Matches(x interface{}) bool {
+	input, ok := x.(*s3.UploadPartInput)
+	if !ok {
+		return false
+	}
+
+	inputBody := input.Body
+	expectBody := m.expect.Body
+
+	i, err := ioutil.ReadAll(inputBody)
+	if err != nil {
+		panic(err)
+	}
+	inputBody.Seek(0, 0)
+
+	e, err := ioutil.ReadAll(expectBody)
+	if err != nil {
+		panic(err)
+	}
+	m.expect.Body.Seek(0, 0)
+
+	if !reflect.DeepEqual(e, i) {
+		return false
+	}
+
+	input.Body = nil
+	m.expect.Body = nil
+
+	return reflect.DeepEqual(m.expect, input)
+}
+
+func (m UploadPartInputMatcher) String() string {
+	body, _ := ioutil.ReadAll(m.expect.Body)
+	m.expect.Body.Seek(0, 0)
+	return fmt.Sprintf("UploadPartInput(%d: %s)", *m.expect.PartNumber, body)
+}