what
a6d3e34e53
新增 fieldx 包,提供基于预定义 Schema 生成 map[string]any 对象的功能。 主要特性: - 支持固定值字段 (string)、字段引用 (field) 和嵌套对象 (object) - 支持点号分隔的嵌套路径访问 (如 "user.name") - 提供多种 Schema 创建方式 (JSON、Map、编程方式) - 完善的错误处理和文档示例
500 lines
11 KiB
Go
500 lines
11 KiB
Go
package fieldx
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
)
|
|
|
|
// TestSchemaFromJSON_Simple 测试从 JSON 创建简单 Schema
|
|
func TestSchemaFromJSON_Simple(t *testing.T) {
|
|
jsonStr := `{
|
|
"name": {
|
|
"type": "field",
|
|
"value": "userName"
|
|
},
|
|
"status": {
|
|
"type": "string",
|
|
"value": "active"
|
|
}
|
|
}`
|
|
|
|
schema, err := SchemaFromJSON(jsonStr)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromJSON() error = %v", err)
|
|
}
|
|
|
|
if schema["name"].Type != FieldTypeField {
|
|
t.Errorf("name.Type = %v, want %v", schema["name"].Type, FieldTypeField)
|
|
}
|
|
|
|
if schema["status"].Type != FieldTypeString {
|
|
t.Errorf("status.Type = %v, want %v", schema["status"].Type, FieldTypeString)
|
|
}
|
|
|
|
// 测试生成
|
|
source := map[string]any{
|
|
"userName": "Alice",
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["name"] != "Alice" {
|
|
t.Errorf("result[name] = %v, want Alice", result["name"])
|
|
}
|
|
|
|
if result["status"] != "active" {
|
|
t.Errorf("result[status] = %v, want active", result["status"])
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromJSON_Nested 测试嵌套对象
|
|
func TestSchemaFromJSON_Nested(t *testing.T) {
|
|
jsonStr := `{
|
|
"type": {
|
|
"type": "string",
|
|
"value": "user_profile"
|
|
},
|
|
"user": {
|
|
"type": "object",
|
|
"fields": {
|
|
"id": {
|
|
"type": "field",
|
|
"value": "userId"
|
|
},
|
|
"name": {
|
|
"type": "field",
|
|
"value": "userName"
|
|
}
|
|
}
|
|
}
|
|
}`
|
|
|
|
schema, err := SchemaFromJSON(jsonStr)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromJSON() error = %v", err)
|
|
}
|
|
|
|
if schema["user"].Type != FieldTypeObject {
|
|
t.Errorf("user.Type = %v, want %v", schema["user"].Type, FieldTypeObject)
|
|
}
|
|
|
|
// 测试生成
|
|
source := map[string]any{
|
|
"userId": 123,
|
|
"userName": "Alice",
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["type"] != "user_profile" {
|
|
t.Errorf("type = %v, want user_profile", result["type"])
|
|
}
|
|
|
|
user := result["user"].(map[string]any)
|
|
if user["id"] != 123 {
|
|
t.Errorf("user.id = %v, want 123", user["id"])
|
|
}
|
|
|
|
if user["name"] != "Alice" {
|
|
t.Errorf("user.name = %v, want Alice", user["name"])
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromJSON_NestedPath 测试嵌套路径访问
|
|
func TestSchemaFromJSON_NestedPath(t *testing.T) {
|
|
jsonStr := `{
|
|
"userId": {
|
|
"type": "field",
|
|
"value": "user.id"
|
|
},
|
|
"userEmail": {
|
|
"type": "field",
|
|
"value": "user.contact.email"
|
|
}
|
|
}`
|
|
|
|
schema, err := SchemaFromJSON(jsonStr)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromJSON() error = %v", err)
|
|
}
|
|
|
|
// 测试嵌套源数据
|
|
source := map[string]any{
|
|
"user": map[string]any{
|
|
"id": 456,
|
|
"contact": map[string]any{
|
|
"email": "alice@example.com",
|
|
},
|
|
},
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["userId"] != 456 {
|
|
t.Errorf("userId = %v, want 456", result["userId"])
|
|
}
|
|
|
|
if result["userEmail"] != "alice@example.com" {
|
|
t.Errorf("userEmail = %v, want alice@example.com", result["userEmail"])
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromJSON_ComplexNested 测试复杂嵌套结构
|
|
func TestSchemaFromJSON_ComplexNested(t *testing.T) {
|
|
jsonStr := `{
|
|
"type": {
|
|
"type": "string",
|
|
"value": "user_profile"
|
|
},
|
|
"user": {
|
|
"type": "object",
|
|
"fields": {
|
|
"id": {
|
|
"type": "field",
|
|
"value": "userId"
|
|
},
|
|
"contact": {
|
|
"type": "object",
|
|
"fields": {
|
|
"email": {
|
|
"type": "field",
|
|
"value": "email"
|
|
},
|
|
"phone": {
|
|
"type": "string",
|
|
"value": "N/A"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}`
|
|
|
|
schema, err := SchemaFromJSON(jsonStr)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromJSON() error = %v", err)
|
|
}
|
|
|
|
source := map[string]any{
|
|
"userId": 123,
|
|
"email": "test@example.com",
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["type"] != "user_profile" {
|
|
t.Errorf("type = %v, want user_profile", result["type"])
|
|
}
|
|
|
|
user := result["user"].(map[string]any)
|
|
if user["id"] != 123 {
|
|
t.Errorf("user.id = %v, want 123", user["id"])
|
|
}
|
|
|
|
contact := user["contact"].(map[string]any)
|
|
if contact["email"] != "test@example.com" {
|
|
t.Errorf("contact.email = %v, want test@example.com", contact["email"])
|
|
}
|
|
|
|
if contact["phone"] != "N/A" {
|
|
t.Errorf("contact.phone = %v, want N/A", contact["phone"])
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromJSON_InvalidJSON 测试无效 JSON
|
|
func TestSchemaFromJSON_InvalidJSON(t *testing.T) {
|
|
jsonStr := `{invalid json}`
|
|
|
|
_, err := SchemaFromJSON(jsonStr)
|
|
if err == nil {
|
|
t.Error("SchemaFromJSON() expected error for invalid JSON, got nil")
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromJSON_EmptyJSON 测试空 JSON
|
|
func TestSchemaFromJSON_EmptyJSON(t *testing.T) {
|
|
jsonStr := `{}`
|
|
|
|
schema, err := SchemaFromJSON(jsonStr)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromJSON() error = %v", err)
|
|
}
|
|
|
|
if len(schema) != 0 {
|
|
t.Errorf("schema length = %v, want 0", len(schema))
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromMap_StringType 测试从 Map 创建字符串类型
|
|
func TestSchemaFromMap_StringType(t *testing.T) {
|
|
data := map[string]any{
|
|
"status": map[string]any{
|
|
"type": "string",
|
|
"value": "active",
|
|
},
|
|
}
|
|
|
|
schema, err := SchemaFromMap(data)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromMap() error = %v", err)
|
|
}
|
|
|
|
if schema["status"].Type != FieldTypeString {
|
|
t.Errorf("status.Type = %v, want %v", schema["status"].Type, FieldTypeString)
|
|
}
|
|
|
|
if schema["status"].Value != "active" {
|
|
t.Errorf("status.Value = %v, want active", schema["status"].Value)
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromMap_FieldType 测试从 Map 创建字段类型
|
|
func TestSchemaFromMap_FieldType(t *testing.T) {
|
|
data := map[string]any{
|
|
"name": map[string]any{
|
|
"type": "field",
|
|
"value": "userName",
|
|
},
|
|
}
|
|
|
|
schema, err := SchemaFromMap(data)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromMap() error = %v", err)
|
|
}
|
|
|
|
if schema["name"].Type != FieldTypeField {
|
|
t.Errorf("name.Type = %v, want %v", schema["name"].Type, FieldTypeField)
|
|
}
|
|
|
|
if schema["name"].Value != "userName" {
|
|
t.Errorf("name.Value = %v, want userName", schema["name"].Value)
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromMap_ObjectType 测试从 Map 创建对象类型
|
|
func TestSchemaFromMap_ObjectType(t *testing.T) {
|
|
data := map[string]any{
|
|
"user": map[string]any{
|
|
"type": "object",
|
|
"fields": map[string]any{
|
|
"id": map[string]any{
|
|
"type": "field",
|
|
"value": "userId",
|
|
},
|
|
"name": map[string]any{
|
|
"type": "string",
|
|
"value": "default_name",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
schema, err := SchemaFromMap(data)
|
|
if err != nil {
|
|
t.Fatalf("SchemaFromMap() error = %v", err)
|
|
}
|
|
|
|
if schema["user"].Type != FieldTypeObject {
|
|
t.Errorf("user.Type = %v, want %v", schema["user"].Type, FieldTypeObject)
|
|
}
|
|
|
|
if schema["user"].Fields["id"].Type != FieldTypeField {
|
|
t.Errorf("user.fields.id.Type = %v, want %v", schema["user"].Fields["id"].Type, FieldTypeField)
|
|
}
|
|
|
|
if schema["user"].Fields["name"].Value != "default_name" {
|
|
t.Errorf("user.fields.name.Value = %v, want default_name", schema["user"].Fields["name"].Value)
|
|
}
|
|
}
|
|
|
|
// TestSchemaFromMap_InvalidData 测试无效数据
|
|
func TestSchemaFromMap_InvalidData(t *testing.T) {
|
|
data := map[string]any{
|
|
"field1": "invalid",
|
|
}
|
|
|
|
_, err := SchemaFromMap(data)
|
|
if err == nil {
|
|
t.Error("SchemaFromMap() expected error for invalid data, got nil")
|
|
}
|
|
}
|
|
|
|
// TestSchema_Unmarshal 测试直接使用 json.Unmarshal
|
|
func TestSchema_Unmarshal(t *testing.T) {
|
|
jsonStr := `{
|
|
"name": {
|
|
"type": "field",
|
|
"value": "userName"
|
|
},
|
|
"status": {
|
|
"type": "string",
|
|
"value": "active"
|
|
}
|
|
}`
|
|
|
|
var schema Schema
|
|
err := json.Unmarshal([]byte(jsonStr), &schema)
|
|
if err != nil {
|
|
t.Fatalf("json.Unmarshal() error = %v", err)
|
|
}
|
|
|
|
if schema["name"].Type != FieldTypeField {
|
|
t.Errorf("name.Type = %v, want %v", schema["name"].Type, FieldTypeField)
|
|
}
|
|
|
|
// 测试生成
|
|
source := map[string]any{
|
|
"userName": "Alice",
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["name"] != "Alice" {
|
|
t.Errorf("result[name] = %v, want Alice", result["name"])
|
|
}
|
|
}
|
|
|
|
// TestSchema_UnmarshalInStruct 测试在结构体中使用 Schema
|
|
func TestSchema_UnmarshalInStruct(t *testing.T) {
|
|
type Config struct {
|
|
Name string `json:"name"`
|
|
Schema Schema `json:"schema"`
|
|
}
|
|
|
|
jsonStr := `{
|
|
"name": "test_config",
|
|
"schema": {
|
|
"userId": {
|
|
"type": "field",
|
|
"value": "user.id"
|
|
},
|
|
"userName": {
|
|
"type": "field",
|
|
"value": "user.name"
|
|
}
|
|
}
|
|
}`
|
|
|
|
var config Config
|
|
err := json.Unmarshal([]byte(jsonStr), &config)
|
|
if err != nil {
|
|
t.Fatalf("json.Unmarshal() error = %v", err)
|
|
}
|
|
|
|
if config.Name != "test_config" {
|
|
t.Errorf("config.Name = %v, want test_config", config.Name)
|
|
}
|
|
|
|
if config.Schema["userId"].Type != FieldTypeField {
|
|
t.Errorf("userId.Type = %v, want %v", config.Schema["userId"].Type, FieldTypeField)
|
|
}
|
|
|
|
// 测试生成
|
|
source := map[string]any{
|
|
"user": map[string]any{
|
|
"id": 123,
|
|
"name": "Alice",
|
|
},
|
|
}
|
|
|
|
result, err := config.Schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["userId"] != 123 {
|
|
t.Errorf("userId = %v, want 123", result["userId"])
|
|
}
|
|
|
|
if result["userName"] != "Alice" {
|
|
t.Errorf("userName = %v, want Alice", result["userName"])
|
|
}
|
|
}
|
|
|
|
// TestSchema_Generate_FieldNotFound 测试字段不存在的情况
|
|
func TestSchema_Generate_FieldNotFound(t *testing.T) {
|
|
schema := Schema{
|
|
"name": Field{
|
|
Type: FieldTypeField,
|
|
Value: "nonExistentField",
|
|
},
|
|
}
|
|
|
|
source := map[string]any{
|
|
"otherField": "value",
|
|
}
|
|
|
|
_, err := schema.Generate(source)
|
|
if err == nil {
|
|
t.Error("Generate() expected error for non-existent field, got nil")
|
|
}
|
|
}
|
|
|
|
// TestSchema_Generate_AllTypes 测试所有字段类型组合
|
|
func TestSchema_Generate_AllTypes(t *testing.T) {
|
|
schema := Schema{
|
|
"fixedValue": Field{
|
|
Type: FieldTypeString,
|
|
Value: "constant",
|
|
},
|
|
"dynamicValue": Field{
|
|
Type: FieldTypeField,
|
|
Value: "inputValue",
|
|
},
|
|
"nestedObject": Field{
|
|
Type: FieldTypeObject,
|
|
Fields: Schema{
|
|
"innerFixed": Field{
|
|
Type: FieldTypeString,
|
|
Value: "inner_constant",
|
|
},
|
|
"innerDynamic": Field{
|
|
Type: FieldTypeField,
|
|
Value: "inputValue",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
source := map[string]any{
|
|
"inputValue": "test_value",
|
|
}
|
|
|
|
result, err := schema.Generate(source)
|
|
if err != nil {
|
|
t.Fatalf("Generate() error = %v", err)
|
|
}
|
|
|
|
if result["fixedValue"] != "constant" {
|
|
t.Errorf("fixedValue = %v, want constant", result["fixedValue"])
|
|
}
|
|
|
|
if result["dynamicValue"] != "test_value" {
|
|
t.Errorf("dynamicValue = %v, want test_value", result["dynamicValue"])
|
|
}
|
|
|
|
nested := result["nestedObject"].(map[string]any)
|
|
if nested["innerFixed"] != "inner_constant" {
|
|
t.Errorf("innerFixed = %v, want inner_constant", nested["innerFixed"])
|
|
}
|
|
|
|
if nested["innerDynamic"] != "test_value" {
|
|
t.Errorf("innerDynamic = %v, want test_value", nested["innerDynamic"])
|
|
}
|
|
}
|