fix ut

Author: tpfz

backend/modules/evaluation/application/convertor/experiment/expt.go

@@ -90,6 +90,9 @@ func toEvaluatorConfDO(mapping []*domain_expt.EvaluatorFieldMapping, runConfigMa
 	}
 	ec := make([]*entity.EvaluatorConf, 0, len(mapping))
 	for _, fm := range mapping {
+		if fm == nil {
+			continue
+		}
 		esf := make([]*entity.FieldConf, 0, len(fm.GetFromEvalSet()))
 		for _, fes := range fm.GetFromEvalSet() {
 			esf = append(esf, &entity.FieldConf{

backend/modules/evaluation/application/convertor/experiment/expt_template.go

@@ -290,6 +290,9 @@ func toEvaluatorFieldMappingDoForTemplate(mapping []*domain_expt.EvaluatorFieldM
 	result := make([]*entity.EvaluatorConf, 0, len(mapping))
 
 	for _, fm := range mapping {
+		if fm == nil {
+			continue
+		}
 		esf := make([]*entity.FieldConf, 0, len(fm.GetFromEvalSet()))
 		for _, fes := range fm.GetFromEvalSet() {
 			esf = append(esf, &entity.FieldConf{

backend/modules/evaluation/application/convertor/experiment/expt_test.go

@@ -2105,3 +2105,299 @@ func TestCreateEvalTargetParamDTO2DOForTemplate(t *testing.T) {
 		assert.Nil(t, result.BotInfoType)
 	})
 }
+
+func TestEvalConfConvert_ConvertToEntity_SetScoreWeight(t *testing.T) {
+	converter := &EvalConfConvert{}
+	scoreWeight1 := 0.6
+	scoreWeight2 := 0.4
+
+	t.Run("设置ScoreWeight到EvaluatorConf", func(t *testing.T) {
+		cer := &expt.CreateExperimentRequest{
+			EvaluatorFieldMapping: []*domain_expt.EvaluatorFieldMapping{
+				domain_expt.NewEvaluatorFieldMapping(),
+				domain_expt.NewEvaluatorFieldMapping(),
+			},
+		}
+		cer.EvaluatorFieldMapping[0].SetEvaluatorVersionID(101)
+		cer.EvaluatorFieldMapping[1].SetEvaluatorVersionID(102)
+		cer.EvaluatorScoreWeights = map[int64]float64{
+			101: scoreWeight1,
+			102: scoreWeight2,
+		}
+
+		result, err := converter.ConvertToEntity(cer, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+		assert.NotNil(t, result.ConnectorConf.EvaluatorsConf)
+		assert.Len(t, result.ConnectorConf.EvaluatorsConf.EvaluatorConf, 2)
+
+		// 验证 ScoreWeight 被正确设置
+		for _, conf := range result.ConnectorConf.EvaluatorsConf.EvaluatorConf {
+			if conf.EvaluatorVersionID == 101 {
+				assert.NotNil(t, conf.ScoreWeight)
+				assert.Equal(t, scoreWeight1, *conf.ScoreWeight)
+			} else if conf.EvaluatorVersionID == 102 {
+				assert.NotNil(t, conf.ScoreWeight)
+				assert.Equal(t, scoreWeight2, *conf.ScoreWeight)
+			}
+		}
+	})
+
+	t.Run("权重为0或负数，不设置ScoreWeight", func(t *testing.T) {
+		cer := &expt.CreateExperimentRequest{
+			EvaluatorFieldMapping: []*domain_expt.EvaluatorFieldMapping{
+				domain_expt.NewEvaluatorFieldMapping(),
+			},
+		}
+		cer.EvaluatorFieldMapping[0].SetEvaluatorVersionID(101)
+		cer.EvaluatorScoreWeights = map[int64]float64{
+			101: 0.0, // 权重为0，不应该设置
+		}
+
+		result, err := converter.ConvertToEntity(cer, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+		if result.ConnectorConf.EvaluatorsConf != nil && len(result.ConnectorConf.EvaluatorsConf.EvaluatorConf) > 0 {
+			conf := result.ConnectorConf.EvaluatorsConf.EvaluatorConf[0]
+			// 权重为0，不应该设置 ScoreWeight
+			assert.Nil(t, conf.ScoreWeight)
+		}
+	})
+
+	t.Run("EvaluatorConf为nil，跳过", func(t *testing.T) {
+		cer := &expt.CreateExperimentRequest{
+			EvaluatorFieldMapping: []*domain_expt.EvaluatorFieldMapping{
+				nil, // nil项，应该跳过
+			},
+			EvaluatorScoreWeights: map[int64]float64{
+				101: scoreWeight1,
+			},
+		}
+
+		result, err := converter.ConvertToEntity(cer, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, result)
+		// nil项应该被跳过，不会导致panic
+	})
+}
+
+func TestToExptDTO_BuildEvaluatorIDVersionItemsFromVersionRef(t *testing.T) {
+	t.Run("从EvaluatorVersionRef构建EvaluatorIDVersionItems", func(t *testing.T) {
+		scoreWeight := 0.7
+		experiment := &entity.Experiment{
+			// 没有 Evaluators，使用 EvaluatorVersionRef
+			EvaluatorVersionRef: []*entity.ExptEvaluatorVersionRef{
+				{
+					EvaluatorID:        1,
+					EvaluatorVersionID: 101,
+				},
+				{
+					EvaluatorID:        2,
+					EvaluatorVersionID: 102,
+				},
+				{
+					EvaluatorID:        0, // 无效，应该跳过
+					EvaluatorVersionID: 103,
+				},
+				{
+					EvaluatorID:        3,
+					EvaluatorVersionID: 0, // 无效，应该跳过
+				},
+			},
+			EvalConf: &entity.EvaluationConfiguration{
+				ConnectorConf: entity.Connector{
+					EvaluatorsConf: &entity.EvaluatorsConf{
+						EvaluatorConf: []*entity.EvaluatorConf{
+							{
+								EvaluatorVersionID: 101,
+								ScoreWeight:        &scoreWeight,
+							},
+						},
+					},
+				},
+			},
+		}
+
+		result := ToExptDTO(experiment)
+		assert.NotNil(t, result)
+		// 验证权重配置被正确填充到 ScoreWeightConfig
+		if result.ScoreWeightConfig != nil {
+			assert.Equal(t, scoreWeight, result.ScoreWeightConfig.EvaluatorScoreWeights[101])
+		}
+		// 验证 EvaluatorIDVersionList 被构建（从 evaluatorVersionIDs 构建）
+		assert.NotNil(t, result.EvaluatorIDVersionList)
+	})
+
+	t.Run("优先使用Evaluators，不使用EvaluatorVersionRef", func(t *testing.T) {
+		experiment := &entity.Experiment{
+			Evaluators: []*entity.Evaluator{
+				{
+					ID: 1,
+					PromptEvaluatorVersion: &entity.PromptEvaluatorVersion{
+						EvaluatorID: 1,
+						ID:          101,
+					},
+					EvaluatorType: entity.EvaluatorTypePrompt,
+				},
+			},
+			EvaluatorVersionRef: []*entity.ExptEvaluatorVersionRef{
+				{
+					EvaluatorID:        2,
+					EvaluatorVersionID: 102,
+				},
+			},
+		}
+
+		result := ToExptDTO(experiment)
+		assert.NotNil(t, result)
+		// 应该优先使用 Evaluators 的信息构建 EvaluatorIDVersionList
+		assert.NotNil(t, result.EvaluatorIDVersionList)
+	})
+}
+
+func TestToExptDTO_FillExptTemplateMeta(t *testing.T) {
+	t.Run("填充ExptTemplateMeta", func(t *testing.T) {
+		experiment := &entity.Experiment{
+			ExptTemplateMeta: &entity.ExptTemplateMeta{
+				ID:          100,
+				WorkspaceID: 200,
+				Name:        "template_name",
+				Desc:        "template_desc",
+				ExptType:    entity.ExptType_Offline,
+			},
+		}
+
+		result := ToExptDTO(experiment)
+		assert.NotNil(t, result)
+		assert.NotNil(t, result.ExptTemplateMeta)
+		assert.Equal(t, int64(100), gptr.Indirect(result.ExptTemplateMeta.ID))
+		assert.Equal(t, int64(200), gptr.Indirect(result.ExptTemplateMeta.WorkspaceID))
+		assert.Equal(t, "template_name", gptr.Indirect(result.ExptTemplateMeta.Name))
+		assert.Equal(t, "template_desc", gptr.Indirect(result.ExptTemplateMeta.Desc))
+		assert.Equal(t, domain_expt.ExptType_Offline, gptr.Indirect(result.ExptTemplateMeta.ExptType))
+	})
+
+	t.Run("ExptTemplateMeta为nil，不填充", func(t *testing.T) {
+		experiment := &entity.Experiment{
+			ExptTemplateMeta: nil,
+		}
+
+		result := ToExptDTO(experiment)
+		assert.NotNil(t, result)
+		assert.Nil(t, result.ExptTemplateMeta)
+	})
+}
+
+func TestToTargetFieldMappingDOForTemplate_RuntimeParam(t *testing.T) {
+	t.Run("设置RuntimeParam到CustomConf", func(t *testing.T) {
+		rtp := &entity.RuntimeParam{
+			JSONValue: gptr.Of(`{"key":"value"}`),
+		}
+		mapping := &domain_expt.TargetFieldMapping{
+			FromEvalSet: []*domain_expt.FieldMapping{
+				{
+					FieldName:     gptr.Of("field1"),
+					FromFieldName: gptr.Of("from1"),
+				},
+			},
+		}
+
+		result := toTargetFieldMappingDOForTemplate(mapping, rtp)
+		assert.NotNil(t, result)
+		assert.NotNil(t, result.CustomConf)
+		assert.Len(t, result.CustomConf.FieldConfs, 1)
+		assert.Equal(t, consts.FieldAdapterBuiltinFieldNameRuntimeParam, result.CustomConf.FieldConfs[0].FieldName)
+		assert.Equal(t, `{"key":"value"}`, result.CustomConf.FieldConfs[0].Value)
+	})
+
+	t.Run("RuntimeParam为nil，不设置CustomConf", func(t *testing.T) {
+		mapping := &domain_expt.TargetFieldMapping{
+			FromEvalSet: []*domain_expt.FieldMapping{
+				{
+					FieldName:     gptr.Of("field1"),
+					FromFieldName: gptr.Of("from1"),
+				},
+			},
+		}
+
+		result := toTargetFieldMappingDOForTemplate(mapping, nil)
+		assert.NotNil(t, result)
+		assert.Nil(t, result.CustomConf)
+	})
+
+	t.Run("RuntimeParam.JSONValue为空，不设置CustomConf", func(t *testing.T) {
+		rtp := &entity.RuntimeParam{
+			JSONValue: nil,
+		}
+		mapping := &domain_expt.TargetFieldMapping{}
+
+		result := toTargetFieldMappingDOForTemplate(mapping, rtp)
+		assert.NotNil(t, result)
+		assert.Nil(t, result.CustomConf)
+	})
+
+	t.Run("RuntimeParam.JSONValue为空字符串，不设置CustomConf", func(t *testing.T) {
+		rtp := &entity.RuntimeParam{
+			JSONValue: gptr.Of(""),
+		}
+		mapping := &domain_expt.TargetFieldMapping{}
+
+		result := toTargetFieldMappingDOForTemplate(mapping, rtp)
+		assert.NotNil(t, result)
+		assert.Nil(t, result.CustomConf)
+	})
+}
+
+func TestToEvaluatorFieldMappingDoForTemplate_Complete(t *testing.T) {
+	t.Run("完整转换评估器字段映射", func(t *testing.T) {
+		mapping := []*domain_expt.EvaluatorFieldMapping{
+			domain_expt.NewEvaluatorFieldMapping(),
+		}
+		mapping[0].SetEvaluatorVersionID(101)
+		mapping[0].SetFromEvalSet([]*domain_expt.FieldMapping{
+			{
+				FieldName:     gptr.Of("input"),
+				FromFieldName: gptr.Of("col1"),
+				ConstValue:    gptr.Of(""),
+			},
+		})
+		mapping[0].SetFromTarget([]*domain_expt.FieldMapping{
+			{
+				FieldName:     gptr.Of("output"),
+				FromFieldName: gptr.Of("col2"),
+			},
+		})
+		mapping[0].SetEvaluatorIDVersionItem(&evaluatordto.EvaluatorIDVersionItem{
+			EvaluatorID:        gptr.Of(int64(1)),
+			Version:            gptr.Of("v1"),
+			EvaluatorVersionID: gptr.Of(int64(101)),
+		})
+
+		result := toEvaluatorFieldMappingDoForTemplate(mapping, nil)
+		assert.NotNil(t, result)
+		assert.Len(t, result, 1)
+		conf := result[0]
+		assert.Equal(t, int64(101), conf.EvaluatorVersionID)
+		assert.Equal(t, int64(1), conf.EvaluatorID)
+		assert.Equal(t, "v1", conf.Version)
+		assert.Len(t, conf.IngressConf.EvalSetAdapter.FieldConfs, 1)
+		assert.Len(t, conf.IngressConf.TargetAdapter.FieldConfs, 1)
+	})
+
+	t.Run("mapping为nil，返回nil", func(t *testing.T) {
+		result := toEvaluatorFieldMappingDoForTemplate(nil, nil)
+		assert.Nil(t, result)
+	})
+
+	t.Run("mapping包含nil项，跳过", func(t *testing.T) {
+		mapping := []*domain_expt.EvaluatorFieldMapping{
+			nil,
+			domain_expt.NewEvaluatorFieldMapping(),
+		}
+		mapping[1].SetEvaluatorVersionID(101)
+
+		result := toEvaluatorFieldMappingDoForTemplate(mapping, nil)
+		assert.NotNil(t, result)
+		assert.Len(t, result, 1)
+	})
+}