feat: extra col

Author: Ev4nFeng

backend/modules/observability/application/convertor/task/task_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bytedance/gg/gptr"
 	"github.com/bytedance/sonic"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	kitCommon "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/domain/common"
 	"github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/domain/dataset"
@@ -219,15 +220,41 @@ func TestTaskConfigDO2DTO_EvaluationExperimentConfig(t *testing.T) {
 		EvaluationExperimentConfig: &entity.EvaluationExperimentConfig{
 			ItemConcurrencyCount: gptr.Of(int32(5)),
 			ItemMaxRetryCount:    gptr.Of(int32(6)),
+			SourceTargetID:       gptr.Of("target-123"),
+			ExptTemplateID:       gptr.Of(int64(999)),
+			SourceTargetVersion:  gptr.Of("v1.0"),
+			FullEvalSetFieldMappings: []*entity.EvaluateFieldMapping{
+				{
+					FieldSchema: &dataset.FieldSchema{
+						Key:  gptr.Of("key1"),
+						Name: gptr.Of("field1"),
+					},
+					TraceFieldKey:      "Input",
+					TraceFieldJsonpath: "$.input",
+					EvalSetName:        gptr.Of("field1"),
+				},
+			},
 		},
 	}
 	dto := TaskConfigDO2DTO(do)
 	if assert.NotNil(t, dto) {
-		if assert.NotNil(t, dto.EvaluationExperimentConfig) {
-			assert.Equal(t, int32(5), ptr.From(dto.EvaluationExperimentConfig.ItemConcurrencyCount))
-			assert.Equal(t, int32(6), ptr.From(dto.EvaluationExperimentConfig.ItemMaxRetryCount))
+		ec := dto.EvaluationExperimentConfig
+		if assert.NotNil(t, ec) {
+			assert.Equal(t, int32(5), ptr.From(ec.ItemConcurrencyCount))
+			assert.Equal(t, int32(6), ptr.From(ec.ItemMaxRetryCount))
+			assert.Equal(t, "target-123", ptr.From(ec.SourceTargetID))
+			assert.Equal(t, int64(999), ptr.From(ec.ExptTemplateID))
+			assert.Equal(t, "v1.0", ptr.From(ec.SourceTargetVersion))
+			if assert.Len(t, ec.FullEvalSetFieldMappings, 1) {
+				fm := ec.FullEvalSetFieldMappings[0]
+				assert.Equal(t, "Input", fm.TraceFieldKey)
+				assert.Equal(t, "$.input", fm.TraceFieldJsonpath)
+				assert.Equal(t, "field1", ptr.From(fm.EvalSetName))
+			}
 		}
 	}
+
+	assert.Nil(t, EvaluationExperimentConfigDO2DTO(nil))
 }
 
 func TestTaskDTO2DO(t *testing.T) {
@@ -429,3 +456,127 @@ func TestSpanFilterDTO2DO(t *testing.T) {
 		}
 	})
 }
