diff --git a/.mockery.yaml b/.mockery.yaml index 2549d95a8fc..6efac13bf6d 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -54,6 +54,11 @@ packages: all: true dir: gen/go/flyteidl2/service/mocks include-auto-generated: true + github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project/projectconnect: + config: + all: true + dir: gen/go/flyteidl2/project/projectconnect/mocks + include-auto-generated: true github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect: config: all: true diff --git a/dataproxy/service/dataproxy_service.go b/dataproxy/service/dataproxy_service.go index edfd49ae230..d9063638cab 100644 --- a/dataproxy/service/dataproxy_service.go +++ b/dataproxy/service/dataproxy_service.go @@ -26,6 +26,8 @@ import ( "github.com/flyteorg/flyte/v2/dataproxy/logs" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy/dataproxyconnect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project/projectconnect" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger" @@ -42,17 +44,19 @@ type Service struct { taskClient taskconnect.TaskServiceClient triggerClient triggerconnect.TriggerServiceClient runClient workflowconnect.RunServiceClient + projectClient projectconnect.ProjectServiceClient logStreamer logs.LogStreamer } // NewService creates a new DataProxyService instance. -func NewService(cfg config.DataProxyConfig, dataStore *storage.DataStore, taskClient taskconnect.TaskServiceClient, triggerClient triggerconnect.TriggerServiceClient, runClient workflowconnect.RunServiceClient, logStreamer logs.LogStreamer) *Service { +func NewService(cfg config.DataProxyConfig, dataStore *storage.DataStore, taskClient taskconnect.TaskServiceClient, triggerClient triggerconnect.TriggerServiceClient, runClient workflowconnect.RunServiceClient, projectClient projectconnect.ProjectServiceClient, logStreamer logs.LogStreamer) *Service { return &Service{ cfg: cfg, dataStore: dataStore, taskClient: taskClient, triggerClient: triggerClient, runClient: runClient, + projectClient: projectClient, logStreamer: logStreamer, } } @@ -74,6 +78,9 @@ func (s *Service) CreateUploadLocation( logger.Errorf(ctx, "Request validation failed: %v", err) return nil, connect.NewError(connect.CodeInvalidArgument, err) } + if err := s.validateProjectExists(ctx, req.Msg.GetProject()); err != nil { + return nil, err + } // Build the storage path storagePath, err := s.constructStoragePath(ctx, req.Msg) @@ -123,6 +130,20 @@ func (s *Service) CreateUploadLocation( return connect.NewResponse(resp), nil } +// validateProjectExists checks that the given project ID exists by calling the ProjectService. +func (s *Service) validateProjectExists(ctx context.Context, projectID string) error { + if _, err := s.projectClient.GetProject(ctx, connect.NewRequest(&project.GetProjectRequest{ + Id: projectID, + })); err != nil { + if connect.CodeOf(err) == connect.CodeNotFound { + return connect.NewError(connect.CodeNotFound, fmt.Errorf("project %q not found", projectID)) + } + logger.Errorf(ctx, "Failed to validate project %q: %v", projectID, err) + return connect.NewError(connect.CodeInternal, fmt.Errorf("failed to validate project: %w", err)) + } + return nil +} + // checkFileExists validates whether a file upload is safe by checking existing files. // Returns an error if: // - File exists without content_md5 provided (cannot verify safe overwrite) @@ -226,6 +247,10 @@ func (s *Service) UploadInputs( return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("id is required")) } + if err := s.validateProjectExists(ctx, project); err != nil { + return nil, err + } + // Resolve the task template to get cache_ignore_input_vars. taskTemplate, err := s.resolveTaskTemplate(ctx, req.Msg) if err != nil { diff --git a/dataproxy/service/dataproxy_service_test.go b/dataproxy/service/dataproxy_service_test.go index bfba6e48c3f..98fda0d4667 100644 --- a/dataproxy/service/dataproxy_service_test.go +++ b/dataproxy/service/dataproxy_service_test.go @@ -25,8 +25,10 @@ import ( "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/core" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy/dataproxyconnect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow" + projectMocks "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project/projectconnect/mocks" workflowMocks "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/workflow/workflowconnect/mocks" ) @@ -104,7 +106,12 @@ func TestCreateUploadLocation(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { mockStore := setupMockDataStore(t) - service := NewService(cfg, mockStore, nil, nil, nil, nil) + mockProjectClient := projectMocks.NewProjectServiceClient(t) + if !tt.wantErr { + mockProjectClient.On("GetProject", mock.Anything, mock.Anything).Return( + connect.NewResponse(&project.GetProjectResponse{}), nil) + } + service := NewService(cfg, mockStore, nil, nil, nil, mockProjectClient, nil) req := &connect.Request[dataproxy.CreateUploadLocationRequest]{ Msg: tt.req, @@ -225,7 +232,7 @@ func TestCheckFileExists(t *testing.T) { mockStore = setupMockDataStoreWithExistingFile(t, tt.existingFileMD5) } - service := NewService(cfg, mockStore, nil, nil, nil, nil) + service := NewService(cfg, mockStore, nil, nil, nil, nil, nil) storagePath := storage.DataReference("s3://test-bucket/uploads/test-project/test-domain/test-root/test-file.txt") err := service.checkFileExists(ctx, storagePath, tt.req) @@ -303,7 +310,7 @@ func TestConstructStoragePath(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { mockStore := setupMockDataStore(t) - service := NewService(cfg, mockStore, nil, nil, nil, nil) + service := NewService(cfg, mockStore, nil, nil, nil, nil, nil) path, err := service.constructStoragePath(ctx, tt.req) @@ -460,7 +467,12 @@ func TestUploadInputs(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { mockStore := setupMockDataStoreWithWriteProtobuf(t) - svc := NewService(cfg, mockStore, nil, nil, nil, nil) + mockProjectClient := projectMocks.NewProjectServiceClient(t) + if !tt.wantErr { + mockProjectClient.On("GetProject", mock.Anything, mock.Anything).Return( + connect.NewResponse(&project.GetProjectResponse{}), nil) + } + svc := NewService(cfg, mockStore, nil, nil, nil, mockProjectClient, nil) req := &connect.Request[dataproxy.UploadInputsRequest]{ Msg: tt.req, @@ -624,7 +636,7 @@ func TestGetActionData(t *testing.T) { ComposedProtobufStore: mockComposedStore, ReferenceConstructor: &simpleRefConstructor{}, } - svc := NewService(cfg, ds, nil, nil, runClient, nil) + svc := NewService(cfg, ds, nil, nil, runClient, nil, nil) resp, err := svc.GetActionData(ctx, connect.NewRequest(&dataproxy.GetActionDataRequest{ ActionId: actionID, @@ -719,7 +731,7 @@ func TestTailLogs(t *testing.T) { _ = stream.Send(&dataproxy.TailLogsResponse{}) }).Return(nil) - svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, streamer) + svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, nil, streamer) client := newTailLogsTestClient(t, svc) stream, err := client.TailLogs(context.Background(), connect.NewRequest(&dataproxy.TailLogsRequest{ @@ -742,7 +754,7 @@ func TestTailLogs(t *testing.T) { nil, connect.NewError(connect.CodeNotFound, assertErr("action missing"))) streamer := &mockLogStreamer{} - svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, streamer) + svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, nil, streamer) client := newTailLogsTestClient(t, svc) stream, err := client.TailLogs(context.Background(), connect.NewRequest(&dataproxy.TailLogsRequest{ @@ -765,7 +777,7 @@ func TestTailLogs(t *testing.T) { }), nil) streamer := &mockLogStreamer{} - svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, streamer) + svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, nil, streamer) client := newTailLogsTestClient(t, svc) stream, err := client.TailLogs(context.Background(), connect.NewRequest(&dataproxy.TailLogsRequest{ @@ -789,7 +801,7 @@ func TestTailLogs(t *testing.T) { streamer.On("TailLogs", mock.Anything, logContext, mock.Anything).Return( connect.NewError(connect.CodeInternal, assertErr("streamer boom"))) - svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, streamer) + svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, nil, streamer) client := newTailLogsTestClient(t, svc) stream, err := client.TailLogs(context.Background(), connect.NewRequest(&dataproxy.TailLogsRequest{ @@ -813,7 +825,7 @@ func TestTailLogs(t *testing.T) { streamer := &mockLogStreamer{} streamer.On("TailLogs", mock.Anything, logContext, mock.Anything).Return(nil) - svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, streamer) + svc := NewService(config.DataProxyConfig{}, nil, nil, nil, runClient, nil, streamer) client := newTailLogsTestClient(t, svc) stream, err := client.TailLogs(context.Background(), connect.NewRequest(&dataproxy.TailLogsRequest{ diff --git a/dataproxy/setup.go b/dataproxy/setup.go index adbe891a17d..b3d9f35471f 100644 --- a/dataproxy/setup.go +++ b/dataproxy/setup.go @@ -14,6 +14,7 @@ import ( "github.com/flyteorg/flyte/v2/flytestdlib/logger" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/cluster/clusterconnect" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/dataproxy/dataproxyconnect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project/projectconnect" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/task/taskconnect" "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/trigger/triggerconnect" ) @@ -27,6 +28,7 @@ func Setup(ctx context.Context, sc *app.SetupContext) error { taskClient := taskconnect.NewTaskServiceClient(http.DefaultClient, baseURL) triggerClient := triggerconnect.NewTriggerServiceClient(http.DefaultClient, baseURL) runClient := workflowconnect.NewRunServiceClient(http.DefaultClient, baseURL) + projectClient := projectconnect.NewProjectServiceClient(http.DefaultClient, baseURL) var logStreamer logs.LogStreamer if sc.K8sConfig != nil { @@ -37,7 +39,7 @@ func Setup(ctx context.Context, sc *app.SetupContext) error { } } - svc := service.NewService(*cfg, sc.DataStore, taskClient, triggerClient, runClient, logStreamer) + svc := service.NewService(*cfg, sc.DataStore, taskClient, triggerClient, runClient, projectClient, logStreamer) path, handler := dataproxyconnect.NewDataProxyServiceHandler(svc) sc.Mux.Handle(path, handler) diff --git a/gen/go/flyteidl2/project/projectconnect/mocks/mocks.go b/gen/go/flyteidl2/project/projectconnect/mocks/mocks.go new file mode 100644 index 00000000000..cfa31627a43 --- /dev/null +++ b/gen/go/flyteidl2/project/projectconnect/mocks/mocks.go @@ -0,0 +1,611 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package mocks + +import ( + "context" + + "connectrpc.com/connect" + "github.com/flyteorg/flyte/v2/gen/go/flyteidl2/project" + mock "github.com/stretchr/testify/mock" +) + +// NewProjectServiceClient creates a new instance of ProjectServiceClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewProjectServiceClient(t interface { + mock.TestingT + Cleanup(func()) +}) *ProjectServiceClient { + mock := &ProjectServiceClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// ProjectServiceClient is an autogenerated mock type for the ProjectServiceClient type +type ProjectServiceClient struct { + mock.Mock +} + +type ProjectServiceClient_Expecter struct { + mock *mock.Mock +} + +func (_m *ProjectServiceClient) EXPECT() *ProjectServiceClient_Expecter { + return &ProjectServiceClient_Expecter{mock: &_m.Mock} +} + +// CreateProject provides a mock function for the type ProjectServiceClient +func (_mock *ProjectServiceClient) CreateProject(context1 context.Context, request *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for CreateProject") + } + + var r0 *connect.Response[project.CreateProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.CreateProjectRequest]) *connect.Response[project.CreateProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.CreateProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.CreateProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceClient_CreateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProject' +type ProjectServiceClient_CreateProject_Call struct { + *mock.Call +} + +// CreateProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.CreateProjectRequest] +func (_e *ProjectServiceClient_Expecter) CreateProject(context1 interface{}, request interface{}) *ProjectServiceClient_CreateProject_Call { + return &ProjectServiceClient_CreateProject_Call{Call: _e.mock.On("CreateProject", context1, request)} +} + +func (_c *ProjectServiceClient_CreateProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.CreateProjectRequest])) *ProjectServiceClient_CreateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.CreateProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.CreateProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceClient_CreateProject_Call) Return(response *connect.Response[project.CreateProjectResponse], err error) *ProjectServiceClient_CreateProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceClient_CreateProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error)) *ProjectServiceClient_CreateProject_Call { + _c.Call.Return(run) + return _c +} + +// GetProject provides a mock function for the type ProjectServiceClient +func (_mock *ProjectServiceClient) GetProject(context1 context.Context, request *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for GetProject") + } + + var r0 *connect.Response[project.GetProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.GetProjectRequest]) *connect.Response[project.GetProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.GetProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.GetProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceClient_GetProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProject' +type ProjectServiceClient_GetProject_Call struct { + *mock.Call +} + +// GetProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.GetProjectRequest] +func (_e *ProjectServiceClient_Expecter) GetProject(context1 interface{}, request interface{}) *ProjectServiceClient_GetProject_Call { + return &ProjectServiceClient_GetProject_Call{Call: _e.mock.On("GetProject", context1, request)} +} + +func (_c *ProjectServiceClient_GetProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.GetProjectRequest])) *ProjectServiceClient_GetProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.GetProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.GetProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceClient_GetProject_Call) Return(response *connect.Response[project.GetProjectResponse], err error) *ProjectServiceClient_GetProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceClient_GetProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error)) *ProjectServiceClient_GetProject_Call { + _c.Call.Return(run) + return _c +} + +// ListProjects provides a mock function for the type ProjectServiceClient +func (_mock *ProjectServiceClient) ListProjects(context1 context.Context, request *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for ListProjects") + } + + var r0 *connect.Response[project.ListProjectsResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.ListProjectsRequest]) *connect.Response[project.ListProjectsResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.ListProjectsResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.ListProjectsRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceClient_ListProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjects' +type ProjectServiceClient_ListProjects_Call struct { + *mock.Call +} + +// ListProjects is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.ListProjectsRequest] +func (_e *ProjectServiceClient_Expecter) ListProjects(context1 interface{}, request interface{}) *ProjectServiceClient_ListProjects_Call { + return &ProjectServiceClient_ListProjects_Call{Call: _e.mock.On("ListProjects", context1, request)} +} + +func (_c *ProjectServiceClient_ListProjects_Call) Run(run func(context1 context.Context, request *connect.Request[project.ListProjectsRequest])) *ProjectServiceClient_ListProjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.ListProjectsRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.ListProjectsRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceClient_ListProjects_Call) Return(response *connect.Response[project.ListProjectsResponse], err error) *ProjectServiceClient_ListProjects_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceClient_ListProjects_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error)) *ProjectServiceClient_ListProjects_Call { + _c.Call.Return(run) + return _c +} + +// UpdateProject provides a mock function for the type ProjectServiceClient +func (_mock *ProjectServiceClient) UpdateProject(context1 context.Context, request *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for UpdateProject") + } + + var r0 *connect.Response[project.UpdateProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) *connect.Response[project.UpdateProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.UpdateProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceClient_UpdateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProject' +type ProjectServiceClient_UpdateProject_Call struct { + *mock.Call +} + +// UpdateProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.UpdateProjectRequest] +func (_e *ProjectServiceClient_Expecter) UpdateProject(context1 interface{}, request interface{}) *ProjectServiceClient_UpdateProject_Call { + return &ProjectServiceClient_UpdateProject_Call{Call: _e.mock.On("UpdateProject", context1, request)} +} + +func (_c *ProjectServiceClient_UpdateProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.UpdateProjectRequest])) *ProjectServiceClient_UpdateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.UpdateProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.UpdateProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceClient_UpdateProject_Call) Return(response *connect.Response[project.UpdateProjectResponse], err error) *ProjectServiceClient_UpdateProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceClient_UpdateProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error)) *ProjectServiceClient_UpdateProject_Call { + _c.Call.Return(run) + return _c +} + +// NewProjectServiceHandler creates a new instance of ProjectServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewProjectServiceHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *ProjectServiceHandler { + mock := &ProjectServiceHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// ProjectServiceHandler is an autogenerated mock type for the ProjectServiceHandler type +type ProjectServiceHandler struct { + mock.Mock +} + +type ProjectServiceHandler_Expecter struct { + mock *mock.Mock +} + +func (_m *ProjectServiceHandler) EXPECT() *ProjectServiceHandler_Expecter { + return &ProjectServiceHandler_Expecter{mock: &_m.Mock} +} + +// CreateProject provides a mock function for the type ProjectServiceHandler +func (_mock *ProjectServiceHandler) CreateProject(context1 context.Context, request *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for CreateProject") + } + + var r0 *connect.Response[project.CreateProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.CreateProjectRequest]) *connect.Response[project.CreateProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.CreateProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.CreateProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceHandler_CreateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateProject' +type ProjectServiceHandler_CreateProject_Call struct { + *mock.Call +} + +// CreateProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.CreateProjectRequest] +func (_e *ProjectServiceHandler_Expecter) CreateProject(context1 interface{}, request interface{}) *ProjectServiceHandler_CreateProject_Call { + return &ProjectServiceHandler_CreateProject_Call{Call: _e.mock.On("CreateProject", context1, request)} +} + +func (_c *ProjectServiceHandler_CreateProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.CreateProjectRequest])) *ProjectServiceHandler_CreateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.CreateProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.CreateProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceHandler_CreateProject_Call) Return(response *connect.Response[project.CreateProjectResponse], err error) *ProjectServiceHandler_CreateProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceHandler_CreateProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.CreateProjectRequest]) (*connect.Response[project.CreateProjectResponse], error)) *ProjectServiceHandler_CreateProject_Call { + _c.Call.Return(run) + return _c +} + +// GetProject provides a mock function for the type ProjectServiceHandler +func (_mock *ProjectServiceHandler) GetProject(context1 context.Context, request *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for GetProject") + } + + var r0 *connect.Response[project.GetProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.GetProjectRequest]) *connect.Response[project.GetProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.GetProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.GetProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceHandler_GetProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetProject' +type ProjectServiceHandler_GetProject_Call struct { + *mock.Call +} + +// GetProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.GetProjectRequest] +func (_e *ProjectServiceHandler_Expecter) GetProject(context1 interface{}, request interface{}) *ProjectServiceHandler_GetProject_Call { + return &ProjectServiceHandler_GetProject_Call{Call: _e.mock.On("GetProject", context1, request)} +} + +func (_c *ProjectServiceHandler_GetProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.GetProjectRequest])) *ProjectServiceHandler_GetProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.GetProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.GetProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceHandler_GetProject_Call) Return(response *connect.Response[project.GetProjectResponse], err error) *ProjectServiceHandler_GetProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceHandler_GetProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.GetProjectRequest]) (*connect.Response[project.GetProjectResponse], error)) *ProjectServiceHandler_GetProject_Call { + _c.Call.Return(run) + return _c +} + +// ListProjects provides a mock function for the type ProjectServiceHandler +func (_mock *ProjectServiceHandler) ListProjects(context1 context.Context, request *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for ListProjects") + } + + var r0 *connect.Response[project.ListProjectsResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.ListProjectsRequest]) *connect.Response[project.ListProjectsResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.ListProjectsResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.ListProjectsRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceHandler_ListProjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListProjects' +type ProjectServiceHandler_ListProjects_Call struct { + *mock.Call +} + +// ListProjects is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.ListProjectsRequest] +func (_e *ProjectServiceHandler_Expecter) ListProjects(context1 interface{}, request interface{}) *ProjectServiceHandler_ListProjects_Call { + return &ProjectServiceHandler_ListProjects_Call{Call: _e.mock.On("ListProjects", context1, request)} +} + +func (_c *ProjectServiceHandler_ListProjects_Call) Run(run func(context1 context.Context, request *connect.Request[project.ListProjectsRequest])) *ProjectServiceHandler_ListProjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.ListProjectsRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.ListProjectsRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceHandler_ListProjects_Call) Return(response *connect.Response[project.ListProjectsResponse], err error) *ProjectServiceHandler_ListProjects_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceHandler_ListProjects_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.ListProjectsRequest]) (*connect.Response[project.ListProjectsResponse], error)) *ProjectServiceHandler_ListProjects_Call { + _c.Call.Return(run) + return _c +} + +// UpdateProject provides a mock function for the type ProjectServiceHandler +func (_mock *ProjectServiceHandler) UpdateProject(context1 context.Context, request *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error) { + ret := _mock.Called(context1, request) + + if len(ret) == 0 { + panic("no return value specified for UpdateProject") + } + + var r0 *connect.Response[project.UpdateProjectResponse] + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error)); ok { + return returnFunc(context1, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) *connect.Response[project.UpdateProjectResponse]); ok { + r0 = returnFunc(context1, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*connect.Response[project.UpdateProjectResponse]) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *connect.Request[project.UpdateProjectRequest]) error); ok { + r1 = returnFunc(context1, request) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ProjectServiceHandler_UpdateProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProject' +type ProjectServiceHandler_UpdateProject_Call struct { + *mock.Call +} + +// UpdateProject is a helper method to define mock.On call +// - context1 context.Context +// - request *connect.Request[project.UpdateProjectRequest] +func (_e *ProjectServiceHandler_Expecter) UpdateProject(context1 interface{}, request interface{}) *ProjectServiceHandler_UpdateProject_Call { + return &ProjectServiceHandler_UpdateProject_Call{Call: _e.mock.On("UpdateProject", context1, request)} +} + +func (_c *ProjectServiceHandler_UpdateProject_Call) Run(run func(context1 context.Context, request *connect.Request[project.UpdateProjectRequest])) *ProjectServiceHandler_UpdateProject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *connect.Request[project.UpdateProjectRequest] + if args[1] != nil { + arg1 = args[1].(*connect.Request[project.UpdateProjectRequest]) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ProjectServiceHandler_UpdateProject_Call) Return(response *connect.Response[project.UpdateProjectResponse], err error) *ProjectServiceHandler_UpdateProject_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *ProjectServiceHandler_UpdateProject_Call) RunAndReturn(run func(context1 context.Context, request *connect.Request[project.UpdateProjectRequest]) (*connect.Response[project.UpdateProjectResponse], error)) *ProjectServiceHandler_UpdateProject_Call { + _c.Call.Return(run) + return _c +}