handler_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: cloudsidecar/pkg/aws/handler/s3 (interfaces: GCPClient,GCPObject,GCPBucket,HandlerInterface)

// Package s3 is a generated GoMock package.
package s3

import (
	storage "cloud.google.com/go/storage"
	context "context"
	s3iface "github.com/aws/aws-sdk-go-v2/service/s3/s3iface"
	gomock "github.com/golang/mock/gomock"
	viper "github.com/spf13/viper"
	http "net/http"
	reflect "reflect"
)

// MockGCPClient is a mock of GCPClient interface
type MockGCPClient struct {
	ctrl     *gomock.Controller
	recorder *MockGCPClientMockRecorder
}

// MockGCPClientMockRecorder is the mock recorder for MockGCPClient
type MockGCPClientMockRecorder struct {
	mock *MockGCPClient
}

// NewMockGCPClient creates a new mock instance
func NewMockGCPClient(ctrl *gomock.Controller) *MockGCPClient {
	mock := &MockGCPClient{ctrl: ctrl}
	mock.recorder = &MockGCPClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGCPClient) EXPECT() *MockGCPClientMockRecorder {
	return m.recorder
}

// Bucket mocks base method
func (m *MockGCPClient) Bucket(arg0 string) *storage.BucketHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bucket", arg0)
	ret0, _ := ret[0].(*storage.BucketHandle)
	return ret0
}

// Bucket indicates an expected call of Bucket
func (mr *MockGCPClientMockRecorder) Bucket(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockGCPClient)(nil).Bucket), arg0)
}

// Close mocks base method
func (m *MockGCPClient) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockGCPClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGCPClient)(nil).Close))
}

// MockGCPObject is a mock of GCPObject interface
type MockGCPObject struct {
	ctrl     *gomock.Controller
	recorder *MockGCPObjectMockRecorder
}

// MockGCPObjectMockRecorder is the mock recorder for MockGCPObject
type MockGCPObjectMockRecorder struct {
	mock *MockGCPObject
}

// NewMockGCPObject creates a new mock instance
func NewMockGCPObject(ctrl *gomock.Controller) *MockGCPObject {
	mock := &MockGCPObject{ctrl: ctrl}
	mock.recorder = &MockGCPObjectMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGCPObject) EXPECT() *MockGCPObjectMockRecorder {
	return m.recorder
}

// ACL mocks base method
func (m *MockGCPObject) ACL() *storage.ACLHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACL")
	ret0, _ := ret[0].(*storage.ACLHandle)
	return ret0
}

// ACL indicates an expected call of ACL
func (mr *MockGCPObjectMockRecorder) ACL() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACL", reflect.TypeOf((*MockGCPObject)(nil).ACL))
}

// Attrs mocks base method
func (m *MockGCPObject) Attrs(arg0 context.Context) (*storage.ObjectAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", arg0)
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Attrs indicates an expected call of Attrs
func (mr *MockGCPObjectMockRecorder) Attrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockGCPObject)(nil).Attrs), arg0)
}

// BucketName mocks base method
func (m *MockGCPObject) BucketName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BucketName")
	ret0, _ := ret[0].(string)
	return ret0
}

// BucketName indicates an expected call of BucketName
func (mr *MockGCPObjectMockRecorder) BucketName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BucketName", reflect.TypeOf((*MockGCPObject)(nil).BucketName))
}

// ComposerFrom mocks base method
func (m *MockGCPObject) ComposerFrom(arg0 ...*storage.ObjectHandle) *storage.Composer {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ComposerFrom", varargs...)
	ret0, _ := ret[0].(*storage.Composer)
	return ret0
}

// ComposerFrom indicates an expected call of ComposerFrom
func (mr *MockGCPObjectMockRecorder) ComposerFrom(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComposerFrom", reflect.TypeOf((*MockGCPObject)(nil).ComposerFrom), arg0...)
}

