baize/test/assign_tag_test.go

package test

import (
	"git.sxidc.com/go-framework/baize/framework/core/tag/assign"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
	"math/rand"
	"strings"
	"testing"
	"time"
)

type AssignTagFrom struct {
	StringField                  string              `assign:"toField:StringField"`
	BoolField                    bool                `assign:"toField:BoolField"`
	IntField                     int                 `assign:"toField:IntField"`
	Int8Field                    int8                `assign:"toField:Int8Field"`
	Int16Field                   int16               `assign:"toField:Int16Field"`
	Int32Field                   int32               `assign:"toField:Int32Field"`
	Int64Field                   int64               `assign:"toField:Int64Field"`
	UintField                    uint                `assign:"toField:UintField"`
	Uint8Field                   uint8               `assign:"toField:Uint8Field"`
	Uint16Field                  uint16              `assign:"toField:Uint16Field"`
	Uint32Field                  uint32              `assign:"toField:Uint32Field"`
	Uint64Field                  uint64              `assign:"toField:Uint64Field"`
	Float32Field                 float32             `assign:"toField:Float32Field"`
	Float64Field                 float64             `assign:"toField:Float64Field"`
	SliceField                   []string            `assign:"toField:SliceField"`
	MapField                     map[string]string   `assign:"toField:MapField"`
	ChanField                    chan any            `assign:"toField:ChanField"`
	FuncField                    func() string       `assign:"toField:FuncField"`
	StructField                  struct{ ID string } `assign:"toField:StructField"`
	FromStringSliceToStringField []string            `assign:"toField:FromStringSliceToStringField"`
	FromTimeToStringField        time.Time           `assign:"toField:FromTimeToStringField"`
	FromTimeToTimeField          time.Time           `assign:"toField:FromTimeToTimeField"`
	FromStringToTimeField        string              `assign:"toField:FromStringToTimeField"`
}

type AssignTagFromPointerField struct {
	StringField                  *string              `assign:"toField:StringField"`
	BoolField                    *bool                `assign:"toField:BoolField"`
	IntField                     *int                 `assign:"toField:IntField"`
	Int8Field                    *int8                `assign:"toField:Int8Field"`
	Int16Field                   *int16               `assign:"toField:Int16Field"`
	Int32Field                   *int32               `assign:"toField:Int32Field"`
	Int64Field                   *int64               `assign:"toField:Int64Field"`
	UintField                    *uint                `assign:"toField:UintField"`
	Uint8Field                   *uint8               `assign:"toField:Uint8Field"`
	Uint16Field                  *uint16              `assign:"toField:Uint16Field"`
	Uint32Field                  *uint32              `assign:"toField:Uint32Field"`
	Uint64Field                  *uint64              `assign:"toField:Uint64Field"`
	Float32Field                 *float32             `assign:"toField:Float32Field"`
	Float64Field                 *float64             `assign:"toField:Float64Field"`
	SliceField                   *[]string            `assign:"toField:SliceField"`
	MapField                     *map[string]string   `assign:"toField:MapField"`
	ChanField                    *chan any            `assign:"toField:ChanField"`
	FuncField                    *func() string       `assign:"toField:FuncField"`
	StructField                  *struct{ ID string } `assign:"toField:StructField"`
	FromStringSliceToStringField *[]string            `assign:"toField:FromStringSliceToStringField"`
	FromTimeToStringField        *time.Time           `assign:"toField:FromTimeToStringField"`
	FromTimeToTimeField          *time.Time           `assign:"toField:FromTimeToTimeField"`
	FromStringToTimeField        *string              `assign:"toField:FromStringToTimeField"`
}

type AssignTagTo struct {
	StringField                  string
	BoolField                    bool
	IntField                     int
	Int8Field                    int8
	Int16Field                   int16
	Int32Field                   int32
	Int64Field                   int64
	UintField                    uint
	Uint8Field                   uint8
	Uint16Field                  uint16
	Uint32Field                  uint32
	Uint64Field                  uint64
	Float32Field                 float32
	Float64Field                 float64
	SliceField                   []string
	MapField                     map[string]string
	ChanField                    chan any
	FuncField                    func() string
	StructField                  struct{ ID string }
	FromStringSliceToStringField string
	FromTimeToStringField        string
	FromTimeToTimeField          time.Time
	FromStringToTimeField        time.Time
}

