sqlboiler/templates_test/relationship_to_many_setops.tpl

{{- if .Table.IsJoinTable -}}
{{- else -}}
	{{- $dot := . -}}
	{{- $table := .Table -}}
	{{- range .Table.ToManyRelationships -}}
		{{- if (and .ForeignColumnUnique (not .ToJoinTable)) -}}
{{- template "relationship_to_one_setops_test_helper" (textsFromOneToOneRelationship $dot.PkgName $dot.Tables $table .) -}}
		{{- else -}}
		{{- $varNameSingular := .Table | singular | camelCase -}}
		{{- $foreignVarNameSingular := .ForeignTable | singular | camelCase -}}
		{{- $rel := textsFromRelationship $dot.Tables $table .}}

func test{{$rel.LocalTable.NameGo}}ToManyAddOp{{$rel.Function.Name}}(t *testing.T) {
	var err error

	tx := MustTx(boil.Begin())
	defer tx.Rollback()

	var a {{$rel.LocalTable.NameGo}}
	var b, c, d, e {{$rel.ForeignTable.NameGo}}

	seed := randomize.NewSeed()
	if err = randomize.Struct(seed, &a, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
		t.Fatal(err)
	}
	foreigners := []*{{$rel.ForeignTable.NameGo}}{&b, &c, &d, &e}
	for _, x := range foreigners {
		if err = randomize.Struct(seed, x, {{$foreignVarNameSingular}}DBTypes, false, {{$foreignVarNameSingular}}PrimaryKeyColumns...); err != nil {
			t.Fatal(err)
		}
	}

	if err := a.Insert(tx); err != nil {
		t.Fatal(err)
	}
	if err = b.Insert(tx); err != nil {
		t.Fatal(err)
	}
	if err = c.Insert(tx); err != nil {
		t.Fatal(err)
	}

	foreignersSplitByInsertion := [][]*{{$rel.ForeignTable.NameGo}}{
		{&b, &c},
		{&d, &e},
	}

	for i, x := range foreignersSplitByInsertion {
		err = a.Add{{$rel.Function.Name}}(tx, i != 0, x...)
		if err != nil {
			t.Fatal(err)
		}

		first := x[0]
		second := x[1]
		{{- if .ToJoinTable}}

		if first.R.{{$rel.Function.ForeignName}}[0] != &a {
			t.Error("relationship was not added properly to the slice")
		}
		if second.R.{{$rel.Function.ForeignName}}[0] != &a {
			t.Error("relationship was not added properly to the slice")
		}
		{{- else}}

		if a.{{$rel.Function.LocalAssignment}} != first.{{$rel.Function.ForeignAssignment}} {
			t.Error("foreign key was wrong value", a.{{$rel.Function.LocalAssignment}}, first.{{$rel.Function.ForeignAssignment}})
		}
		if a.{{$rel.Function.LocalAssignment}} != second.{{$rel.Function.ForeignAssignment}} {
			t.Error("foreign key was wrong value", a.{{$rel.Function.LocalAssignment}}, second.{{$rel.Function.ForeignAssignment}})
		}

		if first.R.{{$rel.Function.ForeignName}} != &a {
			t.Error("relationship was not added properly to the foreign slice")
		}
		if second.R.{{$rel.Function.ForeignName}} != &a {
			t.Error("relationship was not added properly to the foreign slice")
		}
		{{- end}}

		if a.R.{{$rel.Function.Name}}[i*2] != first {
			t.Error("relationship struct slice not set to correct value")
		}
		if a.R.{{$rel.Function.Name}}[i*2+1] != second {
			t.Error("relationship struct slice not set to correct value")
		}

		count, err := a.{{$rel.Function.Name}}(tx).Count()
		if err != nil {
			t.Fatal(err)
		}
		if want := int64((i+1)*2); count != want {
			t.Error("want", want, "got", count)
		}
	}
}
{{- if (or .ForeignColumnNullable .ToJoinTable)}}

