Extend tests

Author: bw19

db_test.go

@@ -17,30 +17,46 @@ limitations under the License.
 package sequel
 
 import (
+	"encoding/json"
 	"testing"
+	"time"
 
 	"github.com/microbus-io/sequel/testdata"
 	"github.com/microbus-io/testarossa"
 )
 
 func TestDB_AutoCreate(t *testing.T) {
-	for _, driver := range []string{"mysql", "pgx" /* , "mssql" */} {
-		t.Run(driver, func(t *testing.T) {
+	t.Parallel()
+	dsns := map[string]string{
+		"mysql": "root:root@tcp(127.0.0.1:3306)/",
+		"pgx":   "postgres://postgres:postgres@127.0.0.1:5432/",
+		// "mssql": "sqlserver://sa:Password123@127.0.0.1:1433",
+	}
+	for drv, dsn := range dsns {
+		t.Run(drv, func(t *testing.T) {
 			assert := testarossa.For(t)
 
-			db, err := OpenTesting(driver, "", "AutoCreate")
+			db, err := OpenTesting(drv, dsn, t.Name())
 			assert.NoError(err)
-			assert.NotNil(db)
+			if !assert.NotNil(db) {
+				return
+			}
 			defer db.Close()
 
 			err = db.Migrate("auto_create", testdata.FS)
 			assert.NoError(err)
 
-			row := db.QueryRow("SELECT COUNT(id) FROM foo")
 			var count int
-			err = row.Scan(&count)
+			stmt := "SELECT COUNT(id) FROM foo"
+			err = db.QueryRow(stmt).Scan(&count)
 			assert.NoError(err)
 			assert.Equal(3, count)
+
+			var id int
+			stmt = db.ConformArgPlaceholders("SELECT id FROM foo WHERE id=?")
+			err = db.QueryRow(stmt, 1).Scan(&id)
+			assert.NoError(err)
+			assert.Equal(1, id)
 		})
 	}
 }
@@ -86,4 +102,281 @@ func TestDB_DatabaseNameFromDataSourceName(t *testing.T) {
 	assert.Expect(name, "my_database", err, nil)
 	name, err = databaseNameFromDataSourceName("mssql", "sqlserver://user:pw@127.0.0.1:1433")
 	assert.Expect(name, "", err, nil)
+
+	// empty dsn
+	_, err = databaseNameFromDataSourceName("mysql", "")
+	assert.Error(err)
+
+	// unsupported driver
+	_, err = databaseNameFromDataSourceName("sqlite", "file.db")
+	assert.Error(err)
+}
+
+func TestDB_InferDriverName(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// Postgres prefix
+	assert.Equal("pgx", inferDriverName("postgres://user:pw@127.0.0.1:5432/mydb"))
+
+	// SQL Server prefix
+	assert.Equal("mssql", inferDriverName("sqlserver://user:pw@127.0.0.1:1433"))
+
+	// MySQL tcp() style
+	assert.Equal("mysql", inferDriverName("root:root@tcp(127.0.0.1:3306)/"))
+
+	// Port-based inference
+	assert.Equal("mysql", inferDriverName("root:root@127.0.0.1:3306/"))
+	assert.Equal("pgx", inferDriverName("user:pw@127.0.0.1:5432/"))
+	assert.Equal("mssql", inferDriverName("user:pw@127.0.0.1:1433"))
+
+	// Empty string
+	assert.Equal("", inferDriverName(""))
+
+	// Unrecognizable DSN
+	assert.Equal("", inferDriverName("some-unknown-dsn"))
+}
+
+func TestDB_SetDatabaseInDataSourceName(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// mysql - set database
+	dsn, err := setDatabaseInDataSourceName("mysql", "root:root@tcp(127.0.0.1:3306)/", "mydb")
+	assert.NoError(err)
+	name, _ := databaseNameFromDataSourceName("mysql", dsn)
+	assert.Equal("mydb", name)
+
+	// mysql - clear database
+	dsn, err = setDatabaseInDataSourceName("mysql", "root:root@tcp(127.0.0.1:3306)/mydb", "")
+	assert.NoError(err)
+	name, _ = databaseNameFromDataSourceName("mysql", dsn)
+	assert.Equal("", name)
+
+	// pgx - set database
+	dsn, err = setDatabaseInDataSourceName("pgx", "postgres://user:pw@127.0.0.1:5432/", "mydb")
+	assert.NoError(err)
+	name, _ = databaseNameFromDataSourceName("pgx", dsn)
+	assert.Equal("mydb", name)
+
+	// pgx - clear database
+	dsn, err = setDatabaseInDataSourceName("pgx", "postgres://user:pw@127.0.0.1:5432/mydb", "")
+	assert.NoError(err)
+	name, _ = databaseNameFromDataSourceName("pgx", dsn)
+	assert.Equal("", name)
+
+	// mssql - set database
+	dsn, err = setDatabaseInDataSourceName("mssql", "sqlserver://user:pw@127.0.0.1:1433", "mydb")
+	assert.NoError(err)
+	name, _ = databaseNameFromDataSourceName("mssql", dsn)
+	assert.Equal("mydb", name)
+
+	// mssql - clear database
+	dsn, err = setDatabaseInDataSourceName("mssql", "sqlserver://user:pw@127.0.0.1:1433?database=mydb", "")
+	assert.NoError(err)
+	name, _ = databaseNameFromDataSourceName("mssql", dsn)
+	assert.Equal("", name)
+
+	// empty dsn
+	_, err = setDatabaseInDataSourceName("mysql", "", "mydb")
+	assert.Error(err)
+
+	// unsupported driver
+	_, err = setDatabaseInDataSourceName("sqlite", "file.db", "mydb")
+	assert.Error(err)
+}
+
+func TestDB_ConformArgPlaceholders_NoArgs(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	db := &DB{driverName: "pgx"}
+	stmt := `SELECT * FROM foo WHERE id=1`
+	assert.Equal(stmt, db.ConformArgPlaceholders(stmt))
+}
+
+func TestDB_ConformArgPlaceholders_NonPgx(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// MySQL driver should return the statement unchanged
+	db := &DB{driverName: "mysql"}
+	stmt := `SELECT * FROM foo WHERE id=? AND name=?`
+	assert.Equal(stmt, db.ConformArgPlaceholders(stmt))
+
+	// MSSQL driver should also return unchanged
+	db = &DB{driverName: "mssql"}
+	assert.Equal(stmt, db.ConformArgPlaceholders(stmt))
+}
+
+func TestDB_NowUTC(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	db := &DB{driverName: "mysql"}
+	assert.Equal("UTC_TIMESTAMP(3)", db.NowUTC())
+
+	db = &DB{driverName: "pgx"}
+	assert.Equal("(NOW() AT TIME ZONE 'UTC')", db.NowUTC())
+
+	db = &DB{driverName: "mssql"}
+	assert.Equal("SYSUTCDATETIME()", db.NowUTC())
+
+	db = &DB{driverName: "unknown"}
+	assert.Equal("", db.NowUTC())
+}
+
+func TestDB_RegexpTextSearch(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// MySQL
+	db := &DB{driverName: "mysql"}
+	assert.Equal("''"+` REGEXP ?`, db.RegexpTextSearch())
+	assert.Equal("name REGEXP ?", db.RegexpTextSearch("name"))
+	assert.Equal("CONCAT_WS(' ',name,email) REGEXP ?", db.RegexpTextSearch("name", "email"))
+
+	// Postgres
+	db = &DB{driverName: "pgx"}
+	assert.Equal("REGEXP_LIKE('', ?, 'i')", db.RegexpTextSearch())
+	assert.Equal("REGEXP_LIKE(name, ?, 'i')", db.RegexpTextSearch("name"))
+	assert.Equal("REGEXP_LIKE(CONCAT_WS(' ',name,email), ?, 'i')", db.RegexpTextSearch("name", "email"))
+
+	// MSSQL
+	db = &DB{driverName: "mssql"}
+	assert.Equal("REGEXP_LIKE('', ?, 'i')", db.RegexpTextSearch())
+	assert.Equal("REGEXP_LIKE(name, ?, 'i')", db.RegexpTextSearch("name"))
+
+	// Unknown driver
+	db = &DB{driverName: "unknown"}
+	assert.Equal("", db.RegexpTextSearch("name"))
+}
+
+func TestDB_Nullify(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// Zero values should return nil
+	assert.Nil(Nullify(""))
+	assert.Nil(Nullify(0))
+	assert.Nil(Nullify(false))
+	assert.Nil(Nullify(time.Time{}))
+
+	// Non-zero values should return the value itself
+	assert.Equal("hello", Nullify("hello"))
+	assert.Equal(42, Nullify(42))
+	assert.Equal(true, Nullify(true))
+	now := time.Now()
+	assert.Equal(now, Nullify(now))
+}
+
+func TestDB_Nullable(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	var s string
+	n := Nullable(&s)
+
+	// Simulate scanning a value
+	n.V = "hello"
+	n.Valid = true
+	err := ApplyBindings(n)
+	assert.NoError(err)
+	assert.Equal("hello", s)
+
+	// Simulate scanning a NULL (Valid=false, V is zero)
+	s = "previous"
+	n2 := Nullable(&s)
+	n2.Valid = false
+	err = ApplyBindings(n2)
+	assert.NoError(err)
+	assert.Equal("", s)
+}
+
+func TestDB_Bind(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	var tags []string
+	b := Bind(func(value string) error {
+		return json.Unmarshal([]byte(value), &tags)
+	})
+
+	// Simulate scanning a JSON string
+	b.V = `["a","b","c"]`
+	b.Valid = true
+	err := ApplyBindings(b)
+	assert.NoError(err)
+	assert.Len(tags, 3)
+	assert.Equal("a", tags[0])
+	assert.Equal("b", tags[1])
+	assert.Equal("c", tags[2])
+}
+
+func TestDB_Bind_Error(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	b := Bind(func(value string) error {
+		return json.Unmarshal([]byte(value), &[]int{})
+	})
+
+	// Simulate scanning invalid JSON
+	b.V = `not-json`
+	b.Valid = true
+	err := ApplyBindings(b)
+	assert.Error(err)
+}
+
+func TestDB_ApplyBindings_NoBindings(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// ApplyBindings should be safe with non-binder args
+	var x int
+	var s string
+	err := ApplyBindings(&x, &s)
+	assert.NoError(err)
+
+	// Empty args
+	err = ApplyBindings()
+	assert.NoError(err)
+}
+
+func TestDB_DriverName(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	db := &DB{driverName: "mysql"}
+	assert.Equal("mysql", db.DriverName())
+
+	db = &DB{driverName: "pgx"}
+	assert.Equal("pgx", db.DriverName())
+}
+
+func TestDB_CloseNil(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// Close on nil DB should not panic
+	var db *DB
+	err := db.Close()
+	assert.NoError(err)
+}
+
+func TestDB_OpenEmptyDSN(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	_, err := Open("mysql", "")
+	assert.Error(err)
+}
+
+func TestDB_OpenInferDriverFails(t *testing.T) {
+	t.Parallel()
+	assert := testarossa.For(t)
+
+	// Unrecognizable DSN without explicit driver
+	_, err := Open("", "some-unknown-connection-string")
+	assert.Error(err)
 }