func (to AssignTagTo) checkFields(t *testing.T, from AssignTagFrom) {
	if from.StringField != to.StringField {
		t.Fatalf("%+v\n", errors.Errorf("StringField not equal: from %v, to %v",
			from.StringField, to.StringField))
	}

	if from.BoolField != to.BoolField {
		t.Fatalf("%+v\n", errors.Errorf("BoolField not equal: from %v, to %v",
			from.BoolField, to.BoolField))
	}

	if from.IntField != to.IntField {
		t.Fatalf("%+v\n", errors.Errorf("IntField not equal: from %v, to %v",
			from.IntField, to.IntField))
	}

	if from.Int8Field != to.Int8Field {
		t.Fatalf("%+v\n", errors.Errorf("Int8Field not equal: from %v, to %v",
			from.Int8Field, to.Int8Field))
	}

	if from.Int16Field != to.Int16Field {
		t.Fatalf("%+v\n", errors.Errorf("Int16Field not equal: from %v, to %v",
			from.Int16Field, to.Int16Field))
	}

	if from.Int32Field != to.Int32Field {
		t.Fatalf("%+v\n", errors.Errorf("Int32Field not equal: from %v, to %v",
			from.Int32Field, to.Int32Field))
	}

	if from.Int64Field != to.Int64Field {
		t.Fatalf("%+v\n", errors.Errorf("Int64Field not equal: from %v, to %v",
			from.Int64Field, to.Int64Field))
	}

	if from.UintField != to.UintField {
		t.Fatalf("%+v\n", errors.Errorf("UintField not equal: from %v, to %v",
			from.UintField, to.UintField))
	}

	if from.Uint8Field != to.Uint8Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint8Field not equal: from %v, to %v",
			from.Uint8Field, to.Uint8Field))
	}

	if from.Uint16Field != to.Uint16Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint16Field not equal: from %v, to %v",
			from.Uint16Field, to.Uint16Field))
	}

	if from.Uint32Field != to.Uint32Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint32Field not equal: from %v, to %v",
			from.Uint32Field, to.Uint32Field))
	}

	if from.Uint64Field != to.Uint64Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint64Field not equal: from %v, to %v",
			from.Uint64Field, to.Uint64Field))
	}

	if from.Float32Field != to.Float32Field {
		t.Fatalf("%+v\n", errors.Errorf("Float32Field not equal: from %v, to %v",
			from.Float32Field, to.Float32Field))
	}

	if from.Float64Field != to.Float64Field {
		t.Fatalf("%+v\n", errors.Errorf("Float64Field not equal: from %v, to %v",
			from.Float64Field, to.Float64Field))
	}

	for i, value := range from.SliceField {
		if value != to.SliceField[i] {
			t.Fatalf("%+v\n", errors.Errorf("SliceField not equal: from %v, to %v",
				value, to.SliceField[i]))
		}
	}

	for key, value := range from.MapField {
		if value != to.MapField[key] {
			t.Fatalf("%+v\n", errors.Errorf("MapField not equal: from %v, to %v",
				value, to.MapField[key]))
		}
	}

	if from.ChanField != to.ChanField {
		t.Fatalf("%+v\n", errors.Errorf("ChanField not equal: from %v, to %v",
			from.ChanField, to.ChanField))
	}

	if from.FuncField() != to.FuncField() {
		t.Fatalf("%+v\n", errors.Errorf("FuncField not equal: from %v, to %v",
			from.FuncField(), to.FuncField()))
	}

	if from.StructField.ID != to.StructField.ID {
		t.Fatalf("%+v\n", errors.Errorf("StructField not equal: from %v, to %v",
			from.StructField.ID, to.StructField.ID))
	}

	if strings.Join(from.FromStringSliceToStringField, "::") != to.FromStringSliceToStringField {
		t.Fatalf("%+v\n", errors.Errorf("FromStringSliceToStringField not equal: from %v, to %v",
			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField))
	}

	if from.FromTimeToStringField.Format(time.DateTime) != to.FromTimeToStringField {
		t.Fatalf("%+v\n", errors.Errorf("FromTimeToStringField not equal: from %v, to %v",
			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField))
	}

	if from.FromTimeToTimeField.Format(time.DateTime) != to.FromTimeToTimeField.Format(time.DateTime) {
		t.Fatalf("%+v\n", errors.Errorf("FromTimeToTimeField not equal: from %v, to %v",
			from.FromTimeToTimeField.Format(time.DateTime), to.FromTimeToTimeField.Format(time.DateTime)))
	}

	if from.FromStringToTimeField != to.FromStringToTimeField.Format(time.DateTime) {
		t.Fatalf("%+v\n", errors.Errorf("FromStringToTimeField not equal: from %v, to %v",
			from.FromStringToTimeField, to.FromStringToTimeField.Format(time.DateTime)))
	}
}

