sqlutil_test.go

package sqlutil

import (
	"testing"

	"github.com/stretchr/testify/require"
)

func TestNew(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		opts      []Option
		wantErrIs error
	}{
		{
			name:      "succeeds with defaults",
			wantErrIs: nil,
		},
		{
			name:      "fails with nil quoteIDFunc",
			opts:      []Option{WithQuoteIDFunc(nil)},
			wantErrIs: ErrNilQuoteIDFunc,
		},
		{
			name:      "fails with nil quoteValueFunc",
			opts:      []Option{WithQuoteValueFunc(nil)},
			wantErrIs: ErrNilQuoteValueFunc,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			_, err := New(tt.opts...)

			if tt.wantErrIs == nil {
				require.NoError(t, err)

				return
			}

			require.ErrorIs(t, err, tt.wantErrIs)
		})
	}
}

func Test_defaultSQLUtil(t *testing.T) {
	t.Parallel()

	c := defaultSQLUtil()
	require.NotNil(t, c.quoteIDFunc)
	require.NotNil(t, c.quoteValueFunc)
}

func Test_validate(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		c         *SQLUtil
		wantErrIs error
	}{
		{
			name: "fail with invalid quoteIDFunc function",
			c: func() *SQLUtil {
				c := defaultSQLUtil()
				c.quoteIDFunc = nil

				return c
			}(),
			wantErrIs: ErrNilQuoteIDFunc,
		},
		{
			name: "fail with invalid quoteValueFunc function",
			c: func() *SQLUtil {
				c := defaultSQLUtil()
				c.quoteValueFunc = nil

				return c
			}(),
			wantErrIs: ErrNilQuoteValueFunc,
		},
		{
			name: "succeed with no errors",
			c: func() *SQLUtil {
				c := defaultSQLUtil()
				return c
			}(),
			wantErrIs: nil,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			err := tt.c.validate()

			if tt.wantErrIs == nil {
				require.NoError(t, err)

				return
			}

			require.ErrorIs(t, err, tt.wantErrIs)
		})
	}
}

func Test_defaultQuoteID(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		id   string
		want string
	}{
		{
			name: "empty string",
			id:   "",
			want: "",
		},
		{
			name: "single value",
			id:   "test1",
			want: "`test1`",
		},
		{
			name: "two parts",
			id:   "parent.child",
			want: "`parent`.`child`",
		},
		{
			name: "multiple parts",
			id:   "parent.child.name",
			want: "`parent`.`child`.`name`",
		},
		{
			name: "multiple parts with space",
			id:   "one two.three four",
			want: "`one two`.`three four`",
		},
		{
			name: "escape backtick",
			id:   "test`4",
			want: "`test``4`",
		},
		{
			name: "escape multiple backtick",
			id:   "test```4",
			want: "`test``````4`",
		},
		{
			name: "backslash kept literal",
			id:   `a\b`,
			want: "`a\\b`",
		},
		{
			name: "special characters",
			id:   "test" + string([]byte{'\'', '"', '`', 0, '\n', '\r', '\\', '\032'}),
			want: "`test'\"``" + string([]byte{0, '\n', '\r', '\\', '\032'}) + "`",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			got := defaultQuoteID(tt.id)

			require.Equal(t, tt.want, got, "QuoteID() got = %v, want %v", got, tt.want)
		})
	}
}

func Test_defaultQuoteValue(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		val  string
		want string
	}{
		{
			name: "empty string is quoted",
			val:  "",
			want: "''",
		},
		{
			name: "simple value",
			val:  "test1",
			want: "'test1'",
		},
		{
			name: "value with spaces",
			val:  "one two three",
			want: "'one two three'",
		},
		{
			name: "escape single quote",
			val:  "test'2",
			want: "'test''2'",
		},
		{
			name: "escape multiple quotes",
			val:  "test'''2",
			want: "'test''''''2'",
		},
		{
			name: "special characters",
			val:  "test" + string([]byte{'\'', '"', '`', 0, '\n', '\r', '\\', '\032'}),
			want: "'test''\"`\\0\\n\\r\\\\\\Z'",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			got := defaultQuoteValue(tt.val)

			require.Equal(t, tt.want, got, "QuoteID() got = %v, want %v", got, tt.want)
		})
	}
}

