service.go

// Code generated by mockery v2.53.4. DO NOT EDIT.

package mocks

import (
	context "context"

	deploymentv1beta3 "github.com/akash-network/akash-api/go/node/deployment/v1beta3"
	mock "github.com/stretchr/testify/mock"

	rest "github.com/akash-network/akash-api/go/provider/client"

	types "github.com/cosmos/cosmos-sdk/types"

	v1 "github.com/akash-network/akash-api/go/provider/v1"

	v1beta3 "github.com/akash-network/provider/cluster/types/v1beta3"

	v1beta4 "github.com/akash-network/akash-api/go/node/market/v1beta4"

	v2beta2 "github.com/akash-network/provider/pkg/apis/akash.network/v2beta2"
)

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

type Service_Expecter struct {
	mock *mock.Mock
}

func (_m *Service) EXPECT() *Service_Expecter {
	return &Service_Expecter{mock: &_m.Mock}
}

// Close provides a mock function with no fields
func (_m *Service) Close() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Close is a helper method to define mock.On call
func (_e *Service_Expecter) Close() *Service_Close_Call {
	return &Service_Close_Call{Call: _e.mock.On("Close")}
}

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

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

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

// Done provides a mock function with no fields
func (_m *Service) Done() <-chan struct{} {
	ret := _m.Called()

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

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

	return r0
}

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

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

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

func (_c *Service_Done_Call) Return(_a0 <-chan struct{}) *Service_Done_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// FindActiveLease provides a mock function with given fields: ctx, owner, dseq, gseq
func (_m *Service) FindActiveLease(ctx context.Context, owner types.Address, dseq uint64, gseq uint32) (bool, v1beta4.LeaseID, v2beta2.ManifestGroup, error) {
	ret := _m.Called(ctx, owner, dseq, gseq)

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

	var r0 bool
	var r1 v1beta4.LeaseID
	var r2 v2beta2.ManifestGroup
	var r3 error
	if rf, ok := ret.Get(0).(func(context.Context, types.Address, uint64, uint32) (bool, v1beta4.LeaseID, v2beta2.ManifestGroup, error)); ok {
		return rf(ctx, owner, dseq, gseq)
	}
	if rf, ok := ret.Get(0).(func(context.Context, types.Address, uint64, uint32) bool); ok {
		r0 = rf(ctx, owner, dseq, gseq)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, types.Address, uint64, uint32) v1beta4.LeaseID); ok {
		r1 = rf(ctx, owner, dseq, gseq)
	} else {
		r1 = ret.Get(1).(v1beta4.LeaseID)
	}

	if rf, ok := ret.Get(2).(func(context.Context, types.Address, uint64, uint32) v2beta2.ManifestGroup); ok {
		r2 = rf(ctx, owner, dseq, gseq)
	} else {
		r2 = ret.Get(2).(v2beta2.ManifestGroup)
	}

	if rf, ok := ret.Get(3).(func(context.Context, types.Address, uint64, uint32) error); ok {
		r3 = rf(ctx, owner, dseq, gseq)
	} else {
		r3 = ret.Error(3)
	}

	return r0, r1, r2, r3
}

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

// FindActiveLease is a helper method to define mock.On call
//   - ctx context.Context
//   - owner types.Address
//   - dseq uint64
//   - gseq uint32
func (_e *Service_Expecter) FindActiveLease(ctx interface{}, owner interface{}, dseq interface{}, gseq interface{}) *Service_FindActiveLease_Call {
	return &Service_FindActiveLease_Call{Call: _e.mock.On("FindActiveLease", ctx, owner, dseq, gseq)}
}

func (_c *Service_FindActiveLease_Call) Run(run func(ctx context.Context, owner types.Address, dseq uint64, gseq uint32)) *Service_FindActiveLease_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(types.Address), args[2].(uint64), args[3].(uint32))
	})
	return _c
}

