gojay

high performance JSON encoder/decoder with stream API for Golang
git clone git://git.lair.cx/gojay
Log | Files | Refs | README | LICENSE

decode_embedded_json_test.go (5518B)


      1 package gojay
      2 
      3 import (
      4 	"bytes"
      5 	"strings"
      6 	"testing"
      7 
      8 	"github.com/stretchr/testify/assert"
      9 )
     10 
     11 type Request struct {
     12 	id     string
     13 	method string
     14 	params EmbeddedJSON
     15 	more   int
     16 }
     17 
     18 func (r *Request) UnmarshalJSONObject(dec *Decoder, key string) error {
     19 	switch key {
     20 	case "id":
     21 		return dec.AddString(&r.id)
     22 	case "method":
     23 		return dec.AddString(&r.method)
     24 	case "params":
     25 		return dec.AddEmbeddedJSON(&r.params)
     26 	case "more":
     27 		dec.AddInt(&r.more)
     28 	}
     29 	return nil
     30 }
     31 
     32 func (r *Request) NKeys() int {
     33 	return 4
     34 }
     35 
     36 func TestDecodeEmbeddedJSONUnmarshalAPI(t *testing.T) {
     37 	testCases := []struct {
     38 		name             string
     39 		json             []byte
     40 		expectedEmbedded string
     41 		err              bool
     42 	}{
     43 		{
     44 			name:             "decode-basic-string",
     45 			json:             []byte(`{"id":"someid","method":"getmydata","params":"raw data", "more":123}`),
     46 			expectedEmbedded: `"raw data"`,
     47 		},
     48 		{
     49 			name:             "decode-basic-int",
     50 			json:             []byte(`{"id":"someid","method":"getmydata","params":12345, "more":123}`),
     51 			expectedEmbedded: `12345`,
     52 		},
     53 		{
     54 			name:             "decode-basic-int",
     55 			json:             []byte(`{"id":"someid","method":"getmydata","params":true, "more":123}`),
     56 			expectedEmbedded: `true`,
     57 		},
     58 		{
     59 			name:             "decode-basic-int",
     60 			json:             []byte(`{"id":"someid","method":"getmydata","params": false, "more":123}`),
     61 			expectedEmbedded: `false`,
     62 		},
     63 		{
     64 			name:             "decode-basic-int",
     65 			json:             []byte(`{"id":"someid","method":"getmydata","params":null, "more":123}`),
     66 			expectedEmbedded: `null`,
     67 		},
     68 		{
     69 			name:             "decode-basic-object",
     70 			json:             []byte(`{"id":"someid","method":"getmydata","params":{"example":"of raw data"}, "more":123}`),
     71 			expectedEmbedded: `{"example":"of raw data"}`,
     72 		},
     73 		{
     74 			name:             "decode-basic-object",
     75 			json:             []byte(`{"id":"someid","method":"getmydata","params":[1,2,3], "more":123}`),
     76 			expectedEmbedded: `[1,2,3]`,
     77 		},
     78 		{
     79 			name:             "decode-null-err",
     80 			json:             []byte(`{"id":"someid","method":"getmydata","params":nil, "more":123}`),
     81 			expectedEmbedded: ``,
     82 			err:              true,
     83 		},
     84 		{
     85 			name:             "decode-bool-false-err",
     86 			json:             []byte(`{"id":"someid","method":"getmydata","params":faulse, "more":123}`),
     87 			expectedEmbedded: ``,
     88 			err:              true,
     89 		},
     90 		{
     91 			name:             "decode-bool-true-err",
     92 			json:             []byte(`{"id":"someid","method":"getmydata","params":trou, "more":123}`),
     93 			expectedEmbedded: ``,
     94 			err:              true,
     95 		},
     96 	}
     97 	for _, testCase := range testCases {
     98 		t.Run(testCase.name, func(t *testing.T) {
     99 			req := &Request{}
    100 			err := Unmarshal(testCase.json, req)
    101 			t.Log(req)
    102 			t.Log(string(req.params))
    103 			if testCase.err {
    104 				assert.NotNil(t, err, "err should not be nil")
    105 			} else {
    106 				assert.Nil(t, err, "err should be nil")
    107 			}
    108 			assert.Equal(t, testCase.expectedEmbedded, string(req.params), "r.params should be equal to expectedEmbeddedResult")
    109 		})
    110 	}
    111 }
    112 
    113 func TestDecodeEmbeddedJSONDecodeAPI(t *testing.T) {
    114 	testCases := []struct {
    115 		name             string
    116 		json             []byte
    117 		expectedEmbedded string
    118 	}{
    119 		{
    120 			name:             "decode-basic-string",
    121 			json:             []byte(`{"id":"someid","method":"getmydata","params":"raw data", "more":123}`),
    122 			expectedEmbedded: `"raw data"`,
    123 		},
    124 		{
    125 			name:             "decode-basic-int",
    126 			json:             []byte(`{"id":"someid","method":"getmydata","params":12345, "more":123}`),
    127 			expectedEmbedded: `12345`,
    128 		},
    129 		{
    130 			name:             "decode-basic-int",
    131 			json:             []byte(`{"id":"someid","method":"getmydata","params":true, "more":123}`),
    132 			expectedEmbedded: `true`,
    133 		},
    134 		{
    135 			name:             "decode-basic-int",
    136 			json:             []byte(`{"id":"someid","method":"getmydata","params": false, "more":123}`),
    137 			expectedEmbedded: `false`,
    138 		},
    139 		{
    140 			name:             "decode-basic-int",
    141 			json:             []byte(`{"id":"someid","method":"getmydata","params":null, "more":123}`),
    142 			expectedEmbedded: `null`,
    143 		},
    144 		{
    145 			name:             "decode-basic-object",
    146 			json:             []byte(`{"id":"someid","method":"getmydata","params":{"example":"of raw data"}, "more":123}`),
    147 			expectedEmbedded: `{"example":"of raw data"}`,
    148 		},
    149 		{
    150 			name:             "decode-basic-object",
    151 			json:             []byte(`{"id":"someid","method":"getmydata","params":[1,2,3], "more":123}`),
    152 			expectedEmbedded: `[1,2,3]`,
    153 		},
    154 	}
    155 	for _, testCase := range testCases {
    156 		t.Run(testCase.name, func(t *testing.T) {
    157 			ej := EmbeddedJSON([]byte{})
    158 			dec := BorrowDecoder(bytes.NewReader(testCase.json))
    159 			err := dec.Decode(&ej)
    160 			assert.Nil(t, err, "err should be nil")
    161 			assert.Equal(t, string(testCase.json), string(ej), "r.params should be equal to expectedEmbeddedResult")
    162 		})
    163 	}
    164 }
    165 
    166 func TestDecodeEmbeededJSONNil(t *testing.T) {
    167 	dec := BorrowDecoder(strings.NewReader(`"bar"`))
    168 	var ej *EmbeddedJSON
    169 	err := dec.decodeEmbeddedJSON(ej)
    170 	assert.NotNil(t, err, `err should not be nil a nil pointer is given`)
    171 	assert.IsType(t, InvalidUnmarshalError(""), err, `err should not be of type InvalidUnmarshalError`)
    172 }
    173 
    174 func TestDecodeEmbeededJSONNil2(t *testing.T) {
    175 	dec := BorrowDecoder(strings.NewReader(`"bar"`))
    176 	var ej *EmbeddedJSON
    177 	err := dec.AddEmbeddedJSON(ej)
    178 	assert.NotNil(t, err, `err should not be nil a nil pointer is given`)
    179 	assert.IsType(t, InvalidUnmarshalError(""), err, `err should not be of type InvalidUnmarshalError`)
    180 }