feat: manually mirror opencoze's code from bytedance

Change-Id: I09a73aadda978ad9511264a756b2ce51f5761adf

backend/internal/mock/infra/contract/chatmodel/chat_model_factory_mock.go

@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: chat_model.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/chatmodel/chat_model_factory_mock.go -package mock -source chat_model.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	chatmodel "github.com/coze-dev/coze-studio/backend/infra/contract/chatmodel"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockFactory is a mock of Factory interface.
+type MockFactory struct {
+	ctrl     *gomock.Controller
+	recorder *MockFactoryMockRecorder
+	isgomock struct{}
+}
+
+// MockFactoryMockRecorder is the mock recorder for MockFactory.
+type MockFactoryMockRecorder struct {
+	mock *MockFactory
+}
+
+// NewMockFactory creates a new mock instance.
+func NewMockFactory(ctrl *gomock.Controller) *MockFactory {
+	mock := &MockFactory{ctrl: ctrl}
+	mock.recorder = &MockFactoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockFactory) EXPECT() *MockFactoryMockRecorder {
+	return m.recorder
+}
+
+// CreateChatModel mocks base method.
+func (m *MockFactory) CreateChatModel(ctx context.Context, protocol chatmodel.Protocol, config *chatmodel.Config) (chatmodel.ToolCallingChatModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateChatModel", ctx, protocol, config)
+	ret0, _ := ret[0].(chatmodel.ToolCallingChatModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateChatModel indicates an expected call of CreateChatModel.
+func (mr *MockFactoryMockRecorder) CreateChatModel(ctx, protocol, config any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChatModel", reflect.TypeOf((*MockFactory)(nil).CreateChatModel), ctx, protocol, config)
+}
+
+// SupportProtocol mocks base method.
+func (m *MockFactory) SupportProtocol(protocol chatmodel.Protocol) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SupportProtocol", protocol)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// SupportProtocol indicates an expected call of SupportProtocol.
+func (mr *MockFactoryMockRecorder) SupportProtocol(protocol any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportProtocol", reflect.TypeOf((*MockFactory)(nil).SupportProtocol), protocol)
+}

backend/internal/mock/infra/contract/chatmodel/toolcalling_model_mock.go

@@ -0,0 +1,240 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: /Users/bytedance/gocode/src/github.com/cloudwego/eino/components/model/interface.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/chatmodel/toolcalling_model_mock.go -package mock -source /Users/bytedance/gocode/src/github.com/cloudwego/eino/components/model/interface.go ToolCallingChatModel
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	model "github.com/cloudwego/eino/components/model"
+	schema "github.com/cloudwego/eino/schema"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockBaseChatModel is a mock of BaseChatModel interface.
+type MockBaseChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockBaseChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockBaseChatModelMockRecorder is the mock recorder for MockBaseChatModel.
+type MockBaseChatModelMockRecorder struct {
+	mock *MockBaseChatModel
+}
+
+// NewMockBaseChatModel creates a new mock instance.
+func NewMockBaseChatModel(ctrl *gomock.Controller) *MockBaseChatModel {
+	mock := &MockBaseChatModel{ctrl: ctrl}
+	mock.recorder = &MockBaseChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBaseChatModel) EXPECT() *MockBaseChatModelMockRecorder {
+	return m.recorder
+}
+
+// Generate mocks base method.
+func (m *MockBaseChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockBaseChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockBaseChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockBaseChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockBaseChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockBaseChatModel)(nil).Stream), varargs...)
+}
+
+// MockChatModel is a mock of ChatModel interface.
+type MockChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockChatModelMockRecorder is the mock recorder for MockChatModel.
+type MockChatModelMockRecorder struct {
+	mock *MockChatModel
+}
+
+// NewMockChatModel creates a new mock instance.
+func NewMockChatModel(ctrl *gomock.Controller) *MockChatModel {
+	mock := &MockChatModel{ctrl: ctrl}
+	mock.recorder = &MockChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockChatModel) EXPECT() *MockChatModelMockRecorder {
+	return m.recorder
+}
+
+// BindTools mocks base method.
+func (m *MockChatModel) BindTools(tools []*schema.ToolInfo) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BindTools", tools)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BindTools indicates an expected call of BindTools.
+func (mr *MockChatModelMockRecorder) BindTools(tools any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindTools", reflect.TypeOf((*MockChatModel)(nil).BindTools), tools)
+}
+
+// Generate mocks base method.
+func (m *MockChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockChatModel)(nil).Stream), varargs...)
+}
+
+// MockToolCallingChatModel is a mock of ToolCallingChatModel interface.
+type MockToolCallingChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockToolCallingChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockToolCallingChatModelMockRecorder is the mock recorder for MockToolCallingChatModel.
+type MockToolCallingChatModelMockRecorder struct {
+	mock *MockToolCallingChatModel
+}
+
+// NewMockToolCallingChatModel creates a new mock instance.
+func NewMockToolCallingChatModel(ctrl *gomock.Controller) *MockToolCallingChatModel {
+	mock := &MockToolCallingChatModel{ctrl: ctrl}
+	mock.recorder = &MockToolCallingChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockToolCallingChatModel) EXPECT() *MockToolCallingChatModelMockRecorder {
+	return m.recorder
+}
+
+// Generate mocks base method.
+func (m *MockToolCallingChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockToolCallingChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockToolCallingChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockToolCallingChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockToolCallingChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockToolCallingChatModel)(nil).Stream), varargs...)
+}
+
+// WithTools mocks base method.
+func (m *MockToolCallingChatModel) WithTools(tools []*schema.ToolInfo) (model.ToolCallingChatModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WithTools", tools)
+	ret0, _ := ret[0].(model.ToolCallingChatModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WithTools indicates an expected call of WithTools.
+func (mr *MockToolCallingChatModelMockRecorder) WithTools(tools any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTools", reflect.TypeOf((*MockToolCallingChatModel)(nil).WithTools), tools)
+}

backend/internal/mock/infra/contract/eventbus/eventbus_mock.go

@@ -0,0 +1,142 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: eventbus.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/eventbus/eventbus_mock.go -package mock -source eventbus.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	eventbus "github.com/coze-dev/coze-studio/backend/infra/contract/eventbus"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockProducer is a mock of Producer interface.
+type MockProducer struct {
+	ctrl     *gomock.Controller
+	recorder *MockProducerMockRecorder
+	isgomock struct{}
+}
+
+// MockProducerMockRecorder is the mock recorder for MockProducer.
+type MockProducerMockRecorder struct {
+	mock *MockProducer
+}
+
+// NewMockProducer creates a new mock instance.
+func NewMockProducer(ctrl *gomock.Controller) *MockProducer {
+	mock := &MockProducer{ctrl: ctrl}
+	mock.recorder = &MockProducerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockProducer) EXPECT() *MockProducerMockRecorder {
+	return m.recorder
+}
+
+// BatchSend mocks base method.
+func (m *MockProducer) BatchSend(ctx context.Context, bodyArr [][]byte, opts ...eventbus.SendOpt) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, bodyArr}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BatchSend", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BatchSend indicates an expected call of BatchSend.
+func (mr *MockProducerMockRecorder) BatchSend(ctx, bodyArr any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, bodyArr}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSend", reflect.TypeOf((*MockProducer)(nil).BatchSend), varargs...)
+}
+
+// Send mocks base method.
+func (m *MockProducer) Send(ctx context.Context, body []byte, opts ...eventbus.SendOpt) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Send", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Send indicates an expected call of Send.
+func (mr *MockProducerMockRecorder) Send(ctx, body any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProducer)(nil).Send), varargs...)
+}
+
+// MockConsumer is a mock of Consumer interface.
+type MockConsumer struct {
+	ctrl     *gomock.Controller
+	recorder *MockConsumerMockRecorder
+	isgomock struct{}
+}
+
+// MockConsumerMockRecorder is the mock recorder for MockConsumer.
+type MockConsumerMockRecorder struct {
+	mock *MockConsumer
+}
+
+// NewMockConsumer creates a new mock instance.
+func NewMockConsumer(ctrl *gomock.Controller) *MockConsumer {
+	mock := &MockConsumer{ctrl: ctrl}
+	mock.recorder = &MockConsumerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConsumer) EXPECT() *MockConsumerMockRecorder {
+	return m.recorder
+}
+
+// MockConsumerHandler is a mock of ConsumerHandler interface.
+type MockConsumerHandler struct {
+	ctrl     *gomock.Controller
+	recorder *MockConsumerHandlerMockRecorder
+	isgomock struct{}
+}
+
+// MockConsumerHandlerMockRecorder is the mock recorder for MockConsumerHandler.
+type MockConsumerHandlerMockRecorder struct {
+	mock *MockConsumerHandler
+}
+
+// NewMockConsumerHandler creates a new mock instance.
+func NewMockConsumerHandler(ctrl *gomock.Controller) *MockConsumerHandler {
+	mock := &MockConsumerHandler{ctrl: ctrl}
+	mock.recorder = &MockConsumerHandlerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConsumerHandler) EXPECT() *MockConsumerHandlerMockRecorder {
+	return m.recorder
+}
+
+// HandleMessage mocks base method.
+func (m *MockConsumerHandler) HandleMessage(ctx context.Context, msg *eventbus.Message) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HandleMessage", ctx, msg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// HandleMessage indicates an expected call of HandleMessage.
+func (mr *MockConsumerHandlerMockRecorder) HandleMessage(ctx, msg any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockConsumerHandler)(nil).HandleMessage), ctx, msg)
+}

