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

Transaction implementation (#2)
Go Tests / test (push) Failing after 6s
Details

Browse Source 
Reviewed-on: #2
This commit was merged in pull request #2.
This commit is contained in:
gdulai
2026-05-24 16:40:04 +00:00
parent e98dbe3338
commit a6ff01d694
7 changed files with 597 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/exec_test.go
+286 -89
View File
@@ -1,48 +1,36 @@
package simpleorm_test
import (
"os"
"testing"
"time"
simpleorm "git.gdulai.com/gdulai/simpleorm"
"git.gdulai.com/gdulai/simpleorm/exec"
log "gitlab.com/gdulai/simpleloglvl"
)
func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
conn.Close()
os.Remove(dbFile)
}
func TestSelectEmpty(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
// WHEN
selectExec, err := exec.CreateSelect[Test](orm, "")
// THEN
if err != nil {
log.LogError("Failed to create select. %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
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()
@@ -50,17 +38,108 @@ func TestSelectEmpty(t *testing.T) {
}
}
func TestInsertAndSelectSingle(t *testing.T) {
func TestInsert(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
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
}
insertErr := insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
insertRes := insertExec.Results()
// THEN
if insertErr != nil {
log.LogError("TestInsertAndSelectSingle failure. %s", err)
t.Fail()
return
}
if len(insertRes) != 1 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
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()
}
}
func TestInsertMultiple(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
// WHEN
insertExec, err := exec.NewInsert[Test](orm, testObj, testObjSecond)
if err != nil {
log.LogError("TestInsertAndSelectSingle setup failed: %s", err)
t.Fail()
return
}
insertErr := insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
insertRes := insertExec.Results()
// THEN
if insertErr != nil {
log.LogError("TestInsertAndSelectSingle failure. %s", err)
t.Fail()
return
}
if len(insertRes) != 2 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
t.Fail()
return
}
entity := insertRes[0]
if entity.ID != 1 || entity.Int64Field != 54 || entity.IntField != 12 || entity.StringField != "asdf" {
log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, entity)
t.Fail()
}
entity = insertRes[1]
if entity.ID != 2 || entity.Int64Field != 12 || entity.IntField != 54 || entity.StringField != "fdsa" {
log.LogError("TestInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObjSecond, entity)
t.Fail()
}
}
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)
@@ -75,29 +154,43 @@ func TestInsertAndSelectSingle(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
if err != nil {
insertErr := insertExec.Execute(conn)
selectErr := selectExec.Execute(conn)
// THEN
if insertErr != nil {
log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
// THEN
if err != nil {
if selectErr != nil {
log.LogError("TestInsertAndSelectSingle failure. %s", err)
t.Fail()
return
}
if len(res) != 1 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
insertRes := insertExec.Results()
if len(insertRes) != 1 {
log.LogError("TestInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(insertRes))
t.Fail()
return
}
singleRes := res[0]
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()
@@ -107,15 +200,12 @@ func TestInsertAndSelectSingle(t *testing.T) {
func TestInsertSelectWithCompositePk(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
testObj := TestWithCompositePk{ID: 12, Name: "Test"}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertSelectWithCompositePk setup failed: %s", err)
@@ -130,15 +220,14 @@ func TestInsertSelectWithCompositePk(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
// THEN
if err != nil {
@@ -146,6 +235,8 @@ func TestInsertSelectWithCompositePk(t *testing.T) {
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError("TestInsertSelectWithCompositePk test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
@@ -162,14 +253,10 @@ func TestInsertSelectWithCompositePk(t *testing.T) {
func TestInsertMultipleAndSelectWithParam(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
// WHEN
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}
@@ -194,23 +281,21 @@ func TestInsertMultipleAndSelectWithParam(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam first insert failed: %s", err)
t.Fail()
return
}
_, err = insertSecond.Execute(conn)
err = insertSecond.Execute(conn)
if err != nil {
log.LogError("TestInsertMultipleAndSelectWithParam second insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
// THEN
if err != nil {
@@ -218,6 +303,8 @@ func TestInsertMultipleAndSelectWithParam(t *testing.T) {
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError(" TestInsertMultipleAndSelectWithParam test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
@@ -234,15 +321,12 @@ func TestInsertMultipleAndSelectWithParam(t *testing.T) {
func TestInsertAndUpdate(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertAndUpdate setup failed: %s", err)
@@ -257,22 +341,21 @@ func TestInsertAndUpdate(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndUpdate insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndUpdate re-select failed: %s", err)
t.Fail()
return
}
res := selectExec.Results()
testObj = res[0]
testObj.IntField = 42069
@@ -285,8 +368,8 @@ func TestInsertAndUpdate(t *testing.T) {
return
}
_, err = updateExec.Execute(conn)
res, selectErr := selectExec.Execute(conn)
err = updateExec.Execute(conn)
selectErr := selectExec.Execute(conn)
// THEN
if err != nil {
@@ -301,6 +384,7 @@ func TestInsertAndUpdate(t *testing.T) {
return
}
res = selectExec.Results()
if len(res) != 1 {
log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
@@ -317,15 +401,12 @@ func TestInsertAndUpdate(t *testing.T) {
func TestInsertAndDelete(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestInsertAndDelete setup failed: %s", err)
@@ -333,7 +414,7 @@ func TestInsertAndDelete(t *testing.T) {
return
}
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndDelete setup failed: %s", err)
t.Fail()
@@ -347,18 +428,15 @@ func TestInsertAndDelete(t *testing.T) {
return
}
selectRes, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
if err != nil {
log.LogError("TestInsertAndDelete setup failed. %s", err)
t.Fail()
return
}
deleteExec, err := exec.NewDelete(orm, selectRes)
// WHEN
_, err = deleteExec.Execute(conn)
deleteExec, err := exec.NewDelete(orm, selectExec.Results())
err = deleteExec.Execute(conn)
// THEN
if err != nil {
@@ -367,7 +445,15 @@ func TestInsertAndDelete(t *testing.T) {
return
}
selectRes, err = selectExec.Execute(conn)
err = selectExec.Execute(conn)
// THEN
if err != nil {
log.LogError("TestInsertAndDelete delete failure. %s", err)
t.Fail()
return
}
selectRes := selectExec.Results()
if len(selectRes) != 0 {
log.LogError("TestInsertAndDelete test failed. Expected: 0, Actual: %s", len(selectRes))
t.Fail()
@@ -378,14 +464,12 @@ func TestInsertAndDelete(t *testing.T) {
func TestBoolInsertAndSelectSingle(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(TestWithBool{})
exec.ExecuteDDL(conn, orm)
testObj := TestWithBool{BoolField: true}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
@@ -400,15 +484,14 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
// THEN
if err != nil {
@@ -416,6 +499,8 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
@@ -432,15 +517,13 @@ func TestBoolInsertAndSelectSingle(t *testing.T) {
func TestTimeInsertAndSelectSingle(t *testing.T) {
// GIVEN
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm, conn := testSetup()
defer cleanUp("test.db", conn)
orm := simpleorm.NewORM(TestWithTime{})
exec.ExecuteDDL(conn, orm)
now := time.Now().UnixMilli()
testObj := TestWithTime{TimeField: now}
// WHEN
insertExec, err := exec.NewInsert(orm, testObj)
if err != nil {
log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
@@ -455,15 +538,14 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
return
}
// WHEN
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
if err != nil {
log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
t.Fail()
return
}
res, err := selectExec.Execute(conn)
err = selectExec.Execute(conn)
// THEN
if err != nil {
@@ -471,6 +553,8 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
t.Fail()
return
}
res := selectExec.Results()
if len(res) != 1 {
log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
t.Fail()
@@ -484,3 +568,116 @@ func TestTimeInsertAndSelectSingle(t *testing.T) {
}
}
func TestTransactionExecuteSimple(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
transaction := exec.NewTransaction(conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
// WHEN
insertExec, err := exec.NewInsert[Test](orm, testObj)
if err != nil {
log.LogError("TestTransactionExecuteSimple failed: %s", err)
t.Fail()
return
}
transErr := transaction.Execute(&insertExec)
if transErr != nil {
transErr = transaction.Finish()
}
// THEN
if transErr != nil {
log.LogError("TestTransactionExecuteSimple failed: %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
}
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()
}
}
func TestTransactionRollback(t *testing.T) {
// GIVEN
orm, conn := testSetup()
defer cleanUp("test.db", conn)
transaction := exec.NewTransaction(conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
// WHEN
insertExec, err := exec.NewInsert[Test](orm, testObj)
if err != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
t.Fail()
return
}
transErr := transaction.Execute(&insertExec)
if transErr != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
t.Fail()
return
}
selectExec, err := exec.CreateSelect[Test](orm, "id = ?", insertExec.Results()[0].ID)
if err != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
t.Fail()
return
}
transErr = transaction.Execute(&selectExec)
if transErr != nil {
log.LogError("TestTransactionRollback WHEN failed: %s", err)
t.Fail()
return
}
beforeRollbackSelectRes := selectExec.Results()
rollbackErr := transaction.Rollback()
afterRollbackErr := selectExec.Execute(conn)
afterRollbackSelectRes := selectExec.Results()
// THEN
if len(beforeRollbackSelectRes) != 1 {
log.LogError("TestTransactionExecuteSimple-THEN: Expected 1, Actual: %s", len(beforeRollbackSelectRes))
t.Fail()
return
}
if rollbackErr != nil {
log.LogError("TestTransactionExecuteSimple-THEN: rollback error: %s", rollbackErr)
t.Fail()
return
}
if afterRollbackErr != nil {
log.LogError("TestTransactionExecuteSimple-THEN: after rollback select error: %s", rollbackErr)
t.Fail()
return
}
if len(afterRollbackSelectRes) != 0 {
log.LogError("TestTransactionExecuteSimple-THEN: Expected 0 after rollback select result")
t.Fail()
return
}
}
test/main_test.go
+17
View File
@@ -4,6 +4,8 @@ import (
"os"
"testing"
simpleorm "git.gdulai.com/gdulai/simpleorm"
"git.gdulai.com/gdulai/simpleorm/exec"
_ "github.com/mattn/go-sqlite3"
log "gitlab.com/gdulai/simpleloglvl"
)
@@ -61,3 +63,18 @@ func TestMain(m *testing.M) {
os.Exit(code)
}
func testSetup() (*simpleorm.ORM, *simpleorm.DBConnection) {
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{}, TestWithBool{}, TestWithTime{})
exec.ExecuteDDL(conn, orm)
return orm, conn
}
func cleanUp(dbFile string, conn *simpleorm.DBConnection) {
conn.Close()
os.Remove(dbFile)
}
test/repository_test.go
+20 -33
View File
@@ -3,26 +3,14 @@ package simpleorm_test
import (
"testing"
simpleorm "git.gdulai.com/gdulai/simpleorm"
"git.gdulai.com/gdulai/simpleorm/exec"
"git.gdulai.com/gdulai/simpleorm/repository"
log "gitlab.com/gdulai/simpleloglvl"
)
func repoTestSetup() (*simpleorm.ORM, *simpleorm.DBConnection) {
conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
TestWithCompositePk{}, TestWithCompositeFk{})
exec.ExecuteDDL(conn, orm)
return orm, conn
}
func TestRepoSelectAll(t *testing.T) {
// GIVEN
orm, conn := repoTestSetup()
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
@@ -32,7 +20,7 @@ func TestRepoSelectAll(t *testing.T) {
t.Fail()
return
}
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
repo := repository.NewRepository[Test](conn, orm)
// WHEN
@@ -48,7 +36,7 @@ func TestRepoSelectAll(t *testing.T) {
func TestRepoSelectByPk(t *testing.T) {
// GIVEN
orm, conn := repoTestSetup()
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
@@ -58,7 +46,7 @@ func TestRepoSelectByPk(t *testing.T) {
t.Fail()
return
}
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
repo := repository.NewRepository[Test](conn, orm)
// WHEN
@@ -74,7 +62,7 @@ func TestRepoSelectByPk(t *testing.T) {
func TestRepoSelectByCompundPk(t *testing.T) {
// GIVEN
orm, conn := repoTestSetup()
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := TestWithCompositePk{ID: 42069, Name: "Test"}
@@ -84,7 +72,7 @@ func TestRepoSelectByCompundPk(t *testing.T) {
t.Fail()
return
}
_, err = insertExec.Execute(conn)
err = insertExec.Execute(conn)
repo := repository.NewRepository[TestWithCompositePk](conn, orm)
// WHEN
@@ -100,46 +88,45 @@ func TestRepoSelectByCompundPk(t *testing.T) {
func TestRepoSave(t *testing.T) {
// GIVEN
orm, conn := repoTestSetup()
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
repo := repository.NewRepository[Test](conn, orm)
// WHEN
repo.Save(testObj)
err := repo.Save(testObj)
// THEN
res := repo.SelectByPk(1)
if res == nil {
log.LogError("TestRepoSave test failed. Result is nil!")
if err != nil {
log.LogError("TestRepoSave failed: %s", err)
}
if testObj.ID == 0 {
log.LogError("TestRepoSave failed! testObj.ID is 0!")
t.Fail()
return
}
}
func TestRepoDelete(t *testing.T) {
// GIVEN
orm, conn := repoTestSetup()
orm, conn := testSetup()
defer cleanUp("test.db", conn)
testObj := Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
testObj := &Test{Int64Field: 54, IntField: 12, StringField: "asdf"}
repo := repository.NewRepository[Test](conn, orm)
repo.Save(testObj)
res := repo.SelectByPk(1)
if res == nil {
err := repo.Save(testObj)
if err != nil {
log.LogError("TestRepoDelete setup failed! Test data not saved!")
t.Fail()
return
}
// WHEN
repo.Delete(*res)
repo.Delete(testObj)
// THEN
res = repo.SelectByPk(1)
res := repo.SelectByPk(testObj.ID)
if res != nil {
log.LogError("TestRepoDelete test failed. Result is not nil!")
t.Fail()