Moved Apply back to query mods

* Added tests for query file

boil/qs/query_mods.go

@@ -4,6 +4,12 @@ import "github.com/pobri19/sqlboiler/boil"
 
 type QueryMod func(q *boil.Query)
 
+func Apply(q *boil.Query, mods ...QueryMod) {
+	for _, mod := range mods {
+		mod(q)
+	}
+}
+
 func Limit(limit int) QueryMod {
 	return func(q *boil.Query) {
 		boil.SetLimit(q, limit)

boil/query.go

@@ -91,14 +91,8 @@ func ExecQueryAll(q *Query) (*sql.Rows, error) {
 	return nil, nil
 }
 
-func Apply(q *Query, mods ...func(q *Query)) {
+func SetDelete(q *Query) {
-	for _, mod := range mods {
+	q.delete = true
-		mod(q)
-	}
-}
-
-func SetDelete(q *Query, flag bool) {
-	q.delete = flag
 }
 
 func SetUpdate(q *Query, cols map[string]interface{}) {

boil/query_test.go

@@ -1,6 +1,7 @@
 package boil
 
 import (
+	"database/sql"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -55,132 +56,240 @@ func TestBuildQuery(t *testing.T) {
 	}
 }
 
-// func TestApply(t *testing.T) {
+func TestExecQuery(t *testing.T) {
-// 	t.Parallel()
+	t.Parallel()
-//
+}
-// 	q := &boil.Query{}
+
-// 	qfn1 := Limit(10)
+func TestExecQueryOne(t *testing.T) {
-// 	qfn2 := Where("x > $1 AND y > $2", 5, 3)
+	t.Parallel()
-//
+}
-// 	q.Apply(qfn1, qfn2)
+
-//
+func TestExecQueryAll(t *testing.T) {
-// 	expect1 := 10
+	t.Parallel()
-// 	if q.limit != expect1 {
+}
-// 		t.Errorf("Expected %d, got %d", expect1, q.limit)
+
-// 	}
+func TestSetLimit(t *testing.T) {
-//
+	t.Parallel()
-// 	expect2 := "x > $1 AND y > $2"
+
-// 	if len(q.where) != 1 {
+	q := &Query{}
-// 		t.Errorf("Expected %d where slices, got %d", len(q.where))
+	SetLimit(q, 10)
-// 	}
+
-//
+	expect := 10
-// 	expect := "x > $1 AND y > $2"
+	if q.limit != expect {
-// 	if q.where[0].clause != expect2 {
+		t.Errorf("Expected %d, got %d", expect, q.limit)
-// 		t.Errorf("Expected %s, got %s", expect, q.where)
+	}
-// 	}
+}
-//
+
-// 	if len(q.where[0].args) != 2 {
+func TestSetWhere(t *testing.T) {
-// 		t.Errorf("Expected %d args, got %d", 2, len(q.where[0].args))
+	t.Parallel()
-// 	}
+
-//
+	q := &Query{}
-// 	if q.where[0].args[0].(int) != 5 || q.where[0].args[1].(int) != 3 {
+	SetWhere(q, "x > $1 AND y > $2", 5, 3)
-// 		t.Errorf("Args not set correctly, expected 5 & 3, got: %#v", q.where[0].args)
+
-// 	}
+	if len(q.where) != 1 {
-// }
+		t.Errorf("Expected %d where slices, got %d", len(q.where))
-//
+	}
-// func TestLimit(t *testing.T) {
+
-// 	t.Parallel()
+	expect := "x > $1 AND y > $2"
-//
+	if q.where[0].clause != expect {
-// 	q := &boil.Query{}
+		t.Errorf("Expected %s, got %s", expect, q.where)
-// 	qfn := Limit(10)
+	}
-//
+
-// 	qfn(q)
+	if len(q.where[0].args) != 2 {
-//
+		t.Errorf("Expected %d args, got %d", 2, len(q.where[0].args))
-// 	expect := 10
+	}
-// 	if q.limit != expect {
+
-// 		t.Errorf("Expected %d, got %d", expect, q.limit)
+	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 TestWhere(t *testing.T) {
+
-// 	t.Parallel()
+func TestSetGroupBy(t *testing.T) {
-//
+	t.Parallel()
-// 	q := &boil.Query{}
+
-// 	qfn := Where("x > $1 AND y > $2", 5, 3)
+	q := &Query{}
-//
+	SetGroupBy(q, "col1, col2")
-// 	qfn(q)
+
-//
+	expect := "col1, col2"
-// 	if len(q.where) != 1 {
+	if len(q.groupBy) != 1 && q.groupBy[0] != expect {
-// 		t.Errorf("Expected %d where slices, got %d", len(q.where))
+		t.Errorf("Expected %s, got %s", expect, q.groupBy[0])
-// 	}
+	}
-//
+}
-// 	expect := "x > $1 AND y > $2"
+
-// 	if q.where[0].clause != expect {
+func TestSetOrderBy(t *testing.T) {
-// 		t.Errorf("Expected %s, got %s", expect, q.where)
+	t.Parallel()
-// 	}
+
-//
+	q := &Query{}
-// 	if len(q.where[0].args) != 2 {
+	SetOrderBy(q, "col1 desc, col2 asc")
-// 		t.Errorf("Expected %d args, got %d", 2, len(q.where[0].args))
+
-// 	}
+	expect := "col1 desc, col2 asc"
-//
+	if len(q.orderBy) != 1 && q.orderBy[0] != expect {
-// 	if q.where[0].args[0].(int) != 5 || q.where[0].args[1].(int) != 3 {
+		t.Errorf("Expected %s, got %s", expect, q.orderBy[0])
-// 		t.Errorf("Args not set correctly, expected 5 & 3, got: %#v", q.where[0].args)
+	}
-// 	}
+}
-// }
+
-//
+func TestSetHaving(t *testing.T) {
-// func TestGroupBy(t *testing.T) {
+	t.Parallel()
-// 	t.Parallel()
+
-//
+	q := &Query{}
-// 	q := &boil.Query{}
+	SetHaving(q, "count(orders.order_id) > 10")
-// 	qfn := GroupBy("col1, col2")
+
-//
+	expect := "count(orders.order_id) > 10"
-// 	qfn(q)
+	if len(q.having) != 1 && q.having[0] != expect {
-//
+		t.Errorf("Expected %s, got %s", expect, q.having[0])
-// 	expect := "col1, col2"
+	}
-// 	if len(q.groupBy) != 1 && q.groupBy[0] != expect {
+}
-// 		t.Errorf("Expected %s, got %s", expect, q.groupBy[0])
+
-// 	}
+func TestSetFrom(t *testing.T) {
-// }
+	t.Parallel()
-//
+
-// func TestOrderBy(t *testing.T) {
+	q := &Query{}
-// 	t.Parallel()
+	SetFrom(q, "videos a, orders b")
-//
+
-// 	q := &boil.Query{}
+	expect := "videos a, orders b"
-// 	qfn := OrderBy("col1 desc, col2 asc")
+	if q.from != expect {
-//
+		t.Errorf("Expected %s, got %s", expect, q.from)
-// 	qfn(q)
+	}
-//
+}
-// 	expect := "col1 desc, col2 asc"
+
-// 	if len(q.orderBy) != 1 && q.orderBy[0] != expect {
+func TestSetDelete(t *testing.T) {
-// 		t.Errorf("Expected %s, got %s", expect, q.orderBy[0])
+	t.Parallel()
-// 	}
+
-// }
+	q := &Query{}
-//
+	SetDelete(q)
-// func TestHaving(t *testing.T) {
+
-// 	t.Parallel()
+	if q.delete != true {
-//
+		t.Errorf("Expected %t, got %t", true, q.delete)
-// 	q := &boil.Query{}
+	}
-// 	qfn := Having("count(orders.order_id) > 10")
+}
-//
+
-// 	qfn(q)
+func TestSetUpdate(t *testing.T) {
-//
+	t.Parallel()
-// 	expect := "count(orders.order_id) > 10"
+
-// 	if len(q.having) != 1 && q.having[0] != expect {
+	q := &Query{}
-// 		t.Errorf("Expected %s, got %s", expect, q.having[0])
+	SetUpdate(q, map[string]interface{}{"col1": 1, "col2": 2})
-// 	}
+
-// }
+	if len(q.update) != 2 {
-//
+		t.Errorf("Expected len 2, got %d", len(q.update))
-// func TestFrom(t *testing.T) {
+	}
-// 	t.Parallel()
+
-//
+	if q.update["col1"] != 1 && q.update["col2"] != 2 {
-// 	q := &boil.Query{}
+		t.Errorf("Value misatch: %#v", q.update)
-// 	qfn := From("videos a, orders b")
+	}
-//
+}
-// 	qfn(q)
+
-//
+func TestSetExecutor(t *testing.T) {
-// 	expect := "videos a, orders b"
+	t.Parallel()
-// 	if q.from != expect {
+
-// 		t.Errorf("Expected %s, got %s", expect, q.from)
+	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)
+	}
+}

cmds/templates/singles/helpers.tpl

@@ -8,8 +8,8 @@ func NewQuery(mods ...qs.QueryMod) *boil.Query {
 
 // NewQueryX initializes a new Query using the passed in QueryMods
 func NewQueryX(executor boil.Executor, mods ...qs.QueryMod) *boil.Query {
-	q := &Query{executor: executor}
+	q := &boil.Query{executor: executor}
-	q.Apply(mods...)
+	qs.Apply(q, mods...)
 
 	return q
 }