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

package mocks

import (
	"time"

	"github.com/sirupsen/logrus"
	mock "github.com/stretchr/testify/mock"
)

// NewContext creates a new instance of Context. 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 NewContext(t interface {
	mock.TestingT
	Cleanup(func())
}) *Context {
	mock := &Context{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type Context_Expecter struct {
	mock *mock.Mock
}

func (_m *Context) EXPECT() *Context_Expecter {
	return &Context_Expecter{mock: &_m.Mock}
}

// Deadline provides a mock function for the type Context
func (_mock *Context) Deadline() (time.Time, bool) {
	ret := _mock.Called()

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

	var r0 time.Time
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func() (time.Time, bool)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(time.Time)
	}
	if returnFunc, ok := ret.Get(1).(func() bool); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

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

// Deadline is a helper method to define mock.On call
func (_e *Context_Expecter) Deadline() *Context_Deadline_Call {
	return &Context_Deadline_Call{Call: _e.mock.On("Deadline")}
}

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

func (_c *Context_Deadline_Call) Return(deadline time.Time, ok bool) *Context_Deadline_Call {
	_c.Call.Return(deadline, ok)
	return _c
}

func (_c *Context_Deadline_Call) RunAndReturn(run func() (time.Time, bool)) *Context_Deadline_Call {
	_c.Call.Return(run)
	return _c
}

// Done provides a mock function for the type Context
func (_mock *Context) Done() <-chan struct{} {
	ret := _mock.Called()

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

	var r0 <-chan struct{}
	if returnFunc, ok := ret.Get(0).(func() <-chan struct{}); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	return r0
}

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

// Done is a helper method to define mock.On call
func (_e *Context_Expecter) Done() *Context_Done_Call {
	return &Context_Done_Call{Call: _e.mock.On("Done")}
}

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

func (_c *Context_Done_Call) Return(valCh <-chan struct{}) *Context_Done_Call {
	_c.Call.Return(valCh)
	return _c
}

func (_c *Context_Done_Call) RunAndReturn(run func() <-chan struct{}) *Context_Done_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Err is a helper method to define mock.On call
func (_e *Context_Expecter) Err() *Context_Err_Call {
	return &Context_Err_Call{Call: _e.mock.On("Err")}
}

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

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

func (_c *Context_Err_Call) RunAndReturn(run func() error) *Context_Err_Call {
	_c.Call.Return(run)
	return _c
}

// Logger provides a mock function for the type Context
func (_mock *Context) Logger() *logrus.Entry {
	ret := _mock.Called()

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

	var r0 *logrus.Entry
	if returnFunc, ok := ret.Get(0).(func() *logrus.Entry); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*logrus.Entry)
		}
	}
	return r0
}

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

// Logger is a helper method to define mock.On call
func (_e *Context_Expecter) Logger() *Context_Logger_Call {
	return &Context_Logger_Call{Call: _e.mock.On("Logger")}
}

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

func (_c *Context_Logger_Call) Return(entry *logrus.Entry) *Context_Logger_Call {
	_c.Call.Return(entry)
	return _c
}

func (_c *Context_Logger_Call) RunAndReturn(run func() *logrus.Entry) *Context_Logger_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// RequestID is a helper method to define mock.On call
func (_e *Context_Expecter) RequestID() *Context_RequestID_Call {
	return &Context_RequestID_Call{Call: _e.mock.On("RequestID")}
}

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

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

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

// Value provides a mock function for the type Context
func (_mock *Context) Value(key any) any {
	ret := _mock.Called(key)

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

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

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

// Value is a helper method to define mock.On call
//   - key any
func (_e *Context_Expecter) Value(key interface{}) *Context_Value_Call {
	return &Context_Value_Call{Call: _e.mock.On("Value", key)}
}

func (_c *Context_Value_Call) Run(run func(key any)) *Context_Value_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 any
		if args[0] != nil {
			arg0 = args[0].(any)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *Context_Value_Call) Return(v any) *Context_Value_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *Context_Value_Call) RunAndReturn(run func(key any) any) *Context_Value_Call {
	_c.Call.Return(run)
	return _c
}