panel/mocks/biz/DatabaseRedisRepo.go

// Code generated by mockery. DO NOT EDIT.

package biz

import (
	request "github.com/acepanel/panel/internal/http/request"
	db "github.com/acepanel/panel/pkg/db"
	mock "github.com/stretchr/testify/mock"
)

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

type DatabaseRedisRepo_Expecter struct {
	mock *mock.Mock
}

func (_m *DatabaseRedisRepo) EXPECT() *DatabaseRedisRepo_Expecter {
	return &DatabaseRedisRepo_Expecter{mock: &_m.Mock}
}

// Clear provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) Clear(req *request.DatabaseRedisClear) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisClear) error); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Clear is a helper method to define mock.On call
//   - req *request.DatabaseRedisClear
func (_e *DatabaseRedisRepo_Expecter) Clear(req interface{}) *DatabaseRedisRepo_Clear_Call {
	return &DatabaseRedisRepo_Clear_Call{Call: _e.mock.On("Clear", req)}
}

func (_c *DatabaseRedisRepo_Clear_Call) Run(run func(req *request.DatabaseRedisClear)) *DatabaseRedisRepo_Clear_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisClear))
	})
	return _c
}

func (_c *DatabaseRedisRepo_Clear_Call) Return(_a0 error) *DatabaseRedisRepo_Clear_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DatabaseRedisRepo_Clear_Call) RunAndReturn(run func(*request.DatabaseRedisClear) error) *DatabaseRedisRepo_Clear_Call {
	_c.Call.Return(run)
	return _c
}

// Data provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) Data(req *request.DatabaseRedisData) ([]db.RedisKV, int, error) {
	ret := _m.Called(req)

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

	var r0 []db.RedisKV
	var r1 int
	var r2 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisData) ([]db.RedisKV, int, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisData) []db.RedisKV); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]db.RedisKV)
		}
	}

	if rf, ok := ret.Get(1).(func(*request.DatabaseRedisData) int); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Get(1).(int)
	}

	if rf, ok := ret.Get(2).(func(*request.DatabaseRedisData) error); ok {
		r2 = rf(req)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// Data is a helper method to define mock.On call
//   - req *request.DatabaseRedisData
func (_e *DatabaseRedisRepo_Expecter) Data(req interface{}) *DatabaseRedisRepo_Data_Call {
	return &DatabaseRedisRepo_Data_Call{Call: _e.mock.On("Data", req)}
}

func (_c *DatabaseRedisRepo_Data_Call) Run(run func(req *request.DatabaseRedisData)) *DatabaseRedisRepo_Data_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisData))
	})
	return _c
}

func (_c *DatabaseRedisRepo_Data_Call) Return(_a0 []db.RedisKV, _a1 int, _a2 error) *DatabaseRedisRepo_Data_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DatabaseRedisRepo_Data_Call) RunAndReturn(run func(*request.DatabaseRedisData) ([]db.RedisKV, int, error)) *DatabaseRedisRepo_Data_Call {
	_c.Call.Return(run)
	return _c
}

// Databases provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) Databases(req *request.DatabaseRedisDatabases) (int, error) {
	ret := _m.Called(req)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisDatabases) (int, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisDatabases) int); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Get(0).(int)
	}

	if rf, ok := ret.Get(1).(func(*request.DatabaseRedisDatabases) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Databases is a helper method to define mock.On call
//   - req *request.DatabaseRedisDatabases
func (_e *DatabaseRedisRepo_Expecter) Databases(req interface{}) *DatabaseRedisRepo_Databases_Call {
	return &DatabaseRedisRepo_Databases_Call{Call: _e.mock.On("Databases", req)}
}

func (_c *DatabaseRedisRepo_Databases_Call) Run(run func(req *request.DatabaseRedisDatabases)) *DatabaseRedisRepo_Databases_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisDatabases))
	})
	return _c
}

func (_c *DatabaseRedisRepo_Databases_Call) Return(_a0 int, _a1 error) *DatabaseRedisRepo_Databases_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DatabaseRedisRepo_Databases_Call) RunAndReturn(run func(*request.DatabaseRedisDatabases) (int, error)) *DatabaseRedisRepo_Databases_Call {
	_c.Call.Return(run)
	return _c
}

// KeyDelete provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) KeyDelete(req *request.DatabaseRedisKeyDelete) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeyDelete) error); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// KeyDelete is a helper method to define mock.On call
//   - req *request.DatabaseRedisKeyDelete
func (_e *DatabaseRedisRepo_Expecter) KeyDelete(req interface{}) *DatabaseRedisRepo_KeyDelete_Call {
	return &DatabaseRedisRepo_KeyDelete_Call{Call: _e.mock.On("KeyDelete", req)}
}

func (_c *DatabaseRedisRepo_KeyDelete_Call) Run(run func(req *request.DatabaseRedisKeyDelete)) *DatabaseRedisRepo_KeyDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisKeyDelete))
	})
	return _c
}

