diff --git a/_mocks/opencsg.com/csghub-server/builder/store/database/mock_AgentInstanceStore.go b/_mocks/opencsg.com/csghub-server/builder/store/database/mock_AgentInstanceStore.go new file mode 100644 index 000000000..0ed5d20b8 --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/builder/store/database/mock_AgentInstanceStore.go @@ -0,0 +1,555 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package database + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + database "opencsg.com/csghub-server/builder/store/database" + + types "opencsg.com/csghub-server/common/types" +) + +// MockAgentInstanceStore is an autogenerated mock type for the AgentInstanceStore type +type MockAgentInstanceStore struct { + mock.Mock +} + +type MockAgentInstanceStore_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentInstanceStore) EXPECT() *MockAgentInstanceStore_Expecter { + return &MockAgentInstanceStore_Expecter{mock: &_m.Mock} +} + +// CountByUserAndType provides a mock function with given fields: ctx, userUUID, instanceType +func (_m *MockAgentInstanceStore) CountByUserAndType(ctx context.Context, userUUID string, instanceType string) (int, error) { + ret := _m.Called(ctx, userUUID, instanceType) + + if len(ret) == 0 { + panic("no return value specified for CountByUserAndType") + } + + var r0 int + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (int, error)); ok { + return rf(ctx, userUUID, instanceType) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) int); ok { + r0 = rf(ctx, userUUID, instanceType) + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, userUUID, instanceType) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_CountByUserAndType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByUserAndType' +type MockAgentInstanceStore_CountByUserAndType_Call struct { + *mock.Call +} + +// CountByUserAndType is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceType string +func (_e *MockAgentInstanceStore_Expecter) CountByUserAndType(ctx interface{}, userUUID interface{}, instanceType interface{}) *MockAgentInstanceStore_CountByUserAndType_Call { + return &MockAgentInstanceStore_CountByUserAndType_Call{Call: _e.mock.On("CountByUserAndType", ctx, userUUID, instanceType)} +} + +func (_c *MockAgentInstanceStore_CountByUserAndType_Call) Run(run func(ctx context.Context, userUUID string, instanceType string)) *MockAgentInstanceStore_CountByUserAndType_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_CountByUserAndType_Call) Return(_a0 int, _a1 error) *MockAgentInstanceStore_CountByUserAndType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_CountByUserAndType_Call) RunAndReturn(run func(context.Context, string, string) (int, error)) *MockAgentInstanceStore_CountByUserAndType_Call { + _c.Call.Return(run) + return _c +} + +// Create provides a mock function with given fields: ctx, instance +func (_m *MockAgentInstanceStore) Create(ctx context.Context, instance *database.AgentInstance) (*database.AgentInstance, error) { + ret := _m.Called(ctx, instance) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + var r0 *database.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *database.AgentInstance) (*database.AgentInstance, error)); ok { + return rf(ctx, instance) + } + if rf, ok := ret.Get(0).(func(context.Context, *database.AgentInstance) *database.AgentInstance); ok { + r0 = rf(ctx, instance) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*database.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *database.AgentInstance) error); ok { + r1 = rf(ctx, instance) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockAgentInstanceStore_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - instance *database.AgentInstance +func (_e *MockAgentInstanceStore_Expecter) Create(ctx interface{}, instance interface{}) *MockAgentInstanceStore_Create_Call { + return &MockAgentInstanceStore_Create_Call{Call: _e.mock.On("Create", ctx, instance)} +} + +func (_c *MockAgentInstanceStore_Create_Call) Run(run func(ctx context.Context, instance *database.AgentInstance)) *MockAgentInstanceStore_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*database.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_Create_Call) Return(_a0 *database.AgentInstance, _a1 error) *MockAgentInstanceStore_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_Create_Call) RunAndReturn(run func(context.Context, *database.AgentInstance) (*database.AgentInstance, error)) *MockAgentInstanceStore_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, id +func (_m *MockAgentInstanceStore) Delete(ctx context.Context, id int64) error { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok { + r0 = rf(ctx, id) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentInstanceStore_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockAgentInstanceStore_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +func (_e *MockAgentInstanceStore_Expecter) Delete(ctx interface{}, id interface{}) *MockAgentInstanceStore_Delete_Call { + return &MockAgentInstanceStore_Delete_Call{Call: _e.mock.On("Delete", ctx, id)} +} + +func (_c *MockAgentInstanceStore_Delete_Call) Run(run func(ctx context.Context, id int64)) *MockAgentInstanceStore_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_Delete_Call) Return(_a0 error) *MockAgentInstanceStore_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceStore_Delete_Call) RunAndReturn(run func(context.Context, int64) error) *MockAgentInstanceStore_Delete_Call { + _c.Call.Return(run) + return _c +} + +// FindByContentID provides a mock function with given fields: ctx, instanceType, contentID +func (_m *MockAgentInstanceStore) FindByContentID(ctx context.Context, instanceType string, contentID string) (*database.AgentInstance, error) { + ret := _m.Called(ctx, instanceType, contentID) + + if len(ret) == 0 { + panic("no return value specified for FindByContentID") + } + + var r0 *database.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (*database.AgentInstance, error)); ok { + return rf(ctx, instanceType, contentID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) *database.AgentInstance); ok { + r0 = rf(ctx, instanceType, contentID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*database.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, instanceType, contentID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_FindByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByContentID' +type MockAgentInstanceStore_FindByContentID_Call struct { + *mock.Call +} + +// FindByContentID is a helper method to define mock.On call +// - ctx context.Context +// - instanceType string +// - contentID string +func (_e *MockAgentInstanceStore_Expecter) FindByContentID(ctx interface{}, instanceType interface{}, contentID interface{}) *MockAgentInstanceStore_FindByContentID_Call { + return &MockAgentInstanceStore_FindByContentID_Call{Call: _e.mock.On("FindByContentID", ctx, instanceType, contentID)} +} + +func (_c *MockAgentInstanceStore_FindByContentID_Call) Run(run func(ctx context.Context, instanceType string, contentID string)) *MockAgentInstanceStore_FindByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_FindByContentID_Call) Return(_a0 *database.AgentInstance, _a1 error) *MockAgentInstanceStore_FindByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_FindByContentID_Call) RunAndReturn(run func(context.Context, string, string) (*database.AgentInstance, error)) *MockAgentInstanceStore_FindByContentID_Call { + _c.Call.Return(run) + return _c +} + +// FindByID provides a mock function with given fields: ctx, id +func (_m *MockAgentInstanceStore) FindByID(ctx context.Context, id int64) (*database.AgentInstance, error) { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for FindByID") + } + + var r0 *database.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, int64) (*database.AgentInstance, error)); ok { + return rf(ctx, id) + } + if rf, ok := ret.Get(0).(func(context.Context, int64) *database.AgentInstance); ok { + r0 = rf(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*database.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok { + r1 = rf(ctx, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_FindByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByID' +type MockAgentInstanceStore_FindByID_Call struct { + *mock.Call +} + +// FindByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +func (_e *MockAgentInstanceStore_Expecter) FindByID(ctx interface{}, id interface{}) *MockAgentInstanceStore_FindByID_Call { + return &MockAgentInstanceStore_FindByID_Call{Call: _e.mock.On("FindByID", ctx, id)} +} + +func (_c *MockAgentInstanceStore_FindByID_Call) Run(run func(ctx context.Context, id int64)) *MockAgentInstanceStore_FindByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_FindByID_Call) Return(_a0 *database.AgentInstance, _a1 error) *MockAgentInstanceStore_FindByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_FindByID_Call) RunAndReturn(run func(context.Context, int64) (*database.AgentInstance, error)) *MockAgentInstanceStore_FindByID_Call { + _c.Call.Return(run) + return _c +} + +// FindByIDs provides a mock function with given fields: ctx, ids +func (_m *MockAgentInstanceStore) FindByIDs(ctx context.Context, ids []int64) ([]database.AgentInstance, error) { + ret := _m.Called(ctx, ids) + + if len(ret) == 0 { + panic("no return value specified for FindByIDs") + } + + var r0 []database.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, []int64) ([]database.AgentInstance, error)); ok { + return rf(ctx, ids) + } + if rf, ok := ret.Get(0).(func(context.Context, []int64) []database.AgentInstance); ok { + r0 = rf(ctx, ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]database.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, []int64) error); ok { + r1 = rf(ctx, ids) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_FindByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindByIDs' +type MockAgentInstanceStore_FindByIDs_Call struct { + *mock.Call +} + +// FindByIDs is a helper method to define mock.On call +// - ctx context.Context +// - ids []int64 +func (_e *MockAgentInstanceStore_Expecter) FindByIDs(ctx interface{}, ids interface{}) *MockAgentInstanceStore_FindByIDs_Call { + return &MockAgentInstanceStore_FindByIDs_Call{Call: _e.mock.On("FindByIDs", ctx, ids)} +} + +func (_c *MockAgentInstanceStore_FindByIDs_Call) Run(run func(ctx context.Context, ids []int64)) *MockAgentInstanceStore_FindByIDs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]int64)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_FindByIDs_Call) Return(_a0 []database.AgentInstance, _a1 error) *MockAgentInstanceStore_FindByIDs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_FindByIDs_Call) RunAndReturn(run func(context.Context, []int64) ([]database.AgentInstance, error)) *MockAgentInstanceStore_FindByIDs_Call { + _c.Call.Return(run) + return _c +} + +// IsInstanceExistsByContentID provides a mock function with given fields: ctx, instanceType, contentID +func (_m *MockAgentInstanceStore) IsInstanceExistsByContentID(ctx context.Context, instanceType string, contentID string) (bool, error) { + ret := _m.Called(ctx, instanceType, contentID) + + if len(ret) == 0 { + panic("no return value specified for IsInstanceExistsByContentID") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok { + return rf(ctx, instanceType, contentID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) bool); ok { + r0 = rf(ctx, instanceType, contentID) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, instanceType, contentID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceStore_IsInstanceExistsByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInstanceExistsByContentID' +type MockAgentInstanceStore_IsInstanceExistsByContentID_Call struct { + *mock.Call +} + +// IsInstanceExistsByContentID is a helper method to define mock.On call +// - ctx context.Context +// - instanceType string +// - contentID string +func (_e *MockAgentInstanceStore_Expecter) IsInstanceExistsByContentID(ctx interface{}, instanceType interface{}, contentID interface{}) *MockAgentInstanceStore_IsInstanceExistsByContentID_Call { + return &MockAgentInstanceStore_IsInstanceExistsByContentID_Call{Call: _e.mock.On("IsInstanceExistsByContentID", ctx, instanceType, contentID)} +} + +func (_c *MockAgentInstanceStore_IsInstanceExistsByContentID_Call) Run(run func(ctx context.Context, instanceType string, contentID string)) *MockAgentInstanceStore_IsInstanceExistsByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_IsInstanceExistsByContentID_Call) Return(_a0 bool, _a1 error) *MockAgentInstanceStore_IsInstanceExistsByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceStore_IsInstanceExistsByContentID_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *MockAgentInstanceStore_IsInstanceExistsByContentID_Call { + _c.Call.Return(run) + return _c +} + +// ListByUserUUID provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentInstanceStore) ListByUserUUID(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int) ([]database.AgentInstance, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListByUserUUID") + } + + var r0 []database.AgentInstance + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceFilter, int, int) ([]database.AgentInstance, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceFilter, int, int) []database.AgentInstance); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]database.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentInstanceFilter, int, int) int); ok { + r1 = rf(ctx, userUUID, filter, per, page) + } else { + r1 = ret.Get(1).(int) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, types.AgentInstanceFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentInstanceStore_ListByUserUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListByUserUUID' +type MockAgentInstanceStore_ListByUserUUID_Call struct { + *mock.Call +} + +// ListByUserUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentInstanceFilter +// - per int +// - page int +func (_e *MockAgentInstanceStore_Expecter) ListByUserUUID(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentInstanceStore_ListByUserUUID_Call { + return &MockAgentInstanceStore_ListByUserUUID_Call{Call: _e.mock.On("ListByUserUUID", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentInstanceStore_ListByUserUUID_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int)) *MockAgentInstanceStore_ListByUserUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentInstanceFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_ListByUserUUID_Call) Return(_a0 []database.AgentInstance, _a1 int, _a2 error) *MockAgentInstanceStore_ListByUserUUID_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentInstanceStore_ListByUserUUID_Call) RunAndReturn(run func(context.Context, string, types.AgentInstanceFilter, int, int) ([]database.AgentInstance, int, error)) *MockAgentInstanceStore_ListByUserUUID_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: ctx, instance +func (_m *MockAgentInstanceStore) Update(ctx context.Context, instance *database.AgentInstance) error { + ret := _m.Called(ctx, instance) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *database.AgentInstance) error); ok { + r0 = rf(ctx, instance) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentInstanceStore_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type MockAgentInstanceStore_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - ctx context.Context +// - instance *database.AgentInstance +func (_e *MockAgentInstanceStore_Expecter) Update(ctx interface{}, instance interface{}) *MockAgentInstanceStore_Update_Call { + return &MockAgentInstanceStore_Update_Call{Call: _e.mock.On("Update", ctx, instance)} +} + +func (_c *MockAgentInstanceStore_Update_Call) Run(run func(ctx context.Context, instance *database.AgentInstance)) *MockAgentInstanceStore_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*database.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentInstanceStore_Update_Call) Return(_a0 error) *MockAgentInstanceStore_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceStore_Update_Call) RunAndReturn(run func(context.Context, *database.AgentInstance) error) *MockAgentInstanceStore_Update_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentInstanceStore creates a new instance of MockAgentInstanceStore. 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 NewMockAgentInstanceStore(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentInstanceStore { + mock := &MockAgentInstanceStore{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/builder/store/database/mock_DeployTaskStore.go b/_mocks/opencsg.com/csghub-server/builder/store/database/mock_DeployTaskStore.go index a83ed1529..969eb0955 100644 --- a/_mocks/opencsg.com/csghub-server/builder/store/database/mock_DeployTaskStore.go +++ b/_mocks/opencsg.com/csghub-server/builder/store/database/mock_DeployTaskStore.go @@ -618,6 +618,65 @@ func (_c *MockDeployTaskStore_GetLatestDeployBySpaceID_Call) RunAndReturn(run fu return _c } +// GetLatestDeploysBySpaceIDs provides a mock function with given fields: ctx, spaceIDs +func (_m *MockDeployTaskStore) GetLatestDeploysBySpaceIDs(ctx context.Context, spaceIDs []int64) (map[int64]*database.Deploy, error) { + ret := _m.Called(ctx, spaceIDs) + + if len(ret) == 0 { + panic("no return value specified for GetLatestDeploysBySpaceIDs") + } + + var r0 map[int64]*database.Deploy + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, []int64) (map[int64]*database.Deploy, error)); ok { + return rf(ctx, spaceIDs) + } + if rf, ok := ret.Get(0).(func(context.Context, []int64) map[int64]*database.Deploy); ok { + r0 = rf(ctx, spaceIDs) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[int64]*database.Deploy) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, []int64) error); ok { + r1 = rf(ctx, spaceIDs) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLatestDeploysBySpaceIDs' +type MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call struct { + *mock.Call +} + +// GetLatestDeploysBySpaceIDs is a helper method to define mock.On call +// - ctx context.Context +// - spaceIDs []int64 +func (_e *MockDeployTaskStore_Expecter) GetLatestDeploysBySpaceIDs(ctx interface{}, spaceIDs interface{}) *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call { + return &MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call{Call: _e.mock.On("GetLatestDeploysBySpaceIDs", ctx, spaceIDs)} +} + +func (_c *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call) Run(run func(ctx context.Context, spaceIDs []int64)) *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]int64)) + }) + return _c +} + +func (_c *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call) Return(_a0 map[int64]*database.Deploy, _a1 error) *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call) RunAndReturn(run func(context.Context, []int64) (map[int64]*database.Deploy, error)) *MockDeployTaskStore_GetLatestDeploysBySpaceIDs_Call { + _c.Call.Return(run) + return _c +} + // GetNewTaskAfter provides a mock function with given fields: ctx, currentDeployTaskID func (_m *MockDeployTaskStore) GetNewTaskAfter(ctx context.Context, currentDeployTaskID int64) (*database.DeployTask, error) { ret := _m.Called(ctx, currentDeployTaskID) diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentComponent.go new file mode 100644 index 000000000..bd2f1b3cb --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentComponent.go @@ -0,0 +1,1659 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package component + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + types "opencsg.com/csghub-server/common/types" +) + +// MockAgentComponent is an autogenerated mock type for the AgentComponent type +type MockAgentComponent struct { + mock.Mock +} + +type MockAgentComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentComponent) EXPECT() *MockAgentComponent_Expecter { + return &MockAgentComponent_Expecter{mock: &_m.Mock} +} + +// CreateInstance provides a mock function with given fields: ctx, instance +func (_m *MockAgentComponent) CreateInstance(ctx context.Context, instance *types.AgentInstance) error { + ret := _m.Called(ctx, instance) + + if len(ret) == 0 { + panic("no return value specified for CreateInstance") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentInstance) error); ok { + r0 = rf(ctx, instance) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance' +type MockAgentComponent_CreateInstance_Call struct { + *mock.Call +} + +// CreateInstance is a helper method to define mock.On call +// - ctx context.Context +// - instance *types.AgentInstance +func (_e *MockAgentComponent_Expecter) CreateInstance(ctx interface{}, instance interface{}) *MockAgentComponent_CreateInstance_Call { + return &MockAgentComponent_CreateInstance_Call{Call: _e.mock.On("CreateInstance", ctx, instance)} +} + +func (_c *MockAgentComponent_CreateInstance_Call) Run(run func(ctx context.Context, instance *types.AgentInstance)) *MockAgentComponent_CreateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentComponent_CreateInstance_Call) Return(_a0 error) *MockAgentComponent_CreateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_CreateInstance_Call) RunAndReturn(run func(context.Context, *types.AgentInstance) error) *MockAgentComponent_CreateInstance_Call { + _c.Call.Return(run) + return _c +} + +// CreateSession provides a mock function with given fields: ctx, userUUID, req +func (_m *MockAgentComponent) CreateSession(ctx context.Context, userUUID string, req *types.CreateAgentInstanceSessionRequest) (string, error) { + ret := _m.Called(ctx, userUUID, req) + + if len(ret) == 0 { + panic("no return value specified for CreateSession") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *types.CreateAgentInstanceSessionRequest) (string, error)); ok { + return rf(ctx, userUUID, req) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *types.CreateAgentInstanceSessionRequest) string); ok { + r0 = rf(ctx, userUUID, req) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *types.CreateAgentInstanceSessionRequest) error); ok { + r1 = rf(ctx, userUUID, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession' +type MockAgentComponent_CreateSession_Call struct { + *mock.Call +} + +// CreateSession is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - req *types.CreateAgentInstanceSessionRequest +func (_e *MockAgentComponent_Expecter) CreateSession(ctx interface{}, userUUID interface{}, req interface{}) *MockAgentComponent_CreateSession_Call { + return &MockAgentComponent_CreateSession_Call{Call: _e.mock.On("CreateSession", ctx, userUUID, req)} +} + +func (_c *MockAgentComponent_CreateSession_Call) Run(run func(ctx context.Context, userUUID string, req *types.CreateAgentInstanceSessionRequest)) *MockAgentComponent_CreateSession_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*types.CreateAgentInstanceSessionRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_CreateSession_Call) Return(sessionUUID string, err error) *MockAgentComponent_CreateSession_Call { + _c.Call.Return(sessionUUID, err) + return _c +} + +func (_c *MockAgentComponent_CreateSession_Call) RunAndReturn(run func(context.Context, string, *types.CreateAgentInstanceSessionRequest) (string, error)) *MockAgentComponent_CreateSession_Call { + _c.Call.Return(run) + return _c +} + +// CreateSessionHistories provides a mock function with given fields: ctx, userUUID, instanceID, req +func (_m *MockAgentComponent) CreateSessionHistories(ctx context.Context, userUUID string, instanceID int64, req *types.CreateSessionHistoryRequest) (*types.CreateSessionHistoryResponse, error) { + ret := _m.Called(ctx, userUUID, instanceID, req) + + if len(ret) == 0 { + panic("no return value specified for CreateSessionHistories") + } + + var r0 *types.CreateSessionHistoryResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, int64, *types.CreateSessionHistoryRequest) (*types.CreateSessionHistoryResponse, error)); ok { + return rf(ctx, userUUID, instanceID, req) + } + if rf, ok := ret.Get(0).(func(context.Context, string, int64, *types.CreateSessionHistoryRequest) *types.CreateSessionHistoryResponse); ok { + r0 = rf(ctx, userUUID, instanceID, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.CreateSessionHistoryResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, int64, *types.CreateSessionHistoryRequest) error); ok { + r1 = rf(ctx, userUUID, instanceID, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_CreateSessionHistories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionHistories' +type MockAgentComponent_CreateSessionHistories_Call struct { + *mock.Call +} + +// CreateSessionHistories is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceID int64 +// - req *types.CreateSessionHistoryRequest +func (_e *MockAgentComponent_Expecter) CreateSessionHistories(ctx interface{}, userUUID interface{}, instanceID interface{}, req interface{}) *MockAgentComponent_CreateSessionHistories_Call { + return &MockAgentComponent_CreateSessionHistories_Call{Call: _e.mock.On("CreateSessionHistories", ctx, userUUID, instanceID, req)} +} + +func (_c *MockAgentComponent_CreateSessionHistories_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, req *types.CreateSessionHistoryRequest)) *MockAgentComponent_CreateSessionHistories_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(*types.CreateSessionHistoryRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_CreateSessionHistories_Call) Return(_a0 *types.CreateSessionHistoryResponse, _a1 error) *MockAgentComponent_CreateSessionHistories_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_CreateSessionHistories_Call) RunAndReturn(run func(context.Context, string, int64, *types.CreateSessionHistoryRequest) (*types.CreateSessionHistoryResponse, error)) *MockAgentComponent_CreateSessionHistories_Call { + _c.Call.Return(run) + return _c +} + +// CreateTaskIfInstanceExists provides a mock function with given fields: ctx, req +func (_m *MockAgentComponent) CreateTaskIfInstanceExists(ctx context.Context, req *types.AgentInstanceTaskReq) error { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for CreateTaskIfInstanceExists") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentInstanceTaskReq) error); ok { + r0 = rf(ctx, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_CreateTaskIfInstanceExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTaskIfInstanceExists' +type MockAgentComponent_CreateTaskIfInstanceExists_Call struct { + *mock.Call +} + +// CreateTaskIfInstanceExists is a helper method to define mock.On call +// - ctx context.Context +// - req *types.AgentInstanceTaskReq +func (_e *MockAgentComponent_Expecter) CreateTaskIfInstanceExists(ctx interface{}, req interface{}) *MockAgentComponent_CreateTaskIfInstanceExists_Call { + return &MockAgentComponent_CreateTaskIfInstanceExists_Call{Call: _e.mock.On("CreateTaskIfInstanceExists", ctx, req)} +} + +func (_c *MockAgentComponent_CreateTaskIfInstanceExists_Call) Run(run func(ctx context.Context, req *types.AgentInstanceTaskReq)) *MockAgentComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstanceTaskReq)) + }) + return _c +} + +func (_c *MockAgentComponent_CreateTaskIfInstanceExists_Call) Return(_a0 error) *MockAgentComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_CreateTaskIfInstanceExists_Call) RunAndReturn(run func(context.Context, *types.AgentInstanceTaskReq) error) *MockAgentComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Return(run) + return _c +} + +// CreateTemplate provides a mock function with given fields: ctx, template +func (_m *MockAgentComponent) CreateTemplate(ctx context.Context, template *types.AgentTemplate) error { + ret := _m.Called(ctx, template) + + if len(ret) == 0 { + panic("no return value specified for CreateTemplate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentTemplate) error); ok { + r0 = rf(ctx, template) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate' +type MockAgentComponent_CreateTemplate_Call struct { + *mock.Call +} + +// CreateTemplate is a helper method to define mock.On call +// - ctx context.Context +// - template *types.AgentTemplate +func (_e *MockAgentComponent_Expecter) CreateTemplate(ctx interface{}, template interface{}) *MockAgentComponent_CreateTemplate_Call { + return &MockAgentComponent_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", ctx, template)} +} + +func (_c *MockAgentComponent_CreateTemplate_Call) Run(run func(ctx context.Context, template *types.AgentTemplate)) *MockAgentComponent_CreateTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentTemplate)) + }) + return _c +} + +func (_c *MockAgentComponent_CreateTemplate_Call) Return(_a0 error) *MockAgentComponent_CreateTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_CreateTemplate_Call) RunAndReturn(run func(context.Context, *types.AgentTemplate) error) *MockAgentComponent_CreateTemplate_Call { + _c.Call.Return(run) + return _c +} + +// DeleteInstance provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentComponent) DeleteInstance(ctx context.Context, id int64, userUUID string) error { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteInstance") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok { + r0 = rf(ctx, id, userUUID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_DeleteInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstance' +type MockAgentComponent_DeleteInstance_Call struct { + *mock.Call +} + +// DeleteInstance is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentComponent_Expecter) DeleteInstance(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentComponent_DeleteInstance_Call { + return &MockAgentComponent_DeleteInstance_Call{Call: _e.mock.On("DeleteInstance", ctx, id, userUUID)} +} + +func (_c *MockAgentComponent_DeleteInstance_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentComponent_DeleteInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_DeleteInstance_Call) Return(_a0 error) *MockAgentComponent_DeleteInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_DeleteInstance_Call) RunAndReturn(run func(context.Context, int64, string) error) *MockAgentComponent_DeleteInstance_Call { + _c.Call.Return(run) + return _c +} + +// DeleteInstanceByContentID provides a mock function with given fields: ctx, userUUID, instanceType, instanceContentID +func (_m *MockAgentComponent) DeleteInstanceByContentID(ctx context.Context, userUUID string, instanceType string, instanceContentID string) error { + ret := _m.Called(ctx, userUUID, instanceType, instanceContentID) + + if len(ret) == 0 { + panic("no return value specified for DeleteInstanceByContentID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { + r0 = rf(ctx, userUUID, instanceType, instanceContentID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_DeleteInstanceByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstanceByContentID' +type MockAgentComponent_DeleteInstanceByContentID_Call struct { + *mock.Call +} + +// DeleteInstanceByContentID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceType string +// - instanceContentID string +func (_e *MockAgentComponent_Expecter) DeleteInstanceByContentID(ctx interface{}, userUUID interface{}, instanceType interface{}, instanceContentID interface{}) *MockAgentComponent_DeleteInstanceByContentID_Call { + return &MockAgentComponent_DeleteInstanceByContentID_Call{Call: _e.mock.On("DeleteInstanceByContentID", ctx, userUUID, instanceType, instanceContentID)} +} + +func (_c *MockAgentComponent_DeleteInstanceByContentID_Call) Run(run func(ctx context.Context, userUUID string, instanceType string, instanceContentID string)) *MockAgentComponent_DeleteInstanceByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_DeleteInstanceByContentID_Call) Return(_a0 error) *MockAgentComponent_DeleteInstanceByContentID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_DeleteInstanceByContentID_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockAgentComponent_DeleteInstanceByContentID_Call { + _c.Call.Return(run) + return _c +} + +// DeleteSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentComponent) DeleteSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) error { + ret := _m.Called(ctx, userUUID, sessionUUID, instanceID) + + if len(ret) == 0 { + panic("no return value specified for DeleteSessionByUUID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) error); ok { + r0 = rf(ctx, userUUID, sessionUUID, instanceID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_DeleteSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSessionByUUID' +type MockAgentComponent_DeleteSessionByUUID_Call struct { + *mock.Call +} + +// DeleteSessionByUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - sessionUUID string +// - instanceID int64 +func (_e *MockAgentComponent_Expecter) DeleteSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentComponent_DeleteSessionByUUID_Call { + return &MockAgentComponent_DeleteSessionByUUID_Call{Call: _e.mock.On("DeleteSessionByUUID", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentComponent_DeleteSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentComponent_DeleteSessionByUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockAgentComponent_DeleteSessionByUUID_Call) Return(_a0 error) *MockAgentComponent_DeleteSessionByUUID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_DeleteSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64) error) *MockAgentComponent_DeleteSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTemplate provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentComponent) DeleteTemplate(ctx context.Context, id int64, userUUID string) error { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteTemplate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok { + r0 = rf(ctx, id, userUUID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_DeleteTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTemplate' +type MockAgentComponent_DeleteTemplate_Call struct { + *mock.Call +} + +// DeleteTemplate is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentComponent_Expecter) DeleteTemplate(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentComponent_DeleteTemplate_Call { + return &MockAgentComponent_DeleteTemplate_Call{Call: _e.mock.On("DeleteTemplate", ctx, id, userUUID)} +} + +func (_c *MockAgentComponent_DeleteTemplate_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentComponent_DeleteTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_DeleteTemplate_Call) Return(_a0 error) *MockAgentComponent_DeleteTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_DeleteTemplate_Call) RunAndReturn(run func(context.Context, int64, string) error) *MockAgentComponent_DeleteTemplate_Call { + _c.Call.Return(run) + return _c +} + +// GetInstanceByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentComponent) GetInstanceByID(ctx context.Context, id int64, userUUID string) (*types.AgentInstance, error) { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for GetInstanceByID") + } + + var r0 *types.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*types.AgentInstance, error)); ok { + return rf(ctx, id, userUUID) + } + if rf, ok := ret.Get(0).(func(context.Context, int64, string) *types.AgentInstance); ok { + r0 = rf(ctx, id, userUUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok { + r1 = rf(ctx, id, userUUID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetInstanceByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceByID' +type MockAgentComponent_GetInstanceByID_Call struct { + *mock.Call +} + +// GetInstanceByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentComponent_Expecter) GetInstanceByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentComponent_GetInstanceByID_Call { + return &MockAgentComponent_GetInstanceByID_Call{Call: _e.mock.On("GetInstanceByID", ctx, id, userUUID)} +} + +func (_c *MockAgentComponent_GetInstanceByID_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentComponent_GetInstanceByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_GetInstanceByID_Call) Return(_a0 *types.AgentInstance, _a1 error) *MockAgentComponent_GetInstanceByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetInstanceByID_Call) RunAndReturn(run func(context.Context, int64, string) (*types.AgentInstance, error)) *MockAgentComponent_GetInstanceByID_Call { + _c.Call.Return(run) + return _c +} + +// GetInstancesStatus provides a mock function with given fields: ctx, userUUID, instanceIDs +func (_m *MockAgentComponent) GetInstancesStatus(ctx context.Context, userUUID string, instanceIDs []int64) ([]types.AgentInstanceStatusResponse, error) { + ret := _m.Called(ctx, userUUID, instanceIDs) + + if len(ret) == 0 { + panic("no return value specified for GetInstancesStatus") + } + + var r0 []types.AgentInstanceStatusResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, []int64) ([]types.AgentInstanceStatusResponse, error)); ok { + return rf(ctx, userUUID, instanceIDs) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []int64) []types.AgentInstanceStatusResponse); ok { + r0 = rf(ctx, userUUID, instanceIDs) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentInstanceStatusResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []int64) error); ok { + r1 = rf(ctx, userUUID, instanceIDs) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetInstancesStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstancesStatus' +type MockAgentComponent_GetInstancesStatus_Call struct { + *mock.Call +} + +// GetInstancesStatus is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceIDs []int64 +func (_e *MockAgentComponent_Expecter) GetInstancesStatus(ctx interface{}, userUUID interface{}, instanceIDs interface{}) *MockAgentComponent_GetInstancesStatus_Call { + return &MockAgentComponent_GetInstancesStatus_Call{Call: _e.mock.On("GetInstancesStatus", ctx, userUUID, instanceIDs)} +} + +func (_c *MockAgentComponent_GetInstancesStatus_Call) Run(run func(ctx context.Context, userUUID string, instanceIDs []int64)) *MockAgentComponent_GetInstancesStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]int64)) + }) + return _c +} + +func (_c *MockAgentComponent_GetInstancesStatus_Call) Return(_a0 []types.AgentInstanceStatusResponse, _a1 error) *MockAgentComponent_GetInstancesStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetInstancesStatus_Call) RunAndReturn(run func(context.Context, string, []int64) ([]types.AgentInstanceStatusResponse, error)) *MockAgentComponent_GetInstancesStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetMonitor provides a mock function with given fields: ctx, monitorID +func (_m *MockAgentComponent) GetMonitor(ctx context.Context, monitorID string) ([]int64, error) { + ret := _m.Called(ctx, monitorID) + + if len(ret) == 0 { + panic("no return value specified for GetMonitor") + } + + var r0 []int64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) ([]int64, error)); ok { + return rf(ctx, monitorID) + } + if rf, ok := ret.Get(0).(func(context.Context, string) []int64); ok { + r0 = rf(ctx, monitorID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]int64) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, monitorID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMonitor' +type MockAgentComponent_GetMonitor_Call struct { + *mock.Call +} + +// GetMonitor is a helper method to define mock.On call +// - ctx context.Context +// - monitorID string +func (_e *MockAgentComponent_Expecter) GetMonitor(ctx interface{}, monitorID interface{}) *MockAgentComponent_GetMonitor_Call { + return &MockAgentComponent_GetMonitor_Call{Call: _e.mock.On("GetMonitor", ctx, monitorID)} +} + +func (_c *MockAgentComponent_GetMonitor_Call) Run(run func(ctx context.Context, monitorID string)) *MockAgentComponent_GetMonitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_GetMonitor_Call) Return(_a0 []int64, _a1 error) *MockAgentComponent_GetMonitor_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetMonitor_Call) RunAndReturn(run func(context.Context, string) ([]int64, error)) *MockAgentComponent_GetMonitor_Call { + _c.Call.Return(run) + return _c +} + +// GetSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentComponent) GetSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) (*types.AgentInstanceSession, error) { + ret := _m.Called(ctx, userUUID, sessionUUID, instanceID) + + if len(ret) == 0 { + panic("no return value specified for GetSessionByUUID") + } + + var r0 *types.AgentInstanceSession + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) (*types.AgentInstanceSession, error)); ok { + return rf(ctx, userUUID, sessionUUID, instanceID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) *types.AgentInstanceSession); ok { + r0 = rf(ctx, userUUID, sessionUUID, instanceID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentInstanceSession) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, int64) error); ok { + r1 = rf(ctx, userUUID, sessionUUID, instanceID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionByUUID' +type MockAgentComponent_GetSessionByUUID_Call struct { + *mock.Call +} + +// GetSessionByUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - sessionUUID string +// - instanceID int64 +func (_e *MockAgentComponent_Expecter) GetSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentComponent_GetSessionByUUID_Call { + return &MockAgentComponent_GetSessionByUUID_Call{Call: _e.mock.On("GetSessionByUUID", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentComponent_GetSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentComponent_GetSessionByUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockAgentComponent_GetSessionByUUID_Call) Return(_a0 *types.AgentInstanceSession, _a1 error) *MockAgentComponent_GetSessionByUUID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64) (*types.AgentInstanceSession, error)) *MockAgentComponent_GetSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskDetail provides a mock function with given fields: ctx, userUUID, id +func (_m *MockAgentComponent) GetTaskDetail(ctx context.Context, userUUID string, id int64) (*types.AgentTaskDetail, error) { + ret := _m.Called(ctx, userUUID, id) + + if len(ret) == 0 { + panic("no return value specified for GetTaskDetail") + } + + var r0 *types.AgentTaskDetail + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, int64) (*types.AgentTaskDetail, error)); ok { + return rf(ctx, userUUID, id) + } + if rf, ok := ret.Get(0).(func(context.Context, string, int64) *types.AgentTaskDetail); ok { + r0 = rf(ctx, userUUID, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentTaskDetail) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, int64) error); ok { + r1 = rf(ctx, userUUID, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetTaskDetail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskDetail' +type MockAgentComponent_GetTaskDetail_Call struct { + *mock.Call +} + +// GetTaskDetail is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - id int64 +func (_e *MockAgentComponent_Expecter) GetTaskDetail(ctx interface{}, userUUID interface{}, id interface{}) *MockAgentComponent_GetTaskDetail_Call { + return &MockAgentComponent_GetTaskDetail_Call{Call: _e.mock.On("GetTaskDetail", ctx, userUUID, id)} +} + +func (_c *MockAgentComponent_GetTaskDetail_Call) Run(run func(ctx context.Context, userUUID string, id int64)) *MockAgentComponent_GetTaskDetail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockAgentComponent_GetTaskDetail_Call) Return(_a0 *types.AgentTaskDetail, _a1 error) *MockAgentComponent_GetTaskDetail_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetTaskDetail_Call) RunAndReturn(run func(context.Context, string, int64) (*types.AgentTaskDetail, error)) *MockAgentComponent_GetTaskDetail_Call { + _c.Call.Return(run) + return _c +} + +// GetTemplateByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentComponent) GetTemplateByID(ctx context.Context, id int64, userUUID string) (*types.AgentTemplate, error) { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for GetTemplateByID") + } + + var r0 *types.AgentTemplate + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*types.AgentTemplate, error)); ok { + return rf(ctx, id, userUUID) + } + if rf, ok := ret.Get(0).(func(context.Context, int64, string) *types.AgentTemplate); ok { + r0 = rf(ctx, id, userUUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentTemplate) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, int64, string) error); ok { + r1 = rf(ctx, id, userUUID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_GetTemplateByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplateByID' +type MockAgentComponent_GetTemplateByID_Call struct { + *mock.Call +} + +// GetTemplateByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentComponent_Expecter) GetTemplateByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentComponent_GetTemplateByID_Call { + return &MockAgentComponent_GetTemplateByID_Call{Call: _e.mock.On("GetTemplateByID", ctx, id, userUUID)} +} + +func (_c *MockAgentComponent_GetTemplateByID_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentComponent_GetTemplateByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_GetTemplateByID_Call) Return(_a0 *types.AgentTemplate, _a1 error) *MockAgentComponent_GetTemplateByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_GetTemplateByID_Call) RunAndReturn(run func(context.Context, int64, string) (*types.AgentTemplate, error)) *MockAgentComponent_GetTemplateByID_Call { + _c.Call.Return(run) + return _c +} + +// IsInstanceExistsByContentID provides a mock function with given fields: ctx, instanceType, instanceContentID +func (_m *MockAgentComponent) IsInstanceExistsByContentID(ctx context.Context, instanceType string, instanceContentID string) (bool, error) { + ret := _m.Called(ctx, instanceType, instanceContentID) + + if len(ret) == 0 { + panic("no return value specified for IsInstanceExistsByContentID") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok { + return rf(ctx, instanceType, instanceContentID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) bool); ok { + r0 = rf(ctx, instanceType, instanceContentID) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, instanceType, instanceContentID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_IsInstanceExistsByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInstanceExistsByContentID' +type MockAgentComponent_IsInstanceExistsByContentID_Call struct { + *mock.Call +} + +// IsInstanceExistsByContentID is a helper method to define mock.On call +// - ctx context.Context +// - instanceType string +// - instanceContentID string +func (_e *MockAgentComponent_Expecter) IsInstanceExistsByContentID(ctx interface{}, instanceType interface{}, instanceContentID interface{}) *MockAgentComponent_IsInstanceExistsByContentID_Call { + return &MockAgentComponent_IsInstanceExistsByContentID_Call{Call: _e.mock.On("IsInstanceExistsByContentID", ctx, instanceType, instanceContentID)} +} + +func (_c *MockAgentComponent_IsInstanceExistsByContentID_Call) Run(run func(ctx context.Context, instanceType string, instanceContentID string)) *MockAgentComponent_IsInstanceExistsByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_IsInstanceExistsByContentID_Call) Return(_a0 bool, _a1 error) *MockAgentComponent_IsInstanceExistsByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_IsInstanceExistsByContentID_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *MockAgentComponent_IsInstanceExistsByContentID_Call { + _c.Call.Return(run) + return _c +} + +// ListInstancesByUserUUID provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentComponent) ListInstancesByUserUUID(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int) ([]*types.AgentInstance, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListInstancesByUserUUID") + } + + var r0 []*types.AgentInstance + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceFilter, int, int) ([]*types.AgentInstance, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceFilter, int, int) []*types.AgentInstance); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentInstanceFilter, int, int) int); ok { + r1 = rf(ctx, userUUID, filter, per, page) + } else { + r1 = ret.Get(1).(int) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, types.AgentInstanceFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentComponent_ListInstancesByUserUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInstancesByUserUUID' +type MockAgentComponent_ListInstancesByUserUUID_Call struct { + *mock.Call +} + +// ListInstancesByUserUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentInstanceFilter +// - per int +// - page int +func (_e *MockAgentComponent_Expecter) ListInstancesByUserUUID(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentComponent_ListInstancesByUserUUID_Call { + return &MockAgentComponent_ListInstancesByUserUUID_Call{Call: _e.mock.On("ListInstancesByUserUUID", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentComponent_ListInstancesByUserUUID_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int)) *MockAgentComponent_ListInstancesByUserUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentInstanceFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentComponent_ListInstancesByUserUUID_Call) Return(_a0 []*types.AgentInstance, _a1 int, _a2 error) *MockAgentComponent_ListInstancesByUserUUID_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentComponent_ListInstancesByUserUUID_Call) RunAndReturn(run func(context.Context, string, types.AgentInstanceFilter, int, int) ([]*types.AgentInstance, int, error)) *MockAgentComponent_ListInstancesByUserUUID_Call { + _c.Call.Return(run) + return _c +} + +// ListSessionHistories provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentComponent) ListSessionHistories(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) ([]*types.AgentInstanceSessionHistory, error) { + ret := _m.Called(ctx, userUUID, sessionUUID, instanceID) + + if len(ret) == 0 { + panic("no return value specified for ListSessionHistories") + } + + var r0 []*types.AgentInstanceSessionHistory + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) ([]*types.AgentInstanceSessionHistory, error)); ok { + return rf(ctx, userUUID, sessionUUID, instanceID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64) []*types.AgentInstanceSessionHistory); ok { + r0 = rf(ctx, userUUID, sessionUUID, instanceID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.AgentInstanceSessionHistory) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, int64) error); ok { + r1 = rf(ctx, userUUID, sessionUUID, instanceID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_ListSessionHistories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSessionHistories' +type MockAgentComponent_ListSessionHistories_Call struct { + *mock.Call +} + +// ListSessionHistories is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - sessionUUID string +// - instanceID int64 +func (_e *MockAgentComponent_Expecter) ListSessionHistories(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentComponent_ListSessionHistories_Call { + return &MockAgentComponent_ListSessionHistories_Call{Call: _e.mock.On("ListSessionHistories", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentComponent_ListSessionHistories_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentComponent_ListSessionHistories_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64)) + }) + return _c +} + +func (_c *MockAgentComponent_ListSessionHistories_Call) Return(_a0 []*types.AgentInstanceSessionHistory, _a1 error) *MockAgentComponent_ListSessionHistories_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_ListSessionHistories_Call) RunAndReturn(run func(context.Context, string, string, int64) ([]*types.AgentInstanceSessionHistory, error)) *MockAgentComponent_ListSessionHistories_Call { + _c.Call.Return(run) + return _c +} + +// ListSessions provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentComponent) ListSessions(ctx context.Context, userUUID string, filter types.AgentInstanceSessionFilter, per int, page int) ([]*types.AgentInstanceSession, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListSessions") + } + + var r0 []*types.AgentInstanceSession + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceSessionFilter, int, int) ([]*types.AgentInstanceSession, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentInstanceSessionFilter, int, int) []*types.AgentInstanceSession); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.AgentInstanceSession) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentInstanceSessionFilter, int, int) int); ok { + r1 = rf(ctx, userUUID, filter, per, page) + } else { + r1 = ret.Get(1).(int) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, types.AgentInstanceSessionFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentComponent_ListSessions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSessions' +type MockAgentComponent_ListSessions_Call struct { + *mock.Call +} + +// ListSessions is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentInstanceSessionFilter +// - per int +// - page int +func (_e *MockAgentComponent_Expecter) ListSessions(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentComponent_ListSessions_Call { + return &MockAgentComponent_ListSessions_Call{Call: _e.mock.On("ListSessions", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentComponent_ListSessions_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentInstanceSessionFilter, per int, page int)) *MockAgentComponent_ListSessions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentInstanceSessionFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentComponent_ListSessions_Call) Return(_a0 []*types.AgentInstanceSession, _a1 int, _a2 error) *MockAgentComponent_ListSessions_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentComponent_ListSessions_Call) RunAndReturn(run func(context.Context, string, types.AgentInstanceSessionFilter, int, int) ([]*types.AgentInstanceSession, int, error)) *MockAgentComponent_ListSessions_Call { + _c.Call.Return(run) + return _c +} + +// ListTasks provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentComponent) ListTasks(ctx context.Context, userUUID string, filter types.AgentTaskFilter, per int, page int) ([]types.AgentTaskListItem, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListTasks") + } + + var r0 []types.AgentTaskListItem + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentTaskFilter, int, int) ([]types.AgentTaskListItem, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentTaskFilter, int, int) []types.AgentTaskListItem); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentTaskListItem) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentTaskFilter, int, int) int); ok { + r1 = rf(ctx, userUUID, filter, per, page) + } else { + r1 = ret.Get(1).(int) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, types.AgentTaskFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentComponent_ListTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTasks' +type MockAgentComponent_ListTasks_Call struct { + *mock.Call +} + +// ListTasks is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentTaskFilter +// - per int +// - page int +func (_e *MockAgentComponent_Expecter) ListTasks(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentComponent_ListTasks_Call { + return &MockAgentComponent_ListTasks_Call{Call: _e.mock.On("ListTasks", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentComponent_ListTasks_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentTaskFilter, per int, page int)) *MockAgentComponent_ListTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentTaskFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentComponent_ListTasks_Call) Return(_a0 []types.AgentTaskListItem, _a1 int, _a2 error) *MockAgentComponent_ListTasks_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentComponent_ListTasks_Call) RunAndReturn(run func(context.Context, string, types.AgentTaskFilter, int, int) ([]types.AgentTaskListItem, int, error)) *MockAgentComponent_ListTasks_Call { + _c.Call.Return(run) + return _c +} + +// ListTemplatesByUserUUID provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentComponent) ListTemplatesByUserUUID(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int) ([]types.AgentTemplate, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListTemplatesByUserUUID") + } + + var r0 []types.AgentTemplate + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentTemplateFilter, int, int) ([]types.AgentTemplate, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentTemplateFilter, int, int) []types.AgentTemplate); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentTemplate) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentTemplateFilter, int, int) int); ok { + r1 = rf(ctx, userUUID, filter, per, page) + } else { + r1 = ret.Get(1).(int) + } + + if rf, ok := ret.Get(2).(func(context.Context, string, types.AgentTemplateFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentComponent_ListTemplatesByUserUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTemplatesByUserUUID' +type MockAgentComponent_ListTemplatesByUserUUID_Call struct { + *mock.Call +} + +// ListTemplatesByUserUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentTemplateFilter +// - per int +// - page int +func (_e *MockAgentComponent_Expecter) ListTemplatesByUserUUID(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentComponent_ListTemplatesByUserUUID_Call { + return &MockAgentComponent_ListTemplatesByUserUUID_Call{Call: _e.mock.On("ListTemplatesByUserUUID", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentComponent_ListTemplatesByUserUUID_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int)) *MockAgentComponent_ListTemplatesByUserUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentTemplateFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentComponent_ListTemplatesByUserUUID_Call) Return(_a0 []types.AgentTemplate, _a1 int, _a2 error) *MockAgentComponent_ListTemplatesByUserUUID_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentComponent_ListTemplatesByUserUUID_Call) RunAndReturn(run func(context.Context, string, types.AgentTemplateFilter, int, int) ([]types.AgentTemplate, int, error)) *MockAgentComponent_ListTemplatesByUserUUID_Call { + _c.Call.Return(run) + return _c +} + +// RefreshMonitor provides a mock function with given fields: ctx, monitorID +func (_m *MockAgentComponent) RefreshMonitor(ctx context.Context, monitorID string) error { + ret := _m.Called(ctx, monitorID) + + if len(ret) == 0 { + panic("no return value specified for RefreshMonitor") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = rf(ctx, monitorID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_RefreshMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshMonitor' +type MockAgentComponent_RefreshMonitor_Call struct { + *mock.Call +} + +// RefreshMonitor is a helper method to define mock.On call +// - ctx context.Context +// - monitorID string +func (_e *MockAgentComponent_Expecter) RefreshMonitor(ctx interface{}, monitorID interface{}) *MockAgentComponent_RefreshMonitor_Call { + return &MockAgentComponent_RefreshMonitor_Call{Call: _e.mock.On("RefreshMonitor", ctx, monitorID)} +} + +func (_c *MockAgentComponent_RefreshMonitor_Call) Run(run func(ctx context.Context, monitorID string)) *MockAgentComponent_RefreshMonitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockAgentComponent_RefreshMonitor_Call) Return(_a0 error) *MockAgentComponent_RefreshMonitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_RefreshMonitor_Call) RunAndReturn(run func(context.Context, string) error) *MockAgentComponent_RefreshMonitor_Call { + _c.Call.Return(run) + return _c +} + +// RewriteSessionHistory provides a mock function with given fields: ctx, userUUID, instanceID, sessionUUID, req +func (_m *MockAgentComponent) RewriteSessionHistory(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.RewriteSessionHistoryRequest) (*types.RewriteSessionHistoryResponse, error) { + ret := _m.Called(ctx, userUUID, instanceID, sessionUUID, req) + + if len(ret) == 0 { + panic("no return value specified for RewriteSessionHistory") + } + + var r0 *types.RewriteSessionHistoryResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, int64, string, *types.RewriteSessionHistoryRequest) (*types.RewriteSessionHistoryResponse, error)); ok { + return rf(ctx, userUUID, instanceID, sessionUUID, req) + } + if rf, ok := ret.Get(0).(func(context.Context, string, int64, string, *types.RewriteSessionHistoryRequest) *types.RewriteSessionHistoryResponse); ok { + r0 = rf(ctx, userUUID, instanceID, sessionUUID, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.RewriteSessionHistoryResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, int64, string, *types.RewriteSessionHistoryRequest) error); ok { + r1 = rf(ctx, userUUID, instanceID, sessionUUID, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_RewriteSessionHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RewriteSessionHistory' +type MockAgentComponent_RewriteSessionHistory_Call struct { + *mock.Call +} + +// RewriteSessionHistory is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceID int64 +// - sessionUUID string +// - req *types.RewriteSessionHistoryRequest +func (_e *MockAgentComponent_Expecter) RewriteSessionHistory(ctx interface{}, userUUID interface{}, instanceID interface{}, sessionUUID interface{}, req interface{}) *MockAgentComponent_RewriteSessionHistory_Call { + return &MockAgentComponent_RewriteSessionHistory_Call{Call: _e.mock.On("RewriteSessionHistory", ctx, userUUID, instanceID, sessionUUID, req)} +} + +func (_c *MockAgentComponent_RewriteSessionHistory_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.RewriteSessionHistoryRequest)) *MockAgentComponent_RewriteSessionHistory_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(string), args[4].(*types.RewriteSessionHistoryRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_RewriteSessionHistory_Call) Return(_a0 *types.RewriteSessionHistoryResponse, _a1 error) *MockAgentComponent_RewriteSessionHistory_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_RewriteSessionHistory_Call) RunAndReturn(run func(context.Context, string, int64, string, *types.RewriteSessionHistoryRequest) (*types.RewriteSessionHistoryResponse, error)) *MockAgentComponent_RewriteSessionHistory_Call { + _c.Call.Return(run) + return _c +} + +// SetMonitor provides a mock function with given fields: ctx, userUUID, request +func (_m *MockAgentComponent) SetMonitor(ctx context.Context, userUUID string, request types.AgentMonitorRequest) error { + ret := _m.Called(ctx, userUUID, request) + + if len(ret) == 0 { + panic("no return value specified for SetMonitor") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentMonitorRequest) error); ok { + r0 = rf(ctx, userUUID, request) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_SetMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMonitor' +type MockAgentComponent_SetMonitor_Call struct { + *mock.Call +} + +// SetMonitor is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - request types.AgentMonitorRequest +func (_e *MockAgentComponent_Expecter) SetMonitor(ctx interface{}, userUUID interface{}, request interface{}) *MockAgentComponent_SetMonitor_Call { + return &MockAgentComponent_SetMonitor_Call{Call: _e.mock.On("SetMonitor", ctx, userUUID, request)} +} + +func (_c *MockAgentComponent_SetMonitor_Call) Run(run func(ctx context.Context, userUUID string, request types.AgentMonitorRequest)) *MockAgentComponent_SetMonitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentMonitorRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_SetMonitor_Call) Return(_a0 error) *MockAgentComponent_SetMonitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_SetMonitor_Call) RunAndReturn(run func(context.Context, string, types.AgentMonitorRequest) error) *MockAgentComponent_SetMonitor_Call { + _c.Call.Return(run) + return _c +} + +// UpdateInstance provides a mock function with given fields: ctx, instance +func (_m *MockAgentComponent) UpdateInstance(ctx context.Context, instance *types.AgentInstance) error { + ret := _m.Called(ctx, instance) + + if len(ret) == 0 { + panic("no return value specified for UpdateInstance") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentInstance) error); ok { + r0 = rf(ctx, instance) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_UpdateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInstance' +type MockAgentComponent_UpdateInstance_Call struct { + *mock.Call +} + +// UpdateInstance is a helper method to define mock.On call +// - ctx context.Context +// - instance *types.AgentInstance +func (_e *MockAgentComponent_Expecter) UpdateInstance(ctx interface{}, instance interface{}) *MockAgentComponent_UpdateInstance_Call { + return &MockAgentComponent_UpdateInstance_Call{Call: _e.mock.On("UpdateInstance", ctx, instance)} +} + +func (_c *MockAgentComponent_UpdateInstance_Call) Run(run func(ctx context.Context, instance *types.AgentInstance)) *MockAgentComponent_UpdateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentComponent_UpdateInstance_Call) Return(_a0 error) *MockAgentComponent_UpdateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_UpdateInstance_Call) RunAndReturn(run func(context.Context, *types.AgentInstance) error) *MockAgentComponent_UpdateInstance_Call { + _c.Call.Return(run) + return _c +} + +// UpdateInstanceByContentID provides a mock function with given fields: ctx, userUUID, instanceType, instanceContentID, updateRequest +func (_m *MockAgentComponent) UpdateInstanceByContentID(ctx context.Context, userUUID string, instanceType string, instanceContentID string, updateRequest types.UpdateAgentInstanceRequest) (*types.AgentInstance, error) { + ret := _m.Called(ctx, userUUID, instanceType, instanceContentID, updateRequest) + + if len(ret) == 0 { + panic("no return value specified for UpdateInstanceByContentID") + } + + var r0 *types.AgentInstance + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, types.UpdateAgentInstanceRequest) (*types.AgentInstance, error)); ok { + return rf(ctx, userUUID, instanceType, instanceContentID, updateRequest) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, string, types.UpdateAgentInstanceRequest) *types.AgentInstance); ok { + r0 = rf(ctx, userUUID, instanceType, instanceContentID, updateRequest) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentInstance) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, string, types.UpdateAgentInstanceRequest) error); ok { + r1 = rf(ctx, userUUID, instanceType, instanceContentID, updateRequest) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentComponent_UpdateInstanceByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInstanceByContentID' +type MockAgentComponent_UpdateInstanceByContentID_Call struct { + *mock.Call +} + +// UpdateInstanceByContentID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceType string +// - instanceContentID string +// - updateRequest types.UpdateAgentInstanceRequest +func (_e *MockAgentComponent_Expecter) UpdateInstanceByContentID(ctx interface{}, userUUID interface{}, instanceType interface{}, instanceContentID interface{}, updateRequest interface{}) *MockAgentComponent_UpdateInstanceByContentID_Call { + return &MockAgentComponent_UpdateInstanceByContentID_Call{Call: _e.mock.On("UpdateInstanceByContentID", ctx, userUUID, instanceType, instanceContentID, updateRequest)} +} + +func (_c *MockAgentComponent_UpdateInstanceByContentID_Call) Run(run func(ctx context.Context, userUUID string, instanceType string, instanceContentID string, updateRequest types.UpdateAgentInstanceRequest)) *MockAgentComponent_UpdateInstanceByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(types.UpdateAgentInstanceRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_UpdateInstanceByContentID_Call) Return(_a0 *types.AgentInstance, _a1 error) *MockAgentComponent_UpdateInstanceByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentComponent_UpdateInstanceByContentID_Call) RunAndReturn(run func(context.Context, string, string, string, types.UpdateAgentInstanceRequest) (*types.AgentInstance, error)) *MockAgentComponent_UpdateInstanceByContentID_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID, req +func (_m *MockAgentComponent) UpdateSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64, req *types.UpdateAgentInstanceSessionRequest) error { + ret := _m.Called(ctx, userUUID, sessionUUID, instanceID, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateSessionByUUID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, int64, *types.UpdateAgentInstanceSessionRequest) error); ok { + r0 = rf(ctx, userUUID, sessionUUID, instanceID, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_UpdateSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSessionByUUID' +type MockAgentComponent_UpdateSessionByUUID_Call struct { + *mock.Call +} + +// UpdateSessionByUUID is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - sessionUUID string +// - instanceID int64 +// - req *types.UpdateAgentInstanceSessionRequest +func (_e *MockAgentComponent_Expecter) UpdateSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}, req interface{}) *MockAgentComponent_UpdateSessionByUUID_Call { + return &MockAgentComponent_UpdateSessionByUUID_Call{Call: _e.mock.On("UpdateSessionByUUID", ctx, userUUID, sessionUUID, instanceID, req)} +} + +func (_c *MockAgentComponent_UpdateSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64, req *types.UpdateAgentInstanceSessionRequest)) *MockAgentComponent_UpdateSessionByUUID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), args[4].(*types.UpdateAgentInstanceSessionRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_UpdateSessionByUUID_Call) Return(_a0 error) *MockAgentComponent_UpdateSessionByUUID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_UpdateSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64, *types.UpdateAgentInstanceSessionRequest) error) *MockAgentComponent_UpdateSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSessionHistoryFeedback provides a mock function with given fields: ctx, userUUID, instanceID, sessionUUID, req +func (_m *MockAgentComponent) UpdateSessionHistoryFeedback(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.FeedbackSessionHistoryRequest) error { + ret := _m.Called(ctx, userUUID, instanceID, sessionUUID, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateSessionHistoryFeedback") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, int64, string, *types.FeedbackSessionHistoryRequest) error); ok { + r0 = rf(ctx, userUUID, instanceID, sessionUUID, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_UpdateSessionHistoryFeedback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSessionHistoryFeedback' +type MockAgentComponent_UpdateSessionHistoryFeedback_Call struct { + *mock.Call +} + +// UpdateSessionHistoryFeedback is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceID int64 +// - sessionUUID string +// - req *types.FeedbackSessionHistoryRequest +func (_e *MockAgentComponent_Expecter) UpdateSessionHistoryFeedback(ctx interface{}, userUUID interface{}, instanceID interface{}, sessionUUID interface{}, req interface{}) *MockAgentComponent_UpdateSessionHistoryFeedback_Call { + return &MockAgentComponent_UpdateSessionHistoryFeedback_Call{Call: _e.mock.On("UpdateSessionHistoryFeedback", ctx, userUUID, instanceID, sessionUUID, req)} +} + +func (_c *MockAgentComponent_UpdateSessionHistoryFeedback_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.FeedbackSessionHistoryRequest)) *MockAgentComponent_UpdateSessionHistoryFeedback_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64), args[3].(string), args[4].(*types.FeedbackSessionHistoryRequest)) + }) + return _c +} + +func (_c *MockAgentComponent_UpdateSessionHistoryFeedback_Call) Return(_a0 error) *MockAgentComponent_UpdateSessionHistoryFeedback_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_UpdateSessionHistoryFeedback_Call) RunAndReturn(run func(context.Context, string, int64, string, *types.FeedbackSessionHistoryRequest) error) *MockAgentComponent_UpdateSessionHistoryFeedback_Call { + _c.Call.Return(run) + return _c +} + +// UpdateTemplate provides a mock function with given fields: ctx, template +func (_m *MockAgentComponent) UpdateTemplate(ctx context.Context, template *types.AgentTemplate) error { + ret := _m.Called(ctx, template) + + if len(ret) == 0 { + panic("no return value specified for UpdateTemplate") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentTemplate) error); ok { + r0 = rf(ctx, template) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentComponent_UpdateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTemplate' +type MockAgentComponent_UpdateTemplate_Call struct { + *mock.Call +} + +// UpdateTemplate is a helper method to define mock.On call +// - ctx context.Context +// - template *types.AgentTemplate +func (_e *MockAgentComponent_Expecter) UpdateTemplate(ctx interface{}, template interface{}) *MockAgentComponent_UpdateTemplate_Call { + return &MockAgentComponent_UpdateTemplate_Call{Call: _e.mock.On("UpdateTemplate", ctx, template)} +} + +func (_c *MockAgentComponent_UpdateTemplate_Call) Run(run func(ctx context.Context, template *types.AgentTemplate)) *MockAgentComponent_UpdateTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentTemplate)) + }) + return _c +} + +func (_c *MockAgentComponent_UpdateTemplate_Call) Return(_a0 error) *MockAgentComponent_UpdateTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentComponent_UpdateTemplate_Call) RunAndReturn(run func(context.Context, *types.AgentTemplate) error) *MockAgentComponent_UpdateTemplate_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentComponent creates a new instance of MockAgentComponent. 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 NewMockAgentComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentComponent { + mock := &MockAgentComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceAdapter.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceAdapter.go new file mode 100644 index 000000000..db789b58e --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceAdapter.go @@ -0,0 +1,406 @@ +// Code generated by mockery v2.53.0. DO NOT EDIT. + +package component + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + database "opencsg.com/csghub-server/builder/store/database" + + types "opencsg.com/csghub-server/common/types" +) + +// MockAgentInstanceAdapter is an autogenerated mock type for the AgentInstanceAdapter type +type MockAgentInstanceAdapter struct { + mock.Mock +} + +type MockAgentInstanceAdapter_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentInstanceAdapter) EXPECT() *MockAgentInstanceAdapter_Expecter { + return &MockAgentInstanceAdapter_Expecter{mock: &_m.Mock} +} + +// CreateInstance provides a mock function with given fields: ctx, userUUID, instance, template +func (_m *MockAgentInstanceAdapter) CreateInstance(ctx context.Context, userUUID string, instance *types.AgentInstance, template *database.AgentTemplate) (*types.AgentInstanceCreationResult, error) { + ret := _m.Called(ctx, userUUID, instance, template) + + if len(ret) == 0 { + panic("no return value specified for CreateInstance") + } + + var r0 *types.AgentInstanceCreationResult + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *types.AgentInstance, *database.AgentTemplate) (*types.AgentInstanceCreationResult, error)); ok { + return rf(ctx, userUUID, instance, template) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *types.AgentInstance, *database.AgentTemplate) *types.AgentInstanceCreationResult); ok { + r0 = rf(ctx, userUUID, instance, template) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentInstanceCreationResult) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *types.AgentInstance, *database.AgentTemplate) error); ok { + r1 = rf(ctx, userUUID, instance, template) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceAdapter_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance' +type MockAgentInstanceAdapter_CreateInstance_Call struct { + *mock.Call +} + +// CreateInstance is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instance *types.AgentInstance +// - template *database.AgentTemplate +func (_e *MockAgentInstanceAdapter_Expecter) CreateInstance(ctx interface{}, userUUID interface{}, instance interface{}, template interface{}) *MockAgentInstanceAdapter_CreateInstance_Call { + return &MockAgentInstanceAdapter_CreateInstance_Call{Call: _e.mock.On("CreateInstance", ctx, userUUID, instance, template)} +} + +func (_c *MockAgentInstanceAdapter_CreateInstance_Call) Run(run func(ctx context.Context, userUUID string, instance *types.AgentInstance, template *database.AgentTemplate)) *MockAgentInstanceAdapter_CreateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*types.AgentInstance), args[3].(*database.AgentTemplate)) + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_CreateInstance_Call) Return(_a0 *types.AgentInstanceCreationResult, _a1 error) *MockAgentInstanceAdapter_CreateInstance_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceAdapter_CreateInstance_Call) RunAndReturn(run func(context.Context, string, *types.AgentInstance, *database.AgentTemplate) (*types.AgentInstanceCreationResult, error)) *MockAgentInstanceAdapter_CreateInstance_Call { + _c.Call.Return(run) + return _c +} + +// DeleteInstance provides a mock function with given fields: ctx, userUUID, contentID +func (_m *MockAgentInstanceAdapter) DeleteInstance(ctx context.Context, userUUID string, contentID string) error { + ret := _m.Called(ctx, userUUID, contentID) + + if len(ret) == 0 { + panic("no return value specified for DeleteInstance") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, userUUID, contentID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentInstanceAdapter_DeleteInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstance' +type MockAgentInstanceAdapter_DeleteInstance_Call struct { + *mock.Call +} + +// DeleteInstance is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - contentID string +func (_e *MockAgentInstanceAdapter_Expecter) DeleteInstance(ctx interface{}, userUUID interface{}, contentID interface{}) *MockAgentInstanceAdapter_DeleteInstance_Call { + return &MockAgentInstanceAdapter_DeleteInstance_Call{Call: _e.mock.On("DeleteInstance", ctx, userUUID, contentID)} +} + +func (_c *MockAgentInstanceAdapter_DeleteInstance_Call) Run(run func(ctx context.Context, userUUID string, contentID string)) *MockAgentInstanceAdapter_DeleteInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_DeleteInstance_Call) Return(_a0 error) *MockAgentInstanceAdapter_DeleteInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceAdapter_DeleteInstance_Call) RunAndReturn(run func(context.Context, string, string) error) *MockAgentInstanceAdapter_DeleteInstance_Call { + _c.Call.Return(run) + return _c +} + +// GetInstanceType provides a mock function with no fields +func (_m *MockAgentInstanceAdapter) GetInstanceType() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetInstanceType") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockAgentInstanceAdapter_GetInstanceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceType' +type MockAgentInstanceAdapter_GetInstanceType_Call struct { + *mock.Call +} + +// GetInstanceType is a helper method to define mock.On call +func (_e *MockAgentInstanceAdapter_Expecter) GetInstanceType() *MockAgentInstanceAdapter_GetInstanceType_Call { + return &MockAgentInstanceAdapter_GetInstanceType_Call{Call: _e.mock.On("GetInstanceType")} +} + +func (_c *MockAgentInstanceAdapter_GetInstanceType_Call) Run(run func()) *MockAgentInstanceAdapter_GetInstanceType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_GetInstanceType_Call) Return(_a0 string) *MockAgentInstanceAdapter_GetInstanceType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceAdapter_GetInstanceType_Call) RunAndReturn(run func() string) *MockAgentInstanceAdapter_GetInstanceType_Call { + _c.Call.Return(run) + return _c +} + +// GetQuotaPerUser provides a mock function with no fields +func (_m *MockAgentInstanceAdapter) GetQuotaPerUser() int { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GetQuotaPerUser") + } + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// MockAgentInstanceAdapter_GetQuotaPerUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQuotaPerUser' +type MockAgentInstanceAdapter_GetQuotaPerUser_Call struct { + *mock.Call +} + +// GetQuotaPerUser is a helper method to define mock.On call +func (_e *MockAgentInstanceAdapter_Expecter) GetQuotaPerUser() *MockAgentInstanceAdapter_GetQuotaPerUser_Call { + return &MockAgentInstanceAdapter_GetQuotaPerUser_Call{Call: _e.mock.On("GetQuotaPerUser")} +} + +func (_c *MockAgentInstanceAdapter_GetQuotaPerUser_Call) Run(run func()) *MockAgentInstanceAdapter_GetQuotaPerUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_GetQuotaPerUser_Call) Return(_a0 int) *MockAgentInstanceAdapter_GetQuotaPerUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceAdapter_GetQuotaPerUser_Call) RunAndReturn(run func() int) *MockAgentInstanceAdapter_GetQuotaPerUser_Call { + _c.Call.Return(run) + return _c +} + +// IsInstanceRunning provides a mock function with given fields: ctx, userUUID, contentID, builtIn +func (_m *MockAgentInstanceAdapter) IsInstanceRunning(ctx context.Context, userUUID string, contentID string, builtIn bool) (bool, error) { + ret := _m.Called(ctx, userUUID, contentID, builtIn) + + if len(ret) == 0 { + panic("no return value specified for IsInstanceRunning") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, bool) (bool, error)); ok { + return rf(ctx, userUUID, contentID, builtIn) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, bool) bool); ok { + r0 = rf(ctx, userUUID, contentID, builtIn) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, bool) error); ok { + r1 = rf(ctx, userUUID, contentID, builtIn) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceAdapter_IsInstanceRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInstanceRunning' +type MockAgentInstanceAdapter_IsInstanceRunning_Call struct { + *mock.Call +} + +// IsInstanceRunning is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - contentID string +// - builtIn bool +func (_e *MockAgentInstanceAdapter_Expecter) IsInstanceRunning(ctx interface{}, userUUID interface{}, contentID interface{}, builtIn interface{}) *MockAgentInstanceAdapter_IsInstanceRunning_Call { + return &MockAgentInstanceAdapter_IsInstanceRunning_Call{Call: _e.mock.On("IsInstanceRunning", ctx, userUUID, contentID, builtIn)} +} + +func (_c *MockAgentInstanceAdapter_IsInstanceRunning_Call) Run(run func(ctx context.Context, userUUID string, contentID string, builtIn bool)) *MockAgentInstanceAdapter_IsInstanceRunning_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(bool)) + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_IsInstanceRunning_Call) Return(_a0 bool, _a1 error) *MockAgentInstanceAdapter_IsInstanceRunning_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceAdapter_IsInstanceRunning_Call) RunAndReturn(run func(context.Context, string, string, bool) (bool, error)) *MockAgentInstanceAdapter_IsInstanceRunning_Call { + _c.Call.Return(run) + return _c +} + +// Status provides a mock function with given fields: ctx, userUUID, contentIDs, builtInMap +func (_m *MockAgentInstanceAdapter) Status(ctx context.Context, userUUID string, contentIDs []string, builtInMap map[string]bool) ([]types.AgentInstanceStatusResult, error) { + ret := _m.Called(ctx, userUUID, contentIDs, builtInMap) + + if len(ret) == 0 { + panic("no return value specified for Status") + } + + var r0 []types.AgentInstanceStatusResult + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, []string, map[string]bool) ([]types.AgentInstanceStatusResult, error)); ok { + return rf(ctx, userUUID, contentIDs, builtInMap) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []string, map[string]bool) []types.AgentInstanceStatusResult); ok { + r0 = rf(ctx, userUUID, contentIDs, builtInMap) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentInstanceStatusResult) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []string, map[string]bool) error); ok { + r1 = rf(ctx, userUUID, contentIDs, builtInMap) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentInstanceAdapter_Status_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Status' +type MockAgentInstanceAdapter_Status_Call struct { + *mock.Call +} + +// Status is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - contentIDs []string +// - builtInMap map[string]bool +func (_e *MockAgentInstanceAdapter_Expecter) Status(ctx interface{}, userUUID interface{}, contentIDs interface{}, builtInMap interface{}) *MockAgentInstanceAdapter_Status_Call { + return &MockAgentInstanceAdapter_Status_Call{Call: _e.mock.On("Status", ctx, userUUID, contentIDs, builtInMap)} +} + +func (_c *MockAgentInstanceAdapter_Status_Call) Run(run func(ctx context.Context, userUUID string, contentIDs []string, builtInMap map[string]bool)) *MockAgentInstanceAdapter_Status_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string), args[3].(map[string]bool)) + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_Status_Call) Return(_a0 []types.AgentInstanceStatusResult, _a1 error) *MockAgentInstanceAdapter_Status_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceAdapter_Status_Call) RunAndReturn(run func(context.Context, string, []string, map[string]bool) ([]types.AgentInstanceStatusResult, error)) *MockAgentInstanceAdapter_Status_Call { + _c.Call.Return(run) + return _c +} + +// UpdateInstance provides a mock function with given fields: ctx, userUUID, instance +func (_m *MockAgentInstanceAdapter) UpdateInstance(ctx context.Context, userUUID string, instance *types.AgentInstance) error { + ret := _m.Called(ctx, userUUID, instance) + + if len(ret) == 0 { + panic("no return value specified for UpdateInstance") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, *types.AgentInstance) error); ok { + r0 = rf(ctx, userUUID, instance) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentInstanceAdapter_UpdateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInstance' +type MockAgentInstanceAdapter_UpdateInstance_Call struct { + *mock.Call +} + +// UpdateInstance is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instance *types.AgentInstance +func (_e *MockAgentInstanceAdapter_Expecter) UpdateInstance(ctx interface{}, userUUID interface{}, instance interface{}) *MockAgentInstanceAdapter_UpdateInstance_Call { + return &MockAgentInstanceAdapter_UpdateInstance_Call{Call: _e.mock.On("UpdateInstance", ctx, userUUID, instance)} +} + +func (_c *MockAgentInstanceAdapter_UpdateInstance_Call) Run(run func(ctx context.Context, userUUID string, instance *types.AgentInstance)) *MockAgentInstanceAdapter_UpdateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(*types.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentInstanceAdapter_UpdateInstance_Call) Return(_a0 error) *MockAgentInstanceAdapter_UpdateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceAdapter_UpdateInstance_Call) RunAndReturn(run func(context.Context, string, *types.AgentInstance) error) *MockAgentInstanceAdapter_UpdateInstance_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentInstanceAdapter creates a new instance of MockAgentInstanceAdapter. 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 NewMockAgentInstanceAdapter(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentInstanceAdapter { + mock := &MockAgentInstanceAdapter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_SpaceComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_SpaceComponent.go index 52d5aa7c4..330da4e79 100644 --- a/_mocks/opencsg.com/csghub-server/component/mock_SpaceComponent.go +++ b/_mocks/opencsg.com/csghub-server/component/mock_SpaceComponent.go @@ -915,6 +915,65 @@ func (_c *MockSpaceComponent_Status_Call) RunAndReturn(run func(context.Context, return _c } +// StatusByPaths provides a mock function with given fields: ctx, paths +func (_m *MockSpaceComponent) StatusByPaths(ctx context.Context, paths []string) (map[string]string, error) { + ret := _m.Called(ctx, paths) + + if len(ret) == 0 { + panic("no return value specified for StatusByPaths") + } + + var r0 map[string]string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, []string) (map[string]string, error)); ok { + return rf(ctx, paths) + } + if rf, ok := ret.Get(0).(func(context.Context, []string) map[string]string); ok { + r0 = rf(ctx, paths) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[string]string) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok { + r1 = rf(ctx, paths) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceComponent_StatusByPaths_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StatusByPaths' +type MockSpaceComponent_StatusByPaths_Call struct { + *mock.Call +} + +// StatusByPaths is a helper method to define mock.On call +// - ctx context.Context +// - paths []string +func (_e *MockSpaceComponent_Expecter) StatusByPaths(ctx interface{}, paths interface{}) *MockSpaceComponent_StatusByPaths_Call { + return &MockSpaceComponent_StatusByPaths_Call{Call: _e.mock.On("StatusByPaths", ctx, paths)} +} + +func (_c *MockSpaceComponent_StatusByPaths_Call) Run(run func(ctx context.Context, paths []string)) *MockSpaceComponent_StatusByPaths_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].([]string)) + }) + return _c +} + +func (_c *MockSpaceComponent_StatusByPaths_Call) Return(_a0 map[string]string, _a1 error) *MockSpaceComponent_StatusByPaths_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceComponent_StatusByPaths_Call) RunAndReturn(run func(context.Context, []string) (map[string]string, error)) *MockSpaceComponent_StatusByPaths_Call { + _c.Call.Return(run) + return _c +} + // Stop provides a mock function with given fields: ctx, namespace, name, deleteSpace func (_m *MockSpaceComponent) Stop(ctx context.Context, namespace string, name string, deleteSpace bool) error { ret := _m.Called(ctx, namespace, name, deleteSpace) diff --git a/builder/store/database/agent_instance.go b/builder/store/database/agent_instance.go new file mode 100644 index 000000000..825437470 --- /dev/null +++ b/builder/store/database/agent_instance.go @@ -0,0 +1,332 @@ +package database + +import ( + "context" + "strings" + + "github.com/uptrace/bun" + "opencsg.com/csghub-server/common/errorx" + "opencsg.com/csghub-server/common/types" +) + +// AgentTemplate represents the template for an agent +type AgentTemplate struct { + ID int64 `bun:",pk,autoincrement" json:"id"` + Type string `bun:",notnull" json:"type"` // Possible values: langflow, agno, code, etc. + UserUUID string `bun:",notnull" json:"user_uuid"` // Associated with the corresponding field in the User table + Name string `bun:",notnull" json:"name"` // Agent template name + Description string `bun:",nullzero" json:"description"` // Agent template description + Content string `bun:",type:text" json:"content"` // Used to store the complete content of the template + Public bool `bun:",notnull" json:"public"` // Whether the template is public + Metadata map[string]any `bun:",type:jsonb" json:"metadata"` // Template metadata + times +} + +// AgentInstance represents an instance created from an agent template +type AgentInstance struct { + ID int64 `bun:",pk,autoincrement" json:"id"` + TemplateID int64 `bun:"" json:"template_id"` // Associated with the id in the template table + UserUUID string `bun:",notnull" json:"user_uuid"` // Associated with the corresponding field in the User table + Type string `bun:",notnull" json:"type"` // Possible values: langflow, agno, code, etc. + ContentID string `bun:",notnull" json:"content_id"` // Used to specify the unique id of the instance resource + Public bool `bun:",notnull" json:"public"` // Whether the instance is public + Name string `bun:",nullzero" json:"name"` // Instance name + Description string `bun:",nullzero" json:"description"` // Instance description + BuiltIn bool `bun:",notnull" json:"built_in"` // Whether the instance is built-in + Metadata map[string]any `bun:",type:jsonb" json:"metadata"` // Instance metadata + times +} + +// AgentTemplateStore provides database operations for AgentTemplate +type AgentTemplateStore interface { + Create(ctx context.Context, template *AgentTemplate) (*AgentTemplate, error) + FindByID(ctx context.Context, id int64) (*AgentTemplate, error) + ListByUserUUID(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int) ([]AgentTemplate, int, error) + Update(ctx context.Context, template *AgentTemplate) error + Delete(ctx context.Context, id int64) error +} + +// AgentInstanceStore provides database operations for AgentInstance +type AgentInstanceStore interface { + Create(ctx context.Context, instance *AgentInstance) (*AgentInstance, error) + FindByID(ctx context.Context, id int64) (*AgentInstance, error) + FindByIDs(ctx context.Context, ids []int64) ([]AgentInstance, error) + FindByContentID(ctx context.Context, instanceType string, contentID string) (*AgentInstance, error) + IsInstanceExistsByContentID(ctx context.Context, instanceType string, contentID string) (bool, error) + ListByUserUUID(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int) ([]AgentInstance, int, error) + Update(ctx context.Context, instance *AgentInstance) error + Delete(ctx context.Context, id int64) error + CountByUserAndType(ctx context.Context, userUUID string, instanceType string) (int, error) +} + +// agentTemplateStoreImpl is the implementation of AgentTemplateStore +type agentTemplateStoreImpl struct { + db *DB +} + +// agentInstanceStoreImpl is the implementation of AgentInstanceStore +type agentInstanceStoreImpl struct { + db *DB +} + +// NewAgentTemplateStore creates a new AgentTemplateStore +func NewAgentTemplateStore() AgentTemplateStore { + return &agentTemplateStoreImpl{ + db: defaultDB, + } +} + +// NewAgentTemplateStoreWithDB creates a new AgentTemplateStore with a specific DB +func NewAgentTemplateStoreWithDB(db *DB) AgentTemplateStore { + return &agentTemplateStoreImpl{ + db: db, + } +} + +// NewAgentInstanceStore creates a new AgentInstanceStore +func NewAgentInstanceStore() AgentInstanceStore { + return &agentInstanceStoreImpl{ + db: defaultDB, + } +} + +// NewAgentInstanceStoreWithDB creates a new AgentInstanceStore with a specific DB +func NewAgentInstanceStoreWithDB(db *DB) AgentInstanceStore { + return &agentInstanceStoreImpl{ + db: db, + } +} + +// Create inserts a new AgentTemplate into the database +func (s *agentTemplateStoreImpl) Create(ctx context.Context, template *AgentTemplate) (*AgentTemplate, error) { + res, err := s.db.Core.NewInsert().Model(template).Exec(ctx, template) + if err = assertAffectedOneRow(res, err); err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "template_type": template.Type, + "user_uuid": template.UserUUID, + }) + } + return template, nil +} + +// FindByID retrieves an AgentTemplate by its ID +func (s *agentTemplateStoreImpl) FindByID(ctx context.Context, id int64) (*AgentTemplate, error) { + template := &AgentTemplate{} + err := s.db.Core.NewSelect().Model(template).Where("id = ?", id).Scan(ctx, template) + if err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "template_id": id, + }) + } + return template, nil +} + +func (s *agentTemplateStoreImpl) applyAgentTemplateFilters(query *bun.SelectQuery, filter types.AgentTemplateFilter) *bun.SelectQuery { + filter.Search = strings.TrimSpace(filter.Search) + if filter.Search != "" { + searchPattern := "%" + filter.Search + "%" + query = query.Where("LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)", searchPattern, searchPattern) + } + + if filter.Type != "" { + query = query.Where("type = ?", filter.Type) + } + + return query +} + +// ListByUserUUID retrieves all AgentTemplates for a specific user +func (s *agentTemplateStoreImpl) ListByUserUUID(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int) ([]AgentTemplate, int, error) { + var templates []AgentTemplate + query := s.db.Core.NewSelect().Model(&templates).Where("user_uuid = ? OR public = ?", userUUID, true) + + query = s.applyAgentTemplateFilters(query, filter) + + total, err := query.Count(ctx) + if err != nil { + return nil, 0, errorx.HandleDBError(err, map[string]any{ + "user_uuid": userUUID, + }) + } + + err = query.Order("updated_at DESC").Limit(per).Offset((page-1)*per).Scan(ctx, &templates) + if err != nil { + return nil, 0, errorx.HandleDBError(err, map[string]any{ + "user_uuid": userUUID, + }) + } + return templates, total, nil +} + +// Update updates an existing AgentTemplate +func (s *agentTemplateStoreImpl) Update(ctx context.Context, template *AgentTemplate) error { + res, err := s.db.Core.NewUpdate().Model(template).Where("id = ?", template.ID).Exec(ctx) + if err = assertAffectedOneRow(res, err); err != nil { + return errorx.HandleDBError(err, map[string]any{ + "template_id": template.ID, + }) + } + return nil +} + +// Delete removes an AgentTemplate from the database +func (s *agentTemplateStoreImpl) Delete(ctx context.Context, id int64) error { + res, err := s.db.Core.NewDelete().Model((*AgentTemplate)(nil)).Where("id = ?", id).Exec(ctx) + if err = assertAffectedOneRow(res, err); err != nil { + return errorx.HandleDBError(err, map[string]any{ + "template_id": id, + }) + } + return nil +} + +// Create inserts a new AgentInstance into the database +func (s *agentInstanceStoreImpl) Create(ctx context.Context, instance *AgentInstance) (*AgentInstance, error) { + res, err := s.db.Core.NewInsert().Model(instance).Exec(ctx, instance) + if err = assertAffectedOneRow(res, err); err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "template_id": instance.TemplateID, + "user_uuid": instance.UserUUID, + "content_id": instance.ContentID, + }) + } + return instance, nil +} + +// FindByID retrieves an AgentInstance by its ID +func (s *agentInstanceStoreImpl) FindByID(ctx context.Context, id int64) (*AgentInstance, error) { + instance := &AgentInstance{} + err := s.db.Core.NewSelect().Model(instance).Where("id = ?", id).Scan(ctx, instance) + if err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "instance_id": id, + }) + } + return instance, nil +} + +// FindByIDs retrieves AgentInstances by their IDs +func (s *agentInstanceStoreImpl) FindByIDs(ctx context.Context, ids []int64) ([]AgentInstance, error) { + instances := make([]AgentInstance, len(ids)) + err := s.db.Core.NewSelect().Model(&instances).Where("id IN (?)", bun.In(ids)).Scan(ctx, &instances) + if err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "instance_ids": ids, + }) + } + return instances, nil +} + +// FindByContentID retrieves an AgentInstance by its content ID +func (s *agentInstanceStoreImpl) FindByContentID(ctx context.Context, instanceType string, contentID string) (*AgentInstance, error) { + instance := &AgentInstance{} + err := s.db.Core.NewSelect().Model(instance).Where("type = ? AND content_id = ?", instanceType, contentID).Limit(1).Scan(ctx, instance) + if err != nil { + return nil, errorx.HandleDBError(err, map[string]any{ + "instance_type": instanceType, + "content_id": contentID, + }) + } + return instance, nil +} + +func (s *agentInstanceStoreImpl) IsInstanceExistsByContentID(ctx context.Context, instanceType string, contentID string) (bool, error) { + exists, err := s.db.Core.NewSelect(). + Model((*AgentInstance)(nil)). + Where("type = ? AND content_id = ?", instanceType, contentID). + Exists(ctx) + if err != nil { + return false, errorx.HandleDBError(err, map[string]any{ + "instance_type": instanceType, + "content_id": contentID, + }) + } + + return exists, nil +} + +func (s *agentInstanceStoreImpl) applyAgentInstanceFilters(query *bun.SelectQuery, filter types.AgentInstanceFilter) *bun.SelectQuery { + filter.Search = strings.TrimSpace(filter.Search) + if filter.Search != "" { + searchPattern := "%" + filter.Search + "%" + query = query.Where("LOWER(name) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?)", searchPattern, searchPattern) + } + + if filter.Type != "" { + query = query.Where("type = ?", filter.Type) + } + + // Apply template ID filter + if filter.TemplateID != nil { + query = query.Where("template_id = ?", *filter.TemplateID) + } + + if filter.BuiltIn != nil { + query = query.Where("built_in = ?", *filter.BuiltIn) + } + + if filter.Public != nil { + query = query.Where("public = ?", *filter.Public) + } + + return query +} + +func (s *agentInstanceStoreImpl) ListByUserUUID(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int) ([]AgentInstance, int, error) { + var instances []AgentInstance + query := s.db.Core.NewSelect().Model(&instances).Where("user_uuid = ? OR public = ?", userUUID, true) + + query = s.applyAgentInstanceFilters(query, filter) + + total, err := query.Count(ctx) + if err != nil { + return nil, 0, errorx.HandleDBError(err, map[string]any{ + "user_uuid": userUUID, + }) + } + + err = query.Order("updated_at DESC").Limit(per).Offset((page-1)*per).Scan(ctx, &instances) + if err != nil { + return nil, 0, errorx.HandleDBError(err, map[string]any{ + "user_uuid": userUUID, + }) + } + return instances, total, nil +} + +// Update updates an existing AgentInstance +func (s *agentInstanceStoreImpl) Update(ctx context.Context, instance *AgentInstance) error { + res, err := s.db.Core.NewUpdate().Model(instance).Where("id = ?", instance.ID).Exec(ctx) + if err = assertAffectedOneRow(res, err); err != nil { + return errorx.HandleDBError(err, map[string]any{ + "instance_id": instance.ID, + }) + } + return nil +} + +// Delete removes an AgentInstance from the database +func (s *agentInstanceStoreImpl) Delete(ctx context.Context, id int64) error { + res, err := s.db.Core.NewDelete().Model((*AgentInstance)(nil)).Where("id = ?", id).Exec(ctx) + if err = assertAffectedOneRow(res, err); err != nil { + return errorx.HandleDBError(err, map[string]any{ + "instance_id": id, + }) + } + return nil +} + +// CountByUserAndType returns the count of agent instances for a specific user and type +func (s *agentInstanceStoreImpl) CountByUserAndType(ctx context.Context, userUUID string, instanceType string) (int, error) { + count, err := s.db.Core.NewSelect(). + Model((*AgentInstance)(nil)). + Where("user_uuid = ? AND type = ?", userUUID, instanceType). + Count(ctx) + if err != nil { + return 0, errorx.HandleDBError(err, map[string]any{ + "user_uuid": userUUID, + "instance_type": instanceType, + }) + } + return count, nil +} diff --git a/builder/store/database/deploy_task.go b/builder/store/database/deploy_task.go index 126842828..e8b465a2e 100644 --- a/builder/store/database/deploy_task.go +++ b/builder/store/database/deploy_task.go @@ -81,6 +81,7 @@ type DeployTaskStore interface { CreateDeploy(ctx context.Context, deploy *Deploy) error UpdateDeploy(ctx context.Context, deploy *Deploy) error GetLatestDeployBySpaceID(ctx context.Context, spaceID int64) (*Deploy, error) + GetLatestDeploysBySpaceIDs(ctx context.Context, spaceIDs []int64) (map[int64]*Deploy, error) CreateDeployTask(ctx context.Context, deployTask *DeployTask) error UpdateDeployTask(ctx context.Context, deployTask *DeployTask) error GetDeployTask(ctx context.Context, id int64) (*DeployTask, error) @@ -138,6 +139,33 @@ func (s *deployTaskStoreImpl) GetLatestDeployBySpaceID(ctx context.Context, spac return deploy, err } +// GetLatestDeploysBySpaceIDs gets the latest deploy for each space ID in a single query +func (s *deployTaskStoreImpl) GetLatestDeploysBySpaceIDs(ctx context.Context, spaceIDs []int64) (map[int64]*Deploy, error) { + if len(spaceIDs) == 0 { + return make(map[int64]*Deploy), nil + } + + var deploys []Deploy + err := s.db.Core.NewSelect(). + ColumnExpr("DISTINCT ON (space_id) *"). + Model(&deploys). + Where("space_id IN (?)", bun.In(spaceIDs)). + Order("space_id", "created_at DESC"). + Scan(ctx) + + if err != nil && !errors.Is(err, sql.ErrNoRows) { + return nil, errorx.HandleDBError(err, nil) + } + + result := make(map[int64]*Deploy, len(deploys)) + for i := range deploys { + deploy := &deploys[i] + result[deploy.SpaceID] = deploy + } + + return result, nil +} + func (s *deployTaskStoreImpl) CreateDeployTask(ctx context.Context, deployTask *DeployTask) error { _, err := s.db.Core.NewInsert().Model(deployTask).Exec(ctx, deployTask) err = errorx.HandleDBError(err, nil) diff --git a/builder/store/database/deploy_task_test.go b/builder/store/database/deploy_task_test.go index d3258cdd7..fef1fbd57 100644 --- a/builder/store/database/deploy_task_test.go +++ b/builder/store/database/deploy_task_test.go @@ -653,3 +653,100 @@ func TestDeployTaskStore_DeleteDeployByID(t *testing.T) { err = store.DeleteDeployByID(ctx, 100, 999999) require.NotNil(t, err) } + +func TestDeployTaskStore_GetLatestDeploysBySpaceIDs(t *testing.T) { + db := tests.InitTestDB() + defer db.Close() + ctx := context.TODO() + store := database.NewDeployTaskStoreWithDB(db) + + // Test with empty spaceIDs + result, err := store.GetLatestDeploysBySpaceIDs(ctx, []int64{}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 0, len(result)) + + // Create test data: multiple deploys for different space IDs + // Space 100: 3 deploys (should return the latest) + // Space 200: 2 deploys (should return the latest) + // Space 300: 1 deploy (should return that one) + // Space 400: no deploys (should not appear in result) + + now := time.Now().UTC() + space100Deploys := []database.Deploy{ + {SpaceID: 100, DeployName: "space100-old", SvcName: "svc100-1", UserID: 1, RepoID: 1, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test"}, + {SpaceID: 100, DeployName: "space100-middle", SvcName: "svc100-2", UserID: 1, RepoID: 1, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test"}, + {SpaceID: 100, DeployName: "space100-latest", SvcName: "svc100-3", UserID: 1, RepoID: 1, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test"}, + } + + space200Deploys := []database.Deploy{ + {SpaceID: 200, DeployName: "space200-old", SvcName: "svc200-1", UserID: 1, RepoID: 2, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test"}, + {SpaceID: 200, DeployName: "space200-latest", SvcName: "svc200-2", UserID: 1, RepoID: 2, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test"}, + } + + space300Deploy := database.Deploy{ + SpaceID: 300, DeployName: "space300-single", SvcName: "svc300-1", UserID: 1, RepoID: 3, GitPath: "test", GitBranch: "main", Template: "test", Hardware: "test", + } + + // Create deploys with different timestamps + for i, dp := range space100Deploys { + err := store.CreateDeploy(ctx, &dp) + require.Nil(t, err) + // Set created_at to different times (oldest first) + _, err = db.BunDB.ExecContext(ctx, "UPDATE deploys SET created_at = ?, updated_at = ? WHERE id = ?", + now.Add(-time.Duration(3-i)*time.Hour), now.Add(-time.Duration(3-i)*time.Hour), dp.ID) + require.NoError(t, err) + } + + for i, dp := range space200Deploys { + err := store.CreateDeploy(ctx, &dp) + require.Nil(t, err) + // Set created_at to different times (oldest first) + _, err = db.BunDB.ExecContext(ctx, "UPDATE deploys SET created_at = ?, updated_at = ? WHERE id = ?", + now.Add(-time.Duration(2-i)*time.Hour), now.Add(-time.Duration(2-i)*time.Hour), dp.ID) + require.NoError(t, err) + } + + err = store.CreateDeploy(ctx, &space300Deploy) + require.Nil(t, err) + + // Test: Get latest deploys for space 100, 200, 300, 400 + spaceIDs := []int64{100, 200, 300, 400} + result, err = store.GetLatestDeploysBySpaceIDs(ctx, spaceIDs) + require.Nil(t, err) + require.NotNil(t, result) + + // Should have 3 results (space 400 has no deploys, so won't appear) + require.Equal(t, 3, len(result)) + + // Verify space 100 has the latest deploy + deploy100, exists := result[100] + require.True(t, exists) + require.NotNil(t, deploy100) + require.Equal(t, "space100-latest", deploy100.DeployName) + require.Equal(t, "svc100-3", deploy100.SvcName) + + // Verify space 200 has the latest deploy + deploy200, exists := result[200] + require.True(t, exists) + require.NotNil(t, deploy200) + require.Equal(t, "space200-latest", deploy200.DeployName) + require.Equal(t, "svc200-2", deploy200.SvcName) + + // Verify space 300 has its deploy + deploy300, exists := result[300] + require.True(t, exists) + require.NotNil(t, deploy300) + require.Equal(t, "space300-single", deploy300.DeployName) + require.Equal(t, "svc300-1", deploy300.SvcName) + + // Verify space 400 is not in the result (no deploys) + _, exists = result[400] + require.False(t, exists) + + // Test with only space IDs that don't exist + result, err = store.GetLatestDeploysBySpaceIDs(ctx, []int64{999, 998}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 0, len(result)) +} diff --git a/common/utils/common/string.go b/common/utils/common/string.go index cbfc20554..044e7c5e8 100644 --- a/common/utils/common/string.go +++ b/common/utils/common/string.go @@ -35,6 +35,20 @@ func TruncString(s string, limit int) string { return string(s1) } +func TruncStringByRune(s string, limit int) string { + runes := []rune(s) + if len(runes) <= limit { + return s + } + + // Reserve 3 runes for "..." + if limit <= 3 { + return string(runes[:limit]) + } + + return string(runes[:limit-3]) + "..." +} + func MD5Hash(s string) string { hash := md5.New() hash.Write([]byte(s)) @@ -49,3 +63,19 @@ func SHA256(s string) string { hashBytes := hash.Sum(nil) return hex.EncodeToString(hashBytes) } + +func SafeDeref(p *string) string { + if p != nil { + return *p + } + return "" +} + +// AllocStringPtr returns a pointer to a heap-allocated copy of the string +// This ensures the string has a stable lifetime and can be safely stored in structs +func AllocStringPtr(s string) *string { + // Allocate on heap explicitly to ensure stable lifetime + ptr := new(string) + *ptr = s + return ptr +} diff --git a/component/agent.go b/component/agent.go new file mode 100644 index 000000000..bb28f5c5f --- /dev/null +++ b/component/agent.go @@ -0,0 +1,49 @@ +package component + +import ( + "context" + + "opencsg.com/csghub-server/common/types" +) + +// AgentComponent defines the interface for agent-related operations +type AgentComponent interface { + // Template operations + CreateTemplate(ctx context.Context, template *types.AgentTemplate) error + GetTemplateByID(ctx context.Context, id int64, userUUID string) (*types.AgentTemplate, error) + ListTemplatesByUserUUID(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int) ([]types.AgentTemplate, int, error) + UpdateTemplate(ctx context.Context, template *types.AgentTemplate) error + DeleteTemplate(ctx context.Context, id int64, userUUID string) error + + // Instance operations + CreateInstance(ctx context.Context, instance *types.AgentInstance) error + GetInstanceByID(ctx context.Context, id int64, userUUID string) (*types.AgentInstance, error) + IsInstanceExistsByContentID(ctx context.Context, instanceType string, instanceContentID string) (bool, error) + ListInstancesByUserUUID(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int) ([]*types.AgentInstance, int, error) + UpdateInstance(ctx context.Context, instance *types.AgentInstance) error + UpdateInstanceByContentID(ctx context.Context, userUUID string, instanceType string, instanceContentID string, updateRequest types.UpdateAgentInstanceRequest) (*types.AgentInstance, error) + DeleteInstance(ctx context.Context, id int64, userUUID string) error + DeleteInstanceByContentID(ctx context.Context, userUUID string, instanceType string, instanceContentID string) error + + // Session operations + CreateSession(ctx context.Context, userUUID string, req *types.CreateAgentInstanceSessionRequest) (sessionUUID string, err error) + ListSessions(ctx context.Context, userUUID string, filter types.AgentInstanceSessionFilter, per int, page int) ([]*types.AgentInstanceSession, int, error) + GetSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) (*types.AgentInstanceSession, error) + DeleteSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) error + UpdateSessionByUUID(ctx context.Context, userUUID string, sessionUUID string, instanceID int64, req *types.UpdateAgentInstanceSessionRequest) error + ListSessionHistories(ctx context.Context, userUUID string, sessionUUID string, instanceID int64) ([]*types.AgentInstanceSessionHistory, error) + CreateSessionHistories(ctx context.Context, userUUID string, instanceID int64, req *types.CreateSessionHistoryRequest) (*types.CreateSessionHistoryResponse, error) + UpdateSessionHistoryFeedback(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.FeedbackSessionHistoryRequest) error + RewriteSessionHistory(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.RewriteSessionHistoryRequest) (*types.RewriteSessionHistoryResponse, error) + + // Task operations + CreateTaskIfInstanceExists(ctx context.Context, req *types.AgentInstanceTaskReq) error + ListTasks(ctx context.Context, userUUID string, filter types.AgentTaskFilter, per int, page int) ([]types.AgentTaskListItem, int, error) + GetTaskDetail(ctx context.Context, userUUID string, id int64) (*types.AgentTaskDetail, error) + + // Status operations + GetInstancesStatus(ctx context.Context, userUUID string, instanceIDs []int64) ([]types.AgentInstanceStatusResponse, error) + SetMonitor(ctx context.Context, userUUID string, request types.AgentMonitorRequest) error + GetMonitor(ctx context.Context, monitorID string) ([]int64, error) + RefreshMonitor(ctx context.Context, monitorID string) error +} diff --git a/component/agent_instance_adapter.go b/component/agent_instance_adapter.go new file mode 100644 index 000000000..ef0afb56e --- /dev/null +++ b/component/agent_instance_adapter.go @@ -0,0 +1,44 @@ +package component + +import ( + "context" + + "opencsg.com/csghub-server/builder/store/database" + "opencsg.com/csghub-server/common/types" +) + +// AgentInstanceAdapter interface defines the contract for agent instance adapters +type AgentInstanceAdapter interface { + CreateInstance(ctx context.Context, userUUID string, instance *types.AgentInstance, template *database.AgentTemplate) (*types.AgentInstanceCreationResult, error) + DeleteInstance(ctx context.Context, userUUID string, contentID string) error + UpdateInstance(ctx context.Context, userUUID string, instance *types.AgentInstance) error + GetInstanceType() string + IsInstanceRunning(ctx context.Context, userUUID string, contentID string, builtIn bool) (bool, error) + Status(ctx context.Context, userUUID string, contentIDs []string, builtInMap map[string]bool) ([]types.AgentInstanceStatusResult, error) + GetQuotaPerUser() int +} + +// AgentInstanceAdapterFactory manages agent instance adapters +type AgentInstanceAdapterFactory struct { + adapters map[string]AgentInstanceAdapter +} + +func NewAgentInstanceAdapterFactory() *AgentInstanceAdapterFactory { + return &AgentInstanceAdapterFactory{adapters: make(map[string]AgentInstanceAdapter)} +} + +func (f *AgentInstanceAdapterFactory) GetAdapter(agentType string) AgentInstanceAdapter { + return f.adapters[agentType] +} + +func (f *AgentInstanceAdapterFactory) RegisterAdapter(agentType string, adapter AgentInstanceAdapter) { + f.adapters[agentType] = adapter +} + +func (f *AgentInstanceAdapterFactory) GetSupportedTypes() []string { + types := make([]string, 0, len(f.adapters)) + for t := range f.adapters { + types = append(types, t) + } + return types +} diff --git a/component/space.go b/component/space.go index c45620c75..73e2faa18 100644 --- a/component/space.go +++ b/component/space.go @@ -54,6 +54,7 @@ type SpaceComponent interface { // FixHasEntryFile checks whether git repo has entry point file and update space's HasAppFile property in db FixHasEntryFile(ctx context.Context, s *database.Space) *database.Space Status(ctx context.Context, namespace, name string) (string, string, error) + StatusByPaths(ctx context.Context, paths []string) (map[string]string, error) Logs(ctx context.Context, namespace, name, since string) (*deploy.MultiLogReader, error) // HasEntryFile checks whether space repo has entry point file to run with HasEntryFile(ctx context.Context, space *database.Space) bool @@ -122,7 +123,10 @@ func (c *spaceComponentImpl) Create(ctx context.Context, req types.CreateSpaceRe slog.Error("failed to create new space in db", slog.Any("req", req), slog.String("error", err.Error())) return nil, fmt.Errorf("failed to create new space in db, error: %w", err) } - _ = c.git.CommitFiles(ctx, *commitFilesReq) + if commitFilesReq != nil { + _ = c.git.CommitFiles(ctx, *commitFilesReq) + } + dbRepo.Path = repoPath err = c.createSpaceDefaultFiles(ctx, dbRepo, req, templatePath) @@ -389,6 +393,16 @@ func (c *spaceComponentImpl) Show(ctx context.Context, namespace, name, currentU } repository := common.BuildCloneInfo(c.config, space.Repository) + for _, tag := range space.Repository.Tags { + tags = append(tags, types.RepoTag{ + Name: tag.Name, + Category: tag.Category, + Group: tag.Group, + BuiltIn: tag.BuiltIn, + ShowName: tag.I18nKey, //ShowName: tag.ShowName, + }) + } + resSpace := &types.Space{ ID: space.ID, Name: space.Repository.Name, @@ -1048,6 +1062,64 @@ func (c *spaceComponentImpl) Status(ctx context.Context, namespace, name string) return spaceStatus.SvcName, spaceStatus.Status, err } +// StatusByPaths queries status for multiple spaces in a single query +// paths is a slice of space paths in the format "namespace/name" +// Returns a map where key is the path and value is the status string +func (c *spaceComponentImpl) StatusByPaths(ctx context.Context, paths []string) (map[string]string, error) { + if len(paths) == 0 { + return make(map[string]string), nil + } + + dbSpaces, err := c.spaceStore.ListByPath(ctx, paths) + if err != nil { + return nil, fmt.Errorf("failed to find spaces by paths, error: %w", err) + } + + pathToDBSpace := make(map[string]*database.Space) + spaceIDs := make([]int64, 0, len(dbSpaces)) + for i := range dbSpaces { + space := &dbSpaces[i] + path := space.Repository.Path + pathToDBSpace[path] = space + spaceIDs = append(spaceIDs, space.ID) + } + + // Get latest deploys for all spaces in one query + deployMap, err := c.deployTaskStore.GetLatestDeploysBySpaceIDs(ctx, spaceIDs) + if err != nil { + return nil, err + } + + result := make(map[string]string) + for _, path := range paths { + dbSpace, exists := pathToDBSpace[path] + if !exists { + // Space not found, set status to Empty + result[path] = SpaceStatusEmpty + continue + } + + if !dbSpace.HasAppFile { + if dbSpace.Sdk == types.NGINX.Name { + result[path] = SpaceStatusNoNGINXConf + } else { + result[path] = SpaceStatusNoAppFile + } + continue + } + + deploy, hasDeploy := deployMap[dbSpace.ID] + if !hasDeploy || deploy == nil { + result[path] = SpaceStatusStopped + continue + } + + result[path] = deployStatusCodeToString(deploy.Status) + } + + return result, nil +} + func (c *spaceComponentImpl) Logs(ctx context.Context, namespace, name, since string) (*deploy.MultiLogReader, error) { s, err := c.spaceStore.FindByPath(ctx, namespace, name) if err != nil { diff --git a/component/space_test.go b/component/space_test.go index 601c331ea..8cc9abc89 100644 --- a/component/space_test.go +++ b/component/space_test.go @@ -642,3 +642,232 @@ func TestSpaceComponent_GetMCPServiceBySvcName(t *testing.T) { require.Contains(t, err.Error(), "failed to get space by id") }) } + +func TestSpaceComponent_StatusByPaths(t *testing.T) { + ctx := context.TODO() + sc := initializeTestSpaceComponent(ctx, t) + + t.Run("empty paths", func(t *testing.T) { + result, err := sc.StatusByPaths(ctx, []string{}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 0, len(result)) + }) + + t.Run("space not found", func(t *testing.T) { + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"nonexistent/space"}). + Return([]database.Space{}, nil).Once() + + // When no spaces are found, spaceIDs will be empty, but GetLatestDeploysBySpaceIDs is still called + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{}). + Return(map[int64]*database.Deploy{}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"nonexistent/space"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusEmpty, result["nonexistent/space"]) + }) + + t.Run("space without HasAppFile - NGINX", func(t *testing.T) { + dbRepo := &database.Repository{ID: 1, Path: "ns1/space1"} + dbSpace := &database.Space{ + ID: 1, + Repository: dbRepo, + HasAppFile: false, + Sdk: types.NGINX.Name, + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns1/space1"}). + Return([]database.Space{*dbSpace}, nil).Once() + + // GetLatestDeploysBySpaceIDs is called with all found space IDs, even if they don't have HasAppFile + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{1}). + Return(map[int64]*database.Deploy{}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns1/space1"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusNoNGINXConf, result["ns1/space1"]) + }) + + t.Run("space without HasAppFile - non-NGINX", func(t *testing.T) { + dbRepo := &database.Repository{ID: 2, Path: "ns2/space2"} + dbSpace := &database.Space{ + ID: 2, + Repository: dbRepo, + HasAppFile: false, + Sdk: "streamlit", + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns2/space2"}). + Return([]database.Space{*dbSpace}, nil).Once() + + // GetLatestDeploysBySpaceIDs is called with all found space IDs, even if they don't have HasAppFile + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{2}). + Return(map[int64]*database.Deploy{}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns2/space2"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusNoAppFile, result["ns2/space2"]) + }) + + t.Run("space with HasAppFile but no deploy", func(t *testing.T) { + dbRepo := &database.Repository{ID: 3, Path: "ns3/space3"} + dbSpace := &database.Space{ + ID: 3, + Repository: dbRepo, + HasAppFile: true, + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns3/space3"}). + Return([]database.Space{*dbSpace}, nil).Once() + + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{3}). + Return(map[int64]*database.Deploy{}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns3/space3"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusStopped, result["ns3/space3"]) + }) + + t.Run("space with HasAppFile and deploy - Running", func(t *testing.T) { + dbRepo := &database.Repository{ID: 4, Path: "ns4/space4"} + dbSpace := &database.Space{ + ID: 4, + Repository: dbRepo, + HasAppFile: true, + } + + deploy := &database.Deploy{ + ID: 1, + Status: 23, // Running + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns4/space4"}). + Return([]database.Space{*dbSpace}, nil).Once() + + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{4}). + Return(map[int64]*database.Deploy{4: deploy}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns4/space4"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusRunning, result["ns4/space4"]) + }) + + t.Run("space with HasAppFile and deploy - Stopped", func(t *testing.T) { + dbRepo := &database.Repository{ID: 5, Path: "ns5/space5"} + dbSpace := &database.Space{ + ID: 5, + Repository: dbRepo, + HasAppFile: true, + } + + deploy := &database.Deploy{ + ID: 2, + Status: 26, // Stopped + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns5/space5"}). + Return([]database.Space{*dbSpace}, nil).Once() + + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{5}). + Return(map[int64]*database.Deploy{5: deploy}, nil).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns5/space5"}) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 1, len(result)) + require.Equal(t, SpaceStatusStopped, result["ns5/space5"]) + }) + + t.Run("multiple spaces with different scenarios", func(t *testing.T) { + paths := []string{"ns6/space6", "ns7/space7", "ns8/space8", "ns9/space9"} + + dbRepo6 := &database.Repository{ID: 6, Path: "ns6/space6"} + dbSpace6 := &database.Space{ + ID: 6, + Repository: dbRepo6, + HasAppFile: false, + Sdk: types.NGINX.Name, + } + + dbRepo7 := &database.Repository{ID: 7, Path: "ns7/space7"} + dbSpace7 := &database.Space{ + ID: 7, + Repository: dbRepo7, + HasAppFile: true, + } + + dbRepo8 := &database.Repository{ID: 8, Path: "ns8/space8"} + dbSpace8 := &database.Space{ + ID: 8, + Repository: dbRepo8, + HasAppFile: true, + } + + deploy8 := &database.Deploy{ + ID: 3, + Status: 23, // Running + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, paths). + Return([]database.Space{*dbSpace6, *dbSpace7, *dbSpace8}, nil).Once() + + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{6, 7, 8}). + Return(map[int64]*database.Deploy{8: deploy8}, nil).Once() + + result, err := sc.StatusByPaths(ctx, paths) + require.Nil(t, err) + require.NotNil(t, result) + require.Equal(t, 4, len(result)) + + // Space 6: no app file, NGINX + require.Equal(t, SpaceStatusNoNGINXConf, result["ns6/space6"]) + + // Space 7: has app file but no deploy + require.Equal(t, SpaceStatusStopped, result["ns7/space7"]) + + // Space 8: has app file and running deploy + require.Equal(t, SpaceStatusRunning, result["ns8/space8"]) + + // Space 9: not found + require.Equal(t, SpaceStatusEmpty, result["ns9/space9"]) + }) + + t.Run("ListByPath error", func(t *testing.T) { + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"error/space"}). + Return(nil, errors.New("database error")).Once() + + result, err := sc.StatusByPaths(ctx, []string{"error/space"}) + require.NotNil(t, err) + require.Nil(t, result) + require.Contains(t, err.Error(), "failed to find spaces by paths") + }) + + t.Run("GetLatestDeploysBySpaceIDs error", func(t *testing.T) { + dbRepo := &database.Repository{ID: 10, Path: "ns10/space10"} + dbSpace := &database.Space{ + ID: 10, + Repository: dbRepo, + HasAppFile: true, + } + + sc.mocks.stores.SpaceMock().EXPECT().ListByPath(ctx, []string{"ns10/space10"}). + Return([]database.Space{*dbSpace}, nil).Once() + + sc.mocks.stores.DeployTaskMock().EXPECT().GetLatestDeploysBySpaceIDs(ctx, []int64{10}). + Return(nil, errors.New("deploy query error")).Once() + + result, err := sc.StatusByPaths(ctx, []string{"ns10/space10"}) + require.NotNil(t, err) + require.Nil(t, result) + }) +}