+
+func TestSourceInfoListDTO2DO(t *testing.T) {
+	t.Parallel()
+
+	t.Run("nil input returns nil", func(t *testing.T) {
+		t.Parallel()
+		assert.Nil(t, SourceInfoListDTO2DO(nil))
+	})
+
+	t.Run("empty input returns nil", func(t *testing.T) {
+		t.Parallel()
+		assert.Nil(t, SourceInfoListDTO2DO([]*kitTask.SourceInfo{}))
+	})
+
+	t.Run("skips nil elements", func(t *testing.T) {
+		t.Parallel()
+		result := SourceInfoListDTO2DO([]*kitTask.SourceInfo{
+			nil,
+			{Name: gptr.Of("svc"), Version: gptr.Of("v1")},
+		})
+		if assert.Len(t, result, 1) {
+			assert.Equal(t, "svc", ptr.From(result[0].Name))
+			assert.Equal(t, "v1", ptr.From(result[0].Version))
+		}
+	})
+
+	t.Run("normal conversion", func(t *testing.T) {
+		t.Parallel()
+		result := SourceInfoListDTO2DO([]*kitTask.SourceInfo{
+			{Name: gptr.Of("a"), Version: gptr.Of("1.0")},
+			{Name: gptr.Of("b"), Version: gptr.Of("2.0")},
+		})
+		if assert.Len(t, result, 2) {
+			assert.Equal(t, "a", ptr.From(result[0].Name))
+			assert.Equal(t, "1.0", ptr.From(result[0].Version))
+			assert.Equal(t, "b", ptr.From(result[1].Name))
+			assert.Equal(t, "2.0", ptr.From(result[1].Version))
+		}
+	})
+}
+
+func TestTaskConfigDTO2DO_FullEvalSetAndSourceInfo(t *testing.T) {
+	t.Parallel()
+
+	schema := &dataset.FieldSchema{
+		Key:         gptr.Of("output_key"),
+		Name:        gptr.Of("Output"),
+		ContentType: gptr.Of("Text"),
+	}
+
+	dto := &kitTask.TaskConfig{
+		AutoEvaluateConfigs: []*kitTask.AutoEvaluateConfig{
+			{
+				EvaluatorVersionID: 1,
+				EvaluatorID:        2,
+				FieldMappings: []*kitTask.EvaluateFieldMapping{
+					{
+						FieldSchema:        schema,
+						TraceFieldKey:      "Input",
+						TraceFieldJsonpath: "$.input",
+						EvalSetName:        gptr.Of("input_field"),
+					},
+				},
+			},
+		},
+		EvaluationExperimentConfig: &kitTask.EvaluationExperimentConfig{
+			ItemConcurrencyCount: gptr.Of(int32(5)),
+			ItemMaxRetryCount:    gptr.Of(int32(3)),
+			ExptTemplateID:       gptr.Of(int64(888)),
+			SourceTargetID:       gptr.Of("target-1"),
+			SourceTargetVersion:  gptr.Of("v2"),
+			FullEvalSetFieldMappings: []*kitTask.EvaluateFieldMapping{
+				{
+					FieldSchema:        schema,
+					TraceFieldKey:      "Output",
+					TraceFieldJsonpath: "$.output",
+					EvalSetName:        gptr.Of("output_field"),
+				},
+				{
+					FieldSchema:        schema,
+					TraceFieldKey:      "Output",
+					TraceFieldJsonpath: "$.output",
+				},
+			},
+		},
+		SourceInfo: []*kitTask.SourceInfo{
+			{Name: gptr.Of("my-service"), Version: gptr.Of("1.0.0")},
+		},
+		IsWorkflowScheduled: gptr.Of(true),
+	}
+
+	cfg := TaskConfigDTO2DO(dto)
+	require.NotNil(t, cfg)
+
+	ec := cfg.EvaluationExperimentConfig
+	if assert.NotNil(t, ec) {
+		assert.Equal(t, int32(5), ptr.From(ec.ItemConcurrencyCount))
+		assert.Equal(t, int32(3), ptr.From(ec.ItemMaxRetryCount))
+		assert.Equal(t, int64(888), ptr.From(ec.ExptTemplateID))
+		assert.Equal(t, "target-1", ptr.From(ec.SourceTargetID))
+		assert.Equal(t, "v2", ptr.From(ec.SourceTargetVersion))
+		if assert.Len(t, ec.FullEvalSetFieldMappings, 2) {
+			assert.Equal(t, "output_field", ptr.From(ec.FullEvalSetFieldMappings[0].EvalSetName))
+			assert.Equal(t, "output", ptr.From(ec.FullEvalSetFieldMappings[0].DatasetKey))
+			assert.Equal(t, "output", ptr.From(ec.FullEvalSetFieldMappings[1].DatasetKey))
+		}
+	}
+
+	if assert.Len(t, cfg.SourceInfo, 1) {
+		assert.Equal(t, "my-service", ptr.From(cfg.SourceInfo[0].Name))
+		assert.Equal(t, "1.0.0", ptr.From(cfg.SourceInfo[0].Version))
+	}
+
+	assert.Equal(t, true, ptr.From(cfg.IsWorkflowScheduled))
+
+	if assert.Len(t, cfg.AutoEvaluateConfigs, 1) {
+		fm := cfg.AutoEvaluateConfigs[0].FieldMappings
+		if assert.Len(t, fm, 1) {
+			assert.Equal(t, "input_field", ptr.From(fm[0].EvalSetName))
+		}
+	}
+
+	assert.Nil(t, TaskConfigDTO2DO(nil))
+}