func (_c *Service_FindActiveLease_Call) Return(_a0 bool, _a1 v1beta4.LeaseID, _a2 v2beta2.ManifestGroup, _a3 error) *Service_FindActiveLease_Call {
	_c.Call.Return(_a0, _a1, _a2, _a3)
	return _c
}

func (_c *Service_FindActiveLease_Call) RunAndReturn(run func(context.Context, types.Address, uint64, uint32) (bool, v1beta4.LeaseID, v2beta2.ManifestGroup, error)) *Service_FindActiveLease_Call {
	_c.Call.Return(run)
	return _c
}

// HostnameService provides a mock function with no fields
func (_m *Service) HostnameService() v1beta3.HostnameServiceClient {
	ret := _m.Called()

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

	var r0 v1beta3.HostnameServiceClient
	if rf, ok := ret.Get(0).(func() v1beta3.HostnameServiceClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta3.HostnameServiceClient)
		}
	}

	return r0
}

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

// HostnameService is a helper method to define mock.On call
func (_e *Service_Expecter) HostnameService() *Service_HostnameService_Call {
	return &Service_HostnameService_Call{Call: _e.mock.On("HostnameService")}
}

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

func (_c *Service_HostnameService_Call) Return(_a0 v1beta3.HostnameServiceClient) *Service_HostnameService_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Service_HostnameService_Call) RunAndReturn(run func() v1beta3.HostnameServiceClient) *Service_HostnameService_Call {
	_c.Call.Return(run)
	return _c
}

// Ready provides a mock function with no fields
func (_m *Service) Ready() <-chan struct{} {
	ret := _m.Called()

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

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

	return r0
}

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

// Ready is a helper method to define mock.On call
func (_e *Service_Expecter) Ready() *Service_Ready_Call {
	return &Service_Ready_Call{Call: _e.mock.On("Ready")}
}

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

func (_c *Service_Ready_Call) Return(_a0 <-chan struct{}) *Service_Ready_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// Reserve provides a mock function with given fields: _a0, _a1
func (_m *Service) Reserve(_a0 v1beta4.OrderID, _a1 deploymentv1beta3.ResourceGroup) (v1beta3.Reservation, error) {
	ret := _m.Called(_a0, _a1)

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

	var r0 v1beta3.Reservation
	var r1 error
	if rf, ok := ret.Get(0).(func(v1beta4.OrderID, deploymentv1beta3.ResourceGroup) (v1beta3.Reservation, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(v1beta4.OrderID, deploymentv1beta3.ResourceGroup) v1beta3.Reservation); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(v1beta3.Reservation)
		}
	}

	if rf, ok := ret.Get(1).(func(v1beta4.OrderID, deploymentv1beta3.ResourceGroup) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Reserve is a helper method to define mock.On call
//   - _a0 v1beta4.OrderID
//   - _a1 deploymentv1beta3.ResourceGroup
func (_e *Service_Expecter) Reserve(_a0 interface{}, _a1 interface{}) *Service_Reserve_Call {
	return &Service_Reserve_Call{Call: _e.mock.On("Reserve", _a0, _a1)}
}

func (_c *Service_Reserve_Call) Run(run func(_a0 v1beta4.OrderID, _a1 deploymentv1beta3.ResourceGroup)) *Service_Reserve_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(v1beta4.OrderID), args[1].(deploymentv1beta3.ResourceGroup))
	})
	return _c
}

func (_c *Service_Reserve_Call) Return(_a0 v1beta3.Reservation, _a1 error) *Service_Reserve_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Service_Reserve_Call) RunAndReturn(run func(v1beta4.OrderID, deploymentv1beta3.ResourceGroup) (v1beta3.Reservation, error)) *Service_Reserve_Call {
	_c.Call.Return(run)
	return _c
}

// Status provides a mock function with given fields: _a0
func (_m *Service) Status(_a0 context.Context) (*rest.ClusterStatus, error) {
	ret := _m.Called(_a0)

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

	var r0 *rest.ClusterStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*rest.ClusterStatus, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *rest.ClusterStatus); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rest.ClusterStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Status is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *Service_Expecter) Status(_a0 interface{}) *Service_Status_Call {
	return &Service_Status_Call{Call: _e.mock.On("Status", _a0)}
}

