gdulai/simpleorm
Public Access
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

WIP: Refactor Exec implementations to be chainable

Browse Source
This commit is contained in:
gdulai
2026-06-05 12:33:46 +02:00
parent d10d0f8414
commit d20184a6f0
5 changed files with 480 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/exec_test.go
+9 -272
View File
@@ -9,36 +9,6 @@ import (
log "gitlab.com/gdulai/simpleloglvl"
)
func TestSelectEmpty(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
// WHEN
selectExec, err := exec.CreateSelect[Test](orm, "")
// THEN
if err != nil {
log.LogError("Failed to create select. %s", err)
t.Fail()
return
}
err = selectExec.Execute(conn)
if err != nil {
log.LogError("Select failure. %s", err)
t.Fail()
return
}
res := selectExec.Results()
if len(res) > 0 {
log.LogError("Expected empty result.")
t.Fail()
return
}
}
func TestInsert(t *testing.T) {
// GIVEN
orm, conn := testSetup()
@@ -133,193 +103,6 @@ func TestInsertMultiple(t *testing.T) {
}
func TestInsertAndSelectSingle(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
t.Fail()
return
}
selectExec, err := exec.CreateSelect[Test](orm, "")
if err != nil {
log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
t.Fail()
return
}
insertErr := insertExec.Execute(conn)
selectErr := selectExec.Execute(conn)
// THEN
if insertErr != nil {
log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
if selectErr != nil {
log.LogError("TestInsertAndSelectSingle failure. %s", err)
t.Fail()
return
}
insertRes := insertExec.Results()
if len(insertRes) != 1 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
t.Fail()
return
}
selectRes := selectExec.Results()
if len(selectRes) != 1 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(selectRes))
t.Fail()
return
}
singleRes := insertRes[0]
if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
t.Fail()
}
singleRes = selectRes[0]
if singleRes.ID != 1 || singleRes.Int64Field != 54 || singleRes.IntField != 12 || singleRes.StringField != "asdf" {
log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
t.Fail()
}
}
func TestInsertSelectWithCompositePk(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := TestWithCompositePk{ID: 12, Name: "Test"}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
t.Fail()
return
}
selectExec, err := exec.CreateSelect[TestWithCompositePk](orm, "")
if err != nil {
log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
t.Fail()
return
}
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
t.Fail()
return
}
err = selectExec.Execute(conn)
// THEN
if err != nil {
log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
return
}
singleRes := res[0]
if singleRes.ID != 12 || singleRes.Name != "Test" {
log.LogError("TestInsertSelectWithCompositePk invalid result. Expected: %s, Actual: %s", testObj, singleRes)
t.Fail()
}
}
func TestInsertMultipleAndSelectWithParam(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
// WHEN
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
t.Fail()
return
}
insertSecond, err := exec.NewInsert(orm, testObjSecond)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
t.Fail()
return
}
selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "fdsa")
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
t.Fail()
return
}
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
t.Fail()
return
}
err = insertSecond.Execute(conn)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
t.Fail()
return
}
err = selectExec.Execute(conn)
// THEN
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
return
}
singleRes := res[0]
if singleRes.ID != 2 || singleRes.Int64Field != 12 || singleRes.IntField != 54 || singleRes.StringField != "fdsa" {
log.LogError("TestInsertMultipleAndSelectWithParam invalid result. Expected: %s, Actual: %s", testObjSecond, singleRes)
t.Fail()
return
}
}
func TestInsertAndUpdate(t *testing.T) {
// GIVEN
orm, conn := testSetup()
@@ -335,13 +118,15 @@ func TestInsertAndUpdate(t *testing.T) {
return
}
selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
selectExec, err := exec.CreateSelect[Test](orm)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
t.Fail()
return
}
selectExec.Where("string_field = ?", "asdf")
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndUpdate insert failed: %s", err)
@@ -422,7 +207,7 @@ func TestInsertAndDelete(t *testing.T) {
return
}
selectExec, err := exec.CreateSelect[Test](orm, "")
selectExec, err := exec.CreateSelect[Test](orm)
if err != nil {
log.LogError("TestInsertAndDelete setup failed: %s", err)
t.Fail()
@@ -478,7 +263,7 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
return
}
selectExec, err := exec.CreateSelect[TestWithBool](orm, "")
selectExec, err := exec.CreateSelect[TestWithBool](orm)
if err != nil {
log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
t.Fail()
@@ -532,7 +317,7 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
return
}
selectExec, err := exec.CreateSelect[TestWithTime](orm, "")
selectExec, err := exec.CreateSelect[TestWithTime](orm)
if err != nil {
log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
t.Fail()
@@ -638,13 +423,15 @@ func TestTransactionRollback(t *testing.T) {
return
}
selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID)
selectExec, err := exec.CreateSelect[Test](orm)
if err != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
t.Fail()
return
}
selectExec.Where("id = ?", insertExec.Results()[0].ID)
transErr = transaction.Execute(&selectExec)
if transErr != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
@@ -683,56 +470,6 @@ func TestTransactionRollback(t *testing.T) {
}
}
func TestSelectWithLimitAndOffset(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testEntites := []Test{}
for i := 0; i < 1000; i++ {
testEntites = append(testEntites, Test{Int64Field: -1, IntField: i, StringField: "Entity " + strconv.Itoa(i)})
}
insertExec, err := exec.NewInsert[Test](orm, testEntites...)
if err != nil {
log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
t.Fail()
return
}
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestSelectWithLimitAndOffset setup failed: %s", err)
t.Fail()
return
}
// WHEN
selectExec, err := exec.CreateSelect[Test](orm, "")
if err != nil {
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
t.Fail()
return
}
selectExec.Limit = 100
selectExec.Offset = 0
err = selectExec.Execute(conn)
if err != nil {
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
t.Fail()
return
}
// THEN
if len(selectExec.Results()) != 100 {
log.LogError("TestSelectWithLimitAndOffset expected result size 100, actual: %s", len(selectExec.Results()))
t.Fail()
}
}
func TestCount(t *testing.T) {
// GIVEN
orm, conn := testSetup()