summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/go-sql-driver/mysql/driver_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/go-sql-driver/mysql/driver_test.go')
-rw-r--r--vendor/github.com/go-sql-driver/mysql/driver_test.go940
1 files changed, 737 insertions, 203 deletions
diff --git a/vendor/github.com/go-sql-driver/mysql/driver_test.go b/vendor/github.com/go-sql-driver/mysql/driver_test.go
index ef5b371cf..78e68f5d0 100644
--- a/vendor/github.com/go-sql-driver/mysql/driver_test.go
+++ b/vendor/github.com/go-sql-driver/mysql/driver_test.go
@@ -9,12 +9,14 @@
package mysql
import (
+ "bytes"
"crypto/tls"
"database/sql"
"database/sql/driver"
"fmt"
"io"
"io/ioutil"
+ "log"
"net"
"net/url"
"os"
@@ -74,23 +76,75 @@ type DBTest struct {
db *sql.DB
}
+func runTestsWithMultiStatement(t *testing.T, dsn string, tests ...func(dbt *DBTest)) {
+ if !available {
+ t.Skipf("MySQL server not running on %s", netAddr)
+ }
+
+ dsn += "&multiStatements=true"
+ var db *sql.DB
+ if _, err := ParseDSN(dsn); err != errInvalidDSNUnsafeCollation {
+ db, err = sql.Open("mysql", dsn)
+ if err != nil {
+ t.Fatalf("error connecting: %s", err.Error())
+ }
+ defer db.Close()
+ }
+
+ dbt := &DBTest{t, db}
+ for _, test := range tests {
+ test(dbt)
+ dbt.db.Exec("DROP TABLE IF EXISTS test")
+ }
+}
+
func runTests(t *testing.T, dsn string, tests ...func(dbt *DBTest)) {
if !available {
- t.Skipf("MySQL-Server not running on %s", netAddr)
+ t.Skipf("MySQL server not running on %s", netAddr)
}
db, err := sql.Open("mysql", dsn)
if err != nil {
- t.Fatalf("Error connecting: %s", err.Error())
+ t.Fatalf("error connecting: %s", err.Error())
}
defer db.Close()
db.Exec("DROP TABLE IF EXISTS test")
+ dsn2 := dsn + "&interpolateParams=true"
+ var db2 *sql.DB
+ if _, err := ParseDSN(dsn2); err != errInvalidDSNUnsafeCollation {
+ db2, err = sql.Open("mysql", dsn2)
+ if err != nil {
+ t.Fatalf("error connecting: %s", err.Error())
+ }
+ defer db2.Close()
+ }
+
+ dsn3 := dsn + "&multiStatements=true"
+ var db3 *sql.DB
+ if _, err := ParseDSN(dsn3); err != errInvalidDSNUnsafeCollation {
+ db3, err = sql.Open("mysql", dsn3)
+ if err != nil {
+ t.Fatalf("error connecting: %s", err.Error())
+ }
+ defer db3.Close()
+ }
+
dbt := &DBTest{t, db}
+ dbt2 := &DBTest{t, db2}
+ dbt3 := &DBTest{t, db3}
for _, test := range tests {
test(dbt)
dbt.db.Exec("DROP TABLE IF EXISTS test")
+ if db2 != nil {
+ test(dbt2)
+ dbt2.db.Exec("DROP TABLE IF EXISTS test")
+ }
+ if db3 != nil {
+ test(dbt3)
+ dbt3.db.Exec("DROP TABLE IF EXISTS test")
+ }
}
}
@@ -98,13 +152,13 @@ func (dbt *DBTest) fail(method, query string, err error) {
if len(query) > 300 {
query = "[query too large to print]"
}
- dbt.Fatalf("Error on %s %s: %s", method, query, err.Error())
+ dbt.Fatalf("error on %s %s: %s", method, query, err.Error())
}
func (dbt *DBTest) mustExec(query string, args ...interface{}) (res sql.Result) {
res, err := dbt.db.Exec(query, args...)
if err != nil {
- dbt.fail("Exec", query, err)
+ dbt.fail("exec", query, err)
}
return res
}
@@ -112,11 +166,22 @@ func (dbt *DBTest) mustExec(query string, args ...interface{}) (res sql.Result)
func (dbt *DBTest) mustQuery(query string, args ...interface{}) (rows *sql.Rows) {
rows, err := dbt.db.Query(query, args...)
if err != nil {
- dbt.fail("Query", query, err)
+ dbt.fail("query", query, err)
}
return rows
}
+func TestEmptyQuery(t *testing.T) {
+ runTests(t, dsn, func(dbt *DBTest) {
+ // just a comment, no query
+ rows := dbt.mustQuery("--")
+ // will hang before #255
+ if rows.Next() {
+ dbt.Errorf("next on rows must be false")
+ }
+ })
+}
+
func TestCRUD(t *testing.T) {
runTests(t, dsn, func(dbt *DBTest) {
// Create Table
@@ -136,7 +201,7 @@ func TestCRUD(t *testing.T) {
dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
}
if count != 1 {
- dbt.Fatalf("Expected 1 affected row, got %d", count)
+ dbt.Fatalf("expected 1 affected row, got %d", count)
}
id, err := res.LastInsertId()
@@ -144,7 +209,7 @@ func TestCRUD(t *testing.T) {
dbt.Fatalf("res.LastInsertId() returned error: %s", err.Error())
}
if id != 0 {
- dbt.Fatalf("Expected InsertID 0, got %d", id)
+ dbt.Fatalf("expected InsertId 0, got %d", id)
}
// Read
@@ -169,7 +234,7 @@ func TestCRUD(t *testing.T) {
dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
}
if count != 1 {
- dbt.Fatalf("Expected 1 affected row, got %d", count)
+ dbt.Fatalf("expected 1 affected row, got %d", count)
}
// Check Update
@@ -194,7 +259,7 @@ func TestCRUD(t *testing.T) {
dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
}
if count != 1 {
- dbt.Fatalf("Expected 1 affected row, got %d", count)
+ dbt.Fatalf("expected 1 affected row, got %d", count)
}
// Check for unexpected rows
@@ -204,8 +269,52 @@ func TestCRUD(t *testing.T) {
dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
}
if count != 0 {
- dbt.Fatalf("Expected 0 affected row, got %d", count)
+ dbt.Fatalf("expected 0 affected row, got %d", count)
+ }
+ })
+}
+
+func TestMultiQuery(t *testing.T) {
+ runTestsWithMultiStatement(t, dsn, func(dbt *DBTest) {
+ // Create Table
+ dbt.mustExec("CREATE TABLE `test` (`id` int(11) NOT NULL, `value` int(11) NOT NULL) ")
+
+ // Create Data
+ res := dbt.mustExec("INSERT INTO test VALUES (1, 1)")
+ count, err := res.RowsAffected()
+ if err != nil {
+ dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
+ }
+ if count != 1 {
+ dbt.Fatalf("expected 1 affected row, got %d", count)
+ }
+
+ // Update
+ res = dbt.mustExec("UPDATE test SET value = 3 WHERE id = 1; UPDATE test SET value = 4 WHERE id = 1; UPDATE test SET value = 5 WHERE id = 1;")
+ count, err = res.RowsAffected()
+ if err != nil {
+ dbt.Fatalf("res.RowsAffected() returned error: %s", err.Error())
+ }
+ if count != 1 {
+ dbt.Fatalf("expected 1 affected row, got %d", count)
+ }
+
+ // Read
+ var out int
+ rows := dbt.mustQuery("SELECT value FROM test WHERE id=1;")
+ if rows.Next() {
+ rows.Scan(&out)
+ if 5 != out {
+ dbt.Errorf("5 != %d", out)
+ }
+
+ if rows.Next() {
+ dbt.Error("unexpected data")
+ }
+ } else {
+ dbt.Error("no data")
}
+
})
}
@@ -256,7 +365,7 @@ func TestInt(t *testing.T) {
})
}
-func TestFloat(t *testing.T) {
+func TestFloat32(t *testing.T) {
runTests(t, dsn, func(dbt *DBTest) {
types := [2]string{"FLOAT", "DOUBLE"}
in := float32(42.23)
@@ -279,6 +388,52 @@ func TestFloat(t *testing.T) {
})
}
+func TestFloat64(t *testing.T) {
+ runTests(t, dsn, func(dbt *DBTest) {
+ types := [2]string{"FLOAT", "DOUBLE"}
+ var expected float64 = 42.23
+ var out float64
+ var rows *sql.Rows
+ for _, v := range types {
+ dbt.mustExec("CREATE TABLE test (value " + v + ")")
+ dbt.mustExec("INSERT INTO test VALUES (42.23)")
+ rows = dbt.mustQuery("SELECT value FROM test")
+ if rows.Next() {
+ rows.Scan(&out)
+ if expected != out {
+ dbt.Errorf("%s: %g != %g", v, expected, out)
+ }
+ } else {
+ dbt.Errorf("%s: no data", v)
+ }
+ dbt.mustExec("DROP TABLE IF EXISTS test")
+ }
+ })
+}
+
+func TestFloat64Placeholder(t *testing.T) {
+ runTests(t, dsn, func(dbt *DBTest) {
+ types := [2]string{"FLOAT", "DOUBLE"}
+ var expected float64 = 42.23
+ var out float64
+ var rows *sql.Rows
+ for _, v := range types {
+ dbt.mustExec("CREATE TABLE test (id int, value " + v + ")")
+ dbt.mustExec("INSERT INTO test VALUES (1, 42.23)")
+ rows = dbt.mustQuery("SELECT value FROM test WHERE id = ?", 1)
+ if rows.Next() {
+ rows.Scan(&out)
+ if expected != out {
+ dbt.Errorf("%s: %g != %g", v, expected, out)
+ }
+ } else {
+ dbt.Errorf("%s: no data", v)
+ }
+ dbt.mustExec("DROP TABLE IF EXISTS test")
+ }
+ })
+}
+
func TestString(t *testing.T) {
runTests(t, dsn, func(dbt *DBTest) {
types := [6]string{"CHAR(255)", "VARCHAR(255)", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT"}
@@ -327,97 +482,281 @@ func TestString(t *testing.T) {
})
}
-func TestDateTime(t *testing.T) {
- type testmode struct {
- selectSuffix string
- args []interface{}
+type timeTests struct {
+ dbtype string
+ tlayout string
+ tests []timeTest
+}
+
+type timeTest struct {
+ s string // leading "!": do not use t as value in queries
+ t time.Time
+}
+
+type timeMode byte
+
+func (t timeMode) String() string {
+ switch t {
+ case binaryString:
+ return "binary:string"
+ case binaryTime:
+ return "binary:time.Time"
+ case textString:
+ return "text:string"
+ }
+ panic("unsupported timeMode")
+}
+
+func (t timeMode) Binary() bool {
+ switch t {
+ case binaryString, binaryTime:
+ return true
}
- type timetest struct {
- in interface{}
- sOut string
- tOut time.Time
- tIsZero bool
+ return false
+}
+
+const (
+ binaryString timeMode = iota
+ binaryTime
+ textString
+)
+
+func (t timeTest) genQuery(dbtype string, mode timeMode) string {
+ var inner string
+ if mode.Binary() {
+ inner = "?"
+ } else {
+ inner = `"%s"`
}
- type tester func(dbt *DBTest, rows *sql.Rows,
- test *timetest, sqltype, resulttype, mode string)
- type setup struct {
- vartype string
- dsnSuffix string
- test tester
+ return `SELECT cast(` + inner + ` as ` + dbtype + `)`
+}
+
+func (t timeTest) run(dbt *DBTest, dbtype, tlayout string, mode timeMode) {
+ var rows *sql.Rows
+ query := t.genQuery(dbtype, mode)
+ switch mode {
+ case binaryString:
+ rows = dbt.mustQuery(query, t.s)
+ case binaryTime:
+ rows = dbt.mustQuery(query, t.t)
+ case textString:
+ query = fmt.Sprintf(query, t.s)
+ rows = dbt.mustQuery(query)
+ default:
+ panic("unsupported mode")
}
- var (
- modes = map[string]*testmode{
- "text": &testmode{},
- "binary": &testmode{" WHERE 1 = ?", []interface{}{1}},
- }
- timetests = map[string][]*timetest{
- "DATE": {
- {sDate, sDate, tDate, false},
- {sDate0, sDate0, tDate0, true},
- {tDate, sDate, tDate, false},
- {tDate0, sDate0, tDate0, true},
- },
- "DATETIME": {
- {sDateTime, sDateTime, tDateTime, false},
- {sDateTime0, sDateTime0, tDate0, true},
- {tDateTime, sDateTime, tDateTime, false},
- {tDate0, sDateTime0, tDate0, true},
- },
- }
- setups = []*setup{
- {"string", "&parseTime=false", func(
- dbt *DBTest, rows *sql.Rows, test *timetest, sqltype, resulttype, mode string) {
- var sOut string
- if err := rows.Scan(&sOut); err != nil {
- dbt.Errorf("%s (%s %s): %s", sqltype, resulttype, mode, err.Error())
- } else if test.sOut != sOut {
- dbt.Errorf("%s (%s %s): %s != %s", sqltype, resulttype, mode, test.sOut, sOut)
- }
- }},
- {"time.Time", "&parseTime=true", func(
- dbt *DBTest, rows *sql.Rows, test *timetest, sqltype, resulttype, mode string) {
- var tOut time.Time
- if err := rows.Scan(&tOut); err != nil {
- dbt.Errorf("%s (%s %s): %s", sqltype, resulttype, mode, err.Error())
- } else if test.tOut != tOut || test.tIsZero != tOut.IsZero() {
- dbt.Errorf("%s (%s %s): %s [%t] != %s [%t]", sqltype, resulttype, mode, test.tOut, test.tIsZero, tOut, tOut.IsZero())
- }
- }},
+ defer rows.Close()
+ var err error
+ if !rows.Next() {
+ err = rows.Err()
+ if err == nil {
+ err = fmt.Errorf("no data")
}
- )
+ dbt.Errorf("%s [%s]: %s", dbtype, mode, err)
+ return
+ }
+ var dst interface{}
+ err = rows.Scan(&dst)
+ if err != nil {
+ dbt.Errorf("%s [%s]: %s", dbtype, mode, err)
+ return
+ }
+ switch val := dst.(type) {
+ case []uint8:
+ str := string(val)
+ if str == t.s {
+ return
+ }
+ if mode.Binary() && dbtype == "DATETIME" && len(str) == 26 && str[:19] == t.s {
+ // a fix mainly for TravisCI:
+ // accept full microsecond resolution in result for DATETIME columns
+ // where the binary protocol was used
+ return
+ }
+ dbt.Errorf("%s [%s] to string: expected %q, got %q",
+ dbtype, mode,
+ t.s, str,
+ )
+ case time.Time:
+ if val == t.t {
+ return
+ }
+ dbt.Errorf("%s [%s] to string: expected %q, got %q",
+ dbtype, mode,
+ t.s, val.Format(tlayout),
+ )
+ default:
+ fmt.Printf("%#v\n", []interface{}{dbtype, tlayout, mode, t.s, t.t})
+ dbt.Errorf("%s [%s]: unhandled type %T (is '%v')",
+ dbtype, mode,
+ val, val,
+ )
+ }
+}
- var s *setup
- testTime := func(dbt *DBTest) {
- var rows *sql.Rows
- for sqltype, tests := range timetests {
- dbt.mustExec("CREATE TABLE test (value " + sqltype + ")")
- for _, test := range tests {
- for mode, q := range modes {
- dbt.mustExec("TRUNCATE test")
- dbt.mustExec("INSERT INTO test VALUES (?)", test.in)
- rows = dbt.mustQuery("SELECT value FROM test"+q.selectSuffix, q.args...)
- if rows.Next() {
- s.test(dbt, rows, test, sqltype, s.vartype, mode)
- } else {
- if err := rows.Err(); err != nil {
- dbt.Errorf("%s (%s %s): %s",
- sqltype, s.vartype, mode, err.Error())
- } else {
- dbt.Errorf("%s (%s %s): no data",
- sqltype, s.vartype, mode)
- }
+func TestDateTime(t *testing.T) {
+ afterTime := func(t time.Time, d string) time.Time {
+ dur, err := time.ParseDuration(d)
+ if err != nil {
+ panic(err)
+ }
+ return t.Add(dur)
+ }
+ // NOTE: MySQL rounds DATETIME(x) up - but that's not included in the tests
+ format := "2006-01-02 15:04:05.999999"
+ t0 := time.Time{}
+ tstr0 := "0000-00-00 00:00:00.000000"
+ testcases := []timeTests{
+ {"DATE", format[:10], []timeTest{
+ {t: time.Date(2011, 11, 20, 0, 0, 0, 0, time.UTC)},
+ {t: t0, s: tstr0[:10]},
+ }},
+ {"DATETIME", format[:19], []timeTest{
+ {t: time.Date(2011, 11, 20, 21, 27, 37, 0, time.UTC)},
+ {t: t0, s: tstr0[:19]},
+ }},
+ {"DATETIME(0)", format[:21], []timeTest{
+ {t: time.Date(2011, 11, 20, 21, 27, 37, 0, time.UTC)},
+ {t: t0, s: tstr0[:19]},
+ }},
+ {"DATETIME(1)", format[:21], []timeTest{
+ {t: time.Date(2011, 11, 20, 21, 27, 37, 100000000, time.UTC)},
+ {t: t0, s: tstr0[:21]},
+ }},
+ {"DATETIME(6)", format, []timeTest{
+ {t: time.Date(2011, 11, 20, 21, 27, 37, 123456000, time.UTC)},
+ {t: t0, s: tstr0},
+ }},
+ {"TIME", format[11:19], []timeTest{
+ {t: afterTime(t0, "12345s")},
+ {s: "!-12:34:56"},
+ {s: "!-838:59:59"},
+ {s: "!838:59:59"},
+ {t: t0, s: tstr0[11:19]},
+ }},
+ {"TIME(0)", format[11:19], []timeTest{
+ {t: afterTime(t0, "12345s")},
+ {s: "!-12:34:56"},
+ {s: "!-838:59:59"},
+ {s: "!838:59:59"},
+ {t: t0, s: tstr0[11:19]},
+ }},
+ {"TIME(1)", format[11:21], []timeTest{
+ {t: afterTime(t0, "12345600ms")},
+ {s: "!-12:34:56.7"},
+ {s: "!-838:59:58.9"},
+ {s: "!838:59:58.9"},
+ {t: t0, s: tstr0[11:21]},
+ }},
+ {"TIME(6)", format[11:], []timeTest{
+ {t: afterTime(t0, "1234567890123000ns")},
+ {s: "!-12:34:56.789012"},
+ {s: "!-838:59:58.999999"},
+ {s: "!838:59:58.999999"},
+ {t: t0, s: tstr0[11:]},
+ }},
+ }
+ dsns := []string{
+ dsn + "&parseTime=true",
+ dsn + "&parseTime=false",
+ }
+ for _, testdsn := range dsns {
+ runTests(t, testdsn, func(dbt *DBTest) {
+ microsecsSupported := false
+ zeroDateSupported := false
+ var rows *sql.Rows
+ var err error
+ rows, err = dbt.db.Query(`SELECT cast("00:00:00.1" as TIME(1)) = "00:00:00.1"`)
+ if err == nil {
+ rows.Scan(&microsecsSupported)
+ rows.Close()
+ }
+ rows, err = dbt.db.Query(`SELECT cast("0000-00-00" as DATE) = "0000-00-00"`)
+ if err == nil {
+ rows.Scan(&zeroDateSupported)
+ rows.Close()
+ }
+ for _, setups := range testcases {
+ if t := setups.dbtype; !microsecsSupported && t[len(t)-1:] == ")" {
+ // skip fractional second tests if unsupported by server
+ continue
+ }
+ for _, setup := range setups.tests {
+ allowBinTime := true
+ if setup.s == "" {
+ // fill time string whereever Go can reliable produce it
+ setup.s = setup.t.Format(setups.tlayout)
+ } else if setup.s[0] == '!' {
+ // skip tests using setup.t as source in queries
+ allowBinTime = false
+ // fix setup.s - remove the "!"
+ setup.s = setup.s[1:]
+ }
+ if !zeroDateSupported && setup.s == tstr0[:len(setup.s)] {
+ // skip disallowed 0000-00-00 date
+ continue
+ }
+ setup.run(dbt, setups.dbtype, setups.tlayout, textString)
+ setup.run(dbt, setups.dbtype, setups.tlayout, binaryString)
+ if allowBinTime {
+ setup.run(dbt, setups.dbtype, setups.tlayout, binaryTime)
}
}
}
- dbt.mustExec("DROP TABLE IF EXISTS test")
- }
+ })
}
+}
- timeDsn := dsn + "&sql_mode=ALLOW_INVALID_DATES"
- for _, v := range setups {
- s = v
- runTests(t, timeDsn+s.dsnSuffix, testTime)
- }
+func TestTimestampMicros(t *testing.T) {
+ format := "2006-01-02 15:04:05.999999"
+ f0 := format[:19]
+ f1 := format[:21]
+ f6 := format[:26]
+ runTests(t, dsn, func(dbt *DBTest) {
+ // check if microseconds are supported.
+ // Do not use timestamp(x) for that check - before 5.5.6, x would mean display width
+ // and not precision.
+ // Se last paragraph at http://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html
+ microsecsSupported := false
+ if rows, err := dbt.db.Query(`SELECT cast("00:00:00.1" as TIME(1)) = "00:00:00.1"`); err == nil {
+ rows.Scan(&microsecsSupported)
+ rows.Close()
+ }
+ if !microsecsSupported {
+ // skip test
+ return
+ }
+ _, err := dbt.db.Exec(`
+ CREATE TABLE test (
+ value0 TIMESTAMP NOT NULL DEFAULT '` + f0 + `',
+ value1 TIMESTAMP(1) NOT NULL DEFAULT '` + f1 + `',
+ value6 TIMESTAMP(6) NOT NULL DEFAULT '` + f6 + `'
+ )`,
+ )
+ if err != nil {
+ dbt.Error(err)
+ }
+ defer dbt.mustExec("DROP TABLE IF EXISTS test")
+ dbt.mustExec("INSERT INTO test SET value0=?, value1=?, value6=?", f0, f1, f6)
+ var res0, res1, res6 string
+ rows := dbt.mustQuery("SELECT * FROM test")
+ if !rows.Next() {
+ dbt.Errorf("test contained no selectable values")
+ }
+ err = rows.Scan(&res0, &res1, &res6)
+ if err != nil {
+ dbt.Error(err)
+ }
+ if res0 != f0 {
+ dbt.Errorf("expected %q, got %q", f0, res0)
+ }
+ if res1 != f1 {
+ dbt.Errorf("expected %q, got %q", f1, res1)
+ }
+ if res6 != f6 {
+ dbt.Errorf("expected %q, got %q", f6, res6)
+ }
+ })
}
func TestNULL(t *testing.T) {
@@ -441,14 +780,14 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if nb.Valid {
- dbt.Error("Valid NullBool which should be invalid")
+ dbt.Error("valid NullBool which should be invalid")
}
// Valid
if err = nonNullStmt.QueryRow().Scan(&nb); err != nil {
dbt.Fatal(err)
}
if !nb.Valid {
- dbt.Error("Invalid NullBool which should be valid")
+ dbt.Error("invalid NullBool which should be valid")
} else if nb.Bool != true {
dbt.Errorf("Unexpected NullBool value: %t (should be true)", nb.Bool)
}
@@ -460,16 +799,16 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if nf.Valid {
- dbt.Error("Valid NullFloat64 which should be invalid")
+ dbt.Error("valid NullFloat64 which should be invalid")
}
// Valid
if err = nonNullStmt.QueryRow().Scan(&nf); err != nil {
dbt.Fatal(err)
}
if !nf.Valid {
- dbt.Error("Invalid NullFloat64 which should be valid")
+ dbt.Error("invalid NullFloat64 which should be valid")
} else if nf.Float64 != float64(1) {
- dbt.Errorf("Unexpected NullFloat64 value: %f (should be 1.0)", nf.Float64)
+ dbt.Errorf("unexpected NullFloat64 value: %f (should be 1.0)", nf.Float64)
}
// NullInt64
@@ -479,16 +818,16 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if ni.Valid {
- dbt.Error("Valid NullInt64 which should be invalid")
+ dbt.Error("valid NullInt64 which should be invalid")
}
// Valid
if err = nonNullStmt.QueryRow().Scan(&ni); err != nil {
dbt.Fatal(err)
}
if !ni.Valid {
- dbt.Error("Invalid NullInt64 which should be valid")
+ dbt.Error("invalid NullInt64 which should be valid")
} else if ni.Int64 != int64(1) {
- dbt.Errorf("Unexpected NullInt64 value: %d (should be 1)", ni.Int64)
+ dbt.Errorf("unexpected NullInt64 value: %d (should be 1)", ni.Int64)
}
// NullString
@@ -498,16 +837,16 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if ns.Valid {
- dbt.Error("Valid NullString which should be invalid")
+ dbt.Error("valid NullString which should be invalid")
}
// Valid
if err = nonNullStmt.QueryRow().Scan(&ns); err != nil {
dbt.Fatal(err)
}
if !ns.Valid {
- dbt.Error("Invalid NullString which should be valid")
+ dbt.Error("invalid NullString which should be valid")
} else if ns.String != `1` {
- dbt.Error("Unexpected NullString value:" + ns.String + " (should be `1`)")
+ dbt.Error("unexpected NullString value:" + ns.String + " (should be `1`)")
}
// nil-bytes
@@ -517,14 +856,14 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if b != nil {
- dbt.Error("Non-nil []byte wich should be nil")
+ dbt.Error("non-nil []byte wich should be nil")
}
// Read non-nil
if err = nonNullStmt.QueryRow().Scan(&b); err != nil {
dbt.Fatal(err)
}
if b == nil {
- dbt.Error("Nil []byte wich should be non-nil")
+ dbt.Error("nil []byte wich should be non-nil")
}
// Insert nil
b = nil
@@ -533,7 +872,7 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if !success {
- dbt.Error("Inserting []byte(nil) as NULL failed")
+ dbt.Error("inserting []byte(nil) as NULL failed")
}
// Check input==output with input==nil
b = nil
@@ -541,7 +880,7 @@ func TestNULL(t *testing.T) {
dbt.Fatal(err)
}
if b != nil {
- dbt.Error("Non-nil echo from nil input")
+ dbt.Error("non-nil echo from nil input")
}
// Check input==output with input!=nil
b = []byte("")
@@ -570,6 +909,49 @@ func TestNULL(t *testing.T) {
})
}
+func TestUint64(t *testing.T) {
+ const (
+ u0 = uint64(0)
+ uall = ^u0
+ uhigh = uall >> 1
+ utop = ^uhigh
+ s0 = int64(0)
+ sall = ^s0
+ shigh = int64(uhigh)
+ stop = ^shigh
+ )
+ runTests(t, dsn, func(dbt *DBTest) {
+ stmt, err := dbt.db.Prepare(`SELECT ?, ?, ? ,?, ?, ?, ?, ?`)
+ if err != nil {
+ dbt.Fatal(err)
+ }
+ defer stmt.Close()
+ row := stmt.QueryRow(
+ u0, uhigh, utop, uall,
+ s0, shigh, stop, sall,
+ )
+
+ var ua, ub, uc, ud uint64
+ var sa, sb, sc, sd int64
+
+ err = row.Scan(&ua, &ub, &uc, &ud, &sa, &sb, &sc, &sd)
+ if err != nil {
+ dbt.Fatal(err)
+ }
+ switch {
+ case ua != u0,
+ ub != uhigh,
+ uc != utop,
+ ud != uall,
+ sa != s0,
+ sb != shigh,
+ sc != stop,
+ sd != sall:
+ dbt.Fatal("unexpected result value")
+ }
+ })
+}
+
func TestLongData(t *testing.T) {
runTests(t, dsn, func(dbt *DBTest) {
var maxAllowedPacketSize int
@@ -660,7 +1042,7 @@ func TestLoadData(t *testing.T) {
dbt.Fatalf("%d != %d", i, id)
}
if values[i-1] != value {
- dbt.Fatalf("%s != %s", values[i-1], value)
+ dbt.Fatalf("%q != %q", values[i-1], value)
}
}
err = rows.Err()
@@ -669,7 +1051,7 @@ func TestLoadData(t *testing.T) {
}
if i != 4 {
- dbt.Fatalf("Rows count mismatch. Got %d, want 4", i)
+ dbt.Fatalf("rows count mismatch. Got %d, want 4", i)
}
}
file, err := ioutil.TempFile("", "gotest")
@@ -685,13 +1067,13 @@ func TestLoadData(t *testing.T) {
// Local File
RegisterLocalFile(file.Name())
- dbt.mustExec(fmt.Sprintf("LOAD DATA LOCAL INFILE '%q' INTO TABLE test", file.Name()))
+ dbt.mustExec(fmt.Sprintf("LOAD DATA LOCAL INFILE %q INTO TABLE test", file.Name()))
verifyLoadDataResult()
// negative test
_, err = dbt.db.Exec("LOAD DATA LOCAL INFILE 'doesnotexist' INTO TABLE test")
if err == nil {
- dbt.Fatal("Load non-existent file didn't fail")
- } else if err.Error() != "Local File 'doesnotexist' is not registered. Use the DSN parameter 'allowAllFiles=true' to allow all files" {
+ dbt.Fatal("load non-existent file didn't fail")
+ } else if err.Error() != "local file 'doesnotexist' is not registered" {
dbt.Fatal(err.Error())
}
@@ -711,7 +1093,7 @@ func TestLoadData(t *testing.T) {
// negative test
_, err = dbt.db.Exec("LOAD DATA LOCAL INFILE 'Reader::doesnotexist' INTO TABLE test")
if err == nil {
- dbt.Fatal("Load non-existent Reader didn't fail")
+ dbt.Fatal("load non-existent Reader didn't fail")
} else if err.Error() != "Reader 'doesnotexist' is not registered" {
dbt.Fatal(err.Error())
}
@@ -765,7 +1147,18 @@ func TestFoundRows(t *testing.T) {
func TestStrict(t *testing.T) {
// ALLOW_INVALID_DATES to get rid of stricter modes - we want to test for warnings, not errors
- relaxedDsn := dsn + "&sql_mode=ALLOW_INVALID_DATES"
+ relaxedDsn := dsn + "&sql_mode='ALLOW_INVALID_DATES,NO_AUTO_CREATE_USER'"
+ // make sure the MySQL version is recent enough with a separate connection
+ // before running the test
+ conn, err := MySQLDriver{}.Open(relaxedDsn)
+ if conn != nil {
+ conn.Close()
+ }
+ if me, ok := err.(*MySQLError); ok && me.Number == 1231 {
+ // Error 1231: Variable 'sql_mode' can't be set to the value of 'ALLOW_INVALID_DATES'
+ // => skip test, MySQL server version is too old
+ return
+ }
runTests(t, relaxedDsn, func(dbt *DBTest) {
dbt.mustExec("CREATE TABLE test (a TINYINT NOT NULL, b CHAR(4))")
@@ -780,7 +1173,7 @@ func TestStrict(t *testing.T) {
var checkWarnings = func(err error, mode string, idx int) {
if err == nil {
- dbt.Errorf("Expected STRICT error on query [%s] %s", mode, queries[idx].in)
+ dbt.Errorf("expected STRICT error on query [%s] %s", mode, queries[idx].in)
}
if warnings, ok := err.(MySQLWarnings); ok {
@@ -789,18 +1182,18 @@ func TestStrict(t *testing.T) {
codes[i] = warnings[i].Code
}
if len(codes) != len(queries[idx].codes) {
- dbt.Errorf("Unexpected STRICT error count on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes)
+ dbt.Errorf("unexpected STRICT error count on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes)
}
for i := range warnings {
if codes[i] != queries[idx].codes[i] {
- dbt.Errorf("Unexpected STRICT error codes on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes)
+ dbt.Errorf("unexpected STRICT error codes on query [%s] %s: Wanted %v, Got %v", mode, queries[idx].in, queries[idx].codes, codes)
return
}
}
} else {
- dbt.Errorf("Unexpected error on query [%s] %s: %s", mode, queries[idx].in, err.Error())
+ dbt.Errorf("unexpected error on query [%s] %s: %s", mode, queries[idx].in, err.Error())
}
}
@@ -816,7 +1209,7 @@ func TestStrict(t *testing.T) {
for i := range queries {
stmt, err = dbt.db.Prepare(queries[i].in)
if err != nil {
- dbt.Errorf("Error on preparing query %s: %s", queries[i].in, err.Error())
+ dbt.Errorf("error on preparing query %s: %s", queries[i].in, err.Error())
}
_, err = stmt.Exec()
@@ -824,7 +1217,7 @@ func TestStrict(t *testing.T) {
err = stmt.Close()
if err != nil {
- dbt.Errorf("Error on closing stmt for query %s: %s", queries[i].in, err.Error())
+ dbt.Errorf("error on closing stmt for query %s: %s", queries[i].in, err.Error())
}
}
})
@@ -834,9 +1227,9 @@ func TestTLS(t *testing.T) {
tlsTest := func(dbt *DBTest) {
if err := dbt.db.Ping(); err != nil {
if err == ErrNoTLS {
- dbt.Skip("Server does not support TLS")
+ dbt.Skip("server does not support TLS")
} else {
- dbt.Fatalf("Error on Ping: %s", err.Error())
+ dbt.Fatalf("error on Ping: %s", err.Error())
}
}
@@ -849,7 +1242,7 @@ func TestTLS(t *testing.T) {
}
if value == nil {
- dbt.Fatal("No Cipher")
+ dbt.Fatal("no Cipher")
}
}
}
@@ -866,42 +1259,42 @@ func TestTLS(t *testing.T) {
func TestReuseClosedConnection(t *testing.T) {
// this test does not use sql.database, it uses the driver directly
if !available {
- t.Skipf("MySQL-Server not running on %s", netAddr)
+ t.Skipf("MySQL server not running on %s", netAddr)
}
md := &MySQLDriver{}
conn, err := md.Open(dsn)
if err != nil {
- t.Fatalf("Error connecting: %s", err.Error())
+ t.Fatalf("error connecting: %s", err.Error())
}
stmt, err := conn.Prepare("DO 1")
if err != nil {
- t.Fatalf("Error preparing statement: %s", err.Error())
+ t.Fatalf("error preparing statement: %s", err.Error())
}
_, err = stmt.Exec(nil)
if err != nil {
- t.Fatalf("Error executing statement: %s", err.Error())
+ t.Fatalf("error executing statement: %s", err.Error())
}
err = conn.Close()
if err != nil {
- t.Fatalf("Error closing connection: %s", err.Error())
+ t.Fatalf("error closing connection: %s", err.Error())
}
defer func() {
if err := recover(); err != nil {
- t.Errorf("Panic after reusing a closed connection: %v", err)
+ t.Errorf("panic after reusing a closed connection: %v", err)
}
}()
_, err = stmt.Exec(nil)
if err != nil && err != driver.ErrBadConn {
- t.Errorf("Unexpected error '%s', expected '%s'",
+ t.Errorf("unexpected error '%s', expected '%s'",
err.Error(), driver.ErrBadConn.Error())
}
}
func TestCharset(t *testing.T) {
if !available {
- t.Skipf("MySQL-Server not running on %s", netAddr)
+ t.Skipf("MySQL server not running on %s", netAddr)
}
mustSetCharset := func(charsetParam, expected string) {
@@ -910,14 +1303,14 @@ func TestCharset(t *testing.T) {
defer rows.Close()
if !rows.Next() {
- dbt.Fatalf("Error getting connection charset: %s", rows.Err())
+ dbt.Fatalf("error getting connection charset: %s", rows.Err())
}
var got string
rows.Scan(&got)
if got != expected {
- dbt.Fatalf("Expected connection charset %s but got %s", expected, got)
+ dbt.Fatalf("expected connection charset %s but got %s", expected, got)
}
})
}
@@ -939,14 +1332,14 @@ func TestFailingCharset(t *testing.T) {
_, err := dbt.db.Exec("SELECT 1")
if err == nil {
dbt.db.Close()
- t.Fatalf("Connection must not succeed without a valid charset")
+ t.Fatalf("connection must not succeed without a valid charset")
}
})
}
func TestCollation(t *testing.T) {
if !available {
- t.Skipf("MySQL-Server not running on %s", netAddr)
+ t.Skipf("MySQL server not running on %s", netAddr)
}
defaultCollation := "utf8_general_ci"
@@ -956,7 +1349,7 @@ func TestCollation(t *testing.T) {
"latin1_general_ci",
"binary",
"utf8_unicode_ci",
- "utf8mb4_general_ci",
+ "cp1257_bin",
}
for _, collation := range testCollations {
@@ -976,12 +1369,36 @@ func TestCollation(t *testing.T) {
}
if got != expected {
- dbt.Fatalf("Expected connection collation %s but got %s", expected, got)
+ dbt.Fatalf("expected connection collation %s but got %s", expected, got)
}
})
}
}
+func TestColumnsWithAlias(t *testing.T) {
+ runTests(t, dsn+"&columnsWithAlias=true", func(dbt *DBTest) {
+ rows := dbt.mustQuery("SELECT 1 AS A")
+ defer rows.Close()
+ cols, _ := rows.Columns()
+ if len(cols) != 1 {
+ t.Fatalf("expected 1 column, got %d", len(cols))
+ }
+ if cols[0] != "A" {
+ t.Fatalf("expected column name \"A\", got \"%s\"", cols[0])
+ }
+ rows.Close()
+
+ rows = dbt.mustQuery("SELECT * FROM (SELECT 1 AS one) AS A")
+ cols, _ = rows.Columns()
+ if len(cols) != 1 {
+ t.Fatalf("expected 1 column, got %d", len(cols))
+ }
+ if cols[0] != "A.one" {
+ t.Fatalf("expected column name \"A.one\", got \"%s\"", cols[0])
+ }
+ })
+}
+
func TestRawBytesResultExceedsBuffer(t *testing.T) {
runTests(t, dsn, func(dbt *DBTest) {
// defaultBufSize from buffer.go
@@ -1011,26 +1428,26 @@ func TestTimezoneConversion(t *testing.T) {
// Insert local time into database (should be converted)
usCentral, _ := time.LoadLocation("US/Central")
- now := time.Now().In(usCentral)
- dbt.mustExec("INSERT INTO test VALUE (?)", now)
+ reftime := time.Date(2014, 05, 30, 18, 03, 17, 0, time.UTC).In(usCentral)
+ dbt.mustExec("INSERT INTO test VALUE (?)", reftime)
// Retrieve time from DB
rows := dbt.mustQuery("SELECT ts FROM test")
if !rows.Next() {
- dbt.Fatal("Didn't get any rows out")
+ dbt.Fatal("did not get any rows out")
}
- var nowDB time.Time
- err := rows.Scan(&nowDB)
+ var dbTime time.Time
+ err := rows.Scan(&dbTime)
if err != nil {
dbt.Fatal("Err", err)
}
// Check that dates match
- if now.Unix() != nowDB.Unix() {
- dbt.Errorf("Times don't match.\n")
- dbt.Errorf(" Now(%v)=%v\n", usCentral, now)
- dbt.Errorf(" Now(UTC)=%v\n", nowDB)
+ if reftime.Unix() != dbTime.Unix() {
+ dbt.Errorf("times do not match.\n")
+ dbt.Errorf(" Now(%v)=%v\n", usCentral, reftime)
+ dbt.Errorf(" Now(UTC)=%v\n", dbTime)
}
}
@@ -1039,42 +1456,6 @@ func TestTimezoneConversion(t *testing.T) {
}
}
-// This tests for https://github.com/go-sql-driver/mysql/pull/139
-//
-// An extra (invisible) nil byte was being added to the beginning of positive
-// time strings.
-func TestTimeSign(t *testing.T) {
- runTests(t, dsn, func(dbt *DBTest) {
- var sTimes = []struct {
- value string
- fieldType string
- }{
- {"12:34:56", "TIME"},
- {"-12:34:56", "TIME"},
- // As described in http://dev.mysql.com/doc/refman/5.6/en/fractional-seconds.html
- // they *should* work, but only in 5.6+.
- // { "12:34:56.789", "TIME(3)" },
- // { "-12:34:56.789", "TIME(3)" },
- }
-
- for _, sTime := range sTimes {
- dbt.db.Exec("DROP TABLE IF EXISTS test")
- dbt.mustExec("CREATE TABLE test (id INT, time_field " + sTime.fieldType + ")")
- dbt.mustExec("INSERT INTO test (id, time_field) VALUES(1, '" + sTime.value + "')")
- rows := dbt.mustQuery("SELECT time_field FROM test WHERE id = ?", 1)
- if rows.Next() {
- var oTime string
- rows.Scan(&oTime)
- if oTime != sTime.value {
- dbt.Errorf(`time values differ: got %q, expected %q.`, oTime, sTime.value)
- }
- } else {
- dbt.Error("expecting at least one row.")
- }
- }
- })
-}
-
// Special cases
func TestRowsClose(t *testing.T) {
@@ -1090,7 +1471,7 @@ func TestRowsClose(t *testing.T) {
}
if rows.Next() {
- dbt.Fatal("Unexpected row after rows.Close()")
+ dbt.Fatal("unexpected row after rows.Close()")
}
err = rows.Err()
@@ -1122,7 +1503,7 @@ func TestCloseStmtBeforeRows(t *testing.T) {
}
if !rows.Next() {
- dbt.Fatal("Getting row failed")
+ dbt.Fatal("getting row failed")
} else {
err = rows.Err()
if err != nil {
@@ -1132,7 +1513,7 @@ func TestCloseStmtBeforeRows(t *testing.T) {
var out bool
err = rows.Scan(&out)
if err != nil {
- dbt.Fatalf("Error on rows.Scan(): %s", err.Error())
+ dbt.Fatalf("error on rows.Scan(): %s", err.Error())
}
if out != true {
dbt.Errorf("true != %t", out)
@@ -1168,7 +1549,7 @@ func TestStmtMultiRows(t *testing.T) {
// 1
if !rows1.Next() {
- dbt.Fatal("1st rows1.Next failed")
+ dbt.Fatal("first rows1.Next failed")
} else {
err = rows1.Err()
if err != nil {
@@ -1177,7 +1558,7 @@ func TestStmtMultiRows(t *testing.T) {
err = rows1.Scan(&out)
if err != nil {
- dbt.Fatalf("Error on rows.Scan(): %s", err.Error())
+ dbt.Fatalf("error on rows.Scan(): %s", err.Error())
}
if out != true {
dbt.Errorf("true != %t", out)
@@ -1185,7 +1566,7 @@ func TestStmtMultiRows(t *testing.T) {
}
if !rows2.Next() {
- dbt.Fatal("1st rows2.Next failed")
+ dbt.Fatal("first rows2.Next failed")
} else {
err = rows2.Err()
if err != nil {
@@ -1194,7 +1575,7 @@ func TestStmtMultiRows(t *testing.T) {
err = rows2.Scan(&out)
if err != nil {
- dbt.Fatalf("Error on rows.Scan(): %s", err.Error())
+ dbt.Fatalf("error on rows.Scan(): %s", err.Error())
}
if out != true {
dbt.Errorf("true != %t", out)
@@ -1203,7 +1584,7 @@ func TestStmtMultiRows(t *testing.T) {
// 2
if !rows1.Next() {
- dbt.Fatal("2nd rows1.Next failed")
+ dbt.Fatal("second rows1.Next failed")
} else {
err = rows1.Err()
if err != nil {
@@ -1212,14 +1593,14 @@ func TestStmtMultiRows(t *testing.T) {
err = rows1.Scan(&out)
if err != nil {
- dbt.Fatalf("Error on rows.Scan(): %s", err.Error())
+ dbt.Fatalf("error on rows.Scan(): %s", err.Error())
}
if out != false {
dbt.Errorf("false != %t", out)
}
if rows1.Next() {
- dbt.Fatal("Unexpected row on rows1")
+ dbt.Fatal("unexpected row on rows1")
}
err = rows1.Close()
if err != nil {
@@ -1228,7 +1609,7 @@ func TestStmtMultiRows(t *testing.T) {
}
if !rows2.Next() {
- dbt.Fatal("2nd rows2.Next failed")
+ dbt.Fatal("second rows2.Next failed")
} else {
err = rows2.Err()
if err != nil {
@@ -1237,14 +1618,14 @@ func TestStmtMultiRows(t *testing.T) {
err = rows2.Scan(&out)
if err != nil {
- dbt.Fatalf("Error on rows.Scan(): %s", err.Error())
+ dbt.Fatalf("error on rows.Scan(): %s", err.Error())
}
if out != false {
dbt.Errorf("false != %t", out)
}
if rows2.Next() {
- dbt.Fatal("Unexpected row on rows2")
+ dbt.Fatal("unexpected row on rows2")
}
err = rows2.Close()
if err != nil {
@@ -1289,7 +1670,7 @@ func TestConcurrent(t *testing.T) {
if err != nil {
dbt.Fatalf("%s", err.Error())
}
- dbt.Logf("Testing up to %d concurrent connections \r\n", max)
+ dbt.Logf("testing up to %d concurrent connections \r\n", max)
var remaining, succeeded int32 = int32(max), 0
@@ -1313,7 +1694,7 @@ func TestConcurrent(t *testing.T) {
if err != nil {
if err.Error() != "Error 1040: Too many connections" {
- fatalf("Error on Conn %d: %s", id, err.Error())
+ fatalf("error on conn %d: %s", id, err.Error())
}
return
}
@@ -1321,13 +1702,13 @@ func TestConcurrent(t *testing.T) {
// keep the connection busy until all connections are open
for remaining > 0 {
if _, err = tx.Exec("DO 1"); err != nil {
- fatalf("Error on Conn %d: %s", id, err.Error())
+ fatalf("error on conn %d: %s", id, err.Error())
return
}
}
if err = tx.Commit(); err != nil {
- fatalf("Error on Conn %d: %s", id, err.Error())
+ fatalf("error on conn %d: %s", id, err.Error())
return
}
@@ -1343,14 +1724,14 @@ func TestConcurrent(t *testing.T) {
dbt.Fatal(fatalError)
}
- dbt.Logf("Reached %d concurrent connections\r\n", succeeded)
+ dbt.Logf("reached %d concurrent connections\r\n", succeeded)
})
}
// Tests custom dial functions
func TestCustomDial(t *testing.T) {
if !available {
- t.Skipf("MySQL-Server not running on %s", netAddr)
+ t.Skipf("MySQL server not running on %s", netAddr)
}
// our custom dial function which justs wraps net.Dial here
@@ -1360,11 +1741,164 @@ func TestCustomDial(t *testing.T) {
db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@mydial(%s)/%s?timeout=30s&strict=true", user, pass, addr, dbname))
if err != nil {
- t.Fatalf("Error connecting: %s", err.Error())
+ t.Fatalf("error connecting: %s", err.Error())
}
defer db.Close()
if _, err = db.Exec("DO 1"); err != nil {
- t.Fatalf("Connection failed: %s", err.Error())
+ t.Fatalf("connection failed: %s", err.Error())
+ }
+}
+
+func TestSQLInjection(t *testing.T) {
+ createTest := func(arg string) func(dbt *DBTest) {
+ return func(dbt *DBTest) {
+ dbt.mustExec("CREATE TABLE test (v INTEGER)")
+ dbt.mustExec("INSERT INTO test VALUES (?)", 1)
+
+ var v int
+ // NULL can't be equal to anything, the idea here is to inject query so it returns row
+ // This test verifies that escapeQuotes and escapeBackslash are working properly
+ err := dbt.db.QueryRow("SELECT v FROM test WHERE NULL = ?", arg).Scan(&v)
+ if err == sql.ErrNoRows {
+ return // success, sql injection failed
+ } else if err == nil {
+ dbt.Errorf("sql injection successful with arg: %s", arg)
+ } else {
+ dbt.Errorf("error running query with arg: %s; err: %s", arg, err.Error())
+ }
+ }
+ }
+
+ dsns := []string{
+ dsn,
+ dsn + "&sql_mode='NO_BACKSLASH_ESCAPES,NO_AUTO_CREATE_USER'",
+ }
+ for _, testdsn := range dsns {
+ runTests(t, testdsn, createTest("1 OR 1=1"))
+ runTests(t, testdsn, createTest("' OR '1'='1"))
+ }
+}
+
+// Test if inserted data is correctly retrieved after being escaped
+func TestInsertRetrieveEscapedData(t *testing.T) {
+ testData := func(dbt *DBTest) {
+ dbt.mustExec("CREATE TABLE test (v VARCHAR(255))")
+
+ // All sequences that are escaped by escapeQuotes and escapeBackslash
+ v := "foo \x00\n\r\x1a\"'\\"
+ dbt.mustExec("INSERT INTO test VALUES (?)", v)
+
+ var out string
+ err := dbt.db.QueryRow("SELECT v FROM test").Scan(&out)
+ if err != nil {
+ dbt.Fatalf("%s", err.Error())
+ }
+
+ if out != v {
+ dbt.Errorf("%q != %q", out, v)
+ }
+ }
+
+ dsns := []string{
+ dsn,
+ dsn + "&sql_mode='NO_BACKSLASH_ESCAPES,NO_AUTO_CREATE_USER'",
}
+ for _, testdsn := range dsns {
+ runTests(t, testdsn, testData)
+ }
+}
+
+func TestUnixSocketAuthFail(t *testing.T) {
+ runTests(t, dsn, func(dbt *DBTest) {
+ // Save the current logger so we can restore it.
+ oldLogger := errLog
+
+ // Set a new logger so we can capture its output.
+ buffer := bytes.NewBuffer(make([]byte, 0, 64))
+ newLogger := log.New(buffer, "prefix: ", 0)
+ SetLogger(newLogger)
+
+ // Restore the logger.
+ defer SetLogger(oldLogger)
+
+ // Make a new DSN that uses the MySQL socket file and a bad password, which
+ // we can make by simply appending any character to the real password.
+ badPass := pass + "x"
+ socket := ""
+ if prot == "unix" {
+ socket = addr
+ } else {
+ // Get socket file from MySQL.
+ err := dbt.db.QueryRow("SELECT @@socket").Scan(&socket)
+ if err != nil {
+ t.Fatalf("error on SELECT @@socket: %s", err.Error())
+ }
+ }
+ t.Logf("socket: %s", socket)
+ badDSN := fmt.Sprintf("%s:%s@unix(%s)/%s?timeout=30s&strict=true", user, badPass, socket, dbname)
+ db, err := sql.Open("mysql", badDSN)
+ if err != nil {
+ t.Fatalf("error connecting: %s", err.Error())
+ }
+ defer db.Close()
+
+ // Connect to MySQL for real. This will cause an auth failure.
+ err = db.Ping()
+ if err == nil {
+ t.Error("expected Ping() to return an error")
+ }
+
+ // The driver should not log anything.
+ if actual := buffer.String(); actual != "" {
+ t.Errorf("expected no output, got %q", actual)
+ }
+ })
+}
+
+// See Issue #422
+func TestInterruptBySignal(t *testing.T) {
+ runTestsWithMultiStatement(t, dsn, func(dbt *DBTest) {
+ dbt.mustExec(`
+ DROP PROCEDURE IF EXISTS test_signal;
+ CREATE PROCEDURE test_signal(ret INT)
+ BEGIN
+ SELECT ret;
+ SIGNAL SQLSTATE
+ '45001'
+ SET
+ MESSAGE_TEXT = "an error",
+ MYSQL_ERRNO = 45001;
+ END
+ `)
+ defer dbt.mustExec("DROP PROCEDURE test_signal")
+
+ var val int
+
+ // text protocol
+ rows, err := dbt.db.Query("CALL test_signal(42)")
+ if err != nil {
+ dbt.Fatalf("error on text query: %s", err.Error())
+ }
+ for rows.Next() {
+ if err := rows.Scan(&val); err != nil {
+ dbt.Error(err)
+ } else if val != 42 {
+ dbt.Errorf("expected val to be 42")
+ }
+ }
+
+ // binary protocol
+ rows, err = dbt.db.Query("CALL test_signal(?)", 42)
+ if err != nil {
+ dbt.Fatalf("error on binary query: %s", err.Error())
+ }
+ for rows.Next() {
+ if err := rows.Scan(&val); err != nil {
+ dbt.Error(err)
+ } else if val != 42 {
+ dbt.Errorf("expected val to be 42")
+ }
+ }
+ })
}
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-06-28 06:57:31 +0000