From 76948d93d6c919fc74976413d34b4d125ae16af8 Mon Sep 17 00:00:00 2001 From: oldme <45782393+oldme-git@users.noreply.github.com> Date: Mon, 11 Nov 2024 20:54:57 +0800 Subject: [PATCH] test(drivers/mysql): use asserts function to replace if statement (#3849) --- .../mysql/mysql_z_unit_transaction_test.go | 710 +++++++++--------- 1 file changed, 357 insertions(+), 353 deletions(-) diff --git a/contrib/drivers/mysql/mysql_z_unit_transaction_test.go b/contrib/drivers/mysql/mysql_z_unit_transaction_test.go index 01cf5f48f77..b0e2a0cc19e 100644 --- a/contrib/drivers/mysql/mysql_z_unit_transaction_test.go +++ b/contrib/drivers/mysql/mysql_z_unit_transaction_test.go @@ -20,67 +20,71 @@ import ( ) func Test_TX_Query(t *testing.T) { - tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err = tx.Query("SELECT ?", 1); err != nil { - gtest.Error(err) - } - if _, err = tx.Query("SELECT ?+?", 1, 2); err != nil { - gtest.Error(err) - } - if _, err = tx.Query("SELECT ?+?", g.Slice{1, 2}); err != nil { - gtest.Error(err) - } - if _, err = tx.Query("ERROR"); err == nil { - gtest.Error("FAIL") - } - if err = tx.Commit(); err != nil { - gtest.Error(err) - } + gtest.C(t, func(t *gtest.T) { + tx, err := db.Begin(ctx) + t.AssertNil(err) + + _, err = tx.Query("SELECT ?", 1) + t.AssertNil(err) + + _, err = tx.Query("SELECT ?+?", 1, 2) + t.AssertNil(err) + + _, err = tx.Query("SELECT ?+?", g.Slice{1, 2}) + t.AssertNil(err) + + _, err = tx.Query("ERROR") + t.AssertNE(err, nil) + + err = tx.Commit() + t.AssertNil(err) + + }) } func Test_TX_Exec(t *testing.T) { - tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Exec("SELECT ?", 1); err != nil { - gtest.Error(err) - } - if _, err := tx.Exec("SELECT ?+?", 1, 2); err != nil { - gtest.Error(err) - } - if _, err := tx.Exec("SELECT ?+?", g.Slice{1, 2}); err != nil { - gtest.Error(err) - } - if _, err := tx.Exec("ERROR"); err == nil { - gtest.Error("FAIL") - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + gtest.C(t, func(t *gtest.T) { + tx, err := db.Begin(ctx) + t.AssertNil(err) + + _, err = tx.Exec("SELECT ?", 1) + t.AssertNil(err) + + _, err = tx.Exec("SELECT ?+?", 1, 2) + t.AssertNil(err) + + _, err = tx.Exec("SELECT ?+?", g.Slice{1, 2}) + t.AssertNil(err) + + _, err = tx.Exec("ERROR") + t.AssertNE(err, nil) + + err = tx.Commit() + t.AssertNil(err) + + }) } func Test_TX_Commit(t *testing.T) { - tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + gtest.C(t, func(t *gtest.T) { + tx, err := db.Begin(ctx) + t.AssertNil(err) + + err = tx.Commit() + t.AssertNil(err) + + }) } func Test_TX_Rollback(t *testing.T) { - tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if err := tx.Rollback(); err != nil { - gtest.Error(err) - } + gtest.C(t, func(t *gtest.T) { + tx, err := db.Begin(ctx) + t.AssertNil(err) + + err = tx.Rollback() + t.AssertNil(err) + + }) } func Test_TX_Prepare(t *testing.T) { @@ -96,6 +100,7 @@ func Test_TX_Prepare(t *testing.T) { array, err := rows.Columns() t.AssertNil(err) + t.Assert(array[0], "100") err = rows.Close() @@ -103,6 +108,7 @@ func Test_TX_Prepare(t *testing.T) { err = tx.Commit() t.AssertNil(err) + }) } @@ -112,38 +118,36 @@ func Test_TX_Insert(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + user := tx.Model(table) - if _, err := user.Data(g.Map{ + + _, err = user.Data(g.Map{ "id": 1, "passport": "t1", "password": "25d55ad283aa400af464c76d713c07ad", "nickname": "T1", "create_time": gtime.Now().String(), - }).Insert(); err != nil { - gtest.Error(err) - } - if _, err := tx.Insert(table, g.Map{ + }).Insert() + t.AssertNil(err) + + _, err = tx.Insert(table, g.Map{ "id": 2, "passport": "t1", "password": "25d55ad283aa400af464c76d713c07ad", "nickname": "T1", "create_time": gtime.Now().String(), - }); err != nil { - gtest.Error(err) - } + }) + t.AssertNil(err) - if n, err := tx.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(2)) - } + n, err := tx.Model(table).Count() + t.AssertNil(err) + + t.Assert(n, int64(2)) + + err = tx.Commit() + t.AssertNil(err) - if err := tx.Commit(); err != nil { - gtest.Error(err) - } }) } @@ -153,10 +157,9 @@ func Test_TX_BatchInsert(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Insert(table, g.List{ + t.AssertNil(err) + + _, err = tx.Insert(table, g.List{ { "id": 2, "passport": "t", @@ -171,17 +174,16 @@ func Test_TX_BatchInsert(t *testing.T) { "nickname": "T3", "create_time": gtime.Now().String(), }, - }, 10); err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } - if n, err := db.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(2)) - } + }, 10) + t.AssertNil(err) + + err = tx.Commit() + t.AssertNil(err) + + n, err := db.Model(table).Count() + t.AssertNil(err) + + t.Assert(n, int64(2)) }) } @@ -191,10 +193,9 @@ func Test_TX_BatchReplace(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Replace(table, g.List{ + t.AssertNil(err) + + _, err = tx.Replace(table, g.List{ { "id": 2, "passport": "USER_2", @@ -209,22 +210,21 @@ func Test_TX_BatchReplace(t *testing.T) { "nickname": "NAME_4", "create_time": gtime.Now().String(), }, - }, 10); err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } - if n, err := db.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(TableSize)) - } - if value, err := db.Model(table).Fields("password").Where("id", 2).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "PASS_2") - } + }, 10) + t.AssertNil(err) + + err = tx.Commit() + t.AssertNil(err) + + n, err := db.Model(table).Count() + t.AssertNil(err) + + t.Assert(n, int64(TableSize)) + + value, err := db.Model(table).Fields("password").Where("id", 2).Value() + t.AssertNil(err) + + t.Assert(value.String(), "PASS_2") }) } @@ -234,10 +234,9 @@ func Test_TX_BatchSave(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Save(table, g.List{ + t.AssertNil(err) + + _, err = tx.Save(table, g.List{ { "id": 4, "passport": "USER_4", @@ -245,24 +244,21 @@ func Test_TX_BatchSave(t *testing.T) { "nickname": "NAME_4", "create_time": gtime.Now().String(), }, - }, 10); err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + }, 10) + t.AssertNil(err) - if n, err := db.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(TableSize)) - } + err = tx.Commit() + t.AssertNil(err) - if value, err := db.Model(table).Fields("password").Where("id", 4).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "PASS_4") - } + n, err := db.Model(table).Count() + t.AssertNil(err) + + t.Assert(n, int64(TableSize)) + + value, err := db.Model(table).Fields("password").Where("id", 4).Value() + t.AssertNil(err) + + t.Assert(value.String(), "PASS_4") }) } @@ -272,26 +268,24 @@ func Test_TX_Replace(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Replace(table, g.Map{ + t.AssertNil(err) + + _, err = tx.Replace(table, g.Map{ "id": 1, "passport": "USER_1", "password": "PASS_1", "nickname": "NAME_1", "create_time": gtime.Now().String(), - }); err != nil { - gtest.Error(err) - } - if err := tx.Rollback(); err != nil { - gtest.Error(err) - } - if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "name_1") - } + }) + t.AssertNil(err) + + err = tx.Rollback() + t.AssertNil(err) + + value, err := db.Model(table).Fields("nickname").Where("id", 1).Value() + t.AssertNil(err) + + t.Assert(value.String(), "name_1") }) } @@ -301,26 +295,24 @@ func Test_TX_Save(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Save(table, g.Map{ + t.AssertNil(err) + + _, err = tx.Save(table, g.Map{ "id": 1, "passport": "USER_1", "password": "PASS_1", "nickname": "NAME_1", "create_time": gtime.Now().String(), - }); err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } - if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "NAME_1") - } + }) + t.AssertNil(err) + + err = tx.Commit() + t.AssertNil(err) + + value, err := db.Model(table).Fields("nickname").Where("id", 1).Value() + t.AssertNil(err) + + t.Assert(value.String(), "NAME_1") }) } @@ -330,26 +322,24 @@ func Test_TX_Update(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if result, err := tx.Update(table, "create_time='2019-10-24 10:00:00'", "id=3"); err != nil { - gtest.Error(err) - } else { - n, _ := result.RowsAffected() - t.Assert(n, 1) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + t.AssertNil(err) + + result, err := tx.Update(table, "create_time='2019-10-24 10:00:00'", "id=3") + t.AssertNil(err) + + n, _ := result.RowsAffected() + t.Assert(n, 1) + + err = tx.Commit() + t.AssertNil(err) + _, err = tx.Model(table).Fields("create_time").Where("id", 3).Value() t.AssertNE(err, nil) - if value, err := db.Model(table).Fields("create_time").Where("id", 3).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "2019-10-24 10:00:00") - } + value, err := db.Model(table).Fields("create_time").Where("id", 3).Value() + t.AssertNil(err) + + t.Assert(value.String(), "2019-10-24 10:00:00") }) } @@ -359,17 +349,16 @@ func Test_TX_GetAll(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if result, err := tx.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil { - gtest.Error(err) - } else { - t.Assert(len(result), 1) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + t.AssertNil(err) + + result, err := tx.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1) + t.AssertNil(err) + + t.Assert(len(result), 1) + + err = tx.Commit() + t.AssertNil(err) + }) } @@ -379,20 +368,17 @@ func Test_TX_GetOne(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if record, err := tx.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "user_2"); err != nil { - gtest.Error(err) - } else { - if record == nil { - gtest.Error("FAIL") - } - t.Assert(record["nickname"].String(), "name_2") - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + t.AssertNil(err) + + record, err := tx.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "user_2") + t.AssertNil(err) + + t.AssertNE(record, nil) + t.Assert(record["nickname"].String(), "name_2") + + err = tx.Commit() + t.AssertNil(err) + }) } @@ -402,17 +388,16 @@ func Test_TX_GetValue(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if value, err := tx.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "user_3"); err != nil { - gtest.Error(err) - } else { - t.Assert(value.Int(), 3) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + t.AssertNil(err) + + value, err := tx.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "user_3") + t.AssertNil(err) + + t.Assert(value.Int(), 3) + + err = tx.Commit() + t.AssertNil(err) + }) } @@ -422,17 +407,16 @@ func Test_TX_GetCount(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if count, err := tx.GetCount("SELECT * FROM " + table); err != nil { - gtest.Error(err) - } else { - t.Assert(count, int64(TableSize)) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + t.AssertNil(err) + + count, err := tx.GetCount("SELECT * FROM " + table) + t.AssertNil(err) + + t.Assert(count, int64(TableSize)) + + err = tx.Commit() + t.AssertNil(err) + }) } @@ -442,9 +426,8 @@ func Test_TX_GetStruct(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -453,20 +436,21 @@ func Test_TX_GetStruct(t *testing.T) { CreateTime gtime.Time } user := new(User) - if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil { - gtest.Error(err) - } + err = tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3) + t.AssertNil(err) + t.Assert(user.NickName, "name_3") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + + err = tx.Commit() + t.AssertNil(err) + }) + gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -475,14 +459,14 @@ func Test_TX_GetStruct(t *testing.T) { CreateTime *gtime.Time } user := new(User) - if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil { - gtest.Error(err) - } + err = tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3) + t.AssertNil(err) + t.Assert(user.NickName, "name_3") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) } @@ -492,9 +476,8 @@ func Test_TX_GetStructs(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -503,9 +486,9 @@ func Test_TX_GetStructs(t *testing.T) { CreateTime gtime.Time } var users []User - if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { - gtest.Error(err) - } + err = tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1) + t.AssertNil(err) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) @@ -514,16 +497,15 @@ func Test_TX_GetStructs(t *testing.T) { t.Assert(users[1].NickName, "name_2") t.Assert(users[2].NickName, "name_3") t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -532,9 +514,9 @@ func Test_TX_GetStructs(t *testing.T) { CreateTime *gtime.Time } var users []User - if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { - gtest.Error(err) - } + err = tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1) + t.AssertNil(err) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) @@ -543,9 +525,9 @@ func Test_TX_GetStructs(t *testing.T) { t.Assert(users[1].NickName, "name_2") t.Assert(users[2].NickName, "name_3") t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) } @@ -555,9 +537,8 @@ func Test_TX_GetScan(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -566,20 +547,19 @@ func Test_TX_GetScan(t *testing.T) { CreateTime gtime.Time } user := new(User) - if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil { - gtest.Error(err) - } + err = tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3) + t.AssertNil(err) + t.Assert(user.NickName, "name_3") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -588,21 +568,20 @@ func Test_TX_GetScan(t *testing.T) { CreateTime *gtime.Time } user := new(User) - if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil { - gtest.Error(err) - } + err = tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3) + t.AssertNil(err) + t.Assert(user.NickName, "name_3") t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -611,9 +590,9 @@ func Test_TX_GetScan(t *testing.T) { CreateTime gtime.Time } var users []User - if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { - gtest.Error(err) - } + err = tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1) + t.AssertNil(err) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) @@ -622,16 +601,15 @@ func Test_TX_GetScan(t *testing.T) { t.Assert(users[1].NickName, "name_2") t.Assert(users[2].NickName, "name_3") t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } + t.AssertNil(err) + type User struct { Id int Passport string @@ -640,9 +618,9 @@ func Test_TX_GetScan(t *testing.T) { CreateTime *gtime.Time } var users []User - if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil { - gtest.Error(err) - } + err = tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1) + t.AssertNil(err) + t.Assert(len(users), TableSize) t.Assert(users[0].Id, 1) t.Assert(users[1].Id, 2) @@ -651,9 +629,9 @@ func Test_TX_GetScan(t *testing.T) { t.Assert(users[1].NickName, "name_2") t.Assert(users[2].NickName, "name_3") t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00") - if err := tx.Commit(); err != nil { - gtest.Error(err) - } + err = tx.Commit() + t.AssertNil(err) + }) } @@ -662,21 +640,18 @@ func Test_TX_Delete(t *testing.T) { table := createInitTable() defer dropTable(table) tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Delete(table, 1); err != nil { - gtest.Error(err) - } - if err := tx.Commit(); err != nil { - gtest.Error(err) - } - if n, err := db.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(0)) - } + t.AssertNil(err) + + _, err = tx.Delete(table, 1) + t.AssertNil(err) + err = tx.Commit() + t.AssertNil(err) + + n, err := db.Model(table).Count() + t.AssertNil(err) + + t.Assert(n, int64(0)) t.Assert(tx.IsClosed(), true) }) @@ -684,27 +659,22 @@ func Test_TX_Delete(t *testing.T) { table := createInitTable() defer dropTable(table) tx, err := db.Begin(ctx) - if err != nil { - gtest.Error(err) - } - if _, err := tx.Delete(table, 1); err != nil { - gtest.Error(err) - } - if n, err := tx.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(0)) - } - if err := tx.Rollback(); err != nil { - gtest.Error(err) - } - if n, err := db.Model(table).Count(); err != nil { - gtest.Error(err) - } else { - t.Assert(n, int64(TableSize)) - t.AssertNE(n, int64(0)) - } + t.AssertNil(err) + + _, err = tx.Delete(table, 1) + t.AssertNil(err) + + n, err := tx.Model(table).Count() + t.AssertNil(err) + t.Assert(n, int64(0)) + + err = tx.Rollback() + t.AssertNil(err) + n, err = db.Model(table).Count() + t.AssertNil(err) + t.Assert(n, int64(TableSize)) + t.AssertNE(n, int64(0)) t.Assert(tx.IsClosed(), true) }) } @@ -716,48 +686,43 @@ func Test_Transaction(t *testing.T) { gtest.C(t, func(t *gtest.T) { ctx := context.TODO() err := db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error { - if _, err := tx.Ctx(ctx).Replace(table, g.Map{ + _, err := tx.Ctx(ctx).Replace(table, g.Map{ "id": 1, "passport": "USER_1", "password": "PASS_1", "nickname": "NAME_1", "create_time": gtime.Now().String(), - }); err != nil { - t.Error(err) - } + }) + t.AssertNil(err) + t.Assert(tx.IsClosed(), false) return gerror.New("error") }) t.AssertNE(err, nil) - if value, err := db.Model(table).Ctx(ctx).Fields("nickname").Where("id", 1).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "name_1") - } + value, err := db.Model(table).Ctx(ctx).Fields("nickname").Where("id", 1).Value() + t.AssertNil(err) + t.Assert(value.String(), "name_1") }) gtest.C(t, func(t *gtest.T) { ctx := context.TODO() err := db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error { - if _, err := tx.Replace(table, g.Map{ + _, err := tx.Replace(table, g.Map{ "id": 1, "passport": "USER_1", "password": "PASS_1", "nickname": "NAME_1", "create_time": gtime.Now().String(), - }); err != nil { - t.Error(err) - } + }) + t.AssertNil(err) return nil }) t.AssertNil(err) - if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "NAME_1") - } + value, err := db.Model(table).Fields("nickname").Where("id", 1).Value() + t.AssertNil(err) + t.Assert(value.String(), "NAME_1") }) } @@ -768,25 +733,22 @@ func Test_Transaction_Panic(t *testing.T) { gtest.C(t, func(t *gtest.T) { ctx := context.TODO() err := db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error { - if _, err := tx.Replace(table, g.Map{ + _, err := tx.Replace(table, g.Map{ "id": 1, "passport": "USER_1", "password": "PASS_1", "nickname": "NAME_1", "create_time": gtime.Now().String(), - }); err != nil { - t.Error(err) - } + }) + t.AssertNil(err) panic("error") return nil }) t.AssertNE(err, nil) - if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil { - gtest.Error(err) - } else { - t.Assert(value.String(), "name_1") - } + value, err := db.Model(table).Fields("nickname").Where("id", 1).Value() + t.AssertNil(err) + t.Assert(value.String(), "name_1") }) } @@ -797,9 +759,11 @@ func Test_Transaction_Nested_Begin_Rollback_Commit(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) t.AssertNil(err) + // tx begin. err = tx.Begin() t.AssertNil(err) + // tx rollback. _, err = tx.Model(table).Data(g.Map{ "id": 1, @@ -809,6 +773,7 @@ func Test_Transaction_Nested_Begin_Rollback_Commit(t *testing.T) { }).Insert() err = tx.Rollback() t.AssertNil(err) + // tx commit. _, err = tx.Model(table).Data(g.Map{ "id": 2, @@ -818,9 +783,11 @@ func Test_Transaction_Nested_Begin_Rollback_Commit(t *testing.T) { }).Insert() err = tx.Commit() t.AssertNil(err) + // check data. all, err := db.Model(table).All() t.AssertNil(err) + t.Assert(len(all), 1) t.Assert(all[0]["id"], 2) }) @@ -853,21 +820,27 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + // rollback err = tx.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error { _, err = tx.Model(table).Data(g.Map{ @@ -878,6 +851,7 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + panic("error") return err }) @@ -888,6 +862,7 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { all, err := db.Ctx(ctx).Model(table).All() t.AssertNil(err) + t.Assert(len(all), 1) t.Assert(all[0]["id"], 1) @@ -907,21 +882,27 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + // rollback err = tx.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error { _, err = tx.Model(table).Data(g.Map{ @@ -932,6 +913,7 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + panic("error") return err }) @@ -942,6 +924,7 @@ func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) { all, err = db.Ctx(ctx).Model(table).All() t.AssertNil(err) + t.Assert(len(all), 2) t.Assert(all[0]["id"], 1) t.Assert(all[1]["id"], 3) @@ -975,18 +958,23 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) @@ -1001,6 +989,7 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + // panic makes this transaction rollback. panic("error") return err @@ -1009,8 +998,10 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { return nil }) t.AssertNil(err) + all, err := db.Model(table).All() t.AssertNil(err) + t.Assert(len(all), 1) t.Assert(all[0]["id"], 1) @@ -1029,18 +1020,23 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) + return err }) t.AssertNil(err) @@ -1055,6 +1051,7 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { "create_time": gtime.Now().String(), }).Insert() t.AssertNil(err) + // panic makes this transaction rollback. panic("error") return err @@ -1066,6 +1063,7 @@ func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) { all, err = db.Model(table).All() t.AssertNil(err) + t.Assert(len(all), 2) t.Assert(all[0]["id"], 1) t.Assert(all[1]["id"], 3) @@ -1079,6 +1077,7 @@ func Test_Transaction_Nested_SavePoint_RollbackTo(t *testing.T) { gtest.C(t, func(t *gtest.T) { tx, err := db.Begin(ctx) t.AssertNil(err) + // tx save point. _, err = tx.Model(table).Data(g.Map{ "id": 1, @@ -1088,6 +1087,7 @@ func Test_Transaction_Nested_SavePoint_RollbackTo(t *testing.T) { }).Insert() err = tx.SavePoint("MyPoint") t.AssertNil(err) + _, err = tx.Model(table).Data(g.Map{ "id": 2, "passport": "user_2", @@ -1097,6 +1097,7 @@ func Test_Transaction_Nested_SavePoint_RollbackTo(t *testing.T) { // tx rollback to. err = tx.RollbackTo("MyPoint") t.AssertNil(err) + // tx commit. err = tx.Commit() t.AssertNil(err) @@ -1104,6 +1105,7 @@ func Test_Transaction_Nested_SavePoint_RollbackTo(t *testing.T) { // check data. all, err := db.Model(table).All() t.AssertNil(err) + t.Assert(len(all), 1) t.Assert(all[0]["id"], 1) }) @@ -1130,12 +1132,14 @@ func Test_Transaction_Method(t *testing.T) { "VALUES('t2','25d55ad283aa400af464c76d713c07ad','T2','2021-08-25 21:53:00',2) ", table)) t.AssertNil(err) + return gerror.New("rollback") }) t.AssertNE(err, nil) count, err := db.Model(table).Count() t.AssertNil(err) + t.Assert(count, int64(0)) }) }