gitee.com/zhongguo168a/gocodes@v0.0.0-20230609140523-e1828349603f/datax/coderx/coder_test.go (about)

     1  package coderx
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"fmt"
     7  	esample "gitee.com/zhongguo168a/gocodes/datax/generate/schema_go/sample/enums"
     8  	"gitee.com/zhongguo168a/gocodes/datax/mapx"
     9  	"gitee.com/zhongguo168a/gocodes/datax/schemax"
    10  	"gitee.com/zhongguo168a/gocodes/myx/errorx"
    11  	"github.com/stretchr/testify/assert"
    12  	"io/ioutil"
    13  	"testing"
    14  )
    15  
    16  type M = map[string]interface{}
    17  type A = []interface{}
    18  
    19  func Load() {
    20  	var err error
    21  	var path = "d:/gitee/gocodes/datax/generate/schema_export/one.json"
    22  	file, readerr := ioutil.ReadFile(path)
    23  	if readerr != nil {
    24  		err = errorx.Wrap(err, fmt.Sprintf("read file %v", path))
    25  		return
    26  	}
    27  
    28  	schemamap := map[string]interface{}{}
    29  	err = json.Unmarshal(file, &schemamap)
    30  	if err != nil {
    31  		err = errorx.Wrap(err, fmt.Sprintf("json.Unmarshal"))
    32  		return
    33  	}
    34  
    35  	schemas := mapx.Array(schemamap, "schemas")
    36  	for _, val := range schemas {
    37  		m := val.(map[string]interface{})
    38  		obj, derr := NewMapToRef().SetSource(m).Create()
    39  		if derr != nil {
    40  			err = errorx.Wrap(derr, fmt.Sprintf("decoder"))
    41  			return
    42  		}
    43  		schemax.AddDecl(obj.(schemax.IDecl), "")
    44  	}
    45  
    46  	if err != nil {
    47  		fmt.Println("schemax.UpdateAlias", err)
    48  	}
    49  }
    50  
    51  func TestMapToByte_Read(t *testing.T) {
    52  	Load()
    53  
    54  	var classMap = M{
    55  		"Bool":    true,
    56  		"String":  "a",
    57  		"Int32":   100,
    58  		"Float32": 100.0,
    59  		"Class1":  M{"Int": 100, "String": "class1"},
    60  		"Sub": func() (x map[string]interface{}) {
    61  			return
    62  		}(),
    63  		"Enum":    esample.Enum1_A,
    64  		"Enum2":   esample.Enum2_B,
    65  		"SubEnum": esample.Enum1_B,
    66  		"Map":     M{"key1": 1, "key2": "2", "key3": 3.0},
    67  		"MapSt": M{
    68  			"key1": M{"String": "ArraySt1", "Int": 100},
    69  			"key2": M{"String": "ArraySt2", "Int": 100},
    70  		},
    71  		"Array": []interface{}{1, 2, 3},
    72  		"ArraySt": []interface{}{
    73  			M{"Map": M{"key1": 1, "key2": "2"}, "Bool": true, "Array": A{"1", "3"}},
    74  			M{"Map": M{"key1": "2", "key2": 4.0}, "Bool": false, "Array": A{"2", "3"}},
    75  		},
    76  	}
    77  
    78  	mapToByte, err := NewMapToByteWithType("Class")
    79  	if err != nil {
    80  		fmt.Println(err)
    81  		return
    82  	}
    83  
    84  	writer := bytes.NewBuffer([]byte{})
    85  	err = mapToByte.WithIgnoreAny().Write(classMap, writer)
    86  	if err != nil {
    87  		fmt.Println(err)
    88  		return
    89  	}
    90  
    91  	byteToMap, err := NewByteToMapWithType("Class")
    92  	if err != nil {
    93  		fmt.Println(err)
    94  		return
    95  	}
    96  	reader := bytes.NewReader(writer.Bytes())
    97  	newmap := map[string]interface{}{}
    98  	err = byteToMap.Read(reader, newmap)
    99  	if err != nil {
   100  		fmt.Println(err)
   101  		return
   102  	}
   103  
   104  	assert.Equal(t, true, err == nil, err)
   105  	assert.Equal(t, fmt.Sprintf("%+v", classMap), fmt.Sprintf("%+v", newmap))
   106  }
   107  
   108  func TestMapToByte_Change(t *testing.T) {
   109  	Load()
   110  
   111  	var classMap = M{
   112  		"Bool":    true,
   113  		"String":  "a",
   114  		"Int32":   100,
   115  		"Float32": 100.0,
   116  		"Class1":  M{"Int": 100, "String": "class1"},
   117  		"Sub": func() (x map[string]interface{}) {
   118  			return
   119  		}(),
   120  		"Enum":    esample.Enum1_C,
   121  		"Enum2":   esample.Enum2_B,
   122  		"SubEnum": esample.Enum1_B,
   123  		"Map":     M{"key1": 1, "key2": "2", "key3": 3.0},
   124  		"MapSt": M{
   125  			"key1": M{"String": "ArraySt1", "Int": 100},
   126  			"key2": M{"String": "ArraySt2", "Int": 100},
   127  		},
   128  		"Array": []interface{}{1, 2, 3},
   129  		"ArraySt": []interface{}{
   130  			M{"Map": M{"key1": 1, "key2": "2"}, "Bool": true, "Array": A{"1", "3"}},
   131  			M{"Map": M{"key1": "2", "key2": 4.0}, "Bool": false, "Array": A{"2", "3"}},
   132  		},
   133  	}
   134  
   135  	mapToByte, err := NewMapToByteWithType("Class")
   136  	if err != nil {
   137  		fmt.Println(err)
   138  		return
   139  	}
   140  
   141  	writer := bytes.NewBuffer([]byte{})
   142  	err = mapToByte.WithIgnoreAny().WithChange().Write(classMap, writer)
   143  	if err != nil {
   144  		fmt.Println(err)
   145  		return
   146  	}
   147  
   148  	byteToMap, err := NewByteToMapWithType("Class")
   149  	if err != nil {
   150  		fmt.Println(err)
   151  		return
   152  	}
   153  	reader := bytes.NewReader(writer.Bytes())
   154  	newmap := map[string]interface{}{}
   155  	err = byteToMap.Read(reader, newmap)
   156  	if err != nil {
   157  		fmt.Println(err)
   158  		return
   159  	}
   160  
   161  	assert.Equal(t, true, err == nil, err)
   162  	assert.Equal(t, fmt.Sprintf("%+v", classMap), fmt.Sprintf("%+v", newmap))
   163  }