gojay

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

encode_time_test.go (3625B)

      1 package gojay
      2 
      3 import (
      4 	"strings"
      5 	"testing"
      6 	"time"
      7 
      8 	"github.com/stretchr/testify/assert"
      9 )
     10 
     11 func TestEncodeTime(t *testing.T) {
     12 	testCases := []struct {
     13 		name         string
     14 		tt           string
     15 		format       string
     16 		expectedJSON string
     17 		err          bool
     18 	}{
     19 		{
     20 			name:         "basic",
     21 			tt:           "2018-02-01",
     22 			format:       "2006-01-02",
     23 			expectedJSON: `"2018-02-01"`,
     24 			err:          false,
     25 		},
     26 	}
     27 
     28 	for _, testCase := range testCases {
     29 		t.Run(testCase.name, func(t *testing.T) {
     30 			b := strings.Builder{}
     31 			tt, err := time.Parse(testCase.format, testCase.tt)
     32 			assert.Nil(t, err)
     33 			enc := NewEncoder(&b)
     34 			err = enc.EncodeTime(&tt, testCase.format)
     35 			if !testCase.err {
     36 				assert.Nil(t, err)
     37 				assert.Equal(t, testCase.expectedJSON, b.String())
     38 			}
     39 		})
     40 	}
     41 	t.Run("encode-time-pool-error", func(t *testing.T) {
     42 		builder := &strings.Builder{}
     43 		enc := NewEncoder(builder)
     44 		enc.isPooled = 1
     45 		defer func() {
     46 			err := recover()
     47 			assert.NotNil(t, err, "err should not be nil")
     48 			assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError")
     49 		}()
     50 		_ = enc.EncodeTime(&time.Time{}, "")
     51 		assert.True(t, false, "should not be called as encoder should have panicked")
     52 	})
     53 	t.Run("write-error", func(t *testing.T) {
     54 		w := TestWriterError("")
     55 		enc := BorrowEncoder(w)
     56 		defer enc.Release()
     57 		err := enc.EncodeTime(&time.Time{}, "")
     58 		assert.NotNil(t, err, "err should not be nil")
     59 	})
     60 }
     61 
     62 func TestAddTimeKey(t *testing.T) {
     63 	testCases := []struct {
     64 		name         string
     65 		tt           string
     66 		format       string
     67 		expectedJSON string
     68 		baseJSON     string
     69 		err          bool
     70 	}{
     71 		{
     72 			name:         "basic",
     73 			tt:           "2018-02-01",
     74 			format:       "2006-01-02",
     75 			baseJSON:     "{",
     76 			expectedJSON: `{"test":"2018-02-01"`,
     77 			err:          false,
     78 		},
     79 		{
     80 			name:         "basic",
     81 			tt:           "2018-02-01",
     82 			format:       "2006-01-02",
     83 			baseJSON:     `{""`,
     84 			expectedJSON: `{"","test":"2018-02-01"`,
     85 			err:          false,
     86 		},
     87 	}
     88 
     89 	for _, testCase := range testCases {
     90 		t.Run(testCase.name, func(t *testing.T) {
     91 			b := strings.Builder{}
     92 			tt, err := time.Parse(testCase.format, testCase.tt)
     93 			assert.Nil(t, err)
     94 			enc := NewEncoder(&b)
     95 			enc.writeString(testCase.baseJSON)
     96 			enc.AddTimeKey("test", &tt, testCase.format)
     97 			enc.Write()
     98 			if !testCase.err {
     99 				assert.Nil(t, err)
    100 				assert.Equal(t, testCase.expectedJSON, b.String())
    101 			}
    102 		})
    103 	}
    104 }
    105 
    106 func TestAddTime(t *testing.T) {
    107 	testCases := []struct {
    108 		name         string
    109 		tt           string
    110 		format       string
    111 		expectedJSON string
    112 		baseJSON     string
    113 		err          bool
    114 	}{
    115 		{
    116 			name:         "basic",
    117 			tt:           "2018-02-01",
    118 			format:       "2006-01-02",
    119 			baseJSON:     "[",
    120 			expectedJSON: `["2018-02-01"`,
    121 			err:          false,
    122 		},
    123 		{
    124 			name:         "basic",
    125 			tt:           "2018-02-01",
    126 			format:       "2006-01-02",
    127 			baseJSON:     "[",
    128 			expectedJSON: `["2018-02-01"`,
    129 			err:          false,
    130 		},
    131 		{
    132 			name:         "basic",
    133 			tt:           "2018-02-01",
    134 			format:       "2006-01-02",
    135 			baseJSON:     `[""`,
    136 			expectedJSON: `["","2018-02-01"`,
    137 			err:          false,
    138 		},
    139 	}
    140 
    141 	for _, testCase := range testCases {
    142 		t.Run(testCase.name, func(t *testing.T) {
    143 			b := strings.Builder{}
    144 			tt, err := time.Parse(testCase.format, testCase.tt)
    145 			assert.Nil(t, err)
    146 			enc := NewEncoder(&b)
    147 			enc.writeString(testCase.baseJSON)
    148 			enc.AddTime(&tt, testCase.format)
    149 			enc.Write()
    150 			if !testCase.err {
    151 				assert.Nil(t, err)
    152 				assert.Equal(t, testCase.expectedJSON, b.String())
    153 			}
    154 		})
    155 	}
    156 }