From 6468a3ade7443a97df33717d2f277f2a2bf87bfd Mon Sep 17 00:00:00 2001 From: Johannes Boyne Date: Wed, 24 Feb 2016 10:12:02 +0100 Subject: [PATCH] initial commit --- .gitignore | 5 + README.md | 36 ++ cmd/main.go | 10 + gofakes3.go | 307 +++++++++++ gofakes3_test.go | 7 + mock/s3iface.go | 1303 ++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 1668 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 cmd/main.go create mode 100644 gofakes3.go create mode 100644 gofakes3_test.go create mode 100644 mock/s3iface.go diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..40f97c6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.DS_Store +DS_Store +node_modules/ +logs/ +*.db diff --git a/README.md b/README.md new file mode 100644 index 0000000..57120de --- /dev/null +++ b/README.md @@ -0,0 +1,36 @@ +# AWS (GOFAKE)S3 + +A golang AWS S3 fake server. + +A 'poor mans' object storage based on [BoltDB](https://github.com/boltdb/bolt). + +``` + s3client -> [gofakes3:9000] -- Get Bucket (List) + ^ |-- Create Bucket + | |-- Delete Bucket + | |-- Head Bucket + | | + | |-- Get Object + | |-- Create Object + | |-- Delete Object + | |-- Head Object + | V + XXXXXXXXXXXXXXXXXXXXX + XXXX XXXX + XXXX XXXX + XX XXX XXXXX + XX XXXXXXXXXXXXXXXXXX XX + XX XX + XX XX + XX BoltDB (Store) XX + XX ⚡️ XX + XX XX + XX XXX + XXX XXXX + XXXXXX XXXX + XXXXXXXXX +``` + +## What to use it for? + +We're using it in combination with local running AWS lambda functions. diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 0000000..7b0b88d --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,10 @@ +package main + +import ( + "github.com/johannesboyne/gofakes3" +) + +func main() { + faker := gofakes3.New() + faker.StartServer() +} diff --git a/gofakes3.go b/gofakes3.go new file mode 100644 index 0000000..8363938 --- /dev/null +++ b/gofakes3.go @@ -0,0 +1,307 @@ +//go:generate mockgen -destination mock/s3iface.go github.com/aws/aws-sdk-go/service/s3/s3iface S3API +package gofakes3 + +import ( + "crypto/md5" + "encoding/hex" + "encoding/xml" + "fmt" + "io" + "io/ioutil" + "log" + "net/http" + "strings" + "time" + + "github.com/boltdb/bolt" + "github.com/gorilla/mux" + "gopkg.in/mgo.v2/bson" +) + +type GoFakeS3 struct { + storage *bolt.DB +} +type Content struct { + Key string `xml:"Key"` + LastModified time.Time `xml:"LastModified"` + ETag string `xml:"ETag"` + Size int `xml:"Size"` + StorageClass string `xml:"StorageClass"` +} +type Bucket struct { + XMLName xml.Name `xml:"ListBucketResult"` + Xmlns string `xml:"xmlns,attr"` + Name string `xml:"Name"` + Prefix string `xml:"Prefix"` + Marker string `xml:"Marker"` + Contents []*Content `xml:"Contents"` +} +type Object struct { + Metadata map[string]string + Obj []byte +} + +// Setup a new fake object storage +func New() *GoFakeS3 { + db, err := bolt.Open("locals3.db", 0600, nil) + if err != nil { + log.Fatal(err) + } + + log.Println("locals3 db created or opened") + return &GoFakeS3{storage: db} +} + +// Start the AWS S3 API, port 9000 +func (g *GoFakeS3) StartServer() { + r := mux.NewRouter() + r.Queries("marker", "prefix") + // BUCKET + r.HandleFunc("/", g.GetBucket).Methods("GET") + r.HandleFunc("/", g.CreateBucket).Methods("PUT") + r.HandleFunc("/{BucketName}", g.CreateBucket).Methods("PUT") + r.HandleFunc("/", g.DeleteBucket).Methods("DELETE") + r.HandleFunc("/", g.HeadBucket).Methods("HEAD") + // OBJECT + r.HandleFunc("/{ObjectName:.{1,}}", g.GetObject).Methods("GET") + r.HandleFunc("/{ObjectName:.{1,}}", g.CreateObject).Methods("PUT") + r.HandleFunc("/", g.CreateObject).Methods("POST") + r.HandleFunc("/{ObjectName:.{1,}}", g.DeleteObject).Methods("DELETE") + r.HandleFunc("/{ObjectName:.{1,}}", g.HeadObject).Methods("HEAD") + + http.Handle("/", r) + http.ListenAndServe(":9000", nil) +} + +// GetBucket lists the contents of a bucket. +func (g *GoFakeS3) GetBucket(w http.ResponseWriter, r *http.Request) { + log.Println("GET BUCKET") + + bucketName := strings.Replace(r.Host, ".localhost:9000", "", -1) + + log.Println("bucketname:", bucketName) + log.Println("prefix :", r.URL.Query().Get("prefix")) + + g.storage.View(func(tx *bolt.Tx) error { + // Assume bucket exists and has keys + b := tx.Bucket([]byte(bucketName)) + if b == nil { + http.Error(w, "No bucket", http.StatusInternalServerError) + return nil + } + c := b.Cursor() + bucketc := &Bucket{ + Xmlns: "http://s3.amazonaws.com/doc/2006-03-01/", + Name: "crowdpatent.com", + Prefix: r.URL.Query().Get("prefix"), + Marker: "", + Contents: []*Content{}, + } + + for k, v := c.First(); k != nil; k, v = c.Next() { + fmt.Printf("%v %s %s\n", strings.Contains(string(k), r.URL.Query().Get("prefix")), string(k), r.URL.Query().Get("prefix")) + if strings.Contains(string(k), r.URL.Query().Get("prefix")) { + hash := md5.Sum(v) + bucketc.Contents = append(bucketc.Contents, &Content{ + Key: string(k), + LastModified: time.Now(), + ETag: "\"" + hex.EncodeToString(hash[:]) + "\"", + Size: len(v), + StorageClass: "STANDARD", + }) + t := Object{} + err := bson.Unmarshal(v, &t) + if err != nil { + panic(err) + } + log.Println(t) + } else { + fmt.Printf("%s | %s\n", string(k), r.URL.Query().Get("prefix")) + } + } + + x, err := xml.MarshalIndent(bucketc, "", " ") + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return nil + } + w.Write(x) + return nil + }) +} + +// CreateBucket creates a new S3 bucket in the BoltDB storage. +func (g *GoFakeS3) CreateBucket(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + var bucketName string + if len(vars["BucketName"]) > 0 { + bucketName = vars["BucketName"] + } else { + bucketName = strings.Replace(r.Host, ".localhost:9000", "", -1) + } + log.Println("CREATE BUCKET:", bucketName) + + g.storage.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte(bucketName)) + if err != nil { + http.Error(w, "bucket existed", http.StatusBadRequest) + return err + } + log.Println("bucket created") + w.Header().Set("Host", r.Header.Get("Host")) + w.Header().Set("Location", "/"+bucketName) + w.Write([]byte{}) + return nil + }) +} + +// CreateBucket creates a new S3 bucket in the BoltDB storage. +func (g *GoFakeS3) DeleteBucket(w http.ResponseWriter, r *http.Request) { + io.WriteString(w, "delete bucket") +} + +// HeadBucket checks whether a bucket exists. +func (g *GoFakeS3) HeadBucket(w http.ResponseWriter, r *http.Request) { + //@TODO(jb): implement + vars := mux.Vars(r) + log.Println("HEAD BUCKET", vars["BucketName"]) + io.WriteString(w, "head bucket") +} + +// GetObject retrievs a bucket object. +func (g *GoFakeS3) GetObject(w http.ResponseWriter, r *http.Request) { + log.Println("GET OBJECT") + vars := mux.Vars(r) + bucketName := strings.Replace(r.Host, ".localhost:9000", "", -1) + log.Println("Bucket:", bucketName) + log.Println("└── Object:", vars["ObjectName"]) + + g.storage.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte(bucketName)) + if b == nil { + log.Println("no bucket") + http.Error(w, "bucket does not exist", http.StatusInternalServerError) + } + v := b.Get([]byte(vars["ObjectName"])) + + if v == nil { + log.Println("no object") + http.Error(w, "object does not exist", http.StatusInternalServerError) + } + t := Object{} + err := bson.Unmarshal(v, &t) + if err != nil { + panic(err) + } + hash := md5.Sum(t.Obj) + w.Header().Set("x-amz-id-2", "LriYPLdmOdAiIfgSm/F1YsViT1LW94/xUQxMsF7xiEb1a0wiIOIxl+zbwZ163pt7") + w.Header().Set("x-amz-request-id", "0A49CE4060975EAC") + for mk, mv := range t.Metadata { + w.Header().Set(mk, mv) + } + w.Header().Set("Last-Modified", time.Now().Format("Mon, 2 Jan 2006 15:04:05 MST")) + w.Header().Set("ETag", "\""+hex.EncodeToString(hash[:])+"\"") + w.Header().Set("Server", "AmazonS3") + w.Header().Set("Content-Length", fmt.Sprintf("%v", len(t.Obj))) + w.Header().Set("Connection", "close") + w.Write(t.Obj) + return nil + }) +} + +// CreateObject creates a new S3 object. +func (g *GoFakeS3) CreateObject(w http.ResponseWriter, r *http.Request) { + vars := mux.Vars(r) + var bucketName string + if len(vars["BucketName"]) > 0 { + bucketName = vars["BucketName"] + } else { + bucketName = strings.Replace(r.Host, ".localhost:9000", "", -1) + } + log.Println("CREATE OBJECT:", bucketName, vars["ObjectName"]) + body, err := ioutil.ReadAll(r.Body) + if err != nil { + panic(err) + } + + meta := make(map[string]string) + for hk, hv := range r.Header { + if strings.Contains(hk, "X-Amz-") { + meta[hk] = hv[0] + } + } + meta["Last-Modified"] = time.Now().Format("Mon, 2 Jan 2006 15:04:05 MST") + + obj := &Object{meta, body} + log.Println(string(body)) + g.storage.Update(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte(bucketName)) + if b == nil { + log.Println("no bucket") + http.Error(w, "bucket does not exist", http.StatusInternalServerError) + return nil + } + log.Println("bucket", bucketName, "found") + data, err := bson.Marshal(obj) + if err != nil { + panic(err) + } + err = b.Put([]byte(vars["ObjectName"]), data) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return fmt.Errorf("error while creating") + } + w.Header().Set("x-amz-id-2", "LriYPLdmOdAiIfgSm/F1YsViT1LW94/xUQxMsF7xiEb1a0wiIOIxl+zbwZ163pt7") + w.Header().Set("x-amz-request-id", "0A49CE4060975EAC") + w.Header().Set("ETag", "\"fbacf535f27731c9771645a39863328\"") + w.Header().Set("Server", "AmazonS3") + w.Write([]byte{}) + return nil + }) +} + +// DeleteObject deletes a S3 object from the bucket. +func (g *GoFakeS3) DeleteObject(w http.ResponseWriter, r *http.Request) { + io.WriteString(w, "delete object") +} + +// HeadObject retrieves only meta information of an object and not the whole. +func (g *GoFakeS3) HeadObject(w http.ResponseWriter, r *http.Request) { + log.Println("HEAD OBJECT") + vars := mux.Vars(r) + bucketName := strings.Replace(r.Host, ".localhost:9000", "", -1) + log.Println("Bucket:", bucketName) + log.Println("└── Object:", vars["ObjectName"]) + + g.storage.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte(bucketName)) + if b == nil { + log.Println("no bucket") + http.Error(w, "bucket does not exist", http.StatusInternalServerError) + } + v := b.Get([]byte(vars["ObjectName"])) + + if v == nil { + log.Println("no object") + http.Error(w, "object does not exist", http.StatusInternalServerError) + } + t := Object{} + err := bson.Unmarshal(v, &t) + if err != nil { + panic(err) + } + hash := md5.Sum(t.Obj) + fmt.Printf("The answer is: %s\n", v) + w.Header().Set("x-amz-id-2", "LriYPLdmOdAiIfgSm/F1YsViT1LW94/xUQxMsF7xiEb1a0wiIOIxl+zbwZ163pt7") + w.Header().Set("x-amz-request-id", "0A49CE4060975EAC") + for mk, mv := range t.Metadata { + w.Header().Set(mk, mv) + } + w.Header().Set("Last-Modified", t.Metadata["Last-Modified"]) + w.Header().Set("ETag", "\""+hex.EncodeToString(hash[:])+"\"") + w.Header().Set("Server", "AmazonS3") + w.Write([]byte{}) + return nil + }) + +} diff --git a/gofakes3_test.go b/gofakes3_test.go new file mode 100644 index 0000000..e7b85ac --- /dev/null +++ b/gofakes3_test.go @@ -0,0 +1,7 @@ +package gofakes3 + +import "testing" + +func TestCreateBucket(t *testing.T) { + //@TODO(jb): implement them for sanity reasons +} diff --git a/mock/s3iface.go b/mock/s3iface.go new file mode 100644 index 0000000..7a95acf --- /dev/null +++ b/mock/s3iface.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 mock_s3iface + +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) +}