// CopierFrom mocks base method
func (m *MockGCPObject) CopierFrom(arg0 *storage.ObjectHandle) *storage.Copier {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopierFrom", arg0)
	ret0, _ := ret[0].(*storage.Copier)
	return ret0
}

// CopierFrom indicates an expected call of CopierFrom
func (mr *MockGCPObjectMockRecorder) CopierFrom(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopierFrom", reflect.TypeOf((*MockGCPObject)(nil).CopierFrom), arg0)
}

// Delete mocks base method
func (m *MockGCPObject) Delete(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockGCPObjectMockRecorder) Delete(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockGCPObject)(nil).Delete), arg0)
}

// Generation mocks base method
func (m *MockGCPObject) Generation(arg0 int64) *storage.ObjectHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Generation", arg0)
	ret0, _ := ret[0].(*storage.ObjectHandle)
	return ret0
}

// Generation indicates an expected call of Generation
func (mr *MockGCPObjectMockRecorder) Generation(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generation", reflect.TypeOf((*MockGCPObject)(nil).Generation), arg0)
}

// If mocks base method
func (m *MockGCPObject) If(arg0 storage.Conditions) *storage.ObjectHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "If", arg0)
	ret0, _ := ret[0].(*storage.ObjectHandle)
	return ret0
}

// If indicates an expected call of If
func (mr *MockGCPObjectMockRecorder) If(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "If", reflect.TypeOf((*MockGCPObject)(nil).If), arg0)
}

// Key mocks base method
func (m *MockGCPObject) Key(arg0 []byte) *storage.ObjectHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key", arg0)
	ret0, _ := ret[0].(*storage.ObjectHandle)
	return ret0
}

// Key indicates an expected call of Key
func (mr *MockGCPObjectMockRecorder) Key(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockGCPObject)(nil).Key), arg0)
}

// NewRangeReader mocks base method
func (m *MockGCPObject) NewRangeReader(arg0 context.Context, arg1, arg2 int64) (*storage.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRangeReader", arg0, arg1, arg2)
	ret0, _ := ret[0].(*storage.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRangeReader indicates an expected call of NewRangeReader
func (mr *MockGCPObjectMockRecorder) NewRangeReader(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRangeReader", reflect.TypeOf((*MockGCPObject)(nil).NewRangeReader), arg0, arg1, arg2)
}

// NewReader mocks base method
func (m *MockGCPObject) NewReader(arg0 context.Context) (*storage.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReader", arg0)
	ret0, _ := ret[0].(*storage.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReader indicates an expected call of NewReader
func (mr *MockGCPObjectMockRecorder) NewReader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReader", reflect.TypeOf((*MockGCPObject)(nil).NewReader), arg0)
}

// NewWriter mocks base method
func (m *MockGCPObject) NewWriter(arg0 context.Context) *storage.Writer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewWriter", arg0)
	ret0, _ := ret[0].(*storage.Writer)
	return ret0
}

// NewWriter indicates an expected call of NewWriter
func (mr *MockGCPObjectMockRecorder) NewWriter(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewWriter", reflect.TypeOf((*MockGCPObject)(nil).NewWriter), arg0)
}

// ObjectName mocks base method
func (m *MockGCPObject) ObjectName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectName")
	ret0, _ := ret[0].(string)
	return ret0
}

// ObjectName indicates an expected call of ObjectName
func (mr *MockGCPObjectMockRecorder) ObjectName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectName", reflect.TypeOf((*MockGCPObject)(nil).ObjectName))
}

// ReadCompressed mocks base method
func (m *MockGCPObject) ReadCompressed(arg0 bool) *storage.ObjectHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadCompressed", arg0)
	ret0, _ := ret[0].(*storage.ObjectHandle)
	return ret0
}

// ReadCompressed indicates an expected call of ReadCompressed
func (mr *MockGCPObjectMockRecorder) ReadCompressed(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadCompressed", reflect.TypeOf((*MockGCPObject)(nil).ReadCompressed), arg0)
}

