code.vegaprotocol.io/vega@v0.79.0/core/referral/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/referral (interfaces: EpochEngine,Broker,TimeService,MarketActivityTracker,StakingBalances)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"
	time "time"

	events "code.vegaprotocol.io/vega/core/events"
	types "code.vegaprotocol.io/vega/core/types"
	num "code.vegaprotocol.io/vega/libs/num"
	gomock "github.com/golang/mock/gomock"
)

// MockEpochEngine is a mock of EpochEngine interface.
type MockEpochEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEpochEngineMockRecorder
}

// MockEpochEngineMockRecorder is the mock recorder for MockEpochEngine.
type MockEpochEngineMockRecorder struct {
	mock *MockEpochEngine
}

// NewMockEpochEngine creates a new mock instance.
func NewMockEpochEngine(ctrl *gomock.Controller) *MockEpochEngine {
	mock := &MockEpochEngine{ctrl: ctrl}
	mock.recorder = &MockEpochEngineMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockEpochEngine) EXPECT() *MockEpochEngineMockRecorder {
	return m.recorder
}

// NotifyOnEpoch mocks base method.
func (m *MockEpochEngine) NotifyOnEpoch(arg0, arg1 func(context.Context, types.Epoch)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyOnEpoch", arg0, arg1)
}

// NotifyOnEpoch indicates an expected call of NotifyOnEpoch.
func (mr *MockEpochEngineMockRecorder) NotifyOnEpoch(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyOnEpoch", reflect.TypeOf((*MockEpochEngine)(nil).NotifyOnEpoch), arg0, arg1)
}

// MockBroker is a mock of Broker interface.
type MockBroker struct {
	ctrl     *gomock.Controller
	recorder *MockBrokerMockRecorder
}

// MockBrokerMockRecorder is the mock recorder for MockBroker.
type MockBrokerMockRecorder struct {
	mock *MockBroker
}

// NewMockBroker creates a new mock instance.
func NewMockBroker(ctrl *gomock.Controller) *MockBroker {
	mock := &MockBroker{ctrl: ctrl}
	mock.recorder = &MockBrokerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBroker) EXPECT() *MockBrokerMockRecorder {
	return m.recorder
}

// Send mocks base method.
func (m *MockBroker) Send(arg0 events.Event) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Send", arg0)
}

// Send indicates an expected call of Send.
func (mr *MockBrokerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBroker)(nil).Send), arg0)
}

// MockTimeService is a mock of TimeService interface.
type MockTimeService struct {
	ctrl     *gomock.Controller
	recorder *MockTimeServiceMockRecorder
}

// MockTimeServiceMockRecorder is the mock recorder for MockTimeService.
type MockTimeServiceMockRecorder struct {
	mock *MockTimeService
}

// NewMockTimeService creates a new mock instance.
func NewMockTimeService(ctrl *gomock.Controller) *MockTimeService {
	mock := &MockTimeService{ctrl: ctrl}
	mock.recorder = &MockTimeServiceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTimeService) EXPECT() *MockTimeServiceMockRecorder {
	return m.recorder
}

// GetTimeNow mocks base method.
func (m *MockTimeService) GetTimeNow() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeNow")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// GetTimeNow indicates an expected call of GetTimeNow.
func (mr *MockTimeServiceMockRecorder) GetTimeNow() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeNow", reflect.TypeOf((*MockTimeService)(nil).GetTimeNow))
}

// MockMarketActivityTracker is a mock of MarketActivityTracker interface.
type MockMarketActivityTracker struct {
	ctrl     *gomock.Controller
	recorder *MockMarketActivityTrackerMockRecorder
}

// MockMarketActivityTrackerMockRecorder is the mock recorder for MockMarketActivityTracker.
type MockMarketActivityTrackerMockRecorder struct {
	mock *MockMarketActivityTracker
}

// NewMockMarketActivityTracker creates a new mock instance.
func NewMockMarketActivityTracker(ctrl *gomock.Controller) *MockMarketActivityTracker {
	mock := &MockMarketActivityTracker{ctrl: ctrl}
	mock.recorder = &MockMarketActivityTrackerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMarketActivityTracker) EXPECT() *MockMarketActivityTrackerMockRecorder {
	return m.recorder
}

// NotionalTakerVolumeForParty mocks base method.
func (m *MockMarketActivityTracker) NotionalTakerVolumeForParty(arg0 string) *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotionalTakerVolumeForParty", arg0)
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

// NotionalTakerVolumeForParty indicates an expected call of NotionalTakerVolumeForParty.
func (mr *MockMarketActivityTrackerMockRecorder) NotionalTakerVolumeForParty(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotionalTakerVolumeForParty", reflect.TypeOf((*MockMarketActivityTracker)(nil).NotionalTakerVolumeForParty), arg0)
}

// MockStakingBalances is a mock of StakingBalances interface.
type MockStakingBalances struct {
	ctrl     *gomock.Controller
	recorder *MockStakingBalancesMockRecorder
}

// MockStakingBalancesMockRecorder is the mock recorder for MockStakingBalances.
type MockStakingBalancesMockRecorder struct {
	mock *MockStakingBalances
}

// NewMockStakingBalances creates a new mock instance.
func NewMockStakingBalances(ctrl *gomock.Controller) *MockStakingBalances {
	mock := &MockStakingBalances{ctrl: ctrl}
	mock.recorder = &MockStakingBalancesMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStakingBalances) EXPECT() *MockStakingBalancesMockRecorder {
	return m.recorder
}

// GetAvailableBalance mocks base method.
func (m *MockStakingBalances) GetAvailableBalance(arg0 string) (*num.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAvailableBalance", arg0)
	ret0, _ := ret[0].(*num.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAvailableBalance indicates an expected call of GetAvailableBalance.
func (mr *MockStakingBalancesMockRecorder) GetAvailableBalance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAvailableBalance", reflect.TypeOf((*MockStakingBalances)(nil).GetAvailableBalance), arg0)
}