code.vegaprotocol.io/vega@v0.79.0/wallet/api/node/mocks/nodes_mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/wallet/api/node (interfaces: Node,Selector)

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

import (
	context "context"
	reflect "reflect"

	v1 "code.vegaprotocol.io/vega/protos/vega/api/v1"
	v10 "code.vegaprotocol.io/vega/protos/vega/commands/v1"
	node "code.vegaprotocol.io/vega/wallet/api/node"
	types "code.vegaprotocol.io/vega/wallet/api/node/types"
	gomock "github.com/golang/mock/gomock"
)

// MockNode is a mock of Node interface.
type MockNode struct {
	ctrl     *gomock.Controller
	recorder *MockNodeMockRecorder
}

// MockNodeMockRecorder is the mock recorder for MockNode.
type MockNodeMockRecorder struct {
	mock *MockNode
}

// NewMockNode creates a new mock instance.
func NewMockNode(ctrl *gomock.Controller) *MockNode {
	mock := &MockNode{ctrl: ctrl}
	mock.recorder = &MockNodeMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// SendTransaction mocks base method.
func (m *MockNode) SendTransaction(arg0 context.Context, arg1 *v10.Transaction, arg2 v1.SubmitTransactionRequest_Type) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendTransaction", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SpamStatistics mocks base method.
func (m *MockNode) SpamStatistics(arg0 context.Context, arg1 string) (types.SpamStatistics, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpamStatistics", arg0, arg1)
	ret0, _ := ret[0].(types.SpamStatistics)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// MockSelector is a mock of Selector interface.
type MockSelector struct {
	ctrl     *gomock.Controller
	recorder *MockSelectorMockRecorder
}

// MockSelectorMockRecorder is the mock recorder for MockSelector.
type MockSelectorMockRecorder struct {
	mock *MockSelector
}

// NewMockSelector creates a new mock instance.
func NewMockSelector(ctrl *gomock.Controller) *MockSelector {
	mock := &MockSelector{ctrl: ctrl}
	mock.recorder = &MockSelectorMockRecorder{mock}
	return mock
}

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

// Node mocks base method.
func (m *MockSelector) Node(arg0 context.Context, arg1 node.SelectionReporter) (node.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Node", arg0, arg1)
	ret0, _ := ret[0].(node.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Stop mocks base method.
func (m *MockSelector) Stop() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Stop")
}

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