217 lines
7.5 KiB
Go
217 lines
7.5 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: geth/common/types.go
|
|
|
|
// Package common is a generated GoMock package.
|
|
package common
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
|
|
accounts "github.com/ethereum/go-ethereum/accounts"
|
|
keystore "github.com/ethereum/go-ethereum/accounts/keystore"
|
|
les "github.com/ethereum/go-ethereum/les"
|
|
node "github.com/ethereum/go-ethereum/node"
|
|
whisperv6 "github.com/ethereum/go-ethereum/whisper/whisperv6"
|
|
gomock "github.com/golang/mock/gomock"
|
|
params "github.com/status-im/status-go/geth/params"
|
|
rpc "github.com/status-im/status-go/geth/rpc"
|
|
)
|
|
|
|
// MockNodeManager is a mock of NodeManager interface
|
|
type MockNodeManager struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockNodeManagerMockRecorder
|
|
}
|
|
|
|
// MockNodeManagerMockRecorder is the mock recorder for MockNodeManager
|
|
type MockNodeManagerMockRecorder struct {
|
|
mock *MockNodeManager
|
|
}
|
|
|
|
// NewMockNodeManager creates a new mock instance
|
|
func NewMockNodeManager(ctrl *gomock.Controller) *MockNodeManager {
|
|
mock := &MockNodeManager{ctrl: ctrl}
|
|
mock.recorder = &MockNodeManagerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockNodeManager) EXPECT() *MockNodeManagerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// StartNode mocks base method
|
|
func (m *MockNodeManager) StartNode(config *params.NodeConfig) error {
|
|
ret := m.ctrl.Call(m, "StartNode", config)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StartNode indicates an expected call of StartNode
|
|
func (mr *MockNodeManagerMockRecorder) StartNode(config interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNode", reflect.TypeOf((*MockNodeManager)(nil).StartNode), config)
|
|
}
|
|
|
|
// EnsureSync mocks base method
|
|
func (m *MockNodeManager) EnsureSync(ctx context.Context) error {
|
|
ret := m.ctrl.Call(m, "EnsureSync", ctx)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// EnsureSync indicates an expected call of EnsureSync
|
|
func (mr *MockNodeManagerMockRecorder) EnsureSync(ctx interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureSync", reflect.TypeOf((*MockNodeManager)(nil).EnsureSync), ctx)
|
|
}
|
|
|
|
// StopNode mocks base method
|
|
func (m *MockNodeManager) StopNode() error {
|
|
ret := m.ctrl.Call(m, "StopNode")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StopNode indicates an expected call of StopNode
|
|
func (mr *MockNodeManagerMockRecorder) StopNode() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNode", reflect.TypeOf((*MockNodeManager)(nil).StopNode))
|
|
}
|
|
|
|
// IsNodeRunning mocks base method
|
|
func (m *MockNodeManager) IsNodeRunning() bool {
|
|
ret := m.ctrl.Call(m, "IsNodeRunning")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsNodeRunning indicates an expected call of IsNodeRunning
|
|
func (mr *MockNodeManagerMockRecorder) IsNodeRunning() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNodeRunning", reflect.TypeOf((*MockNodeManager)(nil).IsNodeRunning))
|
|
}
|
|
|
|
// NodeConfig mocks base method
|
|
func (m *MockNodeManager) NodeConfig() (*params.NodeConfig, error) {
|
|
ret := m.ctrl.Call(m, "NodeConfig")
|
|
ret0, _ := ret[0].(*params.NodeConfig)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// NodeConfig indicates an expected call of NodeConfig
|
|
func (mr *MockNodeManagerMockRecorder) NodeConfig() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeConfig", reflect.TypeOf((*MockNodeManager)(nil).NodeConfig))
|
|
}
|
|
|
|
// Node mocks base method
|
|
func (m *MockNodeManager) Node() (*node.Node, error) {
|
|
ret := m.ctrl.Call(m, "Node")
|
|
ret0, _ := ret[0].(*node.Node)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Node indicates an expected call of Node
|
|
func (mr *MockNodeManagerMockRecorder) Node() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Node", reflect.TypeOf((*MockNodeManager)(nil).Node))
|
|
}
|
|
|
|
// PopulateStaticPeers mocks base method
|
|
func (m *MockNodeManager) PopulateStaticPeers() error {
|
|
ret := m.ctrl.Call(m, "PopulateStaticPeers")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// PopulateStaticPeers indicates an expected call of PopulateStaticPeers
|
|
func (mr *MockNodeManagerMockRecorder) PopulateStaticPeers() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopulateStaticPeers", reflect.TypeOf((*MockNodeManager)(nil).PopulateStaticPeers))
|
|
}
|
|
|
|
// AddPeer mocks base method
|
|
func (m *MockNodeManager) AddPeer(url string) error {
|
|
ret := m.ctrl.Call(m, "AddPeer", url)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddPeer indicates an expected call of AddPeer
|
|
func (mr *MockNodeManagerMockRecorder) AddPeer(url interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeer", reflect.TypeOf((*MockNodeManager)(nil).AddPeer), url)
|
|
}
|
|
|
|
// PeerCount mocks base method
|
|
func (m *MockNodeManager) PeerCount() int {
|
|
ret := m.ctrl.Call(m, "PeerCount")
|
|
ret0, _ := ret[0].(int)
|
|
return ret0
|
|
}
|
|
|
|
// PeerCount indicates an expected call of PeerCount
|
|
func (mr *MockNodeManagerMockRecorder) PeerCount() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerCount", reflect.TypeOf((*MockNodeManager)(nil).PeerCount))
|
|
}
|
|
|
|
// LightEthereumService mocks base method
|
|
func (m *MockNodeManager) LightEthereumService() (*les.LightEthereum, error) {
|
|
ret := m.ctrl.Call(m, "LightEthereumService")
|
|
ret0, _ := ret[0].(*les.LightEthereum)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// LightEthereumService indicates an expected call of LightEthereumService
|
|
func (mr *MockNodeManagerMockRecorder) LightEthereumService() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LightEthereumService", reflect.TypeOf((*MockNodeManager)(nil).LightEthereumService))
|
|
}
|
|
|
|
// WhisperService mocks base method
|
|
func (m *MockNodeManager) WhisperService() (*whisperv6.Whisper, error) {
|
|
ret := m.ctrl.Call(m, "WhisperService")
|
|
ret0, _ := ret[0].(*whisperv6.Whisper)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WhisperService indicates an expected call of WhisperService
|
|
func (mr *MockNodeManagerMockRecorder) WhisperService() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhisperService", reflect.TypeOf((*MockNodeManager)(nil).WhisperService))
|
|
}
|
|
|
|
// AccountManager mocks base method
|
|
func (m *MockNodeManager) AccountManager() (*accounts.Manager, error) {
|
|
ret := m.ctrl.Call(m, "AccountManager")
|
|
ret0, _ := ret[0].(*accounts.Manager)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AccountManager indicates an expected call of AccountManager
|
|
func (mr *MockNodeManagerMockRecorder) AccountManager() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountManager", reflect.TypeOf((*MockNodeManager)(nil).AccountManager))
|
|
}
|
|
|
|
// AccountKeyStore mocks base method
|
|
func (m *MockNodeManager) AccountKeyStore() (*keystore.KeyStore, error) {
|
|
ret := m.ctrl.Call(m, "AccountKeyStore")
|
|
ret0, _ := ret[0].(*keystore.KeyStore)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AccountKeyStore indicates an expected call of AccountKeyStore
|
|
func (mr *MockNodeManagerMockRecorder) AccountKeyStore() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AccountKeyStore", reflect.TypeOf((*MockNodeManager)(nil).AccountKeyStore))
|
|
}
|
|
|
|
// RPCClient mocks base method
|
|
func (m *MockNodeManager) RPCClient() *rpc.Client {
|
|
ret := m.ctrl.Call(m, "RPCClient")
|
|
ret0, _ := ret[0].(*rpc.Client)
|
|
return ret0
|
|
}
|
|
|
|
// RPCClient indicates an expected call of RPCClient
|
|
func (mr *MockNodeManagerMockRecorder) RPCClient() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPCClient", reflect.TypeOf((*MockNodeManager)(nil).RPCClient))
|
|
}
|