From 2ca221f8419406b726861d77217d4d8dfa5099aa Mon Sep 17 00:00:00 2001 From: David Liu Date: Tue, 7 Jul 2026 15:02:57 -0400 Subject: [PATCH 1/4] Add connectivity rule support for azure --- go.mod | 2 +- go.sum | 4 +- internal/cloudservice/mock/mock.go | 1443 +++++++++++++++-- temporalcloudcli/commands.connectivity.go | 34 +- .../commands.connectivity_test.go | 40 + temporalcloudcli/commands.gen.go | 15 +- temporalcloudcli/commands.yml | 20 +- 7 files changed, 1428 insertions(+), 130 deletions(-) diff --git a/go.mod b/go.mod index bb5c9bb..b996c3a 100644 --- a/go.mod +++ b/go.mod @@ -14,7 +14,7 @@ require ( github.com/stretchr/testify v1.11.1 github.com/temporalio/cli/cliext v0.0.0-20260602200703-8bb57b77ad55 go.temporal.io/api v1.62.13 - go.temporal.io/cloud-sdk v0.13.0 + go.temporal.io/cloud-sdk v0.15.0 go.temporal.io/sdk v1.44.1 go.temporal.io/sdk/contrib/envconfig v1.0.0 golang.org/x/oauth2 v0.36.0 diff --git a/go.sum b/go.sum index 68dd564..2116e89 100644 --- a/go.sum +++ b/go.sum @@ -154,8 +154,8 @@ go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09 go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0= go.temporal.io/api v1.62.13 h1:xMa8Nt5oAMX+LvlCJA44wjTCc1H09i2rG9poB1/xvH4= go.temporal.io/api v1.62.13/go.mod h1:0k75tRljEuELWGeXjEZZO7zYqBln4+1FrG6+IMOMy7Q= -go.temporal.io/cloud-sdk v0.13.0 h1:Yhh6TEQG7xZgn8/A7C9WcxM+LS08qXlITRicuo2zGOA= -go.temporal.io/cloud-sdk v0.13.0/go.mod h1:W2O9t9tvo3Q/LhGgYdj8JijWbN5C84os+cz/BadIHYI= +go.temporal.io/cloud-sdk v0.15.0 h1:TwlGhTVnF7d9uIP5wjV/vr7TBYsPEpJw/MNuiylX3DQ= +go.temporal.io/cloud-sdk v0.15.0/go.mod h1:W2O9t9tvo3Q/LhGgYdj8JijWbN5C84os+cz/BadIHYI= go.temporal.io/sdk v1.44.1 h1:Mt2OZLZpqkzDIdg9YyQzO0Rb/HqCDnnqHlIAGAJ5gqM= go.temporal.io/sdk v1.44.1/go.mod h1:vkApR12F9/Y8OR+hkxe7WyXQFuCX6clhzqnAk6rzDAM= go.temporal.io/sdk/contrib/envconfig v1.0.0 h1:1Q/swVgB4EW/p3k7rI9/4hpU4/DC57FSRbU90+UisXw= diff --git a/internal/cloudservice/mock/mock.go b/internal/cloudservice/mock/mock.go index c9d047c..fae37de 100644 --- a/internal/cloudservice/mock/mock.go +++ b/internal/cloudservice/mock/mock.go @@ -869,6 +869,89 @@ func (_c *MockCloudServiceClient_CreateNexusEndpoint_Call) RunAndReturn(run func return _c } +// CreateProject provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) CreateProject(ctx context.Context, in *cloudservice.CreateProjectRequest, opts ...grpc.CallOption) (*cloudservice.CreateProjectResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CreateProject") + } + + var r0 *cloudservice.CreateProjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.CreateProjectRequest, ...grpc.CallOption) (*cloudservice.CreateProjectResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.CreateProjectRequest, ...grpc.CallOption) *cloudservice.CreateProjectResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.CreateProjectResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.CreateProjectRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_CreateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProject' +type MockCloudServiceClient_CreateProject_Call struct { + *mock.Call +} + +// CreateProject is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.CreateProjectRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) CreateProject(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_CreateProject_Call { + return &MockCloudServiceClient_CreateProject_Call{Call: _e.mock.On("CreateProject", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_CreateProject_Call) Run(run func(ctx context.Context, in *cloudservice.CreateProjectRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_CreateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.CreateProjectRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.CreateProjectRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_CreateProject_Call) Return(createProjectResponse *cloudservice.CreateProjectResponse, err error) *MockCloudServiceClient_CreateProject_Call { + _c.Call.Return(createProjectResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_CreateProject_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.CreateProjectRequest, opts ...grpc.CallOption) (*cloudservice.CreateProjectResponse, error)) *MockCloudServiceClient_CreateProject_Call { + _c.Call.Return(run) + return _c +} + // CreateServiceAccount provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) CreateServiceAccount(ctx context.Context, in *cloudservice.CreateServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.CreateServiceAccountResponse, error) { var tmpRet mock.Arguments @@ -1782,6 +1865,89 @@ func (_c *MockCloudServiceClient_DeleteNexusEndpoint_Call) RunAndReturn(run func return _c } +// DeleteProject provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) DeleteProject(ctx context.Context, in *cloudservice.DeleteProjectRequest, opts ...grpc.CallOption) (*cloudservice.DeleteProjectResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteProject") + } + + var r0 *cloudservice.DeleteProjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.DeleteProjectRequest, ...grpc.CallOption) (*cloudservice.DeleteProjectResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.DeleteProjectRequest, ...grpc.CallOption) *cloudservice.DeleteProjectResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.DeleteProjectResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.DeleteProjectRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_DeleteProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteProject' +type MockCloudServiceClient_DeleteProject_Call struct { + *mock.Call +} + +// DeleteProject is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.DeleteProjectRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) DeleteProject(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_DeleteProject_Call { + return &MockCloudServiceClient_DeleteProject_Call{Call: _e.mock.On("DeleteProject", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_DeleteProject_Call) Run(run func(ctx context.Context, in *cloudservice.DeleteProjectRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_DeleteProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.DeleteProjectRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.DeleteProjectRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_DeleteProject_Call) Return(deleteProjectResponse *cloudservice.DeleteProjectResponse, err error) *MockCloudServiceClient_DeleteProject_Call { + _c.Call.Return(deleteProjectResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_DeleteProject_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.DeleteProjectRequest, opts ...grpc.CallOption) (*cloudservice.DeleteProjectResponse, error)) *MockCloudServiceClient_DeleteProject_Call { + _c.Call.Return(run) + return _c +} + // DeleteServiceAccount provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) DeleteServiceAccount(ctx context.Context, in *cloudservice.DeleteServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.DeleteServiceAccountResponse, error) { var tmpRet mock.Arguments @@ -3774,8 +3940,8 @@ func (_c *MockCloudServiceClient_GetNexusEndpoints_Call) RunAndReturn(run func(c return _c } -// GetRegion provides a mock function for the type MockCloudServiceClient -func (_mock *MockCloudServiceClient) GetRegion(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionResponse, error) { +// GetProject provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetProject(ctx context.Context, in *cloudservice.GetProjectRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectResponse, error) { var tmpRet mock.Arguments if len(opts) > 0 { tmpRet = _mock.Called(ctx, in, opts) @@ -3785,22 +3951,22 @@ func (_mock *MockCloudServiceClient) GetRegion(ctx context.Context, in *cloudser ret := tmpRet if len(ret) == 0 { - panic("no return value specified for GetRegion") + panic("no return value specified for GetProject") } - var r0 *cloudservice.GetRegionResponse + var r0 *cloudservice.GetProjectResponse var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) (*cloudservice.GetRegionResponse, error)); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectRequest, ...grpc.CallOption) (*cloudservice.GetProjectResponse, error)); ok { return returnFunc(ctx, in, opts...) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) *cloudservice.GetRegionResponse); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectRequest, ...grpc.CallOption) *cloudservice.GetProjectResponse); ok { r0 = returnFunc(ctx, in, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cloudservice.GetRegionResponse) + r0 = ret.Get(0).(*cloudservice.GetProjectResponse) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) error); ok { + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetProjectRequest, ...grpc.CallOption) error); ok { r1 = returnFunc(ctx, in, opts...) } else { r1 = ret.Error(1) @@ -3808,29 +3974,29 @@ func (_mock *MockCloudServiceClient) GetRegion(ctx context.Context, in *cloudser return r0, r1 } -// MockCloudServiceClient_GetRegion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegion' -type MockCloudServiceClient_GetRegion_Call struct { +// MockCloudServiceClient_GetProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProject' +type MockCloudServiceClient_GetProject_Call struct { *mock.Call } -// GetRegion is a helper method to define mock.On call +// GetProject is a helper method to define mock.On call // - ctx context.Context -// - in *cloudservice.GetRegionRequest +// - in *cloudservice.GetProjectRequest // - opts ...grpc.CallOption -func (_e *MockCloudServiceClient_Expecter) GetRegion(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetRegion_Call { - return &MockCloudServiceClient_GetRegion_Call{Call: _e.mock.On("GetRegion", +func (_e *MockCloudServiceClient_Expecter) GetProject(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetProject_Call { + return &MockCloudServiceClient_GetProject_Call{Call: _e.mock.On("GetProject", append([]interface{}{ctx, in}, opts...)...)} } -func (_c *MockCloudServiceClient_GetRegion_Call) Run(run func(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetRegion_Call { +func (_c *MockCloudServiceClient_GetProject_Call) Run(run func(ctx context.Context, in *cloudservice.GetProjectRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetProject_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { arg0 = args[0].(context.Context) } - var arg1 *cloudservice.GetRegionRequest + var arg1 *cloudservice.GetProjectRequest if args[1] != nil { - arg1 = args[1].(*cloudservice.GetRegionRequest) + arg1 = args[1].(*cloudservice.GetProjectRequest) } var arg2 []grpc.CallOption var variadicArgs []grpc.CallOption @@ -3847,18 +4013,18 @@ func (_c *MockCloudServiceClient_GetRegion_Call) Run(run func(ctx context.Contex return _c } -func (_c *MockCloudServiceClient_GetRegion_Call) Return(getRegionResponse *cloudservice.GetRegionResponse, err error) *MockCloudServiceClient_GetRegion_Call { - _c.Call.Return(getRegionResponse, err) +func (_c *MockCloudServiceClient_GetProject_Call) Return(getProjectResponse *cloudservice.GetProjectResponse, err error) *MockCloudServiceClient_GetProject_Call { + _c.Call.Return(getProjectResponse, err) return _c } -func (_c *MockCloudServiceClient_GetRegion_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionResponse, error)) *MockCloudServiceClient_GetRegion_Call { +func (_c *MockCloudServiceClient_GetProject_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetProjectRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectResponse, error)) *MockCloudServiceClient_GetProject_Call { _c.Call.Return(run) return _c } -// GetRegions provides a mock function for the type MockCloudServiceClient -func (_mock *MockCloudServiceClient) GetRegions(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error) { +// GetProjectScopedServiceAccounts provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetProjectScopedServiceAccounts(ctx context.Context, in *cloudservice.GetProjectScopedServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectScopedServiceAccountsResponse, error) { var tmpRet mock.Arguments if len(opts) > 0 { tmpRet = _mock.Called(ctx, in, opts) @@ -3868,22 +4034,22 @@ func (_mock *MockCloudServiceClient) GetRegions(ctx context.Context, in *cloudse ret := tmpRet if len(ret) == 0 { - panic("no return value specified for GetRegions") + panic("no return value specified for GetProjectScopedServiceAccounts") } - var r0 *cloudservice.GetRegionsResponse + var r0 *cloudservice.GetProjectScopedServiceAccountsResponse var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error)); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectScopedServiceAccountsRequest, ...grpc.CallOption) (*cloudservice.GetProjectScopedServiceAccountsResponse, error)); ok { return returnFunc(ctx, in, opts...) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) *cloudservice.GetRegionsResponse); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectScopedServiceAccountsRequest, ...grpc.CallOption) *cloudservice.GetProjectScopedServiceAccountsResponse); ok { r0 = returnFunc(ctx, in, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cloudservice.GetRegionsResponse) + r0 = ret.Get(0).(*cloudservice.GetProjectScopedServiceAccountsResponse) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) error); ok { + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetProjectScopedServiceAccountsRequest, ...grpc.CallOption) error); ok { r1 = returnFunc(ctx, in, opts...) } else { r1 = ret.Error(1) @@ -3891,29 +4057,29 @@ func (_mock *MockCloudServiceClient) GetRegions(ctx context.Context, in *cloudse return r0, r1 } -// MockCloudServiceClient_GetRegions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegions' -type MockCloudServiceClient_GetRegions_Call struct { +// MockCloudServiceClient_GetProjectScopedServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjectScopedServiceAccounts' +type MockCloudServiceClient_GetProjectScopedServiceAccounts_Call struct { *mock.Call } -// GetRegions is a helper method to define mock.On call +// GetProjectScopedServiceAccounts is a helper method to define mock.On call // - ctx context.Context -// - in *cloudservice.GetRegionsRequest +// - in *cloudservice.GetProjectScopedServiceAccountsRequest // - opts ...grpc.CallOption -func (_e *MockCloudServiceClient_Expecter) GetRegions(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetRegions_Call { - return &MockCloudServiceClient_GetRegions_Call{Call: _e.mock.On("GetRegions", +func (_e *MockCloudServiceClient_Expecter) GetProjectScopedServiceAccounts(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call { + return &MockCloudServiceClient_GetProjectScopedServiceAccounts_Call{Call: _e.mock.On("GetProjectScopedServiceAccounts", append([]interface{}{ctx, in}, opts...)...)} } -func (_c *MockCloudServiceClient_GetRegions_Call) Run(run func(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetRegions_Call { +func (_c *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call) Run(run func(ctx context.Context, in *cloudservice.GetProjectScopedServiceAccountsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { arg0 = args[0].(context.Context) } - var arg1 *cloudservice.GetRegionsRequest + var arg1 *cloudservice.GetProjectScopedServiceAccountsRequest if args[1] != nil { - arg1 = args[1].(*cloudservice.GetRegionsRequest) + arg1 = args[1].(*cloudservice.GetProjectScopedServiceAccountsRequest) } var arg2 []grpc.CallOption var variadicArgs []grpc.CallOption @@ -3930,18 +4096,18 @@ func (_c *MockCloudServiceClient_GetRegions_Call) Run(run func(ctx context.Conte return _c } -func (_c *MockCloudServiceClient_GetRegions_Call) Return(getRegionsResponse *cloudservice.GetRegionsResponse, err error) *MockCloudServiceClient_GetRegions_Call { - _c.Call.Return(getRegionsResponse, err) +func (_c *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call) Return(getProjectScopedServiceAccountsResponse *cloudservice.GetProjectScopedServiceAccountsResponse, err error) *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call { + _c.Call.Return(getProjectScopedServiceAccountsResponse, err) return _c } -func (_c *MockCloudServiceClient_GetRegions_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error)) *MockCloudServiceClient_GetRegions_Call { +func (_c *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetProjectScopedServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectScopedServiceAccountsResponse, error)) *MockCloudServiceClient_GetProjectScopedServiceAccounts_Call { _c.Call.Return(run) return _c } -// GetServiceAccount provides a mock function for the type MockCloudServiceClient -func (_mock *MockCloudServiceClient) GetServiceAccount(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error) { +// GetProjects provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetProjects(ctx context.Context, in *cloudservice.GetProjectsRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectsResponse, error) { var tmpRet mock.Arguments if len(opts) > 0 { tmpRet = _mock.Called(ctx, in, opts) @@ -3951,22 +4117,22 @@ func (_mock *MockCloudServiceClient) GetServiceAccount(ctx context.Context, in * ret := tmpRet if len(ret) == 0 { - panic("no return value specified for GetServiceAccount") + panic("no return value specified for GetProjects") } - var r0 *cloudservice.GetServiceAccountResponse + var r0 *cloudservice.GetProjectsResponse var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error)); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectsRequest, ...grpc.CallOption) (*cloudservice.GetProjectsResponse, error)); ok { return returnFunc(ctx, in, opts...) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountResponse); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetProjectsRequest, ...grpc.CallOption) *cloudservice.GetProjectsResponse); ok { r0 = returnFunc(ctx, in, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cloudservice.GetServiceAccountResponse) + r0 = ret.Get(0).(*cloudservice.GetProjectsResponse) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) error); ok { + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetProjectsRequest, ...grpc.CallOption) error); ok { r1 = returnFunc(ctx, in, opts...) } else { r1 = ret.Error(1) @@ -3974,29 +4140,29 @@ func (_mock *MockCloudServiceClient) GetServiceAccount(ctx context.Context, in * return r0, r1 } -// MockCloudServiceClient_GetServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccount' -type MockCloudServiceClient_GetServiceAccount_Call struct { +// MockCloudServiceClient_GetProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProjects' +type MockCloudServiceClient_GetProjects_Call struct { *mock.Call } -// GetServiceAccount is a helper method to define mock.On call +// GetProjects is a helper method to define mock.On call // - ctx context.Context -// - in *cloudservice.GetServiceAccountRequest +// - in *cloudservice.GetProjectsRequest // - opts ...grpc.CallOption -func (_e *MockCloudServiceClient_Expecter) GetServiceAccount(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccount_Call { - return &MockCloudServiceClient_GetServiceAccount_Call{Call: _e.mock.On("GetServiceAccount", +func (_e *MockCloudServiceClient_Expecter) GetProjects(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetProjects_Call { + return &MockCloudServiceClient_GetProjects_Call{Call: _e.mock.On("GetProjects", append([]interface{}{ctx, in}, opts...)...)} } -func (_c *MockCloudServiceClient_GetServiceAccount_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccount_Call { +func (_c *MockCloudServiceClient_GetProjects_Call) Run(run func(ctx context.Context, in *cloudservice.GetProjectsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetProjects_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { arg0 = args[0].(context.Context) } - var arg1 *cloudservice.GetServiceAccountRequest + var arg1 *cloudservice.GetProjectsRequest if args[1] != nil { - arg1 = args[1].(*cloudservice.GetServiceAccountRequest) + arg1 = args[1].(*cloudservice.GetProjectsRequest) } var arg2 []grpc.CallOption var variadicArgs []grpc.CallOption @@ -4013,18 +4179,18 @@ func (_c *MockCloudServiceClient_GetServiceAccount_Call) Run(run func(ctx contex return _c } -func (_c *MockCloudServiceClient_GetServiceAccount_Call) Return(getServiceAccountResponse *cloudservice.GetServiceAccountResponse, err error) *MockCloudServiceClient_GetServiceAccount_Call { - _c.Call.Return(getServiceAccountResponse, err) +func (_c *MockCloudServiceClient_GetProjects_Call) Return(getProjectsResponse *cloudservice.GetProjectsResponse, err error) *MockCloudServiceClient_GetProjects_Call { + _c.Call.Return(getProjectsResponse, err) return _c } -func (_c *MockCloudServiceClient_GetServiceAccount_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error)) *MockCloudServiceClient_GetServiceAccount_Call { +func (_c *MockCloudServiceClient_GetProjects_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetProjectsRequest, opts ...grpc.CallOption) (*cloudservice.GetProjectsResponse, error)) *MockCloudServiceClient_GetProjects_Call { _c.Call.Return(run) return _c } -// GetServiceAccounts provides a mock function for the type MockCloudServiceClient -func (_mock *MockCloudServiceClient) GetServiceAccounts(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error) { +// GetRegion provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetRegion(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionResponse, error) { var tmpRet mock.Arguments if len(opts) > 0 { tmpRet = _mock.Called(ctx, in, opts) @@ -4034,22 +4200,22 @@ func (_mock *MockCloudServiceClient) GetServiceAccounts(ctx context.Context, in ret := tmpRet if len(ret) == 0 { - panic("no return value specified for GetServiceAccounts") + panic("no return value specified for GetRegion") } - var r0 *cloudservice.GetServiceAccountsResponse + var r0 *cloudservice.GetRegionResponse var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error)); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) (*cloudservice.GetRegionResponse, error)); ok { return returnFunc(ctx, in, opts...) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountsResponse); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) *cloudservice.GetRegionResponse); ok { r0 = returnFunc(ctx, in, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cloudservice.GetServiceAccountsResponse) + r0 = ret.Get(0).(*cloudservice.GetRegionResponse) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) error); ok { + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetRegionRequest, ...grpc.CallOption) error); ok { r1 = returnFunc(ctx, in, opts...) } else { r1 = ret.Error(1) @@ -4057,29 +4223,29 @@ func (_mock *MockCloudServiceClient) GetServiceAccounts(ctx context.Context, in return r0, r1 } -// MockCloudServiceClient_GetServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccounts' -type MockCloudServiceClient_GetServiceAccounts_Call struct { +// MockCloudServiceClient_GetRegion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegion' +type MockCloudServiceClient_GetRegion_Call struct { *mock.Call } -// GetServiceAccounts is a helper method to define mock.On call +// GetRegion is a helper method to define mock.On call // - ctx context.Context -// - in *cloudservice.GetServiceAccountsRequest +// - in *cloudservice.GetRegionRequest // - opts ...grpc.CallOption -func (_e *MockCloudServiceClient_Expecter) GetServiceAccounts(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccounts_Call { - return &MockCloudServiceClient_GetServiceAccounts_Call{Call: _e.mock.On("GetServiceAccounts", +func (_e *MockCloudServiceClient_Expecter) GetRegion(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetRegion_Call { + return &MockCloudServiceClient_GetRegion_Call{Call: _e.mock.On("GetRegion", append([]interface{}{ctx, in}, opts...)...)} } -func (_c *MockCloudServiceClient_GetServiceAccounts_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccounts_Call { +func (_c *MockCloudServiceClient_GetRegion_Call) Run(run func(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetRegion_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { arg0 = args[0].(context.Context) } - var arg1 *cloudservice.GetServiceAccountsRequest + var arg1 *cloudservice.GetRegionRequest if args[1] != nil { - arg1 = args[1].(*cloudservice.GetServiceAccountsRequest) + arg1 = args[1].(*cloudservice.GetRegionRequest) } var arg2 []grpc.CallOption var variadicArgs []grpc.CallOption @@ -4096,18 +4262,18 @@ func (_c *MockCloudServiceClient_GetServiceAccounts_Call) Run(run func(ctx conte return _c } -func (_c *MockCloudServiceClient_GetServiceAccounts_Call) Return(getServiceAccountsResponse *cloudservice.GetServiceAccountsResponse, err error) *MockCloudServiceClient_GetServiceAccounts_Call { - _c.Call.Return(getServiceAccountsResponse, err) +func (_c *MockCloudServiceClient_GetRegion_Call) Return(getRegionResponse *cloudservice.GetRegionResponse, err error) *MockCloudServiceClient_GetRegion_Call { + _c.Call.Return(getRegionResponse, err) return _c } -func (_c *MockCloudServiceClient_GetServiceAccounts_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error)) *MockCloudServiceClient_GetServiceAccounts_Call { +func (_c *MockCloudServiceClient_GetRegion_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetRegionRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionResponse, error)) *MockCloudServiceClient_GetRegion_Call { _c.Call.Return(run) return _c } -// GetUsage provides a mock function for the type MockCloudServiceClient -func (_mock *MockCloudServiceClient) GetUsage(ctx context.Context, in *cloudservice.GetUsageRequest, opts ...grpc.CallOption) (*cloudservice.GetUsageResponse, error) { +// GetRegions provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetRegions(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error) { var tmpRet mock.Arguments if len(opts) > 0 { tmpRet = _mock.Called(ctx, in, opts) @@ -4117,22 +4283,22 @@ func (_mock *MockCloudServiceClient) GetUsage(ctx context.Context, in *cloudserv ret := tmpRet if len(ret) == 0 { - panic("no return value specified for GetUsage") + panic("no return value specified for GetRegions") } - var r0 *cloudservice.GetUsageResponse + var r0 *cloudservice.GetRegionsResponse var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) (*cloudservice.GetUsageResponse, error)); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error)); ok { return returnFunc(ctx, in, opts...) } - if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) *cloudservice.GetUsageResponse); ok { + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) *cloudservice.GetRegionsResponse); ok { r0 = returnFunc(ctx, in, opts...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cloudservice.GetUsageResponse) + r0 = ret.Get(0).(*cloudservice.GetRegionsResponse) } } - if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) error); ok { + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetRegionsRequest, ...grpc.CallOption) error); ok { r1 = returnFunc(ctx, in, opts...) } else { r1 = ret.Error(1) @@ -4140,21 +4306,436 @@ func (_mock *MockCloudServiceClient) GetUsage(ctx context.Context, in *cloudserv return r0, r1 } -// MockCloudServiceClient_GetUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsage' -type MockCloudServiceClient_GetUsage_Call struct { +// MockCloudServiceClient_GetRegions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRegions' +type MockCloudServiceClient_GetRegions_Call struct { *mock.Call } -// GetUsage is a helper method to define mock.On call +// GetRegions is a helper method to define mock.On call // - ctx context.Context -// - in *cloudservice.GetUsageRequest +// - in *cloudservice.GetRegionsRequest // - opts ...grpc.CallOption -func (_e *MockCloudServiceClient_Expecter) GetUsage(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUsage_Call { - return &MockCloudServiceClient_GetUsage_Call{Call: _e.mock.On("GetUsage", +func (_e *MockCloudServiceClient_Expecter) GetRegions(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetRegions_Call { + return &MockCloudServiceClient_GetRegions_Call{Call: _e.mock.On("GetRegions", append([]interface{}{ctx, in}, opts...)...)} } -func (_c *MockCloudServiceClient_GetUsage_Call) Run(run func(ctx context.Context, in *cloudservice.GetUsageRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUsage_Call { +func (_c *MockCloudServiceClient_GetRegions_Call) Run(run func(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetRegions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetRegionsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetRegionsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetRegions_Call) Return(getRegionsResponse *cloudservice.GetRegionsResponse, err error) *MockCloudServiceClient_GetRegions_Call { + _c.Call.Return(getRegionsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetRegions_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetRegionsRequest, opts ...grpc.CallOption) (*cloudservice.GetRegionsResponse, error)) *MockCloudServiceClient_GetRegions_Call { + _c.Call.Return(run) + return _c +} + +// GetServiceAccount provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetServiceAccount(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetServiceAccount") + } + + var r0 *cloudservice.GetServiceAccountResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetServiceAccountResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccount' +type MockCloudServiceClient_GetServiceAccount_Call struct { + *mock.Call +} + +// GetServiceAccount is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetServiceAccountRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetServiceAccount(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccount_Call { + return &MockCloudServiceClient_GetServiceAccount_Call{Call: _e.mock.On("GetServiceAccount", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetServiceAccount_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetServiceAccountRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetServiceAccountRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccount_Call) Return(getServiceAccountResponse *cloudservice.GetServiceAccountResponse, err error) *MockCloudServiceClient_GetServiceAccount_Call { + _c.Call.Return(getServiceAccountResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccount_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountResponse, error)) *MockCloudServiceClient_GetServiceAccount_Call { + _c.Call.Return(run) + return _c +} + +// GetServiceAccountNamespaceAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetServiceAccountNamespaceAssignments(ctx context.Context, in *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountNamespaceAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetServiceAccountNamespaceAssignments") + } + + var r0 *cloudservice.GetServiceAccountNamespaceAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountNamespaceAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountNamespaceAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetServiceAccountNamespaceAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountNamespaceAssignments' +type MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call struct { + *mock.Call +} + +// GetServiceAccountNamespaceAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetServiceAccountNamespaceAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetServiceAccountNamespaceAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call { + return &MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call{Call: _e.mock.On("GetServiceAccountNamespaceAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetServiceAccountNamespaceAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetServiceAccountNamespaceAssignmentsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call) Return(getServiceAccountNamespaceAssignmentsResponse *cloudservice.GetServiceAccountNamespaceAssignmentsResponse, err error) *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call { + _c.Call.Return(getServiceAccountNamespaceAssignmentsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountNamespaceAssignmentsResponse, error)) *MockCloudServiceClient_GetServiceAccountNamespaceAssignments_Call { + _c.Call.Return(run) + return _c +} + +// GetServiceAccountProjectAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetServiceAccountProjectAssignments(ctx context.Context, in *cloudservice.GetServiceAccountProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountProjectAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetServiceAccountProjectAssignments") + } + + var r0 *cloudservice.GetServiceAccountProjectAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountProjectAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountProjectAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountProjectAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountProjectAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetServiceAccountProjectAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountProjectAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetServiceAccountProjectAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountProjectAssignments' +type MockCloudServiceClient_GetServiceAccountProjectAssignments_Call struct { + *mock.Call +} + +// GetServiceAccountProjectAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetServiceAccountProjectAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetServiceAccountProjectAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call { + return &MockCloudServiceClient_GetServiceAccountProjectAssignments_Call{Call: _e.mock.On("GetServiceAccountProjectAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountProjectAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetServiceAccountProjectAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetServiceAccountProjectAssignmentsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call) Return(getServiceAccountProjectAssignmentsResponse *cloudservice.GetServiceAccountProjectAssignmentsResponse, err error) *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call { + _c.Call.Return(getServiceAccountProjectAssignmentsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountProjectAssignmentsResponse, error)) *MockCloudServiceClient_GetServiceAccountProjectAssignments_Call { + _c.Call.Return(run) + return _c +} + +// GetServiceAccounts provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetServiceAccounts(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetServiceAccounts") + } + + var r0 *cloudservice.GetServiceAccountsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) *cloudservice.GetServiceAccountsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetServiceAccountsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetServiceAccountsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccounts' +type MockCloudServiceClient_GetServiceAccounts_Call struct { + *mock.Call +} + +// GetServiceAccounts is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetServiceAccountsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetServiceAccounts(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetServiceAccounts_Call { + return &MockCloudServiceClient_GetServiceAccounts_Call{Call: _e.mock.On("GetServiceAccounts", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetServiceAccounts_Call) Run(run func(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetServiceAccounts_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetServiceAccountsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetServiceAccountsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccounts_Call) Return(getServiceAccountsResponse *cloudservice.GetServiceAccountsResponse, err error) *MockCloudServiceClient_GetServiceAccounts_Call { + _c.Call.Return(getServiceAccountsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetServiceAccounts_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetServiceAccountsRequest, opts ...grpc.CallOption) (*cloudservice.GetServiceAccountsResponse, error)) *MockCloudServiceClient_GetServiceAccounts_Call { + _c.Call.Return(run) + return _c +} + +// GetUsage provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetUsage(ctx context.Context, in *cloudservice.GetUsageRequest, opts ...grpc.CallOption) (*cloudservice.GetUsageResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetUsage") + } + + var r0 *cloudservice.GetUsageResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) (*cloudservice.GetUsageResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) *cloudservice.GetUsageResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetUsageResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUsageRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsage' +type MockCloudServiceClient_GetUsage_Call struct { + *mock.Call +} + +// GetUsage is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetUsageRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetUsage(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUsage_Call { + return &MockCloudServiceClient_GetUsage_Call{Call: _e.mock.On("GetUsage", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetUsage_Call) Run(run func(ctx context.Context, in *cloudservice.GetUsageRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUsage_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { @@ -4438,6 +5019,172 @@ func (_c *MockCloudServiceClient_GetUserGroupMembers_Call) RunAndReturn(run func return _c } +// GetUserGroupNamespaceAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetUserGroupNamespaceAssignments(ctx context.Context, in *cloudservice.GetUserGroupNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupNamespaceAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetUserGroupNamespaceAssignments") + } + + var r0 *cloudservice.GetUserGroupNamespaceAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserGroupNamespaceAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetUserGroupNamespaceAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserGroupNamespaceAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetUserGroupNamespaceAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetUserGroupNamespaceAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUserGroupNamespaceAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserGroupNamespaceAssignments' +type MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call struct { + *mock.Call +} + +// GetUserGroupNamespaceAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetUserGroupNamespaceAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetUserGroupNamespaceAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call { + return &MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call{Call: _e.mock.On("GetUserGroupNamespaceAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetUserGroupNamespaceAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetUserGroupNamespaceAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetUserGroupNamespaceAssignmentsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call) Return(getUserGroupNamespaceAssignmentsResponse *cloudservice.GetUserGroupNamespaceAssignmentsResponse, err error) *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call { + _c.Call.Return(getUserGroupNamespaceAssignmentsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserGroupNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupNamespaceAssignmentsResponse, error)) *MockCloudServiceClient_GetUserGroupNamespaceAssignments_Call { + _c.Call.Return(run) + return _c +} + +// GetUserGroupProjectAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetUserGroupProjectAssignments(ctx context.Context, in *cloudservice.GetUserGroupProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupProjectAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetUserGroupProjectAssignments") + } + + var r0 *cloudservice.GetUserGroupProjectAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserGroupProjectAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetUserGroupProjectAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserGroupProjectAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetUserGroupProjectAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetUserGroupProjectAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUserGroupProjectAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetUserGroupProjectAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserGroupProjectAssignments' +type MockCloudServiceClient_GetUserGroupProjectAssignments_Call struct { + *mock.Call +} + +// GetUserGroupProjectAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetUserGroupProjectAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetUserGroupProjectAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUserGroupProjectAssignments_Call { + return &MockCloudServiceClient_GetUserGroupProjectAssignments_Call{Call: _e.mock.On("GetUserGroupProjectAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetUserGroupProjectAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetUserGroupProjectAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUserGroupProjectAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetUserGroupProjectAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetUserGroupProjectAssignmentsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroupProjectAssignments_Call) Return(getUserGroupProjectAssignmentsResponse *cloudservice.GetUserGroupProjectAssignmentsResponse, err error) *MockCloudServiceClient_GetUserGroupProjectAssignments_Call { + _c.Call.Return(getUserGroupProjectAssignmentsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroupProjectAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserGroupProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupProjectAssignmentsResponse, error)) *MockCloudServiceClient_GetUserGroupProjectAssignments_Call { + _c.Call.Return(run) + return _c +} + // GetUserGroups provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) GetUserGroups(ctx context.Context, in *cloudservice.GetUserGroupsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupsResponse, error) { var tmpRet mock.Arguments @@ -4494,7 +5241,173 @@ func (_c *MockCloudServiceClient_GetUserGroups_Call) Run(run func(ctx context.Co } var arg1 *cloudservice.GetUserGroupsRequest if args[1] != nil { - arg1 = args[1].(*cloudservice.GetUserGroupsRequest) + arg1 = args[1].(*cloudservice.GetUserGroupsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroups_Call) Return(getUserGroupsResponse *cloudservice.GetUserGroupsResponse, err error) *MockCloudServiceClient_GetUserGroups_Call { + _c.Call.Return(getUserGroupsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetUserGroups_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserGroupsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupsResponse, error)) *MockCloudServiceClient_GetUserGroups_Call { + _c.Call.Return(run) + return _c +} + +// GetUserNamespaceAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetUserNamespaceAssignments(ctx context.Context, in *cloudservice.GetUserNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserNamespaceAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetUserNamespaceAssignments") + } + + var r0 *cloudservice.GetUserNamespaceAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserNamespaceAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetUserNamespaceAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserNamespaceAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetUserNamespaceAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetUserNamespaceAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUserNamespaceAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetUserNamespaceAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserNamespaceAssignments' +type MockCloudServiceClient_GetUserNamespaceAssignments_Call struct { + *mock.Call +} + +// GetUserNamespaceAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetUserNamespaceAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetUserNamespaceAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUserNamespaceAssignments_Call { + return &MockCloudServiceClient_GetUserNamespaceAssignments_Call{Call: _e.mock.On("GetUserNamespaceAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetUserNamespaceAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetUserNamespaceAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUserNamespaceAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetUserNamespaceAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetUserNamespaceAssignmentsRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_GetUserNamespaceAssignments_Call) Return(getUserNamespaceAssignmentsResponse *cloudservice.GetUserNamespaceAssignmentsResponse, err error) *MockCloudServiceClient_GetUserNamespaceAssignments_Call { + _c.Call.Return(getUserNamespaceAssignmentsResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_GetUserNamespaceAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserNamespaceAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserNamespaceAssignmentsResponse, error)) *MockCloudServiceClient_GetUserNamespaceAssignments_Call { + _c.Call.Return(run) + return _c +} + +// GetUserProjectAssignments provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) GetUserProjectAssignments(ctx context.Context, in *cloudservice.GetUserProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserProjectAssignmentsResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetUserProjectAssignments") + } + + var r0 *cloudservice.GetUserProjectAssignmentsResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserProjectAssignmentsRequest, ...grpc.CallOption) (*cloudservice.GetUserProjectAssignmentsResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.GetUserProjectAssignmentsRequest, ...grpc.CallOption) *cloudservice.GetUserProjectAssignmentsResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.GetUserProjectAssignmentsResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.GetUserProjectAssignmentsRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_GetUserProjectAssignments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserProjectAssignments' +type MockCloudServiceClient_GetUserProjectAssignments_Call struct { + *mock.Call +} + +// GetUserProjectAssignments is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.GetUserProjectAssignmentsRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) GetUserProjectAssignments(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_GetUserProjectAssignments_Call { + return &MockCloudServiceClient_GetUserProjectAssignments_Call{Call: _e.mock.On("GetUserProjectAssignments", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_GetUserProjectAssignments_Call) Run(run func(ctx context.Context, in *cloudservice.GetUserProjectAssignmentsRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_GetUserProjectAssignments_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.GetUserProjectAssignmentsRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.GetUserProjectAssignmentsRequest) } var arg2 []grpc.CallOption var variadicArgs []grpc.CallOption @@ -4511,12 +5424,12 @@ func (_c *MockCloudServiceClient_GetUserGroups_Call) Run(run func(ctx context.Co return _c } -func (_c *MockCloudServiceClient_GetUserGroups_Call) Return(getUserGroupsResponse *cloudservice.GetUserGroupsResponse, err error) *MockCloudServiceClient_GetUserGroups_Call { - _c.Call.Return(getUserGroupsResponse, err) +func (_c *MockCloudServiceClient_GetUserProjectAssignments_Call) Return(getUserProjectAssignmentsResponse *cloudservice.GetUserProjectAssignmentsResponse, err error) *MockCloudServiceClient_GetUserProjectAssignments_Call { + _c.Call.Return(getUserProjectAssignmentsResponse, err) return _c } -func (_c *MockCloudServiceClient_GetUserGroups_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserGroupsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserGroupsResponse, error)) *MockCloudServiceClient_GetUserGroups_Call { +func (_c *MockCloudServiceClient_GetUserProjectAssignments_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.GetUserProjectAssignmentsRequest, opts ...grpc.CallOption) (*cloudservice.GetUserProjectAssignmentsResponse, error)) *MockCloudServiceClient_GetUserProjectAssignments_Call { _c.Call.Return(run) return _c } @@ -4853,6 +5766,89 @@ func (_c *MockCloudServiceClient_SetServiceAccountNamespaceAccess_Call) RunAndRe return _c } +// SetServiceAccountProjectAccess provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) SetServiceAccountProjectAccess(ctx context.Context, in *cloudservice.SetServiceAccountProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetServiceAccountProjectAccessResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SetServiceAccountProjectAccess") + } + + var r0 *cloudservice.SetServiceAccountProjectAccessResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetServiceAccountProjectAccessRequest, ...grpc.CallOption) (*cloudservice.SetServiceAccountProjectAccessResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetServiceAccountProjectAccessRequest, ...grpc.CallOption) *cloudservice.SetServiceAccountProjectAccessResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.SetServiceAccountProjectAccessResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.SetServiceAccountProjectAccessRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_SetServiceAccountProjectAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetServiceAccountProjectAccess' +type MockCloudServiceClient_SetServiceAccountProjectAccess_Call struct { + *mock.Call +} + +// SetServiceAccountProjectAccess is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.SetServiceAccountProjectAccessRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) SetServiceAccountProjectAccess(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_SetServiceAccountProjectAccess_Call { + return &MockCloudServiceClient_SetServiceAccountProjectAccess_Call{Call: _e.mock.On("SetServiceAccountProjectAccess", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_SetServiceAccountProjectAccess_Call) Run(run func(ctx context.Context, in *cloudservice.SetServiceAccountProjectAccessRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_SetServiceAccountProjectAccess_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.SetServiceAccountProjectAccessRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.SetServiceAccountProjectAccessRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_SetServiceAccountProjectAccess_Call) Return(setServiceAccountProjectAccessResponse *cloudservice.SetServiceAccountProjectAccessResponse, err error) *MockCloudServiceClient_SetServiceAccountProjectAccess_Call { + _c.Call.Return(setServiceAccountProjectAccessResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_SetServiceAccountProjectAccess_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.SetServiceAccountProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetServiceAccountProjectAccessResponse, error)) *MockCloudServiceClient_SetServiceAccountProjectAccess_Call { + _c.Call.Return(run) + return _c +} + // SetUserGroupNamespaceAccess provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) SetUserGroupNamespaceAccess(ctx context.Context, in *cloudservice.SetUserGroupNamespaceAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserGroupNamespaceAccessResponse, error) { var tmpRet mock.Arguments @@ -4936,6 +5932,89 @@ func (_c *MockCloudServiceClient_SetUserGroupNamespaceAccess_Call) RunAndReturn( return _c } +// SetUserGroupProjectAccess provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) SetUserGroupProjectAccess(ctx context.Context, in *cloudservice.SetUserGroupProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserGroupProjectAccessResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SetUserGroupProjectAccess") + } + + var r0 *cloudservice.SetUserGroupProjectAccessResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetUserGroupProjectAccessRequest, ...grpc.CallOption) (*cloudservice.SetUserGroupProjectAccessResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetUserGroupProjectAccessRequest, ...grpc.CallOption) *cloudservice.SetUserGroupProjectAccessResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.SetUserGroupProjectAccessResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.SetUserGroupProjectAccessRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_SetUserGroupProjectAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserGroupProjectAccess' +type MockCloudServiceClient_SetUserGroupProjectAccess_Call struct { + *mock.Call +} + +// SetUserGroupProjectAccess is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.SetUserGroupProjectAccessRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) SetUserGroupProjectAccess(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_SetUserGroupProjectAccess_Call { + return &MockCloudServiceClient_SetUserGroupProjectAccess_Call{Call: _e.mock.On("SetUserGroupProjectAccess", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_SetUserGroupProjectAccess_Call) Run(run func(ctx context.Context, in *cloudservice.SetUserGroupProjectAccessRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_SetUserGroupProjectAccess_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.SetUserGroupProjectAccessRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.SetUserGroupProjectAccessRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_SetUserGroupProjectAccess_Call) Return(setUserGroupProjectAccessResponse *cloudservice.SetUserGroupProjectAccessResponse, err error) *MockCloudServiceClient_SetUserGroupProjectAccess_Call { + _c.Call.Return(setUserGroupProjectAccessResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_SetUserGroupProjectAccess_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.SetUserGroupProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserGroupProjectAccessResponse, error)) *MockCloudServiceClient_SetUserGroupProjectAccess_Call { + _c.Call.Return(run) + return _c +} + // SetUserNamespaceAccess provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) SetUserNamespaceAccess(ctx context.Context, in *cloudservice.SetUserNamespaceAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserNamespaceAccessResponse, error) { var tmpRet mock.Arguments @@ -5019,6 +6098,89 @@ func (_c *MockCloudServiceClient_SetUserNamespaceAccess_Call) RunAndReturn(run f return _c } +// SetUserProjectAccess provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) SetUserProjectAccess(ctx context.Context, in *cloudservice.SetUserProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserProjectAccessResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SetUserProjectAccess") + } + + var r0 *cloudservice.SetUserProjectAccessResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetUserProjectAccessRequest, ...grpc.CallOption) (*cloudservice.SetUserProjectAccessResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.SetUserProjectAccessRequest, ...grpc.CallOption) *cloudservice.SetUserProjectAccessResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.SetUserProjectAccessResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.SetUserProjectAccessRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_SetUserProjectAccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserProjectAccess' +type MockCloudServiceClient_SetUserProjectAccess_Call struct { + *mock.Call +} + +// SetUserProjectAccess is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.SetUserProjectAccessRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) SetUserProjectAccess(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_SetUserProjectAccess_Call { + return &MockCloudServiceClient_SetUserProjectAccess_Call{Call: _e.mock.On("SetUserProjectAccess", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_SetUserProjectAccess_Call) Run(run func(ctx context.Context, in *cloudservice.SetUserProjectAccessRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_SetUserProjectAccess_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.SetUserProjectAccessRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.SetUserProjectAccessRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_SetUserProjectAccess_Call) Return(setUserProjectAccessResponse *cloudservice.SetUserProjectAccessResponse, err error) *MockCloudServiceClient_SetUserProjectAccess_Call { + _c.Call.Return(setUserProjectAccessResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_SetUserProjectAccess_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.SetUserProjectAccessRequest, opts ...grpc.CallOption) (*cloudservice.SetUserProjectAccessResponse, error)) *MockCloudServiceClient_SetUserProjectAccess_Call { + _c.Call.Return(run) + return _c +} + // UpdateAccount provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) UpdateAccount(ctx context.Context, in *cloudservice.UpdateAccountRequest, opts ...grpc.CallOption) (*cloudservice.UpdateAccountResponse, error) { var tmpRet mock.Arguments @@ -5683,6 +6845,89 @@ func (_c *MockCloudServiceClient_UpdateNexusEndpoint_Call) RunAndReturn(run func return _c } +// UpdateProject provides a mock function for the type MockCloudServiceClient +func (_mock *MockCloudServiceClient) UpdateProject(ctx context.Context, in *cloudservice.UpdateProjectRequest, opts ...grpc.CallOption) (*cloudservice.UpdateProjectResponse, error) { + var tmpRet mock.Arguments + if len(opts) > 0 { + tmpRet = _mock.Called(ctx, in, opts) + } else { + tmpRet = _mock.Called(ctx, in) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for UpdateProject") + } + + var r0 *cloudservice.UpdateProjectResponse + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.UpdateProjectRequest, ...grpc.CallOption) (*cloudservice.UpdateProjectResponse, error)); ok { + return returnFunc(ctx, in, opts...) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *cloudservice.UpdateProjectRequest, ...grpc.CallOption) *cloudservice.UpdateProjectResponse); ok { + r0 = returnFunc(ctx, in, opts...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*cloudservice.UpdateProjectResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *cloudservice.UpdateProjectRequest, ...grpc.CallOption) error); ok { + r1 = returnFunc(ctx, in, opts...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockCloudServiceClient_UpdateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProject' +type MockCloudServiceClient_UpdateProject_Call struct { + *mock.Call +} + +// UpdateProject is a helper method to define mock.On call +// - ctx context.Context +// - in *cloudservice.UpdateProjectRequest +// - opts ...grpc.CallOption +func (_e *MockCloudServiceClient_Expecter) UpdateProject(ctx interface{}, in interface{}, opts ...interface{}) *MockCloudServiceClient_UpdateProject_Call { + return &MockCloudServiceClient_UpdateProject_Call{Call: _e.mock.On("UpdateProject", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockCloudServiceClient_UpdateProject_Call) Run(run func(ctx context.Context, in *cloudservice.UpdateProjectRequest, opts ...grpc.CallOption)) *MockCloudServiceClient_UpdateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *cloudservice.UpdateProjectRequest + if args[1] != nil { + arg1 = args[1].(*cloudservice.UpdateProjectRequest) + } + var arg2 []grpc.CallOption + var variadicArgs []grpc.CallOption + if len(args) > 2 { + variadicArgs = args[2].([]grpc.CallOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *MockCloudServiceClient_UpdateProject_Call) Return(updateProjectResponse *cloudservice.UpdateProjectResponse, err error) *MockCloudServiceClient_UpdateProject_Call { + _c.Call.Return(updateProjectResponse, err) + return _c +} + +func (_c *MockCloudServiceClient_UpdateProject_Call) RunAndReturn(run func(ctx context.Context, in *cloudservice.UpdateProjectRequest, opts ...grpc.CallOption) (*cloudservice.UpdateProjectResponse, error)) *MockCloudServiceClient_UpdateProject_Call { + _c.Call.Return(run) + return _c +} + // UpdateServiceAccount provides a mock function for the type MockCloudServiceClient func (_mock *MockCloudServiceClient) UpdateServiceAccount(ctx context.Context, in *cloudservice.UpdateServiceAccountRequest, opts ...grpc.CallOption) (*cloudservice.UpdateServiceAccountResponse, error) { var tmpRet mock.Arguments diff --git a/temporalcloudcli/commands.connectivity.go b/temporalcloudcli/commands.connectivity.go index d582c64..a17548e 100644 --- a/temporalcloudcli/commands.connectivity.go +++ b/temporalcloudcli/commands.connectivity.go @@ -37,10 +37,11 @@ type ( } CreatePrivateConnectivityRuleParams struct { - ConnectionID string - Region string - GCPProjectID string - AsyncOperationID string + ConnectionID string + Region string + GCPProjectID string + AzurePeResourceID string + AsyncOperationID string Cloud cloudservice.CloudServiceClient Prompter Prompter @@ -123,9 +124,6 @@ func CreatePublicConnectivityRule(ctx context.Context, params CreatePublicConnec // CreatePrivateConnectivityRule creates a new private VPC connectivity rule. func CreatePrivateConnectivityRule(ctx context.Context, params CreatePrivateConnectivityRuleParams) error { - if params.ConnectionID == "" { - return errors.New("--connection-id is required for private connectivity") - } if params.Region == "" { return errors.New("--region is required for private connectivity") } @@ -133,9 +131,10 @@ func CreatePrivateConnectivityRule(ctx context.Context, params CreatePrivateConn spec := &connectivityrulev1.ConnectivityRuleSpec{ ConnectionType: &connectivityrulev1.ConnectivityRuleSpec_PrivateRule{ PrivateRule: &connectivityrulev1.PrivateConnectivityRule{ - ConnectionId: params.ConnectionID, - GcpProjectId: params.GCPProjectID, - Region: params.Region, + ConnectionId: params.ConnectionID, + GcpProjectId: params.GCPProjectID, + Region: params.Region, + AzurePeResourceId: params.AzurePeResourceID, }, }, } @@ -230,13 +229,14 @@ func (c *CloudConnectivityPrivateCreateCommand) run(cctx *CommandContext, _ []st return err } return CreatePrivateConnectivityRule(cctx.Context, CreatePrivateConnectivityRuleParams{ - ConnectionID: c.ConnectionId, - Region: c.Region, - GCPProjectID: c.GcpProjectId, - AsyncOperationID: c.AsyncOperationId, - Cloud: cloudClient.CloudService(), - Prompter: newPrompter(cctx), - OperationHandler: NewOperationHandler(cctx, c.AsyncOperationOptions, c.ClientOptions), + ConnectionID: c.ConnectionId, + Region: c.Region, + GCPProjectID: c.GcpProjectId, + AzurePeResourceID: c.AzurePeResourceId, + AsyncOperationID: c.AsyncOperationId, + Cloud: cloudClient.CloudService(), + Prompter: newPrompter(cctx), + OperationHandler: NewOperationHandler(cctx, c.AsyncOperationOptions, c.ClientOptions), }) } diff --git a/temporalcloudcli/commands.connectivity_test.go b/temporalcloudcli/commands.connectivity_test.go index 97ec33b..f3313a2 100644 --- a/temporalcloudcli/commands.connectivity_test.go +++ b/temporalcloudcli/commands.connectivity_test.go @@ -343,6 +343,46 @@ func TestCreatePrivateConnectivityRule_MissingRegion(t *testing.T) { assert.Contains(t, err.Error(), "--region is required") } +// TestCreatePrivateConnectivityRule_Azure_Success verifies that an Azure rule is created with the PE resource ID. +func TestCreatePrivateConnectivityRule_Azure_Success(t *testing.T) { + mockCloud := cloudmock.NewMockCloudServiceClient(t) + mockHandler := cmdmock.NewMockAsyncOperationHandler(t) + mockPrompter := cmdmock.NewMockPrompter(t) + + azurePeResourceID := "/subscriptions/sub-123/resourceGroups/rg-1/providers/Microsoft.Network/privateEndpoints/pe-1" + op := &operation.AsyncOperation{Id: "op-azure"} + expectedSpec := &connectivityrulev1.ConnectivityRuleSpec{ + ConnectionType: &connectivityrulev1.ConnectivityRuleSpec_PrivateRule{ + PrivateRule: &connectivityrulev1.PrivateConnectivityRule{ + Region: "azure-eastus", + AzurePeResourceId: azurePeResourceID, + }, + }, + } + mockPrompter.EXPECT(). + PromptApply(&connectivityrulev1.ConnectivityRuleSpec{}, expectedSpec, false). + Return(nil) + mockCloud.EXPECT(). + CreateConnectivityRule(context.Background(), &cloudservice.CreateConnectivityRuleRequest{ + Spec: expectedSpec, + }). + Return(&cloudservice.CreateConnectivityRuleResponse{ + ConnectivityRuleId: "rule-azure", + AsyncOperation: op, + }, nil) + + mockHandler.EXPECT().HandleOperation(op, "rule-azure").Return(nil) + + err := temporalcloudcli.CreatePrivateConnectivityRule(context.Background(), temporalcloudcli.CreatePrivateConnectivityRuleParams{ + AzurePeResourceID: azurePeResourceID, + Region: "azure-eastus", + Cloud: mockCloud, + Prompter: mockPrompter, + OperationHandler: mockHandler, + }) + require.NoError(t, err) +} + // TestDeleteConnectivityRule_Success verifies that the rule is fetched, diff shown, then deleted. func TestDeleteConnectivityRule_Success(t *testing.T) { mockCloud := cloudmock.NewMockCloudServiceClient(t) diff --git a/temporalcloudcli/commands.gen.go b/temporalcloudcli/commands.gen.go index 46f23f6..584408e 100644 --- a/temporalcloudcli/commands.gen.go +++ b/temporalcloudcli/commands.gen.go @@ -1427,9 +1427,10 @@ type CloudConnectivityPrivateCreateCommand struct { Command cobra.Command ClientOptions AsyncOperationOptions - ConnectionId string - Region string - GcpProjectId string + ConnectionId string + Region string + GcpProjectId string + AzurePeResourceId string } func NewCloudConnectivityPrivateCreateCommand(cctx *CommandContext, parent *CloudConnectivityPrivateCommand) *CloudConnectivityPrivateCreateCommand { @@ -1439,16 +1440,16 @@ func NewCloudConnectivityPrivateCreateCommand(cctx *CommandContext, parent *Clou s.Command.Use = "create [flags]" s.Command.Short = "Create a private connectivity rule" if hasHighlighting { - s.Command.Long = "Create a new private VPC connectivity rule. Requires --connection-id and --region.\n\nExample:\n\n\x1b[1mtemporal cloud connectivity private create --connection-id vpce-12345 --region aws-us-west-2\x1b[0m" + s.Command.Long = "Create a new private connectivity rule for AWS, GCP, or Azure.\n\nFor AWS, provide --connection-id (VPC endpoint ID) and --region.\nFor GCP, provide --connection-id (PSC connection ID), --gcp-project-id, and --region.\nFor Azure, provide --azure-pe-resource-id (ARM resource ID) and --region.\n\nExamples:\n\n\x1b[1mtemporal cloud connectivity private create --connection-id vpce-12345 --region aws-us-west-2\n\ntemporal cloud connectivity private create \\\n --azure-pe-resource-id /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/privateEndpoints/{name} \\\n --region azure-eastus\x1b[0m" } else { - s.Command.Long = "Create a new private VPC connectivity rule. Requires --connection-id and --region.\n\nExample:\n\n```\ntemporal cloud connectivity private create --connection-id vpce-12345 --region aws-us-west-2\n```" + s.Command.Long = "Create a new private connectivity rule for AWS, GCP, or Azure.\n\nFor AWS, provide --connection-id (VPC endpoint ID) and --region.\nFor GCP, provide --connection-id (PSC connection ID), --gcp-project-id, and --region.\nFor Azure, provide --azure-pe-resource-id (ARM resource ID) and --region.\n\nExamples:\n\n```\ntemporal cloud connectivity private create --connection-id vpce-12345 --region aws-us-west-2\n\ntemporal cloud connectivity private create \\\n --azure-pe-resource-id /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/privateEndpoints/{name} \\\n --region azure-eastus\n```" } s.Command.Args = cobra.NoArgs - s.Command.Flags().StringVar(&s.ConnectionId, "connection-id", "", "The connection ID for private connectivity. Required.") - _ = cobra.MarkFlagRequired(s.Command.Flags(), "connection-id") + s.Command.Flags().StringVar(&s.ConnectionId, "connection-id", "", "The connection ID for private connectivity (AWS VPC endpoint ID or GCP PSC connection ID).") s.Command.Flags().StringVar(&s.Region, "region", "", "The region for private connectivity. Required.") _ = cobra.MarkFlagRequired(s.Command.Flags(), "region") s.Command.Flags().StringVar(&s.GcpProjectId, "gcp-project-id", "", "The GCP project ID (only for GCP private connectivity).") + s.Command.Flags().StringVar(&s.AzurePeResourceId, "azure-pe-resource-id", "", "The ARM resource ID of the Azure Private Endpoint (only for Azure private connectivity). Example: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/privateEndpoints/{name}.") s.ClientOptions.BuildFlags(s.Command.Flags()) s.AsyncOperationOptions.BuildFlags(s.Command.Flags()) s.Command.Run = func(c *cobra.Command, args []string) { diff --git a/temporalcloudcli/commands.yml b/temporalcloudcli/commands.yml index 89bdb8c..f602d8a 100644 --- a/temporalcloudcli/commands.yml +++ b/temporalcloudcli/commands.yml @@ -2645,12 +2645,20 @@ commands: - name: cloud connectivity private create summary: Create a private connectivity rule description: | - Create a new private VPC connectivity rule. Requires --connection-id and --region. + Create a new private connectivity rule for AWS, GCP, or Azure. - Example: + For AWS, provide --connection-id (VPC endpoint ID) and --region. + For GCP, provide --connection-id (PSC connection ID), --gcp-project-id, and --region. + For Azure, provide --azure-pe-resource-id (ARM resource ID) and --region. + + Examples: ``` temporal cloud connectivity private create --connection-id vpce-12345 --region aws-us-west-2 + + temporal cloud connectivity private create \ + --azure-pe-resource-id /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/privateEndpoints/{name} \ + --region azure-eastus ``` has-init: false option-sets: @@ -2659,9 +2667,8 @@ commands: options: - name: connection-id type: string - required: true description: | - The connection ID for private connectivity. + The connection ID for private connectivity (AWS VPC endpoint ID or GCP PSC connection ID). - name: region type: string required: true @@ -2671,6 +2678,11 @@ commands: type: string description: | The GCP project ID (only for GCP private connectivity). + - name: azure-pe-resource-id + type: string + description: | + The ARM resource ID of the Azure Private Endpoint (only for Azure private connectivity). + Example: /subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/privateEndpoints/{name}. # User commands - name: cloud user From 8d6154866d66a86c066823f930b4f3eb800c28f8 Mon Sep 17 00:00:00 2001 From: David Liu Date: Tue, 7 Jul 2026 15:21:08 -0400 Subject: [PATCH 2/4] bump go --- go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go.mod b/go.mod index b996c3a..7ecd41e 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/temporalio/cloud-cli -go 1.26.3 +go 1.26.4 require ( github.com/aws/aws-sdk-go-v2 v1.41.11 From 1d2a3d34773d189a0bc37f7cef29f2bc3ad437c9 Mon Sep 17 00:00:00 2001 From: David Liu Date: Tue, 7 Jul 2026 16:37:55 -0400 Subject: [PATCH 3/4] fix test from update --- .../removes_deprecated_field_in_map_value_message.golden.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/temporalcloudcli/internal/protoutils/testdata/strip_deprecated/removes_deprecated_field_in_map_value_message.golden.json b/temporalcloudcli/internal/protoutils/testdata/strip_deprecated/removes_deprecated_field_in_map_value_message.golden.json index 95ee517..715060c 100644 --- a/temporalcloudcli/internal/protoutils/testdata/strip_deprecated/removes_deprecated_field_in_map_value_message.golden.json +++ b/temporalcloudcli/internal/protoutils/testdata/strip_deprecated/removes_deprecated_field_in_map_value_message.golden.json @@ -4,5 +4,6 @@ "ns1": { "permission": "PERMISSION_READ" } - } + }, + "projectAccesses": {} } \ No newline at end of file From 96b608d90ad66c2aa1c3d0d24bad7679842d8fd8 Mon Sep 17 00:00:00 2001 From: David Liu Date: Tue, 7 Jul 2026 16:39:23 -0400 Subject: [PATCH 4/4] remove now irrelevant test --- temporalcloudcli/commands.connectivity_test.go | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/temporalcloudcli/commands.connectivity_test.go b/temporalcloudcli/commands.connectivity_test.go index f3313a2..5bd82e9 100644 --- a/temporalcloudcli/commands.connectivity_test.go +++ b/temporalcloudcli/commands.connectivity_test.go @@ -315,20 +315,6 @@ func TestCreatePrivateConnectivityRule_Success(t *testing.T) { require.NoError(t, err) } -// TestCreatePrivateConnectivityRule_MissingConnectionID verifies an error when no connection-id. -func TestCreatePrivateConnectivityRule_MissingConnectionID(t *testing.T) { - mockCloud := cloudmock.NewMockCloudServiceClient(t) - mockHandler := cmdmock.NewMockAsyncOperationHandler(t) - - err := temporalcloudcli.CreatePrivateConnectivityRule(context.Background(), temporalcloudcli.CreatePrivateConnectivityRuleParams{ - Region: "aws-us-west-2", - Cloud: mockCloud, - OperationHandler: mockHandler, - }) - require.Error(t, err) - assert.Contains(t, err.Error(), "--connection-id is required") -} - // TestCreatePrivateConnectivityRule_MissingRegion verifies an error when no region. func TestCreatePrivateConnectivityRule_MissingRegion(t *testing.T) { mockCloud := cloudmock.NewMockCloudServiceClient(t)