gojay

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

decode_time_test.go (3207B)

      1 package gojay
      2 
      3 import (
      4 	"strings"
      5 	"sync"
      6 	"testing"
      7 	"time"
      8 
      9 	"github.com/stretchr/testify/assert"
     10 )
     11 
     12 func TestDecodeTime(t *testing.T) {
     13 	testCases := []struct {
     14 		name         string
     15 		json         string
     16 		format       string
     17 		err          bool
     18 		expectedTime string
     19 	}{
     20 		{
     21 			name:         "basic",
     22 			json:         `"2018-02-18"`,
     23 			format:       `2006-01-02`,
     24 			err:          false,
     25 			expectedTime: "2018-02-18",
     26 		},
     27 		{
     28 			name:         "basic",
     29 			json:         `"2017-01-02T15:04:05Z"`,
     30 			format:       time.RFC3339,
     31 			err:          false,
     32 			expectedTime: "2017-01-02T15:04:05Z",
     33 		},
     34 		{
     35 			name:         "basic",
     36 			json:         `"2017-01-02T15:04:05ZINVALID"`,
     37 			format:       time.RFC3339,
     38 			err:          true,
     39 			expectedTime: "",
     40 		},
     41 		{
     42 			name:         "basic",
     43 			json:         `"2017-01-02T15:04:05ZINVALID`,
     44 			format:       time.RFC1123,
     45 			err:          true,
     46 			expectedTime: "",
     47 		},
     48 		{
     49 			name:         "basic",
     50 			json:         `"2017-01-02T15:04:05ZINVALID"`,
     51 			format:       time.RFC1123,
     52 			err:          true,
     53 			expectedTime: "",
     54 		},
     55 		{
     56 			name:         "basic",
     57 			json:         `"2017-01-02T15:04:05ZINVALID`,
     58 			format:       time.RFC3339,
     59 			err:          true,
     60 			expectedTime: "",
     61 		},
     62 	}
     63 
     64 	for _, testCase := range testCases {
     65 		t.Run(testCase.name, func(t *testing.T) {
     66 			tm := time.Time{}
     67 			dec := NewDecoder(strings.NewReader(testCase.json))
     68 			err := dec.DecodeTime(&tm, testCase.format)
     69 			if !testCase.err {
     70 				assert.Nil(t, err)
     71 				assert.Equal(t, testCase.expectedTime, tm.Format(testCase.format))
     72 				return
     73 			}
     74 			assert.NotNil(t, err)
     75 		})
     76 	}
     77 }
     78 
     79 func TestDecodeAddTime(t *testing.T) {
     80 	testCases := []struct {
     81 		name         string
     82 		json         string
     83 		format       string
     84 		err          bool
     85 		expectedTime string
     86 	}{
     87 		{
     88 			name:         "basic",
     89 			json:         `"2018-02-18"`,
     90 			format:       `2006-01-02`,
     91 			err:          false,
     92 			expectedTime: "2018-02-18",
     93 		},
     94 		{
     95 			name:         "basic",
     96 			json:         ` "2017-01-02T15:04:05Z"`,
     97 			format:       time.RFC3339,
     98 			err:          false,
     99 			expectedTime: "2017-01-02T15:04:05Z",
    100 		},
    101 		{
    102 			name:         "basic",
    103 			json:         ` "2017-01-02T15:04:05ZINVALID"`,
    104 			format:       time.RFC3339,
    105 			err:          true,
    106 			expectedTime: "",
    107 		},
    108 	}
    109 
    110 	for _, testCase := range testCases {
    111 		t.Run(testCase.name, func(t *testing.T) {
    112 			tm := time.Time{}
    113 			dec := NewDecoder(strings.NewReader(testCase.json))
    114 			err := dec.AddTime(&tm, testCase.format)
    115 			if !testCase.err {
    116 				assert.Nil(t, err)
    117 				assert.Equal(t, testCase.expectedTime, tm.Format(testCase.format))
    118 				return
    119 			}
    120 			assert.NotNil(t, err)
    121 		})
    122 	}
    123 }
    124 
    125 func TestDecoderTimePoolError(t *testing.T) {
    126 	// reset the pool to make sure it's not full
    127 	decPool = sync.Pool{
    128 		New: func() interface{} {
    129 			return NewDecoder(nil)
    130 		},
    131 	}
    132 	dec := NewDecoder(nil)
    133 	dec.Release()
    134 	defer func() {
    135 		err := recover()
    136 		assert.NotNil(t, err, "err shouldnt be nil")
    137 		assert.IsType(t, InvalidUsagePooledDecoderError(""), err, "err should be of type InvalidUsagePooledDecoderError")
    138 	}()
    139 	_ = dec.DecodeTime(&time.Time{}, time.RFC3339)
    140 	assert.True(t, false, "should not be called as decoder should have panicked")
    141 }