add benchmarks and benchmark helpers

create_test.go

@@ -1,27 +1,67 @@
 package orm
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
-func TestCreate1(t *testing.T) {
+func testCreate1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
+	err := e.Model(&user{}).Save(&u)
-	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	assert.NotZero(t, u.Favs.ID)
 }
 
+func testCreate2(t assert.TestingT, e *Engine) {
+	u := friend(t)
+	err := e.Model(&user{}).Save(&u)
+	assert.Nil(t, err)
+	assert.NotZero(t, u.Favs.ID)
+}
+
+func testCreate3(t assert.TestingT, e *Engine) {
+	insertBands(t, e)
+}
+
+func testCreate4(t assert.TestingT, e *Engine) {
+	u := author(t)
+	err := e.Model(&user{}).Save(&u)
+	if err != nil {
+		fmt.Println(err.Error())
+	}
+	assert.Nil(t, err)
+	insertBands(t, e)
+	storyBase(e, t, u)
+}
+
+func TestCreate1(t *testing.T) {
+	e := initTest(t)
+	testCreate1(t, e)
+	e.Disconnect()
+}
+
 func TestCreate2(t *testing.T) {
 	e := initTest(t)
-	u := friend()
+	testCreate2(t, e)
-	err := e.Model(&user{}).Create(&u)
+	e.Disconnect()
-	assert.Nil(t, err)
-	assert.NotZero(t, u.Favs.ID)
 }
 
 func TestCreate3(t *testing.T) {
 	e := initTest(t)
-	insertBands(t, e)
+	testCreate3(t, e)
+	e.Disconnect()
+}
+
+func TestCreate4(t *testing.T) {
+	e := initTest(t)
+	testCreate4(t, e)
+	e.Disconnect()
+}
+
+func BenchmarkCreate(b *testing.B) {
+	b.Run("Create-1", bench(testCreate1))
+	b.Run("Create-2", bench(testCreate2))
+	b.Run("Create-3", bench(testCreate3))
+	b.Run("Create-4", bench(testCreate4))
 }

delete_test.go

@@ -0,0 +1 @@
+package orm

find_test.go

@@ -5,9 +5,19 @@ import (
 	"testing"
 )
 
