Function TestEncoceSQLNullString

encode_sqlnull_test.go:12–74

Null String

(t *testing.T)

// Null String
func TestEncoceSQLNullString(t *testing.T) {
	testCases := []struct {
		name           string
		sqlNullString  sql.NullString
		expectedResult string
		err            bool
	}{
		{
			name: "it should encode a null string",
			sqlNullString: sql.NullString{
				String: "foo bar",
			},
			expectedResult: `"foo bar"`,
		},
		{
			name: "it should return an err as the string is invalid",
			sqlNullString: sql.NullString{
				String: "foo \t bar",
			},
			expectedResult: `"foo \t bar"`,
		},
	}

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