1 files changed, 482 insertions, 1 deletions
diff --git a/src/models/posts_test.go b/src/models/posts_test.go
index 578d483..3317ece 100644
--- a/src/models/posts_test.go
+++ b/src/models/posts_test.go
@@ -494,6 +494,84 @@ func testPostsInsertWhitelist(t *testing.T) {
 	}
 }
 
+func testPostToManyComments(t *testing.T) {
+	var err error
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c Comment
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, true, postColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Post struct: %s", err)
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = randomize.Struct(seed, &b, commentDBTypes, false, commentColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &c, commentDBTypes, false, commentColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+
+	b.PostID = a.ID
+	c.PostID = a.ID
+
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	check, err := a.Comments().All(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bFound, cFound := false, false
+	for _, v := range check {
+		if v.PostID == b.PostID {
+			bFound = true
+		}
+		if v.PostID == c.PostID {
+			cFound = true
+		}
+	}
+
+	if !bFound {
+		t.Error("expected to find b")
+	}
+	if !cFound {
+		t.Error("expected to find c")
+	}
+
+	slice := PostSlice{&a}
+	if err = a.L.LoadComments(ctx, tx, false, (*[]*Post)(&slice), nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.Comments); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	a.R.Comments = nil
+	if err = a.L.LoadComments(ctx, tx, true, &a, nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.Comments); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	if t.Failed() {
+		t.Logf("%#v", check)
+	}
+}
+
 func testPostToManyTags(t *testing.T) {
 	var err error
 	ctx := context.Background()
@@ -578,6 +656,158 @@ func testPostToManyTags(t *testing.T) {
 	}
 }
 
+func testPostToManyVotes(t *testing.T) {
+	var err error
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c Vote
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, true, postColumnsWithDefault...); err != nil {
+		t.Errorf("Unable to randomize Post struct: %s", err)
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	if err = randomize.Struct(seed, &b, voteDBTypes, false, voteColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+	if err = randomize.Struct(seed, &c, voteDBTypes, false, voteColumnsWithDefault...); err != nil {
+		t.Fatal(err)
+	}
+
+	queries.Assign(&b.PostID, a.ID)
+	queries.Assign(&c.PostID, a.ID)
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	check, err := a.Votes().All(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bFound, cFound := false, false
+	for _, v := range check {
+		if queries.Equal(v.PostID, b.PostID) {
+			bFound = true
+		}
+		if queries.Equal(v.PostID, c.PostID) {
+			cFound = true
+		}
+	}
+
+	if !bFound {
+		t.Error("expected to find b")
+	}
+	if !cFound {
+		t.Error("expected to find c")
+	}
+
+	slice := PostSlice{&a}
+	if err = a.L.LoadVotes(ctx, tx, false, (*[]*Post)(&slice), nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.Votes); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	a.R.Votes = nil
+	if err = a.L.LoadVotes(ctx, tx, true, &a, nil); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(a.R.Votes); got != 2 {
+		t.Error("number of eager loaded records wrong, got:", got)
+	}
+
+	if t.Failed() {
+		t.Logf("%#v", check)
+	}
+}
+
+func testPostToManyAddOpComments(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c, d, e Comment
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, false, strmangle.SetComplement(postPrimaryKeyColumns, postColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	foreigners := []*Comment{&b, &c, &d, &e}
+	for _, x := range foreigners {
+		if err = randomize.Struct(seed, x, commentDBTypes, false, strmangle.SetComplement(commentPrimaryKeyColumns, commentColumnsWithoutDefault)...); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	foreignersSplitByInsertion := [][]*Comment{
+		{&b, &c},
+		{&d, &e},
+	}
+
+	for i, x := range foreignersSplitByInsertion {
+		err = a.AddComments(ctx, tx, i != 0, x...)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		first := x[0]
+		second := x[1]
+
+		if a.ID != first.PostID {
+			t.Error("foreign key was wrong value", a.ID, first.PostID)
+		}
+		if a.ID != second.PostID {
+			t.Error("foreign key was wrong value", a.ID, second.PostID)
+		}
+
+		if first.R.Post != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+		if second.R.Post != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+
+		if a.R.Comments[i*2] != first {
+			t.Error("relationship struct slice not set to correct value")
+		}
+		if a.R.Comments[i*2+1] != second {
+			t.Error("relationship struct slice not set to correct value")
+		}
+
+		count, err := a.Comments().Count(ctx, tx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := int64((i + 1) * 2); count != want {
+			t.Error("want", want, "got", count)
+		}
+	}
+}
 func testPostToManyAddOpTags(t *testing.T) {
 	var err error
 
@@ -806,6 +1036,257 @@ func testPostToManyRemoveOpTags(t *testing.T) {
 	}
 }
 
+func testPostToManyAddOpVotes(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c, d, e Vote
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, false, strmangle.SetComplement(postPrimaryKeyColumns, postColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	foreigners := []*Vote{&b, &c, &d, &e}
+	for _, x := range foreigners {
+		if err = randomize.Struct(seed, x, voteDBTypes, false, strmangle.SetComplement(votePrimaryKeyColumns, voteColumnsWithoutDefault)...); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	foreignersSplitByInsertion := [][]*Vote{
+		{&b, &c},
+		{&d, &e},
+	}
+
+	for i, x := range foreignersSplitByInsertion {
+		err = a.AddVotes(ctx, tx, i != 0, x...)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		first := x[0]
+		second := x[1]
+
+		if !queries.Equal(a.ID, first.PostID) {
+			t.Error("foreign key was wrong value", a.ID, first.PostID)
+		}
+		if !queries.Equal(a.ID, second.PostID) {
+			t.Error("foreign key was wrong value", a.ID, second.PostID)
+		}
+
+		if first.R.Post != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+		if second.R.Post != &a {
+			t.Error("relationship was not added properly to the foreign slice")
+		}
+
+		if a.R.Votes[i*2] != first {
+			t.Error("relationship struct slice not set to correct value")
+		}
+		if a.R.Votes[i*2+1] != second {
+			t.Error("relationship struct slice not set to correct value")
+		}
+
+		count, err := a.Votes().Count(ctx, tx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if want := int64((i + 1) * 2); count != want {
+			t.Error("want", want, "got", count)
+		}
+	}
+}
+
+func testPostToManySetOpVotes(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c, d, e Vote
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, false, strmangle.SetComplement(postPrimaryKeyColumns, postColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	foreigners := []*Vote{&b, &c, &d, &e}
+	for _, x := range foreigners {
+		if err = randomize.Struct(seed, x, voteDBTypes, false, strmangle.SetComplement(votePrimaryKeyColumns, voteColumnsWithoutDefault)...); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err = a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = b.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+	if err = c.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	err = a.SetVotes(ctx, tx, false, &b, &c)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := a.Votes().Count(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count != 2 {
+		t.Error("count was wrong:", count)
+	}
+
+	err = a.SetVotes(ctx, tx, true, &d, &e)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err = a.Votes().Count(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count != 2 {
+		t.Error("count was wrong:", count)
+	}
+
+	if !queries.IsValuerNil(b.PostID) {
+		t.Error("want b's foreign key value to be nil")
+	}
+	if !queries.IsValuerNil(c.PostID) {
+		t.Error("want c's foreign key value to be nil")
+	}
+	if !queries.Equal(a.ID, d.PostID) {
+		t.Error("foreign key was wrong value", a.ID, d.PostID)
+	}
+	if !queries.Equal(a.ID, e.PostID) {
+		t.Error("foreign key was wrong value", a.ID, e.PostID)
+	}
+
+	if b.R.Post != nil {
+		t.Error("relationship was not removed properly from the foreign struct")
+	}
+	if c.R.Post != nil {
+		t.Error("relationship was not removed properly from the foreign struct")
+	}
+	if d.R.Post != &a {
+		t.Error("relationship was not added properly to the foreign struct")
+	}
+	if e.R.Post != &a {
+		t.Error("relationship was not added properly to the foreign struct")
+	}
+
+	if a.R.Votes[0] != &d {
+		t.Error("relationship struct slice not set to correct value")
+	}
+	if a.R.Votes[1] != &e {
+		t.Error("relationship struct slice not set to correct value")
+	}
+}
+
+func testPostToManyRemoveOpVotes(t *testing.T) {
+	var err error
+
+	ctx := context.Background()
+	tx := MustTx(boil.BeginTx(ctx, nil))
+	defer func() { _ = tx.Rollback() }()
+
+	var a Post
+	var b, c, d, e Vote
+
+	seed := randomize.NewSeed()
+	if err = randomize.Struct(seed, &a, postDBTypes, false, strmangle.SetComplement(postPrimaryKeyColumns, postColumnsWithoutDefault)...); err != nil {
+		t.Fatal(err)
+	}
+	foreigners := []*Vote{&b, &c, &d, &e}
+	for _, x := range foreigners {
+		if err = randomize.Struct(seed, x, voteDBTypes, false, strmangle.SetComplement(votePrimaryKeyColumns, voteColumnsWithoutDefault)...); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if err := a.Insert(ctx, tx, boil.Infer()); err != nil {
+		t.Fatal(err)
+	}
+
+	err = a.AddVotes(ctx, tx, true, foreigners...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err := a.Votes().Count(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count != 4 {
+		t.Error("count was wrong:", count)
+	}
+
+	err = a.RemoveVotes(ctx, tx, foreigners[:2]...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	count, err = a.Votes().Count(ctx, tx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count != 2 {
+		t.Error("count was wrong:", count)
+	}
+
+	if !queries.IsValuerNil(b.PostID) {
+		t.Error("want b's foreign key value to be nil")
+	}
+	if !queries.IsValuerNil(c.PostID) {
+		t.Error("want c's foreign key value to be nil")
+	}
+
+	if b.R.Post != nil {
+		t.Error("relationship was not removed properly from the foreign struct")
+	}
+	if c.R.Post != nil {
+		t.Error("relationship was not removed properly from the foreign struct")
+	}
+	if d.R.Post != &a {
+		t.Error("relationship to a should have been preserved")
+	}
+	if e.R.Post != &a {
+		t.Error("relationship to a should have been preserved")
+	}
+
+	if len(a.R.Votes) != 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.Votes[1] != &d {
+		t.Error("relationship to d should have been preserved")
+	}
+	if a.R.Votes[0] != &e {
+		t.Error("relationship to e should have been preserved")
+	}
+}
+
 func testPostToOneUserUsingUser(t *testing.T) {
 	ctx := context.Background()
 	tx := MustTx(boil.BeginTx(ctx, nil))
@@ -999,7 +1480,7 @@ func testPostsSelect(t *testing.T) {
 }
 
 var (
-	postDBTypes = map[string]string{`ID`: `integer`, `Title`: `character varying`, `Description`: `text`, `URL`: `character varying`, `UserID`: `integer`, `CreatedAt`: `timestamp with time zone`, `UpdatedAt`: `timestamp with time zone`}
+	postDBTypes = map[string]string{`ID`: `integer`, `Title`: `character varying`, `Description`: `text`, `URL`: `character varying`, `UserID`: `integer`, `State`: `enum.postable_state('hidden','visible')`, `CreatedAt`: `timestamp with time zone`, `UpdatedAt`: `timestamp with time zone`}
 	_           = bytes.MinRead
 )