code.vegaprotocol.io/vega@v0.79.0/datanode/broker/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/datanode/broker (interfaces: Subscriber,TestInterface,ChainInfoI)

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

import (
	"code.vegaprotocol.io/vega/libs/broker"
	context "context"
	reflect "reflect"

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

// MockSubscriber is a mock of Subscriber interface.
type MockSubscriber struct {
	ctrl     *gomock.Controller
	recorder *MockSubscriberMockRecorder
}

// MockSubscriberMockRecorder is the mock recorder for MockSubscriber.
type MockSubscriberMockRecorder struct {
	mock *MockSubscriber
}

// NewMockSubscriber creates a new mock instance.
func NewMockSubscriber(ctrl *gomock.Controller) *MockSubscriber {
	mock := &MockSubscriber{ctrl: ctrl}
	mock.recorder = &MockSubscriberMockRecorder{mock}
	return mock
}

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

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

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

// C mocks base method.
func (m *MockSubscriber) C() chan<- []events.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "C")
	ret0, _ := ret[0].(chan<- []events.Event)
	return ret0
}

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

// Closed mocks base method.
func (m *MockSubscriber) Closed() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Closed")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

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

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

// Push mocks base method.
func (m *MockSubscriber) Push(arg0 ...events.Event) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Push", varargs...)
}

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

// SetID mocks base method.
func (m *MockSubscriber) SetID(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetID", arg0)
}

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

// Skip mocks base method.
func (m *MockSubscriber) Skip() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Skip")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

// Types mocks base method.
func (m *MockSubscriber) Types() []events.Type {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Types")
	ret0, _ := ret[0].([]events.Type)
	return ret0
}

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

// MockTestInterface is a mock of TestInterface interface.
type MockTestInterface struct {
	ctrl     *gomock.Controller
	recorder *MockTestInterfaceMockRecorder
}

// MockTestInterfaceMockRecorder is the mock recorder for MockTestInterface.
type MockTestInterfaceMockRecorder struct {
	mock *MockTestInterface
}

// NewMockTestInterface creates a new mock instance.
func NewMockTestInterface(ctrl *gomock.Controller) *MockTestInterface {
	mock := &MockTestInterface{ctrl: ctrl}
	mock.recorder = &MockTestInterfaceMockRecorder{mock}
	return mock
}

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

// Receive mocks base method.
func (m *MockTestInterface) Receive(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Receive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Subscribe mocks base method.
func (m *MockTestInterface) Subscribe(arg0 broker.Subscriber) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Subscribe", arg0)
	ret0, _ := ret[0].(int)
	return ret0
}

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

// SubscribeBatch mocks base method.
func (m *MockTestInterface) SubscribeBatch(arg0 ...broker.Subscriber) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "SubscribeBatch", varargs...)
}

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

// Unsubscribe mocks base method.
func (m *MockTestInterface) Unsubscribe(arg0 int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Unsubscribe", arg0)
}

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

// MockChainInfoI is a mock of ChainInfoI interface.
type MockChainInfoI struct {
	ctrl     *gomock.Controller
	recorder *MockChainInfoIMockRecorder
}

// MockChainInfoIMockRecorder is the mock recorder for MockChainInfoI.
type MockChainInfoIMockRecorder struct {
	mock *MockChainInfoI
}

// NewMockChainInfoI creates a new mock instance.
func NewMockChainInfoI(ctrl *gomock.Controller) *MockChainInfoI {
	mock := &MockChainInfoI{ctrl: ctrl}
	mock.recorder = &MockChainInfoIMockRecorder{mock}
	return mock
}

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

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

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

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

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