// Test_QuoteValue_Escaping exercises the default escaping behavior through the
// exported QuoteValue entry point, covering single quotes, backticks and every
// control character the escaper handles (\0, \n, \r, \\, \032/\Z).
func Test_QuoteValue_Escaping(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		val  string
		want string
	}{
		{
			name: "empty string is quoted",
			val:  "",
			want: "''",
		},
		{
			name: "single quote doubled",
			val:  "o'reilly",
			want: "'o''reilly'",
		},
		{
			name: "backtick left untouched in value",
			val:  "a`b",
			want: "'a`b'",
		},
		{
			name: "null byte escaped",
			val:  "a" + string([]byte{0}) + "b",
			want: `'a\0b'`,
		},
		{
			name: "newline escaped",
			val:  "a\nb",
			want: `'a\nb'`,
		},
		{
			name: "carriage return escaped",
			val:  "a\rb",
			want: `'a\rb'`,
		},
		{
			name: "backslash escaped",
			val:  `a\b`,
			want: `'a\\b'`,
		},
		{
			name: "substitute (\\032) escaped to Z",
			val:  "a\032b",
			want: `'a\Zb'`,
		},
		{
			name: "all control characters and quote together",
			val:  string([]byte{'\'', 0, '\n', '\r', '\\', '\032', '`'}),
			want: "'''\\0\\n\\r\\\\\\Z`'",
		},
	}

	c, err := New()
	require.NoError(t, err)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			got := c.QuoteValue(tt.val)

			require.Equal(t, tt.want, got, "QuoteValue() got = %v, want %v", got, tt.want)
		})
	}
}

// Test_QuoteID_Escaping exercises the default quoting behavior through the
// exported QuoteID entry point: inside backtick quotes only the backtick is
// special (doubled); backslashes and control characters are kept literal.
func Test_QuoteID_Escaping(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name string
		id   string
		want string
	}{
		{
			name: "embedded backtick doubled",
			id:   "col`umn",
			want: "`col``umn`",
		},
		{
			name: "single quote left untouched in identifier",
			id:   "col'umn",
			want: "`col'umn`",
		},
		{
			name: "dotted identifier with backtick per segment",
			id:   "sch`ema.ta`ble",
			want: "`sch``ema`.`ta``ble`",
		},
		{
			name: "null byte kept literal",
			id:   "a" + string([]byte{0}) + "b",
			want: "`a" + string([]byte{0}) + "b`",
		},
		{
			name: "newline kept literal",
			id:   "a\nb",
			want: "`a\nb`",
		},
		{
			name: "carriage return kept literal",
			id:   "a\rb",
			want: "`a\rb`",
		},
		{
			name: "backslash kept literal",
			id:   `a\b`,
			want: "`a\\b`",
		},
		{
			name: "substitute (\\032) kept literal",
			id:   "a\032b",
			want: "`a\032b`",
		},
		{
			name: "all control characters kept literal and backtick doubled",
			id:   string([]byte{0, '\n', '\r', '\\', '\032', '`'}),
			want: "`" + string([]byte{0, '\n', '\r', '\\', '\032'}) + "```",
		},
	}

	c, err := New()
	require.NoError(t, err)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			got := c.QuoteID(tt.id)

			require.Equal(t, tt.want, got, "QuoteID() got = %v, want %v", got, tt.want)
		})
	}
}

func Test_QuoteID(t *testing.T) {
	t.Parallel()

	fn := func(s string) string { return "TEST" + s }
	c := &SQLUtil{quoteIDFunc: fn}
	s := "5237"
	got := c.QuoteID(s)
	want := fn(s)

	require.Equal(t, want, got, "QuoteID() got = %v, want %v", got, want)
}

func Test_QuoteValue(t *testing.T) {
	t.Parallel()

	fn := func(s string) string { return "TEST" + s }
	c := &SQLUtil{quoteValueFunc: fn}
	s := "5237"
	got := c.QuoteValue(s)
	want := fn(s)

	require.Equal(t, want, got, "QuoteValue() got = %v, want %v", got, want)
}