backend/internal/mock/infra/contract/idgen/idgen_mock.go

@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: idgen.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/idgen/idgen_mock.go --package mock -source idgen.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockIDGenerator is a mock of IDGenerator interface.
+type MockIDGenerator struct {
+	ctrl     *gomock.Controller
+	recorder *MockIDGeneratorMockRecorder
+	isgomock struct{}
+}
+
+// MockIDGeneratorMockRecorder is the mock recorder for MockIDGenerator.
+type MockIDGeneratorMockRecorder struct {
+	mock *MockIDGenerator
+}
+
+// NewMockIDGenerator creates a new mock instance.
+func NewMockIDGenerator(ctrl *gomock.Controller) *MockIDGenerator {
+	mock := &MockIDGenerator{ctrl: ctrl}
+	mock.recorder = &MockIDGeneratorMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockIDGenerator) EXPECT() *MockIDGeneratorMockRecorder {
+	return m.recorder
+}
+
+// GenID mocks base method.
+func (m *MockIDGenerator) GenID(ctx context.Context) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GenID", ctx)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GenID indicates an expected call of GenID.
+func (mr *MockIDGeneratorMockRecorder) GenID(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenID", reflect.TypeOf((*MockIDGenerator)(nil).GenID), ctx)
+}
+
+// GenMultiIDs mocks base method.
+func (m *MockIDGenerator) GenMultiIDs(ctx context.Context, counts int) ([]int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GenMultiIDs", ctx, counts)
+	ret0, _ := ret[0].([]int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GenMultiIDs indicates an expected call of GenMultiIDs.
+func (mr *MockIDGeneratorMockRecorder) GenMultiIDs(ctx, counts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenMultiIDs", reflect.TypeOf((*MockIDGenerator)(nil).GenMultiIDs), ctx, counts)
+}

backend/internal/mock/infra/contract/imagex/imagex_mock.go

@@ -0,0 +1,152 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: imagex.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/imagex/imagex_mock.go --package imagex -source imagex.go
+//
+
+// Package imagex is a generated GoMock package.
+package imagex
+
+import (
+	context "context"
+	reflect "reflect"
+	time "time"
+
+	gomock "go.uber.org/mock/gomock"
+
+	imagex "github.com/coze-dev/coze-studio/backend/infra/contract/imagex"
+)
+
+// MockImageX is a mock of ImageX interface.
+type MockImageX struct {
+	ctrl     *gomock.Controller
+	recorder *MockImageXMockRecorder
+	isgomock struct{}
+}
+
+// MockImageXMockRecorder is the mock recorder for MockImageX.
+type MockImageXMockRecorder struct {
+	mock *MockImageX
+}
+
+// NewMockImageX creates a new mock instance.
+func NewMockImageX(ctrl *gomock.Controller) *MockImageX {
+	mock := &MockImageX{ctrl: ctrl}
+	mock.recorder = &MockImageXMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockImageX) EXPECT() *MockImageXMockRecorder {
+	return m.recorder
+}
+
+// GetResourceURL mocks base method.
+func (m *MockImageX) GetResourceURL(ctx context.Context, uri string, opts ...imagex.GetResourceOpt) (*imagex.ResourceURL, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, uri}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetResourceURL", varargs...)
+	ret0, _ := ret[0].(*imagex.ResourceURL)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetResourceURL indicates an expected call of GetResourceURL.
+func (mr *MockImageXMockRecorder) GetResourceURL(ctx, uri any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, uri}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceURL", reflect.TypeOf((*MockImageX)(nil).GetResourceURL), varargs...)
+}
+
+// GetServerID mocks base method.
+func (m *MockImageX) GetServerID() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServerID")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetServerID indicates an expected call of GetServerID.
+func (mr *MockImageXMockRecorder) GetServerID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerID", reflect.TypeOf((*MockImageX)(nil).GetServerID))
+}
+
+// GetUploadAuth mocks base method.
+func (m *MockImageX) GetUploadAuth(ctx context.Context, opt ...imagex.UploadAuthOpt) (*imagex.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range opt {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUploadAuth", varargs...)
+	ret0, _ := ret[0].(*imagex.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuth indicates an expected call of GetUploadAuth.
+func (mr *MockImageXMockRecorder) GetUploadAuth(ctx any, opt ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, opt...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuth", reflect.TypeOf((*MockImageX)(nil).GetUploadAuth), varargs...)
+}
+
+// GetUploadAuthWithExpire mocks base method.
+func (m *MockImageX) GetUploadAuthWithExpire(ctx context.Context, expire time.Duration, opt ...imagex.UploadAuthOpt) (*imagex.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, expire}
+	for _, a := range opt {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUploadAuthWithExpire", varargs...)
+	ret0, _ := ret[0].(*imagex.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuthWithExpire indicates an expected call of GetUploadAuthWithExpire.
+func (mr *MockImageXMockRecorder) GetUploadAuthWithExpire(ctx, expire any, opt ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, expire}, opt...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuthWithExpire", reflect.TypeOf((*MockImageX)(nil).GetUploadAuthWithExpire), varargs...)
+}
+
+// GetUploadHost mocks base method.
+func (m *MockImageX) GetUploadHost() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUploadHost")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetUploadHost indicates an expected call of GetUploadHost.
+func (mr *MockImageXMockRecorder) GetUploadHost() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadHost", reflect.TypeOf((*MockImageX)(nil).GetUploadHost))
+}
+
+// Upload mocks base method.
+func (m *MockImageX) Upload(ctx context.Context, data []byte, opts ...imagex.UploadAuthOpt) (*imagex.UploadResult, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, data}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Upload", varargs...)
+	ret0, _ := ret[0].(*imagex.UploadResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Upload indicates an expected call of Upload.
+func (mr *MockImageXMockRecorder) Upload(ctx, data any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, data}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockImageX)(nil).Upload), varargs...)
+}

