github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/mapper/exprmapper/json/set_test.go (about)

     1  package json
     2  
     3  import (
     4  	"encoding/json"
     5  	"sync"
     6  	"testing"
     7  
     8  	"github.com/TIBCOSoftware/flogo-lib/core/mapper/exprmapper/json/field"
     9  
    10  	"fmt"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  //1. without array
    15  //2. root array, array with path field, array with
    16  func TestSetArrayObject(t *testing.T) {
    17  	mappingField := field.NewMappingField([]string{"City[0]", "Array[1]", "id"})
    18  	v, err := SetStringValue("setvalue", jsonData, mappingField)
    19  	assert.Nil(t, err)
    20  	assert.NotNil(t, v)
    21  
    22  	d, err := getValue(v, []string{"City[0]", "Array[1]", "id"})
    23  	assert.Nil(t, err)
    24  	assert.Equal(t, "setvalue", d)
    25  
    26  }
    27  
    28  func TestSetArrayObjectEMpty(t *testing.T) {
    29  	mappingField := field.NewMappingField([]string{"City[0]", "Array[1]", "id"})
    30  	v, err := SetStringValue("setvalue", "{}", mappingField)
    31  	assert.Nil(t, err)
    32  	assert.NotNil(t, v)
    33  	printvalue(v)
    34  	d, err := getValue(v, []string{"City[0]", "Array[1]", "id"})
    35  	assert.Nil(t, err)
    36  	assert.Equal(t, "setvalue", d)
    37  
    38  }
    39  
    40  func printvalue(in interface{}) {
    41  	v, _ := json.Marshal(in)
    42  	fmt.Println(string(v))
    43  }
    44  
    45  func TestSetRootChildArray(t *testing.T) {
    46  	mappingField := field.NewMappingField([]string{"Emails[0]"})
    47  	v, err := SetStringValue("test-cases@gmail.com", jsonData, mappingField)
    48  	assert.Nil(t, err)
    49  	assert.NotNil(t, v)
    50  
    51  	d, err := getValue(v, []string{"Emails[0]"})
    52  	assert.Nil(t, err)
    53  	assert.Equal(t, "test-cases@gmail.com", d)
    54  }
    55  
    56  func TestSetRootArray(t *testing.T) {
    57  	mappingField := field.NewMappingField([]string{"[0]", "ss"})
    58  	v, err := SetFieldValue("test-cases@gmail.com", "{}", mappingField)
    59  	assert.Nil(t, err)
    60  	assert.NotNil(t, v)
    61  
    62  	d, err := getValue(v, []string{"[0]", "ss"})
    63  	assert.Nil(t, err)
    64  	assert.Equal(t, "test-cases@gmail.com", d)
    65  
    66  }
    67  
    68  func TestSetObject(t *testing.T) {
    69  	mappingField := field.NewMappingField([]string{"ZipCode"})
    70  	v, err := SetStringValue("77479", jsonData, mappingField)
    71  	assert.Nil(t, err)
    72  	assert.NotNil(t, v)
    73  
    74  	d, err := getValue(v, []string{"ZipCode"})
    75  	assert.Nil(t, err)
    76  	assert.Equal(t, "77479", d)
    77  }
    78  
    79  func TestSetEmptyField(t *testing.T) {
    80  	mappingField := field.NewMappingField([]string{"ZipCode"})
    81  	jsond := "{}"
    82  	v, err := SetStringValue("77479", jsond, mappingField)
    83  	assert.Nil(t, err)
    84  	assert.NotNil(t, v)
    85  	printvalue(v)
    86  	d, err := getValue(v, []string{"ZipCode"})
    87  	assert.Nil(t, err)
    88  	assert.Equal(t, "77479", d)
    89  }
    90  
    91  func TestSetEmptyField4(t *testing.T) {
    92  	jsond := "{}"
    93  	mappingField := field.NewMappingField([]string{"ZipCode[1]"})
    94  	v, err := SetStringValue("77479", jsond, mappingField)
    95  	assert.Nil(t, err)
    96  	assert.NotNil(t, v)
    97  	d, err := getValue(v, []string{"ZipCode[1]"})
    98  	assert.Nil(t, err)
    99  	assert.Equal(t, "77479", d)
   100  }
   101  
   102  func TestSetEmptyField5(t *testing.T) {
   103  	jsond := "{}"
   104  	mappingField := field.NewMappingField([]string{"ZipCode[1]"})
   105  	v, err := SetStringValue("77479", jsond, mappingField)
   106  
   107  	mappingField = field.NewMappingField([]string{"ZipCode[0]"})
   108  	v2, err := SetFieldValue("77479", v, mappingField)
   109  	assert.Nil(t, err)
   110  	assert.NotNil(t, v2)
   111  	d, err := getValue(v, []string{"ZipCode[0]"})
   112  	assert.Nil(t, err)
   113  	assert.Equal(t, "77479", d)
   114  
   115  	d, err = getValue(v, []string{"ZipCode[1]"})
   116  	assert.Nil(t, err)
   117  	assert.Equal(t, "77479", d)
   118  }
   119  
   120  func TestSetEmptyNestField1(t *testing.T) {
   121  	jsond := "{}"
   122  	mappingField := field.NewMappingField([]string{"pet", "photoUrls[0]"})
   123  	v, err := SetStringValue("url", jsond, mappingField)
   124  
   125  	mappingField = field.NewMappingField([]string{"pet", "photoUrls[1]"})
   126  
   127  	v, err = SetFieldValue("url2", v, mappingField)
   128  	assert.Nil(t, err)
   129  	assert.NotNil(t, v)
   130  
   131  	d, err := getValue(v, []string{"pet", "photoUrls[0]"})
   132  	assert.Nil(t, err)
   133  	assert.Equal(t, "url", d)
   134  	d, err = getValue(v, []string{"pet", "photoUrls[1]"})
   135  	assert.Nil(t, err)
   136  	assert.Equal(t, "url2", d)
   137  }
   138  
   139  func TestNameWithSpace(t *testing.T) {
   140  	jsond := "{}"
   141  	mappingField := field.NewMappingField([]string{"pet name", "photoUrls[0]"})
   142  
   143  	v, err := SetFieldValue("url", jsond, mappingField)
   144  	mappingField = field.NewMappingField([]string{"pet name", "photoUrls[1]"})
   145  
   146  	v, err = SetFieldValue("url2", v, mappingField)
   147  	assert.Nil(t, err)
   148  	assert.NotNil(t, v)
   149  
   150  	d, err := getValue(v, []string{"pet name", "photoUrls[0]"})
   151  	assert.Nil(t, err)
   152  	assert.Equal(t, "url", d)
   153  	d, err = getValue(v, []string{"pet name", "photoUrls[1]"})
   154  	assert.Nil(t, err)
   155  	assert.Equal(t, "url2", d)
   156  
   157  }
   158  
   159  func TestNameNest2(t *testing.T) {
   160  	jsond := "{}"
   161  	mappingField := field.NewMappingField([]string{"input", "Account", "records[0]", "ID"})
   162  	v, err := SetFieldValue("id22", jsond, mappingField)
   163  
   164  	mappingField = field.NewMappingField([]string{"input", "Account", "records[0]", "Name"})
   165  
   166  	v, err = SetFieldValue("namesssss", v, mappingField)
   167  	assert.Nil(t, err)
   168  	assert.NotNil(t, v)
   169  
   170  	d, err := getValue(v, []string{"input", "Account", "records[0]", "ID"})
   171  	assert.Nil(t, err)
   172  	assert.Equal(t, "id22", d)
   173  	d, err = getValue(v, []string{"input", "Account", "records[0]", "Name"})
   174  	assert.Nil(t, err)
   175  	assert.Equal(t, "namesssss", d)
   176  }
   177  
   178  func TestNameSameLevel(t *testing.T) {
   179  	jsond := "{}"
   180  	mappingField := field.NewMappingField([]string{"input", "Account", "ID"})
   181  	v, err := SetFieldValue("id", jsond, mappingField)
   182  
   183  	mappingField = field.NewMappingField([]string{"input", "Account", "Name"})
   184  
   185  	v, err = SetFieldValue("namesssss", v, mappingField)
   186  	assert.Nil(t, err)
   187  	assert.NotNil(t, v)
   188  
   189  	d, err := getValue(v, []string{"input", "Account", "ID"})
   190  	assert.Nil(t, err)
   191  	assert.Equal(t, "id", d)
   192  	d, err = getValue(v, []string{"input", "Account", "Name"})
   193  	assert.Nil(t, err)
   194  	assert.Equal(t, "namesssss", d)
   195  
   196  }
   197  
   198  func TestNameWithTag(t *testing.T) {
   199  	jsond := "{}"
   200  	mappingField := field.NewMappingField([]string{"pet", "pet name", "photo	Urls[0]"})
   201  	v, err := SetFieldValue("url", jsond, mappingField)
   202  
   203  	mappingField = field.NewMappingField([]string{"pet", "pet name", "photo	Urls[1]"})
   204  
   205  	v, err = SetFieldValue("url2", v, mappingField)
   206  	assert.Nil(t, err)
   207  	assert.NotNil(t, v)
   208  
   209  	d, err := getValue(v, []string{"pet", "pet name", "photo	Urls[0]"})
   210  	assert.Nil(t, err)
   211  	assert.Equal(t, "url", d)
   212  	d, err = getValue(v, []string{"pet", "pet name", "photo	Urls[1]"})
   213  	assert.Nil(t, err)
   214  	assert.Equal(t, "url2", d)
   215  }
   216  
   217  func TestSetEmptyNestField(t *testing.T) {
   218  	jsond := "{}"
   219  	mappingField := field.NewMappingField([]string{"Response", "Pet", "Tags[0]", "Name"})
   220  	v, err := SetStringValue("tagID", jsond, mappingField)
   221  
   222  	mappingField = field.NewMappingField([]string{"Response", "Pet", "Tags[1]", "Name"})
   223  
   224  	v, err = SetFieldValue("tagID2", v, mappingField)
   225  
   226  	assert.Nil(t, err)
   227  	assert.NotNil(t, v)
   228  	d, err := getValue(v, []string{"Response", "Pet", "Tags[0]", "Name"})
   229  	assert.Nil(t, err)
   230  	assert.Equal(t, "tagID", d)
   231  	d, err = getValue(v, []string{"Response", "Pet", "Tags[1]", "Name"})
   232  	assert.Nil(t, err)
   233  	assert.Equal(t, "tagID2", d)
   234  }
   235  
   236  func TestConcurrentSet(t *testing.T) {
   237  	w := sync.WaitGroup{}
   238  	var recovered interface{}
   239  	//Create factory
   240  
   241  	for r := 0; r < 100000; r++ {
   242  		w.Add(1)
   243  		go func(i int) {
   244  			defer w.Done()
   245  			defer func() {
   246  				if r := recover(); r != nil {
   247  					recovered = r
   248  				}
   249  			}()
   250  			jsond := "{}"
   251  			mappingField := field.NewMappingField([]string{"pet name", "photoUrls[0]"})
   252  			v, err := SetFieldValue("url", jsond, mappingField)
   253  
   254  			mappingField = field.NewMappingField([]string{"pet name", "photoUrls[1]"})
   255  
   256  			v, err = SetFieldValue("url2", v, mappingField)
   257  			assert.Nil(t, err)
   258  			assert.NotNil(t, v)
   259  		}(r)
   260  
   261  	}
   262  	w.Wait()
   263  	assert.Nil(t, recovered)
   264  }
   265  
   266  func getValue(value interface{}, fields []string) (interface{}, error) {
   267  	mapField := field.NewMappingField(fields)
   268  	return GetFieldValue(value, mapField)
   269  }
   270  
   271  func TestSetSpecialObjectField(t *testing.T) {
   272  	mappingField := field.NewMappingField([]string{"Object", "Maps3", "dd*cc", "y.x", "d.d"})
   273  
   274  	value, err := SetStringValue("lixi", "{}", mappingField)
   275  	assert.Nil(t, err)
   276  	assert.NotNil(t, value)
   277  	log.Info(value)
   278  	v, _ := json.Marshal(value)
   279  	assert.Equal(t, `{"Object":{"Maps3":{"dd*cc":{"y.x":{"d.d":"lixi"}}}}}`, string(v))
   280  }
   281  
   282  func TestSetSpecialArrayField2(t *testing.T) {
   283  	mappingField := field.NewMappingField([]string{"Object", "Maps3[0]", "dd*cc"})
   284  
   285  	value, err := SetStringValue("lixi", "{}", mappingField)
   286  	assert.Nil(t, err)
   287  	assert.NotNil(t, value)
   288  	log.Info(value)
   289  	v, _ := json.Marshal(value)
   290  	fmt.Println(string(v))
   291  	assert.Equal(t, `{"Object":{"Maps3":[{"dd*cc":"lixi"}]}}`, string(v))
   292  }
   293  
   294  func TestSetSpecialArrayFieldMultipleLEvel(t *testing.T) {
   295  	// path := `Object.Maps3["dd.cc"][0]["y.x"][d.d].name`
   296  	mappingField := field.NewMappingField([]string{"Object", "Maps3", "dd.cc[0]", "y.x", "d.d", "name"})
   297  	value, err := SetStringValue("lixi", "{}", mappingField)
   298  	assert.Nil(t, err)
   299  	assert.NotNil(t, value)
   300  	log.Info(value)
   301  	v, _ := json.Marshal(value)
   302  	fmt.Println(string(v))
   303  	assert.Equal(t, `{"Object":{"Maps3":{"dd.cc":[{"y.x":{"d.d":{"name":"lixi"}}}]}}}`, string(v))
   304  }
   305  
   306  func TestSetArrayRootOnly(t *testing.T) {
   307  	mappingField := field.NewMappingField([]string{"[0]"})
   308  	value, err := SetStringValue("lixi", "{}", mappingField)
   309  	assert.Nil(t, err)
   310  	assert.NotNil(t, value)
   311  	v, err := getValue(value, []string{"[0]"})
   312  	assert.Nil(t, err)
   313  	assert.Equal(t, "lixi", v)
   314  
   315  	mappingField = field.NewMappingField([]string{"[0]", "tt"})
   316  	value, err = SetStringValue("ssssss", "{}", mappingField)
   317  	assert.Nil(t, err)
   318  	assert.NotNil(t, value)
   319  	v, err = getValue(value, []string{"[0]", "tt"})
   320  	assert.Nil(t, err)
   321  	assert.Equal(t, "ssssss", v)
   322  }
   323  
   324  func TestSetStructValue(t *testing.T) {
   325  	value := struct {
   326  		ID     string `json:"id"`
   327  		Name   string `json:"name"`
   328  		IntV   int    `json:"int_v"`
   329  		Int64V int64  `json:"int_64"`
   330  	}{
   331  		ID:     "12222",
   332  		Name:   "name",
   333  		Int64V: int64(123),
   334  		IntV:   int(12),
   335  	}
   336  
   337  	mappingField := field.NewMappingField([]string{"id"})
   338  
   339  	_, err := SetFieldValue("lixingwangid", &value, mappingField)
   340  	assert.Nil(t, err)
   341  
   342  	assert.Equal(t, "lixingwangid", value.ID)
   343  
   344  }