LBRYCommunity/sqlboiler
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity

Add FilterColumnsByUnique, finish UpdateAll slice

Browse source 
* Add FilterColumnsByUnique
* Fix lots of broken tests
* Made CompareVals less stupid

Note: UpdateAll tests still broken because Unique
is not being fetched correctly for INDEX types,
it is only working for UNIQUE constraints.
This commit is contained in:
Patrick O'brien 2016-08-11 22:26:49 +10:00
parent e3f319346f
commit 18029166c0
19 changed files with 127 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
bdb/column.go
View file

@ -105,6 +105,19 @@ func FilterColumnsByValidated(columns []Column) []Column {
return cols
}
// FilterColumnsByUnique generates the list of unique columns
func FilterColumnsByUnique(columns []Column) []Column {
var cols []Column
for _, c := range columns {
if c.Unique == true {
cols = append(cols, c)
}
}
return cols
}
var (
rgxRawDefaultValue = regexp.MustCompile(`'(.*)'::`)
rgxBoolDefaultValue = regexp.MustCompile(`(?i)true|false`)

2
boil/_fixtures/10.sql
View file

@ -1 +1 @@
UPDATE thing happy, "fun", "stuff" SET ("col1", "col2", "fun"."col3") VALUES ($1, $2, $3) WHERE (aa=$4 or bb=$5) OR (cc=$6) LIMIT 5;
UPDATE thing happy, "fun", "stuff" SET ("col1", "col2", "fun"."col3") = ($1, $2, $3) WHERE (aa=$4 or bb=$5) OR (cc=$6) LIMIT 5;

3
boil/query.go
View file

@ -66,6 +66,7 @@ func ExecQuery(q *Query) (sql.Result, error) {
qs, args := buildQuery(q)
if DebugMode {
fmt.Fprintln(DebugWriter, qs)
fmt.Fprintln(DebugWriter, args)
}
return q.executor.Exec(qs, args...)
}
@ -75,6 +76,7 @@ func ExecQueryOne(q *Query) *sql.Row {
qs, args := buildQuery(q)
if DebugMode {
fmt.Fprintln(DebugWriter, qs)
fmt.Fprintln(DebugWriter, args)
}
return q.executor.QueryRow(qs, args...)
}
@ -84,6 +86,7 @@ func ExecQueryAll(q *Query) (*sql.Rows, error) {
qs, args := buildQuery(q)
if DebugMode {
fmt.Fprintln(DebugWriter, qs)
fmt.Fprintln(DebugWriter, args)
}
return q.executor.Query(qs, args...)
}

2
boil/query_builders.go
View file

@ -112,7 +112,7 @@ func buildUpdateQuery(q *Query) (*bytes.Buffer, []interface{}) {
}
buf.WriteString(fmt.Sprintf(
" SET (%s) VALUES (%s)",
" SET (%s) = (%s)",
strings.Join(cols, ", "),
strmangle.Placeholders(len(cols), 1, 1)),
)

2
imports.go
View file

@ -169,6 +169,8 @@ var defaultTestTemplateImports = imports{
`"testing"`,
`"reflect"`,
`"time"`,
`"errors"`,
`"fmt"`,
},
thirdParty: importList{
`"gopkg.in/nullbio/null.v4"`,

5
templates.go
View file

@ -156,7 +156,9 @@ var templateFunctions = template.FuncMap{
"makeStringMap": strmangle.MakeStringMap,
// Database related mangling
"whereClause": strmangle.WhereClause,
"whereClause": strmangle.WhereClause,
"identQuote": strmangle.IdentQuote,
"identQuoteSlice": strmangle.IdentQuoteSlice,
// Text helpers
"textsFromForeignKey": textsFromForeignKey,
@ -170,6 +172,7 @@ var templateFunctions = template.FuncMap{
"filterColumnsBySimpleDefault": bdb.FilterColumnsBySimpleDefault,
"filterColumnsByAutoIncrement": bdb.FilterColumnsByAutoIncrement,
"filterColumnsByValidated": bdb.FilterColumnsByValidated,
"filterColumnsByUnique": bdb.FilterColumnsByUnique,
"autoIncPrimaryKey": bdb.AutoIncPrimaryKey,
"sqlColDefinitions": bdb.SQLColDefinitions,
"sqlColDefStrings": bdb.SQLColDefStrings,

3
templates/01_types.tpl
View file

@ -5,7 +5,8 @@ var (
{{$varNameSingular}}ColumnsWithoutDefault = []string{{"{"}}{{.Table.Columns | filterColumnsByDefault false | columnNames | stringMap .StringFuncs.quoteWrap | join ","}}{{"}"}}
{{$varNameSingular}}ColumnsWithDefault = []string{{"{"}}{{.Table.Columns | filterColumnsByDefault true | columnNames | stringMap .StringFuncs.quoteWrap | join ","}}{{"}"}}
{{$varNameSingular}}ColumnsWithSimpleDefault = []string{{"{"}}{{.Table.Columns | filterColumnsBySimpleDefault | columnNames | stringMap .StringFuncs.quoteWrap | join ", "}}{{"}"}}
{{$varNameSingular}}ColumnsValidated = []string{{"{"}}{{.Table.Columns | filterColumnsByValidated | columnNames | stringMap .StringFuncs.quoteWrap | join ", "}}{{"}"}}
{{$varNameSingular}}ValidatedColumns = []string{{"{"}}{{.Table.Columns | filterColumnsByValidated | columnNames | stringMap .StringFuncs.quoteWrap | join ", "}}{{"}"}}
{{$varNameSingular}}UniqueColumns = []string{{"{"}}{{.Table.Columns | filterColumnsByUnique | columnNames | stringMap .StringFuncs.quoteWrap | join ", "}}{{"}"}}
{{$varNameSingular}}PrimaryKeyColumns = []string{{"{"}}{{.Table.PKey.Columns | stringMap .StringFuncs.quoteWrap | join ", "}}{{"}"}}
{{$varNameSingular}}AutoIncrementColumns = []string{{"{"}}{{.Table.Columns | filterColumnsByAutoIncrement true | columnNames | stringMap .StringFuncs.quoteWrap | join "," }}{{"}"}}
{{$varNameSingular}}AutoIncPrimaryKey = "{{- with autoIncPrimaryKey .Table.Columns .Table.PKey -}}{{.Name}}{{- end -}}"

3
templates/08_insert.tpl
View file

@ -80,7 +80,8 @@ func (o *{{$tableNameSingular}}) Insert(exec boil.Executor, whitelist ... string
{{end}}
if boil.DebugMode {
fmt.Fprintln(boil.DebugWriter, ins, boil.GetStructValues(o, wl...))
fmt.Fprintln(boil.DebugWriter, ins)
fmt.Fprintln(boil.DebugWriter, boil.GetStructValues(o, wl...))
}
if err != nil {

17
templates/09_update.tpl
View file

@ -121,20 +121,20 @@ func (o {{$tableNameSingular}}Slice) UpdateAll(exec boil.Executor, cols M) error
count := 0
for name, value := range cols {
colNames[count] = name
colNames[count] = strmangle.IdentQuote(name)
args = append(args, value)
count++
}
// Append all of the primary key values for each column
args = append(args, o.inPrimaryKeyArgs())
args = append(args, o.inPrimaryKeyArgs()...)
sql := fmt.Sprintf(
`UPDATE {{.Table.Name}} SET (%s) VALUES (%s) WHERE (%s) IN (%s)`,
`UPDATE {{.Table.Name}} SET (%s) = (%s) WHERE (%s) IN (%s)`,
strings.Join(colNames, ", "),
strmangle.Placeholders(len(args), 1, 1),
strings.Join({{$varNameSingular}}PrimaryKeyColumns, ","),
strmangle.Placeholders(len(o) * len({{$varNameSingular}}PrimaryKeyColumns), len(args)+1, len({{$varNameSingular}}PrimaryKeyColumns)),
strmangle.Placeholders(len(colNames), 1, 1),
strings.Join(strmangle.IdentQuoteSlice({{$varNameSingular}}PrimaryKeyColumns), ","),
strmangle.Placeholders(len(o) * len({{$varNameSingular}}PrimaryKeyColumns), len(colNames)+1, len({{$varNameSingular}}PrimaryKeyColumns)),
)
q := boil.SQL(sql, args...)
@ -145,11 +145,6 @@ func (o {{$tableNameSingular}}Slice) UpdateAll(exec boil.Executor, cols M) error
return fmt.Errorf("{{.PkgName}}: unable to update all in {{$varNameSingular}} slice: %s", err)
}
if boil.DebugMode {
fmt.Fprintln(boil.DebugWriter, sql)
fmt.Fprintln(boil.DebugWriter, )
}
return nil
}

18
templates/10_upsert.tpl
View file

@ -41,7 +41,8 @@ func (o *{{$tableNameSingular}}) Upsert(exec boil.Executor, update bool, conflic
}
if boil.DebugMode {
fmt.Fprintln(boil.DebugWriter, query, boil.GetStructValues(o, columns.whitelist...))
fmt.Fprintln(boil.DebugWriter, query)
fmt.Fprintln(boil.DebugWriter, boil.GetStructValues(o, columns.whitelist...))
}
if err != nil {
@ -90,8 +91,9 @@ func (o *{{$tableNameSingular}}) generateConflictColumns(columns ...string) []st
func (o *{{$tableNameSingular}}) generateUpsertQuery(update bool, columns upsertData) string {
var set, query string
columns.conflict = strmangle.IdentQuoteSlice(columns.conflict)
columns.whitelist = strmangle.IdentQuoteSlice(columns.whitelist)
conflict := strmangle.IdentQuoteSlice(columns.conflict)
whitelist := strmangle.IdentQuoteSlice(columns.whitelist)
returning := strmangle.IdentQuoteSlice(columns.returning)
var sets []string
// Generate the UPDATE SET clause
@ -102,19 +104,19 @@ func (o *{{$tableNameSingular}}) generateUpsertQuery(update bool, columns upsert
set = strings.Join(sets, ", ")
query = fmt.Sprintf(
`INSERT INTO {{.Table.Name}} (%s) VALUES (%s) ON CONFLICT`,
strings.Join(columns.whitelist, `, `),
strmangle.Placeholders(len(columns.whitelist), 1, 1),
"INSERT INTO {{.Table.Name}} (%s) VALUES (%s) ON CONFLICT",
strings.Join(whitelist, ", "),
strmangle.Placeholders(len(whitelist), 1, 1),
)
if !update {
query = query + " DO NOTHING"
} else {
query = fmt.Sprintf(`%s (%s) DO UPDATE SET %s`, query, strings.Join(columns.conflict, `, `), set)
query = fmt.Sprintf("%s (%s) DO UPDATE SET %s", query, strings.Join(conflict, ", "), set)
}
if len(columns.returning) != 0 {
query = fmt.Sprintf(`%s RETURNING %s`, query, strings.Join(columns.returning, ","))
query = fmt.Sprintf("%s RETURNING %s", query, strings.Join(returning, ", "))
}
return query

2
templates/11_delete.tpl
View file

@ -112,7 +112,7 @@ func (o {{$tableNameSingular}}Slice) DeleteAll(exec boil.Executor) error {
sql := fmt.Sprintf(
`DELETE FROM {{.Table.Name}} WHERE (%s) IN (%s)`,
strings.Join({{$varNameSingular}}PrimaryKeyColumns, ","),
strings.Join(strmangle.IdentQuoteSlice({{$varNameSingular}}PrimaryKeyColumns), ","),
strmangle.Placeholders(len(o) * len({{$varNameSingular}}PrimaryKeyColumns), 1, len({{$varNameSingular}}PrimaryKeyColumns)),
)

2
templates/12_reload.tpl
View file

@ -72,7 +72,7 @@ func (o *{{$tableNameSingular}}Slice) ReloadAll(exec boil.Executor) error {
sql := fmt.Sprintf(
`SELECT {{.Table.Name}}.* FROM {{.Table.Name}} WHERE (%s) IN (%s)`,
strings.Join({{$varNameSingular}}PrimaryKeyColumns, ","),
strings.Join(strmangle.IdentQuoteSlice({{$varNameSingular}}PrimaryKeyColumns), ","),
strmangle.Placeholders(len(*o) * len({{$varNameSingular}}PrimaryKeyColumns), 1, len({{$varNameSingular}}PrimaryKeyColumns)),
)

4
templates_test/find.tpl
View file

@ -20,7 +20,9 @@ func Test{{$tableNamePlural}}Find(t *testing.T) {
// Perform all Find queries and assign result objects to slice for comparison
for i := 0; i < len(j); i++ {
j[i], err = {{$tableNameSingular}}FindG({{.Table.PKey.Columns | stringMap .StringFuncs.titleCase | prefixStringSlice "o[i]." | join ", "}})
{{$varNameSingular}}CompareVals(o[i], j[i], t)
err = {{$varNameSingular}}CompareVals(o[i], j[i], true); if err != nil {
t.Error(err)
}
}
f, err := {{$tableNameSingular}}FindG({{.Table.PKey.Columns | stringMap .StringFuncs.titleCase | prefixStringSlice "o[0]." | join ", "}}, {{$varNameSingular}}PrimaryKeyColumns...)

16
templates_test/finishers.tpl
View file

@ -21,7 +21,9 @@ func Test{{$tableNamePlural}}Bind(t *testing.T) {
t.Errorf("Unable to call Bind on {{$tableNameSingular}} single object: %s", err)
}
{{$varNameSingular}}CompareVals(&o, &j, t)
err = {{$varNameSingular}}CompareVals(&o, &j, true); if err != nil {
t.Error(err)
}
// insert 3 rows, attempt to bind into slice
{{$varNamePlural}}DeleteAllRows(t)
@ -50,7 +52,9 @@ func Test{{$tableNamePlural}}Bind(t *testing.T) {
}
for i := 0; i < len(y); i++ {
{{$varNameSingular}}CompareVals(y[i], k[i], t)
err = {{$varNameSingular}}CompareVals(y[i], k[i], true); if err != nil {
t.Error(err)
}
}
{{$varNamePlural}}DeleteAllRows(t)
@ -73,7 +77,9 @@ func Test{{$tableNamePlural}}One(t *testing.T) {
t.Errorf("Unable to fetch One {{$tableNameSingular}} result:\n#%v\nErr: %s", j, err)
}
{{$varNameSingular}}CompareVals(&o, j, t)
err = {{$varNameSingular}}CompareVals(&o, j, true); if err != nil {
t.Error(err)
}
{{$varNamePlural}}DeleteAllRows(t)
}
@ -104,7 +110,9 @@ func Test{{$tableNamePlural}}All(t *testing.T) {
}
for i := 0; i < len(o); i++ {
{{$varNameSingular}}CompareVals(o[i], j[i], t)
err = {{$varNameSingular}}CompareVals(o[i], j[i], true); if err != nil {
t.Error(err)
}
}
{{$varNamePlural}}DeleteAllRows(t)

28
templates_test/helpers.tpl
View file

@ -4,26 +4,36 @@
{{- $varNameSingular := .Table.Name | singular | camelCase -}}
var {{$varNameSingular}}DBTypes = map[string]string{{"{"}}{{.Table.Columns | columnDBTypes | makeStringMap}}{{"}"}}
func {{$varNameSingular}}CompareVals(o *{{$tableNameSingular}}, j *{{$tableNameSingular}}, t *testing.T) {
func {{$varNameSingular}}CompareVals(o *{{$tableNameSingular}}, j *{{$tableNameSingular}}, equal bool, blacklist ...string) error {
{{- range $key, $value := .Table.Columns -}}
{{if eq $value.Type "null.Time"}}
if o.{{titleCase $value.Name}}.Time.Format("02/01/2006") != j.{{titleCase $value.Name}}.Time.Format("02/01/2006") {
t.Errorf("Expected NullTime {{$value.Name}} column string values to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}.Time.Format("02/01/2006"), j.{{titleCase $value.Name}}.Time.Format("02/01/2006"))
if ((equal && o.{{titleCase $value.Name}}.Time.Format("02/01/2006") != j.{{titleCase $value.Name}}.Time.Format("02/01/2006")) ||
(!equal && o.{{titleCase $value.Name}}.Time.Format("02/01/2006") == j.{{titleCase $value.Name}}.Time.Format("02/01/2006"))) &&
!strmangle.HasElement("{{$value.Name}}", blacklist) {
return errors.New(fmt.Sprintf("NullTime {{$value.Name}} unexpected value, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}.Time.Format("02/01/2006"), j.{{titleCase $value.Name}}.Time.Format("02/01/2006")))
}
{{else if eq $value.Type "time.Time"}}
if o.{{titleCase $value.Name}}.Format("02/01/2006") != j.{{titleCase $value.Name}}.Format("02/01/2006") {
t.Errorf("Expected Time {{$value.Name}} column string values to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}.Format("02/01/2006"), j.{{titleCase $value.Name}}.Format("02/01/2006"))
if ((equal && o.{{titleCase $value.Name}}.Format("02/01/2006") != j.{{titleCase $value.Name}}.Format("02/01/2006")) ||
(!equal && o.{{titleCase $value.Name}}.Format("02/01/2006") == j.{{titleCase $value.Name}}.Format("02/01/2006"))) &&
!strmangle.HasElement("{{$value.Name}}", blacklist) {
return errors.New(fmt.Sprintf("Time {{$value.Name}} unexpected value, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}.Format("02/01/2006"), j.{{titleCase $value.Name}}.Format("02/01/2006")))
}
{{else if eq $value.Type "[]byte"}}
if !byteSliceEqual(o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}}) {
t.Errorf("Expected {{$value.Name}} columns to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}})
if ((equal && !byteSliceEqual(o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}})) ||
(!equal && byteSliceEqual(o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}}))) &&
!strmangle.HasElement("{{$value.Name}}", blacklist) {
return errors.New(fmt.Sprintf("Expected {{$value.Name}} columns to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}}))
}
{{else}}
if j.{{titleCase $value.Name}} != o.{{titleCase $value.Name}} {
t.Errorf("Expected {{$value.Name}} columns to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}})
if ((equal && j.{{titleCase $value.Name}} != o.{{titleCase $value.Name}}) ||
(!equal && j.{{titleCase $value.Name}} == o.{{titleCase $value.Name}})) &&
!strmangle.HasElement("{{$value.Name}}", blacklist) {
return errors.New(fmt.Sprintf("Expected {{$value.Name}} columns to match, got:\nStruct: %#v\nResponse: %#v\n\n", o.{{titleCase $value.Name}}, j.{{titleCase $value.Name}}))
}
{{end}}
{{- end -}}
return nil
}
func Test{{$tableNamePlural}}InPrimaryKeyArgs(t *testing.T) {

8
templates_test/insert.tpl
View file

@ -33,13 +33,15 @@ func Test{{$tableNamePlural}}Insert(t *testing.T) {
if err != nil {
t.Errorf("Unable to find {{$tableNameSingular}} row: %s", err)
}
{{$varNameSingular}}CompareVals(o[i], j[i], t)
err = {{$varNameSingular}}CompareVals(o[i], j[i], true); if err != nil {
t.Error(err)
}
}
{{$varNamePlural}}DeleteAllRows(t)
item := &{{$tableNameSingular}}{}
boil.RandomizeValidatedStruct(item, {{$varNameSingular}}ColumnsValidated, {{$varNameSingular}}DBTypes)
boil.RandomizeValidatedStruct(item, {{$varNameSingular}}ValidatedColumns, {{$varNameSingular}}DBTypes)
if err = item.InsertG(); err != nil {
t.Errorf("Unable to insert zero-value item {{$tableNameSingular}}:\n%#v\nErr: %s", item, err)
}
@ -71,7 +73,7 @@ func Test{{$tableNamePlural}}Insert(t *testing.T) {
regularCols := []string{{"{"}}{{.Table.Columns | filterColumnsByAutoIncrement false | filterColumnsByDefault false | columnNames | stringMap $parent.StringFuncs.quoteWrap | join ", "}}{{"}"}}
// Remove the validated columns, they can never be zero values
regularCols = boil.SetComplement(regularCols, {{$varNameSingular}}ColumnsValidated)
regularCols = boil.SetComplement(regularCols, {{$varNameSingular}}ValidatedColumns)
// Ensure the non-defaultvalue columns and non-autoincrement columns are stored correctly as zero or null values.
for _, c := range regularCols {

14
templates_test/reload.tpl
View file

@ -35,8 +35,9 @@ func Test{{$tableNamePlural}}Reload(t *testing.T) {
if err = o1.ReloadG(); err != nil {
t.Errorf("Unable to reload {{$tableNameSingular}} object: %s", err)
}
{{$varNameSingular}}CompareVals(&o, o1, t)
err = {{$varNameSingular}}CompareVals(&o, o1, true); if err != nil {
t.Error(err)
}
{{$varNamePlural}}DeleteAllRows(t)
}
@ -61,8 +62,9 @@ func Test{{$tableNamePlural}}ReloadAll(t *testing.T) {
if err != nil {
t.Errorf("Unable to find {{$tableNameSingular}} row.")
}
{{$varNameSingular}}CompareVals(o1[i], o2[i], t)
err = {{$varNameSingular}}CompareVals(o1[i], o2[i], true); if err != nil {
t.Error(err)
}
}
// Randomize the struct values again, except for the primary key values, so we can call update.
@ -84,7 +86,9 @@ func Test{{$tableNamePlural}}ReloadAll(t *testing.T) {
}
for i := 0; i < len(o1); i++ {
{{$varNameSingular}}CompareVals(o2[i], o1[i], t)
err = {{$varNameSingular}}CompareVals(o2[i], o1[i], true); if err != nil {
t.Error(err)
}
}
{{$varNamePlural}}DeleteAllRows(t)

30
templates_test/update.tpl
View file

@ -6,7 +6,7 @@ func Test{{$tableNamePlural}}Update(t *testing.T) {
var err error
item := {{$tableNameSingular}}{}
boil.RandomizeValidatedStruct(&item, {{$varNameSingular}}ColumnsValidated, {{$varNameSingular}}DBTypes)
boil.RandomizeValidatedStruct(&item, {{$varNameSingular}}ValidatedColumns, {{$varNameSingular}}DBTypes)
if err = item.InsertG(); err != nil {
t.Errorf("Unable to insert zero-value item {{$tableNameSingular}}:\n%#v\nErr: %s", item, err)
}
@ -27,7 +27,9 @@ func Test{{$tableNamePlural}}Update(t *testing.T) {
t.Errorf("Unable to find {{$tableNameSingular}} row: %s", err)
}
{{$varNameSingular}}CompareVals(&item, j, t)
err = {{$varNameSingular}}CompareVals(&item, j, true); if err != nil {
t.Error(err)
}
wl := item.generateUpdateColumns("test")
if len(wl) != 1 && wl[0] != "test" {
@ -62,14 +64,16 @@ func Test{{$tableNamePlural}}SliceUpdateAll(t *testing.T) {
vals := M{}
tmp := {{$tableNameSingular}}{}
if err = boil.RandomizeStruct(&tmp, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
blacklist := boil.SetMerge({{$varNameSingular}}PrimaryKeyColumns, {{$varNameSingular}}UniqueColumns)
fmt.Printf("blacklist: %s\n\n", blacklist)
if err = boil.RandomizeStruct(&tmp, {{$varNameSingular}}DBTypes, false, blacklist...); err != nil {
t.Errorf("Unable to randomize struct {{$tableNameSingular}}: %s", err)
}
// Build the columns and column values from the randomized struct
tmpVal := reflect.Indirect(reflect.ValueOf(tmp))
nonPrimKeys := boil.SetComplement({{$varNameSingular}}Columns, {{$varNameSingular}}PrimaryKeyColumns)
for _, col := range nonPrimKeys {
nonBlacklist := boil.SetComplement({{$varNameSingular}}Columns, blacklist)
for _, col := range nonBlacklist {
vals[col] = tmpVal.FieldByName(strmangle.TitleCase(col)).Interface()
}
@ -83,8 +87,22 @@ func Test{{$tableNamePlural}}SliceUpdateAll(t *testing.T) {
if err != nil {
t.Errorf("Unable to find {{$tableNameSingular}} row: %s", err)
}
{{$varNameSingular}}CompareVals(o[i], &tmp, t)
err = {{$varNameSingular}}CompareVals(j[i], &tmp, true, blacklist...)
if err != nil {
t.Error(err)
}
}
for i := 0; i < len(o); i++ {
// Ensure Find found the correct primary key ID's
orig := boil.GetStructValues(o[i], {{$varNameSingular}}PrimaryKeyColumns...)
new := boil.GetStructValues(j[i], {{$varNameSingular}}PrimaryKeyColumns...)
if !reflect.DeepEqual(orig, new) {
t.Errorf("object %d): primary keys do not match:\n\n%#v\n%#v", i, orig, new)
}
}
{{$varNamePlural}}DeleteAllRows(t)
}

16
templates_test/upsert.tpl
View file

@ -41,14 +41,14 @@ func Test{{$tableNamePlural}}Upsert(t *testing.T) {
}
query := o.generateUpsertQuery(false, upsertCols)
expectedQuery := `INSERT INTO {{.Table.Name}} ("thing", "stuff") VALUES ($1,$2) ON CONFLICT DO NOTHING`
expectedQuery := `INSERT INTO {{.Table.Name}} ("thing", "stuff") VALUES ($1, $2) ON CONFLICT DO NOTHING`
if query != expectedQuery {
t.Errorf("Expected query mismatch:\n\n%s\n%s\n", query, expectedQuery)
}
query = o.generateUpsertQuery(true, upsertCols)
expectedQuery = `INSERT INTO {{.Table.Name}} ("thing", "stuff") VALUES ($1,$2) ON CONFLICT ("key1", "key2") DO UPDATE SET "aaa" = EXCLUDED."aaa", "bbb" = EXCLUDED."bbb"`
expectedQuery = `INSERT INTO {{.Table.Name}} ("thing", "stuff") VALUES ($1, $2) ON CONFLICT ("key1", "key2") DO UPDATE SET "aaa" = EXCLUDED."aaa", "bbb" = EXCLUDED."bbb"`
if query != expectedQuery {
t.Errorf("Expected query mismatch:\n\n%s\n%s\n", query, expectedQuery)
@ -56,7 +56,7 @@ func Test{{$tableNamePlural}}Upsert(t *testing.T) {
upsertCols.returning = []string{"stuff"}
query = o.generateUpsertQuery(true, upsertCols)
expectedQuery = expectedQuery + ` RETURNING stuff`
expectedQuery = expectedQuery + ` RETURNING "stuff"`
if query != expectedQuery {
t.Errorf("Expected query mismatch:\n\n%s\n%s\n", query, expectedQuery)
@ -75,8 +75,9 @@ func Test{{$tableNamePlural}}Upsert(t *testing.T) {
if err != nil {
t.Errorf("Unable to find {{$tableNameSingular}}: %s", err)
}
{{$varNameSingular}}CompareVals(&o, compare, t)
err = {{$varNameSingular}}CompareVals(&o, compare, true); if err != nil {
t.Error(err)
}
// Attempt the UPDATE side of an UPSERT
if err = boil.RandomizeStruct(&o, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
@ -91,8 +92,9 @@ func Test{{$tableNamePlural}}Upsert(t *testing.T) {
if err != nil {
t.Errorf("Unable to find {{$tableNameSingular}}: %s", err)
}
{{$varNameSingular}}CompareVals(&o, compare, t)
err = {{$varNameSingular}}CompareVals(&o, compare, true); if err != nil {
t.Error(err)
}
{{$varNamePlural}}DeleteAllRows(t)
}