backend/internal/mock/infra/contract/orm/sqlitedb.go

@@ -0,0 +1,154 @@
+package orm
+
+import (
+	"fmt"
+	"reflect"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// MockDB represents a test database setup helper
+type MockDB struct {
+	db     *gorm.DB
+	tables map[any]*Table
+}
+
+// NewMockDB creates a new MockDB instance
+func NewMockDB() *MockDB {
+	return &MockDB{
+		tables: make(map[any]*Table),
+	}
+}
+
+// AddTable adds a table to the test database
+func (s *MockDB) AddTable(tableModel any) *Table {
+	if tb, ok := s.tables[tableModel]; ok {
+		return tb
+	}
+
+	tb := &Table{
+		rows: make([]any, 0, 10),
+	}
+
+	s.tables[tableModel] = tb
+	return tb
+}
+
+type Table struct {
+	rows []any
+}
+
+func (t *Table) AddRows(rows ...any) *Table {
+	t.rows = append(t.rows, rows...)
+	return t
+}
+
+// DB returns the underlying gorm.DB instance
+func (s *MockDB) DB() (*gorm.DB, error) {
+	db, err := newSQLiteDB(":memory:")
+	if err != nil {
+		return nil, err
+	}
+	s.db = db
+
+	if err := s.setup(); err != nil {
+		return nil, err
+	}
+
+	return s.db, nil
+}
+
+func (s *MockDB) SharedDB(name string) (*gorm.DB, error) {
+	db, err := newSQLiteDB(fmt.Sprintf("file:%s?mode=memory&cache=shared", name))
+	if err != nil {
+		return nil, err
+	}
+	s.db = db
+
+	if err := s.setup(); err != nil {
+		return nil, err
+	}
+
+	return s.db, nil
+}
+
+// Close cleans up the test database
+func (s *MockDB) Close() error {
+	tables := make([]any, 0, len(s.tables))
+	for tb := range s.tables {
+		tables = append(tables, tb)
+	}
+	if err := s.tearDown(tables...); err != nil {
+		return fmt.Errorf("failed to tear down database: %w", err)
+	}
+	return nil
+}
+
+func (s *MockDB) setup() error {
+
+	for tableModel, tb := range s.tables {
+		// Create tables
+		if err := s.createTableFromStruct(tableModel); err != nil {
+			return fmt.Errorf("failed to create table: %w", err)
+		}
+
+		// Insert test data
+		if err := s.tearUp(tableModel, tb.rows); err != nil {
+			return fmt.Errorf("failed to insert test data: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// newSQLiteDB creates a new in-memory SQLite database for testing
+func newSQLiteDB(dsn string) (*gorm.DB, error) {
+	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Info),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect database: %w", err)
+	}
+	return db, nil
+}
+
+// createTableFromStruct creates a table in the database based on the provided struct
+func (s *MockDB) createTableFromStruct(model any) error {
+	if reflect.TypeOf(model).Kind() != reflect.Ptr {
+		return fmt.Errorf("model must be a pointer to struct")
+	}
+
+	return s.db.AutoMigrate(model)
+}
+
+// tearUp inserts test data into the database
+func (s *MockDB) tearUp(tableModel any, rows []any) error {
+	if len(rows) == 0 {
+		return nil
+	}
+
+	for _, row := range rows {
+		err := s.db.Model(tableModel).Create(row).Error
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// tearDown cleans up the test data
+func (s *MockDB) tearDown(models ...any) error {
+	for _, model := range models {
+		if err := s.db.Where("1 = 1").Delete(model).Error; err != nil {
+			return err
+		}
+
+		if err := s.db.Migrator().DropTable(model); err != nil {
+			return err
+		}
+	}
+	return nil
+}

backend/internal/mock/infra/contract/rdb/rdb_mock.go

@@ -0,0 +1,191 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: rdb.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/rdb/rdb_mock.go --package rdb -source rdb.go
+//
+
+// Package rdb is a generated GoMock package.
+package rdb
+
+import (
+	context "context"
+	reflect "reflect"
+
+	rdb "github.com/coze-dev/coze-studio/backend/infra/contract/rdb"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockRDB is a mock of RDB interface.
+type MockRDB struct {
+	ctrl     *gomock.Controller
+	recorder *MockRDBMockRecorder
+}
+
+// MockRDBMockRecorder is the mock recorder for MockRDB.
+type MockRDBMockRecorder struct {
+	mock *MockRDB
+}
+
+// NewMockRDB creates a new mock instance.
+func NewMockRDB(ctrl *gomock.Controller) *MockRDB {
+	mock := &MockRDB{ctrl: ctrl}
+	mock.recorder = &MockRDBMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRDB) EXPECT() *MockRDBMockRecorder {
+	return m.recorder
+}
+
+// AlterTable mocks base method.
+func (m *MockRDB) AlterTable(ctx context.Context, req *rdb.AlterTableRequest) (*rdb.AlterTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AlterTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.AlterTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AlterTable indicates an expected call of AlterTable.
+func (mr *MockRDBMockRecorder) AlterTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterTable", reflect.TypeOf((*MockRDB)(nil).AlterTable), ctx, req)
+}
+
+// CreateTable mocks base method.
+func (m *MockRDB) CreateTable(ctx context.Context, req *rdb.CreateTableRequest) (*rdb.CreateTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.CreateTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTable indicates an expected call of CreateTable.
+func (mr *MockRDBMockRecorder) CreateTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTable", reflect.TypeOf((*MockRDB)(nil).CreateTable), ctx, req)
+}
+
+// DeleteData mocks base method.
+func (m *MockRDB) DeleteData(ctx context.Context, req *rdb.DeleteDataRequest) (*rdb.DeleteDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteData", ctx, req)
+	ret0, _ := ret[0].(*rdb.DeleteDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteData indicates an expected call of DeleteData.
+func (mr *MockRDBMockRecorder) DeleteData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteData", reflect.TypeOf((*MockRDB)(nil).DeleteData), ctx, req)
+}
+
+// DropTable mocks base method.
+func (m *MockRDB) DropTable(ctx context.Context, req *rdb.DropTableRequest) (*rdb.DropTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DropTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.DropTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DropTable indicates an expected call of DropTable.
+func (mr *MockRDBMockRecorder) DropTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropTable", reflect.TypeOf((*MockRDB)(nil).DropTable), ctx, req)
+}
+
+// ExecuteSQL mocks base method.
+func (m *MockRDB) ExecuteSQL(ctx context.Context, req *rdb.ExecuteSQLRequest) (*rdb.ExecuteSQLResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteSQL", ctx, req)
+	ret0, _ := ret[0].(*rdb.ExecuteSQLResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteSQL indicates an expected call of ExecuteSQL.
+func (mr *MockRDBMockRecorder) ExecuteSQL(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteSQL", reflect.TypeOf((*MockRDB)(nil).ExecuteSQL), ctx, req)
+}
+
+// GetTable mocks base method.
+func (m *MockRDB) GetTable(ctx context.Context, req *rdb.GetTableRequest) (*rdb.GetTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.GetTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTable indicates an expected call of GetTable.
+func (mr *MockRDBMockRecorder) GetTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTable", reflect.TypeOf((*MockRDB)(nil).GetTable), ctx, req)
+}
+
+// InsertData mocks base method.
+func (m *MockRDB) InsertData(ctx context.Context, req *rdb.InsertDataRequest) (*rdb.InsertDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InsertData", ctx, req)
+	ret0, _ := ret[0].(*rdb.InsertDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InsertData indicates an expected call of InsertData.
+func (mr *MockRDBMockRecorder) InsertData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertData", reflect.TypeOf((*MockRDB)(nil).InsertData), ctx, req)
+}
+
+// SelectData mocks base method.
+func (m *MockRDB) SelectData(ctx context.Context, req *rdb.SelectDataRequest) (*rdb.SelectDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SelectData", ctx, req)
+	ret0, _ := ret[0].(*rdb.SelectDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SelectData indicates an expected call of SelectData.
+func (mr *MockRDBMockRecorder) SelectData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectData", reflect.TypeOf((*MockRDB)(nil).SelectData), ctx, req)
+}
+
+// UpdateData mocks base method.
+func (m *MockRDB) UpdateData(ctx context.Context, req *rdb.UpdateDataRequest) (*rdb.UpdateDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateData", ctx, req)
+	ret0, _ := ret[0].(*rdb.UpdateDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateData indicates an expected call of UpdateData.
+func (mr *MockRDBMockRecorder) UpdateData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateData", reflect.TypeOf((*MockRDB)(nil).UpdateData), ctx, req)
+}
+
+// UpsertData mocks base method.
+func (m *MockRDB) UpsertData(ctx context.Context, req *rdb.UpsertDataRequest) (*rdb.UpsertDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpsertData", ctx, req)
+	ret0, _ := ret[0].(*rdb.UpsertDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpsertData indicates an expected call of UpsertData.
+func (mr *MockRDBMockRecorder) UpsertData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertData", reflect.TypeOf((*MockRDB)(nil).UpsertData), ctx, req)
+}

backend/internal/mock/infra/contract/storage/storage_mock.go

@@ -0,0 +1,125 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: storage.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/storage/storage_mock.go -package mock -source storage.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	storage "github.com/coze-dev/coze-studio/backend/infra/contract/storage"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStorage is a mock of Storage interface.
+type MockStorage struct {
+	ctrl     *gomock.Controller
+	recorder *MockStorageMockRecorder
+	isgomock struct{}
+}
+
+// MockStorageMockRecorder is the mock recorder for MockStorage.
+type MockStorageMockRecorder struct {
+	mock *MockStorage
+}
+
+// NewMockStorage creates a new mock instance.
+func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
+	mock := &MockStorage{ctrl: ctrl}
+	mock.recorder = &MockStorageMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStorage) EXPECT() *MockStorageMockRecorder {
+	return m.recorder
+}
+
+// DeleteObject mocks base method.
+func (m *MockStorage) DeleteObject(ctx context.Context, objectKey string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteObject", ctx, objectKey)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteObject indicates an expected call of DeleteObject.
+func (mr *MockStorageMockRecorder) DeleteObject(ctx, objectKey interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockStorage)(nil).DeleteObject), ctx, objectKey)
+}
+
+// GetObject mocks base method.
+func (m *MockStorage) GetObject(ctx context.Context, objectKey string) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetObject", ctx, objectKey)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetObject indicates an expected call of GetObject.
+func (mr *MockStorageMockRecorder) GetObject(ctx, objectKey interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockStorage)(nil).GetObject), ctx, objectKey)
+}
+
+// GetObjectUrl mocks base method.
+func (m *MockStorage) GetObjectUrl(ctx context.Context, objectKey string, opts ...storage.GetOptFn) (string, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, objectKey}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetObjectUrl", varargs...)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetObjectUrl indicates an expected call of GetObjectUrl.
+func (mr *MockStorageMockRecorder) GetObjectUrl(ctx, objectKey interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, objectKey}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectUrl", reflect.TypeOf((*MockStorage)(nil).GetObjectUrl), varargs...)
+}
+
+// GetUploadAuth mocks base method.
+func (m *MockStorage) GetUploadAuth(ctx context.Context) (*storage.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUploadAuth", ctx)
+	ret0, _ := ret[0].(*storage.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuth indicates an expected call of GetUploadAuth.
+func (mr *MockStorageMockRecorder) GetUploadAuth(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuth", reflect.TypeOf((*MockStorage)(nil).GetUploadAuth), ctx)
+}
+
+// PutObject mocks base method.
+func (m *MockStorage) PutObject(ctx context.Context, objectKey string, content []byte, opts ...storage.PutOptFn) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, objectKey, content}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutObject", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PutObject indicates an expected call of PutObject.
+func (mr *MockStorageMockRecorder) PutObject(ctx, objectKey, content interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, objectKey, content}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockStorage)(nil).PutObject), varargs...)
+}