github.com/choria-io/go-choria@v0.28.1-0.20240416190746-b3bf9c7d5a45/inter/imocks/framework.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/choria-io/go-choria/inter (interfaces: ConfigurationProvider,ProtocolConstructor,ConnectionManager,Framework)

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

import (
	context "context"
	tls "crypto/tls"
	x509 "crypto/x509"
	io "io"
	http "net/http"
	reflect "reflect"
	time "time"

	build "github.com/choria-io/go-choria/build"
	config "github.com/choria-io/go-choria/config"
	inter "github.com/choria-io/go-choria/inter"
	protocol "github.com/choria-io/go-choria/protocol"
	election "github.com/choria-io/go-choria/providers/election/streams"
	governor "github.com/choria-io/go-choria/providers/governor/streams"
	kv "github.com/choria-io/go-choria/providers/kv"
	srvcache "github.com/choria-io/go-choria/srvcache"
	gomock "github.com/golang/mock/gomock"
	nats "github.com/nats-io/nats.go"
	logrus "github.com/sirupsen/logrus"
)

// MockConfigurationProvider is a mock of ConfigurationProvider interface.
type MockConfigurationProvider struct {
	ctrl     *gomock.Controller
	recorder *MockConfigurationProviderMockRecorder
}

// MockConfigurationProviderMockRecorder is the mock recorder for MockConfigurationProvider.
type MockConfigurationProviderMockRecorder struct {
	mock *MockConfigurationProvider
}

// NewMockConfigurationProvider creates a new mock instance.
func NewMockConfigurationProvider(ctrl *gomock.Controller) *MockConfigurationProvider {
	mock := &MockConfigurationProvider{ctrl: ctrl}
	mock.recorder = &MockConfigurationProviderMockRecorder{mock}
	return mock
}

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

// Configuration mocks base method.
func (m *MockConfigurationProvider) Configuration() *config.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configuration")
	ret0, _ := ret[0].(*config.Config)
	return ret0
}

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

// MockProtocolConstructor is a mock of ProtocolConstructor interface.
type MockProtocolConstructor struct {
	ctrl     *gomock.Controller
	recorder *MockProtocolConstructorMockRecorder
}

// MockProtocolConstructorMockRecorder is the mock recorder for MockProtocolConstructor.
type MockProtocolConstructorMockRecorder struct {
	mock *MockProtocolConstructor
}

// NewMockProtocolConstructor creates a new mock instance.
func NewMockProtocolConstructor(ctrl *gomock.Controller) *MockProtocolConstructor {
	mock := &MockProtocolConstructor{ctrl: ctrl}
	mock.recorder = &MockProtocolConstructorMockRecorder{mock}
	return mock
}

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

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

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