-func storyBase(e *Engine, t *testing.T, u user, additionalPopulateFields ...string) *story {
+func storyBaseLoop(t assert.TestingT, e *Engine, u user, count int, additionalPopulateFields ...string) {
+	if !isTestBench(t) {
+		for range count {
+			storyBase(e, t, u, additionalPopulateFields...)
+		}
+	} else {
+		storyBase(e, t, u, additionalPopulateFields...)
+	}
+}
+
+func storyBase(e *Engine, t assert.TestingT, u user, additionalPopulateFields ...string) *story {
 	s := iti_multi(u)
-	err := e.Model(&story{}).Create(s)
+	err := e.Model(&story{}).Save(s)
 	assert.Nil(t, err)
 	assert.NotZero(t, s.ID)
 	checkChapters(t, s)
@@ -26,10 +36,9 @@ func storyBase(e *Engine, t *testing.T, u user, additionalPopulateFields ...stri
 	return &ns
 }
 
-func TestFind(t *testing.T) {
+func testFind1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
+	err := e.Model(&user{}).Save(&u)
-	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	var nu user
 	err = e.Model(&user{}).Where("ID = ?", u.ID).Find(&nu)
@@ -38,15 +47,12 @@ func TestFind(t *testing.T) {
 	assert.NotZero(t, nu.Username)
 }
 
-func TestJoin1(t *testing.T) {
+func testJoin1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
+	err := e.Model(&user{}).Save(&u)
-	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	insertBands(t, e)
-	for range 7 {
+	storyBaseLoop(t, e, u, 7)
-		storyBase(e, t, u)
-	}
 	var withBodom []story
 	err = e.Model(&story{}).
 		Join("Chapters.Bands").
@@ -56,36 +62,31 @@ func TestJoin1(t *testing.T) {
 	assert.NotEmpty(t, withBodom)
 }
 
-func TestIn(t *testing.T) {
+func testIn(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
+	err := e.Model(&user{}).Save(&u)
-	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	insertBands(t, e)
-	for range 10 {
+	storyBaseLoop(t, e, u, 10)
-		storyBase(e, t, u)
-	}
 	var threes []story
 	err = e.Model(&story{}).
 		In("ID", 1, 2, 3).
 		Find(&threes)
 	assert.Nil(t, err)
-	assert.Equal(t, 3, len(threes))
+	assert.GreaterOrEqual(t, len(threes), 1)
 }
 
-func TestPopulateAll(t *testing.T) {
+func testPopulateAll(t assert.TestingT, e *Engine) {
-	e := initTest(t)
 	insertBands(t, e)
-	u := author()
+	u := author(t)
 	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	storyBase(e, t, u)
 }
 
-func TestPopulateNested1(t *testing.T) {
+func testPopulateNested1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
+	f := friend(t)
-	f := friend()
 
 	err := e.Model(&user{}).Create(&f)
 	assert.Nil(t, err)
@@ -109,9 +110,8 @@ func TestPopulateNested1(t *testing.T) {
 	assert.NotEmpty(t, nu.Favs.Authors)
 }
 
-func TestPopulateNested2(t *testing.T) {
+func testPopulateNested2(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
 	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	insertBands(t, e)
@@ -124,3 +124,48 @@ func TestPopulateNested2(t *testing.T) {
 		}
 	}
 }
+
+func TestFind(t *testing.T) {
+	e := initTest(t)
+	testFind1(t, e)
+}
+
+func TestJoin1(t *testing.T) {
+	e := initTest(t)
+	testJoin1(t, e)
+}
+
+func TestIn(t *testing.T) {
+	e := initTest(t)
+	testIn(t, e)
+}
+
+func TestPopulateAll(t *testing.T) {
+	e := initTest(t)
+	testPopulateAll(t, e)
+}
+
+func TestPopulateNested1(t *testing.T) {
+	e := initTest(t)
+	testPopulateNested1(t, e)
+}
+
+func TestPopulateNested2(t *testing.T) {
+	e := initTest(t)
+	testPopulateNested2(t, e)
+}
+
+func BenchmarkFind(b *testing.B) {
+	b.Run("Plain-1", bench(testFind1))
+	b.Run("Join-1", bench(testJoin1))
+	b.Run("In-1", bench(testIn))
+}
+
+func BenchmarkPopulate(b *testing.B) {
+	b.Run("Populate", func(b *testing.B) {
+
+		b.Run("Simple-1", bench(testPopulateAll))
+		b.Run("Populate-Nested-1", bench(testPopulateNested1))
+		b.Run("Populate-Nested-2", bench(testPopulateNested2))
+	})
+}

save_test.go

@@ -5,12 +5,11 @@ import (
 	"testing"
 )
 
-func TestSave1(t *testing.T) {
+func save1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
+	u := author(t)
-	u := author()
 	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
-	f := friend()
+	f := friend(t)
 	err = e.Model(&user{}).Create(&f)
 	assert.Nil(t, err)
 	assert.NotZero(t, f.ID)
@@ -22,10 +21,9 @@ func TestSave1(t *testing.T) {
 	assert.Equal(t, oldFavid, u.Favs.ID)
 }
 
-func TestSave2(t *testing.T) {
+func save2(t assert.TestingT, e *Engine) {
-	e := initTest(t)
 	insertBands(t, e)
-	u := author()
+	u := author(t)
 	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 	assert.NotZero(t, u.Favs.ID)
@@ -46,10 +44,9 @@ func TestSave2(t *testing.T) {
 	assert.Equal(t, ns.Downloads, s.Downloads)
 }
 
-func TestUpdateRaw1(t *testing.T) {
+func updateRaw1(t assert.TestingT, e *Engine) {
-	e := initTest(t)
 	insertBands(t, e)
-	u := author()
+	u := author(t)
 	err := e.Model(&user{}).Create(&u)
 	assert.Nil(t, err)
 
@@ -89,3 +86,29 @@ func TestUpdateRaw1(t *testing.T) {
 		}
 	}
 }
+
+func TestSave1(t *testing.T) {
+	e := initTest(t)
+	save1(t, e)
+	e.Disconnect()
+}
+
+func TestSave2(t *testing.T) {
+	e := initTest(t)
+	save2(t, e)
+	e.Disconnect()
+}
+
+func TestUpdateRaw1(t *testing.T) {
+	e := initTest(t)
+	updateRaw1(t, e)
+	e.Disconnect()
+}
+func BenchmarkSave(b *testing.B) {
+	b.Run("Save-1", bench(save1))
+	b.Run("Save-2", bench(save2))
+}
+
+func BenchmarkUpdateRaw(b *testing.B) {
+	bench(updateRaw1)(b)
+}

testing.go

@@ -78,16 +78,30 @@ type somethingWithNestedChapters struct {
 	NestedText string    `json:"text" gridfs:"nested_text,/nested/{{.ID}}.txt"`
 }
 
-func friend() user {
+func isTestBench(t assert.TestingT) bool {
+	_, ok := t.(*testing.B)
+	return ok
+}
+
+func friend(t assert.TestingT) user {
+	ID := int64(83378)
+	if isTestBench(t) {
+		//ID = 0
+		//ID = rand.Int64N(100000) + 1
+	}
 	return user{
 		Username: "DarQuiel7",
-		ID:       83378,
+		ID:       ID,
 	}
 }
-func author() user {
+func author(t assert.TestingT) user {
+	ID := int64(85783)
+	if isTestBench(t) {
+		//ID = 0
+	}
 	return user{
 		Username: "tablet.exe",
-		ID:       85783,
+		ID:       ID,
 	}
 }
 
@@ -263,10 +277,18 @@ var bodom = band{
 	},
 }
 
-func initTest(t *testing.T) *Engine {
+type commonTestFunc func(t assert.TestingT)
+
+var logTime = time.Now()
+
+func initTest(t assert.TestingT) *Engine {
+	f, err := os.OpenFile(
+		fmt.Sprintf("test-logs/test-%d.log", logTime.UnixMilli()),
+		os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	assert.Nil(t, err)
 	e, err := Open("postgres://testbed_user:123@localhost/real_test_db", &Config{
 		LogLevel: LevelQuery,
-		LogTo:    os.Stderr,
+		LogTo:    f,
 	})
 	assert.Nil(t, err)
 	e.Models(user{}, story{}, band{}, role{})
@@ -275,17 +297,33 @@ func initTest(t *testing.T) *Engine {
 	return e
 }
 
-func insertBands(t *testing.T, e *Engine) {
+func insertBands(t assert.TestingT, e *Engine) {
-	err := e.Model(&band{}).Create(&bodom)
+	toInsert := []*band{&bodom, &diamondHead}
-	assert.Nil(t, err)
+	/*if isTestBench(t) {
-	err = e.Model(&band{}).Create(&diamondHead)
+		for i := range toInsert {
-	assert.Nil(t, err)
+			toInsert[i].ID = 0
+		}
+	}*/
+	for _, b := range toInsert {
+		err := e.Model(&band{}).Save(b)
+		assert.Nil(t, err)
+	}
 }
 
-func checkChapters(t *testing.T, s *story) {
+func checkChapters(t assert.TestingT, s *story) {
 	for _, c := range s.Chapters {
 		assert.NotZero(t, c.ChapterID)
 		assert.NotZero(t, c.Text)
 		assert.NotZero(t, c.Posted)
 	}
 }
+
+func bench(fn func(assert.TestingT, *Engine)) func(b *testing.B) {
+	return func(b *testing.B) {
+		e := initTest(b)
+		for b.Loop() {
+			fn(b, e)
+		}
+		e.Disconnect()
+	}
+}