where/driver_test.go at main · pseudomuto/where · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package where_test

import (
	"sort"
	"testing"

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

// MockDriver for testing
type MockDriver struct {
	name string
}

func (m *MockDriver) Name() string                               { return m.name }
func (m *MockDriver) QuoteIdentifier(name string) string         { return "[" + name + "]" }
func (m *MockDriver) Placeholder(position int) string            { return "?" }
func (m *MockDriver) Keywords() []string                         { return []string{"SELECT"} }
func (m *MockDriver) TranslateOperator(op string) (string, bool) { return op, true }
func (m *MockDriver) SupportsFeature(feature string) bool        { return true }

func TestDriverRegistry(t *testing.T) {
	// Create a mock driver for testing
	mockDriver := &MockDriver{name: "test"}

	t.Run("RegisterDriver", func(t *testing.T) {
		// Register a new driver
		where.RegisterDriver("testdb", mockDriver)

		// Verify it was registered
		driver, err := where.GetDriver("testdb")
		require.NoError(t, err)
		require.Equal(t, "test", driver.Name())
	})

	t.Run("GetDriver existing", func(t *testing.T) {
		driver, err := where.GetDriver("postgres")
		require.NoError(t, err)
		require.NotNil(t, driver)
		require.Equal(t, "postgres", driver.Name())
	})

	t.Run("GetDriver nonexistent", func(t *testing.T) {
		driver, err := where.GetDriver("nonexistent")
		require.Error(t, err)
		require.Nil(t, driver)
		require.Contains(t, err.Error(), "driver \"nonexistent\" not registered")
	})

	t.Run("GetDriver with aliases", func(t *testing.T) {
		// Test PostgreSQL aliases
		pg1, err1 := where.GetDriver("postgres")
		require.NoError(t, err1)

		pg2, err2 := where.GetDriver("postgresql")
		require.NoError(t, err2)

		pg3, err3 := where.GetDriver("pg")
		require.NoError(t, err3)

		require.Equal(t, pg1.Name(), pg2.Name())
		require.Equal(t, pg1.Name(), pg3.Name())

		// Test MySQL aliases
		mysql1, err1 := where.GetDriver("mysql")
		require.NoError(t, err1)

		mysql2, err2 := where.GetDriver("mariadb")
		require.NoError(t, err2)

		require.Equal(t, mysql1.Name(), mysql2.Name())

		// Test ClickHouse aliases
		ch1, err1 := where.GetDriver("clickhouse")
		require.NoError(t, err1)

		ch2, err2 := where.GetDriver("ch")
		require.NoError(t, err2)

		require.Equal(t, ch1.Name(), ch2.Name())
	})

	t.Run("ListDrivers", func(t *testing.T) {
		drivers := where.ListDrivers()
		require.NotEmpty(t, drivers)

		// Should include our built-in drivers
		sort.Strings(drivers)
		require.Contains(t, drivers, "clickhouse")
		require.Contains(t, drivers, "mysql")
		require.Contains(t, drivers, "postgres")

		// Should include our test driver if it was registered
		if contains(drivers, "testdb") {
			require.Contains(t, drivers, "testdb")
		}
	})

	t.Run("RegisterDriver overwrites existing", func(t *testing.T) {
		// Register first driver
		driver1 := &MockDriver{name: "first"}
		where.RegisterDriver("overwrite-test", driver1)

		retrieved1, err := where.GetDriver("overwrite-test")
		require.NoError(t, err)
		require.Equal(t, "first", retrieved1.Name())

		// Overwrite with second driver
		driver2 := &MockDriver{name: "second"}
		where.RegisterDriver("overwrite-test", driver2)

		retrieved2, err := where.GetDriver("overwrite-test")
		require.NoError(t, err)
		require.Equal(t, "second", retrieved2.Name())
	})
}

// Helper function
func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}