90 lines
2.8 KiB
Go
90 lines
2.8 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"git.iwork-ai.com/xdc/iqudo-top1/internal/model"
|
|
"git.iwork-ai.com/xdc/iqudo-top1/internal/sop"
|
|
"gorm.io/datatypes"
|
|
)
|
|
|
|
func TestPetDoctorSOPPassesPublishValidation(t *testing.T) {
|
|
fields := petFieldModels()
|
|
nodes := petNodeModels(petNodes())
|
|
edges := petEdgeModels(petEdges())
|
|
if len(fields) != 11 || len(nodes) != 6 || len(edges) != 5 {
|
|
t.Fatalf("unexpected definition size: fields=%d nodes=%d edges=%d", len(fields), len(nodes), len(edges))
|
|
}
|
|
problems := sop.ValidateForPublish("start", nodes, edges, sop.ValidationContext{
|
|
Fields: fields,
|
|
StageKeys: []string{"opening", "symptom", "diagnosis", "recommend"},
|
|
})
|
|
if len(problems) > 0 {
|
|
t.Fatalf("pet doctor SOP should be publishable, got: %v", problems)
|
|
}
|
|
}
|
|
|
|
func TestPetDoctorSOPIsSixStepLinearFlow(t *testing.T) {
|
|
wantNodes := []string{"start", "opening", "symptom", "diagnosis", "recommend", "finish"}
|
|
for index, node := range petNodes() {
|
|
if node.Key != wantNodes[index] {
|
|
t.Fatalf("node %d = %s, want %s", index, node.Key, wantNodes[index])
|
|
}
|
|
}
|
|
wantEdges := [][2]string{{"start", "opening"}, {"opening", "symptom"}, {"symptom", "diagnosis"}, {"diagnosis", "recommend"}, {"recommend", "finish"}}
|
|
for index, edge := range petEdges() {
|
|
if edge.Source != wantEdges[index][0] || edge.Target != wantEdges[index][1] {
|
|
t.Fatalf("edge %d = %s -> %s", index, edge.Source, edge.Target)
|
|
}
|
|
}
|
|
}
|
|
|
|
func petFieldModels() []model.ScenarioField {
|
|
definitions := petFieldDefinitions()
|
|
fields := make([]model.ScenarioField, 0, len(definitions))
|
|
for _, definition := range definitions {
|
|
options, _ := json.Marshal(definition.Options)
|
|
validation, _ := json.Marshal(definition.Validation)
|
|
fields = append(fields, model.ScenarioField{
|
|
FieldKey: definition.Key,
|
|
FieldName: definition.Name,
|
|
SourcePath: definition.SourcePath,
|
|
FieldType: definition.Type,
|
|
Required: definition.Required,
|
|
Options: datatypes.JSON(options),
|
|
Validation: datatypes.JSON(validation),
|
|
})
|
|
}
|
|
return fields
|
|
}
|
|
|
|
func petNodeModels(definitions []nodeDefinition) []model.SOPNode {
|
|
nodes := make([]model.SOPNode, 0, len(definitions))
|
|
for _, definition := range definitions {
|
|
config, _ := json.Marshal(definition.Config)
|
|
nodes = append(nodes, model.SOPNode{
|
|
NodeKey: definition.Key,
|
|
Type: definition.Type,
|
|
Title: definition.Title,
|
|
Content: definition.Content,
|
|
Config: datatypes.JSON(config),
|
|
})
|
|
}
|
|
return nodes
|
|
}
|
|
|
|
func petEdgeModels(definitions []edgeDefinition) []model.SOPEdge {
|
|
edges := make([]model.SOPEdge, 0, len(definitions))
|
|
for _, definition := range definitions {
|
|
condition, _ := json.Marshal(definition.Condition)
|
|
edges = append(edges, model.SOPEdge{
|
|
SourceNodeKey: definition.Source,
|
|
TargetNodeKey: definition.Target,
|
|
Condition: datatypes.JSON(condition),
|
|
Priority: definition.Priority,
|
|
})
|
|
}
|
|
return edges
|
|
}
|