quorum-code/private/mock_private/mock_private.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ethereum/go-ethereum/private (interfaces: Identifiable,PrivateTransactionManager)

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

import (
	reflect "reflect"

	common "github.com/ethereum/go-ethereum/common"
	engine "github.com/ethereum/go-ethereum/private/engine"
	gomock "github.com/golang/mock/gomock"
)

// MockIdentifiable is a mock of Identifiable interface.
type MockIdentifiable struct {
	ctrl     *gomock.Controller
	recorder *MockIdentifiableMockRecorder
}

// MockIdentifiableMockRecorder is the mock recorder for MockIdentifiable.
type MockIdentifiableMockRecorder struct {
	mock *MockIdentifiable
}

// NewMockIdentifiable creates a new mock instance.
func NewMockIdentifiable(ctrl *gomock.Controller) *MockIdentifiable {
	mock := &MockIdentifiable{ctrl: ctrl}
	mock.recorder = &MockIdentifiableMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockPrivateTransactionManager is a mock of PrivateTransactionManager interface.
type MockPrivateTransactionManager struct {
	ctrl     *gomock.Controller
	recorder *MockPrivateTransactionManagerMockRecorder
}

// MockPrivateTransactionManagerMockRecorder is the mock recorder for MockPrivateTransactionManager.
type MockPrivateTransactionManagerMockRecorder struct {
	mock *MockPrivateTransactionManager
}

// NewMockPrivateTransactionManager creates a new mock instance.
func NewMockPrivateTransactionManager(ctrl *gomock.Controller) *MockPrivateTransactionManager {
	mock := &MockPrivateTransactionManager{ctrl: ctrl}
	mock.recorder = &MockPrivateTransactionManagerMockRecorder{mock}
	return mock
}

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

// DecryptPayload mocks base method.
func (m *MockPrivateTransactionManager) DecryptPayload(arg0 common.DecryptRequest) ([]byte, *engine.ExtraMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecryptPayload", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(*engine.ExtraMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// EncryptPayload mocks base method.
func (m *MockPrivateTransactionManager) EncryptPayload(arg0 []byte, arg1 string, arg2 []string, arg3 *engine.ExtraMetadata) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncryptPayload", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// IsSender mocks base method.
func (m *MockPrivateTransactionManager) IsSender(arg0 common.EncryptedPayloadHash) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSender", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Receive mocks base method.
func (m *MockPrivateTransactionManager) Receive(arg0 common.EncryptedPayloadHash) (string, []string, []byte, *engine.ExtraMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Receive", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(*engine.ExtraMetadata)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

// ReceiveRaw mocks base method.
func (m *MockPrivateTransactionManager) ReceiveRaw(arg0 common.EncryptedPayloadHash) ([]byte, string, *engine.ExtraMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveRaw", arg0)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(*engine.ExtraMetadata)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// Send mocks base method.
func (m *MockPrivateTransactionManager) Send(arg0 []byte, arg1 string, arg2 []string, arg3 *engine.ExtraMetadata) (string, []string, common.EncryptedPayloadHash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(common.EncryptedPayloadHash)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// SendSignedTx mocks base method.
func (m *MockPrivateTransactionManager) SendSignedTx(arg0 common.EncryptedPayloadHash, arg1 []string, arg2 *engine.ExtraMetadata) (string, []string, []byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendSignedTx", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].([]byte)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

// StoreRaw mocks base method.
func (m *MockPrivateTransactionManager) StoreRaw(arg0 []byte, arg1 string) (common.EncryptedPayloadHash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreRaw", arg0, arg1)
	ret0, _ := ret[0].(common.EncryptedPayloadHash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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