diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceComponent.go new file mode 100644 index 000000000..11828bae7 --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentInstanceComponent.go @@ -0,0 +1,1212 @@ +// 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" +) + +// MockAgentInstanceComponent is an autogenerated mock type for the AgentInstanceComponent type +type MockAgentInstanceComponent struct { + mock.Mock +} + +type MockAgentInstanceComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentInstanceComponent) EXPECT() *MockAgentInstanceComponent_Expecter { + return &MockAgentInstanceComponent_Expecter{mock: &_m.Mock} +} + +// CreateInstance provides a mock function with given fields: ctx, instance +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_CreateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInstance' +type MockAgentInstanceComponent_CreateInstance_Call struct { + *mock.Call +} + +// CreateInstance is a helper method to define mock.On call +// - ctx context.Context +// - instance *types.AgentInstance +func (_e *MockAgentInstanceComponent_Expecter) CreateInstance(ctx interface{}, instance interface{}) *MockAgentInstanceComponent_CreateInstance_Call { + return &MockAgentInstanceComponent_CreateInstance_Call{Call: _e.mock.On("CreateInstance", ctx, instance)} +} + +func (_c *MockAgentInstanceComponent_CreateInstance_Call) Run(run func(ctx context.Context, instance *types.AgentInstance)) *MockAgentInstanceComponent_CreateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_CreateInstance_Call) Return(_a0 error) *MockAgentInstanceComponent_CreateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_CreateInstance_Call) RunAndReturn(run func(context.Context, *types.AgentInstance) error) *MockAgentInstanceComponent_CreateInstance_Call { + _c.Call.Return(run) + return _c +} + +// CreateSession provides a mock function with given fields: ctx, userUUID, req +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) CreateSession(ctx interface{}, userUUID interface{}, req interface{}) *MockAgentInstanceComponent_CreateSession_Call { + return &MockAgentInstanceComponent_CreateSession_Call{Call: _e.mock.On("CreateSession", ctx, userUUID, req)} +} + +func (_c *MockAgentInstanceComponent_CreateSession_Call) Run(run func(ctx context.Context, userUUID string, req *types.CreateAgentInstanceSessionRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_CreateSession_Call) Return(sessionUUID string, err error) *MockAgentInstanceComponent_CreateSession_Call { + _c.Call.Return(sessionUUID, err) + return _c +} + +func (_c *MockAgentInstanceComponent_CreateSession_Call) RunAndReturn(run func(context.Context, string, *types.CreateAgentInstanceSessionRequest) (string, error)) *MockAgentInstanceComponent_CreateSession_Call { + _c.Call.Return(run) + return _c +} + +// CreateSessionHistories provides a mock function with given fields: ctx, userUUID, instanceID, req +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_CreateSessionHistories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionHistories' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) CreateSessionHistories(ctx interface{}, userUUID interface{}, instanceID interface{}, req interface{}) *MockAgentInstanceComponent_CreateSessionHistories_Call { + return &MockAgentInstanceComponent_CreateSessionHistories_Call{Call: _e.mock.On("CreateSessionHistories", ctx, userUUID, instanceID, req)} +} + +func (_c *MockAgentInstanceComponent_CreateSessionHistories_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, req *types.CreateSessionHistoryRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_CreateSessionHistories_Call) Return(_a0 *types.CreateSessionHistoryResponse, _a1 error) *MockAgentInstanceComponent_CreateSessionHistories_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_CreateSessionHistories_Call) RunAndReturn(run func(context.Context, string, int64, *types.CreateSessionHistoryRequest) (*types.CreateSessionHistoryResponse, error)) *MockAgentInstanceComponent_CreateSessionHistories_Call { + _c.Call.Return(run) + return _c +} + +// DeleteInstance provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_DeleteInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstance' +type MockAgentInstanceComponent_DeleteInstance_Call struct { + *mock.Call +} + +// DeleteInstance is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentInstanceComponent_Expecter) DeleteInstance(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentInstanceComponent_DeleteInstance_Call { + return &MockAgentInstanceComponent_DeleteInstance_Call{Call: _e.mock.On("DeleteInstance", ctx, id, userUUID)} +} + +func (_c *MockAgentInstanceComponent_DeleteInstance_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentInstanceComponent_DeleteInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_DeleteInstance_Call) Return(_a0 error) *MockAgentInstanceComponent_DeleteInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_DeleteInstance_Call) RunAndReturn(run func(context.Context, int64, string) error) *MockAgentInstanceComponent_DeleteInstance_Call { + _c.Call.Return(run) + return _c +} + +// DeleteInstanceByContentID provides a mock function with given fields: ctx, userUUID, instanceType, instanceContentID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_DeleteInstanceByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInstanceByContentID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) DeleteInstanceByContentID(ctx interface{}, userUUID interface{}, instanceType interface{}, instanceContentID interface{}) *MockAgentInstanceComponent_DeleteInstanceByContentID_Call { + return &MockAgentInstanceComponent_DeleteInstanceByContentID_Call{Call: _e.mock.On("DeleteInstanceByContentID", ctx, userUUID, instanceType, instanceContentID)} +} + +func (_c *MockAgentInstanceComponent_DeleteInstanceByContentID_Call) Run(run func(ctx context.Context, userUUID string, instanceType string, instanceContentID string)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_DeleteInstanceByContentID_Call) Return(_a0 error) *MockAgentInstanceComponent_DeleteInstanceByContentID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_DeleteInstanceByContentID_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockAgentInstanceComponent_DeleteInstanceByContentID_Call { + _c.Call.Return(run) + return _c +} + +// DeleteSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_DeleteSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSessionByUUID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) DeleteSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentInstanceComponent_DeleteSessionByUUID_Call { + return &MockAgentInstanceComponent_DeleteSessionByUUID_Call{Call: _e.mock.On("DeleteSessionByUUID", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentInstanceComponent_DeleteSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_DeleteSessionByUUID_Call) Return(_a0 error) *MockAgentInstanceComponent_DeleteSessionByUUID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_DeleteSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64) error) *MockAgentInstanceComponent_DeleteSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// GetInstanceByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_GetInstanceByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstanceByID' +type MockAgentInstanceComponent_GetInstanceByID_Call struct { + *mock.Call +} + +// GetInstanceByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentInstanceComponent_Expecter) GetInstanceByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentInstanceComponent_GetInstanceByID_Call { + return &MockAgentInstanceComponent_GetInstanceByID_Call{Call: _e.mock.On("GetInstanceByID", ctx, id, userUUID)} +} + +func (_c *MockAgentInstanceComponent_GetInstanceByID_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentInstanceComponent_GetInstanceByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_GetInstanceByID_Call) Return(_a0 *types.AgentInstance, _a1 error) *MockAgentInstanceComponent_GetInstanceByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_GetInstanceByID_Call) RunAndReturn(run func(context.Context, int64, string) (*types.AgentInstance, error)) *MockAgentInstanceComponent_GetInstanceByID_Call { + _c.Call.Return(run) + return _c +} + +// GetInstancesStatus provides a mock function with given fields: ctx, userUUID, instanceIDs +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_GetInstancesStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInstancesStatus' +type MockAgentInstanceComponent_GetInstancesStatus_Call struct { + *mock.Call +} + +// GetInstancesStatus is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - instanceIDs []int64 +func (_e *MockAgentInstanceComponent_Expecter) GetInstancesStatus(ctx interface{}, userUUID interface{}, instanceIDs interface{}) *MockAgentInstanceComponent_GetInstancesStatus_Call { + return &MockAgentInstanceComponent_GetInstancesStatus_Call{Call: _e.mock.On("GetInstancesStatus", ctx, userUUID, instanceIDs)} +} + +func (_c *MockAgentInstanceComponent_GetInstancesStatus_Call) Run(run func(ctx context.Context, userUUID string, instanceIDs []int64)) *MockAgentInstanceComponent_GetInstancesStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]int64)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_GetInstancesStatus_Call) Return(_a0 []types.AgentInstanceStatusResponse, _a1 error) *MockAgentInstanceComponent_GetInstancesStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_GetInstancesStatus_Call) RunAndReturn(run func(context.Context, string, []int64) ([]types.AgentInstanceStatusResponse, error)) *MockAgentInstanceComponent_GetInstancesStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetMonitor provides a mock function with given fields: ctx, monitorID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_GetMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMonitor' +type MockAgentInstanceComponent_GetMonitor_Call struct { + *mock.Call +} + +// GetMonitor is a helper method to define mock.On call +// - ctx context.Context +// - monitorID string +func (_e *MockAgentInstanceComponent_Expecter) GetMonitor(ctx interface{}, monitorID interface{}) *MockAgentInstanceComponent_GetMonitor_Call { + return &MockAgentInstanceComponent_GetMonitor_Call{Call: _e.mock.On("GetMonitor", ctx, monitorID)} +} + +func (_c *MockAgentInstanceComponent_GetMonitor_Call) Run(run func(ctx context.Context, monitorID string)) *MockAgentInstanceComponent_GetMonitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_GetMonitor_Call) Return(_a0 []int64, _a1 error) *MockAgentInstanceComponent_GetMonitor_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_GetMonitor_Call) RunAndReturn(run func(context.Context, string) ([]int64, error)) *MockAgentInstanceComponent_GetMonitor_Call { + _c.Call.Return(run) + return _c +} + +// GetSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_GetSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionByUUID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) GetSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentInstanceComponent_GetSessionByUUID_Call { + return &MockAgentInstanceComponent_GetSessionByUUID_Call{Call: _e.mock.On("GetSessionByUUID", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentInstanceComponent_GetSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_GetSessionByUUID_Call) Return(_a0 *types.AgentInstanceSession, _a1 error) *MockAgentInstanceComponent_GetSessionByUUID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_GetSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64) (*types.AgentInstanceSession, error)) *MockAgentInstanceComponent_GetSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// IsInstanceExistsByContentID provides a mock function with given fields: ctx, instanceType, instanceContentID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_IsInstanceExistsByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInstanceExistsByContentID' +type MockAgentInstanceComponent_IsInstanceExistsByContentID_Call struct { + *mock.Call +} + +// IsInstanceExistsByContentID is a helper method to define mock.On call +// - ctx context.Context +// - instanceType string +// - instanceContentID string +func (_e *MockAgentInstanceComponent_Expecter) IsInstanceExistsByContentID(ctx interface{}, instanceType interface{}, instanceContentID interface{}) *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call { + return &MockAgentInstanceComponent_IsInstanceExistsByContentID_Call{Call: _e.mock.On("IsInstanceExistsByContentID", ctx, instanceType, instanceContentID)} +} + +func (_c *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call) Run(run func(ctx context.Context, instanceType string, instanceContentID string)) *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call) Return(_a0 bool, _a1 error) *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *MockAgentInstanceComponent_IsInstanceExistsByContentID_Call { + _c.Call.Return(run) + return _c +} + +// ListInstancesByUserUUID provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_ListInstancesByUserUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInstancesByUserUUID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) ListInstancesByUserUUID(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentInstanceComponent_ListInstancesByUserUUID_Call { + return &MockAgentInstanceComponent_ListInstancesByUserUUID_Call{Call: _e.mock.On("ListInstancesByUserUUID", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentInstanceComponent_ListInstancesByUserUUID_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentInstanceFilter, per int, page int)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_ListInstancesByUserUUID_Call) Return(_a0 []*types.AgentInstance, _a1 int, _a2 error) *MockAgentInstanceComponent_ListInstancesByUserUUID_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentInstanceComponent_ListInstancesByUserUUID_Call) RunAndReturn(run func(context.Context, string, types.AgentInstanceFilter, int, int) ([]*types.AgentInstance, int, error)) *MockAgentInstanceComponent_ListInstancesByUserUUID_Call { + _c.Call.Return(run) + return _c +} + +// ListSessionHistories provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_ListSessionHistories_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSessionHistories' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) ListSessionHistories(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}) *MockAgentInstanceComponent_ListSessionHistories_Call { + return &MockAgentInstanceComponent_ListSessionHistories_Call{Call: _e.mock.On("ListSessionHistories", ctx, userUUID, sessionUUID, instanceID)} +} + +func (_c *MockAgentInstanceComponent_ListSessionHistories_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_ListSessionHistories_Call) Return(_a0 []*types.AgentInstanceSessionHistory, _a1 error) *MockAgentInstanceComponent_ListSessionHistories_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_ListSessionHistories_Call) RunAndReturn(run func(context.Context, string, string, int64) ([]*types.AgentInstanceSessionHistory, error)) *MockAgentInstanceComponent_ListSessionHistories_Call { + _c.Call.Return(run) + return _c +} + +// ListSessions provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_ListSessions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSessions' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) ListSessions(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentInstanceComponent_ListSessions_Call { + return &MockAgentInstanceComponent_ListSessions_Call{Call: _e.mock.On("ListSessions", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentInstanceComponent_ListSessions_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentInstanceSessionFilter, per int, page int)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_ListSessions_Call) Return(_a0 []*types.AgentInstanceSession, _a1 int, _a2 error) *MockAgentInstanceComponent_ListSessions_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentInstanceComponent_ListSessions_Call) RunAndReturn(run func(context.Context, string, types.AgentInstanceSessionFilter, int, int) ([]*types.AgentInstanceSession, int, error)) *MockAgentInstanceComponent_ListSessions_Call { + _c.Call.Return(run) + return _c +} + +// RefreshMonitor provides a mock function with given fields: ctx, monitorID +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_RefreshMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshMonitor' +type MockAgentInstanceComponent_RefreshMonitor_Call struct { + *mock.Call +} + +// RefreshMonitor is a helper method to define mock.On call +// - ctx context.Context +// - monitorID string +func (_e *MockAgentInstanceComponent_Expecter) RefreshMonitor(ctx interface{}, monitorID interface{}) *MockAgentInstanceComponent_RefreshMonitor_Call { + return &MockAgentInstanceComponent_RefreshMonitor_Call{Call: _e.mock.On("RefreshMonitor", ctx, monitorID)} +} + +func (_c *MockAgentInstanceComponent_RefreshMonitor_Call) Run(run func(ctx context.Context, monitorID string)) *MockAgentInstanceComponent_RefreshMonitor_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_RefreshMonitor_Call) Return(_a0 error) *MockAgentInstanceComponent_RefreshMonitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_RefreshMonitor_Call) RunAndReturn(run func(context.Context, string) error) *MockAgentInstanceComponent_RefreshMonitor_Call { + _c.Call.Return(run) + return _c +} + +// RewriteSessionHistory provides a mock function with given fields: ctx, userUUID, instanceID, sessionUUID, req +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_RewriteSessionHistory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RewriteSessionHistory' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) RewriteSessionHistory(ctx interface{}, userUUID interface{}, instanceID interface{}, sessionUUID interface{}, req interface{}) *MockAgentInstanceComponent_RewriteSessionHistory_Call { + return &MockAgentInstanceComponent_RewriteSessionHistory_Call{Call: _e.mock.On("RewriteSessionHistory", ctx, userUUID, instanceID, sessionUUID, req)} +} + +func (_c *MockAgentInstanceComponent_RewriteSessionHistory_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.RewriteSessionHistoryRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_RewriteSessionHistory_Call) Return(_a0 *types.RewriteSessionHistoryResponse, _a1 error) *MockAgentInstanceComponent_RewriteSessionHistory_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_RewriteSessionHistory_Call) RunAndReturn(run func(context.Context, string, int64, string, *types.RewriteSessionHistoryRequest) (*types.RewriteSessionHistoryResponse, error)) *MockAgentInstanceComponent_RewriteSessionHistory_Call { + _c.Call.Return(run) + return _c +} + +// SetMonitor provides a mock function with given fields: ctx, userUUID, request +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_SetMonitor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMonitor' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) SetMonitor(ctx interface{}, userUUID interface{}, request interface{}) *MockAgentInstanceComponent_SetMonitor_Call { + return &MockAgentInstanceComponent_SetMonitor_Call{Call: _e.mock.On("SetMonitor", ctx, userUUID, request)} +} + +func (_c *MockAgentInstanceComponent_SetMonitor_Call) Run(run func(ctx context.Context, userUUID string, request types.AgentMonitorRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_SetMonitor_Call) Return(_a0 error) *MockAgentInstanceComponent_SetMonitor_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_SetMonitor_Call) RunAndReturn(run func(context.Context, string, types.AgentMonitorRequest) error) *MockAgentInstanceComponent_SetMonitor_Call { + _c.Call.Return(run) + return _c +} + +// UpdateInstance provides a mock function with given fields: ctx, instance +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_UpdateInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInstance' +type MockAgentInstanceComponent_UpdateInstance_Call struct { + *mock.Call +} + +// UpdateInstance is a helper method to define mock.On call +// - ctx context.Context +// - instance *types.AgentInstance +func (_e *MockAgentInstanceComponent_Expecter) UpdateInstance(ctx interface{}, instance interface{}) *MockAgentInstanceComponent_UpdateInstance_Call { + return &MockAgentInstanceComponent_UpdateInstance_Call{Call: _e.mock.On("UpdateInstance", ctx, instance)} +} + +func (_c *MockAgentInstanceComponent_UpdateInstance_Call) Run(run func(ctx context.Context, instance *types.AgentInstance)) *MockAgentInstanceComponent_UpdateInstance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstance)) + }) + return _c +} + +func (_c *MockAgentInstanceComponent_UpdateInstance_Call) Return(_a0 error) *MockAgentInstanceComponent_UpdateInstance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_UpdateInstance_Call) RunAndReturn(run func(context.Context, *types.AgentInstance) error) *MockAgentInstanceComponent_UpdateInstance_Call { + _c.Call.Return(run) + return _c +} + +// UpdateInstanceByContentID provides a mock function with given fields: ctx, userUUID, instanceType, instanceContentID, updateRequest +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_UpdateInstanceByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateInstanceByContentID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) UpdateInstanceByContentID(ctx interface{}, userUUID interface{}, instanceType interface{}, instanceContentID interface{}, updateRequest interface{}) *MockAgentInstanceComponent_UpdateInstanceByContentID_Call { + return &MockAgentInstanceComponent_UpdateInstanceByContentID_Call{Call: _e.mock.On("UpdateInstanceByContentID", ctx, userUUID, instanceType, instanceContentID, updateRequest)} +} + +func (_c *MockAgentInstanceComponent_UpdateInstanceByContentID_Call) Run(run func(ctx context.Context, userUUID string, instanceType string, instanceContentID string, updateRequest types.UpdateAgentInstanceRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_UpdateInstanceByContentID_Call) Return(_a0 *types.AgentInstance, _a1 error) *MockAgentInstanceComponent_UpdateInstanceByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentInstanceComponent_UpdateInstanceByContentID_Call) RunAndReturn(run func(context.Context, string, string, string, types.UpdateAgentInstanceRequest) (*types.AgentInstance, error)) *MockAgentInstanceComponent_UpdateInstanceByContentID_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSessionByUUID provides a mock function with given fields: ctx, userUUID, sessionUUID, instanceID, req +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_UpdateSessionByUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSessionByUUID' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) UpdateSessionByUUID(ctx interface{}, userUUID interface{}, sessionUUID interface{}, instanceID interface{}, req interface{}) *MockAgentInstanceComponent_UpdateSessionByUUID_Call { + return &MockAgentInstanceComponent_UpdateSessionByUUID_Call{Call: _e.mock.On("UpdateSessionByUUID", ctx, userUUID, sessionUUID, instanceID, req)} +} + +func (_c *MockAgentInstanceComponent_UpdateSessionByUUID_Call) Run(run func(ctx context.Context, userUUID string, sessionUUID string, instanceID int64, req *types.UpdateAgentInstanceSessionRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_UpdateSessionByUUID_Call) Return(_a0 error) *MockAgentInstanceComponent_UpdateSessionByUUID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_UpdateSessionByUUID_Call) RunAndReturn(run func(context.Context, string, string, int64, *types.UpdateAgentInstanceSessionRequest) error) *MockAgentInstanceComponent_UpdateSessionByUUID_Call { + _c.Call.Return(run) + return _c +} + +// UpdateSessionHistoryFeedback provides a mock function with given fields: ctx, userUUID, instanceID, sessionUUID, req +func (_m *MockAgentInstanceComponent) 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 +} + +// MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSessionHistoryFeedback' +type MockAgentInstanceComponent_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 *MockAgentInstanceComponent_Expecter) UpdateSessionHistoryFeedback(ctx interface{}, userUUID interface{}, instanceID interface{}, sessionUUID interface{}, req interface{}) *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call { + return &MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call{Call: _e.mock.On("UpdateSessionHistoryFeedback", ctx, userUUID, instanceID, sessionUUID, req)} +} + +func (_c *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call) Run(run func(ctx context.Context, userUUID string, instanceID int64, sessionUUID string, req *types.FeedbackSessionHistoryRequest)) *MockAgentInstanceComponent_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 *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call) Return(_a0 error) *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call) RunAndReturn(run func(context.Context, string, int64, string, *types.FeedbackSessionHistoryRequest) error) *MockAgentInstanceComponent_UpdateSessionHistoryFeedback_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentInstanceComponent creates a new instance of MockAgentInstanceComponent. 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 NewMockAgentInstanceComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentInstanceComponent { + mock := &MockAgentInstanceComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentKnowledgeBaseComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentKnowledgeBaseComponent.go new file mode 100644 index 000000000..6518ec0cc --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentKnowledgeBaseComponent.go @@ -0,0 +1,536 @@ +// 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" +) + +// MockAgentKnowledgeBaseComponent is an autogenerated mock type for the AgentKnowledgeBaseComponent type +type MockAgentKnowledgeBaseComponent struct { + mock.Mock +} + +type MockAgentKnowledgeBaseComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentKnowledgeBaseComponent) EXPECT() *MockAgentKnowledgeBaseComponent_Expecter { + return &MockAgentKnowledgeBaseComponent_Expecter{mock: &_m.Mock} +} + +// CreateKnowledgeBase provides a mock function with given fields: ctx, req +func (_m *MockAgentKnowledgeBaseComponent) CreateKnowledgeBase(ctx context.Context, req *types.CreateAgentKnowledgeBaseReq) (*types.AgentKnowledgeBase, error) { + ret := _m.Called(ctx, req) + + if len(ret) == 0 { + panic("no return value specified for CreateKnowledgeBase") + } + + var r0 *types.AgentKnowledgeBase + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *types.CreateAgentKnowledgeBaseReq) (*types.AgentKnowledgeBase, error)); ok { + return rf(ctx, req) + } + if rf, ok := ret.Get(0).(func(context.Context, *types.CreateAgentKnowledgeBaseReq) *types.AgentKnowledgeBase); ok { + r0 = rf(ctx, req) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentKnowledgeBase) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *types.CreateAgentKnowledgeBaseReq) error); ok { + r1 = rf(ctx, req) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateKnowledgeBase' +type MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call struct { + *mock.Call +} + +// CreateKnowledgeBase is a helper method to define mock.On call +// - ctx context.Context +// - req *types.CreateAgentKnowledgeBaseReq +func (_e *MockAgentKnowledgeBaseComponent_Expecter) CreateKnowledgeBase(ctx interface{}, req interface{}) *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call { + return &MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call{Call: _e.mock.On("CreateKnowledgeBase", ctx, req)} +} + +func (_c *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call) Run(run func(ctx context.Context, req *types.CreateAgentKnowledgeBaseReq)) *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.CreateAgentKnowledgeBaseReq)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call) Return(_a0 *types.AgentKnowledgeBase, _a1 error) *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call) RunAndReturn(run func(context.Context, *types.CreateAgentKnowledgeBaseReq) (*types.AgentKnowledgeBase, error)) *MockAgentKnowledgeBaseComponent_CreateKnowledgeBase_Call { + _c.Call.Return(run) + return _c +} + +// DeleteKnowledgeBase provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentKnowledgeBaseComponent) DeleteKnowledgeBase(ctx context.Context, id int64, userUUID string) error { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteKnowledgeBase") + } + + 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 +} + +// MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteKnowledgeBase' +type MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call struct { + *mock.Call +} + +// DeleteKnowledgeBase is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentKnowledgeBaseComponent_Expecter) DeleteKnowledgeBase(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call { + return &MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call{Call: _e.mock.On("DeleteKnowledgeBase", ctx, id, userUUID)} +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call) Return(_a0 error) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call) RunAndReturn(run func(context.Context, int64, string) error) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBase_Call { + _c.Call.Return(run) + return _c +} + +// DeleteKnowledgeBaseByContentID provides a mock function with given fields: ctx, contentID, userUUID +func (_m *MockAgentKnowledgeBaseComponent) DeleteKnowledgeBaseByContentID(ctx context.Context, contentID string, userUUID string) error { + ret := _m.Called(ctx, contentID, userUUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteKnowledgeBaseByContentID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, contentID, userUUID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteKnowledgeBaseByContentID' +type MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call struct { + *mock.Call +} + +// DeleteKnowledgeBaseByContentID is a helper method to define mock.On call +// - ctx context.Context +// - contentID string +// - userUUID string +func (_e *MockAgentKnowledgeBaseComponent_Expecter) DeleteKnowledgeBaseByContentID(ctx interface{}, contentID interface{}, userUUID interface{}) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call { + return &MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call{Call: _e.mock.On("DeleteKnowledgeBaseByContentID", ctx, contentID, userUUID)} +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call) Run(run func(ctx context.Context, contentID string, userUUID string)) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call) Return(_a0 error) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call) RunAndReturn(run func(context.Context, string, string) error) *MockAgentKnowledgeBaseComponent_DeleteKnowledgeBaseByContentID_Call { + _c.Call.Return(run) + return _c +} + +// GetKnowledgeBaseByContentID provides a mock function with given fields: ctx, contentID, userUUID +func (_m *MockAgentKnowledgeBaseComponent) GetKnowledgeBaseByContentID(ctx context.Context, contentID string, userUUID string) (*types.AgentKnowledgeBaseDetail, error) { + ret := _m.Called(ctx, contentID, userUUID) + + if len(ret) == 0 { + panic("no return value specified for GetKnowledgeBaseByContentID") + } + + var r0 *types.AgentKnowledgeBaseDetail + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (*types.AgentKnowledgeBaseDetail, error)); ok { + return rf(ctx, contentID, userUUID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) *types.AgentKnowledgeBaseDetail); ok { + r0 = rf(ctx, contentID, userUUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentKnowledgeBaseDetail) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, contentID, userUUID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKnowledgeBaseByContentID' +type MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call struct { + *mock.Call +} + +// GetKnowledgeBaseByContentID is a helper method to define mock.On call +// - ctx context.Context +// - contentID string +// - userUUID string +func (_e *MockAgentKnowledgeBaseComponent_Expecter) GetKnowledgeBaseByContentID(ctx interface{}, contentID interface{}, userUUID interface{}) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call { + return &MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call{Call: _e.mock.On("GetKnowledgeBaseByContentID", ctx, contentID, userUUID)} +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call) Run(run func(ctx context.Context, contentID string, userUUID string)) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call) Return(_a0 *types.AgentKnowledgeBaseDetail, _a1 error) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call) RunAndReturn(run func(context.Context, string, string) (*types.AgentKnowledgeBaseDetail, error)) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByContentID_Call { + _c.Call.Return(run) + return _c +} + +// GetKnowledgeBaseByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentKnowledgeBaseComponent) GetKnowledgeBaseByID(ctx context.Context, id int64, userUUID string) (*types.AgentKnowledgeBaseDetail, error) { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for GetKnowledgeBaseByID") + } + + var r0 *types.AgentKnowledgeBaseDetail + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string) (*types.AgentKnowledgeBaseDetail, error)); ok { + return rf(ctx, id, userUUID) + } + if rf, ok := ret.Get(0).(func(context.Context, int64, string) *types.AgentKnowledgeBaseDetail); ok { + r0 = rf(ctx, id, userUUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentKnowledgeBaseDetail) + } + } + + 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 +} + +// MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKnowledgeBaseByID' +type MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call struct { + *mock.Call +} + +// GetKnowledgeBaseByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentKnowledgeBaseComponent_Expecter) GetKnowledgeBaseByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call { + return &MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call{Call: _e.mock.On("GetKnowledgeBaseByID", ctx, id, userUUID)} +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call) Return(_a0 *types.AgentKnowledgeBaseDetail, _a1 error) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call) RunAndReturn(run func(context.Context, int64, string) (*types.AgentKnowledgeBaseDetail, error)) *MockAgentKnowledgeBaseComponent_GetKnowledgeBaseByID_Call { + _c.Call.Return(run) + return _c +} + +// IsKnowledgeBaseExistsByContentID provides a mock function with given fields: ctx, contentID +func (_m *MockAgentKnowledgeBaseComponent) IsKnowledgeBaseExistsByContentID(ctx context.Context, contentID string) (bool, error) { + ret := _m.Called(ctx, contentID) + + if len(ret) == 0 { + panic("no return value specified for IsKnowledgeBaseExistsByContentID") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok { + return rf(ctx, contentID) + } + if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok { + r0 = rf(ctx, contentID) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, contentID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsKnowledgeBaseExistsByContentID' +type MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call struct { + *mock.Call +} + +// IsKnowledgeBaseExistsByContentID is a helper method to define mock.On call +// - ctx context.Context +// - contentID string +func (_e *MockAgentKnowledgeBaseComponent_Expecter) IsKnowledgeBaseExistsByContentID(ctx interface{}, contentID interface{}) *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call { + return &MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call{Call: _e.mock.On("IsKnowledgeBaseExistsByContentID", ctx, contentID)} +} + +func (_c *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call) Run(run func(ctx context.Context, contentID string)) *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call) Return(_a0 bool, _a1 error) *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *MockAgentKnowledgeBaseComponent_IsKnowledgeBaseExistsByContentID_Call { + _c.Call.Return(run) + return _c +} + +// ListKnowledgeBases provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentKnowledgeBaseComponent) ListKnowledgeBases(ctx context.Context, userUUID string, filter types.AgentKnowledgeBaseFilter, per int, page int) ([]types.AgentKnowledgeBaseListItem, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListKnowledgeBases") + } + + var r0 []types.AgentKnowledgeBaseListItem + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentKnowledgeBaseFilter, int, int) ([]types.AgentKnowledgeBaseListItem, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentKnowledgeBaseFilter, int, int) []types.AgentKnowledgeBaseListItem); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentKnowledgeBaseListItem) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentKnowledgeBaseFilter, 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.AgentKnowledgeBaseFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListKnowledgeBases' +type MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call struct { + *mock.Call +} + +// ListKnowledgeBases is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentKnowledgeBaseFilter +// - per int +// - page int +func (_e *MockAgentKnowledgeBaseComponent_Expecter) ListKnowledgeBases(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call { + return &MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call{Call: _e.mock.On("ListKnowledgeBases", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentKnowledgeBaseFilter, per int, page int)) *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentKnowledgeBaseFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call) Return(_a0 []types.AgentKnowledgeBaseListItem, _a1 int, _a2 error) *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call) RunAndReturn(run func(context.Context, string, types.AgentKnowledgeBaseFilter, int, int) ([]types.AgentKnowledgeBaseListItem, int, error)) *MockAgentKnowledgeBaseComponent_ListKnowledgeBases_Call { + _c.Call.Return(run) + return _c +} + +// UpdateKnowledgeBase provides a mock function with given fields: ctx, id, userUUID, req +func (_m *MockAgentKnowledgeBaseComponent) UpdateKnowledgeBase(ctx context.Context, id int64, userUUID string, req *types.UpdateAgentKnowledgeBaseRequest) error { + ret := _m.Called(ctx, id, userUUID, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateKnowledgeBase") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, int64, string, *types.UpdateAgentKnowledgeBaseRequest) error); ok { + r0 = rf(ctx, id, userUUID, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateKnowledgeBase' +type MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call struct { + *mock.Call +} + +// UpdateKnowledgeBase is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +// - req *types.UpdateAgentKnowledgeBaseRequest +func (_e *MockAgentKnowledgeBaseComponent_Expecter) UpdateKnowledgeBase(ctx interface{}, id interface{}, userUUID interface{}, req interface{}) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call { + return &MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call{Call: _e.mock.On("UpdateKnowledgeBase", ctx, id, userUUID, req)} +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call) Run(run func(ctx context.Context, id int64, userUUID string, req *types.UpdateAgentKnowledgeBaseRequest)) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string), args[3].(*types.UpdateAgentKnowledgeBaseRequest)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call) Return(_a0 error) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call) RunAndReturn(run func(context.Context, int64, string, *types.UpdateAgentKnowledgeBaseRequest) error) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBase_Call { + _c.Call.Return(run) + return _c +} + +// UpdateKnowledgeBaseByContentID provides a mock function with given fields: ctx, contentID, userUUID, req +func (_m *MockAgentKnowledgeBaseComponent) UpdateKnowledgeBaseByContentID(ctx context.Context, contentID string, userUUID string, req *types.UpdateAgentKnowledgeBaseRequest) error { + ret := _m.Called(ctx, contentID, userUUID, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateKnowledgeBaseByContentID") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, *types.UpdateAgentKnowledgeBaseRequest) error); ok { + r0 = rf(ctx, contentID, userUUID, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateKnowledgeBaseByContentID' +type MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call struct { + *mock.Call +} + +// UpdateKnowledgeBaseByContentID is a helper method to define mock.On call +// - ctx context.Context +// - contentID string +// - userUUID string +// - req *types.UpdateAgentKnowledgeBaseRequest +func (_e *MockAgentKnowledgeBaseComponent_Expecter) UpdateKnowledgeBaseByContentID(ctx interface{}, contentID interface{}, userUUID interface{}, req interface{}) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call { + return &MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call{Call: _e.mock.On("UpdateKnowledgeBaseByContentID", ctx, contentID, userUUID, req)} +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call) Run(run func(ctx context.Context, contentID string, userUUID string, req *types.UpdateAgentKnowledgeBaseRequest)) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*types.UpdateAgentKnowledgeBaseRequest)) + }) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call) Return(_a0 error) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call) RunAndReturn(run func(context.Context, string, string, *types.UpdateAgentKnowledgeBaseRequest) error) *MockAgentKnowledgeBaseComponent_UpdateKnowledgeBaseByContentID_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentKnowledgeBaseComponent creates a new instance of MockAgentKnowledgeBaseComponent. 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 NewMockAgentKnowledgeBaseComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentKnowledgeBaseComponent { + mock := &MockAgentKnowledgeBaseComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentMCPServerComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentMCPServerComponent.go new file mode 100644 index 000000000..ed118dadb --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentMCPServerComponent.go @@ -0,0 +1,310 @@ +// 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" +) + +// MockAgentMCPServerComponent is an autogenerated mock type for the AgentMCPServerComponent type +type MockAgentMCPServerComponent struct { + mock.Mock +} + +type MockAgentMCPServerComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentMCPServerComponent) EXPECT() *MockAgentMCPServerComponent_Expecter { + return &MockAgentMCPServerComponent_Expecter{mock: &_m.Mock} +} + +// CreateMCPServer provides a mock function with given fields: ctx, server +func (_m *MockAgentMCPServerComponent) CreateMCPServer(ctx context.Context, server *types.AgentMCPServer) error { + ret := _m.Called(ctx, server) + + if len(ret) == 0 { + panic("no return value specified for CreateMCPServer") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.AgentMCPServer) error); ok { + r0 = rf(ctx, server) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentMCPServerComponent_CreateMCPServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMCPServer' +type MockAgentMCPServerComponent_CreateMCPServer_Call struct { + *mock.Call +} + +// CreateMCPServer is a helper method to define mock.On call +// - ctx context.Context +// - server *types.AgentMCPServer +func (_e *MockAgentMCPServerComponent_Expecter) CreateMCPServer(ctx interface{}, server interface{}) *MockAgentMCPServerComponent_CreateMCPServer_Call { + return &MockAgentMCPServerComponent_CreateMCPServer_Call{Call: _e.mock.On("CreateMCPServer", ctx, server)} +} + +func (_c *MockAgentMCPServerComponent_CreateMCPServer_Call) Run(run func(ctx context.Context, server *types.AgentMCPServer)) *MockAgentMCPServerComponent_CreateMCPServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentMCPServer)) + }) + return _c +} + +func (_c *MockAgentMCPServerComponent_CreateMCPServer_Call) Return(_a0 error) *MockAgentMCPServerComponent_CreateMCPServer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentMCPServerComponent_CreateMCPServer_Call) RunAndReturn(run func(context.Context, *types.AgentMCPServer) error) *MockAgentMCPServerComponent_CreateMCPServer_Call { + _c.Call.Return(run) + return _c +} + +// DeleteMCPServer provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentMCPServerComponent) DeleteMCPServer(ctx context.Context, id string, userUUID string) error { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteMCPServer") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok { + r0 = rf(ctx, id, userUUID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentMCPServerComponent_DeleteMCPServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMCPServer' +type MockAgentMCPServerComponent_DeleteMCPServer_Call struct { + *mock.Call +} + +// DeleteMCPServer is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userUUID string +func (_e *MockAgentMCPServerComponent_Expecter) DeleteMCPServer(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentMCPServerComponent_DeleteMCPServer_Call { + return &MockAgentMCPServerComponent_DeleteMCPServer_Call{Call: _e.mock.On("DeleteMCPServer", ctx, id, userUUID)} +} + +func (_c *MockAgentMCPServerComponent_DeleteMCPServer_Call) Run(run func(ctx context.Context, id string, userUUID string)) *MockAgentMCPServerComponent_DeleteMCPServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentMCPServerComponent_DeleteMCPServer_Call) Return(_a0 error) *MockAgentMCPServerComponent_DeleteMCPServer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentMCPServerComponent_DeleteMCPServer_Call) RunAndReturn(run func(context.Context, string, string) error) *MockAgentMCPServerComponent_DeleteMCPServer_Call { + _c.Call.Return(run) + return _c +} + +// GetMCPServerByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentMCPServerComponent) GetMCPServerByID(ctx context.Context, id string, userUUID string) (*types.AgentMCPServerDetail, error) { + ret := _m.Called(ctx, id, userUUID) + + if len(ret) == 0 { + panic("no return value specified for GetMCPServerByID") + } + + var r0 *types.AgentMCPServerDetail + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string) (*types.AgentMCPServerDetail, error)); ok { + return rf(ctx, id, userUUID) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string) *types.AgentMCPServerDetail); ok { + r0 = rf(ctx, id, userUUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.AgentMCPServerDetail) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = rf(ctx, id, userUUID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockAgentMCPServerComponent_GetMCPServerByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMCPServerByID' +type MockAgentMCPServerComponent_GetMCPServerByID_Call struct { + *mock.Call +} + +// GetMCPServerByID is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userUUID string +func (_e *MockAgentMCPServerComponent_Expecter) GetMCPServerByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentMCPServerComponent_GetMCPServerByID_Call { + return &MockAgentMCPServerComponent_GetMCPServerByID_Call{Call: _e.mock.On("GetMCPServerByID", ctx, id, userUUID)} +} + +func (_c *MockAgentMCPServerComponent_GetMCPServerByID_Call) Run(run func(ctx context.Context, id string, userUUID string)) *MockAgentMCPServerComponent_GetMCPServerByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentMCPServerComponent_GetMCPServerByID_Call) Return(_a0 *types.AgentMCPServerDetail, _a1 error) *MockAgentMCPServerComponent_GetMCPServerByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentMCPServerComponent_GetMCPServerByID_Call) RunAndReturn(run func(context.Context, string, string) (*types.AgentMCPServerDetail, error)) *MockAgentMCPServerComponent_GetMCPServerByID_Call { + _c.Call.Return(run) + return _c +} + +// ListMCPServers provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentMCPServerComponent) ListMCPServers(ctx context.Context, userUUID string, filter types.AgentMCPServerFilter, per int, page int) ([]types.AgentMCPServerListItem, int, error) { + ret := _m.Called(ctx, userUUID, filter, per, page) + + if len(ret) == 0 { + panic("no return value specified for ListMCPServers") + } + + var r0 []types.AgentMCPServerListItem + var r1 int + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentMCPServerFilter, int, int) ([]types.AgentMCPServerListItem, int, error)); ok { + return rf(ctx, userUUID, filter, per, page) + } + if rf, ok := ret.Get(0).(func(context.Context, string, types.AgentMCPServerFilter, int, int) []types.AgentMCPServerListItem); ok { + r0 = rf(ctx, userUUID, filter, per, page) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]types.AgentMCPServerListItem) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, types.AgentMCPServerFilter, 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.AgentMCPServerFilter, int, int) error); ok { + r2 = rf(ctx, userUUID, filter, per, page) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockAgentMCPServerComponent_ListMCPServers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMCPServers' +type MockAgentMCPServerComponent_ListMCPServers_Call struct { + *mock.Call +} + +// ListMCPServers is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - filter types.AgentMCPServerFilter +// - per int +// - page int +func (_e *MockAgentMCPServerComponent_Expecter) ListMCPServers(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentMCPServerComponent_ListMCPServers_Call { + return &MockAgentMCPServerComponent_ListMCPServers_Call{Call: _e.mock.On("ListMCPServers", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentMCPServerComponent_ListMCPServers_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentMCPServerFilter, per int, page int)) *MockAgentMCPServerComponent_ListMCPServers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AgentMCPServerFilter), args[3].(int), args[4].(int)) + }) + return _c +} + +func (_c *MockAgentMCPServerComponent_ListMCPServers_Call) Return(_a0 []types.AgentMCPServerListItem, _a1 int, _a2 error) *MockAgentMCPServerComponent_ListMCPServers_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentMCPServerComponent_ListMCPServers_Call) RunAndReturn(run func(context.Context, string, types.AgentMCPServerFilter, int, int) ([]types.AgentMCPServerListItem, int, error)) *MockAgentMCPServerComponent_ListMCPServers_Call { + _c.Call.Return(run) + return _c +} + +// UpdateMCPServer provides a mock function with given fields: ctx, id, userUUID, req +func (_m *MockAgentMCPServerComponent) UpdateMCPServer(ctx context.Context, id string, userUUID string, req *types.UpdateAgentMCPServerRequest) error { + ret := _m.Called(ctx, id, userUUID, req) + + if len(ret) == 0 { + panic("no return value specified for UpdateMCPServer") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, *types.UpdateAgentMCPServerRequest) error); ok { + r0 = rf(ctx, id, userUUID, req) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockAgentMCPServerComponent_UpdateMCPServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMCPServer' +type MockAgentMCPServerComponent_UpdateMCPServer_Call struct { + *mock.Call +} + +// UpdateMCPServer is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - userUUID string +// - req *types.UpdateAgentMCPServerRequest +func (_e *MockAgentMCPServerComponent_Expecter) UpdateMCPServer(ctx interface{}, id interface{}, userUUID interface{}, req interface{}) *MockAgentMCPServerComponent_UpdateMCPServer_Call { + return &MockAgentMCPServerComponent_UpdateMCPServer_Call{Call: _e.mock.On("UpdateMCPServer", ctx, id, userUUID, req)} +} + +func (_c *MockAgentMCPServerComponent_UpdateMCPServer_Call) Run(run func(ctx context.Context, id string, userUUID string, req *types.UpdateAgentMCPServerRequest)) *MockAgentMCPServerComponent_UpdateMCPServer_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*types.UpdateAgentMCPServerRequest)) + }) + return _c +} + +func (_c *MockAgentMCPServerComponent_UpdateMCPServer_Call) Return(_a0 error) *MockAgentMCPServerComponent_UpdateMCPServer_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentMCPServerComponent_UpdateMCPServer_Call) RunAndReturn(run func(context.Context, string, string, *types.UpdateAgentMCPServerRequest) error) *MockAgentMCPServerComponent_UpdateMCPServer_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentMCPServerComponent creates a new instance of MockAgentMCPServerComponent. 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 NewMockAgentMCPServerComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentMCPServerComponent { + mock := &MockAgentMCPServerComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentTaskComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentTaskComponent.go new file mode 100644 index 000000000..ed956effc --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentTaskComponent.go @@ -0,0 +1,213 @@ +// 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" +) + +// MockAgentTaskComponent is an autogenerated mock type for the AgentTaskComponent type +type MockAgentTaskComponent struct { + mock.Mock +} + +type MockAgentTaskComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentTaskComponent) EXPECT() *MockAgentTaskComponent_Expecter { + return &MockAgentTaskComponent_Expecter{mock: &_m.Mock} +} + +// CreateTaskIfInstanceExists provides a mock function with given fields: ctx, req +func (_m *MockAgentTaskComponent) 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 +} + +// MockAgentTaskComponent_CreateTaskIfInstanceExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTaskIfInstanceExists' +type MockAgentTaskComponent_CreateTaskIfInstanceExists_Call struct { + *mock.Call +} + +// CreateTaskIfInstanceExists is a helper method to define mock.On call +// - ctx context.Context +// - req *types.AgentInstanceTaskReq +func (_e *MockAgentTaskComponent_Expecter) CreateTaskIfInstanceExists(ctx interface{}, req interface{}) *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call { + return &MockAgentTaskComponent_CreateTaskIfInstanceExists_Call{Call: _e.mock.On("CreateTaskIfInstanceExists", ctx, req)} +} + +func (_c *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call) Run(run func(ctx context.Context, req *types.AgentInstanceTaskReq)) *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentInstanceTaskReq)) + }) + return _c +} + +func (_c *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call) Return(_a0 error) *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call) RunAndReturn(run func(context.Context, *types.AgentInstanceTaskReq) error) *MockAgentTaskComponent_CreateTaskIfInstanceExists_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskDetail provides a mock function with given fields: ctx, userUUID, id +func (_m *MockAgentTaskComponent) 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 +} + +// MockAgentTaskComponent_GetTaskDetail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskDetail' +type MockAgentTaskComponent_GetTaskDetail_Call struct { + *mock.Call +} + +// GetTaskDetail is a helper method to define mock.On call +// - ctx context.Context +// - userUUID string +// - id int64 +func (_e *MockAgentTaskComponent_Expecter) GetTaskDetail(ctx interface{}, userUUID interface{}, id interface{}) *MockAgentTaskComponent_GetTaskDetail_Call { + return &MockAgentTaskComponent_GetTaskDetail_Call{Call: _e.mock.On("GetTaskDetail", ctx, userUUID, id)} +} + +func (_c *MockAgentTaskComponent_GetTaskDetail_Call) Run(run func(ctx context.Context, userUUID string, id int64)) *MockAgentTaskComponent_GetTaskDetail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(int64)) + }) + return _c +} + +func (_c *MockAgentTaskComponent_GetTaskDetail_Call) Return(_a0 *types.AgentTaskDetail, _a1 error) *MockAgentTaskComponent_GetTaskDetail_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentTaskComponent_GetTaskDetail_Call) RunAndReturn(run func(context.Context, string, int64) (*types.AgentTaskDetail, error)) *MockAgentTaskComponent_GetTaskDetail_Call { + _c.Call.Return(run) + return _c +} + +// ListTasks provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentTaskComponent) 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 +} + +// MockAgentTaskComponent_ListTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTasks' +type MockAgentTaskComponent_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 *MockAgentTaskComponent_Expecter) ListTasks(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentTaskComponent_ListTasks_Call { + return &MockAgentTaskComponent_ListTasks_Call{Call: _e.mock.On("ListTasks", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentTaskComponent_ListTasks_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentTaskFilter, per int, page int)) *MockAgentTaskComponent_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 *MockAgentTaskComponent_ListTasks_Call) Return(_a0 []types.AgentTaskListItem, _a1 int, _a2 error) *MockAgentTaskComponent_ListTasks_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentTaskComponent_ListTasks_Call) RunAndReturn(run func(context.Context, string, types.AgentTaskFilter, int, int) ([]types.AgentTaskListItem, int, error)) *MockAgentTaskComponent_ListTasks_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentTaskComponent creates a new instance of MockAgentTaskComponent. 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 NewMockAgentTaskComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentTaskComponent { + mock := &MockAgentTaskComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/_mocks/opencsg.com/csghub-server/component/mock_AgentTemplateComponent.go b/_mocks/opencsg.com/csghub-server/component/mock_AgentTemplateComponent.go new file mode 100644 index 000000000..00ff8651a --- /dev/null +++ b/_mocks/opencsg.com/csghub-server/component/mock_AgentTemplateComponent.go @@ -0,0 +1,308 @@ +// 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" +) + +// MockAgentTemplateComponent is an autogenerated mock type for the AgentTemplateComponent type +type MockAgentTemplateComponent struct { + mock.Mock +} + +type MockAgentTemplateComponent_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAgentTemplateComponent) EXPECT() *MockAgentTemplateComponent_Expecter { + return &MockAgentTemplateComponent_Expecter{mock: &_m.Mock} +} + +// CreateTemplate provides a mock function with given fields: ctx, template +func (_m *MockAgentTemplateComponent) 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 +} + +// MockAgentTemplateComponent_CreateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTemplate' +type MockAgentTemplateComponent_CreateTemplate_Call struct { + *mock.Call +} + +// CreateTemplate is a helper method to define mock.On call +// - ctx context.Context +// - template *types.AgentTemplate +func (_e *MockAgentTemplateComponent_Expecter) CreateTemplate(ctx interface{}, template interface{}) *MockAgentTemplateComponent_CreateTemplate_Call { + return &MockAgentTemplateComponent_CreateTemplate_Call{Call: _e.mock.On("CreateTemplate", ctx, template)} +} + +func (_c *MockAgentTemplateComponent_CreateTemplate_Call) Run(run func(ctx context.Context, template *types.AgentTemplate)) *MockAgentTemplateComponent_CreateTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentTemplate)) + }) + return _c +} + +func (_c *MockAgentTemplateComponent_CreateTemplate_Call) Return(_a0 error) *MockAgentTemplateComponent_CreateTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentTemplateComponent_CreateTemplate_Call) RunAndReturn(run func(context.Context, *types.AgentTemplate) error) *MockAgentTemplateComponent_CreateTemplate_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTemplate provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentTemplateComponent) 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 +} + +// MockAgentTemplateComponent_DeleteTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTemplate' +type MockAgentTemplateComponent_DeleteTemplate_Call struct { + *mock.Call +} + +// DeleteTemplate is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentTemplateComponent_Expecter) DeleteTemplate(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentTemplateComponent_DeleteTemplate_Call { + return &MockAgentTemplateComponent_DeleteTemplate_Call{Call: _e.mock.On("DeleteTemplate", ctx, id, userUUID)} +} + +func (_c *MockAgentTemplateComponent_DeleteTemplate_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentTemplateComponent_DeleteTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentTemplateComponent_DeleteTemplate_Call) Return(_a0 error) *MockAgentTemplateComponent_DeleteTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentTemplateComponent_DeleteTemplate_Call) RunAndReturn(run func(context.Context, int64, string) error) *MockAgentTemplateComponent_DeleteTemplate_Call { + _c.Call.Return(run) + return _c +} + +// GetTemplateByID provides a mock function with given fields: ctx, id, userUUID +func (_m *MockAgentTemplateComponent) 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 +} + +// MockAgentTemplateComponent_GetTemplateByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTemplateByID' +type MockAgentTemplateComponent_GetTemplateByID_Call struct { + *mock.Call +} + +// GetTemplateByID is a helper method to define mock.On call +// - ctx context.Context +// - id int64 +// - userUUID string +func (_e *MockAgentTemplateComponent_Expecter) GetTemplateByID(ctx interface{}, id interface{}, userUUID interface{}) *MockAgentTemplateComponent_GetTemplateByID_Call { + return &MockAgentTemplateComponent_GetTemplateByID_Call{Call: _e.mock.On("GetTemplateByID", ctx, id, userUUID)} +} + +func (_c *MockAgentTemplateComponent_GetTemplateByID_Call) Run(run func(ctx context.Context, id int64, userUUID string)) *MockAgentTemplateComponent_GetTemplateByID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(int64), args[2].(string)) + }) + return _c +} + +func (_c *MockAgentTemplateComponent_GetTemplateByID_Call) Return(_a0 *types.AgentTemplate, _a1 error) *MockAgentTemplateComponent_GetTemplateByID_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockAgentTemplateComponent_GetTemplateByID_Call) RunAndReturn(run func(context.Context, int64, string) (*types.AgentTemplate, error)) *MockAgentTemplateComponent_GetTemplateByID_Call { + _c.Call.Return(run) + return _c +} + +// ListTemplatesByUserUUID provides a mock function with given fields: ctx, userUUID, filter, per, page +func (_m *MockAgentTemplateComponent) 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 +} + +// MockAgentTemplateComponent_ListTemplatesByUserUUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTemplatesByUserUUID' +type MockAgentTemplateComponent_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 *MockAgentTemplateComponent_Expecter) ListTemplatesByUserUUID(ctx interface{}, userUUID interface{}, filter interface{}, per interface{}, page interface{}) *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call { + return &MockAgentTemplateComponent_ListTemplatesByUserUUID_Call{Call: _e.mock.On("ListTemplatesByUserUUID", ctx, userUUID, filter, per, page)} +} + +func (_c *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call) Run(run func(ctx context.Context, userUUID string, filter types.AgentTemplateFilter, per int, page int)) *MockAgentTemplateComponent_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 *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call) Return(_a0 []types.AgentTemplate, _a1 int, _a2 error) *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call) RunAndReturn(run func(context.Context, string, types.AgentTemplateFilter, int, int) ([]types.AgentTemplate, int, error)) *MockAgentTemplateComponent_ListTemplatesByUserUUID_Call { + _c.Call.Return(run) + return _c +} + +// UpdateTemplate provides a mock function with given fields: ctx, template +func (_m *MockAgentTemplateComponent) 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 +} + +// MockAgentTemplateComponent_UpdateTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTemplate' +type MockAgentTemplateComponent_UpdateTemplate_Call struct { + *mock.Call +} + +// UpdateTemplate is a helper method to define mock.On call +// - ctx context.Context +// - template *types.AgentTemplate +func (_e *MockAgentTemplateComponent_Expecter) UpdateTemplate(ctx interface{}, template interface{}) *MockAgentTemplateComponent_UpdateTemplate_Call { + return &MockAgentTemplateComponent_UpdateTemplate_Call{Call: _e.mock.On("UpdateTemplate", ctx, template)} +} + +func (_c *MockAgentTemplateComponent_UpdateTemplate_Call) Run(run func(ctx context.Context, template *types.AgentTemplate)) *MockAgentTemplateComponent_UpdateTemplate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.AgentTemplate)) + }) + return _c +} + +func (_c *MockAgentTemplateComponent_UpdateTemplate_Call) Return(_a0 error) *MockAgentTemplateComponent_UpdateTemplate_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockAgentTemplateComponent_UpdateTemplate_Call) RunAndReturn(run func(context.Context, *types.AgentTemplate) error) *MockAgentTemplateComponent_UpdateTemplate_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAgentTemplateComponent creates a new instance of MockAgentTemplateComponent. 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 NewMockAgentTemplateComponent(t interface { + mock.TestingT + Cleanup(func()) +}) *MockAgentTemplateComponent { + mock := &MockAgentTemplateComponent{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/common/utils/common/map.go b/common/utils/common/map.go new file mode 100644 index 000000000..2853dacea --- /dev/null +++ b/common/utils/common/map.go @@ -0,0 +1,24 @@ +package common + +// MergeMapWithDeletion merges src into dst. +// If a value in src is nil, the key is deleted from dst. +// If the map pointed to by dst is nil, it will be initialized. +// dst must be a non-nil pointer. +func MergeMapWithDeletion(dst *map[string]any, src map[string]any) { + if src == nil { + return + } + if dst == nil { + return + } + if *dst == nil { + *dst = make(map[string]any) + } + for k, v := range src { + if v == nil { + delete(*dst, k) + } else { + (*dst)[k] = v + } + } +} diff --git a/common/utils/common/map_test.go b/common/utils/common/map_test.go new file mode 100644 index 000000000..84a427422 --- /dev/null +++ b/common/utils/common/map_test.go @@ -0,0 +1,193 @@ +package common + +import ( + "testing" +) + +func TestMergeMapWithDeletion(t *testing.T) { + tests := []struct { + name string + dst *map[string]any + src map[string]any + expected *map[string]any + expectNilDst bool + }{ + { + name: "merge with nil src should not modify dst", + dst: &map[string]any{"key1": "value1"}, + src: nil, + expected: &map[string]any{ + "key1": "value1", + }, + }, + { + name: "merge with nil dst pointer should return early", + dst: nil, + src: map[string]any{"key1": "value1", "key2": "value2"}, + expectNilDst: true, + }, + { + name: "merge with nil map should initialize and merge", + dst: func() *map[string]any { var m map[string]any; return &m }(), + src: map[string]any{"key1": "value1", "key2": "value2"}, + expected: &map[string]any{ + "key1": "value1", + "key2": "value2", + }, + }, + { + name: "merge should add new keys", + dst: &map[string]any{"key1": "value1"}, + src: map[string]any{"key2": "value2", "key3": "value3"}, + expected: &map[string]any{ + "key1": "value1", + "key2": "value2", + "key3": "value3", + }, + }, + { + name: "merge should update existing keys", + dst: &map[string]any{"key1": "old_value", "key2": "value2"}, + src: map[string]any{"key1": "new_value"}, + expected: &map[string]any{ + "key1": "new_value", + "key2": "value2", + }, + }, + { + name: "merge should delete keys when value is nil", + dst: &map[string]any{"key1": "value1", "key2": "value2", "key3": "value3"}, + src: map[string]any{"key2": nil}, + expected: &map[string]any{ + "key1": "value1", + "key3": "value3", + }, + }, + { + name: "merge with nil map and nil values should initialize but not add nil keys", + dst: func() *map[string]any { var m map[string]any; return &m }(), + src: map[string]any{"key1": "value1", "key2": nil}, + expected: &map[string]any{ + "key1": "value1", + }, + }, + { + name: "merge should handle mixed operations", + dst: &map[string]any{"key1": "old_value", "key2": "value2", "key3": "value3"}, + src: map[string]any{"key1": "new_value", "key2": nil, "key4": "value4"}, + expected: &map[string]any{ + "key1": "new_value", + "key3": "value3", + "key4": "value4", + }, + }, + { + name: "merge should handle empty dst", + dst: &map[string]any{}, + src: map[string]any{"key1": "value1"}, + expected: &map[string]any{ + "key1": "value1", + }, + }, + { + name: "merge should handle empty src", + dst: &map[string]any{"key1": "value1"}, + src: map[string]any{}, + expected: &map[string]any{ + "key1": "value1", + }, + }, + { + name: "merge should handle different value types", + dst: &map[string]any{"key1": "value1"}, + src: map[string]any{"key2": 42, "key3": true, "key4": []string{"a", "b"}}, + expected: &map[string]any{ + "key1": "value1", + "key2": 42, + "key3": true, + "key4": []string{"a", "b"}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var dst *map[string]any + if tt.dst != nil { + dstMap := make(map[string]any) + for k, v := range *tt.dst { + dstMap[k] = v + } + dst = &dstMap + } + // dst can be nil for the nil pointer test case + + MergeMapWithDeletion(dst, tt.src) + + if tt.expectNilDst { + // Test case expects dst to remain nil + if dst != nil { + t.Error("expected dst to remain nil") + } + return + } + + if dst == nil { + t.Fatal("dst should not be nil after merge") + } + + if tt.expected == nil { + t.Fatal("test case must provide expected result or set expectNilDst") + } + + if len(*dst) != len(*tt.expected) { + t.Errorf("expected length %d, got %d", len(*tt.expected), len(*dst)) + } + + for k, expectedValue := range *tt.expected { + actualValue, exists := (*dst)[k] + if !exists { + t.Errorf("expected key %s to exist", k) + continue + } + if !equalValues(actualValue, expectedValue) { + t.Errorf("key %s: expected %v, got %v", k, expectedValue, actualValue) + } + } + + for k := range *dst { + if _, exists := (*tt.expected)[k]; !exists { + t.Errorf("unexpected key %s in result", k) + } + } + }) + } +} + +// equalValues compares two values for equality, handling slices and other types +func equalValues(a, b any) bool { + if a == nil && b == nil { + return true + } + if a == nil || b == nil { + return false + } + + // For slices, we need special handling + if aSlice, ok := a.([]string); ok { + if bSlice, ok := b.([]string); ok { + if len(aSlice) != len(bSlice) { + return false + } + for i := range aSlice { + if aSlice[i] != bSlice[i] { + return false + } + } + return true + } + return false + } + + return a == b +} diff --git a/component/wire_gen_test.go b/component/wire_gen_test.go index 43de7d0e7..d5eaf0578 100644 --- a/component/wire_gen_test.go +++ b/component/wire_gen_test.go @@ -8,7 +8,6 @@ package component import ( "context" - "github.com/google/wire" "github.com/stretchr/testify/mock" "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/accounting" @@ -45,8 +44,8 @@ func initializeTestRepoComponent(ctx context.Context, t interface { mockAccountingComponent := component.NewMockAccountingComponent(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) multisyncMockClient := multisync.NewMockClient(t) - mockXnetClient := rpc.NewMockXnetSvcClient(t) - componentRepoComponentImpl := NewTestRepoComponent(config, mockStores, mockUserSvcClient, mockGitServer, mockTagComponent, mockClient, mockDeployer, mockCache, mockAccountingComponent, mockMirrorServer, multisyncMockClient, mockXnetClient) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) + componentRepoComponentImpl := NewTestRepoComponent(config, mockStores, mockUserSvcClient, mockGitServer, mockTagComponent, mockClient, mockDeployer, mockCache, mockAccountingComponent, mockMirrorServer, multisyncMockClient, mockXnetSvcClient) mockRepoComponent := component.NewMockRepoComponent(t) mockSpaceComponent := component.NewMockSpaceComponent(t) mockRuntimeArchitectureComponent := component.NewMockRuntimeArchitectureComponent(t) @@ -72,6 +71,7 @@ func initializeTestRepoComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -116,6 +116,7 @@ func initializeTestPromptComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -134,6 +135,7 @@ func initializeTestPromptComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -178,6 +180,7 @@ func initializeTestUserComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -195,6 +198,7 @@ func initializeTestUserComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -240,6 +244,7 @@ func initializeTestSpaceComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -257,6 +262,7 @@ func initializeTestSpaceComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -302,6 +308,7 @@ func initializeTestModelComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -319,6 +326,7 @@ func initializeTestModelComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -363,6 +371,7 @@ func initializeTestAccountingComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -380,6 +389,7 @@ func initializeTestAccountingComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -411,8 +421,8 @@ func initializeTestGitHTTPComponent(ctx context.Context, t interface { mockGitServer := gitserver.NewMockGitServer(t) mockClient := s3.NewMockClient(t) mockCore := s3.NewMockCore(t) - mockXnetClient := rpc.NewMockXnetSvcClient(t) - componentGitHTTPComponentImpl := NewTestGitHTTPComponent(config, mockStores, mockRepoComponent, mockGitServer, mockClient, mockCore, mockXnetClient) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) + componentGitHTTPComponentImpl := NewTestGitHTTPComponent(config, mockStores, mockRepoComponent, mockGitServer, mockClient, mockCore, mockXnetSvcClient) mockAccountingComponent := component.NewMockAccountingComponent(t) mockTagComponent := component.NewMockTagComponent(t) mockSpaceComponent := component.NewMockSpaceComponent(t) @@ -443,6 +453,7 @@ func initializeTestGitHTTPComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -486,6 +497,7 @@ func initializeTestDiscussionComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -504,6 +516,7 @@ func initializeTestDiscussionComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -547,6 +560,7 @@ func initializeTestRuntimeArchComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -565,6 +579,7 @@ func initializeTestRuntimeArchComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -611,6 +626,7 @@ func initializeTestMirrorComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockDeployer := deploy.NewMockDeployer(t) mockCache := cache.NewMockCache(t) mockAccountingClient := accounting.NewMockAccountingClient(t) @@ -627,6 +643,7 @@ func initializeTestMirrorComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -670,6 +687,7 @@ func initializeTestCollectionComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockGitServer := gitserver.NewMockGitServer(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -688,6 +706,7 @@ func initializeTestCollectionComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -731,6 +750,7 @@ func initializeTestBroadcastComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -749,6 +769,7 @@ func initializeTestBroadcastComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -793,6 +814,7 @@ func initializeTestDatasetComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -811,6 +833,7 @@ func initializeTestDatasetComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -855,6 +878,7 @@ func initializeTestCodeComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -873,6 +897,7 @@ func initializeTestCodeComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -917,6 +942,7 @@ func initializeTestMultiSyncComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -935,6 +961,7 @@ func initializeTestMultiSyncComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -981,6 +1008,7 @@ func initializeTestInternalComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -997,6 +1025,7 @@ func initializeTestInternalComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1041,6 +1070,7 @@ func initializeTestMirrorSourceComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1059,6 +1089,7 @@ func initializeTestMirrorSourceComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1104,6 +1135,7 @@ func initializeTestSpaceResourceComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -1121,6 +1153,7 @@ func initializeTestSpaceResourceComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1166,6 +1199,7 @@ func initializeTestTagComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1183,6 +1217,7 @@ func initializeTestTagComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1227,6 +1262,7 @@ func initializeTestRecomComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1245,6 +1281,7 @@ func initializeTestRecomComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1289,6 +1326,7 @@ func initializeTestSpaceSdkComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1307,6 +1345,7 @@ func initializeTestSpaceSdkComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1351,6 +1390,7 @@ func initializeTestTelemetryComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1369,6 +1409,7 @@ func initializeTestTelemetryComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1414,6 +1455,7 @@ func initializeTestClusterComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -1431,6 +1473,7 @@ func initializeTestClusterComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1462,14 +1505,7 @@ func initializeTestEvaluationComponent(ctx context.Context, t interface { mockAccountingComponent := component.NewMockAccountingComponent(t) mockRepoComponent := component.NewMockRepoComponent(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) - componentEvaluationComponentImpl := NewTestEvaluationComponent( - config, - mockStores, - mockDeployer, - mockAccountingComponent, - mockRepoComponent, - mockUserSvcClient, - ) + componentEvaluationComponentImpl := NewTestEvaluationComponent(config, mockStores, mockDeployer, mockAccountingComponent, mockRepoComponent, mockUserSvcClient) mockTagComponent := component.NewMockTagComponent(t) mockSpaceComponent := component.NewMockSpaceComponent(t) mockRuntimeArchitectureComponent := component.NewMockRuntimeArchitectureComponent(t) @@ -1483,6 +1519,7 @@ func initializeTestEvaluationComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockGitServer := gitserver.NewMockGitServer(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -1500,6 +1537,7 @@ func initializeTestEvaluationComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1544,6 +1582,7 @@ func initializeTestHFDatasetComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1562,6 +1601,7 @@ func initializeTestHFDatasetComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1606,6 +1646,7 @@ func initializeTestRepoFileComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1624,6 +1665,7 @@ func initializeTestRepoFileComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1669,6 +1711,7 @@ func initializeTestSensitiveComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1686,6 +1729,7 @@ func initializeTestSensitiveComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1730,6 +1774,7 @@ func initializeTestSSHKeyComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1748,6 +1793,7 @@ func initializeTestSSHKeyComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1792,6 +1838,7 @@ func initializeTestListComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1810,6 +1857,7 @@ func initializeTestListComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1854,6 +1902,7 @@ func initializeTestSyncClientSettingComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1872,6 +1921,7 @@ func initializeTestSyncClientSettingComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1916,6 +1966,7 @@ func initializeTestEventComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1934,6 +1985,7 @@ func initializeTestEventComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -1979,6 +2031,7 @@ func initializeTestLicenseComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -1996,6 +2049,7 @@ func initializeTestLicenseComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2041,6 +2095,7 @@ func initializeTestImportComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2058,6 +2113,7 @@ func initializeTestImportComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2102,6 +2158,7 @@ func initializeTestSpaceTemplateComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2120,6 +2177,7 @@ func initializeTestSpaceTemplateComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2164,6 +2222,7 @@ func initializeTestRuleComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2182,6 +2241,7 @@ func initializeTestRuleComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2226,6 +2286,7 @@ func initializeTestMCPServerComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2244,6 +2305,7 @@ func initializeTestMCPServerComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2288,6 +2350,7 @@ func initializeTestMCPScannerComponent(ctx context.Context, t interface { sensitive: mockSensitiveComponent, } mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2306,6 +2369,7 @@ func initializeTestMCPScannerComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2350,6 +2414,7 @@ func initializeTestStatComponent(ctx context.Context, t interface { runtimeArchitecture: mockRuntimeArchitectureComponent, sensitive: mockSensitiveComponent, } + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2368,6 +2433,7 @@ func initializeTestStatComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2412,6 +2478,7 @@ func initializeTestLLMServiceComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2430,6 +2497,7 @@ func initializeTestLLMServiceComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2474,6 +2542,7 @@ func initializeTestNotebookComponent(ctx context.Context, t interface { } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockCache := cache.NewMockCache(t) @@ -2491,6 +2560,7 @@ func initializeTestNotebookComponent(ctx context.Context, t interface { components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2535,6 +2605,7 @@ func initializeTestMirrorNamespaceMappingComponent(ctx context.Context, t interf } mockGitServer := gitserver.NewMockGitServer(t) mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) mockClient := s3.NewMockClient(t) mockMirrorServer := mirrorserver.NewMockMirrorServer(t) mockDeployer := deploy.NewMockDeployer(t) @@ -2553,6 +2624,7 @@ func initializeTestMirrorNamespaceMappingComponent(ctx context.Context, t interf components: componentMockedComponents, gitServer: mockGitServer, userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, s3Client: mockClient, mirrorServer: mockMirrorServer, deployer: mockDeployer, @@ -2574,6 +2646,69 @@ func initializeTestMirrorNamespaceMappingComponent(ctx context.Context, t interf return componentTestMirrorNamespaceMappingWithMocks } +func initializeTestXnetComponent(ctx context.Context, t interface { + Cleanup(func()) + mock.TestingT +}) *testXnetWithMocks { + mockStores := tests.NewMockStores(t) + mockXnetSvcClient := rpc.NewMockXnetSvcClient(t) + mockRepoComponent := component.NewMockRepoComponent(t) + xnetComponentImpl := NewTestXnetComponent(mockStores, mockXnetSvcClient, mockRepoComponent) + mockAccountingComponent := component.NewMockAccountingComponent(t) + mockTagComponent := component.NewMockTagComponent(t) + mockSpaceComponent := component.NewMockSpaceComponent(t) + mockRuntimeArchitectureComponent := component.NewMockRuntimeArchitectureComponent(t) + mockSensitiveComponent := component.NewMockSensitiveComponent(t) + componentMockedComponents := &mockedComponents{ + accounting: mockAccountingComponent, + repo: mockRepoComponent, + tag: mockTagComponent, + space: mockSpaceComponent, + runtimeArchitecture: mockRuntimeArchitectureComponent, + sensitive: mockSensitiveComponent, + } + mockGitServer := gitserver.NewMockGitServer(t) + mockUserSvcClient := rpc.NewMockUserSvcClient(t) + mockClient := s3.NewMockClient(t) + mockMirrorServer := mirrorserver.NewMockMirrorServer(t) + mockDeployer := deploy.NewMockDeployer(t) + mockCache := cache.NewMockCache(t) + mockAccountingClient := accounting.NewMockAccountingClient(t) + mockReader := parquet.NewMockReader(t) + mockModerationSvcClient := rpc.NewMockModerationSvcClient(t) + mockKeysReader := rsa.NewMockKeysReader(t) + mockImporter := importer.NewMockImporter(t) + mockDataviewerClient := dataviewer.NewMockDataviewerClient(t) + multisyncMockClient := multisync.NewMockClient(t) + mockCore := s3.NewMockCore(t) + mockGitCallbackChecker := checker.NewMockGitCallbackChecker(t) + mocks := &Mocks{ + stores: mockStores, + components: componentMockedComponents, + gitServer: mockGitServer, + userSvcClient: mockUserSvcClient, + xnetClient: mockXnetSvcClient, + s3Client: mockClient, + mirrorServer: mockMirrorServer, + deployer: mockDeployer, + cache: mockCache, + accountingClient: mockAccountingClient, + preader: mockReader, + moderationClient: mockModerationSvcClient, + rsaReader: mockKeysReader, + importer: mockImporter, + dataviewerClient: mockDataviewerClient, + multiSyncClient: multisyncMockClient, + s3Core: mockCore, + checker: mockGitCallbackChecker, + } + componentTestXnetWithMocks := &testXnetWithMocks{ + XnetComponentImpl: xnetComponentImpl, + mocks: mocks, + } + return componentTestXnetWithMocks +} + // wire.go: type testRepoWithMocks struct { @@ -2782,3 +2917,8 @@ type testNotebookWithMocks struct { } var MirrorNamespaceMappingComponentTestSet = wire.NewSet(NewTestMirrorNamespaceMappingComponent) + +type testXnetWithMocks struct { + *XnetComponentImpl + mocks *Mocks +} diff --git a/component/wireset.go b/component/wireset.go index ff1ac91fd..e34ff698f 100644 --- a/component/wireset.go +++ b/component/wireset.go @@ -151,42 +151,10 @@ var MockedCheckerSet = wire.NewSet( wire.Bind(new(checker.GitCallbackChecker), new(*mock_checker.MockGitCallbackChecker)), ) -type Mocks struct { - stores *tests.MockStores - components *mockedComponents - gitServer *mock_git.MockGitServer - userSvcClient *mock_rpc.MockUserSvcClient - s3Client *mock_s3.MockClient - mirrorServer *mock_mirror.MockMirrorServer - deployer *mock_deploy.MockDeployer - cache *mock_cache.MockCache - accountingClient *mock_accounting.MockAccountingClient - preader *mock_preader.MockReader - moderationClient *mock_rpc.MockModerationSvcClient - rsaReader *mock_rsa.MockKeysReader - importer *mock_importer.MockImporter - dataviewerClient *mock_dataviewer_client.MockDataviewerClient - multiSyncClient *mock_multisync.MockClient - s3Core *mock_s3.MockCore - checker *mock_checker.MockGitCallbackChecker -} - -var AllMockSet = wire.NewSet( - wire.Struct(new(mockedComponents), "*"), - wire.Struct(new(Mocks), "*"), -) - func ProvideTestConfig() *config.Config { return &config.Config{} } -var MockSuperSet = wire.NewSet( - MockedComponentSet, AllMockSet, MockedStoreSet, MockedGitServerSet, MockedUserSvcSet, - MockedXnetSvcClientSet, MockedS3Set, MockedS3CoreSet, MockedMultiSyncClientSet, MockedDeployerSet, MockedCacheSet, ProvideTestConfig, MockedMirrorServerSet, - MockedAccountingClientSet, MockedParquetReaderSet, MockedCheckerSet, - MockedModerationSvcClientSet, MockedRsaReader, MockedImporterSet, MockedDataviewerClientSet, -) - func NewTestRepoComponent(config *config.Config, stores *tests.MockStores, rpcUser rpc.UserSvcClient, gitServer gitserver.GitServer, tagComponent TagComponent, s3Client s3.Client, deployer deploy.Deployer, cache cache.Cache, accountingComponent AccountingComponent, mirrorServer mirrorserver.MirrorServer, multiSyncClient multisync.Client, xnetClient rpc.XnetSvcClient) *repoComponentImpl { return &repoComponentImpl{ userStore: stores.User, diff --git a/component/wireset_ce.go b/component/wireset_ce.go index 8a06e233b..a51640a97 100644 --- a/component/wireset_ce.go +++ b/component/wireset_ce.go @@ -3,6 +3,20 @@ package component import ( + "github.com/google/wire" + mock_accounting "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/accounting" + mock_dataviewer_client "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/dataviewer" + mock_deploy "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/deploy" + mock_git "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/git/gitserver" + mock_mirror "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/git/mirrorserver" + mock_importer "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/importer" + mock_multisync "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/multisync" + mock_preader "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/parquet" + mock_rpc "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/rpc" + mock_rsa "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/rsa" + mock_s3 "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/builder/store/s3" + mock_checker "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/component/checker" + mock_cache "opencsg.com/csghub-server/_mocks/opencsg.com/csghub-server/mirror/cache" "opencsg.com/csghub-server/builder/deploy" "opencsg.com/csghub-server/builder/git/gitserver" "opencsg.com/csghub-server/builder/rpc" @@ -10,6 +24,39 @@ import ( "opencsg.com/csghub-server/common/tests" ) +type Mocks struct { + stores *tests.MockStores + components *mockedComponents + gitServer *mock_git.MockGitServer + userSvcClient *mock_rpc.MockUserSvcClient + xnetClient *mock_rpc.MockXnetSvcClient + s3Client *mock_s3.MockClient + mirrorServer *mock_mirror.MockMirrorServer + deployer *mock_deploy.MockDeployer + cache *mock_cache.MockCache + accountingClient *mock_accounting.MockAccountingClient + preader *mock_preader.MockReader + moderationClient *mock_rpc.MockModerationSvcClient + rsaReader *mock_rsa.MockKeysReader + importer *mock_importer.MockImporter + dataviewerClient *mock_dataviewer_client.MockDataviewerClient + multiSyncClient *mock_multisync.MockClient + s3Core *mock_s3.MockCore + checker *mock_checker.MockGitCallbackChecker +} + +var AllMockSet = wire.NewSet( + wire.Struct(new(mockedComponents), "*"), + wire.Struct(new(Mocks), "*"), +) + +var MockSuperSet = wire.NewSet( + MockedComponentSet, AllMockSet, MockedStoreSet, MockedGitServerSet, MockedUserSvcSet, + MockedXnetSvcClientSet, MockedS3Set, MockedS3CoreSet, MockedMultiSyncClientSet, MockedDeployerSet, MockedCacheSet, ProvideTestConfig, MockedMirrorServerSet, + MockedAccountingClientSet, MockedParquetReaderSet, MockedCheckerSet, + MockedModerationSvcClientSet, MockedRsaReader, MockedImporterSet, MockedDataviewerClientSet, +) + func NewTestSpaceComponent( stores *tests.MockStores, repoComponent RepoComponent,