func test{{$rel.LocalTable.NameGo}}ToManySetOp{{$rel.Function.Name}}(t *testing.T) {
	var err error

	tx := MustTx(boil.Begin())
	defer tx.Rollback()

	var a {{$rel.LocalTable.NameGo}}
	var b, c, d, e {{$rel.ForeignTable.NameGo}}

	seed := randomize.NewSeed()
	if err = randomize.Struct(seed, &a, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
		t.Fatal(err)
	}
	foreigners := []*{{$rel.ForeignTable.NameGo}}{&b, &c, &d, &e}
	for _, x := range foreigners {
		if err = randomize.Struct(seed, x, {{$foreignVarNameSingular}}DBTypes, false, {{$foreignVarNameSingular}}PrimaryKeyColumns...); err != nil {
			t.Fatal(err)
		}
	}

	if err = a.Insert(tx); err != nil {
		t.Fatal(err)
	}
	if err = b.Insert(tx); err != nil {
		t.Fatal(err)
	}
	if err = c.Insert(tx); err != nil {
		t.Fatal(err)
	}

	err = a.Set{{$rel.Function.Name}}(tx, false, &b, &c)
	if err != nil {
		t.Fatal(err)
	}

	count, err := a.{{$rel.Function.Name}}(tx).Count()
	if err != nil {
		t.Fatal(err)
	}
	if count != 2 {
		t.Error("count was wrong:", count)
	}

	err = a.Set{{$rel.Function.Name}}(tx, true, &d, &e)
	if err != nil {
		t.Fatal(err)
	}

	count, err = a.{{$rel.Function.Name}}(tx).Count()
	if err != nil {
		t.Fatal(err)
	}
	if count != 2 {
		t.Error("count was wrong:", count)
	}

	{{- if .ToJoinTable}}

	if len(b.R.{{$rel.Function.ForeignName}}) != 0 {
		t.Error("relationship was not removed properly from the slice")
	}
	if len(c.R.{{$rel.Function.ForeignName}}) != 0 {
		t.Error("relationship was not removed properly from the slice")
	}
	if d.R.{{$rel.Function.ForeignName}}[0] != &a {
		t.Error("relationship was not added properly to the slice")
	}
	if e.R.{{$rel.Function.ForeignName}}[0] != &a {
		t.Error("relationship was not added properly to the slice")
	}
	{{- else}}

	if b.{{$rel.ForeignTable.ColumnNameGo}}.Valid {
		t.Error("want b's foreign key value to be nil")
	}
	if c.{{$rel.ForeignTable.ColumnNameGo}}.Valid {
		t.Error("want c's foreign key value to be nil")
	}
	if a.{{$rel.Function.LocalAssignment}} != d.{{$rel.Function.ForeignAssignment}} {
		t.Error("foreign key was wrong value", a.{{$rel.Function.LocalAssignment}}, d.{{$rel.Function.ForeignAssignment}})
	}
	if a.{{$rel.Function.LocalAssignment}} != e.{{$rel.Function.ForeignAssignment}} {
		t.Error("foreign key was wrong value", a.{{$rel.Function.LocalAssignment}}, e.{{$rel.Function.ForeignAssignment}})
	}

	if b.R.{{$rel.Function.ForeignName}} != nil {
		t.Error("relationship was not removed properly from the foreign struct")
	}
	if c.R.{{$rel.Function.ForeignName}} != nil {
		t.Error("relationship was not removed properly from the foreign struct")
	}
	if d.R.{{$rel.Function.ForeignName}} != &a {
		t.Error("relationship was not added properly to the foreign struct")
	}
	if e.R.{{$rel.Function.ForeignName}} != &a {
		t.Error("relationship was not added properly to the foreign struct")
	}
	{{- end}}

	if a.R.{{$rel.Function.Name}}[0] != &d {
		t.Error("relationship struct slice not set to correct value")
	}
	if a.R.{{$rel.Function.Name}}[1] != &e {
		t.Error("relationship struct slice not set to correct value")
	}
}

