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

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/rewards (interfaces: MarketActivityTracker,Delegation,TimeService,Topology,Transfers,Teams,Vesting,ActivityStreak)

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

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

	types "code.vegaprotocol.io/vega/core/types"
	vesting "code.vegaprotocol.io/vega/core/vesting"
	num "code.vegaprotocol.io/vega/libs/num"
	vega "code.vegaprotocol.io/vega/protos/vega"
	gomock "github.com/golang/mock/gomock"
	decimal "github.com/shopspring/decimal"
)

// 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
}

// CalculateMetricForIndividuals mocks base method.
func (m *MockMarketActivityTracker) CalculateMetricForIndividuals(arg0 context.Context, arg1 *vega.DispatchStrategy) []*types.PartyContributionScore {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateMetricForIndividuals", arg0, arg1)
	ret0, _ := ret[0].([]*types.PartyContributionScore)
	return ret0
}

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

// CalculateMetricForTeams mocks base method.
func (m *MockMarketActivityTracker) CalculateMetricForTeams(arg0 context.Context, arg1 *vega.DispatchStrategy) ([]*types.PartyContributionScore, map[string][]*types.PartyContributionScore) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateMetricForTeams", arg0, arg1)
	ret0, _ := ret[0].([]*types.PartyContributionScore)
	ret1, _ := ret[1].(map[string][]*types.PartyContributionScore)
	return ret0, ret1
}

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

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

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

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

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

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

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

// MockDelegation is a mock of Delegation interface.
type MockDelegation struct {
	ctrl     *gomock.Controller
	recorder *MockDelegationMockRecorder
}

// MockDelegationMockRecorder is the mock recorder for MockDelegation.
type MockDelegationMockRecorder struct {
	mock *MockDelegation
}

// NewMockDelegation creates a new mock instance.
func NewMockDelegation(ctrl *gomock.Controller) *MockDelegation {
	mock := &MockDelegation{ctrl: ctrl}
	mock.recorder = &MockDelegationMockRecorder{mock}
	return mock
}

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

// GetValidatorData mocks base method.
func (m *MockDelegation) GetValidatorData() []*types.ValidatorData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValidatorData")
	ret0, _ := ret[0].([]*types.ValidatorData)
	return ret0
}

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

// ProcessEpochDelegations mocks base method.
func (m *MockDelegation) ProcessEpochDelegations(arg0 context.Context, arg1 types.Epoch) []*types.ValidatorData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessEpochDelegations", arg0, arg1)
	ret0, _ := ret[0].([]*types.ValidatorData)
	return ret0
}

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

// 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))
}

// MockTopology is a mock of Topology interface.
type MockTopology struct {
	ctrl     *gomock.Controller
	recorder *MockTopologyMockRecorder
}

// MockTopologyMockRecorder is the mock recorder for MockTopology.
type MockTopologyMockRecorder struct {
	mock *MockTopology
}

// NewMockTopology creates a new mock instance.
func NewMockTopology(ctrl *gomock.Controller) *MockTopology {
	mock := &MockTopology{ctrl: ctrl}
	mock.recorder = &MockTopologyMockRecorder{mock}
	return mock
}

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

// GetRewardsScores mocks base method.
func (m *MockTopology) GetRewardsScores(arg0 context.Context, arg1 string, arg2 []*types.ValidatorData, arg3 types.StakeScoreParams) (*types.ScoreData, *types.ScoreData) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRewardsScores", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*types.ScoreData)
	ret1, _ := ret[1].(*types.ScoreData)
	return ret0, ret1
}

// GetRewardsScores indicates an expected call of GetRewardsScores.
func (mr *MockTopologyMockRecorder) GetRewardsScores(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRewardsScores", reflect.TypeOf((*MockTopology)(nil).GetRewardsScores), arg0, arg1, arg2, arg3)
}

// RecalcValidatorSet mocks base method.
func (m *MockTopology) RecalcValidatorSet(arg0 context.Context, arg1 string, arg2 []*types.ValidatorData, arg3 types.StakeScoreParams) []*types.PartyContributionScore {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecalcValidatorSet", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]*types.PartyContributionScore)
	return ret0
}