// NewMessageFromRequest mocks base method.
func (m *MockProtocolConstructor) NewMessageFromRequest(arg0 protocol.Request, arg1 string) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessageFromRequest", arg0, arg1)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReply mocks base method.
func (m *MockProtocolConstructor) NewReply(arg0 protocol.Request) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReply", arg0)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromMessage mocks base method.
func (m *MockProtocolConstructor) NewReplyFromMessage(arg0 protocol.ProtocolVersion, arg1 inter.Message) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromSecureReply mocks base method.
func (m *MockProtocolConstructor) NewReplyFromSecureReply(arg0 protocol.SecureReply) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromSecureReply", arg0)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromTransportJSON mocks base method.
func (m *MockProtocolConstructor) NewReplyFromTransportJSON(arg0 []byte, arg1 bool) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromTransportJSON", arg0, arg1)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyTransportForMessage mocks base method.
func (m *MockProtocolConstructor) NewReplyTransportForMessage(arg0 inter.Message, arg1 protocol.Request) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyTransportForMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequest mocks base method.
func (m *MockProtocolConstructor) NewRequest(arg0 protocol.ProtocolVersion, arg1, arg2, arg3 string, arg4 int, arg5, arg6 string) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequest", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromMessage mocks base method.
func (m *MockProtocolConstructor) NewRequestFromMessage(arg0 protocol.ProtocolVersion, arg1 inter.Message) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewRequestFromSecureRequest(arg0 protocol.SecureRequest) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromSecureRequest", arg0)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromTransportJSON mocks base method.
func (m *MockProtocolConstructor) NewRequestFromTransportJSON(arg0 []byte, arg1 bool) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromTransportJSON", arg0, arg1)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewRequestMessageFromTransportJSON mocks base method.
func (m *MockProtocolConstructor) NewRequestMessageFromTransportJSON(arg0 []byte) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestMessageFromTransportJSON", arg0)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestTransportForMessage mocks base method.
func (m *MockProtocolConstructor) NewRequestTransportForMessage(arg0 context.Context, arg1 inter.Message, arg2 protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestTransportForMessage", arg0, arg1, arg2)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureReply mocks base method.
func (m *MockProtocolConstructor) NewSecureReply(arg0 protocol.Reply) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReply", arg0)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureReplyFromTransport mocks base method.
func (m *MockProtocolConstructor) NewSecureReplyFromTransport(arg0 protocol.TransportMessage, arg1 bool) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReplyFromTransport", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewSecureRequest(arg0 context.Context, arg1 protocol.Request) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequest", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureRequestFromTransport mocks base method.
func (m *MockProtocolConstructor) NewSecureRequestFromTransport(arg0 protocol.TransportMessage, arg1 bool) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequestFromTransport", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportForSecureReply mocks base method.
func (m *MockProtocolConstructor) NewTransportForSecureReply(arg0 protocol.SecureReply) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureReply", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportForSecureRequest mocks base method.
func (m *MockProtocolConstructor) NewTransportForSecureRequest(arg0 protocol.SecureRequest) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureRequest", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportFromJSON mocks base method.
func (m *MockProtocolConstructor) NewTransportFromJSON(arg0 []byte) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportFromJSON", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportMessage mocks base method.
func (m *MockProtocolConstructor) NewTransportMessage(arg0 protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportMessage", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RequestProtocol mocks base method.
func (m *MockProtocolConstructor) RequestProtocol() protocol.ProtocolVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestProtocol")
	ret0, _ := ret[0].(protocol.ProtocolVersion)
	return ret0
}

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

// MockConnectionManager is a mock of ConnectionManager interface.
type MockConnectionManager struct {
	ctrl     *gomock.Controller
	recorder *MockConnectionManagerMockRecorder
}

// MockConnectionManagerMockRecorder is the mock recorder for MockConnectionManager.
type MockConnectionManagerMockRecorder struct {
	mock *MockConnectionManager
}

// NewMockConnectionManager creates a new mock instance.
func NewMockConnectionManager(ctrl *gomock.Controller) *MockConnectionManager {
	mock := &MockConnectionManager{ctrl: ctrl}
	mock.recorder = &MockConnectionManagerMockRecorder{mock}
	return mock
}

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

// NewConnector mocks base method.
func (m *MockConnectionManager) NewConnector(arg0 context.Context, arg1 func() (srvcache.Servers, error), arg2 string, arg3 *logrus.Entry) (inter.Connector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConnector", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(inter.Connector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockFramework is a mock of Framework interface.
type MockFramework struct {
	ctrl     *gomock.Controller
	recorder *MockFrameworkMockRecorder
}

// MockFrameworkMockRecorder is the mock recorder for MockFramework.
type MockFrameworkMockRecorder struct {
	mock *MockFramework
}

// NewMockFramework creates a new mock instance.
func NewMockFramework(ctrl *gomock.Controller) *MockFramework {
	mock := &MockFramework{ctrl: ctrl}
	mock.recorder = &MockFrameworkMockRecorder{mock}
	return mock
}

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

// BuildInfo mocks base method.
func (m *MockFramework) BuildInfo() *build.Info {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildInfo")
	ret0, _ := ret[0].(*build.Info)
	return ret0
}

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

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

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

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

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

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

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

// Colorize mocks base method.
func (m *MockFramework) Colorize(arg0, arg1 string, arg2 ...interface{}) string {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Colorize", varargs...)
	ret0, _ := ret[0].(string)
	return ret0
}

// Colorize indicates an expected call of Colorize.
func (mr *MockFrameworkMockRecorder) Colorize(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Colorize", reflect.TypeOf((*MockFramework)(nil).Colorize), varargs...)
}

// Configuration mocks base method.
func (m *MockFramework) Configuration() *config.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Configuration")
	ret0, _ := ret[0].(*config.Config)
	return ret0
}

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

// ConfigureProvisioning mocks base method.
func (m *MockFramework) ConfigureProvisioning(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ConfigureProvisioning", arg0)
}

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

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

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

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

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

// Enroll mocks base method.
func (m *MockFramework) Enroll(arg0 context.Context, arg1 time.Duration, arg2 func(string, int)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Enroll", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// KV mocks base method.
func (m *MockFramework) KV(arg0 context.Context, arg1 inter.Connector, arg2 string, arg3 bool, arg4 ...kv.Option) (nats.KeyValue, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "KV", varargs...)
	ret0, _ := ret[0].(nats.KeyValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KV indicates an expected call of KV.
func (mr *MockFrameworkMockRecorder) KV(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KV", reflect.TypeOf((*MockFramework)(nil).KV), varargs...)
}

// KVWithConn mocks base method.
func (m *MockFramework) KVWithConn(arg0 context.Context, arg1 inter.Connector, arg2 string, arg3 bool, arg4 ...kv.Option) (nats.KeyValue, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "KVWithConn", varargs...)
	ret0, _ := ret[0].(nats.KeyValue)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// KVWithConn indicates an expected call of KVWithConn.
func (mr *MockFrameworkMockRecorder) KVWithConn(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KVWithConn", reflect.TypeOf((*MockFramework)(nil).KVWithConn), varargs...)
}

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

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

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

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

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

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

// NewConnector mocks base method.
func (m *MockFramework) NewConnector(arg0 context.Context, arg1 func() (srvcache.Servers, error), arg2 string, arg3 *logrus.Entry) (inter.Connector, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConnector", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(inter.Connector)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewElection mocks base method.
func (m *MockFramework) NewElection(arg0 context.Context, arg1 inter.Connector, arg2 string, arg3 bool, arg4 ...election.Option) (inter.Election, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewElection", varargs...)
	ret0, _ := ret[0].(inter.Election)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewElection indicates an expected call of NewElection.
func (mr *MockFrameworkMockRecorder) NewElection(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewElection", reflect.TypeOf((*MockFramework)(nil).NewElection), varargs...)
}

// NewElectionWithConn mocks base method.
func (m *MockFramework) NewElectionWithConn(arg0 context.Context, arg1 inter.Connector, arg2 string, arg3 bool, arg4 ...election.Option) (inter.Election, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewElectionWithConn", varargs...)
	ret0, _ := ret[0].(inter.Election)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewElectionWithConn indicates an expected call of NewElectionWithConn.
func (mr *MockFrameworkMockRecorder) NewElectionWithConn(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewElectionWithConn", reflect.TypeOf((*MockFramework)(nil).NewElectionWithConn), varargs...)
}

// NewGovernor mocks base method.
func (m *MockFramework) NewGovernor(arg0 context.Context, arg1 string, arg2 inter.Connector, arg3 ...governor.Option) (governor.Governor, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewGovernor", varargs...)
	ret0, _ := ret[0].(governor.Governor)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewGovernor indicates an expected call of NewGovernor.
func (mr *MockFrameworkMockRecorder) NewGovernor(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGovernor", reflect.TypeOf((*MockFramework)(nil).NewGovernor), varargs...)
}

// NewGovernorManager mocks base method.
func (m *MockFramework) NewGovernorManager(arg0 context.Context, arg1 string, arg2 uint64, arg3 time.Duration, arg4 uint, arg5 bool, arg6 inter.Connector, arg7 ...governor.Option) (governor.Manager, inter.Connector, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6}
	for _, a := range arg7 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "NewGovernorManager", varargs...)
	ret0, _ := ret[0].(governor.Manager)
	ret1, _ := ret[1].(inter.Connector)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// NewGovernorManager indicates an expected call of NewGovernorManager.
func (mr *MockFrameworkMockRecorder) NewGovernorManager(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}, arg7 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6}, arg7...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGovernorManager", reflect.TypeOf((*MockFramework)(nil).NewGovernorManager), varargs...)
}

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

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

// NewMessageFromRequest mocks base method.
func (m *MockFramework) NewMessageFromRequest(arg0 protocol.Request, arg1 string) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMessageFromRequest", arg0, arg1)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReply mocks base method.
func (m *MockFramework) NewReply(arg0 protocol.Request) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReply", arg0)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromMessage mocks base method.
func (m *MockFramework) NewReplyFromMessage(arg0 protocol.ProtocolVersion, arg1 inter.Message) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromSecureReply mocks base method.
func (m *MockFramework) NewReplyFromSecureReply(arg0 protocol.SecureReply) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromSecureReply", arg0)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyFromTransportJSON mocks base method.
func (m *MockFramework) NewReplyFromTransportJSON(arg0 []byte, arg1 bool) (protocol.Reply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyFromTransportJSON", arg0, arg1)
	ret0, _ := ret[0].(protocol.Reply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewReplyTransportForMessage mocks base method.
func (m *MockFramework) NewReplyTransportForMessage(arg0 inter.Message, arg1 protocol.Request) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplyTransportForMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequest mocks base method.
func (m *MockFramework) NewRequest(arg0 protocol.ProtocolVersion, arg1, arg2, arg3 string, arg4 int, arg5, arg6 string) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequest", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromMessage mocks base method.
func (m *MockFramework) NewRequestFromMessage(arg0 protocol.ProtocolVersion, arg1 inter.Message) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromMessage", arg0, arg1)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromSecureRequest mocks base method.
func (m *MockFramework) NewRequestFromSecureRequest(arg0 protocol.SecureRequest) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromSecureRequest", arg0)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestFromTransportJSON mocks base method.
func (m *MockFramework) NewRequestFromTransportJSON(arg0 []byte, arg1 bool) (protocol.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestFromTransportJSON", arg0, arg1)
	ret0, _ := ret[0].(protocol.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewRequestMessageFromTransportJSON mocks base method.
func (m *MockFramework) NewRequestMessageFromTransportJSON(arg0 []byte) (inter.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestMessageFromTransportJSON", arg0)
	ret0, _ := ret[0].(inter.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewRequestTransportForMessage mocks base method.
func (m *MockFramework) NewRequestTransportForMessage(arg0 context.Context, arg1 inter.Message, arg2 protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRequestTransportForMessage", arg0, arg1, arg2)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureReply mocks base method.
func (m *MockFramework) NewSecureReply(arg0 protocol.Reply) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReply", arg0)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureReplyFromTransport mocks base method.
func (m *MockFramework) NewSecureReplyFromTransport(arg0 protocol.TransportMessage, arg1 bool) (protocol.SecureReply, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureReplyFromTransport", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureReply)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureRequest mocks base method.
func (m *MockFramework) NewSecureRequest(arg0 context.Context, arg1 protocol.Request) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequest", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewSecureRequestFromTransport mocks base method.
func (m *MockFramework) NewSecureRequestFromTransport(arg0 protocol.TransportMessage, arg1 bool) (protocol.SecureRequest, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSecureRequestFromTransport", arg0, arg1)
	ret0, _ := ret[0].(protocol.SecureRequest)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportForSecureReply mocks base method.
func (m *MockFramework) NewTransportForSecureReply(arg0 protocol.SecureReply) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureReply", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportForSecureRequest mocks base method.
func (m *MockFramework) NewTransportForSecureRequest(arg0 protocol.SecureRequest) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportForSecureRequest", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportFromJSON mocks base method.
func (m *MockFramework) NewTransportFromJSON(arg0 []byte) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportFromJSON", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewTransportMessage mocks base method.
func (m *MockFramework) NewTransportMessage(arg0 protocol.ProtocolVersion) (protocol.TransportMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewTransportMessage", arg0)
	ret0, _ := ret[0].(protocol.TransportMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RequestProtocol mocks base method.
func (m *MockFramework) RequestProtocol() protocol.ProtocolVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestProtocol")
	ret0, _ := ret[0].(protocol.ProtocolVersion)
	return ret0
}

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

// SetLogWriter mocks base method.
func (m *MockFramework) SetLogWriter(arg0 io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogWriter", arg0)
}

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

// SetLogger mocks base method.
func (m *MockFramework) SetLogger(arg0 *logrus.Logger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogger", arg0)
}

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

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

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

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

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

// SignerToken mocks base method.
func (m *MockFramework) SignerToken() (string, time.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignerToken")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(time.Time)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

// TrySrvLookup mocks base method.
func (m *MockFramework) TrySrvLookup(arg0 []string, arg1 srvcache.Server) (srvcache.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TrySrvLookup", arg0, arg1)
	ret0, _ := ret[0].(srvcache.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UniqueIDFromUnverifiedToken mocks base method.
func (m *MockFramework) UniqueIDFromUnverifiedToken() (string, string, time.Time, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UniqueIDFromUnverifiedToken")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(time.Time)
	ret3, _ := ret[3].(string)
	ret4, _ := ret[4].(error)
	return ret0, ret1, ret2, ret3, ret4
}

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

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

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