// Update mocks base method
func (m *MockGCPObject) Update(arg0 context.Context, arg1 storage.ObjectAttrsToUpdate) (*storage.ObjectAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update
func (mr *MockGCPObjectMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGCPObject)(nil).Update), arg0, arg1)
}

// MockGCPBucket is a mock of GCPBucket interface
type MockGCPBucket struct {
	ctrl     *gomock.Controller
	recorder *MockGCPBucketMockRecorder
}

// MockGCPBucketMockRecorder is the mock recorder for MockGCPBucket
type MockGCPBucketMockRecorder struct {
	mock *MockGCPBucket
}

// NewMockGCPBucket creates a new mock instance
func NewMockGCPBucket(ctrl *gomock.Controller) *MockGCPBucket {
	mock := &MockGCPBucket{ctrl: ctrl}
	mock.recorder = &MockGCPBucketMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGCPBucket) EXPECT() *MockGCPBucketMockRecorder {
	return m.recorder
}

// ACL mocks base method
func (m *MockGCPBucket) ACL() *storage.ACLHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACL")
	ret0, _ := ret[0].(*storage.ACLHandle)
	return ret0
}

// ACL indicates an expected call of ACL
func (mr *MockGCPBucketMockRecorder) ACL() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACL", reflect.TypeOf((*MockGCPBucket)(nil).ACL))
}

// Attrs mocks base method
func (m *MockGCPBucket) Attrs(arg0 context.Context) (*storage.BucketAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", arg0)
	ret0, _ := ret[0].(*storage.BucketAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Attrs indicates an expected call of Attrs
func (mr *MockGCPBucketMockRecorder) Attrs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockGCPBucket)(nil).Attrs), arg0)
}

// Create mocks base method
func (m *MockGCPBucket) Create(arg0 context.Context, arg1 string, arg2 *storage.BucketAttrs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create
func (mr *MockGCPBucketMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockGCPBucket)(nil).Create), arg0, arg1, arg2)
}

// DefaultObjectACL mocks base method
func (m *MockGCPBucket) DefaultObjectACL() *storage.ACLHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DefaultObjectACL")
	ret0, _ := ret[0].(*storage.ACLHandle)
	return ret0
}

// DefaultObjectACL indicates an expected call of DefaultObjectACL
func (mr *MockGCPBucketMockRecorder) DefaultObjectACL() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultObjectACL", reflect.TypeOf((*MockGCPBucket)(nil).DefaultObjectACL))
}

// Delete mocks base method
func (m *MockGCPBucket) Delete(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete
func (mr *MockGCPBucketMockRecorder) Delete(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockGCPBucket)(nil).Delete), arg0)
}

// If mocks base method
func (m *MockGCPBucket) If(arg0 storage.BucketConditions) *storage.BucketHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "If", arg0)
	ret0, _ := ret[0].(*storage.BucketHandle)
	return ret0
}

// If indicates an expected call of If
func (mr *MockGCPBucketMockRecorder) If(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "If", reflect.TypeOf((*MockGCPBucket)(nil).If), arg0)
}

// LockRetentionPolicy mocks base method
func (m *MockGCPBucket) LockRetentionPolicy(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockRetentionPolicy", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// LockRetentionPolicy indicates an expected call of LockRetentionPolicy
func (mr *MockGCPBucketMockRecorder) LockRetentionPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockRetentionPolicy", reflect.TypeOf((*MockGCPBucket)(nil).LockRetentionPolicy), arg0)
}

// Object mocks base method
func (m *MockGCPBucket) Object(arg0 string) *storage.ObjectHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Object", arg0)
	ret0, _ := ret[0].(*storage.ObjectHandle)
	return ret0
}

// Object indicates an expected call of Object
func (mr *MockGCPBucketMockRecorder) Object(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Object", reflect.TypeOf((*MockGCPBucket)(nil).Object), arg0)
}