// RecalcValidatorSet indicates an expected call of RecalcValidatorSet.
func (mr *MockTopologyMockRecorder) RecalcValidatorSet(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecalcValidatorSet", reflect.TypeOf((*MockTopology)(nil).RecalcValidatorSet), arg0, arg1, arg2, arg3)
}

// MockTransfers is a mock of Transfers interface.
type MockTransfers struct {
	ctrl     *gomock.Controller
	recorder *MockTransfersMockRecorder
}

// MockTransfersMockRecorder is the mock recorder for MockTransfers.
type MockTransfersMockRecorder struct {
	mock *MockTransfers
}

// NewMockTransfers creates a new mock instance.
func NewMockTransfers(ctrl *gomock.Controller) *MockTransfers {
	mock := &MockTransfers{ctrl: ctrl}
	mock.recorder = &MockTransfersMockRecorder{mock}
	return mock
}

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

// GetDispatchStrategy mocks base method.
func (m *MockTransfers) GetDispatchStrategy(arg0 string) *vega.DispatchStrategy {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDispatchStrategy", arg0)
	ret0, _ := ret[0].(*vega.DispatchStrategy)
	return ret0
}

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

// MockTeams is a mock of Teams interface.
type MockTeams struct {
	ctrl     *gomock.Controller
	recorder *MockTeamsMockRecorder
}

// MockTeamsMockRecorder is the mock recorder for MockTeams.
type MockTeamsMockRecorder struct {
	mock *MockTeams
}

// NewMockTeams creates a new mock instance.
func NewMockTeams(ctrl *gomock.Controller) *MockTeams {
	mock := &MockTeams{ctrl: ctrl}
	mock.recorder = &MockTeamsMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockVesting is a mock of Vesting interface.
type MockVesting struct {
	ctrl     *gomock.Controller
	recorder *MockVestingMockRecorder
}

// MockVestingMockRecorder is the mock recorder for MockVesting.
type MockVestingMockRecorder struct {
	mock *MockVesting
}

// NewMockVesting creates a new mock instance.
func NewMockVesting(ctrl *gomock.Controller) *MockVesting {
	mock := &MockVesting{ctrl: ctrl}
	mock.recorder = &MockVestingMockRecorder{mock}
	return mock
}

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

// AddReward mocks base method.
func (m *MockVesting) AddReward(arg0 context.Context, arg1, arg2 string, arg3 *num.Uint, arg4 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddReward", arg0, arg1, arg2, arg3, arg4)
}

// AddReward indicates an expected call of AddReward.
func (mr *MockVestingMockRecorder) AddReward(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReward", reflect.TypeOf((*MockVesting)(nil).AddReward), arg0, arg1, arg2, arg3, arg4)
}

// GetSingleAndSummedRewardBonusMultipliers mocks base method.
func (m *MockVesting) GetSingleAndSummedRewardBonusMultipliers(arg0 string) (vesting.MultiplierAndQuantBalance, vesting.MultiplierAndQuantBalance) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSingleAndSummedRewardBonusMultipliers", arg0)
	ret0, _ := ret[0].(vesting.MultiplierAndQuantBalance)
	ret1, _ := ret[1].(vesting.MultiplierAndQuantBalance)
	return ret0, ret1
}

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

// MockActivityStreak is a mock of ActivityStreak interface.
type MockActivityStreak struct {
	ctrl     *gomock.Controller
	recorder *MockActivityStreakMockRecorder
}

// MockActivityStreakMockRecorder is the mock recorder for MockActivityStreak.
type MockActivityStreakMockRecorder struct {
	mock *MockActivityStreak
}

// NewMockActivityStreak creates a new mock instance.
func NewMockActivityStreak(ctrl *gomock.Controller) *MockActivityStreak {
	mock := &MockActivityStreak{ctrl: ctrl}
	mock.recorder = &MockActivityStreakMockRecorder{mock}
	return mock
}

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

// GetRewardsDistributionMultiplier mocks base method.
func (m *MockActivityStreak) GetRewardsDistributionMultiplier(arg0 string) decimal.Decimal {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRewardsDistributionMultiplier", arg0)
	ret0, _ := ret[0].(decimal.Decimal)
	return ret0
}

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