type AssignTagToPointerField struct {
	StringField                  *string
	BoolField                    *bool
	IntField                     *int
	Int8Field                    *int8
	Int16Field                   *int16
	Int32Field                   *int32
	Int64Field                   *int64
	UintField                    *uint
	Uint8Field                   *uint8
	Uint16Field                  *uint16
	Uint32Field                  *uint32
	Uint64Field                  *uint64
	Float32Field                 *float32
	Float64Field                 *float64
	SliceField                   *[]string
	MapField                     *map[string]string
	ChanField                    *chan any
	FuncField                    *func() string
	StructField                  *struct{ ID string }
	FromStringSliceToStringField *string
	FromTimeToStringField        *string
	FromTimeToTimeField          *time.Time
	FromStringToTimeField        *time.Time
}

func (to AssignTagToPointerField) checkFields(t *testing.T, from AssignTagFrom) {
	if from.StringField != *to.StringField {
		t.Fatalf("%+v\n", errors.Errorf("StringField not equal: from %v, to %v",
			from.StringField, *to.StringField))
	}

	if from.BoolField != *to.BoolField {
		t.Fatalf("%+v\n", errors.Errorf("BoolField not equal: from %v, to %v",
			from.BoolField, *to.BoolField))
	}

	if from.IntField != *to.IntField {
		t.Fatalf("%+v\n", errors.Errorf("IntField not equal: from %v, to %v",
			from.IntField, *to.IntField))
	}

	if from.Int8Field != *to.Int8Field {
		t.Fatalf("%+v\n", errors.Errorf("Int8Field not equal: from %v, to %v",
			from.Int8Field, *to.Int8Field))
	}

	if from.Int16Field != *to.Int16Field {
		t.Fatalf("%+v\n", errors.Errorf("Int16Field not equal: from %v, to %v",
			from.Int16Field, *to.Int16Field))
	}

	if from.Int32Field != *to.Int32Field {
		t.Fatalf("%+v\n", errors.Errorf("Int32Field not equal: from %v, to %v",
			from.Int32Field, *to.Int32Field))
	}

	if from.Int64Field != *to.Int64Field {
		t.Fatalf("%+v\n", errors.Errorf("Int64Field not equal: from %v, to %v",
			from.Int64Field, *to.Int64Field))
	}

	if from.UintField != *to.UintField {
		t.Fatalf("%+v\n", errors.Errorf("UintField not equal: from %v, to %v",
			from.UintField, *to.UintField))
	}

	if from.Uint8Field != *to.Uint8Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint8Field not equal: from %v, to %v",
			from.Uint8Field, *to.Uint8Field))
	}

	if from.Uint16Field != *to.Uint16Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint16Field not equal: from %v, to %v",
			from.Uint16Field, *to.Uint16Field))
	}

	if from.Uint32Field != *to.Uint32Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint32Field not equal: from %v, to %v",
			from.Uint32Field, *to.Uint32Field))
	}

	if from.Uint64Field != *to.Uint64Field {
		t.Fatalf("%+v\n", errors.Errorf("Uint64Field not equal: from %v, to %v",
			from.Uint64Field, *to.Uint64Field))
	}

	if from.Float32Field != *to.Float32Field {
		t.Fatalf("%+v\n", errors.Errorf("Float32Field not equal: from %v, to %v",
			from.Float32Field, *to.Float32Field))
	}

	if from.Float64Field != *to.Float64Field {
		t.Fatalf("%+v\n", errors.Errorf("Float64Field not equal: from %v, to %v",
			from.Float64Field, *to.Float64Field))
	}

	for i, value := range from.SliceField {
		if value != (*to.SliceField)[i] {
			t.Fatalf("%+v\n", errors.Errorf("SliceField not equal: from %v, to %v",
				value, (*to.SliceField)[i]))
		}
	}

	for key, value := range from.MapField {
		if value != (*to.MapField)[key] {
			t.Fatalf("%+v\n", errors.Errorf("MapField not equal: from %v, to %v",
				value, (*to.MapField)[key]))
		}
	}

	if from.ChanField != *to.ChanField {
		t.Fatalf("%+v\n", errors.Errorf("ChanField not equal: from %v, to %v",
			from.ChanField, *to.ChanField))
	}

	if from.FuncField() != (*to.FuncField)() {
		t.Fatalf("%+v\n", errors.Errorf("FuncField not equal: from %v, to %v",
			from.FuncField(), (*to.FuncField)()))
	}

	if from.StructField.ID != (*to.StructField).ID {
		t.Fatalf("%+v\n", errors.Errorf("StructField not equal: from %v, to %v",
			from.StructField.ID, (*to.StructField).ID))
	}

	if strings.Join(from.FromStringSliceToStringField, "::") != *to.FromStringSliceToStringField {
		t.Fatalf("%+v\n", errors.Errorf("FromStringSliceToStringField not equal: from %v, to %v",
			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField))
	}

	if from.FromTimeToStringField.Format(time.DateTime) != *to.FromTimeToStringField {
		t.Fatalf("%+v\n", errors.Errorf("FromTimeToStringField not equal: from %v, to %v",
			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField))
	}

	if from.FromTimeToTimeField.Format(time.DateTime) != (*to.FromTimeToTimeField).Format(time.DateTime) {
		t.Fatalf("%+v\n", errors.Errorf("FromTimeToTimeField not equal: from %v, to %v",
			from.FromTimeToTimeField.Format(time.DateTime), (*to.FromTimeToTimeField).Format(time.DateTime)))
	}

	if from.FromStringToTimeField != (*to.FromStringToTimeField).Format(time.DateTime) {
		t.Fatalf("%+v\n", errors.Errorf("FromStringToTimeField not equal: from %v, to %v",
			from.FromStringToTimeField, (*to.FromStringToTimeField).Format(time.DateTime)))
	}
}

