github.com/hyperledger/aries-framework-go@v0.3.2/pkg/internal/gomocks/kms/mocks.gen.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/hyperledger/aries-framework-go/pkg/kms (interfaces: Provider,KeyManager)

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	kms "github.com/hyperledger/aries-framework-go/spi/kms"
	secretlock "github.com/hyperledger/aries-framework-go/spi/secretlock"
)

// MockProvider is a mock of Provider interface.
type MockProvider struct {
	ctrl     *gomock.Controller
	recorder *MockProviderMockRecorder
}

// MockProviderMockRecorder is the mock recorder for MockProvider.
type MockProviderMockRecorder struct {
	mock *MockProvider
}

// NewMockProvider creates a new mock instance.
func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
	mock := &MockProvider{ctrl: ctrl}
	mock.recorder = &MockProviderMockRecorder{mock}
	return mock
}

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

// SecretLock mocks base method.
func (m *MockProvider) SecretLock() secretlock.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SecretLock")
	ret0, _ := ret[0].(secretlock.Service)
	return ret0
}

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

// StorageProvider mocks base method.
func (m *MockProvider) StorageProvider() kms.Store {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StorageProvider")
	ret0, _ := ret[0].(kms.Store)
	return ret0
}

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

// MockKeyManager is a mock of KeyManager interface.
type MockKeyManager struct {
	ctrl     *gomock.Controller
	recorder *MockKeyManagerMockRecorder
}

// MockKeyManagerMockRecorder is the mock recorder for MockKeyManager.
type MockKeyManagerMockRecorder struct {
	mock *MockKeyManager
}

// NewMockKeyManager creates a new mock instance.
func NewMockKeyManager(ctrl *gomock.Controller) *MockKeyManager {
	mock := &MockKeyManager{ctrl: ctrl}
	mock.recorder = &MockKeyManagerMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockKeyManager) Create(arg0 kms.KeyType, arg1 ...kms.KeyOpts) (string, interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Create", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(interface{})
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

// ImportPrivateKey mocks base method.
func (m *MockKeyManager) ImportPrivateKey(arg0 interface{}, arg1 kms.KeyType, arg2 ...kms.PrivateKeyOpts) (string, interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportPrivateKey", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(interface{})
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// PubKeyBytesToHandle mocks base method.
func (m *MockKeyManager) PubKeyBytesToHandle(arg0 []byte, arg1 kms.KeyType, arg2 ...kms.KeyOpts) (interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PubKeyBytesToHandle", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Rotate mocks base method.
func (m *MockKeyManager) Rotate(arg0 kms.KeyType, arg1 string, arg2 ...kms.KeyOpts) (string, interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Rotate", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(interface{})
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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