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

Use new randomize package

Browse source
This commit is contained in:
Aaron L 2016-08-18 00:06:28 -07:00
parent f86d8d7ee9
commit 79520d27fb
13 changed files with 49 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
imports.go
View file

@ -181,6 +181,7 @@ var defaultTestTemplateImports = imports{
},
thirdParty: importList{
`"github.com/vattle/sqlboiler/boil"`,
`"github.com/vattle/sqlboiler/boil/randomize"`,
`"github.com/vattle/sqlboiler/strmangle"`,
},
}

12
templates_test/delete.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Delete(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -35,10 +35,10 @@ func test{{$tableNamePlural}}Delete(t *testing.T) {
func test{{$tableNamePlural}}QueryDeleteAll(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -65,10 +65,10 @@ func test{{$tableNamePlural}}QueryDeleteAll(t *testing.T) {
func test{{$tableNamePlural}}SliceDeleteAll(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

4
templates_test/exists.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Exists(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

4
templates_test/find.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Find(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

20
templates_test/finishers.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Bind(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -26,10 +26,10 @@ func test{{$tableNamePlural}}Bind(t *testing.T) {
func test{{$tableNamePlural}}One(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -49,14 +49,14 @@ func test{{$tableNamePlural}}One(t *testing.T) {
func test{{$tableNamePlural}}All(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}}One := &{{$tableNameSingular}}{}
{{$varNameSingular}}Two := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}One, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}One, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
if err = seed.RandomizeStruct({{$varNameSingular}}Two, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}Two, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -83,13 +83,13 @@ func test{{$tableNamePlural}}Count(t *testing.T) {
t.Parallel()
var err error
seed := boil.NewSeed()
seed := randomize.NewSeed()
{{$varNameSingular}}One := &{{$tableNameSingular}}{}
{{$varNameSingular}}Two := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}One, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}One, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
if err = seed.RandomizeStruct({{$varNameSingular}}Two, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}Two, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

8
templates_test/helpers.tpl
View file

@ -11,8 +11,8 @@ func test{{$tableNamePlural}}InPrimaryKeyArgs(t *testing.T) {
var o {{$tableNameSingular}}
o = {{$tableNameSingular}}{}
seed := boil.NewSeed()
if err = seed.RandomizeStruct(&o, {{$varNameSingular}}DBTypes, true); err != nil {
seed := randomize.NewSeed()
if err = randomize.Struct(seed, &o, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Could not randomize struct: %s", err)
}
@ -35,10 +35,10 @@ func test{{$tableNamePlural}}SliceInPrimaryKeyArgs(t *testing.T) {
var err error
o := make({{$tableNameSingular}}Slice, 3)
seed := boil.NewSeed()
seed := randomize.NewSeed()
for i := range o {
o[i] = &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct(o[i], {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, o[i], {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Could not randomize struct: %s", err)
}
}

4
templates_test/hooks.tpl
View file

@ -30,8 +30,8 @@ func test{{$tableNamePlural}}Hooks(t *testing.T) {
empty := &{{$tableNameSingular}}{}
o := &{{$tableNameSingular}}{}
seed := boil.NewSeed()
if err = seed.RandomizeStruct(o, {{$varNameSingular}}DBTypes, false); err != nil {
seed := randomize.NewSeed()
if err = randomize.Struct(seed, o, {{$varNameSingular}}DBTypes, false); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} object: %s", err)
}

8
templates_test/insert.tpl
View file

@ -6,10 +6,10 @@
func test{{$tableNamePlural}}Insert(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -32,10 +32,10 @@ func test{{$tableNamePlural}}Insert(t *testing.T) {
func test{{$tableNamePlural}}InsertWhitelist(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

6
templates_test/relationship_to_many.tpl
View file

@ -19,9 +19,9 @@ func test{{$rel.LocalTable.NameGo}}ToMany{{$rel.Function.Name}}(t *testing.T) {
t.Fatal(err)
}
seed := boil.NewSeed()
seed.RandomizeStruct(&b, {{$rel.ForeignTable.NameSingular | camelCase}}DBTypes, false, "{{.ForeignColumn}}")
seed.RandomizeStruct(&c, {{$rel.ForeignTable.NameSingular | camelCase}}DBTypes, false, "{{.ForeignColumn}}")
seed := randomize.NewSeed()
randomize.Struct(seed, &b, {{$rel.ForeignTable.NameSingular | camelCase}}DBTypes, false, "{{.ForeignColumn}}")
randomize.Struct(seed, &c, {{$rel.ForeignTable.NameSingular | camelCase}}DBTypes, false, "{{.ForeignColumn}}")
{{if .Nullable -}}
a.{{.Column | titleCase}}.Valid = true
{{- end}}

8
templates_test/reload.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Reload(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -26,10 +26,10 @@ func test{{$tableNamePlural}}Reload(t *testing.T) {
func test{{$tableNamePlural}}ReloadAll(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

4
templates_test/select.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Select(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}ColumnsWithDefault...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

12
templates_test/update.tpl
View file

@ -5,10 +5,10 @@
func test{{$tableNamePlural}}Update(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -27,7 +27,7 @@ func test{{$tableNamePlural}}Update(t *testing.T) {
t.Error("want one record, got:", count)
}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -39,10 +39,10 @@ func test{{$tableNamePlural}}Update(t *testing.T) {
func test{{$tableNamePlural}}SliceUpdateAll(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
{{$varNameSingular}} := &{{$tableNameSingular}}{}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -61,7 +61,7 @@ func test{{$tableNamePlural}}SliceUpdateAll(t *testing.T) {
t.Error("want one record, got:", count)
}
if err = seed.RandomizeStruct({{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
if err = randomize.Struct(seed, {{$varNameSingular}}, {{$varNameSingular}}DBTypes, true, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}

6
templates_test/upsert.tpl
View file

@ -5,11 +5,11 @@
func test{{$tableNamePlural}}Upsert(t *testing.T) {
t.Parallel()
seed := boil.NewSeed()
seed := randomize.NewSeed()
var err error
// Attempt the INSERT side of an UPSERT
{{$varNameSingular}} := {{$tableNameSingular}}{}
if err = seed.RandomizeStruct(&{{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
if err = randomize.Struct(seed, &{{$varNameSingular}}, {{$varNameSingular}}DBTypes, true); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}
@ -28,7 +28,7 @@ func test{{$tableNamePlural}}Upsert(t *testing.T) {
}
// Attempt the UPDATE side of an UPSERT
if err = seed.RandomizeStruct(&{{$varNameSingular}}, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
if err = randomize.Struct(seed, &{{$varNameSingular}}, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
t.Errorf("Unable to randomize {{$tableNameSingular}} struct: %s", err)
}