func TestAssignTagDefaultUsage(t *testing.T) {
	stringField := strutils.SimpleUUID()
	boolField := rand.Intn(2) == 0
	intField := rand.Int()
	int8Field := int8(rand.Int())
	int16Field := int16(rand.Int())
	int32Field := int32(rand.Int())
	int64Field := int64(rand.Int())
	uintField := uint(rand.Int())
	uint8Field := uint8(rand.Int())
	uint16Field := uint16(rand.Int())
	uint32Field := uint32(rand.Int())
	uint64Field := uint64(rand.Int())
	float32Field := rand.Float32()
	float64Field := rand.Float64()
	sliceField := []string{strutils.SimpleUUID(), strutils.SimpleUUID()}
	mapField := map[string]string{strutils.SimpleUUID(): strutils.SimpleUUID()}
	chanField := make(chan any)
	returnValue := strutils.SimpleUUID()
	funcField := func() string { return returnValue }
	structField := struct{ ID string }{ID: strutils.SimpleUUID()}
	fromStringSliceToStringField := []string{strutils.SimpleUUID(), strutils.SimpleUUID()}
	fromTimeToStringField := time.Now().Local()
	fromTimeToTimeField := time.Now().Local()
	fromStringToTimeField := time.Now().Local().Format(time.DateTime)

	from := AssignTagFrom{
		StringField:                  stringField,
		BoolField:                    boolField,
		IntField:                     intField,
		Int8Field:                    int8Field,
		Int16Field:                   int16Field,
		Int32Field:                   int32Field,
		Int64Field:                   int64Field,
		UintField:                    uintField,
		Uint8Field:                   uint8Field,
		Uint16Field:                  uint16Field,
		Uint32Field:                  uint32Field,
		Uint64Field:                  uint64Field,
		Float32Field:                 float32Field,
		Float64Field:                 float64Field,
		SliceField:                   sliceField,
		MapField:                     mapField,
		ChanField:                    chanField,
		FuncField:                    funcField,
		StructField:                  structField,
		FromStringSliceToStringField: fromStringSliceToStringField,
		FromTimeToStringField:        fromTimeToStringField,
		FromTimeToTimeField:          fromTimeToTimeField,
		FromStringToTimeField:        fromStringToTimeField,
	}

	fromPointer := AssignTagFromPointerField{
		StringField:                  &stringField,
		BoolField:                    &boolField,
		IntField:                     &intField,
		Int8Field:                    &int8Field,
		Int16Field:                   &int16Field,
		Int32Field:                   &int32Field,
		Int64Field:                   &int64Field,
		UintField:                    &uintField,
		Uint8Field:                   &uint8Field,
		Uint16Field:                  &uint16Field,
		Uint32Field:                  &uint32Field,
		Uint64Field:                  &uint64Field,
		Float32Field:                 &float32Field,
		Float64Field:                 &float64Field,
		SliceField:                   &sliceField,
		MapField:                     &mapField,
		ChanField:                    &chanField,
		FuncField:                    &funcField,
		StructField:                  &structField,
		FromStringSliceToStringField: &fromStringSliceToStringField,
		FromTimeToStringField:        &fromTimeToStringField,
		FromTimeToTimeField:          &fromTimeToTimeField,
		FromStringToTimeField:        &fromStringToTimeField,
	}

	fromPointerNil := AssignTagFromPointerField{}

	to := AssignTagTo{}
	toPointer := AssignTagToPointerField{}

	err := assign.DefaultUsage(from, to)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(from, toPointer)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(fromPointer, to)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(fromPointer, toPointer)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(from, &to)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	to.checkFields(t, from)

	err = assign.DefaultUsage(from, &toPointer)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	toPointer.checkFields(t, from)

	err = assign.DefaultUsage(fromPointer, &to)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	to.checkFields(t, from)

	err = assign.DefaultUsage(fromPointer, &toPointer)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	toPointer.checkFields(t, from)

	err = assign.DefaultUsage(&from, to)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(&from, toPointer)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(&fromPointer, to)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(&fromPointer, toPointer)
	if err == nil || err.Error() != "返回类型不是结构指针" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出to参数必须是指针类型"))
	}

	err = assign.DefaultUsage(&from, &to)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	to.checkFields(t, from)

	err = assign.DefaultUsage(&from, &toPointer)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	toPointer.checkFields(t, from)

	err = assign.DefaultUsage(&fromPointer, &to)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	to.checkFields(t, from)

	err = assign.DefaultUsage(&fromPointer, &toPointer)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	toPointer.checkFields(t, from)

	err = assign.DefaultUsage(fromPointerNil, &to)
	if err == nil || err.Error() != "无法设置值，请检查是否传递的是非指针结构变量且字段为nil" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出from如果有nil字段，必须使用指针结构变量"))
	}

	err = assign.DefaultUsage(fromPointerNil, &toPointer)
	if err == nil || err.Error() != "无法设置值，请检查是否传递的是非指针结构变量且字段为nil" {
		t.Fatalf("%+v\n", errors.Errorf("没有检测出from如果有nil字段，必须使用指针结构变量"))
	}

	err = assign.DefaultUsage(&fromPointerNil, &to)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	to.checkFields(t, from)

	err = assign.DefaultUsage(&fromPointerNil, &toPointer)
	if err != nil {
		t.Fatalf("%+v\n", err)
	}

	toPointer.checkFields(t, from)
}