simpleorm/test/exec_test.go

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")
	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
	}

	err = selectExec.Execute(conn)

	if err != nil {
		log.LogError("Select failure. %s", err)
		t.Fail()
		return
	}
	if len(selectExec.GetResult()) > 0 {
		log.LogError("Expected empty result.")
		t.Fail()
		return
	}
}

func TestInsertAndSelectSingle(t *testing.T) {
	// GIVEN
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	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"}

	insertExec, err := exec.NewInsert[Test](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
	}

	// WHEN
	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)

	// THEN
	res := selectExec.GetResult()

	if err != 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))
		t.Fail()
		return
	}

	singleRes := res[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
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	defer cleanUp("test.db", conn)
	orm := simpleorm.NewORM(Test{}, TestWithFk{}, TestWithFkAndFkId{},
		TestWithCompositePk{}, TestWithCompositeFk{})

	exec.ExecuteDDL(conn, orm)

	testObj := TestWithCompositePk{ID: 12, Name: "Test"}

	insertExec, err := exec.NewInsert[TestWithCompositePk](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
	}

	// WHEN
	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	res := selectExec.GetResult()

	// THEN
	if err != nil {
		log.LogError("TestInsertSelectWithCompositePk failure. %s", err)
		t.Fail()
		return
	}
	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
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	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"}
	testObjSecond := Test{Int64Field: 12, IntField: 54, StringField: "fdsa"}

	insertExec, err := exec.NewInsert[Test](orm, testObj)
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	insertSecond, err := exec.NewInsert[Test](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
	}

	// WHEN

	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)
	res := selectExec.GetResult()

	// THEN
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam failure. %s", err)
		t.Fail()
		return
	}
	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
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	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"}

	insertExec, err := exec.NewInsert[Test](orm, testObj)
	if err != nil {
		log.LogError("TestInsertAndUpdate setup failed: %s", err)
		t.Fail()
		return
	}

	selectExec, err := exec.CreateSelect[Test](orm, "string_field = ?", "asdf")
	if err != nil {
		log.LogError("TestInsertMultipleAndSelectWithParam setup failed: %s", err)
		t.Fail()
		return
	}

	// WHEN

	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestInsertAndUpdate insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	res := selectExec.GetResult()

	if err != nil {
		log.LogError("TestInsertAndUpdate re-select failed: %s", err)
		t.Fail()
		return
	}

	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)
	res = selectExec.GetResult()

	// 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
	}

	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
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	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"}

	insertExec, err := exec.NewInsert[Test](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)
	selectRes := selectExec.GetResult()

	if err != nil {
		log.LogError("TestInsertAndDelete setup failed. %s", err)
		t.Fail()
		return
	}

	deleteExec, err := exec.NewDelete[Test](orm, selectRes...)

	// WHEN
	err = deleteExec.Execute(conn)

	// THEN
	if err != nil {
		log.LogError("TestInsertAndDelete delete failure. %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	selectRes = selectExec.GetResult()

	if len(selectRes) != 0 {
		log.LogError("TestInsertAndDelete test failed. Expected: 0, Actual: %s", len(selectRes))
		t.Fail()
		return
	}

}

func TestBoolInsertAndSelectSingle(t *testing.T) {
	// GIVEN
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	defer cleanUp("test.db", conn)
	orm := simpleorm.NewORM(TestWithBool{})

	exec.ExecuteDDL(conn, orm)

	testObj := TestWithBool{BoolField: true}

	insertExec, err := exec.NewInsert[TestWithBool](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
	}

	// WHEN
	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	res := selectExec.GetResult()

	// THEN
	if err != nil {
		log.LogError("TestBoolInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}
	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
	conn := simpleorm.OpenConnection("sqlite3", "file:test.db")
	defer cleanUp("test.db", conn)
	orm := simpleorm.NewORM(TestWithTime{})

	exec.ExecuteDDL(conn, orm)

	now := time.Now().UnixMilli()
	testObj := TestWithTime{TimeField: now}

	insertExec, err := exec.NewInsert[TestWithTime](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
	}

	// WHEN
	err = insertExec.Execute(conn)
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle insert failed: %s", err)
		t.Fail()
		return
	}

	err = selectExec.Execute(conn)
	res := selectExec.GetResult()

	// THEN
	if err != nil {
		log.LogError("TestTimeInsertAndSelectSingle failure. %s", err)
		t.Fail()
		return
	}
	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()
	}

}