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

package mocks

import (
	"context"

	"github.com/google/uuid"
	mock "github.com/stretchr/testify/mock"
	"gitlab.golang-school.ru/potok-2/lessons/lesson-17/internal/domain"
)

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

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

	return mock
}

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

type Redis_Expecter struct {
	mock *mock.Mock
}

func (_m *Redis) EXPECT() *Redis_Expecter {
	return &Redis_Expecter{mock: &_m.Mock}
}

// IsExists provides a mock function for the type Redis
func (_mock *Redis) IsExists(ctx context.Context, idempotencyKey string) bool {
	ret := _mock.Called(ctx, idempotencyKey)

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

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

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

// IsExists is a helper method to define mock.On call
//   - ctx
//   - idempotencyKey
func (_e *Redis_Expecter) IsExists(ctx interface{}, idempotencyKey interface{}) *Redis_IsExists_Call {
	return &Redis_IsExists_Call{Call: _e.mock.On("IsExists", ctx, idempotencyKey)}
}

func (_c *Redis_IsExists_Call) Run(run func(ctx context.Context, idempotencyKey string)) *Redis_IsExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *Redis_IsExists_Call) Return(b bool) *Redis_IsExists_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *Redis_IsExists_Call) RunAndReturn(run func(ctx context.Context, idempotencyKey string) bool) *Redis_IsExists_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type Postgres_Expecter struct {
	mock *mock.Mock
}

func (_m *Postgres) EXPECT() *Postgres_Expecter {
	return &Postgres_Expecter{mock: &_m.Mock}
}

// CreateProfile provides a mock function for the type Postgres
func (_mock *Postgres) CreateProfile(ctx context.Context, profile domain.Profile) error {
	ret := _mock.Called(ctx, profile)

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

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

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

// CreateProfile is a helper method to define mock.On call
//   - ctx
//   - profile
func (_e *Postgres_Expecter) CreateProfile(ctx interface{}, profile interface{}) *Postgres_CreateProfile_Call {
	return &Postgres_CreateProfile_Call{Call: _e.mock.On("CreateProfile", ctx, profile)}
}

func (_c *Postgres_CreateProfile_Call) Run(run func(ctx context.Context, profile domain.Profile)) *Postgres_CreateProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Profile))
	})
	return _c
}

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

func (_c *Postgres_CreateProfile_Call) RunAndReturn(run func(ctx context.Context, profile domain.Profile) error) *Postgres_CreateProfile_Call {
	_c.Call.Return(run)
	return _c
}

// CreateProperty provides a mock function for the type Postgres
func (_mock *Postgres) CreateProperty(ctx context.Context, property domain.Property) error {
	ret := _mock.Called(ctx, property)

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

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

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

// CreateProperty is a helper method to define mock.On call
//   - ctx
//   - property
func (_e *Postgres_Expecter) CreateProperty(ctx interface{}, property interface{}) *Postgres_CreateProperty_Call {
	return &Postgres_CreateProperty_Call{Call: _e.mock.On("CreateProperty", ctx, property)}
}

func (_c *Postgres_CreateProperty_Call) Run(run func(ctx context.Context, property domain.Property)) *Postgres_CreateProperty_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Property))
	})
	return _c
}

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

func (_c *Postgres_CreateProperty_Call) RunAndReturn(run func(ctx context.Context, property domain.Property) error) *Postgres_CreateProperty_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteProfile provides a mock function for the type Postgres
func (_mock *Postgres) DeleteProfile(ctx context.Context, id uuid.UUID) error {
	ret := _mock.Called(ctx, id)

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

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

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

// DeleteProfile is a helper method to define mock.On call
//   - ctx
//   - id
func (_e *Postgres_Expecter) DeleteProfile(ctx interface{}, id interface{}) *Postgres_DeleteProfile_Call {
	return &Postgres_DeleteProfile_Call{Call: _e.mock.On("DeleteProfile", ctx, id)}
}

func (_c *Postgres_DeleteProfile_Call) Run(run func(ctx context.Context, id uuid.UUID)) *Postgres_DeleteProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

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

func (_c *Postgres_DeleteProfile_Call) RunAndReturn(run func(ctx context.Context, id uuid.UUID) error) *Postgres_DeleteProfile_Call {
	_c.Call.Return(run)
	return _c
}

// GetProfile provides a mock function for the type Postgres
func (_mock *Postgres) GetProfile(ctx context.Context, profileID uuid.UUID) (domain.Profile, error) {
	ret := _mock.Called(ctx, profileID)

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

	var r0 domain.Profile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID) (domain.Profile, error)); ok {
		return returnFunc(ctx, profileID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID) domain.Profile); ok {
		r0 = returnFunc(ctx, profileID)
	} else {
		r0 = ret.Get(0).(domain.Profile)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID) error); ok {
		r1 = returnFunc(ctx, profileID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetProfile is a helper method to define mock.On call
//   - ctx
//   - profileID
func (_e *Postgres_Expecter) GetProfile(ctx interface{}, profileID interface{}) *Postgres_GetProfile_Call {
	return &Postgres_GetProfile_Call{Call: _e.mock.On("GetProfile", ctx, profileID)}
}

func (_c *Postgres_GetProfile_Call) Run(run func(ctx context.Context, profileID uuid.UUID)) *Postgres_GetProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(uuid.UUID))
	})
	return _c
}

func (_c *Postgres_GetProfile_Call) Return(profile domain.Profile, err error) *Postgres_GetProfile_Call {
	_c.Call.Return(profile, err)
	return _c
}

func (_c *Postgres_GetProfile_Call) RunAndReturn(run func(ctx context.Context, profileID uuid.UUID) (domain.Profile, error)) *Postgres_GetProfile_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateProfile provides a mock function for the type Postgres
func (_mock *Postgres) UpdateProfile(ctx context.Context, profile domain.Profile) error {
	ret := _mock.Called(ctx, profile)

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

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

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

// UpdateProfile is a helper method to define mock.On call
//   - ctx
//   - profile
func (_e *Postgres_Expecter) UpdateProfile(ctx interface{}, profile interface{}) *Postgres_UpdateProfile_Call {
	return &Postgres_UpdateProfile_Call{Call: _e.mock.On("UpdateProfile", ctx, profile)}
}

func (_c *Postgres_UpdateProfile_Call) Run(run func(ctx context.Context, profile domain.Profile)) *Postgres_UpdateProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.Profile))
	})
	return _c
}

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

func (_c *Postgres_UpdateProfile_Call) RunAndReturn(run func(ctx context.Context, profile domain.Profile) error) *Postgres_UpdateProfile_Call {
	_c.Call.Return(run)
	return _c
}