Function TestEncoceSQLNullInt64

encode_sqlnull_test.go:291–351

NullInt64

(t *testing.T)

// NullInt64
func TestEncoceSQLNullInt64(t *testing.T) {
	testCases := []struct {
		name           string
		sqlNullInt64   sql.NullInt64
		expectedResult string
		err            bool
	}{
		{
			name: "it should encode a null string",
			sqlNullInt64: sql.NullInt64{
				Int64: int64(1),
			},
			expectedResult: `1`,
		},
		{
			name: "it should return an err as the string is invalid",
			sqlNullInt64: sql.NullInt64{
				Int64: int64(2),
			},
			expectedResult: `2`,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			var b strings.Builder
			enc := NewEncoder(&b)
			err := enc.EncodeSQLNullInt64(&testCase.sqlNullInt64)
			if testCase.err {
				assert.NotNil(t, err)
			} else {
				assert.Nil(t, err)
				assert.Equal(t, testCase.expectedResult, b.String())
			}
		})
	}
	t.Run(
		"should panic as the encoder is pooled",
		func(t *testing.T) {
			builder := &strings.Builder{}
			enc := NewEncoder(builder)
			enc.isPooled = 1
			defer func() {
				err := recover()
				assert.NotNil(t, err, "err should not be nil")
				assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError")
			}()
			_ = enc.EncodeSQLNullInt64(&sql.NullInt64{})
			assert.True(t, false, "should not be called as encoder should have panicked")
		},
	)
	t.Run(
		"should return an error as the writer encounters an error",
		func(t *testing.T) {
			builder := TestWriterError("")
			enc := NewEncoder(builder)
			err := enc.EncodeSQLNullInt64(&sql.NullInt64{})
			assert.NotNil(t, err)