// Objects mocks base method
func (m *MockGCPBucket) Objects(arg0 context.Context, arg1 *storage.Query) *storage.ObjectIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Objects", arg0, arg1)
	ret0, _ := ret[0].(*storage.ObjectIterator)
	return ret0
}

// Objects indicates an expected call of Objects
func (mr *MockGCPBucketMockRecorder) Objects(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Objects", reflect.TypeOf((*MockGCPBucket)(nil).Objects), arg0, arg1)
}

// Update mocks base method
func (m *MockGCPBucket) Update(arg0 context.Context, arg1 storage.BucketAttrsToUpdate) (*storage.BucketAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1)
	ret0, _ := ret[0].(*storage.BucketAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update
func (mr *MockGCPBucketMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockGCPBucket)(nil).Update), arg0, arg1)
}

// UserProject mocks base method
func (m *MockGCPBucket) UserProject(arg0 string) *storage.BucketHandle {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserProject", arg0)
	ret0, _ := ret[0].(*storage.BucketHandle)
	return ret0
}

// UserProject indicates an expected call of UserProject
func (mr *MockGCPBucketMockRecorder) UserProject(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserProject", reflect.TypeOf((*MockGCPBucket)(nil).UserProject), arg0)
}

// MockHandlerInterface is a mock of HandlerInterface interface
type MockHandlerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockHandlerInterfaceMockRecorder
}

// MockHandlerInterfaceMockRecorder is the mock recorder for MockHandlerInterface
type MockHandlerInterfaceMockRecorder struct {
	mock *MockHandlerInterface
}

// NewMockHandlerInterface creates a new mock instance
func NewMockHandlerInterface(ctrl *gomock.Controller) *MockHandlerInterface {
	mock := &MockHandlerInterface{ctrl: ctrl}
	mock.recorder = &MockHandlerInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockHandlerInterface) EXPECT() *MockHandlerInterfaceMockRecorder {
	return m.recorder
}

// GCPRequestSetup mocks base method
func (m *MockHandlerInterface) GCPRequestSetup(arg0 *http.Request) GCPClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GCPRequestSetup", arg0)
	ret0, _ := ret[0].(GCPClient)
	return ret0
}

// GCPRequestSetup indicates an expected call of GCPRequestSetup
func (mr *MockHandlerInterfaceMockRecorder) GCPRequestSetup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GCPRequestSetup", reflect.TypeOf((*MockHandlerInterface)(nil).GCPRequestSetup), arg0)
}

// GetConfig mocks base method
func (m *MockHandlerInterface) GetConfig() *viper.Viper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(*viper.Viper)
	return ret0
}

// GetConfig indicates an expected call of GetConfig
func (mr *MockHandlerInterfaceMockRecorder) GetConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockHandlerInterface)(nil).GetConfig))
}

// GetContext mocks base method
func (m *MockHandlerInterface) GetContext() *context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContext")
	ret0, _ := ret[0].(*context.Context)
	return ret0
}

// GetContext indicates an expected call of GetContext
func (mr *MockHandlerInterfaceMockRecorder) GetContext() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContext", reflect.TypeOf((*MockHandlerInterface)(nil).GetContext))
}

// GetGCPClient mocks base method
func (m *MockHandlerInterface) GetGCPClient(arg0 string) GCPClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGCPClient", arg0)
	ret0, _ := ret[0].(GCPClient)
	return ret0
}

// GetGCPClient indicates an expected call of GetGCPClient
func (mr *MockHandlerInterfaceMockRecorder) GetGCPClient(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCPClient", reflect.TypeOf((*MockHandlerInterface)(nil).GetGCPClient), arg0)
}

// GetS3Client mocks base method
func (m *MockHandlerInterface) GetS3Client() s3iface.S3API {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetS3Client")
	ret0, _ := ret[0].(s3iface.S3API)
	return ret0
}

// GetS3Client indicates an expected call of GetS3Client
func (mr *MockHandlerInterfaceMockRecorder) GetS3Client() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetS3Client", reflect.TypeOf((*MockHandlerInterface)(nil).GetS3Client))
}

