// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"
	"io"

	"bnema.dev/ermite/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

// NewMultipartUpload creates a new instance of MultipartUpload. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMultipartUpload(t interface {
	mock.TestingT
	Cleanup(func())
}) *MultipartUpload {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MultipartUpload{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MultipartUpload is an autogenerated mock type for the MultipartUpload type
type MultipartUpload struct {
	mock.Mock
}

type MultipartUpload_Expecter struct {
	mock *mock.Mock
}

func (_m *MultipartUpload) EXPECT() *MultipartUpload_Expecter {
	return &MultipartUpload_Expecter{mock: &_m.Mock}
}

// Abort provides a mock function for the type MultipartUpload
func (_mock *MultipartUpload) Abort(ctx context.Context) error {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Abort")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MultipartUpload_Abort_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Abort'
type MultipartUpload_Abort_Call struct {
	*mock.Call
}

// Abort is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MultipartUpload_Expecter) Abort(ctx any) *MultipartUpload_Abort_Call {
	return &MultipartUpload_Abort_Call{Call: _e.mock.On("Abort", ctx)}
}

func (_c *MultipartUpload_Abort_Call) Run(run func(ctx context.Context)) *MultipartUpload_Abort_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MultipartUpload_Abort_Call) Return(err error) *MultipartUpload_Abort_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MultipartUpload_Abort_Call) RunAndReturn(run func(ctx context.Context) error) *MultipartUpload_Abort_Call {
	_c.Call.Return(run)
	return _c
}

// Complete provides a mock function for the type MultipartUpload
func (_mock *MultipartUpload) Complete(ctx context.Context) (ports.BlobInfo, error) {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Complete")
	}

	var r0 ports.BlobInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (ports.BlobInfo, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) ports.BlobInfo); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(ports.BlobInfo)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MultipartUpload_Complete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Complete'
type MultipartUpload_Complete_Call struct {
	*mock.Call
}

// Complete is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MultipartUpload_Expecter) Complete(ctx any) *MultipartUpload_Complete_Call {
	return &MultipartUpload_Complete_Call{Call: _e.mock.On("Complete", ctx)}
}

func (_c *MultipartUpload_Complete_Call) Run(run func(ctx context.Context)) *MultipartUpload_Complete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MultipartUpload_Complete_Call) Return(blobInfo ports.BlobInfo, err error) *MultipartUpload_Complete_Call {
	_c.Call.Return(blobInfo, err)
	return _c
}

func (_c *MultipartUpload_Complete_Call) RunAndReturn(run func(ctx context.Context) (ports.BlobInfo, error)) *MultipartUpload_Complete_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function for the type MultipartUpload
func (_mock *MultipartUpload) ID() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for ID")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MultipartUpload_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
type MultipartUpload_ID_Call struct {
	*mock.Call
}

// ID is a helper method to define mock.On call
func (_e *MultipartUpload_Expecter) ID() *MultipartUpload_ID_Call {
	return &MultipartUpload_ID_Call{Call: _e.mock.On("ID")}
}

func (_c *MultipartUpload_ID_Call) Run(run func()) *MultipartUpload_ID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MultipartUpload_ID_Call) Return(s string) *MultipartUpload_ID_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MultipartUpload_ID_Call) RunAndReturn(run func() string) *MultipartUpload_ID_Call {
	_c.Call.Return(run)
	return _c
}

// UploadPart provides a mock function for the type MultipartUpload
func (_mock *MultipartUpload) UploadPart(ctx context.Context, n int, r io.Reader, size int64) error {
	ret := _mock.Called(ctx, n, r, size)

	if len(ret) == 0 {
		panic("no return value specified for UploadPart")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, io.Reader, int64) error); ok {
		r0 = returnFunc(ctx, n, r, size)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MultipartUpload_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart'
type MultipartUpload_UploadPart_Call struct {
	*mock.Call
}

// UploadPart is a helper method to define mock.On call
//   - ctx context.Context
//   - n int
//   - r io.Reader
//   - size int64
func (_e *MultipartUpload_Expecter) UploadPart(ctx any, n any, r any, size any) *MultipartUpload_UploadPart_Call {
	return &MultipartUpload_UploadPart_Call{Call: _e.mock.On("UploadPart", ctx, n, r, size)}
}

func (_c *MultipartUpload_UploadPart_Call) Run(run func(ctx context.Context, n int, r io.Reader, size int64)) *MultipartUpload_UploadPart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 io.Reader
		if args[2] != nil {
			arg2 = args[2].(io.Reader)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MultipartUpload_UploadPart_Call) Return(err error) *MultipartUpload_UploadPart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MultipartUpload_UploadPart_Call) RunAndReturn(run func(ctx context.Context, n int, r io.Reader, size int64) error) *MultipartUpload_UploadPart_Call {
	_c.Call.Return(run)
	return _c
}