Function TestEncoceSQLNullFloat64

encode_sqlnull_test.go:568–629

NullFloat64

(t *testing.T)

// NullFloat64
func TestEncoceSQLNullFloat64(t *testing.T) {
	testCases := []struct {
		name           string
		sqlNullFloat64 sql.NullFloat64
		expectedResult string
		err            bool
	}{
		{
			name: "it should encode a null string",
			sqlNullFloat64: sql.NullFloat64{
				Float64: float64(1),
			},
			expectedResult: `1`,
		},
		{
			name: "it should return an err as the string is invalid",
			sqlNullFloat64: sql.NullFloat64{
				Float64: float64(2),
			},
			expectedResult: `2`,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			var b strings.Builder
			enc := NewEncoder(&b)
			err := enc.EncodeSQLNullFloat64(&testCase.sqlNullFloat64)
			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.EncodeSQLNullFloat64(&sql.NullFloat64{})
			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.EncodeSQLNullFloat64(&sql.NullFloat64{})