func (_c *Service_Status_Call) Run(run func(_a0 context.Context)) *Service_Status_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *Service_Status_Call) Return(_a0 *rest.ClusterStatus, _a1 error) *Service_Status_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Service_Status_Call) RunAndReturn(run func(context.Context) (*rest.ClusterStatus, error)) *Service_Status_Call {
	_c.Call.Return(run)
	return _c
}

// StatusV1 provides a mock function with given fields: _a0
func (_m *Service) StatusV1(_a0 context.Context) (*v1.ClusterStatus, error) {
	ret := _m.Called(_a0)

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

	var r0 *v1.ClusterStatus
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*v1.ClusterStatus, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *v1.ClusterStatus); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1.ClusterStatus)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// StatusV1 is a helper method to define mock.On call
//   - _a0 context.Context
func (_e *Service_Expecter) StatusV1(_a0 interface{}) *Service_StatusV1_Call {
	return &Service_StatusV1_Call{Call: _e.mock.On("StatusV1", _a0)}
}

func (_c *Service_StatusV1_Call) Run(run func(_a0 context.Context)) *Service_StatusV1_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *Service_StatusV1_Call) Return(_a0 *v1.ClusterStatus, _a1 error) *Service_StatusV1_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Service_StatusV1_Call) RunAndReturn(run func(context.Context) (*v1.ClusterStatus, error)) *Service_StatusV1_Call {
	_c.Call.Return(run)
	return _c
}

// TransferHostname provides a mock function with given fields: ctx, leaseID, hostname, serviceName, externalPort
func (_m *Service) TransferHostname(ctx context.Context, leaseID v1beta4.LeaseID, hostname string, serviceName string, externalPort uint32) error {
	ret := _m.Called(ctx, leaseID, hostname, serviceName, externalPort)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, v1beta4.LeaseID, string, string, uint32) error); ok {
		r0 = rf(ctx, leaseID, hostname, serviceName, externalPort)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// TransferHostname is a helper method to define mock.On call
//   - ctx context.Context
//   - leaseID v1beta4.LeaseID
//   - hostname string
//   - serviceName string
//   - externalPort uint32
func (_e *Service_Expecter) TransferHostname(ctx interface{}, leaseID interface{}, hostname interface{}, serviceName interface{}, externalPort interface{}) *Service_TransferHostname_Call {
	return &Service_TransferHostname_Call{Call: _e.mock.On("TransferHostname", ctx, leaseID, hostname, serviceName, externalPort)}
}

func (_c *Service_TransferHostname_Call) Run(run func(ctx context.Context, leaseID v1beta4.LeaseID, hostname string, serviceName string, externalPort uint32)) *Service_TransferHostname_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(v1beta4.LeaseID), args[2].(string), args[3].(string), args[4].(uint32))
	})
	return _c
}

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

func (_c *Service_TransferHostname_Call) RunAndReturn(run func(context.Context, v1beta4.LeaseID, string, string, uint32) error) *Service_TransferHostname_Call {
	_c.Call.Return(run)
	return _c
}

// Unreserve provides a mock function with given fields: _a0
func (_m *Service) Unreserve(_a0 v1beta4.OrderID) error {
	ret := _m.Called(_a0)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(v1beta4.OrderID) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Unreserve is a helper method to define mock.On call
//   - _a0 v1beta4.OrderID
func (_e *Service_Expecter) Unreserve(_a0 interface{}) *Service_Unreserve_Call {
	return &Service_Unreserve_Call{Call: _e.mock.On("Unreserve", _a0)}
}

func (_c *Service_Unreserve_Call) Run(run func(_a0 v1beta4.OrderID)) *Service_Unreserve_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(v1beta4.OrderID))
	})
	return _c
}

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

func (_c *Service_Unreserve_Call) RunAndReturn(run func(v1beta4.OrderID) error) *Service_Unreserve_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}