From 72a71df8318e8b45147f9b55bbec49c9a302f76e Mon Sep 17 00:00:00 2001 From: Gustavo Chain Date: Fri, 22 Apr 2016 16:08:08 +0200 Subject: [PATCH] Test statements --- sqlhooks_test.go | 184 +++++++++++++++++++++++++++-------------------- 1 file changed, 105 insertions(+), 79 deletions(-) diff --git a/sqlhooks_test.go b/sqlhooks_test.go index 2f04fe6..eb12d06 100644 --- a/sqlhooks_test.go +++ b/sqlhooks_test.go @@ -2,46 +2,122 @@ package sqlhooks import ( "database/sql" + "fmt" "sort" "testing" + "time" ) +func openDBWithHooks(t *testing.T, hooks *Hooks) *sql.DB { + // First, we connect directly using `test` driver + if db, err := sql.Open("test", "db"); err != nil { + t.Fatalf("sql.Open: %v", err) + return nil + } else { + if _, err := db.Exec("WIPE"); err != nil { + t.Fatalf("WIPE: %v", err) + return nil + } + + if _, err := db.Exec("CREATE|t|f1=string,f2=string"); err != nil { + t.Fatalf("CREATE: %v", err) + return nil + } + } + + // Now, return a db handler using hooked driver + driver := NewDriver("test", hooks) + driverName := fmt.Sprintf("test-%d", time.Now().UnixNano()) + Register(driverName, driver) + + db, err := sql.Open(driverName, "db") + if err != nil { + t.Fatalf("sql.Open: %v", err) + return nil + } + + return db +} + func TestHooks(t *testing.T) { - expectedExec := "CREATE|t|f1=string" - expectedQuery := "SELECT|t|f1|" + tests := []struct { + op string + query string + args []interface{} + }{ + {"exec", "INSERT|t|f1=?,f2=?", []interface{}{"foo", "bar"}}, + {"query", "SELECT|t|f1|f1=?,f2=?", []interface{}{"foo", "bar"}}, + {"query", "SELECT|t|f1|", []interface{}{}}, + {"stmt.query", "SELECT|t|f1|", nil}, + {"stmt.exec", "INSERT|t|f1=?", []interface{}{"x"}}, + } - hooks := Hooks{ - Query: func(query string, args ...interface{}) func() { - if query != expectedQuery { - t.Errorf("query = `%s`, expected `%s`", query, expectedQuery) + for _, test := range tests { + done := false + assert := func(query string, args ...interface{}) func() { + // Query Assertions + if query != test.query { + t.Errorf("query = `%s`, expected `%s`", query, test.query) } - return nil - }, - Exec: func(query string, args ...interface{}) func() { - if query != expectedExec { - t.Errorf("query = `%s`, expected `%s`", query, expectedExec) + + if test.args == nil { + test.args = []interface{}{} } - return nil - }, - } - Register("test_1", NewDriver("test", &hooks)) - db, _ := sql.Open("test_1", "d1") - db.Exec(expectedExec) - db.Query(expectedQuery) + // Arguments assertions + if len(args) != len(test.args) { + t.Errorf("Expected args: %d, got %d", len(test.args), len(args)) + } + for i, _ := range test.args { + if args[i] != test.args[i] { + t.Errorf("arg[%d] == %#v, got %#v", i, test.args[i], args[i]) + } + } + + return func() { + done = true + } + } + db := openDBWithHooks(t, &Hooks{Query: assert, Exec: assert}) + + switch test.op { + case "query": + if _, err := db.Query(test.query, test.args...); err != nil { + t.Errorf("query: %v", err) + } + case "exec": + if _, err := db.Exec(test.query, test.args...); err != nil { + t.Errorf("exec: %v", err) + } + case "stmt.query": + if stmt, err := db.Prepare(test.query); err != nil { + t.Errorf("prepare: %v", err) + } else { + if _, err := stmt.Query(test.args...); err != nil { + t.Errorf("prepared query: %v", err) + } + } + case "stmt.exec": + if stmt, err := db.Prepare(test.query); err != nil { + t.Errorf("prepare: %v", err) + } else { + if _, err := stmt.Exec(test.args...); err != nil { + t.Errorf("prepared exec: %v", err) + } + } + } - execStmt, _ := db.Prepare(expectedExec) - execStmt.Exec() + if done == false { + t.Errorf("Expected %s cancelation to be completed", test.op) + } - queryStmt, _ := db.Prepare(expectedQuery) - queryStmt.Query() + } } func TestEmptyHooks(t *testing.T) { - Register("test_2", NewDriver("test", &Hooks{})) - db, _ := sql.Open("test_2", "d2") + db := openDBWithHooks(t, &Hooks{}) - if _, err := db.Exec("CREATE|t|f1=string"); err != nil { + if _, err := db.Exec("INSERT|t|f1=?", "foo"); err != nil { t.Fatalf("Exec: %v\n", err) } @@ -51,13 +127,11 @@ func TestEmptyHooks(t *testing.T) { } func TestCreateInsertAndSelect(t *testing.T) { - Register("test_3", NewDriver("test", &Hooks{})) - db, _ := sql.Open("test_3", "d3") + db := openDBWithHooks(t, &Hooks{}) - db.Exec("CREATE|t|f1=string") - db.Exec("INSERT|t|f1=?", "a") - db.Exec("INSERT|t|f1=?", "b") - db.Exec("INSERT|t|f1=?", "c") + db.Exec("INSERT|t|f1=?,f2=?", "a", "1") + db.Exec("INSERT|t|f1=?,f2=?", "b", "2") + db.Exec("INSERT|t|f1=?,f2=?", "c", "3") rows, _ := db.Query("SELECT|t|f1|") var fs []string @@ -78,51 +152,3 @@ func TestCreateInsertAndSelect(t *testing.T) { } } } - -func TestCancelationsAreExecuted(t *testing.T) { - var executed bool - - exec := func() { - executed = true - } - hooks := Hooks{ - Exec: func(string, ...interface{}) func() { return exec }, - Query: func(string, ...interface{}) func() { return exec }, - } - - Register("test_4", NewDriver("test", &hooks)) - - db, _ := sql.Open("test_4", "d4") - - executed = false - db.Exec("CREATE|t1|f1=string") - if executed == false { - t.Error("Exec hook wasn't executed") - } - - executed = false - db.Query("SELECT|t1|f1|") - if executed == false { - t.Error("Query hook wasn't executed") - } - - executed = false - stmt, err := db.Prepare("CREATE|t2|f1=string") - if err != nil { - t.Fatalf("Prepare: %v\n", err) - } - stmt.Exec() - if executed == false { - t.Error("Prepared Exec Hook wasn't executed") - } - - executed = false - stmt, err = db.Prepare("SELECT|t2|f1|") - if err != nil { - t.Fatalf("Prepare: %v\n", err) - } - stmt.Query() - if executed == false { - t.Error("Prepared Exec Hook wasn't executed") - } -}