sqlboiler/boil/query_test.go

348 lines
7.3 KiB
Go
Raw Normal View History

package boil
import (
2016-06-07 08:45:06 +02:00
"bytes"
"database/sql"
"flag"
"fmt"
"io/ioutil"
"path/filepath"
"reflect"
"testing"
"github.com/davecgh/go-spew/spew"
)
var writeGoldenFiles = flag.Bool(
2016-08-01 04:21:06 +02:00
"test.golden",
false,
"Write golden files.",
)
func TestBuildQuery(t *testing.T) {
t.Parallel()
tests := []struct {
q *Query
args []interface{}
}{
2016-08-01 04:21:06 +02:00
{&Query{from: "t"}, nil},
{&Query{from: "q", limit: 5, offset: 6}, nil},
2016-08-01 06:05:03 +02:00
{&Query{from: "q", orderBy: []string{"a ASC", "b DESC"}}, nil},
{&Query{from: "t", selectCols: []string{"count(*) as ab, thing as bd", `"stuff"`}}, nil},
}
for i, test := range tests {
filename := filepath.Join("_fixtures", fmt.Sprintf("%02d.sql", i))
out, args := buildQuery(test.q)
if *writeGoldenFiles {
err := ioutil.WriteFile(filename, []byte(out), 0664)
if err != nil {
t.Fatalf("Failed to write golden file %s: %s\n", filename, err)
}
t.Logf("wrote golden file: %s\n", filename)
continue
}
byt, err := ioutil.ReadFile(filename)
if err != nil {
t.Fatalf("Failed to read golden file %q: %v", filename, err)
}
2016-06-07 08:45:06 +02:00
if string(bytes.TrimSpace(byt)) != out {
t.Errorf("[%02d] Test failed:\nWant:\n%s\nGot:\n%s", i, byt, out)
}
if !reflect.DeepEqual(args, test.args) {
t.Errorf("[%02d] Test failed:\nWant:\n%s\nGot:\n%s", i, spew.Sdump(test.args), spew.Sdump(args))
}
}
}
func TestSetLastWhereAsOr(t *testing.T) {
t.Parallel()
q := &Query{}
SetWhere(q, "")
if q.where[0].orSeperator {
t.Errorf("Do not want or seperator")
}
SetLastWhereAsOr(q)
if len(q.where) != 1 {
t.Errorf("Want len 1")
}
if !q.where[0].orSeperator {
t.Errorf("Want or seperator")
}
SetWhere(q, "")
SetLastWhereAsOr(q)
if len(q.where) != 2 {
t.Errorf("Want len 2")
}
if q.where[0].orSeperator != true {
t.Errorf("Expected true")
}
if q.where[1].orSeperator != true {
t.Errorf("Expected true")
}
}
func TestSetLimit(t *testing.T) {
t.Parallel()
q := &Query{}
SetLimit(q, 10)
expect := 10
if q.limit != expect {
t.Errorf("Expected %d, got %d", expect, q.limit)
}
}
2016-08-01 04:21:06 +02:00
func TestSetOffset(t *testing.T) {
t.Parallel()
q := &Query{}
SetOffset(q, 10)
expect := 10
if q.offset != expect {
t.Errorf("Expected %d, got %d", expect, q.offset)
}
}
func TestSetSQL(t *testing.T) {
t.Parallel()
q := &Query{}
SetSQL(q, "select * from thing", 5, 3)
if len(q.plainSQL.args) != 2 {
t.Errorf("Expected len 2, got %d", len(q.plainSQL.args))
}
if q.plainSQL.sql != "select * from thing" {
t.Errorf("Was not expected string, got %s", q.plainSQL.sql)
}
}
func TestSetWhere(t *testing.T) {
t.Parallel()
q := &Query{}
SetWhere(q, "x > $1 AND y > $2", 5, 3)
if len(q.where) != 1 {
2016-07-08 18:39:36 +02:00
t.Errorf("Expected %d where slices, got %d", 1, len(q.where))
}
expect := "x > $1 AND y > $2"
if q.where[0].clause != expect {
2016-07-08 18:39:36 +02:00
t.Errorf("Expected %s, got %v", expect, q.where)
}
if len(q.where[0].args) != 2 {
t.Errorf("Expected %d args, got %d", 2, len(q.where[0].args))
}
if q.where[0].args[0].(int) != 5 || q.where[0].args[1].(int) != 3 {
t.Errorf("Args not set correctly, expected 5 & 3, got: %#v", q.where[0].args)
}
}
func TestSetGroupBy(t *testing.T) {
t.Parallel()
q := &Query{}
SetGroupBy(q, "col1, col2")
expect := "col1, col2"
if len(q.groupBy) != 1 && q.groupBy[0] != expect {
t.Errorf("Expected %s, got %s", expect, q.groupBy[0])
}
}
func TestSetOrderBy(t *testing.T) {
t.Parallel()
q := &Query{}
SetOrderBy(q, "col1 desc, col2 asc")
expect := "col1 desc, col2 asc"
if len(q.orderBy) != 1 && q.orderBy[0] != expect {
t.Errorf("Expected %s, got %s", expect, q.orderBy[0])
}
}
func TestSetHaving(t *testing.T) {
t.Parallel()
q := &Query{}
SetHaving(q, "count(orders.order_id) > 10")
expect := "count(orders.order_id) > 10"
if len(q.having) != 1 && q.having[0] != expect {
t.Errorf("Expected %s, got %s", expect, q.having[0])
}
}
func TestSetTable(t *testing.T) {
t.Parallel()
q := &Query{}
SetFrom(q, "videos a, orders b")
expect := "videos a, orders b"
if q.from != expect {
t.Errorf("Expected %s, got %s", expect, q.from)
}
}
func TestSetDelete(t *testing.T) {
t.Parallel()
q := &Query{}
SetDelete(q)
if q.delete != true {
t.Errorf("Expected %t, got %t", true, q.delete)
}
}
func TestSetUpdate(t *testing.T) {
t.Parallel()
q := &Query{}
SetUpdate(q, map[string]interface{}{"col1": 1, "col2": 2})
if len(q.update) != 2 {
t.Errorf("Expected len 2, got %d", len(q.update))
}
if q.update["col1"] != 1 && q.update["col2"] != 2 {
t.Errorf("Value misatch: %#v", q.update)
}
}
func TestSetExecutor(t *testing.T) {
t.Parallel()
q := &Query{}
d := &sql.DB{}
SetExecutor(q, d)
if q.executor != d {
t.Errorf("Expected executor to get set to d, but was: %#v", q.executor)
}
}
func TestSetSelect(t *testing.T) {
t.Parallel()
q := &Query{}
SetSelect(q, "col1", "col2")
if len(q.selectCols) != 2 {
t.Errorf("Expected selectCols len 2, got %d", len(q.selectCols))
}
if q.selectCols[0] != `col1` && q.selectCols[1] != `col2` {
t.Errorf("select cols value mismatch: %#v", q.selectCols)
}
}
func TestSetInnerJoin(t *testing.T) {
t.Parallel()
q := &Query{}
SetInnerJoin(q, "thing=$1 AND stuff=$2", 2, 5)
if len(q.innerJoins) != 1 {
t.Errorf("Expected len 1, got %d", len(q.innerJoins))
}
if q.innerJoins[0].on != "thing=$1 AND stuff=$2" {
t.Errorf("Got invalid innerJoin on string: %#v", q.innerJoins)
}
if len(q.innerJoins[0].args) != 2 {
t.Errorf("Expected len 2, got %d", len(q.innerJoins[0].args))
}
if q.innerJoins[0].args[0] != 2 && q.innerJoins[0].args[1] != 5 {
t.Errorf("Invalid args values, got %#v", q.innerJoins[0].args)
}
}
func TestSetOuterJoin(t *testing.T) {
t.Parallel()
q := &Query{}
SetOuterJoin(q, "thing=$1 AND stuff=$2", 2, 5)
if len(q.outerJoins) != 1 {
t.Errorf("Expected len 1, got %d", len(q.outerJoins))
}
if q.outerJoins[0].on != "thing=$1 AND stuff=$2" {
t.Errorf("Got invalid innerJoin on string: %#v", q.outerJoins)
}
if len(q.outerJoins[0].args) != 2 {
t.Errorf("Expected len 2, got %d", len(q.outerJoins[0].args))
}
if q.outerJoins[0].args[0] != 2 && q.outerJoins[0].args[1] != 5 {
t.Errorf("Invalid args values, got %#v", q.outerJoins[0].args)
}
}
func TestSetLeftOuterJoin(t *testing.T) {
t.Parallel()
q := &Query{}
SetLeftOuterJoin(q, "thing=$1 AND stuff=$2", 2, 5)
if len(q.leftOuterJoins) != 1 {
t.Errorf("Expected len 1, got %d", len(q.leftOuterJoins))
}
if q.leftOuterJoins[0].on != "thing=$1 AND stuff=$2" {
t.Errorf("Got invalid innerJoin on string: %#v", q.leftOuterJoins)
}
if len(q.leftOuterJoins[0].args) != 2 {
t.Errorf("Expected len 2, got %d", len(q.leftOuterJoins[0].args))
}
if q.leftOuterJoins[0].args[0] != 2 && q.leftOuterJoins[0].args[1] != 5 {
t.Errorf("Invalid args values, got %#v", q.leftOuterJoins[0].args)
}
}
func TestSetRightOuterJoin(t *testing.T) {
t.Parallel()
q := &Query{}
SetRightOuterJoin(q, "thing=$1 AND stuff=$2", 2, 5)
if len(q.rightOuterJoins) != 1 {
t.Errorf("Expected len 1, got %d", len(q.rightOuterJoins))
}
if q.rightOuterJoins[0].on != "thing=$1 AND stuff=$2" {
t.Errorf("Got invalid innerJoin on string: %#v", q.rightOuterJoins)
}
if len(q.rightOuterJoins[0].args) != 2 {
t.Errorf("Expected len 2, got %d", len(q.rightOuterJoins[0].args))
}
if q.rightOuterJoins[0].args[0] != 2 && q.rightOuterJoins[0].args[1] != 5 {
t.Errorf("Invalid args values, got %#v", q.rightOuterJoins[0].args)
}
}