gojay

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

encode_embedded_json_test.go (3838B)

      1 package gojay
      2 
      3 import (
      4 	"strings"
      5 	"testing"
      6 
      7 	"github.com/stretchr/testify/assert"
      8 )
      9 
     10 func (r *Request) MarshalJSONObject(enc *Encoder) {
     11 	enc.AddStringKey("id", r.id)
     12 	enc.AddStringKey("method", r.method)
     13 	enc.AddEmbeddedJSONKey("params", &r.params)
     14 	params2 := EmbeddedJSON([]byte(``))
     15 	enc.AddEmbeddedJSONKeyOmitEmpty("params2", &params2)
     16 	params3 := EmbeddedJSON([]byte(`"test"`))
     17 	enc.AddEmbeddedJSONKeyOmitEmpty("params3", &params3)
     18 	enc.AddIntKey("more", r.more)
     19 }
     20 
     21 func (r *Request) IsNil() bool {
     22 	return r == nil
     23 }
     24 
     25 type EmbeddedJSONArr []EmbeddedJSON
     26 
     27 func (ear EmbeddedJSONArr) MarshalJSONArray(enc *Encoder) {
     28 	for _, e := range ear {
     29 		enc.AddEmbeddedJSON(&e)
     30 	}
     31 }
     32 
     33 func (ear EmbeddedJSONArr) IsNil() bool {
     34 	return len(ear) == 0
     35 }
     36 
     37 type EmbeddedJSONOmitEmptyArr []EmbeddedJSON
     38 
     39 func (ear EmbeddedJSONOmitEmptyArr) MarshalJSONArray(enc *Encoder) {
     40 	for _, e := range ear {
     41 		enc.AddEmbeddedJSONOmitEmpty(&e)
     42 	}
     43 }
     44 
     45 func (ear EmbeddedJSONOmitEmptyArr) IsNil() bool {
     46 	return len(ear) == 0
     47 }
     48 
     49 func TestEncodingEmbeddedJSON(t *testing.T) {
     50 	t.Run("basic-embedded-json", func(t *testing.T) {
     51 		ej := EmbeddedJSON([]byte(`"test"`))
     52 		b := &strings.Builder{}
     53 		enc := BorrowEncoder(b)
     54 		err := enc.Encode(&ej)
     55 		assert.Nil(t, err, "err should be nil")
     56 		assert.Equal(t, b.String(), `"test"`, "b should be equal to content of EmbeddedJSON")
     57 	})
     58 	t.Run("basic-embedded-json-marshal-api", func(t *testing.T) {
     59 		ej := EmbeddedJSON([]byte(`"test"`))
     60 		b, err := Marshal(&ej)
     61 		assert.Nil(t, err, "err should be nil")
     62 		assert.Equal(t, string(b), `"test"`, "b should be equal to content of EmbeddedJSON")
     63 	})
     64 	t.Run("object-embedded-json", func(t *testing.T) {
     65 		req := Request{
     66 			id:     "test",
     67 			method: "GET",
     68 			params: EmbeddedJSON([]byte(`"test"`)),
     69 		}
     70 		b := &strings.Builder{}
     71 		enc := BorrowEncoder(b)
     72 		err := enc.EncodeObject(&req)
     73 		assert.Nil(t, err, "err should be nil")
     74 		assert.Equal(
     75 			t,
     76 			b.String(),
     77 			`{"id":"test","method":"GET","params":"test","params3":"test","more":0}`,
     78 			"b should be equal to content of EmbeddedJSON",
     79 		)
     80 	})
     81 	t.Run("array-embedded-json", func(t *testing.T) {
     82 		ear := EmbeddedJSONArr{
     83 			[]byte(`"test"`),
     84 			[]byte(`{"test":"test"}`),
     85 		}
     86 		b := &strings.Builder{}
     87 		enc := BorrowEncoder(b)
     88 		err := enc.EncodeArray(ear)
     89 		assert.Nil(t, err, "err should be nil")
     90 		assert.Equal(
     91 			t,
     92 			b.String(),
     93 			`["test",{"test":"test"}]`,
     94 			"b should be equal to content of EmbeddedJSON",
     95 		)
     96 	})
     97 	t.Run("array-embedded-json-omit-empty", func(t *testing.T) {
     98 		ear := EmbeddedJSONOmitEmptyArr{
     99 			[]byte(`"test"`),
    100 			[]byte(``),
    101 			[]byte(`{"test":"test"}`),
    102 			[]byte(``),
    103 			[]byte(`{"test":"test"}`),
    104 		}
    105 		b := &strings.Builder{}
    106 		enc := BorrowEncoder(b)
    107 		err := enc.EncodeArray(ear)
    108 		assert.Nil(t, err, "err should be nil")
    109 		assert.Equal(
    110 			t,
    111 			b.String(),
    112 			`["test",{"test":"test"},{"test":"test"}]`,
    113 			"b should be equal to content of EmbeddedJSON",
    114 		)
    115 	})
    116 	t.Run("write-error", func(t *testing.T) {
    117 		w := TestWriterError("")
    118 		v := EmbeddedJSON([]byte(`"test"`))
    119 		enc := NewEncoder(w)
    120 		err := enc.EncodeEmbeddedJSON(&v)
    121 		assert.NotNil(t, err, "Error should not be nil")
    122 		assert.Equal(t, "Test Error", err.Error(), "err.Error() should be 'Test Error'")
    123 	})
    124 	t.Run("pool-error", func(t *testing.T) {
    125 		v := EmbeddedJSON([]byte(`"test"`))
    126 		enc := BorrowEncoder(nil)
    127 		enc.isPooled = 1
    128 		defer func() {
    129 			err := recover()
    130 			assert.NotNil(t, err, "err shouldnt be nil")
    131 			assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError")
    132 			assert.Equal(t, "Invalid usage of pooled encoder", err.(InvalidUsagePooledEncoderError).Error(), "err should be of type InvalidUsagePooledDecoderError")
    133 		}()
    134 		_ = enc.EncodeEmbeddedJSON(&v)
    135 		assert.True(t, false, "should not be called as it should have panicked")
    136 	})
    137 }