func test{{$rel.LocalTable.NameGo}}ToManyRemoveOp{{$rel.Function.Name}}(t *testing.T) {
	var err error

	tx := MustTx(boil.Begin())
	defer tx.Rollback()

	var a {{$rel.LocalTable.NameGo}}
	var b, c, d, e {{$rel.ForeignTable.NameGo}}

	seed := randomize.NewSeed()
	if err = randomize.Struct(seed, &a, {{$varNameSingular}}DBTypes, false, {{$varNameSingular}}PrimaryKeyColumns...); err != nil {
		t.Fatal(err)
	}
	foreigners := []*{{$rel.ForeignTable.NameGo}}{&b, &c, &d, &e}
	for _, x := range foreigners {
		if err = randomize.Struct(seed, x, {{$foreignVarNameSingular}}DBTypes, false, {{$foreignVarNameSingular}}PrimaryKeyColumns...); err != nil {
			t.Fatal(err)
		}
	}

	if err := a.Insert(tx); err != nil {
		t.Fatal(err)
	}

	err = a.Add{{$rel.Function.Name}}(tx, true, foreigners...)
	if err != nil {
		t.Fatal(err)
	}

	count, err := a.{{$rel.Function.Name}}(tx).Count()
	if err != nil {
		t.Fatal(err)
	}
	if count != 4 {
		t.Error("count was wrong:", count)
	}

	err = a.Remove{{$rel.Function.Name}}(tx, foreigners[:2]...)
	if err != nil {
		t.Fatal(err)
	}

	count, err = a.{{$rel.Function.Name}}(tx).Count()
	if err != nil {
		t.Fatal(err)
	}
	if count != 2 {
		t.Error("count was wrong:", count)
	}

	{{- if .ToJoinTable}}

	if len(b.R.{{$rel.Function.ForeignName}}) != 0 {
		t.Error("relationship was not removed properly from the slice")
	}
	if len(c.R.{{$rel.Function.ForeignName}}) != 0 {
		t.Error("relationship was not removed properly from the slice")
	}
	if d.R.{{$rel.Function.ForeignName}}[0] != &a {
		t.Error("relationship was not added properly to the foreign struct")
	}
	if e.R.{{$rel.Function.ForeignName}}[0] != &a {
		t.Error("relationship was not added properly to the foreign struct")
	}
	{{- else}}

	if b.{{$rel.ForeignTable.ColumnNameGo}}.Valid {
		t.Error("want b's foreign key value to be nil")
	}
	if c.{{$rel.ForeignTable.ColumnNameGo}}.Valid {
		t.Error("want c's foreign key value to be nil")
	}

	if b.R.{{$rel.Function.ForeignName}} != nil {
		t.Error("relationship was not removed properly from the foreign struct")
	}
	if c.R.{{$rel.Function.ForeignName}} != nil {
		t.Error("relationship was not removed properly from the foreign struct")
	}
	if d.R.{{$rel.Function.ForeignName}} != &a {
		t.Error("relationship to a should have been preserved")
	}
	if e.R.{{$rel.Function.ForeignName}} != &a {
		t.Error("relationship to a should have been preserved")
	}
	{{- end}}

	if len(a.R.{{$rel.Function.Name}}) != 2 {
		t.Error("should have preserved two relationships")
	}

	// Removal doesn't do a stable deletion for performance so we have to flip the order
	if a.R.{{$rel.Function.Name}}[1] != &d {
		t.Error("relationship to d should have been preserved")
	}
	if a.R.{{$rel.Function.Name}}[0] != &e {
		t.Error("relationship to e should have been preserved")
	}
}
{{end -}}
{{- end -}}{{- /* if unique foreign key */ -}}
{{- end -}}{{- /* range relationships */ -}}
{{- end -}}{{- /* outer if join table */ -}}