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

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/choria-io/go-choria/inter (interfaces: SecurityProvider)

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

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

	inter "github.com/choria-io/go-choria/inter"
	gomock "github.com/golang/mock/gomock"
)

// MockSecurityProvider is a mock of SecurityProvider interface.
type MockSecurityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSecurityProviderMockRecorder
}

// MockSecurityProviderMockRecorder is the mock recorder for MockSecurityProvider.
type MockSecurityProviderMockRecorder struct {
	mock *MockSecurityProvider
}

// NewMockSecurityProvider creates a new mock instance.
func NewMockSecurityProvider(ctrl *gomock.Controller) *MockSecurityProvider {
	mock := &MockSecurityProvider{ctrl: ctrl}
	mock.recorder = &MockSecurityProviderMockRecorder{mock}
	return mock
}

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

// BackingTechnology mocks base method.
func (m *MockSecurityProvider) BackingTechnology() inter.SecurityTechnology {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackingTechnology")
	ret0, _ := ret[0].(inter.SecurityTechnology)
	return ret0
}

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

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

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

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

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

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

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

// ClientTLSConfig mocks base method.
func (m *MockSecurityProvider) 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 *MockSecurityProviderMockRecorder) ClientTLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientTLSConfig", reflect.TypeOf((*MockSecurityProvider)(nil).ClientTLSConfig))
}

// Enroll mocks base method.
func (m *MockSecurityProvider) 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 *MockSecurityProviderMockRecorder) Enroll(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enroll", reflect.TypeOf((*MockSecurityProvider)(nil).Enroll), arg0, arg1, arg2)
}

// HTTPClient mocks base method.
func (m *MockSecurityProvider) 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 *MockSecurityProviderMockRecorder) HTTPClient(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTPClient", reflect.TypeOf((*MockSecurityProvider)(nil).HTTPClient), arg0)
}

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

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

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

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

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

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

// PublicCert mocks base method.
func (m *MockSecurityProvider) 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 *MockSecurityProviderMockRecorder) PublicCert() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublicCert", reflect.TypeOf((*MockSecurityProvider)(nil).PublicCert))
}

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

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

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

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

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

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

// ShouldAllowCaller mocks base method.
func (m *MockSecurityProvider) ShouldAllowCaller(arg0 string, arg1 ...[]byte) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ShouldAllowCaller", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// TLSConfig mocks base method.
func (m *MockSecurityProvider) 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 *MockSecurityProviderMockRecorder) TLSConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TLSConfig", reflect.TypeOf((*MockSecurityProvider)(nil).TLSConfig))
}

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

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

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

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

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

// VerifySignatureBytes indicates an expected call of VerifySignatureBytes.
func (mr *MockSecurityProviderMockRecorder) VerifySignatureBytes(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, "VerifySignatureBytes", reflect.TypeOf((*MockSecurityProvider)(nil).VerifySignatureBytes), varargs...)
}