diff --git a/go.mod b/go.mod index afb913dc..011251ac 100644 --- a/go.mod +++ b/go.mod @@ -32,8 +32,10 @@ require ( github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/stevenle/topsort v0.2.0 // indirect github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect + golang.org/x/mod v0.17.0 // indirect golang.org/x/sync v0.8.0 // indirect golang.org/x/sys v0.20.0 // indirect + golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/go.sum b/go.sum index ab6c4b36..bf39ecd1 100644 --- a/go.sum +++ b/go.sum @@ -68,6 +68,8 @@ go.uber.org/ratelimit v0.3.1/go.mod h1:6euWsTB6U/Nb3X++xEUXA8ciPJvr19Q/0h1+oDcJh golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= +golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= @@ -97,6 +99,8 @@ golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/mocks/mock_kmsiface/mock.go b/mocks/mock_kmsiface/mock.go new file mode 100644 index 00000000..7cb010c1 --- /dev/null +++ b/mocks/mock_kmsiface/mock.go @@ -0,0 +1,2951 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/kms/kmsiface/interface.go + +// Package mock_kmsiface is a generated GoMock package. +package mock_kmsiface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + kms "github.com/aws/aws-sdk-go/service/kms" + gomock "github.com/golang/mock/gomock" +) + +// MockKMSAPI is a mock of KMSAPI interface. +type MockKMSAPI struct { + ctrl *gomock.Controller + recorder *MockKMSAPIMockRecorder +} + +// MockKMSAPIMockRecorder is the mock recorder for MockKMSAPI. +type MockKMSAPIMockRecorder struct { + mock *MockKMSAPI +} + +// NewMockKMSAPI creates a new mock instance. +func NewMockKMSAPI(ctrl *gomock.Controller) *MockKMSAPI { + mock := &MockKMSAPI{ctrl: ctrl} + mock.recorder = &MockKMSAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockKMSAPI) EXPECT() *MockKMSAPIMockRecorder { + return m.recorder +} + +// CancelKeyDeletion mocks base method. +func (m *MockKMSAPI) CancelKeyDeletion(arg0 *kms.CancelKeyDeletionInput) (*kms.CancelKeyDeletionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelKeyDeletion", arg0) + ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelKeyDeletion indicates an expected call of CancelKeyDeletion. +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletion), arg0) +} + +// CancelKeyDeletionRequest mocks base method. +func (m *MockKMSAPI) CancelKeyDeletionRequest(arg0 *kms.CancelKeyDeletionInput) (*request.Request, *kms.CancelKeyDeletionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelKeyDeletionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.CancelKeyDeletionOutput) + return ret0, ret1 +} + +// CancelKeyDeletionRequest indicates an expected call of CancelKeyDeletionRequest. +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionRequest), arg0) +} + +// CancelKeyDeletionWithContext mocks base method. +func (m *MockKMSAPI) CancelKeyDeletionWithContext(arg0 aws.Context, arg1 *kms.CancelKeyDeletionInput, arg2 ...request.Option) (*kms.CancelKeyDeletionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelKeyDeletionWithContext", varargs...) + ret0, _ := ret[0].(*kms.CancelKeyDeletionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelKeyDeletionWithContext indicates an expected call of CancelKeyDeletionWithContext. +func (mr *MockKMSAPIMockRecorder) CancelKeyDeletionWithContext(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, "CancelKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CancelKeyDeletionWithContext), varargs...) +} + +// ConnectCustomKeyStore mocks base method. +func (m *MockKMSAPI) ConnectCustomKeyStore(arg0 *kms.ConnectCustomKeyStoreInput) (*kms.ConnectCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConnectCustomKeyStore", arg0) + ret0, _ := ret[0].(*kms.ConnectCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConnectCustomKeyStore indicates an expected call of ConnectCustomKeyStore. +func (mr *MockKMSAPIMockRecorder) ConnectCustomKeyStore(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectCustomKeyStore", reflect.TypeOf((*MockKMSAPI)(nil).ConnectCustomKeyStore), arg0) +} + +// ConnectCustomKeyStoreRequest mocks base method. +func (m *MockKMSAPI) ConnectCustomKeyStoreRequest(arg0 *kms.ConnectCustomKeyStoreInput) (*request.Request, *kms.ConnectCustomKeyStoreOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConnectCustomKeyStoreRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ConnectCustomKeyStoreOutput) + return ret0, ret1 +} + +// ConnectCustomKeyStoreRequest indicates an expected call of ConnectCustomKeyStoreRequest. +func (mr *MockKMSAPIMockRecorder) ConnectCustomKeyStoreRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectCustomKeyStoreRequest", reflect.TypeOf((*MockKMSAPI)(nil).ConnectCustomKeyStoreRequest), arg0) +} + +// ConnectCustomKeyStoreWithContext mocks base method. +func (m *MockKMSAPI) ConnectCustomKeyStoreWithContext(arg0 aws.Context, arg1 *kms.ConnectCustomKeyStoreInput, arg2 ...request.Option) (*kms.ConnectCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ConnectCustomKeyStoreWithContext", varargs...) + ret0, _ := ret[0].(*kms.ConnectCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ConnectCustomKeyStoreWithContext indicates an expected call of ConnectCustomKeyStoreWithContext. +func (mr *MockKMSAPIMockRecorder) ConnectCustomKeyStoreWithContext(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, "ConnectCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ConnectCustomKeyStoreWithContext), varargs...) +} + +// CreateAlias mocks base method. +func (m *MockKMSAPI) CreateAlias(arg0 *kms.CreateAliasInput) (*kms.CreateAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAlias", arg0) + ret0, _ := ret[0].(*kms.CreateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAlias indicates an expected call of CreateAlias. +func (mr *MockKMSAPIMockRecorder) CreateAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAlias", reflect.TypeOf((*MockKMSAPI)(nil).CreateAlias), arg0) +} + +// CreateAliasRequest mocks base method. +func (m *MockKMSAPI) CreateAliasRequest(arg0 *kms.CreateAliasInput) (*request.Request, *kms.CreateAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.CreateAliasOutput) + return ret0, ret1 +} + +// CreateAliasRequest indicates an expected call of CreateAliasRequest. +func (mr *MockKMSAPIMockRecorder) CreateAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasRequest), arg0) +} + +// CreateAliasWithContext mocks base method. +func (m *MockKMSAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *kms.CreateAliasInput, arg2 ...request.Option) (*kms.CreateAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...) + ret0, _ := ret[0].(*kms.CreateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAliasWithContext indicates an expected call of CreateAliasWithContext. +func (mr *MockKMSAPIMockRecorder) CreateAliasWithContext(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, "CreateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateAliasWithContext), varargs...) +} + +// CreateCustomKeyStore mocks base method. +func (m *MockKMSAPI) CreateCustomKeyStore(arg0 *kms.CreateCustomKeyStoreInput) (*kms.CreateCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomKeyStore", arg0) + ret0, _ := ret[0].(*kms.CreateCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomKeyStore indicates an expected call of CreateCustomKeyStore. +func (mr *MockKMSAPIMockRecorder) CreateCustomKeyStore(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomKeyStore", reflect.TypeOf((*MockKMSAPI)(nil).CreateCustomKeyStore), arg0) +} + +// CreateCustomKeyStoreRequest mocks base method. +func (m *MockKMSAPI) CreateCustomKeyStoreRequest(arg0 *kms.CreateCustomKeyStoreInput) (*request.Request, *kms.CreateCustomKeyStoreOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateCustomKeyStoreRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.CreateCustomKeyStoreOutput) + return ret0, ret1 +} + +// CreateCustomKeyStoreRequest indicates an expected call of CreateCustomKeyStoreRequest. +func (mr *MockKMSAPIMockRecorder) CreateCustomKeyStoreRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomKeyStoreRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateCustomKeyStoreRequest), arg0) +} + +// CreateCustomKeyStoreWithContext mocks base method. +func (m *MockKMSAPI) CreateCustomKeyStoreWithContext(arg0 aws.Context, arg1 *kms.CreateCustomKeyStoreInput, arg2 ...request.Option) (*kms.CreateCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateCustomKeyStoreWithContext", varargs...) + ret0, _ := ret[0].(*kms.CreateCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateCustomKeyStoreWithContext indicates an expected call of CreateCustomKeyStoreWithContext. +func (mr *MockKMSAPIMockRecorder) CreateCustomKeyStoreWithContext(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, "CreateCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateCustomKeyStoreWithContext), varargs...) +} + +// CreateGrant mocks base method. +func (m *MockKMSAPI) CreateGrant(arg0 *kms.CreateGrantInput) (*kms.CreateGrantOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGrant", arg0) + ret0, _ := ret[0].(*kms.CreateGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGrant indicates an expected call of CreateGrant. +func (mr *MockKMSAPIMockRecorder) CreateGrant(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrant", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrant), arg0) +} + +// CreateGrantRequest mocks base method. +func (m *MockKMSAPI) CreateGrantRequest(arg0 *kms.CreateGrantInput) (*request.Request, *kms.CreateGrantOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGrantRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.CreateGrantOutput) + return ret0, ret1 +} + +// CreateGrantRequest indicates an expected call of CreateGrantRequest. +func (mr *MockKMSAPIMockRecorder) CreateGrantRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantRequest), arg0) +} + +// CreateGrantWithContext mocks base method. +func (m *MockKMSAPI) CreateGrantWithContext(arg0 aws.Context, arg1 *kms.CreateGrantInput, arg2 ...request.Option) (*kms.CreateGrantOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateGrantWithContext", varargs...) + ret0, _ := ret[0].(*kms.CreateGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGrantWithContext indicates an expected call of CreateGrantWithContext. +func (mr *MockKMSAPIMockRecorder) CreateGrantWithContext(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, "CreateGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateGrantWithContext), varargs...) +} + +// CreateKey mocks base method. +func (m *MockKMSAPI) CreateKey(arg0 *kms.CreateKeyInput) (*kms.CreateKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKey", arg0) + ret0, _ := ret[0].(*kms.CreateKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKey indicates an expected call of CreateKey. +func (mr *MockKMSAPIMockRecorder) CreateKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKey", reflect.TypeOf((*MockKMSAPI)(nil).CreateKey), arg0) +} + +// CreateKeyRequest mocks base method. +func (m *MockKMSAPI) CreateKeyRequest(arg0 *kms.CreateKeyInput) (*request.Request, *kms.CreateKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.CreateKeyOutput) + return ret0, ret1 +} + +// CreateKeyRequest indicates an expected call of CreateKeyRequest. +func (mr *MockKMSAPIMockRecorder) CreateKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyRequest), arg0) +} + +// CreateKeyWithContext mocks base method. +func (m *MockKMSAPI) CreateKeyWithContext(arg0 aws.Context, arg1 *kms.CreateKeyInput, arg2 ...request.Option) (*kms.CreateKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.CreateKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateKeyWithContext indicates an expected call of CreateKeyWithContext. +func (mr *MockKMSAPIMockRecorder) CreateKeyWithContext(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, "CreateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).CreateKeyWithContext), varargs...) +} + +// Decrypt mocks base method. +func (m *MockKMSAPI) Decrypt(arg0 *kms.DecryptInput) (*kms.DecryptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decrypt", arg0) + ret0, _ := ret[0].(*kms.DecryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Decrypt indicates an expected call of Decrypt. +func (mr *MockKMSAPIMockRecorder) Decrypt(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decrypt", reflect.TypeOf((*MockKMSAPI)(nil).Decrypt), arg0) +} + +// DecryptRequest mocks base method. +func (m *MockKMSAPI) DecryptRequest(arg0 *kms.DecryptInput) (*request.Request, *kms.DecryptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecryptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DecryptOutput) + return ret0, ret1 +} + +// DecryptRequest indicates an expected call of DecryptRequest. +func (mr *MockKMSAPIMockRecorder) DecryptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).DecryptRequest), arg0) +} + +// DecryptWithContext mocks base method. +func (m *MockKMSAPI) DecryptWithContext(arg0 aws.Context, arg1 *kms.DecryptInput, arg2 ...request.Option) (*kms.DecryptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DecryptWithContext", varargs...) + ret0, _ := ret[0].(*kms.DecryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DecryptWithContext indicates an expected call of DecryptWithContext. +func (mr *MockKMSAPIMockRecorder) DecryptWithContext(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, "DecryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DecryptWithContext), varargs...) +} + +// DeleteAlias mocks base method. +func (m *MockKMSAPI) DeleteAlias(arg0 *kms.DeleteAliasInput) (*kms.DeleteAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAlias", arg0) + ret0, _ := ret[0].(*kms.DeleteAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAlias indicates an expected call of DeleteAlias. +func (mr *MockKMSAPIMockRecorder) DeleteAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAlias", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAlias), arg0) +} + +// DeleteAliasRequest mocks base method. +func (m *MockKMSAPI) DeleteAliasRequest(arg0 *kms.DeleteAliasInput) (*request.Request, *kms.DeleteAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DeleteAliasOutput) + return ret0, ret1 +} + +// DeleteAliasRequest indicates an expected call of DeleteAliasRequest. +func (mr *MockKMSAPIMockRecorder) DeleteAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasRequest), arg0) +} + +// DeleteAliasWithContext mocks base method. +func (m *MockKMSAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *kms.DeleteAliasInput, arg2 ...request.Option) (*kms.DeleteAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...) + ret0, _ := ret[0].(*kms.DeleteAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAliasWithContext indicates an expected call of DeleteAliasWithContext. +func (mr *MockKMSAPIMockRecorder) DeleteAliasWithContext(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, "DeleteAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteAliasWithContext), varargs...) +} + +// DeleteCustomKeyStore mocks base method. +func (m *MockKMSAPI) DeleteCustomKeyStore(arg0 *kms.DeleteCustomKeyStoreInput) (*kms.DeleteCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomKeyStore", arg0) + ret0, _ := ret[0].(*kms.DeleteCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomKeyStore indicates an expected call of DeleteCustomKeyStore. +func (mr *MockKMSAPIMockRecorder) DeleteCustomKeyStore(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomKeyStore", reflect.TypeOf((*MockKMSAPI)(nil).DeleteCustomKeyStore), arg0) +} + +// DeleteCustomKeyStoreRequest mocks base method. +func (m *MockKMSAPI) DeleteCustomKeyStoreRequest(arg0 *kms.DeleteCustomKeyStoreInput) (*request.Request, *kms.DeleteCustomKeyStoreOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteCustomKeyStoreRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DeleteCustomKeyStoreOutput) + return ret0, ret1 +} + +// DeleteCustomKeyStoreRequest indicates an expected call of DeleteCustomKeyStoreRequest. +func (mr *MockKMSAPIMockRecorder) DeleteCustomKeyStoreRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomKeyStoreRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteCustomKeyStoreRequest), arg0) +} + +// DeleteCustomKeyStoreWithContext mocks base method. +func (m *MockKMSAPI) DeleteCustomKeyStoreWithContext(arg0 aws.Context, arg1 *kms.DeleteCustomKeyStoreInput, arg2 ...request.Option) (*kms.DeleteCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteCustomKeyStoreWithContext", varargs...) + ret0, _ := ret[0].(*kms.DeleteCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteCustomKeyStoreWithContext indicates an expected call of DeleteCustomKeyStoreWithContext. +func (mr *MockKMSAPIMockRecorder) DeleteCustomKeyStoreWithContext(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, "DeleteCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteCustomKeyStoreWithContext), varargs...) +} + +// DeleteImportedKeyMaterial mocks base method. +func (m *MockKMSAPI) DeleteImportedKeyMaterial(arg0 *kms.DeleteImportedKeyMaterialInput) (*kms.DeleteImportedKeyMaterialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteImportedKeyMaterial", arg0) + ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteImportedKeyMaterial indicates an expected call of DeleteImportedKeyMaterial. +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterial(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterial), arg0) +} + +// DeleteImportedKeyMaterialRequest mocks base method. +func (m *MockKMSAPI) DeleteImportedKeyMaterialRequest(arg0 *kms.DeleteImportedKeyMaterialInput) (*request.Request, *kms.DeleteImportedKeyMaterialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteImportedKeyMaterialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DeleteImportedKeyMaterialOutput) + return ret0, ret1 +} + +// DeleteImportedKeyMaterialRequest indicates an expected call of DeleteImportedKeyMaterialRequest. +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImportedKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialRequest), arg0) +} + +// DeleteImportedKeyMaterialWithContext mocks base method. +func (m *MockKMSAPI) DeleteImportedKeyMaterialWithContext(arg0 aws.Context, arg1 *kms.DeleteImportedKeyMaterialInput, arg2 ...request.Option) (*kms.DeleteImportedKeyMaterialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteImportedKeyMaterialWithContext", varargs...) + ret0, _ := ret[0].(*kms.DeleteImportedKeyMaterialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteImportedKeyMaterialWithContext indicates an expected call of DeleteImportedKeyMaterialWithContext. +func (mr *MockKMSAPIMockRecorder) DeleteImportedKeyMaterialWithContext(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, "DeleteImportedKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeleteImportedKeyMaterialWithContext), varargs...) +} + +// DeriveSharedSecret mocks base method. +func (m *MockKMSAPI) DeriveSharedSecret(arg0 *kms.DeriveSharedSecretInput) (*kms.DeriveSharedSecretOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeriveSharedSecret", arg0) + ret0, _ := ret[0].(*kms.DeriveSharedSecretOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeriveSharedSecret indicates an expected call of DeriveSharedSecret. +func (mr *MockKMSAPIMockRecorder) DeriveSharedSecret(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveSharedSecret", reflect.TypeOf((*MockKMSAPI)(nil).DeriveSharedSecret), arg0) +} + +// DeriveSharedSecretRequest mocks base method. +func (m *MockKMSAPI) DeriveSharedSecretRequest(arg0 *kms.DeriveSharedSecretInput) (*request.Request, *kms.DeriveSharedSecretOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeriveSharedSecretRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DeriveSharedSecretOutput) + return ret0, ret1 +} + +// DeriveSharedSecretRequest indicates an expected call of DeriveSharedSecretRequest. +func (mr *MockKMSAPIMockRecorder) DeriveSharedSecretRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveSharedSecretRequest", reflect.TypeOf((*MockKMSAPI)(nil).DeriveSharedSecretRequest), arg0) +} + +// DeriveSharedSecretWithContext mocks base method. +func (m *MockKMSAPI) DeriveSharedSecretWithContext(arg0 aws.Context, arg1 *kms.DeriveSharedSecretInput, arg2 ...request.Option) (*kms.DeriveSharedSecretOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeriveSharedSecretWithContext", varargs...) + ret0, _ := ret[0].(*kms.DeriveSharedSecretOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeriveSharedSecretWithContext indicates an expected call of DeriveSharedSecretWithContext. +func (mr *MockKMSAPIMockRecorder) DeriveSharedSecretWithContext(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, "DeriveSharedSecretWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DeriveSharedSecretWithContext), varargs...) +} + +// DescribeCustomKeyStores mocks base method. +func (m *MockKMSAPI) DescribeCustomKeyStores(arg0 *kms.DescribeCustomKeyStoresInput) (*kms.DescribeCustomKeyStoresOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCustomKeyStores", arg0) + ret0, _ := ret[0].(*kms.DescribeCustomKeyStoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCustomKeyStores indicates an expected call of DescribeCustomKeyStores. +func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStores(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomKeyStores", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStores), arg0) +} + +// DescribeCustomKeyStoresPages mocks base method. +func (m *MockKMSAPI) DescribeCustomKeyStoresPages(arg0 *kms.DescribeCustomKeyStoresInput, arg1 func(*kms.DescribeCustomKeyStoresOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCustomKeyStoresPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCustomKeyStoresPages indicates an expected call of DescribeCustomKeyStoresPages. +func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStoresPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomKeyStoresPages", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStoresPages), arg0, arg1) +} + +// DescribeCustomKeyStoresPagesWithContext mocks base method. +func (m *MockKMSAPI) DescribeCustomKeyStoresPagesWithContext(arg0 aws.Context, arg1 *kms.DescribeCustomKeyStoresInput, arg2 func(*kms.DescribeCustomKeyStoresOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCustomKeyStoresPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeCustomKeyStoresPagesWithContext indicates an expected call of DescribeCustomKeyStoresPagesWithContext. +func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStoresPagesWithContext(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, "DescribeCustomKeyStoresPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStoresPagesWithContext), varargs...) +} + +// DescribeCustomKeyStoresRequest mocks base method. +func (m *MockKMSAPI) DescribeCustomKeyStoresRequest(arg0 *kms.DescribeCustomKeyStoresInput) (*request.Request, *kms.DescribeCustomKeyStoresOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCustomKeyStoresRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DescribeCustomKeyStoresOutput) + return ret0, ret1 +} + +// DescribeCustomKeyStoresRequest indicates an expected call of DescribeCustomKeyStoresRequest. +func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStoresRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomKeyStoresRequest", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStoresRequest), arg0) +} + +// DescribeCustomKeyStoresWithContext mocks base method. +func (m *MockKMSAPI) DescribeCustomKeyStoresWithContext(arg0 aws.Context, arg1 *kms.DescribeCustomKeyStoresInput, arg2 ...request.Option) (*kms.DescribeCustomKeyStoresOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeCustomKeyStoresWithContext", varargs...) + ret0, _ := ret[0].(*kms.DescribeCustomKeyStoresOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCustomKeyStoresWithContext indicates an expected call of DescribeCustomKeyStoresWithContext. +func (mr *MockKMSAPIMockRecorder) DescribeCustomKeyStoresWithContext(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, "DescribeCustomKeyStoresWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeCustomKeyStoresWithContext), varargs...) +} + +// DescribeKey mocks base method. +func (m *MockKMSAPI) DescribeKey(arg0 *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKey", arg0) + ret0, _ := ret[0].(*kms.DescribeKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKey indicates an expected call of DescribeKey. +func (mr *MockKMSAPIMockRecorder) DescribeKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKey", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKey), arg0) +} + +// DescribeKeyRequest mocks base method. +func (m *MockKMSAPI) DescribeKeyRequest(arg0 *kms.DescribeKeyInput) (*request.Request, *kms.DescribeKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DescribeKeyOutput) + return ret0, ret1 +} + +// DescribeKeyRequest indicates an expected call of DescribeKeyRequest. +func (mr *MockKMSAPIMockRecorder) DescribeKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyRequest), arg0) +} + +// DescribeKeyWithContext mocks base method. +func (m *MockKMSAPI) DescribeKeyWithContext(arg0 aws.Context, arg1 *kms.DescribeKeyInput, arg2 ...request.Option) (*kms.DescribeKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.DescribeKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeKeyWithContext indicates an expected call of DescribeKeyWithContext. +func (mr *MockKMSAPIMockRecorder) DescribeKeyWithContext(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, "DescribeKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DescribeKeyWithContext), varargs...) +} + +// DisableKey mocks base method. +func (m *MockKMSAPI) DisableKey(arg0 *kms.DisableKeyInput) (*kms.DisableKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableKey", arg0) + ret0, _ := ret[0].(*kms.DisableKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableKey indicates an expected call of DisableKey. +func (mr *MockKMSAPIMockRecorder) DisableKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKey", reflect.TypeOf((*MockKMSAPI)(nil).DisableKey), arg0) +} + +// DisableKeyRequest mocks base method. +func (m *MockKMSAPI) DisableKeyRequest(arg0 *kms.DisableKeyInput) (*request.Request, *kms.DisableKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DisableKeyOutput) + return ret0, ret1 +} + +// DisableKeyRequest indicates an expected call of DisableKeyRequest. +func (mr *MockKMSAPIMockRecorder) DisableKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRequest), arg0) +} + +// DisableKeyRotation mocks base method. +func (m *MockKMSAPI) DisableKeyRotation(arg0 *kms.DisableKeyRotationInput) (*kms.DisableKeyRotationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableKeyRotation", arg0) + ret0, _ := ret[0].(*kms.DisableKeyRotationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableKeyRotation indicates an expected call of DisableKeyRotation. +func (mr *MockKMSAPIMockRecorder) DisableKeyRotation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotation), arg0) +} + +// DisableKeyRotationRequest mocks base method. +func (m *MockKMSAPI) DisableKeyRotationRequest(arg0 *kms.DisableKeyRotationInput) (*request.Request, *kms.DisableKeyRotationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableKeyRotationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DisableKeyRotationOutput) + return ret0, ret1 +} + +// DisableKeyRotationRequest indicates an expected call of DisableKeyRotationRequest. +func (mr *MockKMSAPIMockRecorder) DisableKeyRotationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationRequest), arg0) +} + +// DisableKeyRotationWithContext mocks base method. +func (m *MockKMSAPI) DisableKeyRotationWithContext(arg0 aws.Context, arg1 *kms.DisableKeyRotationInput, arg2 ...request.Option) (*kms.DisableKeyRotationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableKeyRotationWithContext", varargs...) + ret0, _ := ret[0].(*kms.DisableKeyRotationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableKeyRotationWithContext indicates an expected call of DisableKeyRotationWithContext. +func (mr *MockKMSAPIMockRecorder) DisableKeyRotationWithContext(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, "DisableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyRotationWithContext), varargs...) +} + +// DisableKeyWithContext mocks base method. +func (m *MockKMSAPI) DisableKeyWithContext(arg0 aws.Context, arg1 *kms.DisableKeyInput, arg2 ...request.Option) (*kms.DisableKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.DisableKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableKeyWithContext indicates an expected call of DisableKeyWithContext. +func (mr *MockKMSAPIMockRecorder) DisableKeyWithContext(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, "DisableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisableKeyWithContext), varargs...) +} + +// DisconnectCustomKeyStore mocks base method. +func (m *MockKMSAPI) DisconnectCustomKeyStore(arg0 *kms.DisconnectCustomKeyStoreInput) (*kms.DisconnectCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisconnectCustomKeyStore", arg0) + ret0, _ := ret[0].(*kms.DisconnectCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisconnectCustomKeyStore indicates an expected call of DisconnectCustomKeyStore. +func (mr *MockKMSAPIMockRecorder) DisconnectCustomKeyStore(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectCustomKeyStore", reflect.TypeOf((*MockKMSAPI)(nil).DisconnectCustomKeyStore), arg0) +} + +// DisconnectCustomKeyStoreRequest mocks base method. +func (m *MockKMSAPI) DisconnectCustomKeyStoreRequest(arg0 *kms.DisconnectCustomKeyStoreInput) (*request.Request, *kms.DisconnectCustomKeyStoreOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisconnectCustomKeyStoreRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.DisconnectCustomKeyStoreOutput) + return ret0, ret1 +} + +// DisconnectCustomKeyStoreRequest indicates an expected call of DisconnectCustomKeyStoreRequest. +func (mr *MockKMSAPIMockRecorder) DisconnectCustomKeyStoreRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectCustomKeyStoreRequest", reflect.TypeOf((*MockKMSAPI)(nil).DisconnectCustomKeyStoreRequest), arg0) +} + +// DisconnectCustomKeyStoreWithContext mocks base method. +func (m *MockKMSAPI) DisconnectCustomKeyStoreWithContext(arg0 aws.Context, arg1 *kms.DisconnectCustomKeyStoreInput, arg2 ...request.Option) (*kms.DisconnectCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisconnectCustomKeyStoreWithContext", varargs...) + ret0, _ := ret[0].(*kms.DisconnectCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisconnectCustomKeyStoreWithContext indicates an expected call of DisconnectCustomKeyStoreWithContext. +func (mr *MockKMSAPIMockRecorder) DisconnectCustomKeyStoreWithContext(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, "DisconnectCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).DisconnectCustomKeyStoreWithContext), varargs...) +} + +// EnableKey mocks base method. +func (m *MockKMSAPI) EnableKey(arg0 *kms.EnableKeyInput) (*kms.EnableKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableKey", arg0) + ret0, _ := ret[0].(*kms.EnableKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableKey indicates an expected call of EnableKey. +func (mr *MockKMSAPIMockRecorder) EnableKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKey", reflect.TypeOf((*MockKMSAPI)(nil).EnableKey), arg0) +} + +// EnableKeyRequest mocks base method. +func (m *MockKMSAPI) EnableKeyRequest(arg0 *kms.EnableKeyInput) (*request.Request, *kms.EnableKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.EnableKeyOutput) + return ret0, ret1 +} + +// EnableKeyRequest indicates an expected call of EnableKeyRequest. +func (mr *MockKMSAPIMockRecorder) EnableKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRequest), arg0) +} + +// EnableKeyRotation mocks base method. +func (m *MockKMSAPI) EnableKeyRotation(arg0 *kms.EnableKeyRotationInput) (*kms.EnableKeyRotationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableKeyRotation", arg0) + ret0, _ := ret[0].(*kms.EnableKeyRotationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableKeyRotation indicates an expected call of EnableKeyRotation. +func (mr *MockKMSAPIMockRecorder) EnableKeyRotation(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotation", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotation), arg0) +} + +// EnableKeyRotationRequest mocks base method. +func (m *MockKMSAPI) EnableKeyRotationRequest(arg0 *kms.EnableKeyRotationInput) (*request.Request, *kms.EnableKeyRotationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableKeyRotationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.EnableKeyRotationOutput) + return ret0, ret1 +} + +// EnableKeyRotationRequest indicates an expected call of EnableKeyRotationRequest. +func (mr *MockKMSAPIMockRecorder) EnableKeyRotationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKeyRotationRequest", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationRequest), arg0) +} + +// EnableKeyRotationWithContext mocks base method. +func (m *MockKMSAPI) EnableKeyRotationWithContext(arg0 aws.Context, arg1 *kms.EnableKeyRotationInput, arg2 ...request.Option) (*kms.EnableKeyRotationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableKeyRotationWithContext", varargs...) + ret0, _ := ret[0].(*kms.EnableKeyRotationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableKeyRotationWithContext indicates an expected call of EnableKeyRotationWithContext. +func (mr *MockKMSAPIMockRecorder) EnableKeyRotationWithContext(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, "EnableKeyRotationWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyRotationWithContext), varargs...) +} + +// EnableKeyWithContext mocks base method. +func (m *MockKMSAPI) EnableKeyWithContext(arg0 aws.Context, arg1 *kms.EnableKeyInput, arg2 ...request.Option) (*kms.EnableKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.EnableKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableKeyWithContext indicates an expected call of EnableKeyWithContext. +func (mr *MockKMSAPIMockRecorder) EnableKeyWithContext(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, "EnableKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EnableKeyWithContext), varargs...) +} + +// Encrypt mocks base method. +func (m *MockKMSAPI) Encrypt(arg0 *kms.EncryptInput) (*kms.EncryptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Encrypt", arg0) + ret0, _ := ret[0].(*kms.EncryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Encrypt indicates an expected call of Encrypt. +func (mr *MockKMSAPIMockRecorder) Encrypt(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Encrypt", reflect.TypeOf((*MockKMSAPI)(nil).Encrypt), arg0) +} + +// EncryptRequest mocks base method. +func (m *MockKMSAPI) EncryptRequest(arg0 *kms.EncryptInput) (*request.Request, *kms.EncryptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EncryptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.EncryptOutput) + return ret0, ret1 +} + +// EncryptRequest indicates an expected call of EncryptRequest. +func (mr *MockKMSAPIMockRecorder) EncryptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).EncryptRequest), arg0) +} + +// EncryptWithContext mocks base method. +func (m *MockKMSAPI) EncryptWithContext(arg0 aws.Context, arg1 *kms.EncryptInput, arg2 ...request.Option) (*kms.EncryptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EncryptWithContext", varargs...) + ret0, _ := ret[0].(*kms.EncryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EncryptWithContext indicates an expected call of EncryptWithContext. +func (mr *MockKMSAPIMockRecorder) EncryptWithContext(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, "EncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).EncryptWithContext), varargs...) +} + +// GenerateDataKey mocks base method. +func (m *MockKMSAPI) GenerateDataKey(arg0 *kms.GenerateDataKeyInput) (*kms.GenerateDataKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKey", arg0) + ret0, _ := ret[0].(*kms.GenerateDataKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKey indicates an expected call of GenerateDataKey. +func (mr *MockKMSAPIMockRecorder) GenerateDataKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKey", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKey), arg0) +} + +// GenerateDataKeyPair mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPair(arg0 *kms.GenerateDataKeyPairInput) (*kms.GenerateDataKeyPairOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyPair", arg0) + ret0, _ := ret[0].(*kms.GenerateDataKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyPair indicates an expected call of GenerateDataKeyPair. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPair(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPair", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPair), arg0) +} + +// GenerateDataKeyPairRequest mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPairRequest(arg0 *kms.GenerateDataKeyPairInput) (*request.Request, *kms.GenerateDataKeyPairOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyPairRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateDataKeyPairOutput) + return ret0, ret1 +} + +// GenerateDataKeyPairRequest indicates an expected call of GenerateDataKeyPairRequest. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPairRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairRequest), arg0) +} + +// GenerateDataKeyPairWithContext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPairWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyPairInput, arg2 ...request.Option) (*kms.GenerateDataKeyPairOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateDataKeyPairWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateDataKeyPairOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyPairWithContext indicates an expected call of GenerateDataKeyPairWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithContext(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, "GenerateDataKeyPairWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithContext), varargs...) +} + +// GenerateDataKeyPairWithoutPlaintext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintext(arg0 *kms.GenerateDataKeyPairWithoutPlaintextInput) (*kms.GenerateDataKeyPairWithoutPlaintextOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintext", arg0) + ret0, _ := ret[0].(*kms.GenerateDataKeyPairWithoutPlaintextOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyPairWithoutPlaintext indicates an expected call of GenerateDataKeyPairWithoutPlaintext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithoutPlaintext(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPairWithoutPlaintext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithoutPlaintext), arg0) +} + +// GenerateDataKeyPairWithoutPlaintextRequest mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintextRequest(arg0 *kms.GenerateDataKeyPairWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyPairWithoutPlaintextOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintextRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateDataKeyPairWithoutPlaintextOutput) + return ret0, ret1 +} + +// GenerateDataKeyPairWithoutPlaintextRequest indicates an expected call of GenerateDataKeyPairWithoutPlaintextRequest. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithoutPlaintextRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyPairWithoutPlaintextRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithoutPlaintextRequest), arg0) +} + +// GenerateDataKeyPairWithoutPlaintextWithContext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyPairWithoutPlaintextWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyPairWithoutPlaintextInput, arg2 ...request.Option) (*kms.GenerateDataKeyPairWithoutPlaintextOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateDataKeyPairWithoutPlaintextWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateDataKeyPairWithoutPlaintextOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyPairWithoutPlaintextWithContext indicates an expected call of GenerateDataKeyPairWithoutPlaintextWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyPairWithoutPlaintextWithContext(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, "GenerateDataKeyPairWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyPairWithoutPlaintextWithContext), varargs...) +} + +// GenerateDataKeyRequest mocks base method. +func (m *MockKMSAPI) GenerateDataKeyRequest(arg0 *kms.GenerateDataKeyInput) (*request.Request, *kms.GenerateDataKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateDataKeyOutput) + return ret0, ret1 +} + +// GenerateDataKeyRequest indicates an expected call of GenerateDataKeyRequest. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyRequest), arg0) +} + +// GenerateDataKeyWithContext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyInput, arg2 ...request.Option) (*kms.GenerateDataKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateDataKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateDataKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyWithContext indicates an expected call of GenerateDataKeyWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithContext(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, "GenerateDataKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithContext), varargs...) +} + +// GenerateDataKeyWithoutPlaintext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintext(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintext", arg0) + ret0, _ := ret[0].(*kms.GenerateDataKeyWithoutPlaintextOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyWithoutPlaintext indicates an expected call of GenerateDataKeyWithoutPlaintext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintext(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintext), arg0) +} + +// GenerateDataKeyWithoutPlaintextRequest mocks base method. +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextRequest(arg0 *kms.GenerateDataKeyWithoutPlaintextInput) (*request.Request, *kms.GenerateDataKeyWithoutPlaintextOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintextRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateDataKeyWithoutPlaintextOutput) + return ret0, ret1 +} + +// GenerateDataKeyWithoutPlaintextRequest indicates an expected call of GenerateDataKeyWithoutPlaintextRequest. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintextRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateDataKeyWithoutPlaintextRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextRequest), arg0) +} + +// GenerateDataKeyWithoutPlaintextWithContext mocks base method. +func (m *MockKMSAPI) GenerateDataKeyWithoutPlaintextWithContext(arg0 aws.Context, arg1 *kms.GenerateDataKeyWithoutPlaintextInput, arg2 ...request.Option) (*kms.GenerateDataKeyWithoutPlaintextOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateDataKeyWithoutPlaintextWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateDataKeyWithoutPlaintextOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateDataKeyWithoutPlaintextWithContext indicates an expected call of GenerateDataKeyWithoutPlaintextWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateDataKeyWithoutPlaintextWithContext(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, "GenerateDataKeyWithoutPlaintextWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateDataKeyWithoutPlaintextWithContext), varargs...) +} + +// GenerateMac mocks base method. +func (m *MockKMSAPI) GenerateMac(arg0 *kms.GenerateMacInput) (*kms.GenerateMacOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateMac", arg0) + ret0, _ := ret[0].(*kms.GenerateMacOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateMac indicates an expected call of GenerateMac. +func (mr *MockKMSAPIMockRecorder) GenerateMac(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateMac", reflect.TypeOf((*MockKMSAPI)(nil).GenerateMac), arg0) +} + +// GenerateMacRequest mocks base method. +func (m *MockKMSAPI) GenerateMacRequest(arg0 *kms.GenerateMacInput) (*request.Request, *kms.GenerateMacOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateMacRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateMacOutput) + return ret0, ret1 +} + +// GenerateMacRequest indicates an expected call of GenerateMacRequest. +func (mr *MockKMSAPIMockRecorder) GenerateMacRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateMacRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateMacRequest), arg0) +} + +// GenerateMacWithContext mocks base method. +func (m *MockKMSAPI) GenerateMacWithContext(arg0 aws.Context, arg1 *kms.GenerateMacInput, arg2 ...request.Option) (*kms.GenerateMacOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateMacWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateMacOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateMacWithContext indicates an expected call of GenerateMacWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateMacWithContext(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, "GenerateMacWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateMacWithContext), varargs...) +} + +// GenerateRandom mocks base method. +func (m *MockKMSAPI) GenerateRandom(arg0 *kms.GenerateRandomInput) (*kms.GenerateRandomOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateRandom", arg0) + ret0, _ := ret[0].(*kms.GenerateRandomOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateRandom indicates an expected call of GenerateRandom. +func (mr *MockKMSAPIMockRecorder) GenerateRandom(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandom", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandom), arg0) +} + +// GenerateRandomRequest mocks base method. +func (m *MockKMSAPI) GenerateRandomRequest(arg0 *kms.GenerateRandomInput) (*request.Request, *kms.GenerateRandomOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GenerateRandomRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GenerateRandomOutput) + return ret0, ret1 +} + +// GenerateRandomRequest indicates an expected call of GenerateRandomRequest. +func (mr *MockKMSAPIMockRecorder) GenerateRandomRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateRandomRequest", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomRequest), arg0) +} + +// GenerateRandomWithContext mocks base method. +func (m *MockKMSAPI) GenerateRandomWithContext(arg0 aws.Context, arg1 *kms.GenerateRandomInput, arg2 ...request.Option) (*kms.GenerateRandomOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GenerateRandomWithContext", varargs...) + ret0, _ := ret[0].(*kms.GenerateRandomOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GenerateRandomWithContext indicates an expected call of GenerateRandomWithContext. +func (mr *MockKMSAPIMockRecorder) GenerateRandomWithContext(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, "GenerateRandomWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GenerateRandomWithContext), varargs...) +} + +// GetKeyPolicy mocks base method. +func (m *MockKMSAPI) GetKeyPolicy(arg0 *kms.GetKeyPolicyInput) (*kms.GetKeyPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetKeyPolicy", arg0) + ret0, _ := ret[0].(*kms.GetKeyPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetKeyPolicy indicates an expected call of GetKeyPolicy. +func (mr *MockKMSAPIMockRecorder) GetKeyPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicy), arg0) +} + +// GetKeyPolicyRequest mocks base method. +func (m *MockKMSAPI) GetKeyPolicyRequest(arg0 *kms.GetKeyPolicyInput) (*request.Request, *kms.GetKeyPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetKeyPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GetKeyPolicyOutput) + return ret0, ret1 +} + +// GetKeyPolicyRequest indicates an expected call of GetKeyPolicyRequest. +func (mr *MockKMSAPIMockRecorder) GetKeyPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyRequest), arg0) +} + +// GetKeyPolicyWithContext mocks base method. +func (m *MockKMSAPI) GetKeyPolicyWithContext(arg0 aws.Context, arg1 *kms.GetKeyPolicyInput, arg2 ...request.Option) (*kms.GetKeyPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetKeyPolicyWithContext", varargs...) + ret0, _ := ret[0].(*kms.GetKeyPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetKeyPolicyWithContext indicates an expected call of GetKeyPolicyWithContext. +func (mr *MockKMSAPIMockRecorder) GetKeyPolicyWithContext(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, "GetKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyPolicyWithContext), varargs...) +} + +// GetKeyRotationStatus mocks base method. +func (m *MockKMSAPI) GetKeyRotationStatus(arg0 *kms.GetKeyRotationStatusInput) (*kms.GetKeyRotationStatusOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetKeyRotationStatus", arg0) + ret0, _ := ret[0].(*kms.GetKeyRotationStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetKeyRotationStatus indicates an expected call of GetKeyRotationStatus. +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatus(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatus", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatus), arg0) +} + +// GetKeyRotationStatusRequest mocks base method. +func (m *MockKMSAPI) GetKeyRotationStatusRequest(arg0 *kms.GetKeyRotationStatusInput) (*request.Request, *kms.GetKeyRotationStatusOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetKeyRotationStatusRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GetKeyRotationStatusOutput) + return ret0, ret1 +} + +// GetKeyRotationStatusRequest indicates an expected call of GetKeyRotationStatusRequest. +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatusRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKeyRotationStatusRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusRequest), arg0) +} + +// GetKeyRotationStatusWithContext mocks base method. +func (m *MockKMSAPI) GetKeyRotationStatusWithContext(arg0 aws.Context, arg1 *kms.GetKeyRotationStatusInput, arg2 ...request.Option) (*kms.GetKeyRotationStatusOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetKeyRotationStatusWithContext", varargs...) + ret0, _ := ret[0].(*kms.GetKeyRotationStatusOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetKeyRotationStatusWithContext indicates an expected call of GetKeyRotationStatusWithContext. +func (mr *MockKMSAPIMockRecorder) GetKeyRotationStatusWithContext(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, "GetKeyRotationStatusWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetKeyRotationStatusWithContext), varargs...) +} + +// GetParametersForImport mocks base method. +func (m *MockKMSAPI) GetParametersForImport(arg0 *kms.GetParametersForImportInput) (*kms.GetParametersForImportOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetParametersForImport", arg0) + ret0, _ := ret[0].(*kms.GetParametersForImportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetParametersForImport indicates an expected call of GetParametersForImport. +func (mr *MockKMSAPIMockRecorder) GetParametersForImport(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImport", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImport), arg0) +} + +// GetParametersForImportRequest mocks base method. +func (m *MockKMSAPI) GetParametersForImportRequest(arg0 *kms.GetParametersForImportInput) (*request.Request, *kms.GetParametersForImportOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetParametersForImportRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GetParametersForImportOutput) + return ret0, ret1 +} + +// GetParametersForImportRequest indicates an expected call of GetParametersForImportRequest. +func (mr *MockKMSAPIMockRecorder) GetParametersForImportRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParametersForImportRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportRequest), arg0) +} + +// GetParametersForImportWithContext mocks base method. +func (m *MockKMSAPI) GetParametersForImportWithContext(arg0 aws.Context, arg1 *kms.GetParametersForImportInput, arg2 ...request.Option) (*kms.GetParametersForImportOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetParametersForImportWithContext", varargs...) + ret0, _ := ret[0].(*kms.GetParametersForImportOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetParametersForImportWithContext indicates an expected call of GetParametersForImportWithContext. +func (mr *MockKMSAPIMockRecorder) GetParametersForImportWithContext(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, "GetParametersForImportWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetParametersForImportWithContext), varargs...) +} + +// GetPublicKey mocks base method. +func (m *MockKMSAPI) GetPublicKey(arg0 *kms.GetPublicKeyInput) (*kms.GetPublicKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPublicKey", arg0) + ret0, _ := ret[0].(*kms.GetPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPublicKey indicates an expected call of GetPublicKey. +func (mr *MockKMSAPIMockRecorder) GetPublicKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKey", reflect.TypeOf((*MockKMSAPI)(nil).GetPublicKey), arg0) +} + +// GetPublicKeyRequest mocks base method. +func (m *MockKMSAPI) GetPublicKeyRequest(arg0 *kms.GetPublicKeyInput) (*request.Request, *kms.GetPublicKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPublicKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.GetPublicKeyOutput) + return ret0, ret1 +} + +// GetPublicKeyRequest indicates an expected call of GetPublicKeyRequest. +func (mr *MockKMSAPIMockRecorder) GetPublicKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublicKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).GetPublicKeyRequest), arg0) +} + +// GetPublicKeyWithContext mocks base method. +func (m *MockKMSAPI) GetPublicKeyWithContext(arg0 aws.Context, arg1 *kms.GetPublicKeyInput, arg2 ...request.Option) (*kms.GetPublicKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPublicKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.GetPublicKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPublicKeyWithContext indicates an expected call of GetPublicKeyWithContext. +func (mr *MockKMSAPIMockRecorder) GetPublicKeyWithContext(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, "GetPublicKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).GetPublicKeyWithContext), varargs...) +} + +// ImportKeyMaterial mocks base method. +func (m *MockKMSAPI) ImportKeyMaterial(arg0 *kms.ImportKeyMaterialInput) (*kms.ImportKeyMaterialOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportKeyMaterial", arg0) + ret0, _ := ret[0].(*kms.ImportKeyMaterialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportKeyMaterial indicates an expected call of ImportKeyMaterial. +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterial(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterial", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterial), arg0) +} + +// ImportKeyMaterialRequest mocks base method. +func (m *MockKMSAPI) ImportKeyMaterialRequest(arg0 *kms.ImportKeyMaterialInput) (*request.Request, *kms.ImportKeyMaterialOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportKeyMaterialRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ImportKeyMaterialOutput) + return ret0, ret1 +} + +// ImportKeyMaterialRequest indicates an expected call of ImportKeyMaterialRequest. +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterialRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyMaterialRequest", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialRequest), arg0) +} + +// ImportKeyMaterialWithContext mocks base method. +func (m *MockKMSAPI) ImportKeyMaterialWithContext(arg0 aws.Context, arg1 *kms.ImportKeyMaterialInput, arg2 ...request.Option) (*kms.ImportKeyMaterialOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportKeyMaterialWithContext", varargs...) + ret0, _ := ret[0].(*kms.ImportKeyMaterialOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportKeyMaterialWithContext indicates an expected call of ImportKeyMaterialWithContext. +func (mr *MockKMSAPIMockRecorder) ImportKeyMaterialWithContext(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, "ImportKeyMaterialWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ImportKeyMaterialWithContext), varargs...) +} + +// ListAliases mocks base method. +func (m *MockKMSAPI) ListAliases(arg0 *kms.ListAliasesInput) (*kms.ListAliasesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliases", arg0) + ret0, _ := ret[0].(*kms.ListAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAliases indicates an expected call of ListAliases. +func (mr *MockKMSAPIMockRecorder) ListAliases(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliases", reflect.TypeOf((*MockKMSAPI)(nil).ListAliases), arg0) +} + +// ListAliasesPages mocks base method. +func (m *MockKMSAPI) ListAliasesPages(arg0 *kms.ListAliasesInput, arg1 func(*kms.ListAliasesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliasesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAliasesPages indicates an expected call of ListAliasesPages. +func (mr *MockKMSAPIMockRecorder) ListAliasesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPages), arg0, arg1) +} + +// ListAliasesPagesWithContext mocks base method. +func (m *MockKMSAPI) ListAliasesPagesWithContext(arg0 aws.Context, arg1 *kms.ListAliasesInput, arg2 func(*kms.ListAliasesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAliasesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListAliasesPagesWithContext indicates an expected call of ListAliasesPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListAliasesPagesWithContext(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, "ListAliasesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesPagesWithContext), varargs...) +} + +// ListAliasesRequest mocks base method. +func (m *MockKMSAPI) ListAliasesRequest(arg0 *kms.ListAliasesInput) (*request.Request, *kms.ListAliasesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListAliasesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListAliasesOutput) + return ret0, ret1 +} + +// ListAliasesRequest indicates an expected call of ListAliasesRequest. +func (mr *MockKMSAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesRequest), arg0) +} + +// ListAliasesWithContext mocks base method. +func (m *MockKMSAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *kms.ListAliasesInput, arg2 ...request.Option) (*kms.ListAliasesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListAliasesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListAliasesWithContext indicates an expected call of ListAliasesWithContext. +func (mr *MockKMSAPIMockRecorder) ListAliasesWithContext(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, "ListAliasesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListAliasesWithContext), varargs...) +} + +// ListGrants mocks base method. +func (m *MockKMSAPI) ListGrants(arg0 *kms.ListGrantsInput) (*kms.ListGrantsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGrants", arg0) + ret0, _ := ret[0].(*kms.ListGrantsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGrants indicates an expected call of ListGrants. +func (mr *MockKMSAPIMockRecorder) ListGrants(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListGrants), arg0) +} + +// ListGrantsPages mocks base method. +func (m *MockKMSAPI) ListGrantsPages(arg0 *kms.ListGrantsInput, arg1 func(*kms.ListGrantsResponse, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGrantsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGrantsPages indicates an expected call of ListGrantsPages. +func (mr *MockKMSAPIMockRecorder) ListGrantsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPages), arg0, arg1) +} + +// ListGrantsPagesWithContext mocks base method. +func (m *MockKMSAPI) ListGrantsPagesWithContext(arg0 aws.Context, arg1 *kms.ListGrantsInput, arg2 func(*kms.ListGrantsResponse, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGrantsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListGrantsPagesWithContext indicates an expected call of ListGrantsPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListGrantsPagesWithContext(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, "ListGrantsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsPagesWithContext), varargs...) +} + +// ListGrantsRequest mocks base method. +func (m *MockKMSAPI) ListGrantsRequest(arg0 *kms.ListGrantsInput) (*request.Request, *kms.ListGrantsResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListGrantsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListGrantsResponse) + return ret0, ret1 +} + +// ListGrantsRequest indicates an expected call of ListGrantsRequest. +func (mr *MockKMSAPIMockRecorder) ListGrantsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsRequest), arg0) +} + +// ListGrantsWithContext mocks base method. +func (m *MockKMSAPI) ListGrantsWithContext(arg0 aws.Context, arg1 *kms.ListGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListGrantsWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListGrantsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListGrantsWithContext indicates an expected call of ListGrantsWithContext. +func (mr *MockKMSAPIMockRecorder) ListGrantsWithContext(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, "ListGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListGrantsWithContext), varargs...) +} + +// ListKeyPolicies mocks base method. +func (m *MockKMSAPI) ListKeyPolicies(arg0 *kms.ListKeyPoliciesInput) (*kms.ListKeyPoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyPolicies", arg0) + ret0, _ := ret[0].(*kms.ListKeyPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeyPolicies indicates an expected call of ListKeyPolicies. +func (mr *MockKMSAPIMockRecorder) ListKeyPolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPolicies", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPolicies), arg0) +} + +// ListKeyPoliciesPages mocks base method. +func (m *MockKMSAPI) ListKeyPoliciesPages(arg0 *kms.ListKeyPoliciesInput, arg1 func(*kms.ListKeyPoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyPoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeyPoliciesPages indicates an expected call of ListKeyPoliciesPages. +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPages), arg0, arg1) +} + +// ListKeyPoliciesPagesWithContext mocks base method. +func (m *MockKMSAPI) ListKeyPoliciesPagesWithContext(arg0 aws.Context, arg1 *kms.ListKeyPoliciesInput, arg2 func(*kms.ListKeyPoliciesOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeyPoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeyPoliciesPagesWithContext indicates an expected call of ListKeyPoliciesPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesPagesWithContext(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, "ListKeyPoliciesPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesPagesWithContext), varargs...) +} + +// ListKeyPoliciesRequest mocks base method. +func (m *MockKMSAPI) ListKeyPoliciesRequest(arg0 *kms.ListKeyPoliciesInput) (*request.Request, *kms.ListKeyPoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyPoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListKeyPoliciesOutput) + return ret0, ret1 +} + +// ListKeyPoliciesRequest indicates an expected call of ListKeyPoliciesRequest. +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyPoliciesRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesRequest), arg0) +} + +// ListKeyPoliciesWithContext mocks base method. +func (m *MockKMSAPI) ListKeyPoliciesWithContext(arg0 aws.Context, arg1 *kms.ListKeyPoliciesInput, arg2 ...request.Option) (*kms.ListKeyPoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeyPoliciesWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListKeyPoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeyPoliciesWithContext indicates an expected call of ListKeyPoliciesWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeyPoliciesWithContext(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, "ListKeyPoliciesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyPoliciesWithContext), varargs...) +} + +// ListKeyRotations mocks base method. +func (m *MockKMSAPI) ListKeyRotations(arg0 *kms.ListKeyRotationsInput) (*kms.ListKeyRotationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyRotations", arg0) + ret0, _ := ret[0].(*kms.ListKeyRotationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeyRotations indicates an expected call of ListKeyRotations. +func (mr *MockKMSAPIMockRecorder) ListKeyRotations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyRotations", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyRotations), arg0) +} + +// ListKeyRotationsPages mocks base method. +func (m *MockKMSAPI) ListKeyRotationsPages(arg0 *kms.ListKeyRotationsInput, arg1 func(*kms.ListKeyRotationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyRotationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeyRotationsPages indicates an expected call of ListKeyRotationsPages. +func (mr *MockKMSAPIMockRecorder) ListKeyRotationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyRotationsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyRotationsPages), arg0, arg1) +} + +// ListKeyRotationsPagesWithContext mocks base method. +func (m *MockKMSAPI) ListKeyRotationsPagesWithContext(arg0 aws.Context, arg1 *kms.ListKeyRotationsInput, arg2 func(*kms.ListKeyRotationsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeyRotationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeyRotationsPagesWithContext indicates an expected call of ListKeyRotationsPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeyRotationsPagesWithContext(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, "ListKeyRotationsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyRotationsPagesWithContext), varargs...) +} + +// ListKeyRotationsRequest mocks base method. +func (m *MockKMSAPI) ListKeyRotationsRequest(arg0 *kms.ListKeyRotationsInput) (*request.Request, *kms.ListKeyRotationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeyRotationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListKeyRotationsOutput) + return ret0, ret1 +} + +// ListKeyRotationsRequest indicates an expected call of ListKeyRotationsRequest. +func (mr *MockKMSAPIMockRecorder) ListKeyRotationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeyRotationsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyRotationsRequest), arg0) +} + +// ListKeyRotationsWithContext mocks base method. +func (m *MockKMSAPI) ListKeyRotationsWithContext(arg0 aws.Context, arg1 *kms.ListKeyRotationsInput, arg2 ...request.Option) (*kms.ListKeyRotationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeyRotationsWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListKeyRotationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeyRotationsWithContext indicates an expected call of ListKeyRotationsWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeyRotationsWithContext(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, "ListKeyRotationsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeyRotationsWithContext), varargs...) +} + +// ListKeys mocks base method. +func (m *MockKMSAPI) ListKeys(arg0 *kms.ListKeysInput) (*kms.ListKeysOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeys", arg0) + ret0, _ := ret[0].(*kms.ListKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeys indicates an expected call of ListKeys. +func (mr *MockKMSAPIMockRecorder) ListKeys(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockKMSAPI)(nil).ListKeys), arg0) +} + +// ListKeysPages mocks base method. +func (m *MockKMSAPI) ListKeysPages(arg0 *kms.ListKeysInput, arg1 func(*kms.ListKeysOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeysPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeysPages indicates an expected call of ListKeysPages. +func (mr *MockKMSAPIMockRecorder) ListKeysPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysPages", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPages), arg0, arg1) +} + +// ListKeysPagesWithContext mocks base method. +func (m *MockKMSAPI) ListKeysPagesWithContext(arg0 aws.Context, arg1 *kms.ListKeysInput, arg2 func(*kms.ListKeysOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeysPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListKeysPagesWithContext indicates an expected call of ListKeysPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeysPagesWithContext(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, "ListKeysPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysPagesWithContext), varargs...) +} + +// ListKeysRequest mocks base method. +func (m *MockKMSAPI) ListKeysRequest(arg0 *kms.ListKeysInput) (*request.Request, *kms.ListKeysOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListKeysRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListKeysOutput) + return ret0, ret1 +} + +// ListKeysRequest indicates an expected call of ListKeysRequest. +func (mr *MockKMSAPIMockRecorder) ListKeysRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeysRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysRequest), arg0) +} + +// ListKeysWithContext mocks base method. +func (m *MockKMSAPI) ListKeysWithContext(arg0 aws.Context, arg1 *kms.ListKeysInput, arg2 ...request.Option) (*kms.ListKeysOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListKeysWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListKeysOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListKeysWithContext indicates an expected call of ListKeysWithContext. +func (mr *MockKMSAPIMockRecorder) ListKeysWithContext(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, "ListKeysWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListKeysWithContext), varargs...) +} + +// ListResourceTags mocks base method. +func (m *MockKMSAPI) ListResourceTags(arg0 *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceTags", arg0) + ret0, _ := ret[0].(*kms.ListResourceTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResourceTags indicates an expected call of ListResourceTags. +func (mr *MockKMSAPIMockRecorder) ListResourceTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTags", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTags), arg0) +} + +// ListResourceTagsPages mocks base method. +func (m *MockKMSAPI) ListResourceTagsPages(arg0 *kms.ListResourceTagsInput, arg1 func(*kms.ListResourceTagsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceTagsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResourceTagsPages indicates an expected call of ListResourceTagsPages. +func (mr *MockKMSAPIMockRecorder) ListResourceTagsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTagsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsPages), arg0, arg1) +} + +// ListResourceTagsPagesWithContext mocks base method. +func (m *MockKMSAPI) ListResourceTagsPagesWithContext(arg0 aws.Context, arg1 *kms.ListResourceTagsInput, arg2 func(*kms.ListResourceTagsOutput, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResourceTagsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListResourceTagsPagesWithContext indicates an expected call of ListResourceTagsPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListResourceTagsPagesWithContext(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, "ListResourceTagsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsPagesWithContext), varargs...) +} + +// ListResourceTagsRequest mocks base method. +func (m *MockKMSAPI) ListResourceTagsRequest(arg0 *kms.ListResourceTagsInput) (*request.Request, *kms.ListResourceTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListResourceTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListResourceTagsOutput) + return ret0, ret1 +} + +// ListResourceTagsRequest indicates an expected call of ListResourceTagsRequest. +func (mr *MockKMSAPIMockRecorder) ListResourceTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceTagsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsRequest), arg0) +} + +// ListResourceTagsWithContext mocks base method. +func (m *MockKMSAPI) ListResourceTagsWithContext(arg0 aws.Context, arg1 *kms.ListResourceTagsInput, arg2 ...request.Option) (*kms.ListResourceTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListResourceTagsWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListResourceTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListResourceTagsWithContext indicates an expected call of ListResourceTagsWithContext. +func (mr *MockKMSAPIMockRecorder) ListResourceTagsWithContext(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, "ListResourceTagsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListResourceTagsWithContext), varargs...) +} + +// ListRetirableGrants mocks base method. +func (m *MockKMSAPI) ListRetirableGrants(arg0 *kms.ListRetirableGrantsInput) (*kms.ListGrantsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRetirableGrants", arg0) + ret0, _ := ret[0].(*kms.ListGrantsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRetirableGrants indicates an expected call of ListRetirableGrants. +func (mr *MockKMSAPIMockRecorder) ListRetirableGrants(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrants", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrants), arg0) +} + +// ListRetirableGrantsPages mocks base method. +func (m *MockKMSAPI) ListRetirableGrantsPages(arg0 *kms.ListRetirableGrantsInput, arg1 func(*kms.ListGrantsResponse, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRetirableGrantsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRetirableGrantsPages indicates an expected call of ListRetirableGrantsPages. +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrantsPages", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsPages), arg0, arg1) +} + +// ListRetirableGrantsPagesWithContext mocks base method. +func (m *MockKMSAPI) ListRetirableGrantsPagesWithContext(arg0 aws.Context, arg1 *kms.ListRetirableGrantsInput, arg2 func(*kms.ListGrantsResponse, bool) bool, arg3 ...request.Option) error { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRetirableGrantsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListRetirableGrantsPagesWithContext indicates an expected call of ListRetirableGrantsPagesWithContext. +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsPagesWithContext(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, "ListRetirableGrantsPagesWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsPagesWithContext), varargs...) +} + +// ListRetirableGrantsRequest mocks base method. +func (m *MockKMSAPI) ListRetirableGrantsRequest(arg0 *kms.ListRetirableGrantsInput) (*request.Request, *kms.ListGrantsResponse) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListRetirableGrantsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ListGrantsResponse) + return ret0, ret1 +} + +// ListRetirableGrantsRequest indicates an expected call of ListRetirableGrantsRequest. +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRetirableGrantsRequest", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsRequest), arg0) +} + +// ListRetirableGrantsWithContext mocks base method. +func (m *MockKMSAPI) ListRetirableGrantsWithContext(arg0 aws.Context, arg1 *kms.ListRetirableGrantsInput, arg2 ...request.Option) (*kms.ListGrantsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListRetirableGrantsWithContext", varargs...) + ret0, _ := ret[0].(*kms.ListGrantsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListRetirableGrantsWithContext indicates an expected call of ListRetirableGrantsWithContext. +func (mr *MockKMSAPIMockRecorder) ListRetirableGrantsWithContext(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, "ListRetirableGrantsWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ListRetirableGrantsWithContext), varargs...) +} + +// PutKeyPolicy mocks base method. +func (m *MockKMSAPI) PutKeyPolicy(arg0 *kms.PutKeyPolicyInput) (*kms.PutKeyPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutKeyPolicy", arg0) + ret0, _ := ret[0].(*kms.PutKeyPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutKeyPolicy indicates an expected call of PutKeyPolicy. +func (mr *MockKMSAPIMockRecorder) PutKeyPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicy", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicy), arg0) +} + +// PutKeyPolicyRequest mocks base method. +func (m *MockKMSAPI) PutKeyPolicyRequest(arg0 *kms.PutKeyPolicyInput) (*request.Request, *kms.PutKeyPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutKeyPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.PutKeyPolicyOutput) + return ret0, ret1 +} + +// PutKeyPolicyRequest indicates an expected call of PutKeyPolicyRequest. +func (mr *MockKMSAPIMockRecorder) PutKeyPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutKeyPolicyRequest", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyRequest), arg0) +} + +// PutKeyPolicyWithContext mocks base method. +func (m *MockKMSAPI) PutKeyPolicyWithContext(arg0 aws.Context, arg1 *kms.PutKeyPolicyInput, arg2 ...request.Option) (*kms.PutKeyPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutKeyPolicyWithContext", varargs...) + ret0, _ := ret[0].(*kms.PutKeyPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutKeyPolicyWithContext indicates an expected call of PutKeyPolicyWithContext. +func (mr *MockKMSAPIMockRecorder) PutKeyPolicyWithContext(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, "PutKeyPolicyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).PutKeyPolicyWithContext), varargs...) +} + +// ReEncrypt mocks base method. +func (m *MockKMSAPI) ReEncrypt(arg0 *kms.ReEncryptInput) (*kms.ReEncryptOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReEncrypt", arg0) + ret0, _ := ret[0].(*kms.ReEncryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReEncrypt indicates an expected call of ReEncrypt. +func (mr *MockKMSAPIMockRecorder) ReEncrypt(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncrypt", reflect.TypeOf((*MockKMSAPI)(nil).ReEncrypt), arg0) +} + +// ReEncryptRequest mocks base method. +func (m *MockKMSAPI) ReEncryptRequest(arg0 *kms.ReEncryptInput) (*request.Request, *kms.ReEncryptOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReEncryptRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ReEncryptOutput) + return ret0, ret1 +} + +// ReEncryptRequest indicates an expected call of ReEncryptRequest. +func (mr *MockKMSAPIMockRecorder) ReEncryptRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReEncryptRequest", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptRequest), arg0) +} + +// ReEncryptWithContext mocks base method. +func (m *MockKMSAPI) ReEncryptWithContext(arg0 aws.Context, arg1 *kms.ReEncryptInput, arg2 ...request.Option) (*kms.ReEncryptOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReEncryptWithContext", varargs...) + ret0, _ := ret[0].(*kms.ReEncryptOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReEncryptWithContext indicates an expected call of ReEncryptWithContext. +func (mr *MockKMSAPIMockRecorder) ReEncryptWithContext(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, "ReEncryptWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ReEncryptWithContext), varargs...) +} + +// ReplicateKey mocks base method. +func (m *MockKMSAPI) ReplicateKey(arg0 *kms.ReplicateKeyInput) (*kms.ReplicateKeyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplicateKey", arg0) + ret0, _ := ret[0].(*kms.ReplicateKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplicateKey indicates an expected call of ReplicateKey. +func (mr *MockKMSAPIMockRecorder) ReplicateKey(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateKey", reflect.TypeOf((*MockKMSAPI)(nil).ReplicateKey), arg0) +} + +// ReplicateKeyRequest mocks base method. +func (m *MockKMSAPI) ReplicateKeyRequest(arg0 *kms.ReplicateKeyInput) (*request.Request, *kms.ReplicateKeyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReplicateKeyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ReplicateKeyOutput) + return ret0, ret1 +} + +// ReplicateKeyRequest indicates an expected call of ReplicateKeyRequest. +func (mr *MockKMSAPIMockRecorder) ReplicateKeyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplicateKeyRequest", reflect.TypeOf((*MockKMSAPI)(nil).ReplicateKeyRequest), arg0) +} + +// ReplicateKeyWithContext mocks base method. +func (m *MockKMSAPI) ReplicateKeyWithContext(arg0 aws.Context, arg1 *kms.ReplicateKeyInput, arg2 ...request.Option) (*kms.ReplicateKeyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReplicateKeyWithContext", varargs...) + ret0, _ := ret[0].(*kms.ReplicateKeyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReplicateKeyWithContext indicates an expected call of ReplicateKeyWithContext. +func (mr *MockKMSAPIMockRecorder) ReplicateKeyWithContext(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, "ReplicateKeyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ReplicateKeyWithContext), varargs...) +} + +// RetireGrant mocks base method. +func (m *MockKMSAPI) RetireGrant(arg0 *kms.RetireGrantInput) (*kms.RetireGrantOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetireGrant", arg0) + ret0, _ := ret[0].(*kms.RetireGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetireGrant indicates an expected call of RetireGrant. +func (mr *MockKMSAPIMockRecorder) RetireGrant(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrant", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrant), arg0) +} + +// RetireGrantRequest mocks base method. +func (m *MockKMSAPI) RetireGrantRequest(arg0 *kms.RetireGrantInput) (*request.Request, *kms.RetireGrantOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RetireGrantRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.RetireGrantOutput) + return ret0, ret1 +} + +// RetireGrantRequest indicates an expected call of RetireGrantRequest. +func (mr *MockKMSAPIMockRecorder) RetireGrantRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetireGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantRequest), arg0) +} + +// RetireGrantWithContext mocks base method. +func (m *MockKMSAPI) RetireGrantWithContext(arg0 aws.Context, arg1 *kms.RetireGrantInput, arg2 ...request.Option) (*kms.RetireGrantOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RetireGrantWithContext", varargs...) + ret0, _ := ret[0].(*kms.RetireGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RetireGrantWithContext indicates an expected call of RetireGrantWithContext. +func (mr *MockKMSAPIMockRecorder) RetireGrantWithContext(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, "RetireGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RetireGrantWithContext), varargs...) +} + +// RevokeGrant mocks base method. +func (m *MockKMSAPI) RevokeGrant(arg0 *kms.RevokeGrantInput) (*kms.RevokeGrantOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeGrant", arg0) + ret0, _ := ret[0].(*kms.RevokeGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeGrant indicates an expected call of RevokeGrant. +func (mr *MockKMSAPIMockRecorder) RevokeGrant(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrant", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrant), arg0) +} + +// RevokeGrantRequest mocks base method. +func (m *MockKMSAPI) RevokeGrantRequest(arg0 *kms.RevokeGrantInput) (*request.Request, *kms.RevokeGrantOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RevokeGrantRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.RevokeGrantOutput) + return ret0, ret1 +} + +// RevokeGrantRequest indicates an expected call of RevokeGrantRequest. +func (mr *MockKMSAPIMockRecorder) RevokeGrantRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrantRequest", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantRequest), arg0) +} + +// RevokeGrantWithContext mocks base method. +func (m *MockKMSAPI) RevokeGrantWithContext(arg0 aws.Context, arg1 *kms.RevokeGrantInput, arg2 ...request.Option) (*kms.RevokeGrantOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RevokeGrantWithContext", varargs...) + ret0, _ := ret[0].(*kms.RevokeGrantOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeGrantWithContext indicates an expected call of RevokeGrantWithContext. +func (mr *MockKMSAPIMockRecorder) RevokeGrantWithContext(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, "RevokeGrantWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RevokeGrantWithContext), varargs...) +} + +// RotateKeyOnDemand mocks base method. +func (m *MockKMSAPI) RotateKeyOnDemand(arg0 *kms.RotateKeyOnDemandInput) (*kms.RotateKeyOnDemandOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RotateKeyOnDemand", arg0) + ret0, _ := ret[0].(*kms.RotateKeyOnDemandOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RotateKeyOnDemand indicates an expected call of RotateKeyOnDemand. +func (mr *MockKMSAPIMockRecorder) RotateKeyOnDemand(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateKeyOnDemand", reflect.TypeOf((*MockKMSAPI)(nil).RotateKeyOnDemand), arg0) +} + +// RotateKeyOnDemandRequest mocks base method. +func (m *MockKMSAPI) RotateKeyOnDemandRequest(arg0 *kms.RotateKeyOnDemandInput) (*request.Request, *kms.RotateKeyOnDemandOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RotateKeyOnDemandRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.RotateKeyOnDemandOutput) + return ret0, ret1 +} + +// RotateKeyOnDemandRequest indicates an expected call of RotateKeyOnDemandRequest. +func (mr *MockKMSAPIMockRecorder) RotateKeyOnDemandRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateKeyOnDemandRequest", reflect.TypeOf((*MockKMSAPI)(nil).RotateKeyOnDemandRequest), arg0) +} + +// RotateKeyOnDemandWithContext mocks base method. +func (m *MockKMSAPI) RotateKeyOnDemandWithContext(arg0 aws.Context, arg1 *kms.RotateKeyOnDemandInput, arg2 ...request.Option) (*kms.RotateKeyOnDemandOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RotateKeyOnDemandWithContext", varargs...) + ret0, _ := ret[0].(*kms.RotateKeyOnDemandOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RotateKeyOnDemandWithContext indicates an expected call of RotateKeyOnDemandWithContext. +func (mr *MockKMSAPIMockRecorder) RotateKeyOnDemandWithContext(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, "RotateKeyOnDemandWithContext", reflect.TypeOf((*MockKMSAPI)(nil).RotateKeyOnDemandWithContext), varargs...) +} + +// ScheduleKeyDeletion mocks base method. +func (m *MockKMSAPI) ScheduleKeyDeletion(arg0 *kms.ScheduleKeyDeletionInput) (*kms.ScheduleKeyDeletionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScheduleKeyDeletion", arg0) + ret0, _ := ret[0].(*kms.ScheduleKeyDeletionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ScheduleKeyDeletion indicates an expected call of ScheduleKeyDeletion. +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletion", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletion), arg0) +} + +// ScheduleKeyDeletionRequest mocks base method. +func (m *MockKMSAPI) ScheduleKeyDeletionRequest(arg0 *kms.ScheduleKeyDeletionInput) (*request.Request, *kms.ScheduleKeyDeletionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScheduleKeyDeletionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.ScheduleKeyDeletionOutput) + return ret0, ret1 +} + +// ScheduleKeyDeletionRequest indicates an expected call of ScheduleKeyDeletionRequest. +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleKeyDeletionRequest", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionRequest), arg0) +} + +// ScheduleKeyDeletionWithContext mocks base method. +func (m *MockKMSAPI) ScheduleKeyDeletionWithContext(arg0 aws.Context, arg1 *kms.ScheduleKeyDeletionInput, arg2 ...request.Option) (*kms.ScheduleKeyDeletionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScheduleKeyDeletionWithContext", varargs...) + ret0, _ := ret[0].(*kms.ScheduleKeyDeletionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ScheduleKeyDeletionWithContext indicates an expected call of ScheduleKeyDeletionWithContext. +func (mr *MockKMSAPIMockRecorder) ScheduleKeyDeletionWithContext(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, "ScheduleKeyDeletionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).ScheduleKeyDeletionWithContext), varargs...) +} + +// Sign mocks base method. +func (m *MockKMSAPI) Sign(arg0 *kms.SignInput) (*kms.SignOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sign", arg0) + ret0, _ := ret[0].(*kms.SignOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Sign indicates an expected call of Sign. +func (mr *MockKMSAPIMockRecorder) Sign(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sign", reflect.TypeOf((*MockKMSAPI)(nil).Sign), arg0) +} + +// SignRequest mocks base method. +func (m *MockKMSAPI) SignRequest(arg0 *kms.SignInput) (*request.Request, *kms.SignOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SignRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.SignOutput) + return ret0, ret1 +} + +// SignRequest indicates an expected call of SignRequest. +func (mr *MockKMSAPIMockRecorder) SignRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignRequest", reflect.TypeOf((*MockKMSAPI)(nil).SignRequest), arg0) +} + +// SignWithContext mocks base method. +func (m *MockKMSAPI) SignWithContext(arg0 aws.Context, arg1 *kms.SignInput, arg2 ...request.Option) (*kms.SignOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SignWithContext", varargs...) + ret0, _ := ret[0].(*kms.SignOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SignWithContext indicates an expected call of SignWithContext. +func (mr *MockKMSAPIMockRecorder) SignWithContext(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, "SignWithContext", reflect.TypeOf((*MockKMSAPI)(nil).SignWithContext), varargs...) +} + +// TagResource mocks base method. +func (m *MockKMSAPI) TagResource(arg0 *kms.TagResourceInput) (*kms.TagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResource", arg0) + ret0, _ := ret[0].(*kms.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResource indicates an expected call of TagResource. +func (mr *MockKMSAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockKMSAPI)(nil).TagResource), arg0) +} + +// TagResourceRequest mocks base method. +func (m *MockKMSAPI) TagResourceRequest(arg0 *kms.TagResourceInput) (*request.Request, *kms.TagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.TagResourceOutput) + return ret0, ret1 +} + +// TagResourceRequest indicates an expected call of TagResourceRequest. +func (mr *MockKMSAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceRequest), arg0) +} + +// TagResourceWithContext mocks base method. +func (m *MockKMSAPI) TagResourceWithContext(arg0 aws.Context, arg1 *kms.TagResourceInput, arg2 ...request.Option) (*kms.TagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) + ret0, _ := ret[0].(*kms.TagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TagResourceWithContext indicates an expected call of TagResourceWithContext. +func (mr *MockKMSAPIMockRecorder) TagResourceWithContext(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, "TagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).TagResourceWithContext), varargs...) +} + +// UntagResource mocks base method. +func (m *MockKMSAPI) UntagResource(arg0 *kms.UntagResourceInput) (*kms.UntagResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResource", arg0) + ret0, _ := ret[0].(*kms.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResource indicates an expected call of UntagResource. +func (mr *MockKMSAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockKMSAPI)(nil).UntagResource), arg0) +} + +// UntagResourceRequest mocks base method. +func (m *MockKMSAPI) UntagResourceRequest(arg0 *kms.UntagResourceInput) (*request.Request, *kms.UntagResourceOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.UntagResourceOutput) + return ret0, ret1 +} + +// UntagResourceRequest indicates an expected call of UntagResourceRequest. +func (mr *MockKMSAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceRequest), arg0) +} + +// UntagResourceWithContext mocks base method. +func (m *MockKMSAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *kms.UntagResourceInput, arg2 ...request.Option) (*kms.UntagResourceOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) + ret0, _ := ret[0].(*kms.UntagResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. +func (mr *MockKMSAPIMockRecorder) UntagResourceWithContext(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, "UntagResourceWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UntagResourceWithContext), varargs...) +} + +// UpdateAlias mocks base method. +func (m *MockKMSAPI) UpdateAlias(arg0 *kms.UpdateAliasInput) (*kms.UpdateAliasOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAlias", arg0) + ret0, _ := ret[0].(*kms.UpdateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAlias indicates an expected call of UpdateAlias. +func (mr *MockKMSAPIMockRecorder) UpdateAlias(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAlias", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAlias), arg0) +} + +// UpdateAliasRequest mocks base method. +func (m *MockKMSAPI) UpdateAliasRequest(arg0 *kms.UpdateAliasInput) (*request.Request, *kms.UpdateAliasOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.UpdateAliasOutput) + return ret0, ret1 +} + +// UpdateAliasRequest indicates an expected call of UpdateAliasRequest. +func (mr *MockKMSAPIMockRecorder) UpdateAliasRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAliasRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasRequest), arg0) +} + +// UpdateAliasWithContext mocks base method. +func (m *MockKMSAPI) UpdateAliasWithContext(arg0 aws.Context, arg1 *kms.UpdateAliasInput, arg2 ...request.Option) (*kms.UpdateAliasOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAliasWithContext", varargs...) + ret0, _ := ret[0].(*kms.UpdateAliasOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAliasWithContext indicates an expected call of UpdateAliasWithContext. +func (mr *MockKMSAPIMockRecorder) UpdateAliasWithContext(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, "UpdateAliasWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateAliasWithContext), varargs...) +} + +// UpdateCustomKeyStore mocks base method. +func (m *MockKMSAPI) UpdateCustomKeyStore(arg0 *kms.UpdateCustomKeyStoreInput) (*kms.UpdateCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCustomKeyStore", arg0) + ret0, _ := ret[0].(*kms.UpdateCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateCustomKeyStore indicates an expected call of UpdateCustomKeyStore. +func (mr *MockKMSAPIMockRecorder) UpdateCustomKeyStore(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomKeyStore", reflect.TypeOf((*MockKMSAPI)(nil).UpdateCustomKeyStore), arg0) +} + +// UpdateCustomKeyStoreRequest mocks base method. +func (m *MockKMSAPI) UpdateCustomKeyStoreRequest(arg0 *kms.UpdateCustomKeyStoreInput) (*request.Request, *kms.UpdateCustomKeyStoreOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateCustomKeyStoreRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.UpdateCustomKeyStoreOutput) + return ret0, ret1 +} + +// UpdateCustomKeyStoreRequest indicates an expected call of UpdateCustomKeyStoreRequest. +func (mr *MockKMSAPIMockRecorder) UpdateCustomKeyStoreRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomKeyStoreRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateCustomKeyStoreRequest), arg0) +} + +// UpdateCustomKeyStoreWithContext mocks base method. +func (m *MockKMSAPI) UpdateCustomKeyStoreWithContext(arg0 aws.Context, arg1 *kms.UpdateCustomKeyStoreInput, arg2 ...request.Option) (*kms.UpdateCustomKeyStoreOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateCustomKeyStoreWithContext", varargs...) + ret0, _ := ret[0].(*kms.UpdateCustomKeyStoreOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateCustomKeyStoreWithContext indicates an expected call of UpdateCustomKeyStoreWithContext. +func (mr *MockKMSAPIMockRecorder) UpdateCustomKeyStoreWithContext(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, "UpdateCustomKeyStoreWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateCustomKeyStoreWithContext), varargs...) +} + +// UpdateKeyDescription mocks base method. +func (m *MockKMSAPI) UpdateKeyDescription(arg0 *kms.UpdateKeyDescriptionInput) (*kms.UpdateKeyDescriptionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateKeyDescription", arg0) + ret0, _ := ret[0].(*kms.UpdateKeyDescriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateKeyDescription indicates an expected call of UpdateKeyDescription. +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescription", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescription), arg0) +} + +// UpdateKeyDescriptionRequest mocks base method. +func (m *MockKMSAPI) UpdateKeyDescriptionRequest(arg0 *kms.UpdateKeyDescriptionInput) (*request.Request, *kms.UpdateKeyDescriptionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateKeyDescriptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.UpdateKeyDescriptionOutput) + return ret0, ret1 +} + +// UpdateKeyDescriptionRequest indicates an expected call of UpdateKeyDescriptionRequest. +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescriptionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKeyDescriptionRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionRequest), arg0) +} + +// UpdateKeyDescriptionWithContext mocks base method. +func (m *MockKMSAPI) UpdateKeyDescriptionWithContext(arg0 aws.Context, arg1 *kms.UpdateKeyDescriptionInput, arg2 ...request.Option) (*kms.UpdateKeyDescriptionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateKeyDescriptionWithContext", varargs...) + ret0, _ := ret[0].(*kms.UpdateKeyDescriptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateKeyDescriptionWithContext indicates an expected call of UpdateKeyDescriptionWithContext. +func (mr *MockKMSAPIMockRecorder) UpdateKeyDescriptionWithContext(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, "UpdateKeyDescriptionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdateKeyDescriptionWithContext), varargs...) +} + +// UpdatePrimaryRegion mocks base method. +func (m *MockKMSAPI) UpdatePrimaryRegion(arg0 *kms.UpdatePrimaryRegionInput) (*kms.UpdatePrimaryRegionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePrimaryRegion", arg0) + ret0, _ := ret[0].(*kms.UpdatePrimaryRegionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePrimaryRegion indicates an expected call of UpdatePrimaryRegion. +func (mr *MockKMSAPIMockRecorder) UpdatePrimaryRegion(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrimaryRegion", reflect.TypeOf((*MockKMSAPI)(nil).UpdatePrimaryRegion), arg0) +} + +// UpdatePrimaryRegionRequest mocks base method. +func (m *MockKMSAPI) UpdatePrimaryRegionRequest(arg0 *kms.UpdatePrimaryRegionInput) (*request.Request, *kms.UpdatePrimaryRegionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePrimaryRegionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.UpdatePrimaryRegionOutput) + return ret0, ret1 +} + +// UpdatePrimaryRegionRequest indicates an expected call of UpdatePrimaryRegionRequest. +func (mr *MockKMSAPIMockRecorder) UpdatePrimaryRegionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrimaryRegionRequest", reflect.TypeOf((*MockKMSAPI)(nil).UpdatePrimaryRegionRequest), arg0) +} + +// UpdatePrimaryRegionWithContext mocks base method. +func (m *MockKMSAPI) UpdatePrimaryRegionWithContext(arg0 aws.Context, arg1 *kms.UpdatePrimaryRegionInput, arg2 ...request.Option) (*kms.UpdatePrimaryRegionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePrimaryRegionWithContext", varargs...) + ret0, _ := ret[0].(*kms.UpdatePrimaryRegionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePrimaryRegionWithContext indicates an expected call of UpdatePrimaryRegionWithContext. +func (mr *MockKMSAPIMockRecorder) UpdatePrimaryRegionWithContext(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, "UpdatePrimaryRegionWithContext", reflect.TypeOf((*MockKMSAPI)(nil).UpdatePrimaryRegionWithContext), varargs...) +} + +// Verify mocks base method. +func (m *MockKMSAPI) Verify(arg0 *kms.VerifyInput) (*kms.VerifyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Verify", arg0) + ret0, _ := ret[0].(*kms.VerifyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Verify indicates an expected call of Verify. +func (mr *MockKMSAPIMockRecorder) Verify(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verify", reflect.TypeOf((*MockKMSAPI)(nil).Verify), arg0) +} + +// VerifyMac mocks base method. +func (m *MockKMSAPI) VerifyMac(arg0 *kms.VerifyMacInput) (*kms.VerifyMacOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyMac", arg0) + ret0, _ := ret[0].(*kms.VerifyMacOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyMac indicates an expected call of VerifyMac. +func (mr *MockKMSAPIMockRecorder) VerifyMac(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMac", reflect.TypeOf((*MockKMSAPI)(nil).VerifyMac), arg0) +} + +// VerifyMacRequest mocks base method. +func (m *MockKMSAPI) VerifyMacRequest(arg0 *kms.VerifyMacInput) (*request.Request, *kms.VerifyMacOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyMacRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.VerifyMacOutput) + return ret0, ret1 +} + +// VerifyMacRequest indicates an expected call of VerifyMacRequest. +func (mr *MockKMSAPIMockRecorder) VerifyMacRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyMacRequest", reflect.TypeOf((*MockKMSAPI)(nil).VerifyMacRequest), arg0) +} + +// VerifyMacWithContext mocks base method. +func (m *MockKMSAPI) VerifyMacWithContext(arg0 aws.Context, arg1 *kms.VerifyMacInput, arg2 ...request.Option) (*kms.VerifyMacOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "VerifyMacWithContext", varargs...) + ret0, _ := ret[0].(*kms.VerifyMacOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyMacWithContext indicates an expected call of VerifyMacWithContext. +func (mr *MockKMSAPIMockRecorder) VerifyMacWithContext(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, "VerifyMacWithContext", reflect.TypeOf((*MockKMSAPI)(nil).VerifyMacWithContext), varargs...) +} + +// VerifyRequest mocks base method. +func (m *MockKMSAPI) VerifyRequest(arg0 *kms.VerifyInput) (*request.Request, *kms.VerifyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*kms.VerifyOutput) + return ret0, ret1 +} + +// VerifyRequest indicates an expected call of VerifyRequest. +func (mr *MockKMSAPIMockRecorder) VerifyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyRequest", reflect.TypeOf((*MockKMSAPI)(nil).VerifyRequest), arg0) +} + +// VerifyWithContext mocks base method. +func (m *MockKMSAPI) VerifyWithContext(arg0 aws.Context, arg1 *kms.VerifyInput, arg2 ...request.Option) (*kms.VerifyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "VerifyWithContext", varargs...) + ret0, _ := ret[0].(*kms.VerifyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyWithContext indicates an expected call of VerifyWithContext. +func (mr *MockKMSAPIMockRecorder) VerifyWithContext(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, "VerifyWithContext", reflect.TypeOf((*MockKMSAPI)(nil).VerifyWithContext), varargs...) +} diff --git a/resources/kms-aliases.go b/resources/kms-alias.go similarity index 61% rename from resources/kms-aliases.go rename to resources/kms-alias.go index c9ee72f0..1a8d2d29 100644 --- a/resources/kms-aliases.go +++ b/resources/kms-alias.go @@ -2,11 +2,11 @@ package resources import ( "context" - "fmt" "strings" "github.com/aws/aws-sdk-go/service/kms" + "github.com/aws/aws-sdk-go/service/kms/kmsiface" "github.com/ekristen/libnuke/pkg/registry" "github.com/ekristen/libnuke/pkg/resource" @@ -25,19 +25,26 @@ func init() { }) } -type KMSAliasLister struct{} +type KMSAliasLister struct { + mockSvc kmsiface.KMSAPI +} func (l *KMSAliasLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { opts := o.(*nuke.ListerOpts) + resources := make([]resource.Resource, 0) - svc := kms.New(opts.Session) + var svc kmsiface.KMSAPI + if l.mockSvc != nil { + svc = l.mockSvc + } else { + svc = kms.New(opts.Session) + } - resources := make([]resource.Resource, 0) err := svc.ListAliasesPages(nil, func(page *kms.ListAliasesOutput, lastPage bool) bool { for _, alias := range page.Aliases { resources = append(resources, &KMSAlias{ svc: svc, - name: alias.AliasName, + Name: alias.AliasName, }) } return true @@ -50,32 +57,28 @@ func (l *KMSAliasLister) List(_ context.Context, o interface{}) ([]resource.Reso } type KMSAlias struct { - svc *kms.KMS - name *string + svc kmsiface.KMSAPI + Name *string } -func (e *KMSAlias) Filter() error { - if strings.HasPrefix(*e.name, "alias/aws/") { +func (r *KMSAlias) Filter() error { + if strings.HasPrefix(*r.Name, "alias/aws/") { return fmt.Errorf("cannot delete AWS alias") } return nil } -func (e *KMSAlias) Remove(_ context.Context) error { - _, err := e.svc.DeleteAlias(&kms.DeleteAliasInput{ - AliasName: e.name, +func (r *KMSAlias) Remove(_ context.Context) error { + _, err := r.svc.DeleteAlias(&kms.DeleteAliasInput{ + AliasName: r.Name, }) return err } -func (e *KMSAlias) String() string { - return *e.name +func (r *KMSAlias) String() string { + return *r.Name } -func (e *KMSAlias) Properties() types.Properties { - properties := types.NewProperties() - properties. - Set("Name", e.name) - - return properties +func (r *KMSAlias) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) } diff --git a/resources/kms-alias_mock_test.go b/resources/kms-alias_mock_test.go new file mode 100644 index 00000000..bcd43675 --- /dev/null +++ b/resources/kms-alias_mock_test.go @@ -0,0 +1,125 @@ +package resources + +import ( + "context" + "testing" + + "github.com/golang/mock/gomock" + "github.com/gotidy/ptr" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/kms" + + "github.com/ekristen/aws-nuke/v3/mocks/mock_kmsiface" + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +func Test_Mock_KMSAlias_List(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + mockKMS.EXPECT().ListAliasesPages(gomock.Any(), gomock.Any()).DoAndReturn( + func(input *kms.ListAliasesInput, fn func(*kms.ListAliasesOutput, bool) bool) error { + fn(&kms.ListAliasesOutput{ + Aliases: []*kms.AliasListEntry{ + {AliasName: aws.String("alias/test-alias-1")}, + {AliasName: aws.String("alias/test-alias-2")}, + }, + }, true) + return nil + }, + ) + + lister := KMSAliasLister{ + mockSvc: mockKMS, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + a.NoError(err) + a.Len(resources, 2) +} + +func Test_Mock_KMSAlias_List_Error(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + mockKMS.EXPECT(). + ListAliasesPages(gomock.Any(), gomock.Any()). + Return(awserr.New("BadRequest", "400 Bad Request", nil)) + + lister := KMSAliasLister{ + mockSvc: mockKMS, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + a.Error(err) + a.Nil(resources) + a.EqualError(err, "BadRequest: 400 Bad Request") +} + +func Test_KMSAlias_Filter(t *testing.T) { + a := assert.New(t) + + alias := &KMSAlias{ + Name: ptr.String("alias/aws/test-alias"), + } + + err := alias.Filter() + a.Error(err) + a.EqualError(err, "cannot delete AWS alias") + + alias.Name = ptr.String("alias/custom/test-alias") + err = alias.Filter() + a.NoError(err) +} + +func Test_KMSAlias_Properties(t *testing.T) { + a := assert.New(t) + + alias := &KMSAlias{ + Name: ptr.String("alias/custom/test-alias"), + } + + a.Equal("alias/custom/test-alias", alias.String()) + a.Equal("alias/custom/test-alias", alias.Properties().Get("Name")) +} + +func Test_Mock_KMSAlias_Remove(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + // Mock the DeleteAlias method + mockKMS.EXPECT().DeleteAlias(&kms.DeleteAliasInput{ + AliasName: ptr.String("alias/test-alias-1"), + }).Return(&kms.DeleteAliasOutput{}, nil) + + alias := &KMSAlias{ + svc: mockKMS, + Name: ptr.String("alias/test-alias-1"), + } + + err := alias.Remove(context.TODO()) + a.NoError(err) +} diff --git a/resources/kms-key.go b/resources/kms-key.go new file mode 100644 index 00000000..adba6096 --- /dev/null +++ b/resources/kms-key.go @@ -0,0 +1,137 @@ +package resources + +import ( + "context" + "errors" + "fmt" + + "github.com/gotidy/ptr" + "github.com/sirupsen/logrus" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/kms" + "github.com/aws/aws-sdk-go/service/kms/kmsiface" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const KMSKeyResource = "KMSKey" + +func init() { + registry.Register(®istry.Registration{ + Name: KMSKeyResource, + Scope: nuke.Account, + Lister: &KMSKeyLister{}, + DependsOn: []string{ + KMSAliasResource, + }, + }) +} + +type KMSKeyLister struct { + mockSvc kmsiface.KMSAPI +} + +func (l *KMSKeyLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + resources := make([]resource.Resource, 0) + + var svc kmsiface.KMSAPI + if l.mockSvc != nil { + svc = l.mockSvc + } else { + svc = kms.New(opts.Session) + } + + inaccessibleKeys := false + + if err := svc.ListKeysPages(nil, func(keysOut *kms.ListKeysOutput, lastPage bool) bool { + for _, key := range keysOut.Keys { + resp, err := svc.DescribeKey(&kms.DescribeKeyInput{ + KeyId: key.KeyId, + }) + if err != nil { + var awsError awserr.Error + if errors.As(err, &awsError) { + if awsError.Code() == "AccessDeniedException" { + inaccessibleKeys = true + logrus.WithError(err).Debug("unable to describe key") + continue + } + } + + logrus.WithError(err).Error("unable to describe key") + continue + } + + kmsKey := &KMSKey{ + svc: svc, + ID: resp.KeyMetadata.KeyId, + State: resp.KeyMetadata.KeyState, + Manager: resp.KeyMetadata.KeyManager, + } + + tags, err := svc.ListResourceTags(&kms.ListResourceTagsInput{ + KeyId: key.KeyId, + }) + if err != nil { + logrus.WithError(err).Error("unable to list tags") + } else { + kmsKey.Tags = tags.Tags + } + + resources = append(resources, kmsKey) + } + + return !lastPage + }); err != nil { + return nil, err + } + + if inaccessibleKeys { + logrus.Warn("one or more KMS keys were inaccessible, debug logging will contain more information") + } + + return resources, nil +} + +type KMSKey struct { + svc kmsiface.KMSAPI + ID *string + State *string + Manager *string + Tags []*kms.Tag +} + +func (r *KMSKey) Filter() error { + if ptr.ToString(r.State) == kms.KeyStatePendingDeletion { + return fmt.Errorf("is already in PendingDeletion state") + } + + if ptr.ToString(r.Manager) == kms.KeyManagerTypeAws { + return fmt.Errorf("cannot delete AWS managed key") + } + + return nil +} + +func (r *KMSKey) Remove(_ context.Context) error { + _, err := r.svc.ScheduleKeyDeletion(&kms.ScheduleKeyDeletionInput{ + KeyId: r.ID, + PendingWindowInDays: aws.Int64(7), + }) + return err +} + +func (r *KMSKey) String() string { + return *r.ID +} + +func (r *KMSKey) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} diff --git a/resources/kms-key_mock_test.go b/resources/kms-key_mock_test.go new file mode 100644 index 00000000..04b11f3e --- /dev/null +++ b/resources/kms-key_mock_test.go @@ -0,0 +1,223 @@ +package resources + +import ( + "context" + "testing" + + "github.com/golang/mock/gomock" + "github.com/gotidy/ptr" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/kms" + + "github.com/ekristen/aws-nuke/v3/mocks/mock_kmsiface" + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +func Test_Mock_KMSKey_List(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + mockKMS.EXPECT().ListKeysPages(gomock.Any(), gomock.Any()).DoAndReturn( + func(input *kms.ListKeysInput, fn func(*kms.ListKeysOutput, bool) bool) error { + fn(&kms.ListKeysOutput{ + Keys: []*kms.KeyListEntry{ + {KeyId: aws.String("test-key-id")}, + }, + }, true) + return nil + }, + ) + + mockKMS.EXPECT().DescribeKey(gomock.Any()).DoAndReturn( + func(input *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { + return &kms.DescribeKeyOutput{ + KeyMetadata: &kms.KeyMetadata{ + KeyId: aws.String("test-key-id"), + Arn: aws.String("arn:aws:kms:us-east-2:123456789012:key/test-key-id"), + KeyManager: aws.String(kms.KeyManagerTypeCustomer), + KeyState: aws.String(kms.KeyStateEnabled), + }, + }, nil + }, + ) + + mockKMS.EXPECT().ListResourceTags(gomock.Any()).DoAndReturn( + func(input *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) { + return &kms.ListResourceTagsOutput{ + Tags: []*kms.Tag{ + {TagKey: aws.String("Environment"), TagValue: aws.String("Test")}, + }, + }, nil + }, + ) + + lister := KMSKeyLister{ + mockSvc: mockKMS, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + a.NoError(err) + a.Len(resources, 1) +} + +func Test_Mock_KMSKey_List_WithAccessDenied(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + // Mock the ListKeysPages method to return two keys + mockKMS.EXPECT().ListKeysPages(gomock.Any(), gomock.Any()).DoAndReturn( + func(input *kms.ListKeysInput, fn func(*kms.ListKeysOutput, bool) bool) error { + fn(&kms.ListKeysOutput{ + Keys: []*kms.KeyListEntry{ + {KeyId: aws.String("test-key-id-1")}, + {KeyId: aws.String("test-key-id-2")}, + }, + }, true) + return nil + }, + ) + + // Mock DescribeKey for the first key to return a valid response + mockKMS.EXPECT().DescribeKey(&kms.DescribeKeyInput{ + KeyId: aws.String("test-key-id-1"), + }).DoAndReturn( + func(input *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { + return &kms.DescribeKeyOutput{ + KeyMetadata: &kms.KeyMetadata{ + KeyId: aws.String("test-key-id-1"), + Arn: aws.String("arn:aws:kms:us-east-2:123456789012:key/test-key-id-1"), + KeyManager: aws.String(kms.KeyManagerTypeCustomer), + KeyState: aws.String(kms.KeyStateEnabled), + }, + }, nil + }, + ) + + // Mock DescribeKey for the second key to return AccessDeniedException + mockKMS.EXPECT().DescribeKey(&kms.DescribeKeyInput{ + KeyId: aws.String("test-key-id-2"), + }).DoAndReturn( + func(input *kms.DescribeKeyInput) (*kms.DescribeKeyOutput, error) { + return nil, awserr.New("AccessDeniedException", "no resource-based policy allows the kms:DescribeKey action", nil) + }, + ) + + // Mock ListResourceTags for the first key + mockKMS.EXPECT().ListResourceTags(&kms.ListResourceTagsInput{ + KeyId: aws.String("test-key-id-1"), + }).DoAndReturn( + func(input *kms.ListResourceTagsInput) (*kms.ListResourceTagsOutput, error) { + return &kms.ListResourceTagsOutput{ + Tags: []*kms.Tag{ + {TagKey: aws.String("Environment"), TagValue: aws.String("Test")}, + }, + }, nil + }, + ) + + lister := KMSKeyLister{ + mockSvc: mockKMS, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + a.NoError(err) + a.Len(resources, 1) +} + +func Test_Mock_KMSKey_Filter(t *testing.T) { + cases := []struct { + name string + state string + manager string + error string + }{ + { + name: "aws-managed-key", + state: kms.KeyStateEnabled, + manager: kms.KeyManagerTypeAws, + error: "cannot delete AWS managed key", + }, + { + name: "pending-deletion-key", + state: kms.KeyStatePendingDeletion, + manager: kms.KeyManagerTypeCustomer, + error: "is already in PendingDeletion state", + }, + { + name: "enabled-key", + state: kms.KeyStateEnabled, + manager: kms.KeyManagerTypeCustomer, + error: "", + }, + } + + for _, tc := range cases { + kmsKey := KMSKey{ + ID: ptr.String("test-key-id"), + State: ptr.String(tc.state), + Manager: ptr.String(tc.manager), + } + + err := kmsKey.Filter() + if tc.error == "" { + assert.NoError(t, err) + } else { + assert.ErrorContains(t, err, tc.error) + } + } +} + +func Test_Mock_KMSKey_Properties(t *testing.T) { + kmsKey := KMSKey{ + ID: ptr.String("test-key-id"), + State: ptr.String(kms.KeyStateEnabled), + Manager: ptr.String(kms.KeyManagerTypeCustomer), + } + + assert.Equal(t, "test-key-id", kmsKey.String()) + assert.Equal(t, kms.KeyStateEnabled, kmsKey.Properties().Get("State")) + assert.Equal(t, kms.KeyManagerTypeCustomer, kmsKey.Properties().Get("Manager")) +} + +func Test_Mock_KMSKey_Remove(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockKMS := mock_kmsiface.NewMockKMSAPI(ctrl) + + mockKMS.EXPECT().ScheduleKeyDeletion(&kms.ScheduleKeyDeletionInput{ + KeyId: aws.String("test-key-id"), + PendingWindowInDays: aws.Int64(7), + }).Return(&kms.ScheduleKeyDeletionOutput{}, nil) + + kmsKey := KMSKey{ + svc: mockKMS, + ID: ptr.String("test-key-id"), + State: ptr.String(kms.KeyStateEnabled), + Manager: ptr.String(kms.KeyManagerTypeCustomer), + } + + err := kmsKey.Remove(context.TODO()) + a.NoError(err) +} diff --git a/resources/kms-keys_test.go b/resources/kms-key_test.go similarity index 95% rename from resources/kms-keys_test.go rename to resources/kms-key_test.go index b26f83c0..7522d521 100644 --- a/resources/kms-keys_test.go +++ b/resources/kms-key_test.go @@ -51,14 +51,14 @@ func Test_KMSKey_Remove(t *testing.T) { kmsKey := KMSKey{ svc: svc, - id: *out.KeyMetadata.KeyId, + ID: out.KeyMetadata.KeyId, } removeError := kmsKey.Remove(context.TODO()) assert.NoError(t, removeError) _, err = svc.DescribeKey(&kms.DescribeKeyInput{ - KeyId: aws.String(kmsKey.id), + KeyId: kmsKey.ID, }) var awsError awserr.Error if errors.As(err, &awsError) { diff --git a/resources/kms-keys.go b/resources/kms-keys.go deleted file mode 100644 index b77e6bce..00000000 --- a/resources/kms-keys.go +++ /dev/null @@ -1,131 +0,0 @@ -package resources - -import ( - "context" - - "fmt" - - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/kms" - - "github.com/ekristen/libnuke/pkg/registry" - "github.com/ekristen/libnuke/pkg/resource" - "github.com/ekristen/libnuke/pkg/types" - - "github.com/ekristen/aws-nuke/v3/pkg/nuke" -) - -const KMSKeyResource = "KMSKey" - -func init() { - registry.Register(®istry.Registration{ - Name: KMSKeyResource, - Scope: nuke.Account, - Lister: &KMSKeyLister{}, - DependsOn: []string{ - KMSAliasResource, - }, - }) -} - -type KMSKeyLister struct{} - -func (l *KMSKeyLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { - opts := o.(*nuke.ListerOpts) - - svc := kms.New(opts.Session) - resources := make([]resource.Resource, 0) - - var innerErr error - if err := svc.ListKeysPages(nil, func(resp *kms.ListKeysOutput, lastPage bool) bool { - for _, key := range resp.Keys { - resp, err := svc.DescribeKey(&kms.DescribeKeyInput{ - KeyId: key.KeyId, - }) - if err != nil { - innerErr = err - return false - } - - if *resp.KeyMetadata.KeyManager == kms.KeyManagerTypeAws { - continue - } - - if *resp.KeyMetadata.KeyState == kms.KeyStatePendingDeletion { - continue - } - - kmsKey := &KMSKey{ - svc: svc, - id: *resp.KeyMetadata.KeyId, - state: *resp.KeyMetadata.KeyState, - manager: resp.KeyMetadata.KeyManager, - } - - tags, err := svc.ListResourceTags(&kms.ListResourceTagsInput{ - KeyId: key.KeyId, - }) - if err != nil { - innerErr = err - return false - } - - kmsKey.tags = tags.Tags - resources = append(resources, kmsKey) - } - - return !lastPage - }); err != nil { - return nil, err - } - - if innerErr != nil { - return nil, innerErr - } - - return resources, nil -} - -type KMSKey struct { - svc *kms.KMS - id string - state string - manager *string - tags []*kms.Tag -} - -func (e *KMSKey) Filter() error { - if e.state == "PendingDeletion" { - return fmt.Errorf("is already in PendingDeletion state") - } - - if e.manager != nil && *e.manager == kms.KeyManagerTypeAws { - return fmt.Errorf("cannot delete AWS managed key") - } - - return nil -} - -func (e *KMSKey) Remove(_ context.Context) error { - _, err := e.svc.ScheduleKeyDeletion(&kms.ScheduleKeyDeletionInput{ - KeyId: &e.id, - PendingWindowInDays: aws.Int64(7), - }) - return err -} - -func (e *KMSKey) String() string { - return e.id -} - -func (e *KMSKey) Properties() types.Properties { - properties := types.NewProperties() - properties. - Set("ID", e.id) - - for _, tag := range e.tags { - properties.SetTag(tag.TagKey, tag.TagValue) - } - - return properties -} diff --git a/resources/kms_mock_test.go b/resources/kms_mock_test.go new file mode 100644 index 00000000..a5216b1a --- /dev/null +++ b/resources/kms_mock_test.go @@ -0,0 +1,4 @@ +//go:generate ../mocks/generate_mocks.sh kms kmsiface +package resources + +// Note: empty on purpose, this file exist purely to generate mocks for the KMS service