566 lines
13 KiB
Go
566 lines
13 KiB
Go
package simpleorm_test
|
|
|
|
import (
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.gdulai.com/gdulai/simpleorm/exec"
|
|
log "gitlab.com/gdulai/simpleloglvl"
|
|
)
|
|
|
|
func TestInsert(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
|
|
}
|
|
|
|
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 TestInsertAndUpdate(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("TestInsertAndUpdate setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
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)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
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
|
|
testObj.Int64Field = 69420
|
|
|
|
updateExec, err := exec.NewUpdate(orm, testObj)
|
|
if err != nil {
|
|
log.LogError("TestInsertAndUpdate setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = updateExec.Execute(conn)
|
|
selectErr := selectExec.Execute(conn)
|
|
|
|
// THEN
|
|
if err != nil {
|
|
log.LogError("TestInsertAndUpdate update failure. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
if selectErr != nil {
|
|
log.LogError("TestInsertAndUpdate select failure. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
res = selectExec.Results()
|
|
if len(res) != 1 {
|
|
log.LogError("TestInsertAndUpdate test failed. Expected: 1, Actual: %s", len(res))
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
singleRes := res[0]
|
|
if singleRes.ID != 1 || singleRes.Int64Field != 69420 || singleRes.IntField != 42069 || singleRes.StringField != "asdf" {
|
|
log.LogError("TestInsertAndUpdate invalid result. Expected: %s, Actual: %s", testObj, singleRes)
|
|
t.Fail()
|
|
}
|
|
|
|
}
|
|
|
|
func TestInsertAndDelete(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("TestInsertAndDelete setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = insertExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestInsertAndDelete setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
selectExec, err := exec.CreateSelect[Test](orm)
|
|
if err != nil {
|
|
log.LogError("TestInsertAndDelete setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = selectExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestInsertAndDelete setup failed. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
deleteExec, err := exec.NewDelete(orm, selectExec.Results())
|
|
err = deleteExec.Execute(conn)
|
|
|
|
// THEN
|
|
if err != nil {
|
|
log.LogError("TestInsertAndDelete delete failure. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
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()
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
func TestBoolInsertAndSelectSingle(t *testing.T) {
|
|
// GIVEN
|
|
orm, conn := testSetup()
|
|
defer cleanUp("test.db", conn)
|
|
|
|
testObj := TestWithBool{BoolField: true}
|
|
|
|
// WHEN
|
|
insertExec, err := exec.NewInsert(orm, testObj)
|
|
if err != nil {
|
|
log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
selectExec, err := exec.CreateSelect[TestWithBool](orm)
|
|
if err != nil {
|
|
log.LogError("TestBoolInsertAndSelectSingle setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = insertExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = selectExec.Execute(conn)
|
|
|
|
// THEN
|
|
if err != nil {
|
|
log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
res := selectExec.Results()
|
|
if len(res) != 1 {
|
|
log.LogError("TestBoolInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
singleRes := res[0]
|
|
if singleRes.ID != 1 || !singleRes.BoolField {
|
|
log.LogError("TestBoolInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
|
|
t.Fail()
|
|
}
|
|
|
|
}
|
|
|
|
func TestTimeInsertAndSelectSingle(t *testing.T) {
|
|
// GIVEN
|
|
orm, conn := testSetup()
|
|
defer cleanUp("test.db", conn)
|
|
|
|
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)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
selectExec, err := exec.CreateSelect[TestWithTime](orm)
|
|
if err != nil {
|
|
log.LogError("TestTimeInsertAndSelectSingle setup failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = insertExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
err = selectExec.Execute(conn)
|
|
|
|
// THEN
|
|
if err != nil {
|
|
log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
res := selectExec.Results()
|
|
if len(res) != 1 {
|
|
log.LogError("TestTimeInsertAndSelectSingle test failed. Expected: 1, Actual: %s", len(res))
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
singleRes := res[0]
|
|
if singleRes.ID != 1 || singleRes.TimeField != now {
|
|
log.LogError("TestTimeInsertAndSelectSingle invalid result. Expected: %s, Actual: %s", testObj, singleRes)
|
|
t.Fail()
|
|
}
|
|
|
|
}
|
|
|
|
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)
|
|
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)
|
|
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
|
|
}
|
|
}
|
|
|
|
func TestCount(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
|
|
|
|
countExec, err := exec.CreateCount[Test](orm, "")
|
|
if err != nil {
|
|
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
err = countExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
// THEN
|
|
|
|
if countExec.Result() != 1000 {
|
|
log.LogError("TestSelectWithLimitAndOffset expected result size 1000, actual: %s", countExec.Result())
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestCountWithCondition(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
|
|
|
|
countExec, err := exec.CreateCount[Test](orm, "id % 2 = 0")
|
|
if err != nil {
|
|
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
err = countExec.Execute(conn)
|
|
if err != nil {
|
|
log.LogError("TestSelectWithLimitAndOffset failed: %s", err)
|
|
t.Fail()
|
|
return
|
|
}
|
|
|
|
// THEN
|
|
|
|
if countExec.Result() != 500 {
|
|
log.LogError("TestSelectWithLimitAndOffset expected result size 500, actual: %s", countExec.Result())
|
|
t.Fail()
|
|
}
|
|
}
|