Function TestEncoceSQLNullBool

encode_sqlnull_test.go:846–907

NullBool

(t *testing.T)

// NullBool
func TestEncoceSQLNullBool(t *testing.T) {
	testCases := []struct {
		name           string
		sqlNullBool    sql.NullBool
		expectedResult string
		err            bool
	}{
		{
			name: "it should encode a null string",
			sqlNullBool: sql.NullBool{
				Bool: true,
			},
			expectedResult: `true`,
		},
		{
			name: "it should return an err as the string is invalid",
			sqlNullBool: sql.NullBool{
				Bool: false,
			},
			expectedResult: `false`,
		},
	}

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