diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientOption.go new file mode 100644 index 00000000..fc7778d9 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_billing_account_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go new file mode 100644 index 00000000..b85247bf --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service/mock_ClientService.go @@ -0,0 +1,662 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_billing_account_service + +import ( + billing_account_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/billing_account_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// BillingAccountServiceCreate provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceCreate(params *billing_account_service.BillingAccountServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceCreate") + } + + var r0 *billing_account_service.BillingAccountServiceCreateOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceCreateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceCreateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceCreateOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceCreateOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceCreateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceCreate' +type MockClientService_BillingAccountServiceCreate_Call struct { + *mock.Call +} + +// BillingAccountServiceCreate is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceCreateParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceCreate(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceCreate_Call { + return &MockClientService_BillingAccountServiceCreate_Call{Call: _e.mock.On("BillingAccountServiceCreate", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceCreate_Call) Run(run func(params *billing_account_service.BillingAccountServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceCreateParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceCreate_Call) Return(_a0 *billing_account_service.BillingAccountServiceCreateOK, _a1 error) *MockClientService_BillingAccountServiceCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceCreate_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceCreateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateOK, error)) *MockClientService_BillingAccountServiceCreate_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceCreateSetupIntent provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceCreateSetupIntent(params *billing_account_service.BillingAccountServiceCreateSetupIntentParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateSetupIntentOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceCreateSetupIntent") + } + + var r0 *billing_account_service.BillingAccountServiceCreateSetupIntentOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceCreateSetupIntentParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateSetupIntentOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceCreateSetupIntentParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceCreateSetupIntentOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceCreateSetupIntentOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceCreateSetupIntentParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceCreateSetupIntent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceCreateSetupIntent' +type MockClientService_BillingAccountServiceCreateSetupIntent_Call struct { + *mock.Call +} + +// BillingAccountServiceCreateSetupIntent is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceCreateSetupIntentParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceCreateSetupIntent(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceCreateSetupIntent_Call { + return &MockClientService_BillingAccountServiceCreateSetupIntent_Call{Call: _e.mock.On("BillingAccountServiceCreateSetupIntent", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceCreateSetupIntent_Call) Run(run func(params *billing_account_service.BillingAccountServiceCreateSetupIntentParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceCreateSetupIntent_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceCreateSetupIntentParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceCreateSetupIntent_Call) Return(_a0 *billing_account_service.BillingAccountServiceCreateSetupIntentOK, _a1 error) *MockClientService_BillingAccountServiceCreateSetupIntent_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceCreateSetupIntent_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceCreateSetupIntentParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceCreateSetupIntentOK, error)) *MockClientService_BillingAccountServiceCreateSetupIntent_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceDeleteBillingAccount provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceDeleteBillingAccount(params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceDeleteBillingAccount") + } + + var r0 *billing_account_service.BillingAccountServiceDeleteBillingAccountOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceDeleteBillingAccountOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceDeleteBillingAccountOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceDeleteBillingAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceDeleteBillingAccount' +type MockClientService_BillingAccountServiceDeleteBillingAccount_Call struct { + *mock.Call +} + +// BillingAccountServiceDeleteBillingAccount is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceDeleteBillingAccount(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { + return &MockClientService_BillingAccountServiceDeleteBillingAccount_Call{Call: _e.mock.On("BillingAccountServiceDeleteBillingAccount", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) Run(run func(params *billing_account_service.BillingAccountServiceDeleteBillingAccountParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) Return(_a0 *billing_account_service.BillingAccountServiceDeleteBillingAccountOK, _a1 error) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceDeleteBillingAccount_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceDeleteBillingAccountParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceDeleteBillingAccountOK, error)) *MockClientService_BillingAccountServiceDeleteBillingAccount_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceGet provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceGet(params *billing_account_service.BillingAccountServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceGet") + } + + var r0 *billing_account_service.BillingAccountServiceGetOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceGetOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceGetOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceGetParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceGet' +type MockClientService_BillingAccountServiceGet_Call struct { + *mock.Call +} + +// BillingAccountServiceGet is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceGetParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceGet(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceGet_Call { + return &MockClientService_BillingAccountServiceGet_Call{Call: _e.mock.On("BillingAccountServiceGet", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceGet_Call) Run(run func(params *billing_account_service.BillingAccountServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceGetParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceGet_Call) Return(_a0 *billing_account_service.BillingAccountServiceGetOK, _a1 error) *MockClientService_BillingAccountServiceGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceGet_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceGetParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetOK, error)) *MockClientService_BillingAccountServiceGet_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceGetByProject provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceGetByProject(params *billing_account_service.BillingAccountServiceGetByProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetByProjectOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceGetByProject") + } + + var r0 *billing_account_service.BillingAccountServiceGetByProjectOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetByProjectParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetByProjectOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceGetByProjectParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceGetByProjectOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceGetByProjectOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceGetByProjectParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceGetByProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceGetByProject' +type MockClientService_BillingAccountServiceGetByProject_Call struct { + *mock.Call +} + +// BillingAccountServiceGetByProject is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceGetByProjectParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceGetByProject(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceGetByProject_Call { + return &MockClientService_BillingAccountServiceGetByProject_Call{Call: _e.mock.On("BillingAccountServiceGetByProject", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceGetByProject_Call) Run(run func(params *billing_account_service.BillingAccountServiceGetByProjectParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceGetByProject_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceGetByProjectParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceGetByProject_Call) Return(_a0 *billing_account_service.BillingAccountServiceGetByProjectOK, _a1 error) *MockClientService_BillingAccountServiceGetByProject_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceGetByProject_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceGetByProjectParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceGetByProjectOK, error)) *MockClientService_BillingAccountServiceGetByProject_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceList provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceList(params *billing_account_service.BillingAccountServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceList") + } + + var r0 *billing_account_service.BillingAccountServiceListOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceListOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceListOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceList' +type MockClientService_BillingAccountServiceList_Call struct { + *mock.Call +} + +// BillingAccountServiceList is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceListParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceList(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceList_Call { + return &MockClientService_BillingAccountServiceList_Call{Call: _e.mock.On("BillingAccountServiceList", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceList_Call) Run(run func(params *billing_account_service.BillingAccountServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceListParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceList_Call) Return(_a0 *billing_account_service.BillingAccountServiceListOK, _a1 error) *MockClientService_BillingAccountServiceList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceList_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceListParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceListOK, error)) *MockClientService_BillingAccountServiceList_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceRemoveOnDemandPaymentMethod provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceRemoveOnDemandPaymentMethod(params *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceRemoveOnDemandPaymentMethod") + } + + var r0 *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceRemoveOnDemandPaymentMethod' +type MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call struct { + *mock.Call +} + +// BillingAccountServiceRemoveOnDemandPaymentMethod is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceRemoveOnDemandPaymentMethod(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call { + return &MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call{Call: _e.mock.On("BillingAccountServiceRemoveOnDemandPaymentMethod", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call) Run(run func(params *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call) Return(_a0 *billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK, _a1 error) *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceRemoveOnDemandPaymentMethodOK, error)) *MockClientService_BillingAccountServiceRemoveOnDemandPaymentMethod_Call { + _c.Call.Return(run) + return _c +} + +// BillingAccountServiceUpdate provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) BillingAccountServiceUpdate(params *billing_account_service.BillingAccountServiceUpdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceUpdateOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for BillingAccountServiceUpdate") + } + + var r0 *billing_account_service.BillingAccountServiceUpdateOK + var r1 error + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceUpdateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceUpdateOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*billing_account_service.BillingAccountServiceUpdateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) *billing_account_service.BillingAccountServiceUpdateOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*billing_account_service.BillingAccountServiceUpdateOK) + } + } + + if rf, ok := ret.Get(1).(func(*billing_account_service.BillingAccountServiceUpdateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_BillingAccountServiceUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BillingAccountServiceUpdate' +type MockClientService_BillingAccountServiceUpdate_Call struct { + *mock.Call +} + +// BillingAccountServiceUpdate is a helper method to define mock.On call +// - params *billing_account_service.BillingAccountServiceUpdateParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...billing_account_service.ClientOption +func (_e *MockClientService_Expecter) BillingAccountServiceUpdate(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_BillingAccountServiceUpdate_Call { + return &MockClientService_BillingAccountServiceUpdate_Call{Call: _e.mock.On("BillingAccountServiceUpdate", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_BillingAccountServiceUpdate_Call) Run(run func(params *billing_account_service.BillingAccountServiceUpdateParams, authInfo runtime.ClientAuthInfoWriter, opts ...billing_account_service.ClientOption)) *MockClientService_BillingAccountServiceUpdate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]billing_account_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(billing_account_service.ClientOption) + } + } + run(args[0].(*billing_account_service.BillingAccountServiceUpdateParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_BillingAccountServiceUpdate_Call) Return(_a0 *billing_account_service.BillingAccountServiceUpdateOK, _a1 error) *MockClientService_BillingAccountServiceUpdate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_BillingAccountServiceUpdate_Call) RunAndReturn(run func(*billing_account_service.BillingAccountServiceUpdateParams, runtime.ClientAuthInfoWriter, ...billing_account_service.ClientOption) (*billing_account_service.BillingAccountServiceUpdateOK, error)) *MockClientService_BillingAccountServiceUpdate_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientOption.go new file mode 100644 index 00000000..894840ed --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_f_c_p_management_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientService.go new file mode 100644 index 00000000..20f16547 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service/mock_ClientService.go @@ -0,0 +1,218 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_f_c_p_management_service + +import ( + f_c_p_management_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/f_c_p_management_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// FCPManagementServiceGetConsumptionPool provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) FCPManagementServiceGetConsumptionPool(params *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FCPManagementServiceGetConsumptionPool") + } + + var r0 *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK + var r1 error + if rf, ok := ret.Get(0).(func(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK) + } + } + + if rf, ok := ret.Get(1).(func(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_FCPManagementServiceGetConsumptionPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FCPManagementServiceGetConsumptionPool' +type MockClientService_FCPManagementServiceGetConsumptionPool_Call struct { + *mock.Call +} + +// FCPManagementServiceGetConsumptionPool is a helper method to define mock.On call +// - params *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...f_c_p_management_service.ClientOption +func (_e *MockClientService_Expecter) FCPManagementServiceGetConsumptionPool(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_FCPManagementServiceGetConsumptionPool_Call { + return &MockClientService_FCPManagementServiceGetConsumptionPool_Call{Call: _e.mock.On("FCPManagementServiceGetConsumptionPool", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_FCPManagementServiceGetConsumptionPool_Call) Run(run func(params *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, authInfo runtime.ClientAuthInfoWriter, opts ...f_c_p_management_service.ClientOption)) *MockClientService_FCPManagementServiceGetConsumptionPool_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]f_c_p_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(f_c_p_management_service.ClientOption) + } + } + run(args[0].(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_FCPManagementServiceGetConsumptionPool_Call) Return(_a0 *f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK, _a1 error) *MockClientService_FCPManagementServiceGetConsumptionPool_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_FCPManagementServiceGetConsumptionPool_Call) RunAndReturn(run func(*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceGetConsumptionPoolOK, error)) *MockClientService_FCPManagementServiceGetConsumptionPool_Call { + _c.Call.Return(run) + return _c +} + +// FCPManagementServiceListConsumptionPools provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) FCPManagementServiceListConsumptionPools(params *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, authInfo runtime.ClientAuthInfoWriter, opts ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for FCPManagementServiceListConsumptionPools") + } + + var r0 *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK + var r1 error + if rf, ok := ret.Get(0).(func(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK) + } + } + + if rf, ok := ret.Get(1).(func(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_FCPManagementServiceListConsumptionPools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FCPManagementServiceListConsumptionPools' +type MockClientService_FCPManagementServiceListConsumptionPools_Call struct { + *mock.Call +} + +// FCPManagementServiceListConsumptionPools is a helper method to define mock.On call +// - params *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...f_c_p_management_service.ClientOption +func (_e *MockClientService_Expecter) FCPManagementServiceListConsumptionPools(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_FCPManagementServiceListConsumptionPools_Call { + return &MockClientService_FCPManagementServiceListConsumptionPools_Call{Call: _e.mock.On("FCPManagementServiceListConsumptionPools", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_FCPManagementServiceListConsumptionPools_Call) Run(run func(params *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, authInfo runtime.ClientAuthInfoWriter, opts ...f_c_p_management_service.ClientOption)) *MockClientService_FCPManagementServiceListConsumptionPools_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]f_c_p_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(f_c_p_management_service.ClientOption) + } + } + run(args[0].(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_FCPManagementServiceListConsumptionPools_Call) Return(_a0 *f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK, _a1 error) *MockClientService_FCPManagementServiceListConsumptionPools_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_FCPManagementServiceListConsumptionPools_Call) RunAndReturn(run func(*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsParams, runtime.ClientAuthInfoWriter, ...f_c_p_management_service.ClientOption) (*f_c_p_management_service.FCPManagementServiceListConsumptionPoolsOK, error)) *MockClientService_FCPManagementServiceListConsumptionPools_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientOption.go new file mode 100644 index 00000000..fbed6c31 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_invoice_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientService.go new file mode 100644 index 00000000..ccab83a6 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service/mock_ClientService.go @@ -0,0 +1,144 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_invoice_service + +import ( + invoice_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/invoice_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// InvoiceServiceGetUsage provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvoiceServiceGetUsage(params *invoice_service.InvoiceServiceGetUsageParams, authInfo runtime.ClientAuthInfoWriter, opts ...invoice_service.ClientOption) (*invoice_service.InvoiceServiceGetUsageOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvoiceServiceGetUsage") + } + + var r0 *invoice_service.InvoiceServiceGetUsageOK + var r1 error + if rf, ok := ret.Get(0).(func(*invoice_service.InvoiceServiceGetUsageParams, runtime.ClientAuthInfoWriter, ...invoice_service.ClientOption) (*invoice_service.InvoiceServiceGetUsageOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invoice_service.InvoiceServiceGetUsageParams, runtime.ClientAuthInfoWriter, ...invoice_service.ClientOption) *invoice_service.InvoiceServiceGetUsageOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invoice_service.InvoiceServiceGetUsageOK) + } + } + + if rf, ok := ret.Get(1).(func(*invoice_service.InvoiceServiceGetUsageParams, runtime.ClientAuthInfoWriter, ...invoice_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvoiceServiceGetUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvoiceServiceGetUsage' +type MockClientService_InvoiceServiceGetUsage_Call struct { + *mock.Call +} + +// InvoiceServiceGetUsage is a helper method to define mock.On call +// - params *invoice_service.InvoiceServiceGetUsageParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invoice_service.ClientOption +func (_e *MockClientService_Expecter) InvoiceServiceGetUsage(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvoiceServiceGetUsage_Call { + return &MockClientService_InvoiceServiceGetUsage_Call{Call: _e.mock.On("InvoiceServiceGetUsage", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvoiceServiceGetUsage_Call) Run(run func(params *invoice_service.InvoiceServiceGetUsageParams, authInfo runtime.ClientAuthInfoWriter, opts ...invoice_service.ClientOption)) *MockClientService_InvoiceServiceGetUsage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invoice_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invoice_service.ClientOption) + } + } + run(args[0].(*invoice_service.InvoiceServiceGetUsageParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvoiceServiceGetUsage_Call) Return(_a0 *invoice_service.InvoiceServiceGetUsageOK, _a1 error) *MockClientService_InvoiceServiceGetUsage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvoiceServiceGetUsage_Call) RunAndReturn(run func(*invoice_service.InvoiceServiceGetUsageParams, runtime.ClientAuthInfoWriter, ...invoice_service.ClientOption) (*invoice_service.InvoiceServiceGetUsageOK, error)) *MockClientService_InvoiceServiceGetUsage_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientOption.go new file mode 100644 index 00000000..409cd7e0 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientOption.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_product_service + +import ( + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientService.go new file mode 100644 index 00000000..d27226c5 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service/mock_ClientService.go @@ -0,0 +1,217 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_product_service + +import ( + runtime "github.com/go-openapi/runtime" + product_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/product_service" + mock "github.com/stretchr/testify/mock" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// ProductServiceEstimateCost provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProductServiceEstimateCost(params *product_service.ProductServiceEstimateCostParams, authInfo runtime.ClientAuthInfoWriter, opts ...product_service.ClientOption) (*product_service.ProductServiceEstimateCostOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProductServiceEstimateCost") + } + + var r0 *product_service.ProductServiceEstimateCostOK + var r1 error + if rf, ok := ret.Get(0).(func(*product_service.ProductServiceEstimateCostParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) (*product_service.ProductServiceEstimateCostOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*product_service.ProductServiceEstimateCostParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) *product_service.ProductServiceEstimateCostOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*product_service.ProductServiceEstimateCostOK) + } + } + + if rf, ok := ret.Get(1).(func(*product_service.ProductServiceEstimateCostParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProductServiceEstimateCost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProductServiceEstimateCost' +type MockClientService_ProductServiceEstimateCost_Call struct { + *mock.Call +} + +// ProductServiceEstimateCost is a helper method to define mock.On call +// - params *product_service.ProductServiceEstimateCostParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...product_service.ClientOption +func (_e *MockClientService_Expecter) ProductServiceEstimateCost(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProductServiceEstimateCost_Call { + return &MockClientService_ProductServiceEstimateCost_Call{Call: _e.mock.On("ProductServiceEstimateCost", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProductServiceEstimateCost_Call) Run(run func(params *product_service.ProductServiceEstimateCostParams, authInfo runtime.ClientAuthInfoWriter, opts ...product_service.ClientOption)) *MockClientService_ProductServiceEstimateCost_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]product_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(product_service.ClientOption) + } + } + run(args[0].(*product_service.ProductServiceEstimateCostParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProductServiceEstimateCost_Call) Return(_a0 *product_service.ProductServiceEstimateCostOK, _a1 error) *MockClientService_ProductServiceEstimateCost_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProductServiceEstimateCost_Call) RunAndReturn(run func(*product_service.ProductServiceEstimateCostParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) (*product_service.ProductServiceEstimateCostOK, error)) *MockClientService_ProductServiceEstimateCost_Call { + _c.Call.Return(run) + return _c +} + +// ProductServiceListAvailablePackages provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProductServiceListAvailablePackages(params *product_service.ProductServiceListAvailablePackagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...product_service.ClientOption) (*product_service.ProductServiceListAvailablePackagesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProductServiceListAvailablePackages") + } + + var r0 *product_service.ProductServiceListAvailablePackagesOK + var r1 error + if rf, ok := ret.Get(0).(func(*product_service.ProductServiceListAvailablePackagesParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) (*product_service.ProductServiceListAvailablePackagesOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*product_service.ProductServiceListAvailablePackagesParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) *product_service.ProductServiceListAvailablePackagesOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*product_service.ProductServiceListAvailablePackagesOK) + } + } + + if rf, ok := ret.Get(1).(func(*product_service.ProductServiceListAvailablePackagesParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProductServiceListAvailablePackages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProductServiceListAvailablePackages' +type MockClientService_ProductServiceListAvailablePackages_Call struct { + *mock.Call +} + +// ProductServiceListAvailablePackages is a helper method to define mock.On call +// - params *product_service.ProductServiceListAvailablePackagesParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...product_service.ClientOption +func (_e *MockClientService_Expecter) ProductServiceListAvailablePackages(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProductServiceListAvailablePackages_Call { + return &MockClientService_ProductServiceListAvailablePackages_Call{Call: _e.mock.On("ProductServiceListAvailablePackages", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProductServiceListAvailablePackages_Call) Run(run func(params *product_service.ProductServiceListAvailablePackagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...product_service.ClientOption)) *MockClientService_ProductServiceListAvailablePackages_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]product_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(product_service.ClientOption) + } + } + run(args[0].(*product_service.ProductServiceListAvailablePackagesParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProductServiceListAvailablePackages_Call) Return(_a0 *product_service.ProductServiceListAvailablePackagesOK, _a1 error) *MockClientService_ProductServiceListAvailablePackages_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProductServiceListAvailablePackages_Call) RunAndReturn(run func(*product_service.ProductServiceListAvailablePackagesParams, runtime.ClientAuthInfoWriter, ...product_service.ClientOption) (*product_service.ProductServiceListAvailablePackagesOK, error)) *MockClientService_ProductServiceListAvailablePackages_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientOption.go new file mode 100644 index 00000000..1ff24179 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_statement_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go new file mode 100644 index 00000000..a63fa049 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service/mock_ClientService.go @@ -0,0 +1,292 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_statement_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" + + statement_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-billing/preview/2020-11-05/client/statement_service" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// StatementServiceGetRunningStatement provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) StatementServiceGetRunningStatement(params *statement_service.StatementServiceGetRunningStatementParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption) (*statement_service.StatementServiceGetRunningStatementOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for StatementServiceGetRunningStatement") + } + + var r0 *statement_service.StatementServiceGetRunningStatementOK + var r1 error + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetRunningStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetRunningStatementOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetRunningStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) *statement_service.StatementServiceGetRunningStatementOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*statement_service.StatementServiceGetRunningStatementOK) + } + } + + if rf, ok := ret.Get(1).(func(*statement_service.StatementServiceGetRunningStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_StatementServiceGetRunningStatement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatementServiceGetRunningStatement' +type MockClientService_StatementServiceGetRunningStatement_Call struct { + *mock.Call +} + +// StatementServiceGetRunningStatement is a helper method to define mock.On call +// - params *statement_service.StatementServiceGetRunningStatementParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...statement_service.ClientOption +func (_e *MockClientService_Expecter) StatementServiceGetRunningStatement(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_StatementServiceGetRunningStatement_Call { + return &MockClientService_StatementServiceGetRunningStatement_Call{Call: _e.mock.On("StatementServiceGetRunningStatement", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_StatementServiceGetRunningStatement_Call) Run(run func(params *statement_service.StatementServiceGetRunningStatementParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption)) *MockClientService_StatementServiceGetRunningStatement_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]statement_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(statement_service.ClientOption) + } + } + run(args[0].(*statement_service.StatementServiceGetRunningStatementParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_StatementServiceGetRunningStatement_Call) Return(_a0 *statement_service.StatementServiceGetRunningStatementOK, _a1 error) *MockClientService_StatementServiceGetRunningStatement_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_StatementServiceGetRunningStatement_Call) RunAndReturn(run func(*statement_service.StatementServiceGetRunningStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetRunningStatementOK, error)) *MockClientService_StatementServiceGetRunningStatement_Call { + _c.Call.Return(run) + return _c +} + +// StatementServiceGetStatement provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) StatementServiceGetStatement(params *statement_service.StatementServiceGetStatementParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for StatementServiceGetStatement") + } + + var r0 *statement_service.StatementServiceGetStatementOK + var r1 error + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceGetStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) *statement_service.StatementServiceGetStatementOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*statement_service.StatementServiceGetStatementOK) + } + } + + if rf, ok := ret.Get(1).(func(*statement_service.StatementServiceGetStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_StatementServiceGetStatement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatementServiceGetStatement' +type MockClientService_StatementServiceGetStatement_Call struct { + *mock.Call +} + +// StatementServiceGetStatement is a helper method to define mock.On call +// - params *statement_service.StatementServiceGetStatementParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...statement_service.ClientOption +func (_e *MockClientService_Expecter) StatementServiceGetStatement(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_StatementServiceGetStatement_Call { + return &MockClientService_StatementServiceGetStatement_Call{Call: _e.mock.On("StatementServiceGetStatement", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_StatementServiceGetStatement_Call) Run(run func(params *statement_service.StatementServiceGetStatementParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption)) *MockClientService_StatementServiceGetStatement_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]statement_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(statement_service.ClientOption) + } + } + run(args[0].(*statement_service.StatementServiceGetStatementParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_StatementServiceGetStatement_Call) Return(_a0 *statement_service.StatementServiceGetStatementOK, _a1 error) *MockClientService_StatementServiceGetStatement_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_StatementServiceGetStatement_Call) RunAndReturn(run func(*statement_service.StatementServiceGetStatementParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceGetStatementOK, error)) *MockClientService_StatementServiceGetStatement_Call { + _c.Call.Return(run) + return _c +} + +// StatementServiceListStatements provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) StatementServiceListStatements(params *statement_service.StatementServiceListStatementsParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption) (*statement_service.StatementServiceListStatementsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for StatementServiceListStatements") + } + + var r0 *statement_service.StatementServiceListStatementsOK + var r1 error + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceListStatementsParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceListStatementsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*statement_service.StatementServiceListStatementsParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) *statement_service.StatementServiceListStatementsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*statement_service.StatementServiceListStatementsOK) + } + } + + if rf, ok := ret.Get(1).(func(*statement_service.StatementServiceListStatementsParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_StatementServiceListStatements_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatementServiceListStatements' +type MockClientService_StatementServiceListStatements_Call struct { + *mock.Call +} + +// StatementServiceListStatements is a helper method to define mock.On call +// - params *statement_service.StatementServiceListStatementsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...statement_service.ClientOption +func (_e *MockClientService_Expecter) StatementServiceListStatements(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_StatementServiceListStatements_Call { + return &MockClientService_StatementServiceListStatements_Call{Call: _e.mock.On("StatementServiceListStatements", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_StatementServiceListStatements_Call) Run(run func(params *statement_service.StatementServiceListStatementsParams, authInfo runtime.ClientAuthInfoWriter, opts ...statement_service.ClientOption)) *MockClientService_StatementServiceListStatements_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]statement_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(statement_service.ClientOption) + } + } + run(args[0].(*statement_service.StatementServiceListStatementsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_StatementServiceListStatements_Call) Return(_a0 *statement_service.StatementServiceListStatementsOK, _a1 error) *MockClientService_StatementServiceListStatements_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_StatementServiceListStatements_Call) RunAndReturn(run func(*statement_service.StatementServiceListStatementsParams, runtime.ClientAuthInfoWriter, ...statement_service.ClientOption) (*statement_service.StatementServiceListStatementsOK, error)) *MockClientService_StatementServiceListStatements_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientOption.go new file mode 100644 index 00000000..25caf105 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_auth_config_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientService.go new file mode 100644 index 00000000..a5cae96d --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service/mock_ClientService.go @@ -0,0 +1,366 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_auth_config_service + +import ( + auth_config_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/auth_config_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// AuthConfigServiceCreateAuthConnection provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) AuthConfigServiceCreateAuthConnection(params *auth_config_service.AuthConfigServiceCreateAuthConnectionParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceCreateAuthConnectionOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AuthConfigServiceCreateAuthConnection") + } + + var r0 *auth_config_service.AuthConfigServiceCreateAuthConnectionOK + var r1 error + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceCreateAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceCreateAuthConnectionOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceCreateAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) *auth_config_service.AuthConfigServiceCreateAuthConnectionOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*auth_config_service.AuthConfigServiceCreateAuthConnectionOK) + } + } + + if rf, ok := ret.Get(1).(func(*auth_config_service.AuthConfigServiceCreateAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_AuthConfigServiceCreateAuthConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthConfigServiceCreateAuthConnection' +type MockClientService_AuthConfigServiceCreateAuthConnection_Call struct { + *mock.Call +} + +// AuthConfigServiceCreateAuthConnection is a helper method to define mock.On call +// - params *auth_config_service.AuthConfigServiceCreateAuthConnectionParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...auth_config_service.ClientOption +func (_e *MockClientService_Expecter) AuthConfigServiceCreateAuthConnection(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_AuthConfigServiceCreateAuthConnection_Call { + return &MockClientService_AuthConfigServiceCreateAuthConnection_Call{Call: _e.mock.On("AuthConfigServiceCreateAuthConnection", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_AuthConfigServiceCreateAuthConnection_Call) Run(run func(params *auth_config_service.AuthConfigServiceCreateAuthConnectionParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption)) *MockClientService_AuthConfigServiceCreateAuthConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]auth_config_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(auth_config_service.ClientOption) + } + } + run(args[0].(*auth_config_service.AuthConfigServiceCreateAuthConnectionParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_AuthConfigServiceCreateAuthConnection_Call) Return(_a0 *auth_config_service.AuthConfigServiceCreateAuthConnectionOK, _a1 error) *MockClientService_AuthConfigServiceCreateAuthConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_AuthConfigServiceCreateAuthConnection_Call) RunAndReturn(run func(*auth_config_service.AuthConfigServiceCreateAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceCreateAuthConnectionOK, error)) *MockClientService_AuthConfigServiceCreateAuthConnection_Call { + _c.Call.Return(run) + return _c +} + +// AuthConfigServiceDeleteAuthConnectionFromOrganization provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) AuthConfigServiceDeleteAuthConnectionFromOrganization(params *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AuthConfigServiceDeleteAuthConnectionFromOrganization") + } + + var r0 *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthConfigServiceDeleteAuthConnectionFromOrganization' +type MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call struct { + *mock.Call +} + +// AuthConfigServiceDeleteAuthConnectionFromOrganization is a helper method to define mock.On call +// - params *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...auth_config_service.ClientOption +func (_e *MockClientService_Expecter) AuthConfigServiceDeleteAuthConnectionFromOrganization(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call { + return &MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call{Call: _e.mock.On("AuthConfigServiceDeleteAuthConnectionFromOrganization", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call) Run(run func(params *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption)) *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]auth_config_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(auth_config_service.ClientOption) + } + } + run(args[0].(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call) Return(_a0 *auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK, _a1 error) *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call) RunAndReturn(run func(*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceDeleteAuthConnectionFromOrganizationOK, error)) *MockClientService_AuthConfigServiceDeleteAuthConnectionFromOrganization_Call { + _c.Call.Return(run) + return _c +} + +// AuthConfigServiceEditAuthConnection provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) AuthConfigServiceEditAuthConnection(params *auth_config_service.AuthConfigServiceEditAuthConnectionParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceEditAuthConnectionOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AuthConfigServiceEditAuthConnection") + } + + var r0 *auth_config_service.AuthConfigServiceEditAuthConnectionOK + var r1 error + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceEditAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceEditAuthConnectionOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceEditAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) *auth_config_service.AuthConfigServiceEditAuthConnectionOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*auth_config_service.AuthConfigServiceEditAuthConnectionOK) + } + } + + if rf, ok := ret.Get(1).(func(*auth_config_service.AuthConfigServiceEditAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_AuthConfigServiceEditAuthConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthConfigServiceEditAuthConnection' +type MockClientService_AuthConfigServiceEditAuthConnection_Call struct { + *mock.Call +} + +// AuthConfigServiceEditAuthConnection is a helper method to define mock.On call +// - params *auth_config_service.AuthConfigServiceEditAuthConnectionParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...auth_config_service.ClientOption +func (_e *MockClientService_Expecter) AuthConfigServiceEditAuthConnection(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_AuthConfigServiceEditAuthConnection_Call { + return &MockClientService_AuthConfigServiceEditAuthConnection_Call{Call: _e.mock.On("AuthConfigServiceEditAuthConnection", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_AuthConfigServiceEditAuthConnection_Call) Run(run func(params *auth_config_service.AuthConfigServiceEditAuthConnectionParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption)) *MockClientService_AuthConfigServiceEditAuthConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]auth_config_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(auth_config_service.ClientOption) + } + } + run(args[0].(*auth_config_service.AuthConfigServiceEditAuthConnectionParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_AuthConfigServiceEditAuthConnection_Call) Return(_a0 *auth_config_service.AuthConfigServiceEditAuthConnectionOK, _a1 error) *MockClientService_AuthConfigServiceEditAuthConnection_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_AuthConfigServiceEditAuthConnection_Call) RunAndReturn(run func(*auth_config_service.AuthConfigServiceEditAuthConnectionParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceEditAuthConnectionOK, error)) *MockClientService_AuthConfigServiceEditAuthConnection_Call { + _c.Call.Return(run) + return _c +} + +// AuthConfigServiceGetAuthConnections provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) AuthConfigServiceGetAuthConnections(params *auth_config_service.AuthConfigServiceGetAuthConnectionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceGetAuthConnectionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AuthConfigServiceGetAuthConnections") + } + + var r0 *auth_config_service.AuthConfigServiceGetAuthConnectionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceGetAuthConnectionsParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceGetAuthConnectionsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*auth_config_service.AuthConfigServiceGetAuthConnectionsParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) *auth_config_service.AuthConfigServiceGetAuthConnectionsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*auth_config_service.AuthConfigServiceGetAuthConnectionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*auth_config_service.AuthConfigServiceGetAuthConnectionsParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_AuthConfigServiceGetAuthConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthConfigServiceGetAuthConnections' +type MockClientService_AuthConfigServiceGetAuthConnections_Call struct { + *mock.Call +} + +// AuthConfigServiceGetAuthConnections is a helper method to define mock.On call +// - params *auth_config_service.AuthConfigServiceGetAuthConnectionsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...auth_config_service.ClientOption +func (_e *MockClientService_Expecter) AuthConfigServiceGetAuthConnections(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_AuthConfigServiceGetAuthConnections_Call { + return &MockClientService_AuthConfigServiceGetAuthConnections_Call{Call: _e.mock.On("AuthConfigServiceGetAuthConnections", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_AuthConfigServiceGetAuthConnections_Call) Run(run func(params *auth_config_service.AuthConfigServiceGetAuthConnectionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...auth_config_service.ClientOption)) *MockClientService_AuthConfigServiceGetAuthConnections_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]auth_config_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(auth_config_service.ClientOption) + } + } + run(args[0].(*auth_config_service.AuthConfigServiceGetAuthConnectionsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_AuthConfigServiceGetAuthConnections_Call) Return(_a0 *auth_config_service.AuthConfigServiceGetAuthConnectionsOK, _a1 error) *MockClientService_AuthConfigServiceGetAuthConnections_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_AuthConfigServiceGetAuthConnections_Call) RunAndReturn(run func(*auth_config_service.AuthConfigServiceGetAuthConnectionsParams, runtime.ClientAuthInfoWriter, ...auth_config_service.ClientOption) (*auth_config_service.AuthConfigServiceGetAuthConnectionsOK, error)) *MockClientService_AuthConfigServiceGetAuthConnections_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientOption.go new file mode 100644 index 00000000..c4fbb44d --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_groups_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientService.go new file mode 100644 index 00000000..f6d9ef82 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service/mock_ClientService.go @@ -0,0 +1,810 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_groups_service + +import ( + groups_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/groups_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// GroupsServiceCountGroupsForPrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceCountGroupsForPrincipals(params *groups_service.GroupsServiceCountGroupsForPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceCountGroupsForPrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceCountGroupsForPrincipals") + } + + var r0 *groups_service.GroupsServiceCountGroupsForPrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountGroupsForPrincipalsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountGroupsForPrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountGroupsForPrincipalsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceCountGroupsForPrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceCountGroupsForPrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceCountGroupsForPrincipalsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceCountGroupsForPrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceCountGroupsForPrincipals' +type MockClientService_GroupsServiceCountGroupsForPrincipals_Call struct { + *mock.Call +} + +// GroupsServiceCountGroupsForPrincipals is a helper method to define mock.On call +// - params *groups_service.GroupsServiceCountGroupsForPrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceCountGroupsForPrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceCountGroupsForPrincipals_Call { + return &MockClientService_GroupsServiceCountGroupsForPrincipals_Call{Call: _e.mock.On("GroupsServiceCountGroupsForPrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceCountGroupsForPrincipals_Call) Run(run func(params *groups_service.GroupsServiceCountGroupsForPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceCountGroupsForPrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceCountGroupsForPrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceCountGroupsForPrincipals_Call) Return(_a0 *groups_service.GroupsServiceCountGroupsForPrincipalsOK, _a1 error) *MockClientService_GroupsServiceCountGroupsForPrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceCountGroupsForPrincipals_Call) RunAndReturn(run func(*groups_service.GroupsServiceCountGroupsForPrincipalsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountGroupsForPrincipalsOK, error)) *MockClientService_GroupsServiceCountGroupsForPrincipals_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceCountMembersForGroups provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceCountMembersForGroups(params *groups_service.GroupsServiceCountMembersForGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceCountMembersForGroupsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceCountMembersForGroups") + } + + var r0 *groups_service.GroupsServiceCountMembersForGroupsOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountMembersForGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountMembersForGroupsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountMembersForGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceCountMembersForGroupsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceCountMembersForGroupsOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceCountMembersForGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceCountMembersForGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceCountMembersForGroups' +type MockClientService_GroupsServiceCountMembersForGroups_Call struct { + *mock.Call +} + +// GroupsServiceCountMembersForGroups is a helper method to define mock.On call +// - params *groups_service.GroupsServiceCountMembersForGroupsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceCountMembersForGroups(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceCountMembersForGroups_Call { + return &MockClientService_GroupsServiceCountMembersForGroups_Call{Call: _e.mock.On("GroupsServiceCountMembersForGroups", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceCountMembersForGroups_Call) Run(run func(params *groups_service.GroupsServiceCountMembersForGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceCountMembersForGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceCountMembersForGroupsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceCountMembersForGroups_Call) Return(_a0 *groups_service.GroupsServiceCountMembersForGroupsOK, _a1 error) *MockClientService_GroupsServiceCountMembersForGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceCountMembersForGroups_Call) RunAndReturn(run func(*groups_service.GroupsServiceCountMembersForGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountMembersForGroupsOK, error)) *MockClientService_GroupsServiceCountMembersForGroups_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceCountOrganizationGroups provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceCountOrganizationGroups(params *groups_service.GroupsServiceCountOrganizationGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceCountOrganizationGroupsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceCountOrganizationGroups") + } + + var r0 *groups_service.GroupsServiceCountOrganizationGroupsOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountOrganizationGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountOrganizationGroupsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCountOrganizationGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceCountOrganizationGroupsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceCountOrganizationGroupsOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceCountOrganizationGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceCountOrganizationGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceCountOrganizationGroups' +type MockClientService_GroupsServiceCountOrganizationGroups_Call struct { + *mock.Call +} + +// GroupsServiceCountOrganizationGroups is a helper method to define mock.On call +// - params *groups_service.GroupsServiceCountOrganizationGroupsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceCountOrganizationGroups(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceCountOrganizationGroups_Call { + return &MockClientService_GroupsServiceCountOrganizationGroups_Call{Call: _e.mock.On("GroupsServiceCountOrganizationGroups", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceCountOrganizationGroups_Call) Run(run func(params *groups_service.GroupsServiceCountOrganizationGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceCountOrganizationGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceCountOrganizationGroupsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceCountOrganizationGroups_Call) Return(_a0 *groups_service.GroupsServiceCountOrganizationGroupsOK, _a1 error) *MockClientService_GroupsServiceCountOrganizationGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceCountOrganizationGroups_Call) RunAndReturn(run func(*groups_service.GroupsServiceCountOrganizationGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCountOrganizationGroupsOK, error)) *MockClientService_GroupsServiceCountOrganizationGroups_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceCreateGroup provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceCreateGroup(params *groups_service.GroupsServiceCreateGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceCreateGroupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceCreateGroup") + } + + var r0 *groups_service.GroupsServiceCreateGroupOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCreateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCreateGroupOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceCreateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceCreateGroupOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceCreateGroupOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceCreateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceCreateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceCreateGroup' +type MockClientService_GroupsServiceCreateGroup_Call struct { + *mock.Call +} + +// GroupsServiceCreateGroup is a helper method to define mock.On call +// - params *groups_service.GroupsServiceCreateGroupParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceCreateGroup(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceCreateGroup_Call { + return &MockClientService_GroupsServiceCreateGroup_Call{Call: _e.mock.On("GroupsServiceCreateGroup", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceCreateGroup_Call) Run(run func(params *groups_service.GroupsServiceCreateGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceCreateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceCreateGroupParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceCreateGroup_Call) Return(_a0 *groups_service.GroupsServiceCreateGroupOK, _a1 error) *MockClientService_GroupsServiceCreateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceCreateGroup_Call) RunAndReturn(run func(*groups_service.GroupsServiceCreateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceCreateGroupOK, error)) *MockClientService_GroupsServiceCreateGroup_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceDeleteGroup provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceDeleteGroup(params *groups_service.GroupsServiceDeleteGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceDeleteGroupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceDeleteGroup") + } + + var r0 *groups_service.GroupsServiceDeleteGroupOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceDeleteGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceDeleteGroupOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceDeleteGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceDeleteGroupOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceDeleteGroupOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceDeleteGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceDeleteGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceDeleteGroup' +type MockClientService_GroupsServiceDeleteGroup_Call struct { + *mock.Call +} + +// GroupsServiceDeleteGroup is a helper method to define mock.On call +// - params *groups_service.GroupsServiceDeleteGroupParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceDeleteGroup(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceDeleteGroup_Call { + return &MockClientService_GroupsServiceDeleteGroup_Call{Call: _e.mock.On("GroupsServiceDeleteGroup", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceDeleteGroup_Call) Run(run func(params *groups_service.GroupsServiceDeleteGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceDeleteGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceDeleteGroupParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceDeleteGroup_Call) Return(_a0 *groups_service.GroupsServiceDeleteGroupOK, _a1 error) *MockClientService_GroupsServiceDeleteGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceDeleteGroup_Call) RunAndReturn(run func(*groups_service.GroupsServiceDeleteGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceDeleteGroupOK, error)) *MockClientService_GroupsServiceDeleteGroup_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceGetGroup provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceGetGroup(params *groups_service.GroupsServiceGetGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceGetGroupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceGetGroup") + } + + var r0 *groups_service.GroupsServiceGetGroupOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceGetGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceGetGroupOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceGetGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceGetGroupOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceGetGroupOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceGetGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceGetGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceGetGroup' +type MockClientService_GroupsServiceGetGroup_Call struct { + *mock.Call +} + +// GroupsServiceGetGroup is a helper method to define mock.On call +// - params *groups_service.GroupsServiceGetGroupParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceGetGroup(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceGetGroup_Call { + return &MockClientService_GroupsServiceGetGroup_Call{Call: _e.mock.On("GroupsServiceGetGroup", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceGetGroup_Call) Run(run func(params *groups_service.GroupsServiceGetGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceGetGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceGetGroupParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceGetGroup_Call) Return(_a0 *groups_service.GroupsServiceGetGroupOK, _a1 error) *MockClientService_GroupsServiceGetGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceGetGroup_Call) RunAndReturn(run func(*groups_service.GroupsServiceGetGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceGetGroupOK, error)) *MockClientService_GroupsServiceGetGroup_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceListGroupMembers provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceListGroupMembers(params *groups_service.GroupsServiceListGroupMembersParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupMembersOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceListGroupMembers") + } + + var r0 *groups_service.GroupsServiceListGroupMembersOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceListGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupMembersOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceListGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceListGroupMembersOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceListGroupMembersOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceListGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceListGroupMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceListGroupMembers' +type MockClientService_GroupsServiceListGroupMembers_Call struct { + *mock.Call +} + +// GroupsServiceListGroupMembers is a helper method to define mock.On call +// - params *groups_service.GroupsServiceListGroupMembersParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceListGroupMembers(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceListGroupMembers_Call { + return &MockClientService_GroupsServiceListGroupMembers_Call{Call: _e.mock.On("GroupsServiceListGroupMembers", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceListGroupMembers_Call) Run(run func(params *groups_service.GroupsServiceListGroupMembersParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceListGroupMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceListGroupMembersParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceListGroupMembers_Call) Return(_a0 *groups_service.GroupsServiceListGroupMembersOK, _a1 error) *MockClientService_GroupsServiceListGroupMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceListGroupMembers_Call) RunAndReturn(run func(*groups_service.GroupsServiceListGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupMembersOK, error)) *MockClientService_GroupsServiceListGroupMembers_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceListGroups provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceListGroups(params *groups_service.GroupsServiceListGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceListGroups") + } + + var r0 *groups_service.GroupsServiceListGroupsOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceListGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceListGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceListGroupsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceListGroupsOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceListGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceListGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceListGroups' +type MockClientService_GroupsServiceListGroups_Call struct { + *mock.Call +} + +// GroupsServiceListGroups is a helper method to define mock.On call +// - params *groups_service.GroupsServiceListGroupsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceListGroups(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceListGroups_Call { + return &MockClientService_GroupsServiceListGroups_Call{Call: _e.mock.On("GroupsServiceListGroups", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceListGroups_Call) Run(run func(params *groups_service.GroupsServiceListGroupsParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceListGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceListGroupsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceListGroups_Call) Return(_a0 *groups_service.GroupsServiceListGroupsOK, _a1 error) *MockClientService_GroupsServiceListGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceListGroups_Call) RunAndReturn(run func(*groups_service.GroupsServiceListGroupsParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceListGroupsOK, error)) *MockClientService_GroupsServiceListGroups_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceUpdateGroup provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceUpdateGroup(params *groups_service.GroupsServiceUpdateGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceUpdateGroup") + } + + var r0 *groups_service.GroupsServiceUpdateGroupOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceUpdateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceUpdateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceUpdateGroupOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceUpdateGroupOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceUpdateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceUpdateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceUpdateGroup' +type MockClientService_GroupsServiceUpdateGroup_Call struct { + *mock.Call +} + +// GroupsServiceUpdateGroup is a helper method to define mock.On call +// - params *groups_service.GroupsServiceUpdateGroupParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceUpdateGroup(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceUpdateGroup_Call { + return &MockClientService_GroupsServiceUpdateGroup_Call{Call: _e.mock.On("GroupsServiceUpdateGroup", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceUpdateGroup_Call) Run(run func(params *groups_service.GroupsServiceUpdateGroupParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceUpdateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceUpdateGroupParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceUpdateGroup_Call) Return(_a0 *groups_service.GroupsServiceUpdateGroupOK, _a1 error) *MockClientService_GroupsServiceUpdateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceUpdateGroup_Call) RunAndReturn(run func(*groups_service.GroupsServiceUpdateGroupParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupOK, error)) *MockClientService_GroupsServiceUpdateGroup_Call { + _c.Call.Return(run) + return _c +} + +// GroupsServiceUpdateGroupMembers provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) GroupsServiceUpdateGroupMembers(params *groups_service.GroupsServiceUpdateGroupMembersParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupMembersOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GroupsServiceUpdateGroupMembers") + } + + var r0 *groups_service.GroupsServiceUpdateGroupMembersOK + var r1 error + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceUpdateGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupMembersOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*groups_service.GroupsServiceUpdateGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) *groups_service.GroupsServiceUpdateGroupMembersOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*groups_service.GroupsServiceUpdateGroupMembersOK) + } + } + + if rf, ok := ret.Get(1).(func(*groups_service.GroupsServiceUpdateGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_GroupsServiceUpdateGroupMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupsServiceUpdateGroupMembers' +type MockClientService_GroupsServiceUpdateGroupMembers_Call struct { + *mock.Call +} + +// GroupsServiceUpdateGroupMembers is a helper method to define mock.On call +// - params *groups_service.GroupsServiceUpdateGroupMembersParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...groups_service.ClientOption +func (_e *MockClientService_Expecter) GroupsServiceUpdateGroupMembers(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_GroupsServiceUpdateGroupMembers_Call { + return &MockClientService_GroupsServiceUpdateGroupMembers_Call{Call: _e.mock.On("GroupsServiceUpdateGroupMembers", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_GroupsServiceUpdateGroupMembers_Call) Run(run func(params *groups_service.GroupsServiceUpdateGroupMembersParams, authInfo runtime.ClientAuthInfoWriter, opts ...groups_service.ClientOption)) *MockClientService_GroupsServiceUpdateGroupMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]groups_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(groups_service.ClientOption) + } + } + run(args[0].(*groups_service.GroupsServiceUpdateGroupMembersParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_GroupsServiceUpdateGroupMembers_Call) Return(_a0 *groups_service.GroupsServiceUpdateGroupMembersOK, _a1 error) *MockClientService_GroupsServiceUpdateGroupMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_GroupsServiceUpdateGroupMembers_Call) RunAndReturn(run func(*groups_service.GroupsServiceUpdateGroupMembersParams, runtime.ClientAuthInfoWriter, ...groups_service.ClientOption) (*groups_service.GroupsServiceUpdateGroupMembersOK, error)) *MockClientService_GroupsServiceUpdateGroupMembers_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientOption.go new file mode 100644 index 00000000..b067639e --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_iam_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientService.go new file mode 100644 index 00000000..22f42595 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service/mock_ClientService.go @@ -0,0 +1,957 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_iam_service + +import ( + iam_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/iam_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// IamServiceBatchGetPrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceBatchGetPrincipals(params *iam_service.IamServiceBatchGetPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceBatchGetPrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceBatchGetPrincipals") + } + + var r0 *iam_service.IamServiceBatchGetPrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceBatchGetPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceBatchGetPrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceBatchGetPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceBatchGetPrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceBatchGetPrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceBatchGetPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceBatchGetPrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceBatchGetPrincipals' +type MockClientService_IamServiceBatchGetPrincipals_Call struct { + *mock.Call +} + +// IamServiceBatchGetPrincipals is a helper method to define mock.On call +// - params *iam_service.IamServiceBatchGetPrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceBatchGetPrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceBatchGetPrincipals_Call { + return &MockClientService_IamServiceBatchGetPrincipals_Call{Call: _e.mock.On("IamServiceBatchGetPrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceBatchGetPrincipals_Call) Run(run func(params *iam_service.IamServiceBatchGetPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceBatchGetPrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceBatchGetPrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceBatchGetPrincipals_Call) Return(_a0 *iam_service.IamServiceBatchGetPrincipalsOK, _a1 error) *MockClientService_IamServiceBatchGetPrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceBatchGetPrincipals_Call) RunAndReturn(run func(*iam_service.IamServiceBatchGetPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceBatchGetPrincipalsOK, error)) *MockClientService_IamServiceBatchGetPrincipals_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceCreateUserPrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceCreateUserPrincipal(params *iam_service.IamServiceCreateUserPrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceCreateUserPrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceCreateUserPrincipal") + } + + var r0 *iam_service.IamServiceCreateUserPrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceCreateUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceCreateUserPrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceCreateUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceCreateUserPrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceCreateUserPrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceCreateUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceCreateUserPrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceCreateUserPrincipal' +type MockClientService_IamServiceCreateUserPrincipal_Call struct { + *mock.Call +} + +// IamServiceCreateUserPrincipal is a helper method to define mock.On call +// - params *iam_service.IamServiceCreateUserPrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceCreateUserPrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceCreateUserPrincipal_Call { + return &MockClientService_IamServiceCreateUserPrincipal_Call{Call: _e.mock.On("IamServiceCreateUserPrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceCreateUserPrincipal_Call) Run(run func(params *iam_service.IamServiceCreateUserPrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceCreateUserPrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceCreateUserPrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceCreateUserPrincipal_Call) Return(_a0 *iam_service.IamServiceCreateUserPrincipalOK, _a1 error) *MockClientService_IamServiceCreateUserPrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceCreateUserPrincipal_Call) RunAndReturn(run func(*iam_service.IamServiceCreateUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceCreateUserPrincipalOK, error)) *MockClientService_IamServiceCreateUserPrincipal_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceDeleteOrganizationMembership provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceDeleteOrganizationMembership(params *iam_service.IamServiceDeleteOrganizationMembershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceDeleteOrganizationMembershipOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceDeleteOrganizationMembership") + } + + var r0 *iam_service.IamServiceDeleteOrganizationMembershipOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceDeleteOrganizationMembershipParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceDeleteOrganizationMembershipOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceDeleteOrganizationMembershipParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceDeleteOrganizationMembershipOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceDeleteOrganizationMembershipOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceDeleteOrganizationMembershipParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceDeleteOrganizationMembership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceDeleteOrganizationMembership' +type MockClientService_IamServiceDeleteOrganizationMembership_Call struct { + *mock.Call +} + +// IamServiceDeleteOrganizationMembership is a helper method to define mock.On call +// - params *iam_service.IamServiceDeleteOrganizationMembershipParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceDeleteOrganizationMembership(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceDeleteOrganizationMembership_Call { + return &MockClientService_IamServiceDeleteOrganizationMembership_Call{Call: _e.mock.On("IamServiceDeleteOrganizationMembership", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceDeleteOrganizationMembership_Call) Run(run func(params *iam_service.IamServiceDeleteOrganizationMembershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceDeleteOrganizationMembership_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceDeleteOrganizationMembershipParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceDeleteOrganizationMembership_Call) Return(_a0 *iam_service.IamServiceDeleteOrganizationMembershipOK, _a1 error) *MockClientService_IamServiceDeleteOrganizationMembership_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceDeleteOrganizationMembership_Call) RunAndReturn(run func(*iam_service.IamServiceDeleteOrganizationMembershipParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceDeleteOrganizationMembershipOK, error)) *MockClientService_IamServiceDeleteOrganizationMembership_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceGetCallerIdentity provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceGetCallerIdentity(params *iam_service.IamServiceGetCallerIdentityParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceGetCallerIdentityOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceGetCallerIdentity") + } + + var r0 *iam_service.IamServiceGetCallerIdentityOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetCallerIdentityParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetCallerIdentityOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetCallerIdentityParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceGetCallerIdentityOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceGetCallerIdentityOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceGetCallerIdentityParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceGetCallerIdentity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceGetCallerIdentity' +type MockClientService_IamServiceGetCallerIdentity_Call struct { + *mock.Call +} + +// IamServiceGetCallerIdentity is a helper method to define mock.On call +// - params *iam_service.IamServiceGetCallerIdentityParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceGetCallerIdentity(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceGetCallerIdentity_Call { + return &MockClientService_IamServiceGetCallerIdentity_Call{Call: _e.mock.On("IamServiceGetCallerIdentity", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceGetCallerIdentity_Call) Run(run func(params *iam_service.IamServiceGetCallerIdentityParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceGetCallerIdentity_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceGetCallerIdentityParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceGetCallerIdentity_Call) Return(_a0 *iam_service.IamServiceGetCallerIdentityOK, _a1 error) *MockClientService_IamServiceGetCallerIdentity_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceGetCallerIdentity_Call) RunAndReturn(run func(*iam_service.IamServiceGetCallerIdentityParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetCallerIdentityOK, error)) *MockClientService_IamServiceGetCallerIdentity_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceGetCurrentUserPrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceGetCurrentUserPrincipal(params *iam_service.IamServiceGetCurrentUserPrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceGetCurrentUserPrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceGetCurrentUserPrincipal") + } + + var r0 *iam_service.IamServiceGetCurrentUserPrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetCurrentUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetCurrentUserPrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetCurrentUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceGetCurrentUserPrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceGetCurrentUserPrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceGetCurrentUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceGetCurrentUserPrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceGetCurrentUserPrincipal' +type MockClientService_IamServiceGetCurrentUserPrincipal_Call struct { + *mock.Call +} + +// IamServiceGetCurrentUserPrincipal is a helper method to define mock.On call +// - params *iam_service.IamServiceGetCurrentUserPrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceGetCurrentUserPrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceGetCurrentUserPrincipal_Call { + return &MockClientService_IamServiceGetCurrentUserPrincipal_Call{Call: _e.mock.On("IamServiceGetCurrentUserPrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceGetCurrentUserPrincipal_Call) Run(run func(params *iam_service.IamServiceGetCurrentUserPrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceGetCurrentUserPrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceGetCurrentUserPrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceGetCurrentUserPrincipal_Call) Return(_a0 *iam_service.IamServiceGetCurrentUserPrincipalOK, _a1 error) *MockClientService_IamServiceGetCurrentUserPrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceGetCurrentUserPrincipal_Call) RunAndReturn(run func(*iam_service.IamServiceGetCurrentUserPrincipalParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetCurrentUserPrincipalOK, error)) *MockClientService_IamServiceGetCurrentUserPrincipal_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceGetOrganizationAuthMetadata provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceGetOrganizationAuthMetadata(params *iam_service.IamServiceGetOrganizationAuthMetadataParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceGetOrganizationAuthMetadataOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceGetOrganizationAuthMetadata") + } + + var r0 *iam_service.IamServiceGetOrganizationAuthMetadataOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetOrganizationAuthMetadataParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetOrganizationAuthMetadataOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetOrganizationAuthMetadataParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceGetOrganizationAuthMetadataOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceGetOrganizationAuthMetadataOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceGetOrganizationAuthMetadataParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceGetOrganizationAuthMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceGetOrganizationAuthMetadata' +type MockClientService_IamServiceGetOrganizationAuthMetadata_Call struct { + *mock.Call +} + +// IamServiceGetOrganizationAuthMetadata is a helper method to define mock.On call +// - params *iam_service.IamServiceGetOrganizationAuthMetadataParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceGetOrganizationAuthMetadata(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceGetOrganizationAuthMetadata_Call { + return &MockClientService_IamServiceGetOrganizationAuthMetadata_Call{Call: _e.mock.On("IamServiceGetOrganizationAuthMetadata", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceGetOrganizationAuthMetadata_Call) Run(run func(params *iam_service.IamServiceGetOrganizationAuthMetadataParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceGetOrganizationAuthMetadata_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceGetOrganizationAuthMetadataParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceGetOrganizationAuthMetadata_Call) Return(_a0 *iam_service.IamServiceGetOrganizationAuthMetadataOK, _a1 error) *MockClientService_IamServiceGetOrganizationAuthMetadata_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceGetOrganizationAuthMetadata_Call) RunAndReturn(run func(*iam_service.IamServiceGetOrganizationAuthMetadataParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetOrganizationAuthMetadataOK, error)) *MockClientService_IamServiceGetOrganizationAuthMetadata_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceGetUserPrincipalByIDInOrganization provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceGetUserPrincipalByIDInOrganization(params *iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceGetUserPrincipalByIDInOrganization") + } + + var r0 *iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceGetUserPrincipalByIDInOrganization' +type MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call struct { + *mock.Call +} + +// IamServiceGetUserPrincipalByIDInOrganization is a helper method to define mock.On call +// - params *iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceGetUserPrincipalByIDInOrganization(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call { + return &MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call{Call: _e.mock.On("IamServiceGetUserPrincipalByIDInOrganization", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call) Run(run func(params *iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call) Return(_a0 *iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK, _a1 error) *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call) RunAndReturn(run func(*iam_service.IamServiceGetUserPrincipalByIDInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalByIDInOrganizationOK, error)) *MockClientService_IamServiceGetUserPrincipalByIDInOrganization_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceGetUserPrincipalsByIDsInOrganization provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceGetUserPrincipalsByIDsInOrganization(params *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceGetUserPrincipalsByIDsInOrganization") + } + + var r0 *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceGetUserPrincipalsByIDsInOrganization' +type MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call struct { + *mock.Call +} + +// IamServiceGetUserPrincipalsByIDsInOrganization is a helper method to define mock.On call +// - params *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceGetUserPrincipalsByIDsInOrganization(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call { + return &MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call{Call: _e.mock.On("IamServiceGetUserPrincipalsByIDsInOrganization", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call) Run(run func(params *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call) Return(_a0 *iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK, _a1 error) *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call) RunAndReturn(run func(*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceGetUserPrincipalsByIDsInOrganizationOK, error)) *MockClientService_IamServiceGetUserPrincipalsByIDsInOrganization_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceListUserPrincipalsByOrganization provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceListUserPrincipalsByOrganization(params *iam_service.IamServiceListUserPrincipalsByOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceListUserPrincipalsByOrganizationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceListUserPrincipalsByOrganization") + } + + var r0 *iam_service.IamServiceListUserPrincipalsByOrganizationOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceListUserPrincipalsByOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceListUserPrincipalsByOrganizationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceListUserPrincipalsByOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceListUserPrincipalsByOrganizationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceListUserPrincipalsByOrganizationOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceListUserPrincipalsByOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceListUserPrincipalsByOrganization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceListUserPrincipalsByOrganization' +type MockClientService_IamServiceListUserPrincipalsByOrganization_Call struct { + *mock.Call +} + +// IamServiceListUserPrincipalsByOrganization is a helper method to define mock.On call +// - params *iam_service.IamServiceListUserPrincipalsByOrganizationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceListUserPrincipalsByOrganization(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceListUserPrincipalsByOrganization_Call { + return &MockClientService_IamServiceListUserPrincipalsByOrganization_Call{Call: _e.mock.On("IamServiceListUserPrincipalsByOrganization", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceListUserPrincipalsByOrganization_Call) Run(run func(params *iam_service.IamServiceListUserPrincipalsByOrganizationParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceListUserPrincipalsByOrganization_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceListUserPrincipalsByOrganizationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceListUserPrincipalsByOrganization_Call) Return(_a0 *iam_service.IamServiceListUserPrincipalsByOrganizationOK, _a1 error) *MockClientService_IamServiceListUserPrincipalsByOrganization_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceListUserPrincipalsByOrganization_Call) RunAndReturn(run func(*iam_service.IamServiceListUserPrincipalsByOrganizationParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceListUserPrincipalsByOrganizationOK, error)) *MockClientService_IamServiceListUserPrincipalsByOrganization_Call { + _c.Call.Return(run) + return _c +} + +// IamServicePing provides a mock function with given fields: params, opts +func (_m *MockClientService) IamServicePing(params *iam_service.IamServicePingParams, opts ...iam_service.ClientOption) (*iam_service.IamServicePingOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServicePing") + } + + var r0 *iam_service.IamServicePingOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServicePingParams, ...iam_service.ClientOption) (*iam_service.IamServicePingOK, error)); ok { + return rf(params, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServicePingParams, ...iam_service.ClientOption) *iam_service.IamServicePingOK); ok { + r0 = rf(params, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServicePingOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServicePingParams, ...iam_service.ClientOption) error); ok { + r1 = rf(params, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServicePing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServicePing' +type MockClientService_IamServicePing_Call struct { + *mock.Call +} + +// IamServicePing is a helper method to define mock.On call +// - params *iam_service.IamServicePingParams +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServicePing(params interface{}, opts ...interface{}) *MockClientService_IamServicePing_Call { + return &MockClientService_IamServicePing_Call{Call: _e.mock.On("IamServicePing", + append([]interface{}{params}, opts...)...)} +} + +func (_c *MockClientService_IamServicePing_Call) Run(run func(params *iam_service.IamServicePingParams, opts ...iam_service.ClientOption)) *MockClientService_IamServicePing_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServicePingParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServicePing_Call) Return(_a0 *iam_service.IamServicePingOK, _a1 error) *MockClientService_IamServicePing_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServicePing_Call) RunAndReturn(run func(*iam_service.IamServicePingParams, ...iam_service.ClientOption) (*iam_service.IamServicePingOK, error)) *MockClientService_IamServicePing_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceSearchPrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceSearchPrincipals(params *iam_service.IamServiceSearchPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceSearchPrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceSearchPrincipals") + } + + var r0 *iam_service.IamServiceSearchPrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceSearchPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceSearchPrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceSearchPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceSearchPrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceSearchPrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceSearchPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceSearchPrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceSearchPrincipals' +type MockClientService_IamServiceSearchPrincipals_Call struct { + *mock.Call +} + +// IamServiceSearchPrincipals is a helper method to define mock.On call +// - params *iam_service.IamServiceSearchPrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceSearchPrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceSearchPrincipals_Call { + return &MockClientService_IamServiceSearchPrincipals_Call{Call: _e.mock.On("IamServiceSearchPrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceSearchPrincipals_Call) Run(run func(params *iam_service.IamServiceSearchPrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceSearchPrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceSearchPrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceSearchPrincipals_Call) Return(_a0 *iam_service.IamServiceSearchPrincipalsOK, _a1 error) *MockClientService_IamServiceSearchPrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceSearchPrincipals_Call) RunAndReturn(run func(*iam_service.IamServiceSearchPrincipalsParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceSearchPrincipalsOK, error)) *MockClientService_IamServiceSearchPrincipals_Call { + _c.Call.Return(run) + return _c +} + +// IamServiceUpdateWebConsolePreferences provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) IamServiceUpdateWebConsolePreferences(params *iam_service.IamServiceUpdateWebConsolePreferencesParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption) (*iam_service.IamServiceUpdateWebConsolePreferencesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for IamServiceUpdateWebConsolePreferences") + } + + var r0 *iam_service.IamServiceUpdateWebConsolePreferencesOK + var r1 error + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceUpdateWebConsolePreferencesParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceUpdateWebConsolePreferencesOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*iam_service.IamServiceUpdateWebConsolePreferencesParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) *iam_service.IamServiceUpdateWebConsolePreferencesOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*iam_service.IamServiceUpdateWebConsolePreferencesOK) + } + } + + if rf, ok := ret.Get(1).(func(*iam_service.IamServiceUpdateWebConsolePreferencesParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_IamServiceUpdateWebConsolePreferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IamServiceUpdateWebConsolePreferences' +type MockClientService_IamServiceUpdateWebConsolePreferences_Call struct { + *mock.Call +} + +// IamServiceUpdateWebConsolePreferences is a helper method to define mock.On call +// - params *iam_service.IamServiceUpdateWebConsolePreferencesParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...iam_service.ClientOption +func (_e *MockClientService_Expecter) IamServiceUpdateWebConsolePreferences(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_IamServiceUpdateWebConsolePreferences_Call { + return &MockClientService_IamServiceUpdateWebConsolePreferences_Call{Call: _e.mock.On("IamServiceUpdateWebConsolePreferences", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_IamServiceUpdateWebConsolePreferences_Call) Run(run func(params *iam_service.IamServiceUpdateWebConsolePreferencesParams, authInfo runtime.ClientAuthInfoWriter, opts ...iam_service.ClientOption)) *MockClientService_IamServiceUpdateWebConsolePreferences_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]iam_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(iam_service.ClientOption) + } + } + run(args[0].(*iam_service.IamServiceUpdateWebConsolePreferencesParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_IamServiceUpdateWebConsolePreferences_Call) Return(_a0 *iam_service.IamServiceUpdateWebConsolePreferencesOK, _a1 error) *MockClientService_IamServiceUpdateWebConsolePreferences_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_IamServiceUpdateWebConsolePreferences_Call) RunAndReturn(run func(*iam_service.IamServiceUpdateWebConsolePreferencesParams, runtime.ClientAuthInfoWriter, ...iam_service.ClientOption) (*iam_service.IamServiceUpdateWebConsolePreferencesOK, error)) *MockClientService_IamServiceUpdateWebConsolePreferences_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientOption.go new file mode 100644 index 00000000..16897e45 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_invitations_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientService.go new file mode 100644 index 00000000..7c8d2340 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service/mock_ClientService.go @@ -0,0 +1,440 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_invitations_service + +import ( + invitations_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/invitations_service" + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// InvitationsServiceAcceptOrganizationInvitation provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvitationsServiceAcceptOrganizationInvitation(params *invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceAcceptOrganizationInvitationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvitationsServiceAcceptOrganizationInvitation") + } + + var r0 *invitations_service.InvitationsServiceAcceptOrganizationInvitationOK + var r1 error + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceAcceptOrganizationInvitationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) *invitations_service.InvitationsServiceAcceptOrganizationInvitationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invitations_service.InvitationsServiceAcceptOrganizationInvitationOK) + } + } + + if rf, ok := ret.Get(1).(func(*invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvitationsServiceAcceptOrganizationInvitation' +type MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call struct { + *mock.Call +} + +// InvitationsServiceAcceptOrganizationInvitation is a helper method to define mock.On call +// - params *invitations_service.InvitationsServiceAcceptOrganizationInvitationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invitations_service.ClientOption +func (_e *MockClientService_Expecter) InvitationsServiceAcceptOrganizationInvitation(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call { + return &MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call{Call: _e.mock.On("InvitationsServiceAcceptOrganizationInvitation", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call) Run(run func(params *invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption)) *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invitations_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invitations_service.ClientOption) + } + } + run(args[0].(*invitations_service.InvitationsServiceAcceptOrganizationInvitationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call) Return(_a0 *invitations_service.InvitationsServiceAcceptOrganizationInvitationOK, _a1 error) *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call) RunAndReturn(run func(*invitations_service.InvitationsServiceAcceptOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceAcceptOrganizationInvitationOK, error)) *MockClientService_InvitationsServiceAcceptOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// InvitationsServiceCreateOrganizationInvitations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvitationsServiceCreateOrganizationInvitations(params *invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceCreateOrganizationInvitationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvitationsServiceCreateOrganizationInvitations") + } + + var r0 *invitations_service.InvitationsServiceCreateOrganizationInvitationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceCreateOrganizationInvitationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) *invitations_service.InvitationsServiceCreateOrganizationInvitationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invitations_service.InvitationsServiceCreateOrganizationInvitationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvitationsServiceCreateOrganizationInvitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvitationsServiceCreateOrganizationInvitations' +type MockClientService_InvitationsServiceCreateOrganizationInvitations_Call struct { + *mock.Call +} + +// InvitationsServiceCreateOrganizationInvitations is a helper method to define mock.On call +// - params *invitations_service.InvitationsServiceCreateOrganizationInvitationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invitations_service.ClientOption +func (_e *MockClientService_Expecter) InvitationsServiceCreateOrganizationInvitations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call { + return &MockClientService_InvitationsServiceCreateOrganizationInvitations_Call{Call: _e.mock.On("InvitationsServiceCreateOrganizationInvitations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call) Run(run func(params *invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption)) *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invitations_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invitations_service.ClientOption) + } + } + run(args[0].(*invitations_service.InvitationsServiceCreateOrganizationInvitationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call) Return(_a0 *invitations_service.InvitationsServiceCreateOrganizationInvitationsOK, _a1 error) *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call) RunAndReturn(run func(*invitations_service.InvitationsServiceCreateOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceCreateOrganizationInvitationsOK, error)) *MockClientService_InvitationsServiceCreateOrganizationInvitations_Call { + _c.Call.Return(run) + return _c +} + +// InvitationsServiceDeleteOrganizationInvitation provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvitationsServiceDeleteOrganizationInvitation(params *invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceDeleteOrganizationInvitationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvitationsServiceDeleteOrganizationInvitation") + } + + var r0 *invitations_service.InvitationsServiceDeleteOrganizationInvitationOK + var r1 error + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceDeleteOrganizationInvitationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) *invitations_service.InvitationsServiceDeleteOrganizationInvitationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invitations_service.InvitationsServiceDeleteOrganizationInvitationOK) + } + } + + if rf, ok := ret.Get(1).(func(*invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvitationsServiceDeleteOrganizationInvitation' +type MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call struct { + *mock.Call +} + +// InvitationsServiceDeleteOrganizationInvitation is a helper method to define mock.On call +// - params *invitations_service.InvitationsServiceDeleteOrganizationInvitationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invitations_service.ClientOption +func (_e *MockClientService_Expecter) InvitationsServiceDeleteOrganizationInvitation(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call { + return &MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call{Call: _e.mock.On("InvitationsServiceDeleteOrganizationInvitation", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call) Run(run func(params *invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption)) *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invitations_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invitations_service.ClientOption) + } + } + run(args[0].(*invitations_service.InvitationsServiceDeleteOrganizationInvitationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call) Return(_a0 *invitations_service.InvitationsServiceDeleteOrganizationInvitationOK, _a1 error) *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call) RunAndReturn(run func(*invitations_service.InvitationsServiceDeleteOrganizationInvitationParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceDeleteOrganizationInvitationOK, error)) *MockClientService_InvitationsServiceDeleteOrganizationInvitation_Call { + _c.Call.Return(run) + return _c +} + +// InvitationsServiceGetOrganizationNameByInvitationToken provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvitationsServiceGetOrganizationNameByInvitationToken(params *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvitationsServiceGetOrganizationNameByInvitationToken") + } + + var r0 *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK + var r1 error + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK) + } + } + + if rf, ok := ret.Get(1).(func(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvitationsServiceGetOrganizationNameByInvitationToken' +type MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call struct { + *mock.Call +} + +// InvitationsServiceGetOrganizationNameByInvitationToken is a helper method to define mock.On call +// - params *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invitations_service.ClientOption +func (_e *MockClientService_Expecter) InvitationsServiceGetOrganizationNameByInvitationToken(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call { + return &MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call{Call: _e.mock.On("InvitationsServiceGetOrganizationNameByInvitationToken", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call) Run(run func(params *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption)) *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invitations_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invitations_service.ClientOption) + } + } + run(args[0].(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call) Return(_a0 *invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK, _a1 error) *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call) RunAndReturn(run func(*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceGetOrganizationNameByInvitationTokenOK, error)) *MockClientService_InvitationsServiceGetOrganizationNameByInvitationToken_Call { + _c.Call.Return(run) + return _c +} + +// InvitationsServiceListOrganizationInvitations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) InvitationsServiceListOrganizationInvitations(params *invitations_service.InvitationsServiceListOrganizationInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceListOrganizationInvitationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for InvitationsServiceListOrganizationInvitations") + } + + var r0 *invitations_service.InvitationsServiceListOrganizationInvitationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceListOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceListOrganizationInvitationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*invitations_service.InvitationsServiceListOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) *invitations_service.InvitationsServiceListOrganizationInvitationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*invitations_service.InvitationsServiceListOrganizationInvitationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*invitations_service.InvitationsServiceListOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_InvitationsServiceListOrganizationInvitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvitationsServiceListOrganizationInvitations' +type MockClientService_InvitationsServiceListOrganizationInvitations_Call struct { + *mock.Call +} + +// InvitationsServiceListOrganizationInvitations is a helper method to define mock.On call +// - params *invitations_service.InvitationsServiceListOrganizationInvitationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...invitations_service.ClientOption +func (_e *MockClientService_Expecter) InvitationsServiceListOrganizationInvitations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_InvitationsServiceListOrganizationInvitations_Call { + return &MockClientService_InvitationsServiceListOrganizationInvitations_Call{Call: _e.mock.On("InvitationsServiceListOrganizationInvitations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_InvitationsServiceListOrganizationInvitations_Call) Run(run func(params *invitations_service.InvitationsServiceListOrganizationInvitationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...invitations_service.ClientOption)) *MockClientService_InvitationsServiceListOrganizationInvitations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]invitations_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(invitations_service.ClientOption) + } + } + run(args[0].(*invitations_service.InvitationsServiceListOrganizationInvitationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_InvitationsServiceListOrganizationInvitations_Call) Return(_a0 *invitations_service.InvitationsServiceListOrganizationInvitationsOK, _a1 error) *MockClientService_InvitationsServiceListOrganizationInvitations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_InvitationsServiceListOrganizationInvitations_Call) RunAndReturn(run func(*invitations_service.InvitationsServiceListOrganizationInvitationsParams, runtime.ClientAuthInfoWriter, ...invitations_service.ClientOption) (*invitations_service.InvitationsServiceListOrganizationInvitationsOK, error)) *MockClientService_InvitationsServiceListOrganizationInvitations_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientOption.go new file mode 100644 index 00000000..2c5cd3a2 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientOption.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_profile_service + +import ( + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientService.go new file mode 100644 index 00000000..76c84353 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service/mock_ClientService.go @@ -0,0 +1,513 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_profile_service + +import ( + runtime "github.com/go-openapi/runtime" + profile_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/profile_service" + mock "github.com/stretchr/testify/mock" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// ProfileServiceConfirmMFAEnrollment provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceConfirmMFAEnrollment(params *profile_service.ProfileServiceConfirmMFAEnrollmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceConfirmMFAEnrollmentOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceConfirmMFAEnrollment") + } + + var r0 *profile_service.ProfileServiceConfirmMFAEnrollmentOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceConfirmMFAEnrollmentParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceConfirmMFAEnrollmentOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceConfirmMFAEnrollmentParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceConfirmMFAEnrollmentOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceConfirmMFAEnrollmentOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceConfirmMFAEnrollmentParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceConfirmMFAEnrollment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceConfirmMFAEnrollment' +type MockClientService_ProfileServiceConfirmMFAEnrollment_Call struct { + *mock.Call +} + +// ProfileServiceConfirmMFAEnrollment is a helper method to define mock.On call +// - params *profile_service.ProfileServiceConfirmMFAEnrollmentParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceConfirmMFAEnrollment(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceConfirmMFAEnrollment_Call { + return &MockClientService_ProfileServiceConfirmMFAEnrollment_Call{Call: _e.mock.On("ProfileServiceConfirmMFAEnrollment", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceConfirmMFAEnrollment_Call) Run(run func(params *profile_service.ProfileServiceConfirmMFAEnrollmentParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceConfirmMFAEnrollment_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceConfirmMFAEnrollmentParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceConfirmMFAEnrollment_Call) Return(_a0 *profile_service.ProfileServiceConfirmMFAEnrollmentOK, _a1 error) *MockClientService_ProfileServiceConfirmMFAEnrollment_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceConfirmMFAEnrollment_Call) RunAndReturn(run func(*profile_service.ProfileServiceConfirmMFAEnrollmentParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceConfirmMFAEnrollmentOK, error)) *MockClientService_ProfileServiceConfirmMFAEnrollment_Call { + _c.Call.Return(run) + return _c +} + +// ProfileServiceDisableMFA provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceDisableMFA(params *profile_service.ProfileServiceDisableMFAParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceDisableMFAOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceDisableMFA") + } + + var r0 *profile_service.ProfileServiceDisableMFAOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceDisableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceDisableMFAOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceDisableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceDisableMFAOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceDisableMFAOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceDisableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceDisableMFA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceDisableMFA' +type MockClientService_ProfileServiceDisableMFA_Call struct { + *mock.Call +} + +// ProfileServiceDisableMFA is a helper method to define mock.On call +// - params *profile_service.ProfileServiceDisableMFAParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceDisableMFA(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceDisableMFA_Call { + return &MockClientService_ProfileServiceDisableMFA_Call{Call: _e.mock.On("ProfileServiceDisableMFA", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceDisableMFA_Call) Run(run func(params *profile_service.ProfileServiceDisableMFAParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceDisableMFA_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceDisableMFAParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceDisableMFA_Call) Return(_a0 *profile_service.ProfileServiceDisableMFAOK, _a1 error) *MockClientService_ProfileServiceDisableMFA_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceDisableMFA_Call) RunAndReturn(run func(*profile_service.ProfileServiceDisableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceDisableMFAOK, error)) *MockClientService_ProfileServiceDisableMFA_Call { + _c.Call.Return(run) + return _c +} + +// ProfileServiceEnableMFA provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceEnableMFA(params *profile_service.ProfileServiceEnableMFAParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceEnableMFAOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceEnableMFA") + } + + var r0 *profile_service.ProfileServiceEnableMFAOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceEnableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceEnableMFAOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceEnableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceEnableMFAOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceEnableMFAOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceEnableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceEnableMFA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceEnableMFA' +type MockClientService_ProfileServiceEnableMFA_Call struct { + *mock.Call +} + +// ProfileServiceEnableMFA is a helper method to define mock.On call +// - params *profile_service.ProfileServiceEnableMFAParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceEnableMFA(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceEnableMFA_Call { + return &MockClientService_ProfileServiceEnableMFA_Call{Call: _e.mock.On("ProfileServiceEnableMFA", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceEnableMFA_Call) Run(run func(params *profile_service.ProfileServiceEnableMFAParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceEnableMFA_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceEnableMFAParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceEnableMFA_Call) Return(_a0 *profile_service.ProfileServiceEnableMFAOK, _a1 error) *MockClientService_ProfileServiceEnableMFA_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceEnableMFA_Call) RunAndReturn(run func(*profile_service.ProfileServiceEnableMFAParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceEnableMFAOK, error)) *MockClientService_ProfileServiceEnableMFA_Call { + _c.Call.Return(run) + return _c +} + +// ProfileServiceGetMFAStatus provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceGetMFAStatus(params *profile_service.ProfileServiceGetMFAStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceGetMFAStatusOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceGetMFAStatus") + } + + var r0 *profile_service.ProfileServiceGetMFAStatusOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceGetMFAStatusParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceGetMFAStatusOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceGetMFAStatusParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceGetMFAStatusOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceGetMFAStatusOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceGetMFAStatusParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceGetMFAStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceGetMFAStatus' +type MockClientService_ProfileServiceGetMFAStatus_Call struct { + *mock.Call +} + +// ProfileServiceGetMFAStatus is a helper method to define mock.On call +// - params *profile_service.ProfileServiceGetMFAStatusParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceGetMFAStatus(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceGetMFAStatus_Call { + return &MockClientService_ProfileServiceGetMFAStatus_Call{Call: _e.mock.On("ProfileServiceGetMFAStatus", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceGetMFAStatus_Call) Run(run func(params *profile_service.ProfileServiceGetMFAStatusParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceGetMFAStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceGetMFAStatusParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceGetMFAStatus_Call) Return(_a0 *profile_service.ProfileServiceGetMFAStatusOK, _a1 error) *MockClientService_ProfileServiceGetMFAStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceGetMFAStatus_Call) RunAndReturn(run func(*profile_service.ProfileServiceGetMFAStatusParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceGetMFAStatusOK, error)) *MockClientService_ProfileServiceGetMFAStatus_Call { + _c.Call.Return(run) + return _c +} + +// ProfileServiceResetPassword provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceResetPassword(params *profile_service.ProfileServiceResetPasswordParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceResetPasswordOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceResetPassword") + } + + var r0 *profile_service.ProfileServiceResetPasswordOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceResetPasswordParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceResetPasswordOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceResetPasswordParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceResetPasswordOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceResetPasswordOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceResetPasswordParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceResetPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceResetPassword' +type MockClientService_ProfileServiceResetPassword_Call struct { + *mock.Call +} + +// ProfileServiceResetPassword is a helper method to define mock.On call +// - params *profile_service.ProfileServiceResetPasswordParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceResetPassword(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceResetPassword_Call { + return &MockClientService_ProfileServiceResetPassword_Call{Call: _e.mock.On("ProfileServiceResetPassword", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceResetPassword_Call) Run(run func(params *profile_service.ProfileServiceResetPasswordParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceResetPassword_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceResetPasswordParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceResetPassword_Call) Return(_a0 *profile_service.ProfileServiceResetPasswordOK, _a1 error) *MockClientService_ProfileServiceResetPassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceResetPassword_Call) RunAndReturn(run func(*profile_service.ProfileServiceResetPasswordParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceResetPasswordOK, error)) *MockClientService_ProfileServiceResetPassword_Call { + _c.Call.Return(run) + return _c +} + +// ProfileServiceSendVerificationEmail provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProfileServiceSendVerificationEmail(params *profile_service.ProfileServiceSendVerificationEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption) (*profile_service.ProfileServiceSendVerificationEmailOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProfileServiceSendVerificationEmail") + } + + var r0 *profile_service.ProfileServiceSendVerificationEmailOK + var r1 error + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceSendVerificationEmailParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceSendVerificationEmailOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*profile_service.ProfileServiceSendVerificationEmailParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) *profile_service.ProfileServiceSendVerificationEmailOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*profile_service.ProfileServiceSendVerificationEmailOK) + } + } + + if rf, ok := ret.Get(1).(func(*profile_service.ProfileServiceSendVerificationEmailParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProfileServiceSendVerificationEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProfileServiceSendVerificationEmail' +type MockClientService_ProfileServiceSendVerificationEmail_Call struct { + *mock.Call +} + +// ProfileServiceSendVerificationEmail is a helper method to define mock.On call +// - params *profile_service.ProfileServiceSendVerificationEmailParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...profile_service.ClientOption +func (_e *MockClientService_Expecter) ProfileServiceSendVerificationEmail(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProfileServiceSendVerificationEmail_Call { + return &MockClientService_ProfileServiceSendVerificationEmail_Call{Call: _e.mock.On("ProfileServiceSendVerificationEmail", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProfileServiceSendVerificationEmail_Call) Run(run func(params *profile_service.ProfileServiceSendVerificationEmailParams, authInfo runtime.ClientAuthInfoWriter, opts ...profile_service.ClientOption)) *MockClientService_ProfileServiceSendVerificationEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]profile_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(profile_service.ClientOption) + } + } + run(args[0].(*profile_service.ProfileServiceSendVerificationEmailParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProfileServiceSendVerificationEmail_Call) Return(_a0 *profile_service.ProfileServiceSendVerificationEmailOK, _a1 error) *MockClientService_ProfileServiceSendVerificationEmail_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProfileServiceSendVerificationEmail_Call) RunAndReturn(run func(*profile_service.ProfileServiceSendVerificationEmailParams, runtime.ClientAuthInfoWriter, ...profile_service.ClientOption) (*profile_service.ProfileServiceSendVerificationEmailOK, error)) *MockClientService_ProfileServiceSendVerificationEmail_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientOption.go new file mode 100644 index 00000000..d555318b --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_s_s_o_management_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientService.go new file mode 100644 index 00000000..8f1529a5 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service/mock_ClientService.go @@ -0,0 +1,736 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_s_s_o_management_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" + + s_s_o_management_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/s_s_o_management_service" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// SSOManagementServiceCreateSSOConfiguration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceCreateSSOConfiguration(params *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceCreateSSOConfiguration") + } + + var r0 *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceCreateSSOConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceCreateSSOConfiguration' +type MockClientService_SSOManagementServiceCreateSSOConfiguration_Call struct { + *mock.Call +} + +// SSOManagementServiceCreateSSOConfiguration is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceCreateSSOConfiguration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call { + return &MockClientService_SSOManagementServiceCreateSSOConfiguration_Call{Call: _e.mock.On("SSOManagementServiceCreateSSOConfiguration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK, _a1 error) *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceCreateSSOConfigurationOK, error)) *MockClientService_SSOManagementServiceCreateSSOConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceDeleteSSOConfiguration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceDeleteSSOConfiguration(params *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceDeleteSSOConfiguration") + } + + var r0 *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceDeleteSSOConfiguration' +type MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call struct { + *mock.Call +} + +// SSOManagementServiceDeleteSSOConfiguration is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceDeleteSSOConfiguration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call { + return &MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call{Call: _e.mock.On("SSOManagementServiceDeleteSSOConfiguration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK, _a1 error) *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceDeleteSSOConfigurationOK, error)) *MockClientService_SSOManagementServiceDeleteSSOConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceGetPreconfigurationData provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceGetPreconfigurationData(params *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceGetPreconfigurationData") + } + + var r0 *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceGetPreconfigurationData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceGetPreconfigurationData' +type MockClientService_SSOManagementServiceGetPreconfigurationData_Call struct { + *mock.Call +} + +// SSOManagementServiceGetPreconfigurationData is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceGetPreconfigurationData(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceGetPreconfigurationData_Call { + return &MockClientService_SSOManagementServiceGetPreconfigurationData_Call{Call: _e.mock.On("SSOManagementServiceGetPreconfigurationData", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceGetPreconfigurationData_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceGetPreconfigurationData_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetPreconfigurationData_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK, _a1 error) *MockClientService_SSOManagementServiceGetPreconfigurationData_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetPreconfigurationData_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetPreconfigurationDataOK, error)) *MockClientService_SSOManagementServiceGetPreconfigurationData_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceGetSSOConfiguration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceGetSSOConfiguration(params *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceGetSSOConfiguration") + } + + var r0 *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceGetSSOConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceGetSSOConfiguration' +type MockClientService_SSOManagementServiceGetSSOConfiguration_Call struct { + *mock.Call +} + +// SSOManagementServiceGetSSOConfiguration is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceGetSSOConfiguration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceGetSSOConfiguration_Call { + return &MockClientService_SSOManagementServiceGetSSOConfiguration_Call{Call: _e.mock.On("SSOManagementServiceGetSSOConfiguration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceGetSSOConfiguration_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceGetSSOConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetSSOConfiguration_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK, _a1 error) *MockClientService_SSOManagementServiceGetSSOConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetSSOConfiguration_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOConfigurationOK, error)) *MockClientService_SSOManagementServiceGetSSOConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceGetSSOType provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceGetSSOType(params *s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOTypeOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceGetSSOType") + } + + var r0 *s_s_o_management_service.SSOManagementServiceGetSSOTypeOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOTypeOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceGetSSOTypeOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceGetSSOTypeOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceGetSSOType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceGetSSOType' +type MockClientService_SSOManagementServiceGetSSOType_Call struct { + *mock.Call +} + +// SSOManagementServiceGetSSOType is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceGetSSOTypeParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceGetSSOType(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceGetSSOType_Call { + return &MockClientService_SSOManagementServiceGetSSOType_Call{Call: _e.mock.On("SSOManagementServiceGetSSOType", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceGetSSOType_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceGetSSOType_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceGetSSOTypeParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetSSOType_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceGetSSOTypeOK, _a1 error) *MockClientService_SSOManagementServiceGetSSOType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceGetSSOType_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceGetSSOTypeParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceGetSSOTypeOK, error)) *MockClientService_SSOManagementServiceGetSSOType_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceListSSOConfigurations provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceListSSOConfigurations(params *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceListSSOConfigurations") + } + + var r0 *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceListSSOConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceListSSOConfigurations' +type MockClientService_SSOManagementServiceListSSOConfigurations_Call struct { + *mock.Call +} + +// SSOManagementServiceListSSOConfigurations is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceListSSOConfigurations(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceListSSOConfigurations_Call { + return &MockClientService_SSOManagementServiceListSSOConfigurations_Call{Call: _e.mock.On("SSOManagementServiceListSSOConfigurations", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceListSSOConfigurations_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceListSSOConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceListSSOConfigurations_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK, _a1 error) *MockClientService_SSOManagementServiceListSSOConfigurations_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceListSSOConfigurations_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceListSSOConfigurationsOK, error)) *MockClientService_SSOManagementServiceListSSOConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceUpdateSSOConfiguration provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceUpdateSSOConfiguration(params *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceUpdateSSOConfiguration") + } + + var r0 *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceUpdateSSOConfiguration' +type MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call struct { + *mock.Call +} + +// SSOManagementServiceUpdateSSOConfiguration is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceUpdateSSOConfiguration(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call { + return &MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call{Call: _e.mock.On("SSOManagementServiceUpdateSSOConfiguration", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK, _a1 error) *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceUpdateSSOConfigurationOK, error)) *MockClientService_SSOManagementServiceUpdateSSOConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceVerifyDomainOwnership provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceVerifyDomainOwnership(params *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceVerifyDomainOwnership") + } + + var r0 *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceVerifyDomainOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceVerifyDomainOwnership' +type MockClientService_SSOManagementServiceVerifyDomainOwnership_Call struct { + *mock.Call +} + +// SSOManagementServiceVerifyDomainOwnership is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceVerifyDomainOwnership(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call { + return &MockClientService_SSOManagementServiceVerifyDomainOwnership_Call{Call: _e.mock.On("SSOManagementServiceVerifyDomainOwnership", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK, _a1 error) *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifyDomainOwnershipOK, error)) *MockClientService_SSOManagementServiceVerifyDomainOwnership_Call { + _c.Call.Return(run) + return _c +} + +// SSOManagementServiceVerifySSODomainOwnership provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) SSOManagementServiceVerifySSODomainOwnership(params *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SSOManagementServiceVerifySSODomainOwnership") + } + + var r0 *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK + var r1 error + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK) + } + } + + if rf, ok := ret.Get(1).(func(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SSOManagementServiceVerifySSODomainOwnership' +type MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call struct { + *mock.Call +} + +// SSOManagementServiceVerifySSODomainOwnership is a helper method to define mock.On call +// - params *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...s_s_o_management_service.ClientOption +func (_e *MockClientService_Expecter) SSOManagementServiceVerifySSODomainOwnership(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call { + return &MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call{Call: _e.mock.On("SSOManagementServiceVerifySSODomainOwnership", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call) Run(run func(params *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, authInfo runtime.ClientAuthInfoWriter, opts ...s_s_o_management_service.ClientOption)) *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]s_s_o_management_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(s_s_o_management_service.ClientOption) + } + } + run(args[0].(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call) Return(_a0 *s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK, _a1 error) *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call) RunAndReturn(run func(*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipParams, runtime.ClientAuthInfoWriter, ...s_s_o_management_service.ClientOption) (*s_s_o_management_service.SSOManagementServiceVerifySSODomainOwnershipOK, error)) *MockClientService_SSOManagementServiceVerifySSODomainOwnership_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientOption.go new file mode 100644 index 00000000..744bf8f8 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientOption.go @@ -0,0 +1,68 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_service_principals_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientService.go new file mode 100644 index 00000000..0fac5aab --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service/mock_ClientService.go @@ -0,0 +1,2290 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_service_principals_service + +import ( + runtime "github.com/go-openapi/runtime" + mock "github.com/stretchr/testify/mock" + + service_principals_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-iam/stable/2019-12-10/client/service_principals_service" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// ServicePrincipalsServiceCreateOrganizationServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateOrganizationServicePrincipal(params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateOrganizationServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateOrganizationServicePrincipal' +type MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateOrganizationServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateOrganizationServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateOrganizationServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateOrganizationServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateOrganizationServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateOrganizationServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateOrganizationServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateOrganizationServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateOrganizationServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateOrganizationServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateOrganizationServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceCreateOrganizationServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateProjectServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateProjectServicePrincipal(params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateProjectServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateProjectServicePrincipal' +type MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateProjectServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateProjectServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateProjectServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateProjectServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateProjectServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateProjectServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateProjectServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateProjectServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateProjectServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateProjectServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateProjectServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceCreateProjectServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateServicePrincipal(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateServicePrincipal' +type MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateServicePrincipal2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateServicePrincipal2(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateServicePrincipal2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateServicePrincipal2' +type MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateServicePrincipal2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateServicePrincipal2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call { + return &MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateServicePrincipal2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipal2OK, error)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipal2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateServicePrincipalKey2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateServicePrincipalKey2(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateServicePrincipalKey2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateServicePrincipalKey2' +type MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateServicePrincipalKey2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateServicePrincipalKey2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call { + return &MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateServicePrincipalKey2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateServicePrincipalKey2OK, error)) *MockClientService_ServicePrincipalsServiceCreateServicePrincipalKey2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceCreateWorkloadIdentityProvider provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceCreateWorkloadIdentityProvider(params *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceCreateWorkloadIdentityProvider") + } + + var r0 *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceCreateWorkloadIdentityProvider' +type MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceCreateWorkloadIdentityProvider is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceCreateWorkloadIdentityProvider(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call { + return &MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call{Call: _e.mock.On("ServicePrincipalsServiceCreateWorkloadIdentityProvider", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK, _a1 error) *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceCreateWorkloadIdentityProviderOK, error)) *MockClientService_ServicePrincipalsServiceCreateWorkloadIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteOrganizationServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteOrganizationServicePrincipal(params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteOrganizationServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteOrganizationServicePrincipal' +type MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteOrganizationServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteOrganizationServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteOrganizationServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteOrganizationServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceDeleteOrganizationServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteProjectServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteProjectServicePrincipal(params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteProjectServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteProjectServicePrincipal' +type MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteProjectServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteProjectServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteProjectServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteProjectServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteProjectServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteProjectServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteProjectServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteProjectServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteProjectServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteProjectServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteProjectServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceDeleteProjectServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteServicePrincipal(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteServicePrincipal' +type MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteServicePrincipal2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteServicePrincipal2(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteServicePrincipal2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteServicePrincipal2' +type MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteServicePrincipal2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteServicePrincipal2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call { + return &MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteServicePrincipal2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipal2OK, error)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipal2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteServicePrincipalKey provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteServicePrincipalKey(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteServicePrincipalKey") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteServicePrincipalKey' +type MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteServicePrincipalKey is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteServicePrincipalKey(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call { + return &MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteServicePrincipalKey", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKeyOK, error)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteServicePrincipalKey2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteServicePrincipalKey2(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteServicePrincipalKey2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteServicePrincipalKey2' +type MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteServicePrincipalKey2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteServicePrincipalKey2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call { + return &MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteServicePrincipalKey2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteServicePrincipalKey2OK, error)) *MockClientService_ServicePrincipalsServiceDeleteServicePrincipalKey2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceDeleteWorkloadIdentityProvider provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceDeleteWorkloadIdentityProvider(params *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceDeleteWorkloadIdentityProvider") + } + + var r0 *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceDeleteWorkloadIdentityProvider' +type MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceDeleteWorkloadIdentityProvider is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceDeleteWorkloadIdentityProvider(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call { + return &MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call{Call: _e.mock.On("ServicePrincipalsServiceDeleteWorkloadIdentityProvider", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK, _a1 error) *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceDeleteWorkloadIdentityProviderOK, error)) *MockClientService_ServicePrincipalsServiceDeleteWorkloadIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceExchangeWorkloadIdentityToken provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceExchangeWorkloadIdentityToken(params *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceExchangeWorkloadIdentityToken") + } + + var r0 *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceExchangeWorkloadIdentityToken' +type MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceExchangeWorkloadIdentityToken is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceExchangeWorkloadIdentityToken(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call { + return &MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call{Call: _e.mock.On("ServicePrincipalsServiceExchangeWorkloadIdentityToken", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK, _a1 error) *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceExchangeWorkloadIdentityTokenOK, error)) *MockClientService_ServicePrincipalsServiceExchangeWorkloadIdentityToken_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceGetOrganizationServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceGetOrganizationServicePrincipal(params *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceGetOrganizationServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceGetOrganizationServicePrincipal' +type MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceGetOrganizationServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceGetOrganizationServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceGetOrganizationServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetOrganizationServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceGetOrganizationServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceGetProjectServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceGetProjectServicePrincipal(params *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceGetProjectServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceGetProjectServicePrincipal' +type MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceGetProjectServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceGetProjectServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceGetProjectServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetProjectServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceGetProjectServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceGetServicePrincipal provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceGetServicePrincipal(params *service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceGetServicePrincipal") + } + + var r0 *service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceGetServicePrincipal' +type MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceGetServicePrincipal is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceGetServicePrincipal(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call { + return &MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call{Call: _e.mock.On("ServicePrincipalsServiceGetServicePrincipal", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK, _a1 error) *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipalParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipalOK, error)) *MockClientService_ServicePrincipalsServiceGetServicePrincipal_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceGetServicePrincipal2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceGetServicePrincipal2(params *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceGetServicePrincipal2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceGetServicePrincipal2' +type MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceGetServicePrincipal2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceGetServicePrincipal2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call { + return &MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call{Call: _e.mock.On("ServicePrincipalsServiceGetServicePrincipal2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK, _a1 error) *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetServicePrincipal2OK, error)) *MockClientService_ServicePrincipalsServiceGetServicePrincipal2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceGetWorkloadIdentityProvider provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceGetWorkloadIdentityProvider(params *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceGetWorkloadIdentityProvider") + } + + var r0 *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceGetWorkloadIdentityProvider' +type MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceGetWorkloadIdentityProvider is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceGetWorkloadIdentityProvider(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call { + return &MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call{Call: _e.mock.On("ServicePrincipalsServiceGetWorkloadIdentityProvider", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK, _a1 error) *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceGetWorkloadIdentityProviderOK, error)) *MockClientService_ServicePrincipalsServiceGetWorkloadIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceListOrganizationServicePrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceListOrganizationServicePrincipals(params *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceListOrganizationServicePrincipals") + } + + var r0 *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceListOrganizationServicePrincipals' +type MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceListOrganizationServicePrincipals is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceListOrganizationServicePrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call { + return &MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call{Call: _e.mock.On("ServicePrincipalsServiceListOrganizationServicePrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK, _a1 error) *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListOrganizationServicePrincipalsOK, error)) *MockClientService_ServicePrincipalsServiceListOrganizationServicePrincipals_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceListProjectServicePrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceListProjectServicePrincipals(params *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceListProjectServicePrincipals") + } + + var r0 *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceListProjectServicePrincipals' +type MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceListProjectServicePrincipals is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceListProjectServicePrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call { + return &MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call{Call: _e.mock.On("ServicePrincipalsServiceListProjectServicePrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK, _a1 error) *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListProjectServicePrincipalsOK, error)) *MockClientService_ServicePrincipalsServiceListProjectServicePrincipals_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceListServicePrincipals provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceListServicePrincipals(params *service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceListServicePrincipals") + } + + var r0 *service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceListServicePrincipals_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceListServicePrincipals' +type MockClientService_ServicePrincipalsServiceListServicePrincipals_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceListServicePrincipals is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceListServicePrincipals(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call { + return &MockClientService_ServicePrincipalsServiceListServicePrincipals_Call{Call: _e.mock.On("ServicePrincipalsServiceListServicePrincipals", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK, _a1 error) *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceListServicePrincipalsParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipalsOK, error)) *MockClientService_ServicePrincipalsServiceListServicePrincipals_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceListServicePrincipals2 provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceListServicePrincipals2(params *service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceListServicePrincipals2") + } + + var r0 *service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceListServicePrincipals2' +type MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceListServicePrincipals2 is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceListServicePrincipals2(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call { + return &MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call{Call: _e.mock.On("ServicePrincipalsServiceListServicePrincipals2", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK, _a1 error) *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceListServicePrincipals2Params, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListServicePrincipals2OK, error)) *MockClientService_ServicePrincipalsServiceListServicePrincipals2_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceListWorkloadIdentityProvider provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceListWorkloadIdentityProvider(params *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceListWorkloadIdentityProvider") + } + + var r0 *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceListWorkloadIdentityProvider' +type MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceListWorkloadIdentityProvider is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceListWorkloadIdentityProvider(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call { + return &MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call{Call: _e.mock.On("ServicePrincipalsServiceListWorkloadIdentityProvider", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK, _a1 error) *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceListWorkloadIdentityProviderOK, error)) *MockClientService_ServicePrincipalsServiceListWorkloadIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// ServicePrincipalsServiceUpdateWorkloadIdentityProvider provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ServicePrincipalsServiceUpdateWorkloadIdentityProvider(params *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ServicePrincipalsServiceUpdateWorkloadIdentityProvider") + } + + var r0 *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK + var r1 error + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK) + } + } + + if rf, ok := ret.Get(1).(func(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServicePrincipalsServiceUpdateWorkloadIdentityProvider' +type MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call struct { + *mock.Call +} + +// ServicePrincipalsServiceUpdateWorkloadIdentityProvider is a helper method to define mock.On call +// - params *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...service_principals_service.ClientOption +func (_e *MockClientService_Expecter) ServicePrincipalsServiceUpdateWorkloadIdentityProvider(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call { + return &MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call{Call: _e.mock.On("ServicePrincipalsServiceUpdateWorkloadIdentityProvider", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call) Run(run func(params *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, authInfo runtime.ClientAuthInfoWriter, opts ...service_principals_service.ClientOption)) *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]service_principals_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(service_principals_service.ClientOption) + } + } + run(args[0].(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call) Return(_a0 *service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK, _a1 error) *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call) RunAndReturn(run func(*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderParams, runtime.ClientAuthInfoWriter, ...service_principals_service.ClientOption) (*service_principals_service.ServicePrincipalsServiceUpdateWorkloadIdentityProviderOK, error)) *MockClientService_ServicePrincipalsServiceUpdateWorkloadIdentityProvider_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientOption.go new file mode 100644 index 00000000..120cbd63 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientOption.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_organization_service + +import ( + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientService.go new file mode 100644 index 00000000..c45d22be --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service/mock_ClientService.go @@ -0,0 +1,735 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_organization_service + +import ( + runtime "github.com/go-openapi/runtime" + organization_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/organization_service" + mock "github.com/stretchr/testify/mock" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// OrganizationServiceCreate provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceCreate(params *organization_service.OrganizationServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceCreateOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceCreate") + } + + var r0 *organization_service.OrganizationServiceCreateOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceCreateParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceCreateOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceCreateParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceCreateOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceCreateOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceCreateParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceCreate' +type MockClientService_OrganizationServiceCreate_Call struct { + *mock.Call +} + +// OrganizationServiceCreate is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceCreateParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceCreate(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceCreate_Call { + return &MockClientService_OrganizationServiceCreate_Call{Call: _e.mock.On("OrganizationServiceCreate", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceCreate_Call) Run(run func(params *organization_service.OrganizationServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceCreateParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceCreate_Call) Return(_a0 *organization_service.OrganizationServiceCreateOK, _a1 error) *MockClientService_OrganizationServiceCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceCreate_Call) RunAndReturn(run func(*organization_service.OrganizationServiceCreateParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceCreateOK, error)) *MockClientService_OrganizationServiceCreate_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceGet provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceGet(params *organization_service.OrganizationServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceGet") + } + + var r0 *organization_service.OrganizationServiceGetOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceGetOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceGetOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceGetParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceGet' +type MockClientService_OrganizationServiceGet_Call struct { + *mock.Call +} + +// OrganizationServiceGet is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceGetParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceGet(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceGet_Call { + return &MockClientService_OrganizationServiceGet_Call{Call: _e.mock.On("OrganizationServiceGet", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceGet_Call) Run(run func(params *organization_service.OrganizationServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceGetParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceGet_Call) Return(_a0 *organization_service.OrganizationServiceGetOK, _a1 error) *MockClientService_OrganizationServiceGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceGet_Call) RunAndReturn(run func(*organization_service.OrganizationServiceGetParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetOK, error)) *MockClientService_OrganizationServiceGet_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceGetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceGetIamPolicy(params *organization_service.OrganizationServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceGetIamPolicy") + } + + var r0 *organization_service.OrganizationServiceGetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceGetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceGetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceGetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceGetIamPolicy' +type MockClientService_OrganizationServiceGetIamPolicy_Call struct { + *mock.Call +} + +// OrganizationServiceGetIamPolicy is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceGetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceGetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceGetIamPolicy_Call { + return &MockClientService_OrganizationServiceGetIamPolicy_Call{Call: _e.mock.On("OrganizationServiceGetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceGetIamPolicy_Call) Run(run func(params *organization_service.OrganizationServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceGetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceGetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceGetIamPolicy_Call) Return(_a0 *organization_service.OrganizationServiceGetIamPolicyOK, _a1 error) *MockClientService_OrganizationServiceGetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceGetIamPolicy_Call) RunAndReturn(run func(*organization_service.OrganizationServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetIamPolicyOK, error)) *MockClientService_OrganizationServiceGetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceGetRole provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceGetRole(params *organization_service.OrganizationServiceGetRoleParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetRoleOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceGetRole") + } + + var r0 *organization_service.OrganizationServiceGetRoleOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetRoleParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetRoleOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceGetRoleParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceGetRoleOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceGetRoleOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceGetRoleParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceGetRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceGetRole' +type MockClientService_OrganizationServiceGetRole_Call struct { + *mock.Call +} + +// OrganizationServiceGetRole is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceGetRoleParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceGetRole(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceGetRole_Call { + return &MockClientService_OrganizationServiceGetRole_Call{Call: _e.mock.On("OrganizationServiceGetRole", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceGetRole_Call) Run(run func(params *organization_service.OrganizationServiceGetRoleParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceGetRole_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceGetRoleParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceGetRole_Call) Return(_a0 *organization_service.OrganizationServiceGetRoleOK, _a1 error) *MockClientService_OrganizationServiceGetRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceGetRole_Call) RunAndReturn(run func(*organization_service.OrganizationServiceGetRoleParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceGetRoleOK, error)) *MockClientService_OrganizationServiceGetRole_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceList provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceList(params *organization_service.OrganizationServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceListOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceList") + } + + var r0 *organization_service.OrganizationServiceListOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceListParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceListOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceListParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceListOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceListOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceListParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceList' +type MockClientService_OrganizationServiceList_Call struct { + *mock.Call +} + +// OrganizationServiceList is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceListParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceList(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceList_Call { + return &MockClientService_OrganizationServiceList_Call{Call: _e.mock.On("OrganizationServiceList", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceList_Call) Run(run func(params *organization_service.OrganizationServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceListParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceList_Call) Return(_a0 *organization_service.OrganizationServiceListOK, _a1 error) *MockClientService_OrganizationServiceList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceList_Call) RunAndReturn(run func(*organization_service.OrganizationServiceListParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceListOK, error)) *MockClientService_OrganizationServiceList_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceListRoles provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceListRoles(params *organization_service.OrganizationServiceListRolesParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceListRolesOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceListRoles") + } + + var r0 *organization_service.OrganizationServiceListRolesOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceListRolesParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceListRolesOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceListRolesParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceListRolesOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceListRolesOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceListRolesParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceListRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceListRoles' +type MockClientService_OrganizationServiceListRoles_Call struct { + *mock.Call +} + +// OrganizationServiceListRoles is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceListRolesParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceListRoles(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceListRoles_Call { + return &MockClientService_OrganizationServiceListRoles_Call{Call: _e.mock.On("OrganizationServiceListRoles", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceListRoles_Call) Run(run func(params *organization_service.OrganizationServiceListRolesParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceListRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceListRolesParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceListRoles_Call) Return(_a0 *organization_service.OrganizationServiceListRolesOK, _a1 error) *MockClientService_OrganizationServiceListRoles_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceListRoles_Call) RunAndReturn(run func(*organization_service.OrganizationServiceListRolesParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceListRolesOK, error)) *MockClientService_OrganizationServiceListRoles_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceSetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceSetIamPolicy(params *organization_service.OrganizationServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceSetIamPolicy") + } + + var r0 *organization_service.OrganizationServiceSetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceSetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceSetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceSetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceSetIamPolicy' +type MockClientService_OrganizationServiceSetIamPolicy_Call struct { + *mock.Call +} + +// OrganizationServiceSetIamPolicy is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceSetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceSetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceSetIamPolicy_Call { + return &MockClientService_OrganizationServiceSetIamPolicy_Call{Call: _e.mock.On("OrganizationServiceSetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceSetIamPolicy_Call) Run(run func(params *organization_service.OrganizationServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceSetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceSetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceSetIamPolicy_Call) Return(_a0 *organization_service.OrganizationServiceSetIamPolicyOK, _a1 error) *MockClientService_OrganizationServiceSetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceSetIamPolicy_Call) RunAndReturn(run func(*organization_service.OrganizationServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetIamPolicyOK, error)) *MockClientService_OrganizationServiceSetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceSetName provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceSetName(params *organization_service.OrganizationServiceSetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetNameOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceSetName") + } + + var r0 *organization_service.OrganizationServiceSetNameOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceSetNameParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetNameOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceSetNameParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceSetNameOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceSetNameOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceSetNameParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceSetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceSetName' +type MockClientService_OrganizationServiceSetName_Call struct { + *mock.Call +} + +// OrganizationServiceSetName is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceSetNameParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceSetName(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceSetName_Call { + return &MockClientService_OrganizationServiceSetName_Call{Call: _e.mock.On("OrganizationServiceSetName", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceSetName_Call) Run(run func(params *organization_service.OrganizationServiceSetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceSetName_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceSetNameParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceSetName_Call) Return(_a0 *organization_service.OrganizationServiceSetNameOK, _a1 error) *MockClientService_OrganizationServiceSetName_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceSetName_Call) RunAndReturn(run func(*organization_service.OrganizationServiceSetNameParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceSetNameOK, error)) *MockClientService_OrganizationServiceSetName_Call { + _c.Call.Return(run) + return _c +} + +// OrganizationServiceTestIamPermissions provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) OrganizationServiceTestIamPermissions(params *organization_service.OrganizationServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption) (*organization_service.OrganizationServiceTestIamPermissionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OrganizationServiceTestIamPermissions") + } + + var r0 *organization_service.OrganizationServiceTestIamPermissionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceTestIamPermissionsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*organization_service.OrganizationServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) *organization_service.OrganizationServiceTestIamPermissionsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*organization_service.OrganizationServiceTestIamPermissionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*organization_service.OrganizationServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_OrganizationServiceTestIamPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OrganizationServiceTestIamPermissions' +type MockClientService_OrganizationServiceTestIamPermissions_Call struct { + *mock.Call +} + +// OrganizationServiceTestIamPermissions is a helper method to define mock.On call +// - params *organization_service.OrganizationServiceTestIamPermissionsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...organization_service.ClientOption +func (_e *MockClientService_Expecter) OrganizationServiceTestIamPermissions(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_OrganizationServiceTestIamPermissions_Call { + return &MockClientService_OrganizationServiceTestIamPermissions_Call{Call: _e.mock.On("OrganizationServiceTestIamPermissions", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_OrganizationServiceTestIamPermissions_Call) Run(run func(params *organization_service.OrganizationServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...organization_service.ClientOption)) *MockClientService_OrganizationServiceTestIamPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]organization_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(organization_service.ClientOption) + } + } + run(args[0].(*organization_service.OrganizationServiceTestIamPermissionsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_OrganizationServiceTestIamPermissions_Call) Return(_a0 *organization_service.OrganizationServiceTestIamPermissionsOK, _a1 error) *MockClientService_OrganizationServiceTestIamPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_OrganizationServiceTestIamPermissions_Call) RunAndReturn(run func(*organization_service.OrganizationServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...organization_service.ClientOption) (*organization_service.OrganizationServiceTestIamPermissionsOK, error)) *MockClientService_OrganizationServiceTestIamPermissions_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientOption.go new file mode 100644 index 00000000..c103c358 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientOption.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_project_service + +import ( + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientService.go new file mode 100644 index 00000000..cd5f1e98 --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service/mock_ClientService.go @@ -0,0 +1,809 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_project_service + +import ( + runtime "github.com/go-openapi/runtime" + project_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/project_service" + mock "github.com/stretchr/testify/mock" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// ProjectServiceCreate provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceCreate(params *project_service.ProjectServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceCreateOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceCreate") + } + + var r0 *project_service.ProjectServiceCreateOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceCreateParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceCreateOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceCreateParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceCreateOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceCreateOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceCreateParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceCreate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceCreate' +type MockClientService_ProjectServiceCreate_Call struct { + *mock.Call +} + +// ProjectServiceCreate is a helper method to define mock.On call +// - params *project_service.ProjectServiceCreateParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceCreate(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceCreate_Call { + return &MockClientService_ProjectServiceCreate_Call{Call: _e.mock.On("ProjectServiceCreate", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceCreate_Call) Run(run func(params *project_service.ProjectServiceCreateParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceCreate_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceCreateParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceCreate_Call) Return(_a0 *project_service.ProjectServiceCreateOK, _a1 error) *MockClientService_ProjectServiceCreate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceCreate_Call) RunAndReturn(run func(*project_service.ProjectServiceCreateParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceCreateOK, error)) *MockClientService_ProjectServiceCreate_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceDelete provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceDelete(params *project_service.ProjectServiceDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceDeleteOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceDelete") + } + + var r0 *project_service.ProjectServiceDeleteOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceDeleteParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceDeleteOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceDeleteParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceDeleteOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceDeleteOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceDeleteParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceDelete' +type MockClientService_ProjectServiceDelete_Call struct { + *mock.Call +} + +// ProjectServiceDelete is a helper method to define mock.On call +// - params *project_service.ProjectServiceDeleteParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceDelete(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceDelete_Call { + return &MockClientService_ProjectServiceDelete_Call{Call: _e.mock.On("ProjectServiceDelete", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceDelete_Call) Run(run func(params *project_service.ProjectServiceDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceDelete_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceDeleteParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceDelete_Call) Return(_a0 *project_service.ProjectServiceDeleteOK, _a1 error) *MockClientService_ProjectServiceDelete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceDelete_Call) RunAndReturn(run func(*project_service.ProjectServiceDeleteParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceDeleteOK, error)) *MockClientService_ProjectServiceDelete_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceGet provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceGet(params *project_service.ProjectServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceGetOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceGet") + } + + var r0 *project_service.ProjectServiceGetOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceGetOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceGetOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceGetParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceGet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceGet' +type MockClientService_ProjectServiceGet_Call struct { + *mock.Call +} + +// ProjectServiceGet is a helper method to define mock.On call +// - params *project_service.ProjectServiceGetParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceGet(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceGet_Call { + return &MockClientService_ProjectServiceGet_Call{Call: _e.mock.On("ProjectServiceGet", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceGet_Call) Run(run func(params *project_service.ProjectServiceGetParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceGet_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceGetParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceGet_Call) Return(_a0 *project_service.ProjectServiceGetOK, _a1 error) *MockClientService_ProjectServiceGet_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceGet_Call) RunAndReturn(run func(*project_service.ProjectServiceGetParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetOK, error)) *MockClientService_ProjectServiceGet_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceGetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceGetIamPolicy(params *project_service.ProjectServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceGetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceGetIamPolicy") + } + + var r0 *project_service.ProjectServiceGetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceGetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceGetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceGetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceGetIamPolicy' +type MockClientService_ProjectServiceGetIamPolicy_Call struct { + *mock.Call +} + +// ProjectServiceGetIamPolicy is a helper method to define mock.On call +// - params *project_service.ProjectServiceGetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceGetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceGetIamPolicy_Call { + return &MockClientService_ProjectServiceGetIamPolicy_Call{Call: _e.mock.On("ProjectServiceGetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceGetIamPolicy_Call) Run(run func(params *project_service.ProjectServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceGetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceGetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceGetIamPolicy_Call) Return(_a0 *project_service.ProjectServiceGetIamPolicyOK, _a1 error) *MockClientService_ProjectServiceGetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceGetIamPolicy_Call) RunAndReturn(run func(*project_service.ProjectServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetIamPolicyOK, error)) *MockClientService_ProjectServiceGetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceGetProjectsCount provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceGetProjectsCount(params *project_service.ProjectServiceGetProjectsCountParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceGetProjectsCountOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceGetProjectsCount") + } + + var r0 *project_service.ProjectServiceGetProjectsCountOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetProjectsCountParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetProjectsCountOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceGetProjectsCountParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceGetProjectsCountOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceGetProjectsCountOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceGetProjectsCountParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceGetProjectsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceGetProjectsCount' +type MockClientService_ProjectServiceGetProjectsCount_Call struct { + *mock.Call +} + +// ProjectServiceGetProjectsCount is a helper method to define mock.On call +// - params *project_service.ProjectServiceGetProjectsCountParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceGetProjectsCount(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceGetProjectsCount_Call { + return &MockClientService_ProjectServiceGetProjectsCount_Call{Call: _e.mock.On("ProjectServiceGetProjectsCount", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceGetProjectsCount_Call) Run(run func(params *project_service.ProjectServiceGetProjectsCountParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceGetProjectsCount_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceGetProjectsCountParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceGetProjectsCount_Call) Return(_a0 *project_service.ProjectServiceGetProjectsCountOK, _a1 error) *MockClientService_ProjectServiceGetProjectsCount_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceGetProjectsCount_Call) RunAndReturn(run func(*project_service.ProjectServiceGetProjectsCountParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceGetProjectsCountOK, error)) *MockClientService_ProjectServiceGetProjectsCount_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceList provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceList(params *project_service.ProjectServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceListOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceList") + } + + var r0 *project_service.ProjectServiceListOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceListParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceListOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceListParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceListOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceListOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceListParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceList' +type MockClientService_ProjectServiceList_Call struct { + *mock.Call +} + +// ProjectServiceList is a helper method to define mock.On call +// - params *project_service.ProjectServiceListParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceList(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceList_Call { + return &MockClientService_ProjectServiceList_Call{Call: _e.mock.On("ProjectServiceList", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceList_Call) Run(run func(params *project_service.ProjectServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceListParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceList_Call) Return(_a0 *project_service.ProjectServiceListOK, _a1 error) *MockClientService_ProjectServiceList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceList_Call) RunAndReturn(run func(*project_service.ProjectServiceListParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceListOK, error)) *MockClientService_ProjectServiceList_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceSetDescription provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceSetDescription(params *project_service.ProjectServiceSetDescriptionParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceSetDescriptionOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceSetDescription") + } + + var r0 *project_service.ProjectServiceSetDescriptionOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetDescriptionParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetDescriptionOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetDescriptionParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceSetDescriptionOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceSetDescriptionOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceSetDescriptionParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceSetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceSetDescription' +type MockClientService_ProjectServiceSetDescription_Call struct { + *mock.Call +} + +// ProjectServiceSetDescription is a helper method to define mock.On call +// - params *project_service.ProjectServiceSetDescriptionParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceSetDescription(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceSetDescription_Call { + return &MockClientService_ProjectServiceSetDescription_Call{Call: _e.mock.On("ProjectServiceSetDescription", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceSetDescription_Call) Run(run func(params *project_service.ProjectServiceSetDescriptionParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceSetDescription_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceSetDescriptionParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceSetDescription_Call) Return(_a0 *project_service.ProjectServiceSetDescriptionOK, _a1 error) *MockClientService_ProjectServiceSetDescription_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceSetDescription_Call) RunAndReturn(run func(*project_service.ProjectServiceSetDescriptionParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetDescriptionOK, error)) *MockClientService_ProjectServiceSetDescription_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceSetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceSetIamPolicy(params *project_service.ProjectServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceSetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceSetIamPolicy") + } + + var r0 *project_service.ProjectServiceSetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceSetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceSetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceSetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceSetIamPolicy' +type MockClientService_ProjectServiceSetIamPolicy_Call struct { + *mock.Call +} + +// ProjectServiceSetIamPolicy is a helper method to define mock.On call +// - params *project_service.ProjectServiceSetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceSetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceSetIamPolicy_Call { + return &MockClientService_ProjectServiceSetIamPolicy_Call{Call: _e.mock.On("ProjectServiceSetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceSetIamPolicy_Call) Run(run func(params *project_service.ProjectServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceSetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceSetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceSetIamPolicy_Call) Return(_a0 *project_service.ProjectServiceSetIamPolicyOK, _a1 error) *MockClientService_ProjectServiceSetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceSetIamPolicy_Call) RunAndReturn(run func(*project_service.ProjectServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetIamPolicyOK, error)) *MockClientService_ProjectServiceSetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceSetName provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceSetName(params *project_service.ProjectServiceSetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceSetNameOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceSetName") + } + + var r0 *project_service.ProjectServiceSetNameOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetNameParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetNameOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceSetNameParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceSetNameOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceSetNameOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceSetNameParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceSetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceSetName' +type MockClientService_ProjectServiceSetName_Call struct { + *mock.Call +} + +// ProjectServiceSetName is a helper method to define mock.On call +// - params *project_service.ProjectServiceSetNameParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceSetName(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceSetName_Call { + return &MockClientService_ProjectServiceSetName_Call{Call: _e.mock.On("ProjectServiceSetName", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceSetName_Call) Run(run func(params *project_service.ProjectServiceSetNameParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceSetName_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceSetNameParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceSetName_Call) Return(_a0 *project_service.ProjectServiceSetNameOK, _a1 error) *MockClientService_ProjectServiceSetName_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceSetName_Call) RunAndReturn(run func(*project_service.ProjectServiceSetNameParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceSetNameOK, error)) *MockClientService_ProjectServiceSetName_Call { + _c.Call.Return(run) + return _c +} + +// ProjectServiceTestIamPermissions provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ProjectServiceTestIamPermissions(params *project_service.ProjectServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption) (*project_service.ProjectServiceTestIamPermissionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ProjectServiceTestIamPermissions") + } + + var r0 *project_service.ProjectServiceTestIamPermissionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceTestIamPermissionsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*project_service.ProjectServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) *project_service.ProjectServiceTestIamPermissionsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*project_service.ProjectServiceTestIamPermissionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*project_service.ProjectServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ProjectServiceTestIamPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProjectServiceTestIamPermissions' +type MockClientService_ProjectServiceTestIamPermissions_Call struct { + *mock.Call +} + +// ProjectServiceTestIamPermissions is a helper method to define mock.On call +// - params *project_service.ProjectServiceTestIamPermissionsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...project_service.ClientOption +func (_e *MockClientService_Expecter) ProjectServiceTestIamPermissions(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ProjectServiceTestIamPermissions_Call { + return &MockClientService_ProjectServiceTestIamPermissions_Call{Call: _e.mock.On("ProjectServiceTestIamPermissions", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ProjectServiceTestIamPermissions_Call) Run(run func(params *project_service.ProjectServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...project_service.ClientOption)) *MockClientService_ProjectServiceTestIamPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]project_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(project_service.ClientOption) + } + } + run(args[0].(*project_service.ProjectServiceTestIamPermissionsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ProjectServiceTestIamPermissions_Call) Return(_a0 *project_service.ProjectServiceTestIamPermissionsOK, _a1 error) *MockClientService_ProjectServiceTestIamPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ProjectServiceTestIamPermissions_Call) RunAndReturn(run func(*project_service.ProjectServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...project_service.ClientOption) (*project_service.ProjectServiceTestIamPermissionsOK, error)) *MockClientService_ProjectServiceTestIamPermissions_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientOption.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientOption.go new file mode 100644 index 00000000..eddcbd7b --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientOption.go @@ -0,0 +1,69 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_resource_service + +import ( + mock "github.com/stretchr/testify/mock" + + runtime "github.com/go-openapi/runtime" +) + +// MockClientOption is an autogenerated mock type for the ClientOption type +type MockClientOption struct { + mock.Mock +} + +type MockClientOption_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientOption) EXPECT() *MockClientOption_Expecter { + return &MockClientOption_Expecter{mock: &_m.Mock} +} + +// Execute provides a mock function with given fields: _a0 +func (_m *MockClientOption) Execute(_a0 *runtime.ClientOperation) { + _m.Called(_a0) +} + +// MockClientOption_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute' +type MockClientOption_Execute_Call struct { + *mock.Call +} + +// Execute is a helper method to define mock.On call +// - _a0 *runtime.ClientOperation +func (_e *MockClientOption_Expecter) Execute(_a0 interface{}) *MockClientOption_Execute_Call { + return &MockClientOption_Execute_Call{Call: _e.mock.On("Execute", _a0)} +} + +func (_c *MockClientOption_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*runtime.ClientOperation)) + }) + return _c +} + +func (_c *MockClientOption_Execute_Call) Return() *MockClientOption_Execute_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientOption_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_Execute_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientOption creates a new instance of MockClientOption. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientOption(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientOption { + mock := &MockClientOption{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientService.go b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientService.go new file mode 100644 index 00000000..75c0727e --- /dev/null +++ b/internal/pkg/api/mocks/github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service/mock_ClientService.go @@ -0,0 +1,365 @@ +// Code generated by mockery. DO NOT EDIT. + +package mock_resource_service + +import ( + runtime "github.com/go-openapi/runtime" + resource_service "github.com/hashicorp/hcp-sdk-go/clients/cloud-resource-manager/stable/2019-12-10/client/resource_service" + mock "github.com/stretchr/testify/mock" +) + +// MockClientService is an autogenerated mock type for the ClientService type +type MockClientService struct { + mock.Mock +} + +type MockClientService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClientService) EXPECT() *MockClientService_Expecter { + return &MockClientService_Expecter{mock: &_m.Mock} +} + +// ResourceServiceGetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ResourceServiceGetIamPolicy(params *resource_service.ResourceServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption) (*resource_service.ResourceServiceGetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ResourceServiceGetIamPolicy") + } + + var r0 *resource_service.ResourceServiceGetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceGetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) *resource_service.ResourceServiceGetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*resource_service.ResourceServiceGetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*resource_service.ResourceServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ResourceServiceGetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceServiceGetIamPolicy' +type MockClientService_ResourceServiceGetIamPolicy_Call struct { + *mock.Call +} + +// ResourceServiceGetIamPolicy is a helper method to define mock.On call +// - params *resource_service.ResourceServiceGetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...resource_service.ClientOption +func (_e *MockClientService_Expecter) ResourceServiceGetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ResourceServiceGetIamPolicy_Call { + return &MockClientService_ResourceServiceGetIamPolicy_Call{Call: _e.mock.On("ResourceServiceGetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ResourceServiceGetIamPolicy_Call) Run(run func(params *resource_service.ResourceServiceGetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption)) *MockClientService_ResourceServiceGetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]resource_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(resource_service.ClientOption) + } + } + run(args[0].(*resource_service.ResourceServiceGetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ResourceServiceGetIamPolicy_Call) Return(_a0 *resource_service.ResourceServiceGetIamPolicyOK, _a1 error) *MockClientService_ResourceServiceGetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ResourceServiceGetIamPolicy_Call) RunAndReturn(run func(*resource_service.ResourceServiceGetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceGetIamPolicyOK, error)) *MockClientService_ResourceServiceGetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// ResourceServiceList provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ResourceServiceList(params *resource_service.ResourceServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption) (*resource_service.ResourceServiceListOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ResourceServiceList") + } + + var r0 *resource_service.ResourceServiceListOK + var r1 error + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceListParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceListOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceListParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) *resource_service.ResourceServiceListOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*resource_service.ResourceServiceListOK) + } + } + + if rf, ok := ret.Get(1).(func(*resource_service.ResourceServiceListParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ResourceServiceList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceServiceList' +type MockClientService_ResourceServiceList_Call struct { + *mock.Call +} + +// ResourceServiceList is a helper method to define mock.On call +// - params *resource_service.ResourceServiceListParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...resource_service.ClientOption +func (_e *MockClientService_Expecter) ResourceServiceList(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ResourceServiceList_Call { + return &MockClientService_ResourceServiceList_Call{Call: _e.mock.On("ResourceServiceList", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ResourceServiceList_Call) Run(run func(params *resource_service.ResourceServiceListParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption)) *MockClientService_ResourceServiceList_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]resource_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(resource_service.ClientOption) + } + } + run(args[0].(*resource_service.ResourceServiceListParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ResourceServiceList_Call) Return(_a0 *resource_service.ResourceServiceListOK, _a1 error) *MockClientService_ResourceServiceList_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ResourceServiceList_Call) RunAndReturn(run func(*resource_service.ResourceServiceListParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceListOK, error)) *MockClientService_ResourceServiceList_Call { + _c.Call.Return(run) + return _c +} + +// ResourceServiceSetIamPolicy provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ResourceServiceSetIamPolicy(params *resource_service.ResourceServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption) (*resource_service.ResourceServiceSetIamPolicyOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ResourceServiceSetIamPolicy") + } + + var r0 *resource_service.ResourceServiceSetIamPolicyOK + var r1 error + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceSetIamPolicyOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) *resource_service.ResourceServiceSetIamPolicyOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*resource_service.ResourceServiceSetIamPolicyOK) + } + } + + if rf, ok := ret.Get(1).(func(*resource_service.ResourceServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ResourceServiceSetIamPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceServiceSetIamPolicy' +type MockClientService_ResourceServiceSetIamPolicy_Call struct { + *mock.Call +} + +// ResourceServiceSetIamPolicy is a helper method to define mock.On call +// - params *resource_service.ResourceServiceSetIamPolicyParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...resource_service.ClientOption +func (_e *MockClientService_Expecter) ResourceServiceSetIamPolicy(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ResourceServiceSetIamPolicy_Call { + return &MockClientService_ResourceServiceSetIamPolicy_Call{Call: _e.mock.On("ResourceServiceSetIamPolicy", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ResourceServiceSetIamPolicy_Call) Run(run func(params *resource_service.ResourceServiceSetIamPolicyParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption)) *MockClientService_ResourceServiceSetIamPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]resource_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(resource_service.ClientOption) + } + } + run(args[0].(*resource_service.ResourceServiceSetIamPolicyParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ResourceServiceSetIamPolicy_Call) Return(_a0 *resource_service.ResourceServiceSetIamPolicyOK, _a1 error) *MockClientService_ResourceServiceSetIamPolicy_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ResourceServiceSetIamPolicy_Call) RunAndReturn(run func(*resource_service.ResourceServiceSetIamPolicyParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceSetIamPolicyOK, error)) *MockClientService_ResourceServiceSetIamPolicy_Call { + _c.Call.Return(run) + return _c +} + +// ResourceServiceTestIamPermissions provides a mock function with given fields: params, authInfo, opts +func (_m *MockClientService) ResourceServiceTestIamPermissions(params *resource_service.ResourceServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption) (*resource_service.ResourceServiceTestIamPermissionsOK, error) { + _va := make([]interface{}, len(opts)) + for _i := range opts { + _va[_i] = opts[_i] + } + var _ca []interface{} + _ca = append(_ca, params, authInfo) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ResourceServiceTestIamPermissions") + } + + var r0 *resource_service.ResourceServiceTestIamPermissionsOK + var r1 error + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceTestIamPermissionsOK, error)); ok { + return rf(params, authInfo, opts...) + } + if rf, ok := ret.Get(0).(func(*resource_service.ResourceServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) *resource_service.ResourceServiceTestIamPermissionsOK); ok { + r0 = rf(params, authInfo, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*resource_service.ResourceServiceTestIamPermissionsOK) + } + } + + if rf, ok := ret.Get(1).(func(*resource_service.ResourceServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) error); ok { + r1 = rf(params, authInfo, opts...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClientService_ResourceServiceTestIamPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceServiceTestIamPermissions' +type MockClientService_ResourceServiceTestIamPermissions_Call struct { + *mock.Call +} + +// ResourceServiceTestIamPermissions is a helper method to define mock.On call +// - params *resource_service.ResourceServiceTestIamPermissionsParams +// - authInfo runtime.ClientAuthInfoWriter +// - opts ...resource_service.ClientOption +func (_e *MockClientService_Expecter) ResourceServiceTestIamPermissions(params interface{}, authInfo interface{}, opts ...interface{}) *MockClientService_ResourceServiceTestIamPermissions_Call { + return &MockClientService_ResourceServiceTestIamPermissions_Call{Call: _e.mock.On("ResourceServiceTestIamPermissions", + append([]interface{}{params, authInfo}, opts...)...)} +} + +func (_c *MockClientService_ResourceServiceTestIamPermissions_Call) Run(run func(params *resource_service.ResourceServiceTestIamPermissionsParams, authInfo runtime.ClientAuthInfoWriter, opts ...resource_service.ClientOption)) *MockClientService_ResourceServiceTestIamPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]resource_service.ClientOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(resource_service.ClientOption) + } + } + run(args[0].(*resource_service.ResourceServiceTestIamPermissionsParams), args[1].(runtime.ClientAuthInfoWriter), variadicArgs...) + }) + return _c +} + +func (_c *MockClientService_ResourceServiceTestIamPermissions_Call) Return(_a0 *resource_service.ResourceServiceTestIamPermissionsOK, _a1 error) *MockClientService_ResourceServiceTestIamPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClientService_ResourceServiceTestIamPermissions_Call) RunAndReturn(run func(*resource_service.ResourceServiceTestIamPermissionsParams, runtime.ClientAuthInfoWriter, ...resource_service.ClientOption) (*resource_service.ResourceServiceTestIamPermissionsOK, error)) *MockClientService_ResourceServiceTestIamPermissions_Call { + _c.Call.Return(run) + return _c +} + +// SetTransport provides a mock function with given fields: transport +func (_m *MockClientService) SetTransport(transport runtime.ClientTransport) { + _m.Called(transport) +} + +// MockClientService_SetTransport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTransport' +type MockClientService_SetTransport_Call struct { + *mock.Call +} + +// SetTransport is a helper method to define mock.On call +// - transport runtime.ClientTransport +func (_e *MockClientService_Expecter) SetTransport(transport interface{}) *MockClientService_SetTransport_Call { + return &MockClientService_SetTransport_Call{Call: _e.mock.On("SetTransport", transport)} +} + +func (_c *MockClientService_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(runtime.ClientTransport)) + }) + return _c +} + +func (_c *MockClientService_SetTransport_Call) Return() *MockClientService_SetTransport_Call { + _c.Call.Return() + return _c +} + +func (_c *MockClientService_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_SetTransport_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClientService creates a new instance of MockClientService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClientService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClientService { + mock := &MockClientService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}