func (_c *DatabaseRedisRepo_KeyDelete_Call) Return(_a0 error) *DatabaseRedisRepo_KeyDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DatabaseRedisRepo_KeyDelete_Call) RunAndReturn(run func(*request.DatabaseRedisKeyDelete) error) *DatabaseRedisRepo_KeyDelete_Call {
	_c.Call.Return(run)
	return _c
}

// KeyGet provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) KeyGet(req *request.DatabaseRedisKeyGet) (*db.RedisKV, error) {
	ret := _m.Called(req)

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

	var r0 *db.RedisKV
	var r1 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeyGet) (*db.RedisKV, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeyGet) *db.RedisKV); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*db.RedisKV)
		}
	}

	if rf, ok := ret.Get(1).(func(*request.DatabaseRedisKeyGet) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// KeyGet is a helper method to define mock.On call
//   - req *request.DatabaseRedisKeyGet
func (_e *DatabaseRedisRepo_Expecter) KeyGet(req interface{}) *DatabaseRedisRepo_KeyGet_Call {
	return &DatabaseRedisRepo_KeyGet_Call{Call: _e.mock.On("KeyGet", req)}
}

func (_c *DatabaseRedisRepo_KeyGet_Call) Run(run func(req *request.DatabaseRedisKeyGet)) *DatabaseRedisRepo_KeyGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisKeyGet))
	})
	return _c
}

func (_c *DatabaseRedisRepo_KeyGet_Call) Return(_a0 *db.RedisKV, _a1 error) *DatabaseRedisRepo_KeyGet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DatabaseRedisRepo_KeyGet_Call) RunAndReturn(run func(*request.DatabaseRedisKeyGet) (*db.RedisKV, error)) *DatabaseRedisRepo_KeyGet_Call {
	_c.Call.Return(run)
	return _c
}

// KeyRename provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) KeyRename(req *request.DatabaseRedisKeyRename) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeyRename) error); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// KeyRename is a helper method to define mock.On call
//   - req *request.DatabaseRedisKeyRename
func (_e *DatabaseRedisRepo_Expecter) KeyRename(req interface{}) *DatabaseRedisRepo_KeyRename_Call {
	return &DatabaseRedisRepo_KeyRename_Call{Call: _e.mock.On("KeyRename", req)}
}

func (_c *DatabaseRedisRepo_KeyRename_Call) Run(run func(req *request.DatabaseRedisKeyRename)) *DatabaseRedisRepo_KeyRename_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisKeyRename))
	})
	return _c
}

func (_c *DatabaseRedisRepo_KeyRename_Call) Return(_a0 error) *DatabaseRedisRepo_KeyRename_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DatabaseRedisRepo_KeyRename_Call) RunAndReturn(run func(*request.DatabaseRedisKeyRename) error) *DatabaseRedisRepo_KeyRename_Call {
	_c.Call.Return(run)
	return _c
}

// KeySet provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) KeySet(req *request.DatabaseRedisKeySet) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeySet) error); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// KeySet is a helper method to define mock.On call
//   - req *request.DatabaseRedisKeySet
func (_e *DatabaseRedisRepo_Expecter) KeySet(req interface{}) *DatabaseRedisRepo_KeySet_Call {
	return &DatabaseRedisRepo_KeySet_Call{Call: _e.mock.On("KeySet", req)}
}

func (_c *DatabaseRedisRepo_KeySet_Call) Run(run func(req *request.DatabaseRedisKeySet)) *DatabaseRedisRepo_KeySet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisKeySet))
	})
	return _c
}

func (_c *DatabaseRedisRepo_KeySet_Call) Return(_a0 error) *DatabaseRedisRepo_KeySet_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DatabaseRedisRepo_KeySet_Call) RunAndReturn(run func(*request.DatabaseRedisKeySet) error) *DatabaseRedisRepo_KeySet_Call {
	_c.Call.Return(run)
	return _c
}

// KeyTTL provides a mock function with given fields: req
func (_m *DatabaseRedisRepo) KeyTTL(req *request.DatabaseRedisKeyTTL) error {
	ret := _m.Called(req)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*request.DatabaseRedisKeyTTL) error); ok {
		r0 = rf(req)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// KeyTTL is a helper method to define mock.On call
//   - req *request.DatabaseRedisKeyTTL
func (_e *DatabaseRedisRepo_Expecter) KeyTTL(req interface{}) *DatabaseRedisRepo_KeyTTL_Call {
	return &DatabaseRedisRepo_KeyTTL_Call{Call: _e.mock.On("KeyTTL", req)}
}

func (_c *DatabaseRedisRepo_KeyTTL_Call) Run(run func(req *request.DatabaseRedisKeyTTL)) *DatabaseRedisRepo_KeyTTL_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*request.DatabaseRedisKeyTTL))
	})
	return _c
}

func (_c *DatabaseRedisRepo_KeyTTL_Call) Return(_a0 error) *DatabaseRedisRepo_KeyTTL_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DatabaseRedisRepo_KeyTTL_Call) RunAndReturn(run func(*request.DatabaseRedisKeyTTL) error) *DatabaseRedisRepo_KeyTTL_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}