github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/pkg/fftypes/jsondata_test.go (about)

     1  // Copyright © 2021 Kaleido, Inc.
     2  //
     3  // SPDX-License-Identifier: Apache-2.0
     4  //
     5  // Licensed under the Apache License, Version 2.0 (the "License");
     6  // you may not use this file except in compliance with the License.
     7  // You may obtain a copy of the License at
     8  //
     9  //     http://www.apache.org/licenses/LICENSE-2.0
    10  //
    11  // Unless required by applicable law or agreed to in writing, software
    12  // distributed under the License is distributed on an "AS IS" BASIS,
    13  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  // See the License for the specific language governing permissions and
    15  // limitations under the License.
    16  
    17  package fftypes
    18  
    19  import (
    20  	"encoding/json"
    21  	"fmt"
    22  	"testing"
    23  
    24  	"github.com/stretchr/testify/assert"
    25  )
    26  
    27  func TestJSONObject(t *testing.T) {
    28  
    29  	data := JSONObject{
    30  		"some": "data",
    31  	}
    32  
    33  	b, err := data.Value()
    34  	assert.NoError(t, err)
    35  	assert.IsType(t, []byte{}, b)
    36  
    37  	var dataRead JSONObject
    38  	err = dataRead.Scan(b)
    39  	assert.NoError(t, err)
    40  
    41  	assert.Equal(t, `{"some":"data"}`, fmt.Sprintf("%v", dataRead))
    42  
    43  	j1, err := json.Marshal(&data)
    44  	assert.NoError(t, err)
    45  	j2, err := json.Marshal(&dataRead)
    46  	assert.NoError(t, err)
    47  	assert.Equal(t, string(j1), string(j2))
    48  	j3 := dataRead.String()
    49  	assert.Equal(t, string(j1), j3)
    50  
    51  	err = dataRead.Scan("")
    52  	assert.NoError(t, err)
    53  
    54  	err = dataRead.Scan(nil)
    55  	assert.NoError(t, err)
    56  
    57  	var wrongType int
    58  	err = dataRead.Scan(&wrongType)
    59  	assert.Error(t, err)
    60  
    61  	hash, err := dataRead.Hash("goodStuff")
    62  	assert.NoError(t, err)
    63  	assert.NotEmpty(t, hash)
    64  
    65  	var badJson JSONObject = map[string]interface{}{"not": map[bool]string{true: "json"}}
    66  	hash, err = badJson.Hash("badStuff")
    67  	assert.Regexp(t, "FF10151.*badStuff", err)
    68  	assert.Nil(t, hash)
    69  
    70  	v, ok := JSONObject{"test": false}.GetStringOk("test")
    71  	assert.False(t, ok)
    72  	assert.Equal(t, "", v)
    73  }
    74  
    75  func TestJSONObjectArray(t *testing.T) {
    76  
    77  	data := JSONObjectArray{
    78  		{"some": "data"},
    79  	}
    80  
    81  	b, err := data.Value()
    82  	assert.NoError(t, err)
    83  	assert.IsType(t, []byte{}, b)
    84  
    85  	var dataRead JSONObjectArray
    86  	err = dataRead.Scan(b)
    87  	assert.NoError(t, err)
    88  
    89  	assert.Equal(t, `[{"some":"data"}]`, fmt.Sprintf("%v", dataRead))
    90  
    91  	j1, err := json.Marshal(&data)
    92  	assert.NoError(t, err)
    93  	j2, err := json.Marshal(&dataRead)
    94  	assert.NoError(t, err)
    95  	assert.Equal(t, string(j1), string(j2))
    96  	j3 := dataRead.String()
    97  	assert.Equal(t, string(j1), j3)
    98  
    99  	err = dataRead.Scan("")
   100  	assert.NoError(t, err)
   101  
   102  	err = dataRead.Scan(nil)
   103  	assert.NoError(t, err)
   104  
   105  	var wrongType int
   106  	err = dataRead.Scan(&wrongType)
   107  	assert.Error(t, err)
   108  
   109  	hash, err := dataRead.Hash("goodStuff")
   110  	assert.NoError(t, err)
   111  	assert.NotEmpty(t, hash)
   112  
   113  	var badJson JSONObjectArray = []JSONObject{{"not": map[bool]string{true: "json"}}}
   114  	hash, err = badJson.Hash("badStuff")
   115  	assert.Regexp(t, "FF10151.*badStuff", err)
   116  	assert.Nil(t, hash)
   117  
   118  }
   119  
   120  func TestJSONNestedSafeGet(t *testing.T) {
   121  
   122  	var jd JSONObject
   123  	err := json.Unmarshal([]byte(`
   124  		{
   125  			"nested_array": [
   126  				{
   127  					"with": {
   128  						"some": "value"
   129  					}
   130  				}
   131  			],
   132  			"string_array": ["str1","str2"]
   133  		}
   134  	`), &jd)
   135  	assert.NoError(t, err)
   136  
   137  	va, ok := jd.GetObjectArrayOk("wrong")
   138  	assert.False(t, ok)
   139  	assert.NotNil(t, va)
   140  
   141  	vo, ok := jd.GetObjectOk("wrong")
   142  	assert.False(t, ok)
   143  	assert.NotNil(t, vo)
   144  
   145  	assert.Equal(t, "value",
   146  		jd.GetObjectArray("nested_array")[0].
   147  			GetObject("with").
   148  			GetString("some"),
   149  	)
   150  
   151  	sa, ok := jd.GetStringArrayOk("wrong")
   152  	assert.False(t, ok)
   153  	assert.Empty(t, sa)
   154  
   155  	sa, ok = jd.GetStringArrayOk("string_array")
   156  	assert.True(t, ok)
   157  	assert.Equal(t, []string{"str1", "str2"}, sa)
   158  
   159  	assert.Equal(t, []string{"str1", "str2"}, jd.GetStringArray("string_array"))
   160  
   161  	sa, ok = ToStringArray(jd.GetStringArray("string_array"))
   162  	assert.True(t, ok)
   163  	assert.Equal(t, []string{"str1", "str2"}, sa)
   164  
   165  	remapped, ok := ToJSONObjectArray(jd.GetObjectArray("nested_array"))
   166  	assert.True(t, ok)
   167  	assert.Equal(t, "value",
   168  		remapped[0].
   169  			GetObject("with").
   170  			GetString("some"),
   171  	)
   172  
   173  	assert.Equal(t, "",
   174  		jd.GetObject("no").
   175  			GetObject("path").
   176  			GetObject("to").
   177  			GetString("here"),
   178  	)
   179  
   180  }