// SetConfig mocks base method
func (m *MockHandlerInterface) SetConfig(arg0 *viper.Viper) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConfig", arg0)
}

// SetConfig indicates an expected call of SetConfig
func (mr *MockHandlerInterfaceMockRecorder) SetConfig(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfig", reflect.TypeOf((*MockHandlerInterface)(nil).SetConfig), arg0)
}

// SetContext mocks base method
func (m *MockHandlerInterface) SetContext(arg0 *context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetContext", arg0)
}

// SetContext indicates an expected call of SetContext
func (mr *MockHandlerInterfaceMockRecorder) SetContext(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetContext", reflect.TypeOf((*MockHandlerInterface)(nil).SetContext), arg0)
}

// SetGCPClient mocks base method
func (m *MockHandlerInterface) SetGCPClient(arg0 string, arg1 GCPClient) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGCPClient", arg0, arg1)
}

// SetGCPClient indicates an expected call of SetGCPClient
func (mr *MockHandlerInterfaceMockRecorder) SetGCPClient(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCPClient", reflect.TypeOf((*MockHandlerInterface)(nil).SetGCPClient), arg0, arg1)
}

// SetGCPClientFromCreds mocks base method
func (m *MockHandlerInterface) SetGCPClientFromCreds(arg0 *string) GCPClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGCPClientFromCreds", arg0)
	ret0, _ := ret[0].(GCPClient)
	return ret0
}

// SetGCPClientFromCreds indicates an expected call of SetGCPClientFromCreds
func (mr *MockHandlerInterfaceMockRecorder) SetGCPClientFromCreds(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCPClientFromCreds", reflect.TypeOf((*MockHandlerInterface)(nil).SetGCPClientFromCreds), arg0)
}

// SetS3Client mocks base method
func (m *MockHandlerInterface) SetS3Client(arg0 s3iface.S3API) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetS3Client", arg0)
}

// SetS3Client indicates an expected call of SetS3Client
func (mr *MockHandlerInterfaceMockRecorder) SetS3Client(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetS3Client", reflect.TypeOf((*MockHandlerInterface)(nil).SetS3Client), arg0)
}

// MockGCPObjectWriter is a mock of GCPObjectWriter interface
type MockGCPObjectWriter struct {
	ctrl     *gomock.Controller
	recorder *MockGCPObjectWriterMockRecorder
}

// MockGCPObjectWriterMockRecorder is the mock recorder for MockGCPObjectWriter
type MockGCPObjectWriterMockRecorder struct {
	mock *MockGCPObjectWriter
}

// NewMockGCPObjectWriter creates a new mock instance
func NewMockGCPObjectWriter(ctrl *gomock.Controller) *MockGCPObjectWriter {
	mock := &MockGCPObjectWriter{ctrl: ctrl}
	mock.recorder = &MockGCPObjectWriterMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockGCPObjectWriter) EXPECT() *MockGCPObjectWriterMockRecorder {
	return m.recorder
}

// Write mocks base method
func (m *MockGCPObjectWriter) Write(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write
func (mr *MockGCPObjectWriterMockRecorder) Write(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockGCPObjectWriter)(nil).Write), p)
}

// Close mocks base method
func (m *MockGCPObjectWriter) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close
func (mr *MockGCPObjectWriterMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGCPObjectWriter)(nil).Close))
}

// CloseWithError mocks base method
func (m *MockGCPObjectWriter) CloseWithError(err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseWithError", err)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseWithError indicates an expected call of CloseWithError
func (mr *MockGCPObjectWriterMockRecorder) CloseWithError(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockGCPObjectWriter)(nil).CloseWithError), err)
}

// Attrs mocks base method
func (m *MockGCPObjectWriter) Attrs() *storage.ObjectAttrs {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs")
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	return ret0
}

// Attrs indicates an expected call of Attrs
func (mr *MockGCPObjectWriterMockRecorder) Attrs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockGCPObjectWriter)(nil).Attrs))
}