From eb9e20b46045d7bb3be649852380b7555fce2084 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Thu, 22 Jun 2023 19:20:52 +0800 Subject: [PATCH 01/11] --wip-- [skip ci] --- canal/canal_test.go | 103 ++++++++---------- client/auth_test.go | 14 +-- client/client_test.go | 240 +++++++++++++++++++++--------------------- client/common_test.go | 22 ---- client/conn_test.go | 104 +++++++++--------- client/pool_test.go | 25 +++-- driver/driver_test.go | 51 ++++----- dump/parser_test.go | 58 +++++----- dump/schema_test.go | 55 +++++----- dump/setup_test.go | 6 -- 10 files changed, 324 insertions(+), 354 deletions(-) diff --git a/canal/canal_test.go b/canal/canal_test.go index 80f463d2b..c1ab3901a 100644 --- a/canal/canal_test.go +++ b/canal/canal_test.go @@ -5,25 +5,24 @@ import ( "testing" "time" - . "github.com/pingcap/check" - "github.com/pingcap/errors" "github.com/pingcap/tidb/parser" "github.com/siddontang/go-log/log" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/replication" "github.com/go-mysql-org/go-mysql/test_util" ) -func Test(t *testing.T) { - TestingT(t) -} - type canalTestSuite struct { + suite.Suite c *Canal } -var _ = Suite(&canalTestSuite{}) +func TestCanal(t *testing.T) { + suite.Run(t, new(canalTestSuite)) +} const ( miA = 0 @@ -35,7 +34,7 @@ const ( umiC = 16777215 ) -func (s *canalTestSuite) SetUpSuite(c *C) { +func (s *canalTestSuite) SetUpSuite() { cfg := NewDefaultConfig() cfg.Addr = fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) cfg.User = "root" @@ -55,8 +54,8 @@ func (s *canalTestSuite) SetUpSuite(c *C) { var err error s.c, err = NewCanal(cfg) - c.Assert(err, IsNil) - s.execute(c, "DROP TABLE IF EXISTS test.canal_test") + require.NoError(s.T(), err) + s.execute("DROP TABLE IF EXISTS test.canal_test") sql := ` CREATE TABLE IF NOT EXISTS test.canal_test ( id int AUTO_INCREMENT, @@ -68,28 +67,28 @@ func (s *canalTestSuite) SetUpSuite(c *C) { )ENGINE=innodb; ` - s.execute(c, sql) + s.execute(sql) - s.execute(c, "DELETE FROM test.canal_test") - s.execute(c, "INSERT INTO test.canal_test (content, name, mi, umi) VALUES (?, ?, ?, ?), (?, ?, ?, ?), (?, ?, ?, ?)", + s.execute("DELETE FROM test.canal_test") + s.execute("INSERT INTO test.canal_test (content, name, mi, umi) VALUES (?, ?, ?, ?), (?, ?, ?, ?), (?, ?, ?, ?)", "1", "a", miA, umiA, `\0\ndsfasdf`, "b", miC, umiC, "", "c", miB, umiB, ) - s.execute(c, "SET GLOBAL binlog_format = 'ROW'") + s.execute("SET GLOBAL binlog_format = 'ROW'") - s.c.SetEventHandler(&testEventHandler{c: c}) + s.c.SetEventHandler(&testEventHandler{t: s.T()}) go func() { set, _ := mysql.ParseGTIDSet("mysql", "") err = s.c.StartFromGTID(set) - c.Assert(err, IsNil) + require.NoError(s.T(), err) }() } -func (s *canalTestSuite) TearDownSuite(c *C) { +func (s *canalTestSuite) TearDownSuite() { // To test the heartbeat and read timeout,so need to sleep 1 seconds without data transmission - c.Logf("Start testing the heartbeat and read timeout") + s.T().Logf("Start testing the heartbeat and read timeout") time.Sleep(time.Second) if s.c != nil { @@ -98,15 +97,15 @@ func (s *canalTestSuite) TearDownSuite(c *C) { } } -func (s *canalTestSuite) execute(c *C, query string, args ...interface{}) *mysql.Result { +func (s *canalTestSuite) execute(query string, args ...interface{}) *mysql.Result { r, err := s.c.Execute(query, args...) - c.Assert(err, IsNil) + require.NoError(s.T(), err) return r } type testEventHandler struct { DummyEventHandler - c *C + t *testing.T } func (h *testEventHandler) OnRow(e *RowsEvent) error { @@ -126,41 +125,41 @@ func (h *testEventHandler) OnPosSynced(header *replication.EventHeader, p mysql. return nil } -func (s *canalTestSuite) TestCanal(c *C) { +func (s *canalTestSuite) TestCanal() { <-s.c.WaitDumpDone() for i := 1; i < 10; i++ { - s.execute(c, "INSERT INTO test.canal_test (name) VALUES (?)", fmt.Sprintf("%d", i)) + s.execute("INSERT INTO test.canal_test (name) VALUES (?)", fmt.Sprintf("%d", i)) } - s.execute(c, "INSERT INTO test.canal_test (mi,umi) VALUES (?,?), (?,?), (?,?)", + s.execute("INSERT INTO test.canal_test (mi,umi) VALUES (?,?), (?,?), (?,?)", miA, umiA, miC, umiC, miB, umiB, ) - s.execute(c, "ALTER TABLE test.canal_test ADD `age` INT(5) NOT NULL AFTER `name`") - s.execute(c, "INSERT INTO test.canal_test (name,age) VALUES (?,?)", "d", "18") + s.execute("ALTER TABLE test.canal_test ADD `age` INT(5) NOT NULL AFTER `name`") + s.execute("INSERT INTO test.canal_test (name,age) VALUES (?,?)", "d", "18") err := s.c.CatchMasterPos(10 * time.Second) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *canalTestSuite) TestCanalFilter(c *C) { +func (s *canalTestSuite) TestCanalFilter() { // included sch, err := s.c.GetTable("test", "canal_test") - c.Assert(err, IsNil) - c.Assert(sch, NotNil) + require.NoError(s.T(), err) + require.NotNil(s.T(), sch) _, err = s.c.GetTable("not_exist_db", "canal_test") - c.Assert(errors.Trace(err), Not(Equals), ErrExcludedTable) + require.NotErrorIs(s.T(), err, ErrExcludedTable) // excluded sch, err = s.c.GetTable("test", "canal_test_inner") - c.Assert(errors.Cause(err), Equals, ErrExcludedTable) - c.Assert(sch, IsNil) + require.ErrorIs(s.T(), err, ErrExcludedTable) + require.Nil(s.T(), sch) sch, err = s.c.GetTable("mysql", "canal_test") - c.Assert(errors.Cause(err), Equals, ErrExcludedTable) - c.Assert(sch, IsNil) + require.ErrorIs(s.T(), err, ErrExcludedTable) + require.Nil(s.T(), sch) sch, err = s.c.GetTable("not_exist_db", "not_canal_test") - c.Assert(errors.Cause(err), Equals, ErrExcludedTable) - c.Assert(sch, IsNil) + require.ErrorIs(s.T(), err, ErrExcludedTable) + require.Nil(s.T(), sch) } func TestCreateTableExp(t *testing.T) { @@ -170,22 +169,20 @@ func TestCreateTableExp(t *testing.T) { "CREATE TABLE IF NOT EXISTS mydb.`mytable` (`id` int(10)) ENGINE=InnoDB", "CREATE TABLE IF NOT EXISTS `mydb`.mytable (`id` int(10)) ENGINE=InnoDB", } - table := "mytable" - db := "mydb" + expected := &node{ + db: "mydb", + table: "mytable", + } pr := parser.New() for _, s := range cases { stmts, _, err := pr.Parse(s, "", "") - if err != nil { - t.Fatalf("TestCreateTableExp:case %s failed\n", s) - } + require.NoError(t, err) for _, st := range stmts { nodes := parseStmt(st) if len(nodes) == 0 { continue } - if nodes[0].db != db || nodes[0].table != table { - t.Fatalf("TestCreateTableExp:case %s failed\n", s) - } + require.Equal(t, expected, nodes[0]) } } } @@ -203,9 +200,7 @@ func TestAlterTableExp(t *testing.T) { pr := parser.New() for _, s := range cases { stmts, _, err := pr.Parse(s, "", "") - if err != nil { - t.Fatalf("TestAlterTableExp:case %s failed\n", s) - } + require.NoError(t, err) for _, st := range stmts { nodes := parseStmt(st) if len(nodes) == 0 { @@ -237,9 +232,7 @@ func TestRenameTableExp(t *testing.T) { pr := parser.New() for _, s := range cases { stmts, _, err := pr.Parse(s, "", "") - if err != nil { - t.Fatalf("TestRenameTableExp:case %s failed\n", s) - } + require.NoError(t, err) for _, st := range stmts { nodes := parseStmt(st) if len(nodes) == 0 { @@ -281,9 +274,7 @@ func TestDropTableExp(t *testing.T) { pr := parser.New() for _, s := range cases { stmts, _, err := pr.Parse(s, "", "") - if err != nil { - t.Fatalf("TestDropTableExp:case %s failed\n", s) - } + require.NoError(t, err) for _, st := range stmts { nodes := parseStmt(st) if len(nodes) == 0 { @@ -325,9 +316,7 @@ func TestWithoutSchemeExp(t *testing.T) { pr := parser.New() for _, s := range cases { stmts, _, err := pr.Parse(string(s.Query), "", "") - if err != nil { - t.Fatalf("TestCreateTableExp:case %s failed\n", s.Query) - } + require.NoError(t, err) for _, st := range stmts { nodes := parseStmt(st) if len(nodes) == 0 { diff --git a/client/auth_test.go b/client/auth_test.go index d5c79a1b5..8d91e4118 100644 --- a/client/auth_test.go +++ b/client/auth_test.go @@ -1,10 +1,10 @@ package client import ( - "bytes" "testing" "github.com/go-mysql-org/go-mysql/mysql" + "github.com/stretchr/testify/require" ) func TestConnGenAttributes(t *testing.T) { @@ -26,17 +26,11 @@ func TestConnGenAttributes(t *testing.T) { // the order of the attributes map cannot be guaranteed so to test the content // of the attribute data we need to check its partial contents - if len(data) != 98 { - t.Fatalf("unexpected data length, got %d", len(data)) - } - if data[0] != 0x61 { - t.Fatalf("unexpected length-encoded int, got %#x", data[0]) - } + require.Len(t, data, 98) + require.Equal(t, byte(0x1a), data[0]) for k, v := range c.attributes { fixt := append(mysql.PutLengthEncodedString([]byte(k)), mysql.PutLengthEncodedString([]byte(v))...) - if !bytes.Contains(data, fixt) { - t.Fatalf("%s attribute not found", k) - } + require.Contains(t, data, fixt) } } diff --git a/client/client_test.go b/client/client_test.go index a7cc81999..be7a1298a 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -4,9 +4,11 @@ import ( "encoding/json" "fmt" "strings" + "testing" - . "github.com/pingcap/check" "github.com/pingcap/errors" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/test_util" @@ -14,49 +16,55 @@ import ( ) type clientTestSuite struct { + suite.Suite c *Conn port string } -func (s *clientTestSuite) SetUpSuite(c *C) { +func TestClientSuite(t *testing.T) { + segs := strings.Split(*test_util.MysqlPort, ",") + for _, seg := range segs { + suite.Run(t, &clientTestSuite{port: seg}) + } +} + +func (s *clientTestSuite) SetUpSuite() { var err error addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) s.c, err = Connect(addr, *testUser, *testPassword, "") - if err != nil { - c.Fatal(err) - } + require.NoError(s.T(), err) var result *mysql.Result result, err = s.c.Execute("CREATE DATABASE IF NOT EXISTS " + *testDB) - c.Assert(err, IsNil) - c.Assert(result.RowNumber() >= 0, IsTrue) + require.NoError(s.T(), err) + require.Greater(s.T(), result.RowNumber(), 0) _, err = s.c.Execute("USE " + *testDB) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - s.testConn_CreateTable(c) - s.testStmt_CreateTable(c) + s.testConn_CreateTable() + s.testStmt_CreateTable() } -func (s *clientTestSuite) TearDownSuite(c *C) { +func (s *clientTestSuite) TearDownSuite() { if s.c == nil { return } - s.testConn_DropTable(c) - s.testStmt_DropTable(c) + s.testConn_DropTable() + s.testStmt_DropTable() if s.c != nil { s.c.Close() } } -func (s *clientTestSuite) testConn_DropTable(c *C) { +func (s *clientTestSuite) testConn_DropTable() { _, err := s.c.Execute("drop table if exists mixer_test_conn") - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) testConn_CreateTable(c *C) { +func (s *clientTestSuite) testConn_CreateTable() { str := `CREATE TABLE IF NOT EXISTS mixer_test_conn ( id BIGINT(64) UNSIGNED NOT NULL, str VARCHAR(256), @@ -69,15 +77,15 @@ func (s *clientTestSuite) testConn_CreateTable(c *C) { ) ENGINE=InnoDB DEFAULT CHARSET=utf8` _, err := s.c.Execute(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestConn_Ping(c *C) { +func (s *clientTestSuite) TestConn_Ping() { err := s.c.Ping() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestConn_SetCapability(c *C) { +func (s *clientTestSuite) TestConn_SetCapability() { caps := []uint32{ mysql.CLIENT_LONG_PASSWORD, mysql.CLIENT_FOUND_ROWS, @@ -104,44 +112,39 @@ func (s *clientTestSuite) TestConn_SetCapability(c *C) { } for _, capI := range caps { - c.Assert(s.c.ccaps&capI > 0, IsFalse) + require.False(s.T(), s.c.ccaps&capI > 0) s.c.SetCapability(capI) - c.Assert(s.c.ccaps&capI > 0, IsTrue) + require.True(s.T(), s.c.ccaps&capI > 0) s.c.UnsetCapability(capI) - c.Assert(s.c.ccaps&capI > 0, IsFalse) + require.False(s.T(), s.c.ccaps&capI > 0) } } // NOTE for MySQL 5.5 and 5.6, server side has to config SSL to pass the TLS test, otherwise, it will throw error that // MySQL server does not support TLS required by the client. However, for MySQL 5.7 and above, auto generated certificates // are used by default so that manual config is no longer necessary. -func (s *clientTestSuite) TestConn_TLS_Verify(c *C) { +func (s *clientTestSuite) TestConn_TLS_Verify() { // Verify that the provided tls.Config is used when attempting to connect to mysql. // An empty tls.Config will result in a connection error. addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) _, err := Connect(addr, *testUser, *testPassword, *testDB, func(c *Conn) { c.UseSSL(false) }) - if err == nil { - c.Fatal("expected error") - } - expected := "either ServerName or InsecureSkipVerify must be specified in the tls.Config" - if !strings.Contains(err.Error(), expected) { - c.Fatalf("expected '%s' to contain '%s'", err.Error(), expected) - } + + require.ErrorContains(s.T(), err, expected) } -func (s *clientTestSuite) TestConn_TLS_Skip_Verify(c *C) { +func (s *clientTestSuite) TestConn_TLS_Skip_Verify() { // An empty tls.Config will result in a connection error but we can configure to skip it. addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) _, err := Connect(addr, *testUser, *testPassword, *testDB, func(c *Conn) { c.UseSSL(true) }) - c.Assert(err, Equals, nil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestConn_TLS_Certificate(c *C) { +func (s *clientTestSuite) TestConn_TLS_Certificate() { // This test uses the TLS suite in 'go-mysql/docker/resources'. The certificates are not valid for any names. // And if server uses auto-generated certificates, it will be an error like: // "x509: certificate is valid for MySQL_Server_8.0.12_Auto_Generated_Server_Certificate, not not-a-valid-name" @@ -150,96 +153,94 @@ func (s *clientTestSuite) TestConn_TLS_Certificate(c *C) { _, err := Connect(addr, *testUser, *testPassword, *testDB, func(c *Conn) { c.SetTLSConfig(tlsConfig) }) - if err == nil { - c.Fatal("expected error") - } + require.Error(s.T(), err) if !strings.Contains(errors.ErrorStack(err), "certificate is not valid for any names") && !strings.Contains(errors.ErrorStack(err), "certificate is valid for") { - c.Fatalf("expected errors for server name verification, but got unknown error: %s", errors.ErrorStack(err)) + s.T().Fatalf("expected errors for server name verification, but got unknown error: %s", errors.ErrorStack(err)) } } -func (s *clientTestSuite) TestConn_Insert(c *C) { +func (s *clientTestSuite) TestConn_Insert() { str := `insert into mixer_test_conn (id, str, f, e) values(1, "a", 3.14, "test1")` pkg, err := s.c.Execute(str) - c.Assert(err, IsNil) - c.Assert(pkg.AffectedRows, Equals, uint64(1)) + require.NoError(s.T(), err) + require.Equal(s.T(), uint64(1), pkg.AffectedRows) } -func (s *clientTestSuite) TestConn_Insert2(c *C) { +func (s *clientTestSuite) TestConn_Insert2() { str := `insert into mixer_test_conn (id, j) values(?, ?)` j := json.RawMessage(`[]`) pkg, err := s.c.Execute(str, []interface{}{2, j}...) - c.Assert(err, IsNil) - c.Assert(pkg.AffectedRows, Equals, uint64(1)) + require.NoError(s.T(), err) + require.Equal(s.T(), uint64(1), pkg.AffectedRows) } -func (s *clientTestSuite) TestConn_Select(c *C) { +func (s *clientTestSuite) TestConn_Select() { str := `select str, f, e from mixer_test_conn where id = 1` result, err := s.c.Execute(str) - c.Assert(err, IsNil) - c.Assert(result.Fields, HasLen, 3) - c.Assert(result.Values, HasLen, 1) + require.NoError(s.T(), err) + require.Len(s.T(), result.Fields, 3) + require.Len(s.T(), result.Values, 1) ss, _ := result.GetString(0, 0) - c.Assert(ss, Equals, "a") + require.Equal(s.T(), "a", ss) f, _ := result.GetFloat(0, 1) - c.Assert(f, Equals, 3.14) + require.Equal(s.T(), 3.14, f) e, _ := result.GetString(0, 2) - c.Assert(e, Equals, "test1") + require.Equal(s.T(), "test1", e) ss, _ = result.GetStringByName(0, "str") - c.Assert(ss, Equals, "a") + require.Equal(s.T(), "a", ss) f, _ = result.GetFloatByName(0, "f") - c.Assert(f, Equals, 3.14) + require.Equal(s.T(), 3.14, f) e, _ = result.GetStringByName(0, "e") - c.Assert(e, Equals, "test1") + require.Equal(s.T(), "test1", e) } -func (s *clientTestSuite) TestConn_Escape(c *C) { +func (s *clientTestSuite) TestConn_Escape() { e := `""''\abc` str := fmt.Sprintf(`insert into mixer_test_conn (id, str) values(5, "%s")`, mysql.Escape(e)) _, err := s.c.Execute(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) str = `select str from mixer_test_conn where id = ?` r, err := s.c.Execute(str, 5) - c.Assert(err, IsNil) + require.NoError(s.T(), err) ss, _ := r.GetString(0, 0) - c.Assert(ss, Equals, e) + require.Equal(s.T(), e, ss) } -func (s *clientTestSuite) TestConn_SetCharset(c *C) { +func (s *clientTestSuite) TestConn_SetCharset() { err := s.c.SetCharset("gb2312") - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = s.c.SetCharset("utf8") - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) testStmt_DropTable(c *C) { +func (s *clientTestSuite) testStmt_DropTable() { str := `drop table if exists mixer_test_stmt` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() _, err = stmt.Execute() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) testStmt_CreateTable(c *C) { +func (s *clientTestSuite) testStmt_CreateTable() { str := `CREATE TABLE IF NOT EXISTS mixer_test_stmt ( id BIGINT(64) UNSIGNED NOT NULL, str VARCHAR(256), @@ -251,175 +252,174 @@ func (s *clientTestSuite) testStmt_CreateTable(c *C) { ) ENGINE=InnoDB DEFAULT CHARSET=utf8` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() _, err = stmt.Execute() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestStmt_Delete(c *C) { +func (s *clientTestSuite) TestStmt_Delete() { str := `delete from mixer_test_stmt` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() _, err = stmt.Execute() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestStmt_Insert(c *C) { +func (s *clientTestSuite) TestStmt_Insert() { str := `insert into mixer_test_stmt (id, str, f, e, u, i) values (?, ?, ?, ?, ?, ?)` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() r, err := stmt.Execute(1, "a", 3.14, "test1", 255, -127) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - c.Assert(r.AffectedRows, Equals, uint64(1)) + require.Equal(s.T(), uint64(1), r.AffectedRows) } -func (s *clientTestSuite) TestStmt_Select(c *C) { +func (s *clientTestSuite) TestStmt_Select() { str := `select str, f, e from mixer_test_stmt where id = ?` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() result, err := stmt.Execute(1) - c.Assert(err, IsNil) - c.Assert(result.Values, HasLen, 1) - c.Assert(result.Fields, HasLen, 3) + require.NoError(s.T(), err) + require.Len(s.T(), result.Fields, 3) + require.Len(s.T(), result.Values, 1) ss, _ := result.GetString(0, 0) - c.Assert(ss, Equals, "a") + require.Equal(s.T(), "a", ss) f, _ := result.GetFloat(0, 1) - c.Assert(f, Equals, 3.14) + require.Equal(s.T(), 3.14, f) e, _ := result.GetString(0, 2) - c.Assert(e, Equals, "test1") + require.Equal(s.T(), "test1", e) ss, _ = result.GetStringByName(0, "str") - c.Assert(ss, Equals, "a") + require.Equal(s.T(), "a", ss) f, _ = result.GetFloatByName(0, "f") - c.Assert(f, Equals, 3.14) + require.Equal(s.T(), 3.14, f) e, _ = result.GetStringByName(0, "e") - c.Assert(e, Equals, "test1") + require.Equal(s.T(), "test1", e) } -func (s *clientTestSuite) TestStmt_NULL(c *C) { +func (s *clientTestSuite) TestStmt_NULL() { str := `insert into mixer_test_stmt (id, str, f, e) values (?, ?, ?, ?)` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() result, err := stmt.Execute(2, nil, 3.14, nil) - c.Assert(err, IsNil) - - c.Assert(result.AffectedRows, Equals, uint64(1)) + require.NoError(s.T(), err) + require.Equal(s.T(), uint64(1), result.AffectedRows) stmt.Close() str = `select * from mixer_test_stmt where id = ?` stmt, err = s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() result, err = stmt.Execute(2) - c.Assert(err, IsNil) + require.NoError(s.T(), err) b, err := result.IsNullByName(0, "id") - c.Assert(err, IsNil) - c.Assert(b, Equals, false) + require.NoError(s.T(), err) + require.False(s.T(), b) b, err = result.IsNullByName(0, "str") - c.Assert(err, IsNil) - c.Assert(b, Equals, true) + require.NoError(s.T(), err) + require.True(s.T(), b) b, err = result.IsNullByName(0, "f") - c.Assert(err, IsNil) - c.Assert(b, Equals, false) + require.NoError(s.T(), err) + require.False(s.T(), b) b, err = result.IsNullByName(0, "e") - c.Assert(err, IsNil) - c.Assert(b, Equals, true) + require.NoError(s.T(), err) + require.True(s.T(), b) } -func (s *clientTestSuite) TestStmt_Unsigned(c *C) { +func (s *clientTestSuite) TestStmt_Unsigned() { str := `insert into mixer_test_stmt (id, u) values (?, ?)` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() result, err := stmt.Execute(3, uint8(255)) - c.Assert(err, IsNil) - c.Assert(result.AffectedRows, Equals, uint64(1)) + require.NoError(s.T(), err) + require.Equal(s.T(), uint64(1), result.AffectedRows) str = `select u from mixer_test_stmt where id = ?` stmt, err = s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() result, err = stmt.Execute(3) - c.Assert(err, IsNil) + require.NoError(s.T(), err) u, err := result.GetUint(0, 0) - c.Assert(err, IsNil) - c.Assert(u, Equals, uint64(255)) + require.NoError(s.T(), err) + require.Equal(s.T(), uint64(255), u) } -func (s *clientTestSuite) TestStmt_Signed(c *C) { +func (s *clientTestSuite) TestStmt_Signed() { str := `insert into mixer_test_stmt (id, i) values (?, ?)` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() _, err = stmt.Execute(4, 127) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = stmt.Execute(uint64(18446744073709551516), int8(-128)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *clientTestSuite) TestStmt_Trans(c *C) { +func (s *clientTestSuite) TestStmt_Trans() { _, err := s.c.Execute(`insert into mixer_test_stmt (id, str) values (1002, "abc")`) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = s.c.Begin() - c.Assert(err, IsNil) + require.NoError(s.T(), err) str := `select str from mixer_test_stmt where id = ?` stmt, err := s.c.Prepare(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() _, err = stmt.Execute(1002) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = s.c.Commit() - c.Assert(err, IsNil) + require.NoError(s.T(), err) r, err := stmt.Execute(1002) - c.Assert(err, IsNil) + require.NoError(s.T(), err) str, _ = r.GetString(0, 0) - c.Assert(str, Equals, `abc`) + require.Equal(s.T(), `abc`, str) } diff --git a/client/common_test.go b/client/common_test.go index d28e63753..b36c1abf5 100644 --- a/client/common_test.go +++ b/client/common_test.go @@ -2,30 +2,8 @@ package client import ( "flag" - "strings" - "testing" - - . "github.com/pingcap/check" - - "github.com/go-mysql-org/go-mysql/test_util" ) var testUser = flag.String("user", "root", "MySQL user") var testPassword = flag.String("pass", "", "MySQL password") var testDB = flag.String("db", "test", "MySQL test database") - -func Test(t *testing.T) { - // We cover the whole range of MySQL server versions using docker-compose to bind them to different ports for testing. - // MySQL is constantly updating auth plugin to make it secure: - // starting from MySQL 8.0.4, a new auth plugin is introduced, causing plain password auth to fail with error: - // ERROR 1251 (08004): Client does not support authentication protocol requested by server; consider upgrading MySQL client - // Hint: use docker-compose to start corresponding MySQL docker containers and add their ports here - - segs := strings.Split(*test_util.MysqlPort, ",") - for _, seg := range segs { - Suite(&clientTestSuite{port: seg}) - Suite(&connTestSuite{port: seg}) - Suite(&poolTestSuite{port: seg}) - } - TestingT(t) -} diff --git a/client/conn_test.go b/client/conn_test.go index 54cae5b33..153fa1144 100644 --- a/client/conn_test.go +++ b/client/conn_test.go @@ -3,19 +3,29 @@ package client import ( "fmt" "strings" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/test_util" ) type connTestSuite struct { + suite.Suite c *Conn port string } -func (s *connTestSuite) SetUpSuite(c *C) { +func TestConnSuite(t *testing.T) { + segs := strings.Split(*test_util.MysqlPort, ",") + for _, seg := range segs { + suite.Run(t, &connTestSuite{port: seg}) + } +} + +func (s *connTestSuite) SetUpSuite() { var err error addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) s.c, err = Connect(addr, *testUser, *testPassword, "", func(c *Conn) { @@ -23,25 +33,23 @@ func (s *connTestSuite) SetUpSuite(c *C) { c.SetCapability(mysql.CLIENT_MULTI_STATEMENTS) c.SetAttributes(map[string]string{"attrtest": "attrvalue"}) }) - if err != nil { - c.Fatal(err) - } + require.NoError(s.T(), err) _, err = s.c.Execute("CREATE DATABASE IF NOT EXISTS " + *testDB) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.c.Execute("USE " + *testDB) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - s.testExecute_CreateTable(c) + s.testExecute_CreateTable() } -func (s *connTestSuite) TearDownSuite(c *C) { +func (s *connTestSuite) TearDownSuite() { if s.c == nil { return } - s.testExecute_DropTable(c) + s.testExecute_DropTable() if s.c != nil { s.c.Close() @@ -53,7 +61,7 @@ var ( testExecuteSelectStreamingTablename = "execute_plain_table" ) -func (s *connTestSuite) testExecute_CreateTable(c *C) { +func (s *connTestSuite) testExecute_CreateTable() { str := `CREATE TABLE IF NOT EXISTS ` + testExecuteSelectStreamingTablename + ` ( id INT UNSIGNED NOT NULL, str VARCHAR(256), @@ -61,36 +69,36 @@ func (s *connTestSuite) testExecute_CreateTable(c *C) { ) ENGINE=InnoDB DEFAULT CHARSET=utf8` result, err := s.c.Execute(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) result.Close() result, err = s.c.Execute(`TRUNCATE TABLE ` + testExecuteSelectStreamingTablename) - c.Assert(err, IsNil) + require.NoError(s.T(), err) result.Close() stmt, err := s.c.Prepare(`INSERT INTO ` + testExecuteSelectStreamingTablename + ` (id, str) VALUES (?, ?)`) - c.Assert(err, IsNil) + require.NoError(s.T(), err) defer stmt.Close() for id, str := range testExecuteSelectStreamingRows { result, err := stmt.Execute(id, str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) result.Close() } } -func (s *connTestSuite) testExecute_DropTable(c *C) { +func (s *connTestSuite) testExecute_DropTable() { _, err := s.c.Execute(`drop table if exists ` + testExecuteSelectStreamingTablename) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *connTestSuite) TestFieldList(c *C) { +func (s *connTestSuite) TestFieldList() { fields, err := s.c.FieldList(testExecuteSelectStreamingTablename, "") - c.Assert(err, IsNil) - c.Assert(fields, HasLen, 2) + require.NoError(s.T(), err) + require.Len(s.T(), fields, 2) } -func (s *connTestSuite) TestExecuteMultiple(c *C) { +func (s *connTestSuite) TestExecuteMultiple() { queries := []string{ `INSERT INTO ` + testExecuteSelectStreamingTablename + ` (id, str) VALUES (999, "executemultiple")`, `SELECT id FROM ` + testExecuteSelectStreamingTablename + ` LIMIT 2`, @@ -106,31 +114,31 @@ func (s *connTestSuite) TestExecuteMultiple(c *C) { // also, since this is not the last query, the SERVER_MORE_RESULTS_EXISTS // flag should be set case 0, 2: - c.Assert(result.Status&mysql.SERVER_MORE_RESULTS_EXISTS, Not(Equals), 0) - c.Assert(result.Resultset, IsNil) - c.Assert(result.AffectedRows, Equals, uint64(1)) - c.Assert(err, IsNil) + require.True(s.T(), result.Status&mysql.SERVER_MORE_RESULTS_EXISTS > 0) + require.Nil(s.T(), result.Resultset) + require.Equal(s.T(), uint64(1), result.AffectedRows) + require.NoError(s.T(), err) case 1: // the SELECT query should have an resultset // still not the last query, flag should be set - c.Assert(result.Status&mysql.SERVER_MORE_RESULTS_EXISTS, Not(Equals), 0) - c.Assert(result.Resultset, NotNil) - c.Assert(err, IsNil) + require.True(s.T(), result.Status&mysql.SERVER_MORE_RESULTS_EXISTS > 0) + require.NotNil(s.T(), result.Resultset) + require.NoError(s.T(), err) case 3: // this query is obviously bogus so the error should be non-nil - c.Assert(result, IsNil) - c.Assert(err, NotNil) + require.Nil(s.T(), result) + require.Error(s.T(), err) } count++ }) - c.Assert(count, Equals, 4) - c.Assert(err, IsNil) - c.Assert(result.StreamingDone, Equals, true) - c.Assert(result.Streaming, Equals, mysql.StreamingMultiple) + require.Equal(s.T(), 4, count) + require.NoError(s.T(), err) + require.True(s.T(), result.StreamingDone) + require.Equal(s.T(), mysql.StreamingMultiple, result.Streaming) } -func (s *connTestSuite) TestExecuteSelectStreaming(c *C) { +func (s *connTestSuite) TestExecuteSelectStreaming() { var ( expectedRowId int64 perResultCallbackCalledTimes int @@ -143,42 +151,42 @@ func (s *connTestSuite) TestExecuteSelectStreaming(c *C) { &result, func(row []mysql.FieldValue) error { // Check number of columns - c.Assert(row, HasLen, colsInResult) + require.Len(s.T(), row, colsInResult) // Check type of columns - c.Assert(row[0].Type, Equals, mysql.FieldValueType(mysql.FieldValueTypeUnsigned)) - c.Assert(row[1].Type, Equals, mysql.FieldValueType(mysql.FieldValueTypeString)) + require.Equal(s.T(), mysql.FieldValueType(mysql.FieldValueTypeUnsigned), row[0].Type) + require.Equal(s.T(), mysql.FieldValueType(mysql.FieldValueTypeString), row[1].Type) id := row[0].AsInt64() str := row[1].AsString() // Check order of rows - c.Assert(id, Equals, expectedRowId) + require.Equal(s.T(), expectedRowId, id) // Check string values (protection from incorrect reuse of memory) - c.Assert(string(str), Equals, testExecuteSelectStreamingRows[id]) + require.Equal(s.T(), testExecuteSelectStreamingRows[id], string(str)) expectedRowId++ return nil }, func(result *mysql.Result) error { // result.Resultset must be defined at this point - c.Assert(result.Resultset, NotNil) + require.NotNil(s.T(), result.Resultset) // Check number of columns - c.Assert(result.Resultset.Fields, HasLen, colsInResult) + require.Len(s.T(), result.Resultset.Fields, colsInResult) perResultCallbackCalledTimes++ return nil }) - c.Assert(err, IsNil) + require.NoError(s.T(), err) // Check total rows count - c.Assert(expectedRowId, Equals, int64(len(testExecuteSelectStreamingRows))) + require.Equal(s.T(), int64(len(testExecuteSelectStreamingRows)), expectedRowId) // Check perResultCallback call count - c.Assert(perResultCallbackCalledTimes, Equals, 1) + require.Equal(s.T(), 1, perResultCallbackCalledTimes) } -func (s *connTestSuite) TestAttributes(c *C) { +func (s *connTestSuite) TestAttributes() { // Test that both custom attributes and library set attributes are visible - c.Assert(s.c.attributes["_client_name"], Equals, "go-mysql") - c.Assert(s.c.attributes["attrtest"], Equals, "attrvalue") + require.Equal(s.T(), "go-mysql", s.c.attributes["_client_name"]) + require.Equal(s.T(), "attrvalue", s.c.attributes["attrtest"]) } diff --git a/client/pool_test.go b/client/pool_test.go index 8d6e0c05a..1599f9662 100644 --- a/client/pool_test.go +++ b/client/pool_test.go @@ -3,29 +3,40 @@ package client import ( "context" "fmt" + "strings" + "testing" "github.com/go-mysql-org/go-mysql/test_util" - . "github.com/pingcap/check" "github.com/siddontang/go-log/log" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" ) type poolTestSuite struct { + suite.Suite port string } -func (s poolTestSuite) TestPool_Close(c *C) { +func TestPoolSuite(t *testing.T) { + segs := strings.Split(*test_util.MysqlPort, ",") + for _, seg := range segs { + suite.Run(t, &poolTestSuite{port: seg}) + } +} + +func (s *poolTestSuite) TestPool_Close() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) pool := NewPool(log.Debugf, 5, 10, 5, addr, *testUser, *testPassword, "") conn, err := pool.GetConn(context.Background()) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = conn.Ping() - c.Assert(err, IsNil) + require.NoError(s.T(), err) pool.PutConn(conn) pool.Close() var poolStats ConnectionStats pool.GetStats(&poolStats) - c.Assert(poolStats.TotalCount, Equals, 0) - c.Assert(pool.readyConnection, HasLen, 0) + require.Equal(s.T(), 0, poolStats.TotalCount) + require.Len(s.T(), pool.readyConnection, 0) _, err = pool.GetConn(context.Background()) - c.Assert(err, NotNil) + require.Error(s.T(), err) } diff --git a/driver/driver_test.go b/driver/driver_test.go index b60a2e5d7..7116d6ddd 100644 --- a/driver/driver_test.go +++ b/driver/driver_test.go @@ -4,11 +4,11 @@ import ( "flag" "fmt" "net/url" - "reflect" "testing" "github.com/jmoiron/sqlx" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/test_util" ) @@ -18,64 +18,63 @@ var testPassword = flag.String("pass", "", "MySQL password") var testDB = flag.String("db", "test", "MySQL test database") func TestDriver(t *testing.T) { - TestingT(t) + suite.Run(t, new(testDriverSuite)) } type testDriverSuite struct { + suite.Suite db *sqlx.DB } -var _ = Suite(&testDriverSuite{}) - -func (s *testDriverSuite) SetUpSuite(c *C) { +func (s *testDriverSuite) SetUpSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) dsn := fmt.Sprintf("%s:%s@%s/%s", *testUser, *testPassword, addr, *testDB) var err error s.db, err = sqlx.Open("mysql", dsn) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *testDriverSuite) TearDownSuite(c *C) { +func (s *testDriverSuite) TearDownSuite() { if s.db != nil { s.db.Close() } } -func (s *testDriverSuite) TestConn(c *C) { +func (s *testDriverSuite) TestConn() { var n int err := s.db.Get(&n, "SELECT 1") - c.Assert(err, IsNil) - c.Assert(n, Equals, 1) + require.NoError(s.T(), err) + require.Equal(s.T(), 1, n) _, err = s.db.Exec("USE test") - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *testDriverSuite) TestStmt(c *C) { +func (s *testDriverSuite) TestStmt() { stmt, err := s.db.Preparex("SELECT ? + ?") - c.Assert(err, IsNil) + require.NoError(s.T(), err) var n int err = stmt.Get(&n, 1, 1) - c.Assert(err, IsNil) - c.Assert(n, Equals, 2) + require.NoError(s.T(), err) + require.Equal(s.T(), 2, n) err = stmt.Close() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *testDriverSuite) TestTransaction(c *C) { +func (s *testDriverSuite) TestTransaction() { tx, err := s.db.Beginx() - c.Assert(err, IsNil) + require.NoError(s.T(), err) var n int err = tx.Get(&n, "SELECT 1") - c.Assert(err, IsNil) - c.Assert(n, Equals, 1) + require.NoError(s.T(), err) + require.Equal(s.T(), 1, n) err = tx.Commit() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } func TestParseDSN(t *testing.T) { @@ -93,12 +92,8 @@ func TestParseDSN(t *testing.T) { for supplied, expected := range testDSNs { actual, err := parseDSN(supplied) - if err != nil { - t.Errorf("TestParseDSN failed. Got error: %s", err) - } + require.NoError(t, err) // Compare that with expected - if !reflect.DeepEqual(actual, expected) { - t.Errorf("TestParseDSN failed.\nExpected:\n%#v\nGot:\n%#v", expected, actual) - } + require.Equal(t, expected, actual) } } diff --git a/dump/parser_test.go b/dump/parser_test.go index 73d301559..3e5fc9ba0 100644 --- a/dump/parser_test.go +++ b/dump/parser_test.go @@ -2,17 +2,13 @@ package dump import ( "strings" + "testing" "github.com/go-mysql-org/go-mysql/mysql" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -type parserTestSuite struct { -} - -var _ = Suite(&parserTestSuite{}) - -func (s *parserTestSuite) TestParseGtidExp(c *C) { +func TestParseGtidExp(t *testing.T) { // binlogExp := regexp.MustCompile("^CHANGE MASTER TO MASTER_LOG_FILE='(.+)', MASTER_LOG_POS=(\\d+);") // gtidExp := regexp.MustCompile("(\\w{8}(-\\w{4}){3}-\\w{12}:\\d+-\\d+)") tbls := []struct { @@ -56,22 +52,22 @@ e7574090-b123-11e8-8bb4-005056a29643:1' var handler = new(testParseHandler) err := Parse(reader, handler, true) - c.Assert(err, IsNil) + require.NoError(t, err) if tt.expected == "" { if handler.gset != nil { - c.Assert(handler.gset, IsNil) + require.Nil(t, handler.gset) } else { continue } } expectedGtidset, err := mysql.ParseGTIDSet("mysql", tt.expected) - c.Assert(err, IsNil) - c.Assert(expectedGtidset.Equal(handler.gset), IsTrue) + require.NoError(t, err) + require.True(t, expectedGtidset.Equal(handler.gset)) } } -func (s *parserTestSuite) TestParseFindTable(c *C) { +func TestParseFindTable(t *testing.T) { tbl := []struct { sql string table string @@ -81,13 +77,13 @@ func (s *parserTestSuite) TestParseFindTable(c *C) { {"INSERT INTO `a.b` VALUES ('1');", "a.b"}, } - for _, t := range tbl { - res := valuesExp.FindAllStringSubmatch(t.sql, -1)[0][1] - c.Assert(res, Equals, t.table) + for _, te := range tbl { + res := valuesExp.FindAllStringSubmatch(te.sql, -1)[0][1] + require.Equal(t, te.table, res) } } -func (s *parserTestSuite) TestUnescape(c *C) { +func TestUnescape(t *testing.T) { tbl := []struct { escaped string expected string @@ -106,29 +102,29 @@ func (s *parserTestSuite) TestUnescape(c *C) { {`\abc`, `abc`}, } - for _, t := range tbl { - unesacped := unescapeString(t.escaped) - c.Assert(unesacped, Equals, t.expected) + for _, te := range tbl { + unesacped := unescapeString(te.escaped) + require.Equal(t, te.expected, unesacped) } } -func (s *parserTestSuite) TestParseValue(c *C) { +func TestParseValue(t *testing.T) { str := `'abc\\',''` values, err := parseValues(str) - c.Assert(err, IsNil) - c.Assert(values, DeepEquals, []string{`'abc\'`, `''`}) + require.NoError(t, err) + require.Equal(t, []string{`'abc\'`, `''`}, values) str = `123,'\Z#÷QÎx£. Æ‘ÇoPâÅ_\r—\\','','qn'` values, err = parseValues(str) - c.Assert(err, IsNil) - c.Assert(values, HasLen, 4) + require.NoError(t, err) + require.Len(t, values, 4) str = `123,'\Z#÷QÎx£. Æ‘ÇoPâÅ_\r—\\','','qn\'` _, err = parseValues(str) - c.Assert(err, NotNil) + require.Error(t, err) } -func (s *parserTestSuite) TestParseLine(c *C) { +func TestParseLine(t *testing.T) { lines := []struct { line string expected string @@ -143,13 +139,13 @@ func (s *parserTestSuite) TestParseLine(c *C) { return c == '\r' || c == '\n' } - for _, t := range lines { - l := strings.TrimRightFunc(t.line, f) + for _, te := range lines { + l := strings.TrimRightFunc(te.line, f) m := valuesExp.FindAllStringSubmatch(l, -1) - c.Assert(m, HasLen, 1) - c.Assert(m[0][1], Matches, "test") - c.Assert(m[0][2], Matches, t.expected) + require.Len(t, m, 1) + require.Equal(t, "test", m[0][1]) + require.Equal(t, te.expected, m[0][2]) } } diff --git a/dump/schema_test.go b/dump/schema_test.go index d3ca014e0..c273a2cbc 100644 --- a/dump/schema_test.go +++ b/dump/schema_test.go @@ -5,39 +5,44 @@ import ( "fmt" "io" "os" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/client" "github.com/go-mysql-org/go-mysql/test_util" ) type schemaTestSuite struct { + suite.Suite conn *client.Conn d *Dumper } -var _ = Suite(&schemaTestSuite{}) +func TestSchemaSuite(t *testing.T) { + suite.Run(t, new(schemaTestSuite)) +} -func (s *schemaTestSuite) SetUpSuite(c *C) { +func (s *schemaTestSuite) SetUpSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) var err error s.conn, err = client.Connect(addr, "root", "", "") - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.d, err = NewDumper(*execution, addr, "root", "") - c.Assert(err, IsNil) - c.Assert(s.d, NotNil) + require.NoError(s.T(), err) + require.NotNil(s.T(), s.d) s.d.SetCharset("utf8") s.d.SetErrOut(os.Stderr) _, err = s.conn.Execute("CREATE DATABASE IF NOT EXISTS test1") - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute("CREATE DATABASE IF NOT EXISTS test2") - c.Assert(err, IsNil) + require.NoError(s.T(), err) str := `CREATE TABLE IF NOT EXISTS test%d.t%d ( id int AUTO_INCREMENT, @@ -45,45 +50,45 @@ func (s *schemaTestSuite) SetUpSuite(c *C) { PRIMARY KEY(id) ) ENGINE=INNODB` _, err = s.conn.Execute(fmt.Sprintf(str, 1, 1)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 2, 1)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 1, 2)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 2, 2)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) str = `INSERT INTO test%d.t%d (name) VALUES ("a"), ("b"), ("\\"), ("''")` _, err = s.conn.Execute(fmt.Sprintf(str, 1, 1)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 2, 1)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 1, 2)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute(fmt.Sprintf(str, 2, 2)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *schemaTestSuite) TearDownSuite(c *C) { +func (s *schemaTestSuite) TearDownSuite() { if s.conn != nil { _, err := s.conn.Execute("DROP DATABASE IF EXISTS test1") - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.conn.Execute("DROP DATABASE IF EXISTS test2") - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.conn.Close() } } -func (s *schemaTestSuite) TestDump(c *C) { +func (s *schemaTestSuite) TestDump() { // Using mysql 5.7 can't work, error: // mysqldump: Error 1412: Table definition has changed, // please retry transaction when dumping table `test_replication` at row: 0 @@ -95,15 +100,15 @@ func (s *schemaTestSuite) TestDump(c *C) { s.d.AddIgnoreTables("test1", "t2") err := s.d.Dump(io.Discard) - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.d.AddTables("test1", "t1") err = s.d.Dump(io.Discard) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *schemaTestSuite) TestParse(c *C) { +func (s *schemaTestSuite) TestParse() { var buf bytes.Buffer s.d.Reset() @@ -111,8 +116,8 @@ func (s *schemaTestSuite) TestParse(c *C) { s.d.AddDatabases("test1", "test2") err := s.d.Dump(&buf) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = Parse(&buf, new(testParseHandler), true) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } diff --git a/dump/setup_test.go b/dump/setup_test.go index 4eff73b1d..029df78d9 100644 --- a/dump/setup_test.go +++ b/dump/setup_test.go @@ -2,18 +2,12 @@ package dump import ( "flag" - "testing" "github.com/go-mysql-org/go-mysql/mysql" - . "github.com/pingcap/check" ) var execution = flag.String("exec", "mysqldump", "mysqldump execution path") -func Test(t *testing.T) { - TestingT(t) -} - type testParseHandler struct { gset mysql.GTIDSet } From 2c52cdf27ac1ec4200579706863704c25d343dae Mon Sep 17 00:00:00 2001 From: lance6716 Date: Thu, 22 Jun 2023 19:36:52 +0800 Subject: [PATCH 02/11] finish another package Signed-off-by: lance6716 --- failover/failover_test.go | 110 +++++++++++++++++++------------------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/failover/failover_test.go b/failover/failover_test.go index 2c6246efa..d3081d2c4 100644 --- a/failover/failover_test.go +++ b/failover/failover_test.go @@ -5,26 +5,26 @@ import ( "fmt" "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/test_util" ) var enable_failover_test = flag.Bool("test-failover", false, "enable test failover") -func Test(t *testing.T) { - TestingT(t) -} - type failoverTestSuite struct { + suite.Suite s []*Server } -var _ = Suite(&failoverTestSuite{}) +func TestFailoverSuite(t *testing.T) { + suite.Run(t, new(failoverTestSuite)) +} -func (s *failoverTestSuite) SetUpSuite(c *C) { +func (s *failoverTestSuite) SetUpSuite() { if !*enable_failover_test { - c.Skip("skip test failover") + s.T().Skip("skip test failover") } ports := []int{3306, 3307, 3308, 3316, 3317, 3318} @@ -38,139 +38,139 @@ func (s *failoverTestSuite) SetUpSuite(c *C) { var err error for i := 0; i < len(ports); i++ { err = s.s[i].StopSlave() - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = s.s[i].ResetSlaveALL() - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.s[i].Execute(`SET GLOBAL BINLOG_FORMAT = "ROW"`) - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.s[i].Execute("DROP TABLE IF EXISTS test.go_mysql_test") - c.Assert(err, IsNil) + require.NoError(s.T(), err) _, err = s.s[i].Execute("CREATE TABLE IF NOT EXISTS test.go_mysql_test (id INT AUTO_INCREMENT, name VARCHAR(256), PRIMARY KEY(id)) engine=innodb") - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = s.s[i].ResetMaster() - c.Assert(err, IsNil) + require.NoError(s.T(), err) } } -func (s *failoverTestSuite) TearDownSuite(c *C) { +func (s *failoverTestSuite) TearDownSuite() { } -func (s *failoverTestSuite) TestMysqlFailover(c *C) { +func (s *failoverTestSuite) TestMysqlFailover() { h := new(MysqlGTIDHandler) m := s.s[0] s1 := s.s[1] s2 := s.s[2] - s.testFailover(c, h, m, s1, s2) + s.testFailover(h, m, s1, s2) } -func (s *failoverTestSuite) TestMariadbFailover(c *C) { +func (s *failoverTestSuite) TestMariadbFailover() { h := new(MariadbGTIDHandler) for i := 3; i <= 5; i++ { _, err := s.s[i].Execute("SET GLOBAL gtid_slave_pos = ''") - c.Assert(err, IsNil) + require.NoError(s.T(), err) } m := s.s[3] s1 := s.s[4] s2 := s.s[5] - s.testFailover(c, h, m, s1, s2) + s.testFailover(h, m, s1, s2) } -func (s *failoverTestSuite) testFailover(c *C, h Handler, m *Server, s1 *Server, s2 *Server) { +func (s *failoverTestSuite) testFailover(h Handler, m *Server, s1 *Server, s2 *Server) { var err error err = h.ChangeMasterTo(s1, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = h.ChangeMasterTo(s2, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - id := s.checkInsert(c, m, "a") + id := s.checkInsert(m, "a") err = h.WaitCatchMaster(s1, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = h.WaitCatchMaster(s2, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - s.checkSelect(c, s1, id, "a") - s.checkSelect(c, s2, id, "a") + s.checkSelect(s1, id, "a") + s.checkSelect(s2, id, "a") err = s2.StopSlaveIOThread() - c.Assert(err, IsNil) + require.NoError(s.T(), err) - _ = s.checkInsert(c, m, "b") - id = s.checkInsert(c, m, "c") + _ = s.checkInsert(m, "b") + id = s.checkInsert(m, "c") err = h.WaitCatchMaster(s1, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - s.checkSelect(c, s1, id, "c") + s.checkSelect(s1, id, "c") best, err := h.FindBestSlaves([]*Server{s1, s2}) - c.Assert(err, IsNil) - c.Assert(best, DeepEquals, []*Server{s1}) + require.NoError(s.T(), err) + require.Equal(s.T(), []*Server{s1}, best) // promote s1 to master err = h.Promote(s1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) // change s2 to master s1 err = h.ChangeMasterTo(s2, s1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = h.WaitCatchMaster(s2, s1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - s.checkSelect(c, s2, id, "c") + s.checkSelect(s2, id, "c") // change m to master s1 err = h.ChangeMasterTo(m, s1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) m, s1 = s1, m - _ = s.checkInsert(c, m, "d") + _ = s.checkInsert(m, "d") err = h.WaitCatchMaster(s1, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) err = h.WaitCatchMaster(s2, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) best, err = h.FindBestSlaves([]*Server{s1, s2}) - c.Assert(err, IsNil) - c.Assert(best, DeepEquals, []*Server{s1, s2}) + require.NoError(s.T(), err) + require.Equal(s.T(), []*Server{s1, s2}, best) err = s2.StopSlaveIOThread() - c.Assert(err, IsNil) + require.NoError(s.T(), err) - _ = s.checkInsert(c, m, "e") + _ = s.checkInsert(m, "e") err = h.WaitCatchMaster(s1, m) - c.Assert(err, IsNil) + require.NoError(s.T(), err) best, err = h.FindBestSlaves([]*Server{s1, s2}) - c.Assert(err, IsNil) - c.Assert(best, DeepEquals, []*Server{s1}) + require.NoError(s.T(), err) + require.Equal(s.T(), []*Server{s1}, best) } -func (s *failoverTestSuite) checkSelect(c *C, m *Server, id uint64, name string) { +func (s *failoverTestSuite) checkSelect(m *Server, id uint64, name string) { rr, err := m.Execute("SELECT name FROM test.go_mysql_test WHERE id = ?", id) - c.Assert(err, IsNil) + require.NoError(s.T(), err) str, _ := rr.GetString(0, 0) - c.Assert(str, Equals, name) + require.Equal(s.T(), name, str) } -func (s *failoverTestSuite) checkInsert(c *C, m *Server, name string) uint64 { +func (s *failoverTestSuite) checkInsert(m *Server, name string) uint64 { r, err := m.Execute("INSERT INTO test.go_mysql_test (name) VALUES (?)", name) - c.Assert(err, IsNil) + require.NoError(s.T(), err) return r.InsertId } From ae6e50ae1048230e64973037d04ffc4b93424c18 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Thu, 22 Jun 2023 19:53:47 +0800 Subject: [PATCH 03/11] fix some file Signed-off-by: lance6716 --- canal/canal_test.go | 2 +- client/client_test.go | 2 +- client/conn_test.go | 2 +- driver/driver_test.go | 2 +- dump/schema_test.go | 2 +- failover/failover_test.go | 2 +- mysql/mariadb_gtid_test.go | 2 +- mysql/mysql_test.go | 2 +- replication/backup_test.go | 17 ++- replication/event_test.go | 78 +++++++------- replication/parser_test.go | 51 ++++----- replication/replication_test.go | 171 ++++++++++++++---------------- schema/schema_test.go | 2 +- server/caching_sha2_cache_test.go | 2 +- server/server_test.go | 2 +- 15 files changed, 166 insertions(+), 173 deletions(-) diff --git a/canal/canal_test.go b/canal/canal_test.go index c1ab3901a..ef6230eab 100644 --- a/canal/canal_test.go +++ b/canal/canal_test.go @@ -34,7 +34,7 @@ const ( umiC = 16777215 ) -func (s *canalTestSuite) SetUpSuite() { +func (s *canalTestSuite) SetupSuite() { cfg := NewDefaultConfig() cfg.Addr = fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) cfg.User = "root" diff --git a/client/client_test.go b/client/client_test.go index be7a1298a..0e17588d5 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -28,7 +28,7 @@ func TestClientSuite(t *testing.T) { } } -func (s *clientTestSuite) SetUpSuite() { +func (s *clientTestSuite) SetupSuite() { var err error addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) s.c, err = Connect(addr, *testUser, *testPassword, "") diff --git a/client/conn_test.go b/client/conn_test.go index 153fa1144..f3c1e4fae 100644 --- a/client/conn_test.go +++ b/client/conn_test.go @@ -25,7 +25,7 @@ func TestConnSuite(t *testing.T) { } } -func (s *connTestSuite) SetUpSuite() { +func (s *connTestSuite) SetupSuite() { var err error addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, s.port) s.c, err = Connect(addr, *testUser, *testPassword, "", func(c *Conn) { diff --git a/driver/driver_test.go b/driver/driver_test.go index 7116d6ddd..3f7575613 100644 --- a/driver/driver_test.go +++ b/driver/driver_test.go @@ -26,7 +26,7 @@ type testDriverSuite struct { db *sqlx.DB } -func (s *testDriverSuite) SetUpSuite() { +func (s *testDriverSuite) SetupSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) dsn := fmt.Sprintf("%s:%s@%s/%s", *testUser, *testPassword, addr, *testDB) diff --git a/dump/schema_test.go b/dump/schema_test.go index c273a2cbc..6f506c1ee 100644 --- a/dump/schema_test.go +++ b/dump/schema_test.go @@ -24,7 +24,7 @@ func TestSchemaSuite(t *testing.T) { suite.Run(t, new(schemaTestSuite)) } -func (s *schemaTestSuite) SetUpSuite() { +func (s *schemaTestSuite) SetupSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) var err error diff --git a/failover/failover_test.go b/failover/failover_test.go index d3081d2c4..fe72305ff 100644 --- a/failover/failover_test.go +++ b/failover/failover_test.go @@ -22,7 +22,7 @@ func TestFailoverSuite(t *testing.T) { suite.Run(t, new(failoverTestSuite)) } -func (s *failoverTestSuite) SetUpSuite() { +func (s *failoverTestSuite) SetupSuite() { if !*enable_failover_test { s.T().Skip("skip test failover") } diff --git a/mysql/mariadb_gtid_test.go b/mysql/mariadb_gtid_test.go index 6d0ce22c3..1eab1567c 100644 --- a/mysql/mariadb_gtid_test.go +++ b/mysql/mariadb_gtid_test.go @@ -9,7 +9,7 @@ type mariaDBTestSuite struct { var _ = check.Suite(&mariaDBTestSuite{}) -func (t *mariaDBTestSuite) SetUpSuite(c *check.C) { +func (t *mariaDBTestSuite) SetupSuite(c *check.C) { } diff --git a/mysql/mysql_test.go b/mysql/mysql_test.go index eb27aebfd..8206fe66f 100644 --- a/mysql/mysql_test.go +++ b/mysql/mysql_test.go @@ -20,7 +20,7 @@ type mysqlTestSuite struct { var _ = check.Suite(&mysqlTestSuite{}) -func (t *mysqlTestSuite) SetUpSuite(c *check.C) { +func (t *mysqlTestSuite) SetupSuite(c *check.C) { } diff --git a/replication/backup_test.go b/replication/backup_test.go index 7293321af..b4e1e98b6 100644 --- a/replication/backup_test.go +++ b/replication/backup_test.go @@ -5,20 +5,19 @@ import ( "os" "time" - . "github.com/pingcap/check" - "github.com/pingcap/errors" + "github.com/stretchr/testify/require" "github.com/go-mysql-org/go-mysql/mysql" ) -func (t *testSyncerSuite) TestStartBackupEndInGivenTime(c *C) { - t.setupTest(c, mysql.MySQLFlavor) +func (t *testSyncerSuite) TestStartBackupEndInGivenTime() { + t.setupTest(mysql.MySQLFlavor) - t.testExecute(c, "RESET MASTER") + t.testExecute("RESET MASTER") for times := 1; times <= 2; times++ { - t.testSync(c, nil) - t.testExecute(c, "FLUSH LOGS") + t.testSync(nil) + t.testExecute("FLUSH LOGS") } binlogDir := "./var" @@ -30,7 +29,7 @@ func (t *testSyncerSuite) TestStartBackupEndInGivenTime(c *C) { go func() { err := t.b.StartBackup(binlogDir, mysql.Position{Name: "", Pos: uint32(0)}, timeout) - c.Assert(err, IsNil) + require.NoError(t.T(), err) done <- true }() failTimeout := 5 * timeout @@ -39,6 +38,6 @@ func (t *testSyncerSuite) TestStartBackupEndInGivenTime(c *C) { case <-done: return case <-ctx.Done(): - c.Assert(errors.New("time out error"), IsNil) + t.T().Fatal("time out error") } } diff --git a/replication/event_test.go b/replication/event_test.go index 509df8b5c..a0cf9fcff 100644 --- a/replication/event_test.go +++ b/replication/event_test.go @@ -1,34 +1,37 @@ package replication import ( + "testing" + . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -func (_ *testDecodeSuite) TestMariadbGTIDListEvent(c *C) { +func TestMariadbGTIDListEvent(t *testing.T) { // single GTID, 1-2-3 data := []byte{1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0} ev := MariadbGTIDListEvent{} err := ev.Decode(data) - c.Assert(err, IsNil) - c.Assert(len(ev.GTIDs), Equals, 1) - c.Assert(ev.GTIDs[0].DomainID, Equals, uint32(1)) - c.Assert(ev.GTIDs[0].ServerID, Equals, uint32(2)) - c.Assert(ev.GTIDs[0].SequenceNumber, Equals, uint64(3)) + require.NoError(t, err) + require.Len(t, ev.GTIDs, 1) + require.Equal(t, uint32(1), ev.GTIDs[0].DomainID) + require.Equal(t, uint32(2), ev.GTIDs[0].ServerID) + require.Equal(t, uint64(3), ev.GTIDs[0].SequenceNumber) // multi GTIDs, 1-2-3,4-5-6,7-8-9 data = []byte{3, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0} ev = MariadbGTIDListEvent{} err = ev.Decode(data) - c.Assert(err, IsNil) - c.Assert(len(ev.GTIDs), Equals, 3) + require.NoError(t, err) + require.Len(t, ev.GTIDs, 3) for i := 0; i < 3; i++ { - c.Assert(ev.GTIDs[i].DomainID, Equals, uint32(1+3*i)) - c.Assert(ev.GTIDs[i].ServerID, Equals, uint32(2+3*i)) - c.Assert(ev.GTIDs[i].SequenceNumber, Equals, uint64(3+3*i)) + require.Equal(t, uint32(1+3*i), ev.GTIDs[i].DomainID) + require.Equal(t, uint32(2+3*i), ev.GTIDs[i].ServerID) + require.Equal(t, uint64(3+3*i), ev.GTIDs[i].SequenceNumber) } } -func (_ *testDecodeSuite) TestMariadbGTIDEvent(c *C) { +func TestMariadbGTIDEvent(t *testing.T) { data := []byte{ 1, 2, 3, 4, 5, 6, 7, 8, // SequenceNumber 0x2a, 1, 0x3b, 4, // DomainID @@ -38,23 +41,23 @@ func (_ *testDecodeSuite) TestMariadbGTIDEvent(c *C) { ev := MariadbGTIDEvent{} err := ev.Decode(data) - c.Assert(err, IsNil) + require.NoError(t, err) - c.Assert(ev.GTID.SequenceNumber, Equals, uint64(0x0807060504030201)) - c.Assert(ev.GTID.DomainID, Equals, uint32(0x043b012a)) - c.Assert(ev.Flags, Equals, byte(0xff)) - c.Assert(ev.IsDDL(), Equals, true) - c.Assert(ev.IsStandalone(), Equals, true) - c.Assert(ev.IsGroupCommit(), Equals, true) - c.Assert(ev.CommitID, Equals, uint64(0x1716151413121110)) + require.Equal(t, uint64(0x0807060504030201), ev.GTID.SequenceNumber) + require.Equal(t, uint32(0x043b012a), ev.GTID.DomainID) + require.Equal(t, byte(0xff), ev.Flags) + require.True(t, ev.IsDDL()) + require.True(t, ev.IsStandalone()) + require.True(t, ev.IsGroupCommit()) + require.Equal(t, uint64(0x1716151413121110), ev.CommitID) } -func (_ *testDecodeSuite) TestGTIDEventMysql8NewFields(c *C) { +func TestGTIDEventMysql8NewFields(t *testing.T) { testcases := []struct { data []byte expectImmediateCommitTimestamp uint64 expectOriginalCommitTimestamp uint64 - expectTransactoinLength uint64 + expectTransactionLength uint64 expectImmediateServerVersion uint32 expectOriginalServerVersion uint32 }{ @@ -63,7 +66,7 @@ func (_ *testDecodeSuite) TestGTIDEventMysql8NewFields(c *C) { data: []byte("\x00Z\xa7*\u007fD\xa8\x11\xea\x94\u007f\x02B\xac\x19\x00\x02\x02\x01\x00\x00\x00\x00\x00\x00\x02v\x00\x00\x00\x00\x00\x00\x00w\x00\x00\x00\x00\x00\x00\x00\xc1G\x81\x16x\xa0\x85\x00\x00\x00\x00\x00\x00\x00\xfc\xc5\x03\x938\x01\x80\x00\x00\x00\x00"), expectImmediateCommitTimestamp: 1583812517644225, expectOriginalCommitTimestamp: 0, - expectTransactoinLength: 965, + expectTransactionLength: 965, expectImmediateServerVersion: 80019, expectOriginalServerVersion: 0, }, @@ -72,7 +75,7 @@ func (_ *testDecodeSuite) TestGTIDEventMysql8NewFields(c *C) { data: []byte("\x00Z\xa7*\u007fD\xa8\x11\xea\x94\u007f\x02B\xac\x19\x00\x02\x03\x01\x00\x00\x00\x00\x00\x00\x025\x00\x00\x00\x00\x00\x00\x006\x00\x00\x00\x00\x00\x00\x00"), expectImmediateCommitTimestamp: 0, expectOriginalCommitTimestamp: 0, - expectTransactoinLength: 0, + expectTransactionLength: 0, expectImmediateServerVersion: 0, expectOriginalServerVersion: 0, }, @@ -81,7 +84,7 @@ func (_ *testDecodeSuite) TestGTIDEventMysql8NewFields(c *C) { data: []byte("\x00\\\xcc\x103D\xa8\x11\xea\xbdY\x02B\xac\x19\x00\x03w\x00\x00\x00\x00\x00\x00\x00\x02x\x00\x00\x00\x00\x00\x00\x00y\x00\x00\x00\x00\x00\x00\x00j0\xb1>x\xa0\x05\xfc\xc3\x03\x938\x01\x00"), expectImmediateCommitTimestamp: 1583813191872618, expectOriginalCommitTimestamp: 1583813191872618, - expectTransactoinLength: 963, + expectTransactionLength: 963, expectImmediateServerVersion: 80019, expectOriginalServerVersion: 80019, }, @@ -90,28 +93,29 @@ func (_ *testDecodeSuite) TestGTIDEventMysql8NewFields(c *C) { for _, tc := range testcases { ev := new(GTIDEvent) err := ev.Decode(tc.data) - c.Assert(err, IsNil) - c.Assert(ev.ImmediateCommitTimestamp, Equals, tc.expectImmediateCommitTimestamp) - c.Assert(ev.OriginalCommitTimestamp, Equals, tc.expectOriginalCommitTimestamp) - c.Assert(ev.ImmediateServerVersion, Equals, tc.expectImmediateServerVersion) - c.Assert(ev.OriginalServerVersion, Equals, tc.expectOriginalServerVersion) + require.NoError(t, err) + require.Equal(t, tc.expectImmediateCommitTimestamp, ev.ImmediateCommitTimestamp) + require.Equal(t, tc.expectOriginalCommitTimestamp, ev.OriginalCommitTimestamp) + require.Equal(t, tc.expectTransactionLength, ev.TransactionLength) + require.Equal(t, tc.expectImmediateServerVersion, ev.ImmediateServerVersion) + require.Equal(t, tc.expectOriginalServerVersion, ev.OriginalServerVersion) } } -func (_ *testDecodeSuite) TestIntVarEvent(c *C) { +func TestIntVarEvent(t *testing.T) { // IntVarEvent Type LastInsertID, Value 13 data := []byte{1, 13, 0, 0, 0, 0, 0, 0, 0} ev := IntVarEvent{} err := ev.Decode(data) - c.Assert(err, IsNil) - c.Assert(ev.Type, Equals, LAST_INSERT_ID) - c.Assert(ev.Value, Equals, uint64(13)) + require.NoError(t, err) + require.Equal(t, LAST_INSERT_ID, ev.Type) + require.Equal(t, uint64(13), ev.Value) // IntVarEvent Type InsertID, Value 23 data = []byte{2, 23, 0, 0, 0, 0, 0, 0, 0} ev = IntVarEvent{} err = ev.Decode(data) - c.Assert(err, IsNil) - c.Assert(ev.Type, Equals, INSERT_ID) - c.Assert(ev.Value, Equals, uint64(23)) + require.NoError(t, err) + require.Equal(t, INSERT_ID, ev.Type) + require.Equal(t, uint64(23), ev.Value) } diff --git a/replication/parser_test.go b/replication/parser_test.go index 48137d700..d1774f8c7 100644 --- a/replication/parser_test.go +++ b/replication/parser_test.go @@ -2,11 +2,12 @@ package replication import ( "bytes" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -func (t *testSyncerSuite) TestIndexOutOfRange(c *C) { +func TestIndexOutOfRange(t *testing.T) { parser := NewBinlogParser() parser.format = &FormatDescriptionEvent{ @@ -40,10 +41,10 @@ func (t *testSyncerSuite) TestIndexOutOfRange(c *C) { 0x65, 0x6d, 0xb1, 0x3c, 0x38, 0xcb, }) - c.Assert(err, IsNil) + require.NoError(t, err) } -func (t *testSyncerSuite) TestParseEvent(c *C) { +func TestParseEvent(t *testing.T) { parser := NewBinlogParser() parser.format = &FormatDescriptionEvent{ Version: 0x4, @@ -64,20 +65,20 @@ func (t *testSyncerSuite) TestParseEvent(c *C) { for _, tc := range testCases { r := bytes.NewReader(tc.byteData) _, err := parser.ParseSingleEvent(r, func(e *BinlogEvent) error { - c.Assert(e.Header.EventType, Equals, STOP_EVENT) - c.Assert(e.Header.EventSize, Equals, tc.eventSize) + require.Equal(t, STOP_EVENT, e.Header.EventType) + require.Equal(t, tc.eventSize, e.Header.EventSize) return nil }) - c.Assert(err, IsNil) + require.NoError(t, err) e, err2 := parser.Parse(tc.byteData) - c.Assert(e.Header.EventType, Equals, STOP_EVENT) - c.Assert(e.Header.EventSize, Equals, tc.eventSize) - c.Assert(err2, IsNil) + require.NoError(t, err2) + require.Equal(t, STOP_EVENT, e.Header.EventType) + require.Equal(t, tc.eventSize, e.Header.EventSize) } } -func (t *testSyncerSuite) TestRowsEventDecodeFunc(c *C) { +func TestRowsEventDecodeFunc(t *testing.T) { testCases := []struct { byteData []byte eventSize uint32 @@ -103,13 +104,13 @@ func (t *testSyncerSuite) TestRowsEventDecodeFunc(c *C) { }) for _, tc := range testCases { e, err := parser.Parse(tc.byteData) - c.Assert(err, IsNil) - c.Assert(e.Header.EventType, Equals, tc.eventType) - c.Assert(e.Header.EventSize, Equals, tc.eventSize) + require.NoError(t, err) + require.Equal(t, tc.eventType, e.Header.EventType) + require.Equal(t, tc.eventSize, e.Header.EventSize) } } -func (t *testSyncerSuite) TestRowsEventDecodeImageWithEmptyJSON(c *C) { +func TestRowsEventDecodeImageWithEmptyJSON(t *testing.T) { data := []byte("\x01\a\x00\xf6+\x0f\x00\xeb\xafP\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\xac\xfa\xbeÙ\xaf\xab1\x184\x11\x00\x00") bitmap := []byte{255} @@ -125,17 +126,17 @@ func (t *testSyncerSuite) TestRowsEventDecodeImageWithEmptyJSON(c *C) { ColumnCount: uint64(len(table.ColumnType)), } n, err := e.decodeImage(data, bitmap, EnumRowImageTypeUpdateAI) - c.Assert(err, IsNil) - c.Assert(n, Equals, len(data)) + require.NoError(t, err) + require.Len(t, data, n) - c.Assert(len(e.Rows), Equals, 1) - c.Assert(len(e.Rows[0]), Equals, len(table.ColumnType)) + require.Len(t, e.Rows, 1) + require.Len(t, e.Rows[0], len(table.ColumnType)) row := e.Rows[0] - c.Assert(row[0], Equals, int32(994294)) - c.Assert(row[1], Equals, int32(38842347)) - c.Assert(row[2], DeepEquals, []byte{}) // empty json - c.Assert(row[3], DeepEquals, []byte{}) // empty json - c.Assert(row[4], DeepEquals, []byte{}) // empty json - c.Assert(row[7], Equals, int32(4404)) + require.Equal(t, int32(994294), row[0]) + require.Equal(t, int32(38842347), row[1]) + require.Equal(t, []byte{}, row[2]) // empty json + require.Equal(t, []byte{}, row[3]) // empty json + require.Equal(t, []byte{}, row[4]) // empty json + require.Equal(t, int32(4404), row[7]) } diff --git a/replication/replication_test.go b/replication/replication_test.go index 0cb7512be..addb2fa72 100644 --- a/replication/replication_test.go +++ b/replication/replication_test.go @@ -11,7 +11,8 @@ import ( "time" "github.com/google/uuid" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/client" "github.com/go-mysql-org/go-mysql/mysql" @@ -20,11 +21,8 @@ import ( var testOutputLogs = flag.Bool("out", false, "output binlog event") -func TestBinLogSyncer(t *testing.T) { - TestingT(t) -} - type testSyncerSuite struct { + suite.Suite b *BinlogSyncer c *client.Conn @@ -33,18 +31,11 @@ type testSyncerSuite struct { flavor string } -var _ = Suite(&testSyncerSuite{}) - -func (t *testSyncerSuite) SetUpSuite(c *C) { -} - -func (t *testSyncerSuite) TearDownSuite(c *C) { +func TestSyncerSuite(t *testing.T) { + suite.Run(t, new(testSyncerSuite)) } -func (t *testSyncerSuite) SetUpTest(c *C) { -} - -func (t *testSyncerSuite) TearDownTest(c *C) { +func (t *testSyncerSuite) TearDownTest() { if t.b != nil { t.b.Close() t.b = nil @@ -56,14 +47,12 @@ func (t *testSyncerSuite) TearDownTest(c *C) { } } -func (t *testSyncerSuite) testExecute(c *C, query string) { +func (t *testSyncerSuite) testExecute(query string) { _, err := t.c.Execute(query) - if err != nil { - c.Assert(fmt.Errorf("query %q execution failed: %w", query, err), IsNil) - } + require.NoError(t.T(), err) } -func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { +func (t *testSyncerSuite) testSync(s *BinlogStreamer) { t.wg.Add(1) go func() { defer t.wg.Done() @@ -81,7 +70,7 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { return } - c.Assert(err, IsNil) + require.NoError(t.T(), err) if *testOutputLogs { e.Dump(os.Stdout) @@ -91,10 +80,10 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { }() // use mixed format - t.testExecute(c, "SET SESSION binlog_format = 'MIXED'") + t.testExecute("SET SESSION binlog_format = 'MIXED'") str := `DROP TABLE IF EXISTS test_replication` - t.testExecute(c, str) + t.testExecute(str) str = `CREATE TABLE test_replication ( id BIGINT(64) UNSIGNED NOT NULL AUTO_INCREMENT, @@ -117,32 +106,32 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { PRIMARY KEY (id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8` - t.testExecute(c, str) + t.testExecute(str) // use row format - t.testExecute(c, "SET SESSION binlog_format = 'ROW'") + t.testExecute("SET SESSION binlog_format = 'ROW'") - t.testExecute(c, `INSERT INTO test_replication (str, f, i, e, b, y, da, ts, dt, tm, de, t, bb, se) + t.testExecute(`INSERT INTO test_replication (str, f, i, e, b, y, da, ts, dt, tm, de, t, bb, se) VALUES ("3", -3.14, 10, "e1", 0b0011, 1985, "2012-05-07", "2012-05-07 14:01:01", "2012-05-07 14:01:01", "14:01:01", -45363.64, "abc", "12345", "a,b")`) if t.flavor == mysql.MySQLFlavor { - t.testExecute(c, "SET SESSION binlog_row_image = 'MINIMAL'") + t.testExecute("SET SESSION binlog_row_image = 'MINIMAL'") if eq, err := t.c.CompareServerVersion("8.0.0"); (err == nil) && (eq >= 0) { - t.testExecute(c, "SET SESSION binlog_row_value_options = 'PARTIAL_JSON'") + t.testExecute("SET SESSION binlog_row_value_options = 'PARTIAL_JSON'") } const id = 100 - t.testExecute(c, fmt.Sprintf(`INSERT INTO test_replication (id, str, f, i, bb, de) VALUES (%d, "4", -3.14, 100, "abc", -45635.64)`, id)) - t.testExecute(c, fmt.Sprintf(`UPDATE test_replication SET f = -12.14, de = 555.34 WHERE id = %d`, id)) - t.testExecute(c, fmt.Sprintf(`DELETE FROM test_replication WHERE id = %d`, id)) + t.testExecute(fmt.Sprintf(`INSERT INTO test_replication (id, str, f, i, bb, de) VALUES (%d, "4", -3.14, 100, "abc", -45635.64)`, id)) + t.testExecute(fmt.Sprintf(`UPDATE test_replication SET f = -12.14, de = 555.34 WHERE id = %d`, id)) + t.testExecute(fmt.Sprintf(`DELETE FROM test_replication WHERE id = %d`, id)) } // check whether we can create the table including the json field str = `DROP TABLE IF EXISTS test_json` - t.testExecute(c, str) + t.testExecute(str) str = `CREATE TABLE test_json ( id BIGINT(64) UNSIGNED NOT NULL AUTO_INCREMENT, @@ -152,11 +141,11 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { ) ENGINE=InnoDB` if _, err := t.c.Execute(str); err == nil { - t.testExecute(c, `INSERT INTO test_json (c2) VALUES (1)`) - t.testExecute(c, `INSERT INTO test_json (c1, c2) VALUES ('{"key1": "value1", "key2": "value2"}', 1)`) + t.testExecute(`INSERT INTO test_json (c2) VALUES (1)`) + t.testExecute(`INSERT INTO test_json (c1, c2) VALUES ('{"key1": "value1", "key2": "value2"}', 1)`) } - t.testExecute(c, "DROP TABLE IF EXISTS test_json_v2") + t.testExecute("DROP TABLE IF EXISTS test_json_v2") str = `CREATE TABLE test_json_v2 ( id INT, @@ -210,7 +199,7 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { } for _, query := range tbls { - t.testExecute(c, query) + t.testExecute(query) } // "Partial Updates of JSON Values" from https://dev.mysql.com/doc/refman/8.0/en/json.html @@ -225,15 +214,15 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { // ToDo(atercattus): add more tests with JSON_REPLACE() and JSON_REMOVE() } for _, query := range tbls { - t.testExecute(c, query) + t.testExecute(query) } // If MySQL supports JSON, it must supports GEOMETRY. - t.testExecute(c, "DROP TABLE IF EXISTS test_geo") + t.testExecute("DROP TABLE IF EXISTS test_geo") str = `CREATE TABLE test_geo (g GEOMETRY)` _, err = t.c.Execute(str) - c.Assert(err, IsNil) + require.NoError(t.T(), err) tbls = []string{ `INSERT INTO test_geo VALUES (POINT(1, 1))`, @@ -242,15 +231,15 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { } for _, query := range tbls { - t.testExecute(c, query) + t.testExecute(query) } } str = `DROP TABLE IF EXISTS test_parse_time` - t.testExecute(c, str) + t.testExecute(str) // Must allow zero time. - t.testExecute(c, `SET sql_mode=''`) + t.testExecute(`SET sql_mode=''`) str = `CREATE TABLE test_parse_time ( a1 DATETIME, a2 DATETIME(3), @@ -258,9 +247,9 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { b1 TIMESTAMP, b2 TIMESTAMP(3) , b3 TIMESTAMP(6))` - t.testExecute(c, str) + t.testExecute(str) - t.testExecute(c, `INSERT INTO test_parse_time VALUES + t.testExecute(`INSERT INTO test_parse_time VALUES ("2014-09-08 17:51:04.123456", "2014-09-08 17:51:04.123456", "2014-09-08 17:51:04.123456", "2014-09-08 17:51:04.123456","2014-09-08 17:51:04.123456","2014-09-08 17:51:04.123456"), ("0000-00-00 00:00:00.000000", "0000-00-00 00:00:00.000000", "0000-00-00 00:00:00.000000", @@ -271,7 +260,7 @@ func (t *testSyncerSuite) testSync(c *C, s *BinlogStreamer) { t.wg.Wait() } -func (t *testSyncerSuite) setupTest(c *C, flavor string) { +func (t *testSyncerSuite) setupTest(flavor string) { var port uint16 = 3306 switch flavor { case mysql.MariaDBFlavor: @@ -287,14 +276,14 @@ func (t *testSyncerSuite) setupTest(c *C, flavor string) { t.c, err = client.Connect(fmt.Sprintf("%s:%d", *test_util.MysqlHost, port), "root", "", "") if err != nil { - c.Skip(err.Error()) + t.T().Skip(err.Error()) } _, err = t.c.Execute("CREATE DATABASE IF NOT EXISTS test") - c.Assert(err, IsNil) + require.NoError(t.T(), err) _, err = t.c.Execute("USE test") - c.Assert(err, IsNil) + require.NoError(t.T(), err) if t.b != nil { t.b.Close() @@ -313,29 +302,29 @@ func (t *testSyncerSuite) setupTest(c *C, flavor string) { t.b = NewBinlogSyncer(cfg) } -func (t *testSyncerSuite) testPositionSync(c *C) { +func (t *testSyncerSuite) testPositionSync() { // get current master binlog file and position r, err := t.c.Execute("SHOW MASTER STATUS") - c.Assert(err, IsNil) + require.NoError(t.T(), err) binFile, _ := r.GetString(0, 0) binPos, _ := r.GetInt(0, 1) s, err := t.b.StartSync(mysql.Position{Name: binFile, Pos: uint32(binPos)}) - c.Assert(err, IsNil) + require.NoError(t.T(), err) r, err = t.c.Execute("SHOW SLAVE HOSTS") - c.Assert(err, IsNil) + require.NoError(t.T(), err) // List of replicas must not be empty - c.Assert(r.Values, Not(HasLen), 0) + require.Len(t.T(), r.Values, 0) // Slave_UUID is empty for mysql 8.0.28+ (8.0.32 still broken) if eq, err := t.c.CompareServerVersion("8.0.28"); (err == nil) && (eq < 0) { // check we have set Slave_UUID slaveUUID, _ := r.GetString(0, 4) - c.Assert(slaveUUID, HasLen, 36) + require.Len(t.T(), slaveUUID, 36) } else if err != nil { - c.Error("Cannot compare with server version: %w", err) + require.NoError(t.T(), err) } // Test re-sync. @@ -343,81 +332,81 @@ func (t *testSyncerSuite) testPositionSync(c *C) { _ = t.b.c.SetReadDeadline(time.Now().Add(time.Millisecond)) time.Sleep(100 * time.Millisecond) - t.testSync(c, s) + t.testSync(s) } -func (t *testSyncerSuite) TestMysqlPositionSync(c *C) { - t.setupTest(c, mysql.MySQLFlavor) - t.testPositionSync(c) +func (t *testSyncerSuite) TestMysqlPositionSync() { + t.setupTest(mysql.MySQLFlavor) + t.testPositionSync() } -func (t *testSyncerSuite) TestMysqlGTIDSync(c *C) { - t.setupTest(c, mysql.MySQLFlavor) +func (t *testSyncerSuite) TestMysqlGTIDSync() { + t.setupTest(mysql.MySQLFlavor) r, err := t.c.Execute("SELECT @@gtid_mode") - c.Assert(err, IsNil) + require.NoError(t.T(), err) modeOn, _ := r.GetString(0, 0) if modeOn != "ON" { - c.Skip("GTID mode is not ON") + t.T().Skip("GTID mode is not ON") } r, err = t.c.Execute("SHOW GLOBAL VARIABLES LIKE 'SERVER_UUID'") - c.Assert(err, IsNil) + require.NoError(t.T(), err) var masterUuid uuid.UUID if s, _ := r.GetString(0, 1); len(s) > 0 && s != "NONE" { masterUuid, err = uuid.Parse(s) - c.Assert(err, IsNil) + require.NoError(t.T(), err) } set, _ := mysql.ParseMysqlGTIDSet(fmt.Sprintf("%s:%d-%d", masterUuid.String(), 1, 2)) s, err := t.b.StartSyncGTID(set) - c.Assert(err, IsNil) + require.NoError(t.T(), err) - t.testSync(c, s) + t.testSync(s) } -func (t *testSyncerSuite) TestMariadbPositionSync(c *C) { - t.setupTest(c, mysql.MariaDBFlavor) +func (t *testSyncerSuite) TestMariadbPositionSync() { + t.setupTest(mysql.MariaDBFlavor) - t.testPositionSync(c) + t.testPositionSync() } -func (t *testSyncerSuite) TestMariadbGTIDSync(c *C) { - t.setupTest(c, mysql.MariaDBFlavor) +func (t *testSyncerSuite) TestMariadbGTIDSync() { + t.setupTest(mysql.MariaDBFlavor) // get current master gtid binlog pos r, err := t.c.Execute("SELECT @@gtid_binlog_pos") - c.Assert(err, IsNil) + require.NoError(t.T(), err) str, _ := r.GetString(0, 0) set, _ := mysql.ParseMariadbGTIDSet(str) s, err := t.b.StartSyncGTID(set) - c.Assert(err, IsNil) + require.NoError(t.T(), err) - t.testSync(c, s) + t.testSync(s) } -func (t *testSyncerSuite) TestMariadbAnnotateRows(c *C) { - t.setupTest(c, mysql.MariaDBFlavor) +func (t *testSyncerSuite) TestMariadbAnnotateRows() { + t.setupTest(mysql.MariaDBFlavor) t.b.cfg.DumpCommandFlag = BINLOG_SEND_ANNOTATE_ROWS_EVENT - t.testPositionSync(c) + t.testPositionSync() } -func (t *testSyncerSuite) TestMysqlSemiPositionSync(c *C) { - t.setupTest(c, mysql.MySQLFlavor) +func (t *testSyncerSuite) TestMysqlSemiPositionSync() { + t.setupTest(mysql.MySQLFlavor) t.b.cfg.SemiSyncEnabled = true - t.testPositionSync(c) + t.testPositionSync() } -func (t *testSyncerSuite) TestMysqlBinlogCodec(c *C) { - t.setupTest(c, mysql.MySQLFlavor) +func (t *testSyncerSuite) TestMysqlBinlogCodec() { + t.setupTest(mysql.MySQLFlavor) - t.testExecute(c, "RESET MASTER") + t.testExecute("RESET MASTER") var wg sync.WaitGroup wg.Add(1) @@ -426,11 +415,11 @@ func (t *testSyncerSuite) TestMysqlBinlogCodec(c *C) { go func() { defer wg.Done() - t.testSync(c, nil) + t.testSync(nil) - t.testExecute(c, "FLUSH LOGS") + t.testExecute("FLUSH LOGS") - t.testSync(c, nil) + t.testSync(nil) }() binlogDir := "./var" @@ -438,7 +427,7 @@ func (t *testSyncerSuite) TestMysqlBinlogCodec(c *C) { os.RemoveAll(binlogDir) err := t.b.StartBackup(binlogDir, mysql.Position{Name: "", Pos: uint32(0)}, 2*time.Second) - c.Assert(err, IsNil) + require.NoError(t.T(), err) p := NewBinlogParser() p.SetVerifyChecksum(true) @@ -452,14 +441,14 @@ func (t *testSyncerSuite) TestMysqlBinlogCodec(c *C) { } dir, err := os.Open(binlogDir) - c.Assert(err, IsNil) + require.NoError(t.T(), err) defer dir.Close() files, err := dir.Readdirnames(-1) - c.Assert(err, IsNil) + require.NoError(t.T(), err) for _, file := range files { err = p.ParseFile(path.Join(binlogDir, file), 0, f) - c.Assert(err, IsNil) + require.NoError(t.T(), err) } } diff --git a/schema/schema_test.go b/schema/schema_test.go index 5d86bffb4..443e53a3b 100644 --- a/schema/schema_test.go +++ b/schema/schema_test.go @@ -27,7 +27,7 @@ type schemaTestSuite struct { var _ = Suite(&schemaTestSuite{}) -func (s *schemaTestSuite) SetUpSuite(c *C) { +func (s *schemaTestSuite) SetupSuite(c *C) { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) var err error diff --git a/server/caching_sha2_cache_test.go b/server/caching_sha2_cache_test.go index 85b6fb67c..627113e42 100644 --- a/server/caching_sha2_cache_test.go +++ b/server/caching_sha2_cache_test.go @@ -79,7 +79,7 @@ type cacheTestSuite struct { l net.Listener } -func (s *cacheTestSuite) SetUpSuite(c *C) { +func (s *cacheTestSuite) SetupSuite(c *C) { s.serverAddr = fmt.Sprintf("%s:%s", *test_util.MysqlFakeHost, *test_util.MysqlFakePort) var err error diff --git a/server/server_test.go b/server/server_test.go index e1ce748b1..7ddec8c8d 100644 --- a/server/server_test.go +++ b/server/server_test.go @@ -98,7 +98,7 @@ type serverTestSuite struct { l net.Listener } -func (s *serverTestSuite) SetUpSuite(c *C) { +func (s *serverTestSuite) SetupSuite(c *C) { addr := fmt.Sprintf("%s:%s", *test_util.MysqlFakeHost, *test_util.MysqlFakePort) var err error From d0ccb19e32ad7d8cfddd434204c962c6c37a358f Mon Sep 17 00:00:00 2001 From: lance6716 Date: Thu, 22 Jun 2023 21:34:54 +0800 Subject: [PATCH 04/11] change more files Signed-off-by: lance6716 --- client/auth_test.go | 2 +- client/client_test.go | 2 +- replication/event_test.go | 1 - replication/time_test.go | 21 +++---- schema/schema_test.go | 115 +++++++++++++++++++------------------- 5 files changed, 67 insertions(+), 74 deletions(-) diff --git a/client/auth_test.go b/client/auth_test.go index 8d91e4118..350e3aed2 100644 --- a/client/auth_test.go +++ b/client/auth_test.go @@ -27,7 +27,7 @@ func TestConnGenAttributes(t *testing.T) { // of the attribute data we need to check its partial contents require.Len(t, data, 98) - require.Equal(t, byte(0x1a), data[0]) + require.Equal(t, byte(0x61), data[0]) for k, v := range c.attributes { fixt := append(mysql.PutLengthEncodedString([]byte(k)), mysql.PutLengthEncodedString([]byte(v))...) diff --git a/client/client_test.go b/client/client_test.go index 0e17588d5..7fddd9dad 100644 --- a/client/client_test.go +++ b/client/client_test.go @@ -37,7 +37,7 @@ func (s *clientTestSuite) SetupSuite() { var result *mysql.Result result, err = s.c.Execute("CREATE DATABASE IF NOT EXISTS " + *testDB) require.NoError(s.T(), err) - require.Greater(s.T(), result.RowNumber(), 0) + require.GreaterOrEqual(s.T(), result.RowNumber(), 0) _, err = s.c.Execute("USE " + *testDB) require.NoError(s.T(), err) diff --git a/replication/event_test.go b/replication/event_test.go index a0cf9fcff..78bddc345 100644 --- a/replication/event_test.go +++ b/replication/event_test.go @@ -3,7 +3,6 @@ package replication import ( "testing" - . "github.com/pingcap/check" "github.com/stretchr/testify/require" ) diff --git a/replication/time_test.go b/replication/time_test.go index 3a06aaf69..2ce9ad18d 100644 --- a/replication/time_test.go +++ b/replication/time_test.go @@ -1,16 +1,13 @@ package replication import ( + "testing" "time" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -type testTimeSuite struct{} - -var _ = Suite(&testTimeSuite{}) - -func (s *testTimeSuite) TestTime(c *C) { +func TestTime(tt *testing.T) { tbls := []struct { year int month int @@ -29,7 +26,7 @@ func (s *testTimeSuite) TestTime(c *C) { for _, t := range tbls { t1 := fracTime{time.Date(t.year, time.Month(t.month), t.day, t.hour, t.min, t.sec, t.microSec*1000, time.UTC), t.frac, nil} - c.Assert(t1.String(), Equals, t.expected) + require.Equal(tt, t.expected, t1.String()) } zeroTbls := []struct { @@ -46,25 +43,23 @@ func (s *testTimeSuite) TestTime(c *C) { } for _, t := range zeroTbls { - c.Assert(formatZeroTime(t.frac, t.dec), Equals, t.expected) + require.Equal(tt, t.expected, formatZeroTime(t.frac, t.dec)) } } -func (s *testTimeSuite) TestTimeStringLocation(c *C) { +func TestTimeStringLocation(tt *testing.T) { t := fracTime{ time.Date(2018, time.Month(7), 30, 10, 0, 0, 0, time.FixedZone("EST", -5*3600)), 0, nil, } - c.Assert(t.String(), Equals, "2018-07-30 10:00:00") + require.Equal(tt, "2018-07-30 15:00:00", t.String()) t = fracTime{ time.Date(2018, time.Month(7), 30, 10, 0, 0, 0, time.FixedZone("EST", -5*3600)), 0, time.UTC, } - c.Assert(t.String(), Equals, "2018-07-30 15:00:00") + require.Equal(tt, "2018-07-30 10:00:00", t.String()) } - -var _ = Suite(&testTimeSuite{}) diff --git a/schema/schema_test.go b/schema/schema_test.go index 443e53a3b..24fb7a2d5 100644 --- a/schema/schema_test.go +++ b/schema/schema_test.go @@ -6,39 +6,38 @@ import ( "fmt" "testing" - . "github.com/pingcap/check" - "github.com/go-mysql-org/go-mysql/client" _ "github.com/go-mysql-org/go-mysql/driver" "github.com/go-mysql-org/go-mysql/test_util" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" ) var schema = flag.String("schema", "test", "MySQL Database") var pwd = flag.String("pwd", "", "MySQL password") -func Test(t *testing.T) { - TestingT(t) -} - type schemaTestSuite struct { + suite.Suite conn *client.Conn sqlDB *sql.DB } -var _ = Suite(&schemaTestSuite{}) +func TestSchemaSuite(t *testing.T) { + suite.Run(t, new(schemaTestSuite)) +} -func (s *schemaTestSuite) SetupSuite(c *C) { +func (s *schemaTestSuite) SetupSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlHost, *test_util.MysqlPort) var err error s.conn, err = client.Connect(addr, "root", *pwd, *schema) - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.sqlDB, err = sql.Open("mysql", fmt.Sprintf("root:%s@%s", *pwd, addr)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) } -func (s *schemaTestSuite) TearDownSuite(c *C) { +func (s *schemaTestSuite) TearDownSuite() { if s.conn != nil { s.conn.Close() } @@ -48,9 +47,9 @@ func (s *schemaTestSuite) TearDownSuite(c *C) { } } -func (s *schemaTestSuite) TestSchema(c *C) { +func (s *schemaTestSuite) TestSchema() { _, err := s.conn.Execute(`DROP TABLE IF EXISTS schema_test`) - c.Assert(err, IsNil) + require.NoError(s.T(), err) str := ` CREATE TABLE IF NOT EXISTS schema_test ( @@ -76,62 +75,62 @@ func (s *schemaTestSuite) TestSchema(c *C) { ` _, err = s.conn.Execute(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) ta, err := NewTable(s.conn, *schema, "schema_test") - c.Assert(err, IsNil) - - c.Assert(ta.Columns, HasLen, 15) - c.Assert(ta.Indexes, HasLen, 3) - c.Assert(ta.PKColumns, DeepEquals, []int{2, 0}) - c.Assert(ta.IsPrimaryKey(0), IsTrue) - c.Assert(ta.IsPrimaryKey(1), IsFalse) - c.Assert(ta.IsPrimaryKey(2), IsTrue) - c.Assert(ta.IsPrimaryKey(3), IsFalse) - c.Assert(ta.GetPKColumn(0), Equals, &ta.Columns[2]) - c.Assert(ta.GetPKColumn(1), Equals, &ta.Columns[0]) - c.Assert(ta.GetPKColumn(2), IsNil) - c.Assert(ta.GetPKColumn(3), IsNil) - c.Assert(ta.Indexes[0].Columns, HasLen, 2) - c.Assert(ta.Indexes[0].Name, Equals, "PRIMARY") - c.Assert(ta.Indexes[2].Name, Equals, "name_idx") - c.Assert(ta.Columns[3].Type, Equals, TYPE_STRING) - c.Assert(ta.Columns[3].MaxSize, Equals, uint(256)) - c.Assert(ta.Columns[3].FixedSize, Equals, uint(0)) - c.Assert(ta.Columns[4].EnumValues, DeepEquals, []string{"appointing", "serving", "abnormal", "stop", "noaftermarket", "finish", "financial_audit"}) - c.Assert(ta.Columns[5].SetValues, DeepEquals, []string{"a", "b", "c"}) - c.Assert(ta.Columns[7].Type, Equals, TYPE_DECIMAL) - c.Assert(ta.Columns[0].IsUnsigned, IsFalse) - c.Assert(ta.Columns[8].IsUnsigned, IsTrue) - c.Assert(ta.Columns[9].IsUnsigned, IsTrue) - c.Assert(ta.Columns[10].Collation, Matches, "^ucs2.*") - c.Assert(ta.Columns[10].MaxSize, Equals, uint(256)) - c.Assert(ta.Columns[10].FixedSize, Equals, uint(0)) - c.Assert(ta.Columns[11].Collation, Matches, "^utf8.*") - c.Assert(ta.Columns[12].Type, Equals, TYPE_STRING) - c.Assert(ta.Columns[12].MaxSize, Equals, uint(10)) - c.Assert(ta.Columns[12].FixedSize, Equals, uint(10)) - c.Assert(ta.Columns[13].Type, Equals, TYPE_BINARY) - c.Assert(ta.Columns[13].MaxSize, Equals, uint(11)) - c.Assert(ta.Columns[13].FixedSize, Equals, uint(11)) - c.Assert(ta.Columns[14].Type, Equals, TYPE_BINARY) - c.Assert(ta.Columns[14].MaxSize, Equals, uint(12)) - c.Assert(ta.Columns[14].FixedSize, Equals, uint(0)) + require.NoError(s.T(), err) + + require.Len(s.T(), ta.Columns, 15) + require.Len(s.T(), ta.Indexes, 3) + require.Equal(s.T(), []int{2, 0}, ta.PKColumns) + require.True(s.T(), ta.IsPrimaryKey(0)) + require.False(s.T(), ta.IsPrimaryKey(1)) + require.True(s.T(), ta.IsPrimaryKey(2)) + require.False(s.T(), ta.IsPrimaryKey(3)) + require.Equal(s.T(), &ta.Columns[2], ta.GetPKColumn(0)) + require.Equal(s.T(), &ta.Columns[0], ta.GetPKColumn(1)) + require.Nil(s.T(), ta.GetPKColumn(2)) + require.Nil(s.T(), ta.GetPKColumn(3)) + require.Len(s.T(), ta.Indexes[0].Columns, 2) + require.Equal(s.T(), "PRIMARY", ta.Columns[0].Name) + require.Equal(s.T(), "name_idx", ta.Columns[2].Name) + require.Equal(s.T(), TYPE_STRING, ta.Columns[3].Type) + require.Equal(s.T(), uint(256), ta.Columns[3].MaxSize) + require.Equal(s.T(), uint(0), ta.Columns[3].FixedSize) + require.Equal(s.T(), []string{"appointing", "serving", "abnormal", "stop", "noaftermarket", "finish", "financial_audit"}, ta.Columns[4].EnumValues) + require.Equal(s.T(), []string{"a", "b", "c"}, ta.Columns[5].SetValues) + require.Equal(s.T(), TYPE_DECIMAL, ta.Columns[7].Type) + require.False(s.T(), ta.Columns[0].IsUnsigned) + require.True(s.T(), ta.Columns[8].IsUnsigned) + require.True(s.T(), ta.Columns[9].IsUnsigned) + require.Contains(s.T(), ta.Columns[10].Collation, "ucs2") + require.Equal(s.T(), uint(256), ta.Columns[10].MaxSize) + require.Equal(s.T(), uint(0), ta.Columns[10].MaxSize) + require.Contains(s.T(), ta.Columns[11].Collation, "utf8") + require.Equal(s.T(), TYPE_STRING, ta.Columns[12].Type) + require.Equal(s.T(), uint(10), ta.Columns[12].MaxSize) + require.Equal(s.T(), uint(10), ta.Columns[12].FixedSize) + require.Equal(s.T(), TYPE_BINARY, ta.Columns[13].Type) + require.Equal(s.T(), uint(11), ta.Columns[13].MaxSize) + require.Equal(s.T(), uint(11), ta.Columns[13].FixedSize) + require.Equal(s.T(), TYPE_BINARY, ta.Columns[14].Type) + require.Equal(s.T(), uint(12), ta.Columns[14].MaxSize) + require.Equal(s.T(), uint(0), ta.Columns[14].FixedSize) taSqlDb, err := NewTableFromSqlDB(s.sqlDB, *schema, "schema_test") - c.Assert(err, IsNil) + require.NoError(s.T(), err) - c.Assert(taSqlDb, DeepEquals, ta) + require.Equal(s.T(), ta, taSqlDb) } -func (s *schemaTestSuite) TestQuoteSchema(c *C) { +func (s *schemaTestSuite) TestQuoteSchema() { str := "CREATE TABLE IF NOT EXISTS `a-b_test` (`a.b` INT) ENGINE = INNODB" _, err := s.conn.Execute(str) - c.Assert(err, IsNil) + require.NoError(s.T(), err) ta, err := NewTable(s.conn, *schema, "a-b_test") - c.Assert(err, IsNil) + require.NoError(s.T(), err) - c.Assert(ta.Columns[0].Name, Equals, "a.b") + require.Equal(s.T(), "a.b", ta.Columns[0].Name) } From 6d945fb2927ca6c97fcef0168d8a421d364fb145 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Thu, 22 Jun 2023 22:43:26 +0800 Subject: [PATCH 05/11] change more files Signed-off-by: lance6716 --- client/auth_test.go | 2 +- mysql/position_test.go | 15 ++- mysql/util_test.go | 17 ++-- replication/replication_test.go | 2 +- replication/time_test.go | 4 +- schema/schema_test.go | 4 +- server/caching_sha2_cache_test.go | 50 +++++----- server/conn_test.go | 41 ++++---- server/handshake_resp_test.go | 13 +-- server/resp_test.go | 152 +++++++++++++++--------------- server/server_test.go | 80 ++++++++-------- utils/utils_test.go | 2 - 12 files changed, 181 insertions(+), 201 deletions(-) diff --git a/client/auth_test.go b/client/auth_test.go index 350e3aed2..85dba1e98 100644 --- a/client/auth_test.go +++ b/client/auth_test.go @@ -31,6 +31,6 @@ func TestConnGenAttributes(t *testing.T) { for k, v := range c.attributes { fixt := append(mysql.PutLengthEncodedString([]byte(k)), mysql.PutLengthEncodedString([]byte(v))...) - require.Contains(t, data, fixt) + require.Subset(t, data, fixt) } } diff --git a/mysql/position_test.go b/mysql/position_test.go index aecf5d63b..401b03939 100644 --- a/mysql/position_test.go +++ b/mysql/position_test.go @@ -1,15 +1,12 @@ package mysql import ( - "github.com/pingcap/check" -) - -type positionCompareSuite struct { -} + "testing" -var _ = check.Suite(&positionCompareSuite{}) + "github.com/stretchr/testify/require" +) -func (t *positionCompareSuite) TestPosCompare(c *check.C) { +func TestPosCompare(t *testing.T) { ascendingPositions := []Position{ { "", @@ -42,10 +39,10 @@ func (t *positionCompareSuite) TestPosCompare(c *check.C) { } for i := 1; i < len(ascendingPositions); i++ { - c.Assert(ascendingPositions[i-1].Compare(ascendingPositions[i]), check.Equals, -1) + require.Equal(t, -1, ascendingPositions[i-1].Compare(ascendingPositions[i])) } for _, p := range ascendingPositions { - c.Assert(p.Compare(p), check.Equals, 0) + require.Equal(t, 0, p.Compare(p)) } } diff --git a/mysql/util_test.go b/mysql/util_test.go index 29a5b02e4..5851ed81e 100644 --- a/mysql/util_test.go +++ b/mysql/util_test.go @@ -1,15 +1,12 @@ package mysql import ( - "github.com/pingcap/check" -) - -type utilTestSuite struct { -} + "testing" -var _ = check.Suite(&utilTestSuite{}) + "github.com/stretchr/testify/require" +) -func (s *utilTestSuite) TestCompareServerVersions(c *check.C) { +func TestCompareServerVersions(t *testing.T) { tests := []struct { A string B string @@ -21,10 +18,8 @@ func (s *utilTestSuite) TestCompareServerVersions(c *check.C) { } for _, test := range tests { - comment := check.Commentf("%q vs. %q", test.A, test.B) - got, err := CompareServerVersions(test.A, test.B) - c.Assert(err, check.IsNil, comment) - c.Assert(got, check.Equals, test.Expect, comment) + require.NoError(t, err) + require.Equal(t, test.Expect, got) } } diff --git a/replication/replication_test.go b/replication/replication_test.go index addb2fa72..8b70f9e44 100644 --- a/replication/replication_test.go +++ b/replication/replication_test.go @@ -316,7 +316,7 @@ func (t *testSyncerSuite) testPositionSync() { require.NoError(t.T(), err) // List of replicas must not be empty - require.Len(t.T(), r.Values, 0) + require.Greater(t.T(), len(r.Values), 0) // Slave_UUID is empty for mysql 8.0.28+ (8.0.32 still broken) if eq, err := t.c.CompareServerVersion("8.0.28"); (err == nil) && (eq < 0) { diff --git a/replication/time_test.go b/replication/time_test.go index 2ce9ad18d..84065d7c0 100644 --- a/replication/time_test.go +++ b/replication/time_test.go @@ -54,12 +54,12 @@ func TestTimeStringLocation(tt *testing.T) { nil, } - require.Equal(tt, "2018-07-30 15:00:00", t.String()) + require.Equal(tt, "2018-07-30 10:00:00", t.String()) t = fracTime{ time.Date(2018, time.Month(7), 30, 10, 0, 0, 0, time.FixedZone("EST", -5*3600)), 0, time.UTC, } - require.Equal(tt, "2018-07-30 10:00:00", t.String()) + require.Equal(tt, "2018-07-30 15:00:00", t.String()) } diff --git a/schema/schema_test.go b/schema/schema_test.go index 24fb7a2d5..799c532c5 100644 --- a/schema/schema_test.go +++ b/schema/schema_test.go @@ -92,8 +92,8 @@ func (s *schemaTestSuite) TestSchema() { require.Nil(s.T(), ta.GetPKColumn(2)) require.Nil(s.T(), ta.GetPKColumn(3)) require.Len(s.T(), ta.Indexes[0].Columns, 2) - require.Equal(s.T(), "PRIMARY", ta.Columns[0].Name) - require.Equal(s.T(), "name_idx", ta.Columns[2].Name) + require.Equal(s.T(), "PRIMARY", ta.Indexes[0].Name) + require.Equal(s.T(), "name_idx", ta.Indexes[2].Name) require.Equal(s.T(), TYPE_STRING, ta.Columns[3].Type) require.Equal(s.T(), uint(256), ta.Columns[3].MaxSize) require.Equal(s.T(), uint(0), ta.Columns[3].FixedSize) diff --git a/server/caching_sha2_cache_test.go b/server/caching_sha2_cache_test.go index 627113e42..247e1870f 100644 --- a/server/caching_sha2_cache_test.go +++ b/server/caching_sha2_cache_test.go @@ -10,9 +10,10 @@ import ( "time" _ "github.com/go-sql-driver/mysql" - . "github.com/pingcap/check" "github.com/pingcap/errors" "github.com/siddontang/go-log/log" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/test_util" @@ -32,13 +33,11 @@ func TestCachingSha2Cache(t *testing.T) { cacheServer := NewServer("8.0.12", mysql.DEFAULT_COLLATION_ID, mysql.AUTH_CACHING_SHA2_PASSWORD, test_keys.PubPem, tlsConf) // no TLS - Suite(&cacheTestSuite{ + suite.Run(t, &cacheTestSuite{ server: cacheServer, credProvider: remoteProvider, tlsPara: "false", }) - - TestingT(t) } func TestCachingSha2CacheTLS(t *testing.T) { @@ -49,13 +48,11 @@ func TestCachingSha2CacheTLS(t *testing.T) { cacheServer := NewServer("8.0.12", mysql.DEFAULT_COLLATION_ID, mysql.AUTH_CACHING_SHA2_PASSWORD, test_keys.PubPem, tlsConf) // TLS - Suite(&cacheTestSuite{ + suite.Run(t, &cacheTestSuite{ server: cacheServer, credProvider: remoteProvider, tlsPara: "skip-verify", }) - - TestingT(t) } type RemoteThrottleProvider struct { @@ -69,6 +66,7 @@ func (m *RemoteThrottleProvider) GetCredential(username string) (password string } type cacheTestSuite struct { + suite.Suite server *Server serverAddr string credProvider CredentialProvider @@ -79,40 +77,40 @@ type cacheTestSuite struct { l net.Listener } -func (s *cacheTestSuite) SetupSuite(c *C) { +func (s *cacheTestSuite) SetupSuite() { s.serverAddr = fmt.Sprintf("%s:%s", *test_util.MysqlFakeHost, *test_util.MysqlFakePort) var err error s.l, err = net.Listen("tcp", s.serverAddr) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - go s.onAccept(c) + go s.onAccept() time.Sleep(30 * time.Millisecond) } -func (s *cacheTestSuite) TearDownSuite(c *C) { +func (s *cacheTestSuite) TearDownSuite() { if s.l != nil { s.l.Close() } } -func (s *cacheTestSuite) onAccept(c *C) { +func (s *cacheTestSuite) onAccept() { for { conn, err := s.l.Accept() if err != nil { return } - go s.onConn(conn, c) + go s.onConn(conn) } } -func (s *cacheTestSuite) onConn(conn net.Conn, c *C) { +func (s *cacheTestSuite) onConn(conn net.Conn) { //co, err := NewConn(conn, *testUser, *testPassword, &testHandler{s}) co, err := NewCustomizedConn(conn, s.server, s.credProvider, &testCacheHandler{s}) - c.Assert(err, IsNil) + require.NoError(s.T(), err) for { err = co.HandleCommand() if err != nil { @@ -121,30 +119,30 @@ func (s *cacheTestSuite) onConn(conn net.Conn, c *C) { } } -func (s *cacheTestSuite) runSelect(c *C) { +func (s *cacheTestSuite) runSelect() { var a int64 var b string err := s.db.QueryRow("SELECT a, b FROM tbl WHERE id=1").Scan(&a, &b) - c.Assert(err, IsNil) - c.Assert(a, Equals, int64(1)) - c.Assert(b, Equals, "hello world") + require.NoError(s.T(), err) + require.Equal(s.T(), int64(1), a) + require.Equal(s.T(), "hello world", b) } -func (s *cacheTestSuite) TestCache(c *C) { +func (s *cacheTestSuite) TestCache() { // first connection t1 := time.Now() var err error s.db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=%s", *testUser, *testPassword, s.serverAddr, *testDB, s.tlsPara)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.db.SetMaxIdleConns(4) - s.runSelect(c) + s.runSelect() t2 := time.Now() d1 := int(t2.Sub(t1).Nanoseconds() / 1e6) //log.Debugf("first connection took %d milliseconds", d1) - c.Assert(d1, GreaterEqual, delay) + require.GreaterOrEqual(s.T(), d1, delay) if s.db != nil { s.db.Close() @@ -153,15 +151,15 @@ func (s *cacheTestSuite) TestCache(c *C) { // second connection t3 := time.Now() s.db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=%s", *testUser, *testPassword, s.serverAddr, *testDB, s.tlsPara)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.db.SetMaxIdleConns(4) - s.runSelect(c) + s.runSelect() t4 := time.Now() d2 := int(t4.Sub(t3).Nanoseconds() / 1e6) //log.Debugf("second connection took %d milliseconds", d2) - c.Assert(d2, Less, delay) + require.Less(s.T(), d2, delay) if s.db != nil { s.db.Close() } diff --git a/server/conn_test.go b/server/conn_test.go index da5926582..d14882136 100644 --- a/server/conn_test.go +++ b/server/conn_test.go @@ -1,16 +1,13 @@ package server import ( + "testing" + "github.com/go-mysql-org/go-mysql/mysql" - "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -type connTestSuite struct { -} - -var _ = check.Suite(&connTestSuite{}) - -func (t *connTestSuite) TestStatus(c *check.C) { +func TestStatus(t *testing.T) { conn := Conn{} flags := []uint16{ @@ -29,35 +26,35 @@ func (t *connTestSuite) TestStatus(c *check.C) { } for _, f := range flags { - c.Assert(conn.HasStatus(f), check.IsFalse) + require.False(t, conn.HasStatus(f)) conn.SetStatus(f) - c.Assert(conn.HasStatus(f), check.IsTrue) + require.True(t, conn.HasStatus(f)) conn.UnsetStatus(f) - c.Assert(conn.HasStatus(f), check.IsFalse) + require.False(t, conn.HasStatus(f)) } // check special flag setters // IsAutoCommit - c.Assert(conn.IsAutoCommit(), check.IsFalse) + require.False(t, conn.IsAutoCommit()) conn.SetStatus(mysql.SERVER_STATUS_AUTOCOMMIT) - c.Assert(conn.IsAutoCommit(), check.IsTrue) + require.True(t, conn.IsAutoCommit()) conn.UnsetStatus(mysql.SERVER_STATUS_AUTOCOMMIT) // IsInTransaction - c.Assert(conn.IsInTransaction(), check.IsFalse) + require.False(t, conn.IsInTransaction()) conn.SetStatus(mysql.SERVER_STATUS_IN_TRANS) - c.Assert(conn.IsInTransaction(), check.IsTrue) + require.True(t, conn.IsInTransaction()) conn.UnsetStatus(mysql.SERVER_STATUS_IN_TRANS) // SetInTransaction & ClearInTransaction - c.Assert(conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS), check.IsFalse) + require.False(t, conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS)) conn.SetInTransaction() - c.Assert(conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS), check.IsTrue) + require.True(t, conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS)) conn.ClearInTransaction() - c.Assert(conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS), check.IsFalse) + require.False(t, conn.HasStatus(mysql.SERVER_STATUS_IN_TRANS)) } -func (t *connTestSuite) TestCapability(c *check.C) { +func TestCapability(t *testing.T) { conn := Conn{} caps := []uint32{ @@ -86,11 +83,11 @@ func (t *connTestSuite) TestCapability(c *check.C) { } for _, capI := range caps { - c.Assert(conn.HasCapability(capI), check.IsFalse) + require.False(t, conn.HasCapability(capI)) conn.SetCapability(capI) - c.Assert(conn.HasCapability(capI), check.IsTrue) - c.Assert(conn.Capability()&capI > 0, check.IsTrue) + require.True(t, conn.HasCapability(capI)) + require.True(t, conn.Capability()&capI > 0) conn.UnsetCapability(capI) - c.Assert(conn.HasCapability(capI), check.IsFalse) + require.False(t, conn.HasCapability(capI)) } } diff --git a/server/handshake_resp_test.go b/server/handshake_resp_test.go index dc0df4d8d..c75b9d180 100644 --- a/server/handshake_resp_test.go +++ b/server/handshake_resp_test.go @@ -7,6 +7,7 @@ import ( "github.com/go-mysql-org/go-mysql/mocks" "github.com/go-mysql-org/go-mysql/mysql" "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" ) func TestReadAuthData(t *testing.T) { @@ -18,18 +19,12 @@ func TestReadAuthData(t *testing.T) { // test out of range index returns 'bad handshake' error _, _, _, err := c.readAuthData(data, len(data)) - if err == nil || err.Error() != "ERROR 1043 (08S01): Bad handshake" { - t.Fatal("expected error, got nil") - } + require.ErrorContains(t, err, "ERROR 1043 (08S01): Bad handshake") // test good index position reads auth data _, _, readBytes, err := c.readAuthData(data, len(data)-1) - if err != nil { - t.Fatalf("expected nil error, got %v", err) - } - if readBytes != len(data)-1 { - t.Fatalf("expected %d read bytes, got %d", len(data)-1, readBytes) - } + require.NoError(t, err) + require.Equal(t, len(data)-1, readBytes) } func TestDecodeFirstPart(t *testing.T) { diff --git a/server/resp_test.go b/server/resp_test.go index 4a290e6e5..1abb32c8f 100644 --- a/server/resp_test.go +++ b/server/resp_test.go @@ -2,18 +2,15 @@ package server import ( "errors" + "testing" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/packet" mockconn "github.com/go-mysql-org/go-mysql/test_util/conn" - "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -type respConnTestSuite struct{} - -var _ = check.Suite(&respConnTestSuite{}) - -func (t *respConnTestSuite) TestConnWriteOK(c *check.C) { +func TestConnWriteOK(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} @@ -24,92 +21,95 @@ func (t *respConnTestSuite) TestConnWriteOK(c *check.C) { // write ok with insertid and affectedrows set err := conn.writeOK(result) - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{3, 0, 0, 0, mysql.OK_HEADER, 1, 2}) + require.NoError(t, err) + expected := []byte{3, 0, 0, 0, mysql.OK_HEADER, 1, 2} + require.Equal(t, expected, clientConn.WriteBuffered) // set capability for CLIENT_PROTOCOL_41 conn.SetCapability(mysql.CLIENT_PROTOCOL_41) conn.SetStatus(mysql.SERVER_QUERY_WAS_SLOW) err = conn.writeOK(result) - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{7, 0, 0, 1, mysql.OK_HEADER, 1, 2, 0, 8, 0, 0}) + require.NoError(t, err) + expected = []byte{7, 0, 0, 1, mysql.OK_HEADER, 1, 2, 0, 8, 0, 0} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteEOF(c *check.C) { +func TestConnWriteEOF(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} // write regular EOF err := conn.writeEOF() - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{1, 0, 0, 0, mysql.EOF_HEADER}) + require.NoError(t, err) + expected := []byte{1, 0, 0, 0, mysql.EOF_HEADER} + require.Equal(t, expected, clientConn.WriteBuffered) // set capability for CLIENT_PROTOCOL_41 conn.SetCapability(mysql.CLIENT_PROTOCOL_41) conn.SetStatus(mysql.SERVER_MORE_RESULTS_EXISTS) err = conn.writeEOF() - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{5, 0, 0, 1, mysql.EOF_HEADER, - 0, 0, 8, 0}) + require.NoError(t, err) + expected = []byte{5, 0, 0, 1, mysql.EOF_HEADER, 0, 8, 0, 0} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteError(c *check.C) { +func TestConnWriteError(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} merr := mysql.NewDefaultError(mysql.ER_YES) // nice and short error message // write regular Error err := conn.writeError(merr) - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{6, 0, 0, 0, mysql.ERR_HEADER, - 235, 3, 89, 69, 83}) + require.NoError(t, err) + expected := []byte{6, 0, 0, 0, mysql.ERR_HEADER, 235, 3, 89, 69, 83} + require.Equal(t, expected, clientConn.WriteBuffered) // set capability for CLIENT_PROTOCOL_41 conn.SetCapability(mysql.CLIENT_PROTOCOL_41) err = conn.writeError(merr) - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{12, 0, 0, 1, mysql.ERR_HEADER, - 235, 3, 35, 72, 89, 48, 48, 48, 89, 69, 83}) + require.NoError(t, err) + expected = []byte{12, 0, 0, 1, mysql.ERR_HEADER, 235, 3, 35, 72, 89, 48, 48, 48, 89, 69, 83} + require.Equal(t, expected, clientConn.WriteBuffered) // unknown error err = conn.writeError(errors.New("test")) - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{13, 0, 0, 2, mysql.ERR_HEADER, - 81, 4, 35, 72, 89, 48, 48, 48, 116, 101, 115, 116}) + require.NoError(t, err) + expected = []byte{13, 0, 0, 1, mysql.ERR_HEADER, 81, 4, 35, 72, 89, 48, 48, 48, 116, 101, 115, 116} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteAuthSwitchRequest(c *check.C) { +func TestConnWriteAuthSwitchRequest(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} err := conn.writeAuthSwitchRequest("test") - c.Assert(err, check.IsNil) + require.NoError(t, err) // first 10 bytes are static, then there is a part random, ending with a \0 - c.Assert(clientConn.WriteBuffered[:10], check.BytesEquals, []byte{27, 0, 0, 0, mysql.EOF_HEADER, - 116, 101, 115, 116, 0}) - c.Assert(clientConn.WriteBuffered[len(clientConn.WriteBuffered)-1:], check.BytesEquals, []byte{0}) + expected := []byte{27, 0, 0, 0, mysql.EOF_HEADER, 116, 101, 115, 116, 0} + require.Equal(t, expected, clientConn.WriteBuffered[:10]) + require.Equal(t, byte(0), clientConn.WriteBuffered[len(clientConn.WriteBuffered)-1]) } -func (t *respConnTestSuite) TestConnReadAuthSwitchRequestResponse(c *check.C) { +func TestConnReadAuthSwitchRequestResponse(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} // prepare response for \NUL clientConn.SetResponse([][]byte{{1, 0, 0, 0, 0}}) data, err := conn.readAuthSwitchRequestResponse() - c.Assert(err, check.IsNil) - c.Assert(data, check.BytesEquals, []byte{}) + require.NoError(t, err) + require.Equal(t, []byte{}, data) // prepare response for some auth switch data clientConn.SetResponse([][]byte{{4, 0, 0, 0, 1, 2, 3, 4}}) conn = &Conn{Conn: packet.NewConn(clientConn)} data, err = conn.readAuthSwitchRequestResponse() - c.Assert(err, check.IsNil) - c.Assert(data, check.BytesEquals, []byte{1, 2, 3, 4}) + require.NoError(t, err) + require.Equal(t, []byte{1, 2, 3, 4}, data) } -func (t *respConnTestSuite) TestConnWriteAuthMoreDataPubkey(c *check.C) { +func TestConnWriteAuthMoreDataPubkey(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{ Conn: packet.NewConn(clientConn), @@ -119,32 +119,32 @@ func (t *respConnTestSuite) TestConnWriteAuthMoreDataPubkey(c *check.C) { } err := conn.writeAuthMoreDataPubkey() - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{5, 0, 0, 0, mysql.MORE_DATE_HEADER, - 1, 2, 3, 4}) + require.NoError(t, err) + expected := []byte{5, 0, 0, 0, mysql.MORE_DATE_HEADER, 1, 2, 3, 4} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteAuthMoreDataFullAuth(c *check.C) { +func TestConnWriteAuthMoreDataFullAuth(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} err := conn.writeAuthMoreDataFullAuth() - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{2, 0, 0, 0, mysql.MORE_DATE_HEADER, - mysql.CACHE_SHA2_FULL_AUTH}) + require.NoError(t, err) + expected := []byte{2, 0, 0, 0, mysql.MORE_DATE_HEADER, mysql.CACHE_SHA2_FULL_AUTH} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteAuthMoreDataFastAuth(c *check.C) { +func TestConnWriteAuthMoreDataFastAuth(t *testing.T) { clientConn := &mockconn.MockConn{} conn := &Conn{Conn: packet.NewConn(clientConn)} err := conn.writeAuthMoreDataFastAuth() - c.Assert(err, check.IsNil) - c.Assert(clientConn.WriteBuffered, check.BytesEquals, []byte{2, 0, 0, 0, mysql.MORE_DATE_HEADER, - mysql.CACHE_SHA2_FAST_AUTH}) + require.NoError(t, err) + expected := []byte{2, 0, 0, 0, mysql.MORE_DATE_HEADER, mysql.CACHE_SHA2_FAST_AUTH} + require.Equal(t, expected, clientConn.WriteBuffered) } -func (t *respConnTestSuite) TestConnWriteResultset(c *check.C) { +func TestConnWriteResultset(t *testing.T) { clientConn := &mockconn.MockConn{MultiWrite: true} conn := &Conn{Conn: packet.NewConn(clientConn)} @@ -152,45 +152,45 @@ func (t *respConnTestSuite) TestConnWriteResultset(c *check.C) { // write minimalistic resultset err := conn.writeResultset(r) - c.Assert(err, check.IsNil) + require.NoError(t, err) // column length 0 - c.Assert(clientConn.WriteBuffered[:5], check.BytesEquals, []byte{1, 0, 0, 0, 0}) + require.Equal(t, []byte{1, 0, 0, 0, 0}, clientConn.WriteBuffered[:5]) // no fields and an EOF - c.Assert(clientConn.WriteBuffered[5:10], check.BytesEquals, []byte{1, 0, 0, 1, mysql.EOF_HEADER}) + require.Equal(t, []byte{1, 0, 0, 1, mysql.EOF_HEADER}, clientConn.WriteBuffered[5:10]) // no rows and another EOF - c.Assert(clientConn.WriteBuffered[10:], check.BytesEquals, []byte{1, 0, 0, 2, mysql.EOF_HEADER}) + require.Equal(t, []byte{1, 0, 0, 2, mysql.EOF_HEADER}, clientConn.WriteBuffered[10:]) // reset write buffer and fill up the resultset with (little) data clientConn.WriteBuffered = []byte{} r, err = mysql.BuildSimpleTextResultset([]string{"a"}, [][]interface{}{{"b"}}) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = conn.writeResultset(r) - c.Assert(err, check.IsNil) + require.NoError(t, err) // column length 1 - c.Assert(clientConn.WriteBuffered[:5], check.BytesEquals, []byte{1, 0, 0, 3, 1}) + require.Equal(t, []byte{1, 0, 0, 0, 1}, clientConn.WriteBuffered[:5]) // fields and EOF - c.Assert(clientConn.WriteBuffered[5:32], check.BytesEquals, []byte{23, 0, 0, 4, 3, 100, 101, 102, 0, 0, 0, 1, 'a', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}) - c.Assert(clientConn.WriteBuffered[32:37], check.BytesEquals, []byte{1, 0, 0, 5, mysql.EOF_HEADER}) + require.Equal(t, []byte{23, 0, 0, 4, 3, 100, 101, 102, 0, 0, 0, 1, 'a', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}, clientConn.WriteBuffered[5:32]) + require.Equal(t, []byte{1, 0, 0, 5, mysql.EOF_HEADER}, clientConn.WriteBuffered[32:37]) // rowdata and EOF - c.Assert(clientConn.WriteBuffered[37:43], check.BytesEquals, []byte{2, 0, 0, 6, 1, 'b'}) - c.Assert(clientConn.WriteBuffered[43:], check.BytesEquals, []byte{1, 0, 0, 7, mysql.EOF_HEADER}) + require.Equal(t, []byte{2, 0, 0, 6, 1, 'b'}, clientConn.WriteBuffered[37:43]) + require.Equal(t, []byte{1, 0, 0, 7, mysql.EOF_HEADER}, clientConn.WriteBuffered[43:]) } -func (t *respConnTestSuite) TestConnWriteFieldList(c *check.C) { +func TestConnWriteFieldList(t *testing.T) { clientConn := &mockconn.MockConn{MultiWrite: true} conn := &Conn{Conn: packet.NewConn(clientConn)} r, err := mysql.BuildSimpleTextResultset([]string{"c"}, [][]interface{}{{"d"}}) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = conn.writeFieldList(r.Fields, nil) - c.Assert(err, check.IsNil) + require.NoError(t, err) // column length 1 - c.Assert(clientConn.WriteBuffered[:27], check.BytesEquals, []byte{23, 0, 0, 0, 3, 100, 101, 102, 0, 0, 0, 1, 'c', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}) - c.Assert(clientConn.WriteBuffered[27:], check.BytesEquals, []byte{1, 0, 0, 1, mysql.EOF_HEADER}) + require.Equal(t, []byte{23, 0, 0, 0, 3, 100, 101, 102, 0, 0, 0, 1, 'c', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}, clientConn.WriteBuffered[:27]) + require.Equal(t, []byte{1, 0, 0, 1, mysql.EOF_HEADER}, clientConn.WriteBuffered[27:]) } -func (t *respConnTestSuite) TestConnWriteFieldValues(c *check.C) { +func TestConnWriteFieldValues(t *testing.T) { clientConn := &mockconn.MockConn{MultiWrite: true} conn := &Conn{Conn: packet.NewConn(clientConn)} @@ -199,33 +199,33 @@ func (t *respConnTestSuite) TestConnWriteFieldValues(c *check.C) { {nil}, }) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = conn.writeFieldList(r.Fields, nil) - c.Assert(err, check.IsNil) + require.NoError(t, err) // fields and EOF - c.Assert(clientConn.WriteBuffered[:27], check.BytesEquals, []byte{23, 0, 0, 0, 3, 100, 101, 102, 0, 0, 0, 1, 'c', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}) - c.Assert(clientConn.WriteBuffered[27:32], check.BytesEquals, []byte{1, 0, 0, 1, mysql.EOF_HEADER}) + require.Equal(t, []byte{23, 0, 0, 0, 3, 100, 101, 102, 0, 0, 0, 1, 'c', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}, clientConn.WriteBuffered[:27]) + require.Equal(t, []byte{1, 0, 0, 1, mysql.EOF_HEADER}, clientConn.WriteBuffered[27:32]) r.Values = make([][]mysql.FieldValue, len(r.RowDatas)) for i := range r.Values { r.Values[i], err = r.RowDatas[i].Parse(r.Fields, false, r.Values[i]) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = conn.writeFieldValues(r.Values[i]) - c.Assert(err, check.IsNil) + require.NoError(t, err) } err = conn.writeEOF() - c.Assert(err, check.IsNil) + require.NoError(t, err) // first row - c.Assert(clientConn.WriteBuffered[32:38], check.BytesEquals, []byte{2, 0, 0, 2, 1, 'd'}) + require.Equal(t, []byte{2, 0, 0, 2, 1, 'd'}, clientConn.WriteBuffered[32:38]) // second row with NULL value - c.Assert(clientConn.WriteBuffered[38:43], check.BytesEquals, []byte{1, 0, 0, 3, 251}) + require.Equal(t, []byte{2, 0, 0, 3, 251}, clientConn.WriteBuffered[38:43]) // EOF - c.Assert(clientConn.WriteBuffered[43:], check.BytesEquals, []byte{1, 0, 0, 4, mysql.EOF_HEADER}) + require.Equal(t, []byte{1, 0, 0, 4, mysql.EOF_HEADER}, clientConn.WriteBuffered[43:]) } diff --git a/server/server_test.go b/server/server_test.go index 7ddec8c8d..1756f4c55 100644 --- a/server/server_test.go +++ b/server/server_test.go @@ -11,9 +11,10 @@ import ( "time" _ "github.com/go-sql-driver/mysql" - . "github.com/pingcap/check" "github.com/pingcap/errors" "github.com/siddontang/go-log/log" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" "github.com/go-mysql-org/go-mysql/mysql" "github.com/go-mysql-org/go-mysql/test_util" @@ -66,7 +67,7 @@ func Test(t *testing.T) { servers := prepareServerConf() //no TLS for _, svr := range servers { - Suite(&serverTestSuite{ + suite.Run(t, &serverTestSuite{ server: svr, credProvider: inMemProvider, tlsPara: "false", @@ -76,18 +77,17 @@ func Test(t *testing.T) { // TLS if server supports for _, svr := range servers { if svr.tlsConfig != nil { - Suite(&serverTestSuite{ + suite.Run(t, &serverTestSuite{ server: svr, credProvider: inMemProvider, tlsPara: "skip-verify", }) } } - - TestingT(t) } type serverTestSuite struct { + suite.Suite server *Server credProvider CredentialProvider @@ -98,25 +98,25 @@ type serverTestSuite struct { l net.Listener } -func (s *serverTestSuite) SetupSuite(c *C) { +func (s *serverTestSuite) SetupSuite() { addr := fmt.Sprintf("%s:%s", *test_util.MysqlFakeHost, *test_util.MysqlFakePort) var err error s.l, err = net.Listen("tcp", addr) - c.Assert(err, IsNil) + require.NoError(s.T(), err) - go s.onAccept(c) + go s.onAccept() time.Sleep(20 * time.Millisecond) s.db, err = sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=%s", *testUser, *testPassword, addr, *testDB, s.tlsPara)) - c.Assert(err, IsNil) + require.NoError(s.T(), err) s.db.SetMaxIdleConns(4) } -func (s *serverTestSuite) TearDownSuite(c *C) { +func (s *serverTestSuite) TearDownSuite() { if s.db != nil { s.db.Close() } @@ -126,21 +126,21 @@ func (s *serverTestSuite) TearDownSuite(c *C) { } } -func (s *serverTestSuite) onAccept(c *C) { +func (s *serverTestSuite) onAccept() { for { conn, err := s.l.Accept() if err != nil { return } - go s.onConn(conn, c) + go s.onConn(conn) } } -func (s *serverTestSuite) onConn(conn net.Conn, c *C) { +func (s *serverTestSuite) onConn(conn net.Conn) { //co, err := NewConn(conn, *testUser, *testPassword, &testHandler{s}) co, err := NewCustomizedConn(conn, s.server, s.credProvider, &testHandler{s}) - c.Assert(err, IsNil) + require.NoError(s.T(), err) // set SSL if defined for { err = co.HandleCommand() @@ -150,68 +150,68 @@ func (s *serverTestSuite) onConn(conn net.Conn, c *C) { } } -func (s *serverTestSuite) TestSelect(c *C) { +func (s *serverTestSuite) TestSelect() { var a int64 var b string err := s.db.QueryRow("SELECT a, b FROM tbl WHERE id=1").Scan(&a, &b) - c.Assert(err, IsNil) - c.Assert(a, Equals, int64(1)) - c.Assert(b, Equals, "hello world") + require.NoError(s.T(), err) + require.Equal(s.T(), int64(1), a) + require.Equal(s.T(), "hello world", b) } -func (s *serverTestSuite) TestExec(c *C) { +func (s *serverTestSuite) TestExec() { r, err := s.db.Exec("INSERT INTO tbl (a, b) values (1, \"hello world\")") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ := r.LastInsertId() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("REPLACE INTO tbl (a, b) values (1, \"hello world\")") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("UPDATE tbl SET b = \"abc\" where a = 1") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("DELETE FROM tbl where a = 1") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) } -func (s *serverTestSuite) TestStmtSelect(c *C) { +func (s *serverTestSuite) TestStmtSelect() { var a int64 var b string err := s.db.QueryRow("SELECT a, b FROM tbl WHERE id=?", 1).Scan(&a, &b) - c.Assert(err, IsNil) - c.Assert(a, Equals, int64(1)) - c.Assert(b, Equals, "hello world") + require.NoError(s.T(), err) + require.Equal(s.T(), int64(1), a) + require.Equal(s.T(), "hello world", b) } -func (s *serverTestSuite) TestStmtExec(c *C) { +func (s *serverTestSuite) TestStmtExec() { r, err := s.db.Exec("INSERT INTO tbl (a, b) values (?, ?)", 1, "hello world") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ := r.LastInsertId() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("REPLACE INTO tbl (a, b) values (?, ?)", 1, "hello world") - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("UPDATE tbl SET b = \"abc\" where a = ?", 1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) r, err = s.db.Exec("DELETE FROM tbl where a = ?", 1) - c.Assert(err, IsNil) + require.NoError(s.T(), err) i, _ = r.RowsAffected() - c.Assert(i, Equals, int64(1)) + require.Equal(s.T(), int64(1), i) } type testHandler struct { diff --git a/utils/utils_test.go b/utils/utils_test.go index 3e67760c0..c8c0bf461 100644 --- a/utils/utils_test.go +++ b/utils/utils_test.go @@ -2,7 +2,5 @@ package utils // Will register common flags import ( - _ "github.com/pingcap/check" - _ "github.com/go-mysql-org/go-mysql/test_util" ) From 8cebfbeea1cfded8fa55b514268df4d200a5c4ba Mon Sep 17 00:00:00 2001 From: lance6716 Date: Fri, 23 Jun 2023 21:33:35 +0800 Subject: [PATCH 06/11] change more files Signed-off-by: lance6716 --- mysql/mysql_test.go | 239 +++++++++++++++++++----------------------- schema/schema_test.go | 2 +- server/resp_test.go | 8 +- 3 files changed, 115 insertions(+), 134 deletions(-) diff --git a/mysql/mysql_test.go b/mysql/mysql_test.go index 8206fe66f..c8f16c19f 100644 --- a/mysql/mysql_test.go +++ b/mysql/mysql_test.go @@ -6,143 +6,126 @@ import ( "testing" "github.com/google/uuid" - "github.com/pingcap/check" + "github.com/stretchr/testify/require" _ "github.com/go-mysql-org/go-mysql/test_util" // Will register common flags ) -func Test(t *testing.T) { - check.TestingT(t) -} - -type mysqlTestSuite struct { -} - -var _ = check.Suite(&mysqlTestSuite{}) - -func (t *mysqlTestSuite) SetupSuite(c *check.C) { - -} - -func (t *mysqlTestSuite) TearDownSuite(c *check.C) { - -} - -func (t *mysqlTestSuite) TestMysqlGTIDInterval(c *check.C) { +func TestMysqlGTIDInterval(t *testing.T) { i, err := parseInterval("1-2") - c.Assert(err, check.IsNil) - c.Assert(i, check.DeepEquals, Interval{1, 3}) + require.NoError(t, err) + require.Equal(t, Interval{1, 3}, i) i, err = parseInterval("1") - c.Assert(err, check.IsNil) - c.Assert(i, check.DeepEquals, Interval{1, 2}) + require.NoError(t, err) + require.Equal(t, Interval{1, 2}, i) i, err = parseInterval("1-1") - c.Assert(err, check.IsNil) - c.Assert(i, check.DeepEquals, Interval{1, 2}) + require.NoError(t, err) + require.Equal(t, Interval{1, 2}, i) } -func (t *mysqlTestSuite) TestMysqlGTIDIntervalSlice(c *check.C) { +func TestMysqlGTIDIntervalSlice(t *testing.T) { i := IntervalSlice{Interval{1, 2}, Interval{2, 4}, Interval{2, 3}} i.Sort() - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{1, 2}, Interval{2, 3}, Interval{2, 4}}) + require.Equal(t, IntervalSlice{Interval{1, 2}, Interval{2, 3}, Interval{2, 4}}, i) n := i.Normalize() - c.Assert(n, check.DeepEquals, IntervalSlice{Interval{1, 4}}) + require.Equal(t, IntervalSlice{Interval{1, 4}}, n) i = IntervalSlice{Interval{1, 2}, Interval{3, 5}, Interval{1, 3}} i.Sort() - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{1, 2}, Interval{1, 3}, Interval{3, 5}}) + require.Equal(t, IntervalSlice{Interval{1, 2}, Interval{1, 3}, Interval{3, 5}}, i) n = i.Normalize() - c.Assert(n, check.DeepEquals, IntervalSlice{Interval{1, 5}}) + require.Equal(t, IntervalSlice{Interval{1, 5}}, n) i = IntervalSlice{Interval{1, 2}, Interval{4, 5}, Interval{1, 3}} i.Sort() - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{1, 2}, Interval{1, 3}, Interval{4, 5}}) + require.Equal(t, IntervalSlice{Interval{1, 2}, Interval{1, 3}, Interval{4, 5}}, i) n = i.Normalize() - c.Assert(n, check.DeepEquals, IntervalSlice{Interval{1, 3}, Interval{4, 5}}) + require.Equal(t, IntervalSlice{Interval{1, 3}, Interval{4, 5}}, n) i = IntervalSlice{Interval{1, 4}, Interval{2, 3}} i.Sort() - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{1, 4}, Interval{2, 3}}) + require.Equal(t, IntervalSlice{Interval{1, 4}, Interval{2, 3}}, i) n = i.Normalize() - c.Assert(n, check.DeepEquals, IntervalSlice{Interval{1, 4}}) + require.Equal(t, IntervalSlice{Interval{1, 4}}, n) n1 := IntervalSlice{Interval{1, 3}, Interval{4, 5}} n2 := IntervalSlice{Interval{1, 2}} - c.Assert(n1.Contain(n2), check.Equals, true) - c.Assert(n2.Contain(n1), check.Equals, false) + require.True(t, n1.Contain(n2)) + require.False(t, n2.Contain(n1)) n1 = IntervalSlice{Interval{1, 3}, Interval{4, 5}} n2 = IntervalSlice{Interval{1, 6}} - c.Assert(n1.Contain(n2), check.Equals, false) - c.Assert(n2.Contain(n1), check.Equals, true) + require.False(t, n1.Contain(n2)) + require.True(t, n2.Contain(n1)) } -func (t *mysqlTestSuite) TestMysqlGTIDInsertInterval(c *check.C) { +func TestMysqlGTIDInsertInterval(t *testing.T) { i := IntervalSlice{Interval{100, 200}} i.InsertInterval(Interval{300, 400}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{100, 200}, Interval{300, 400}}) + require.Equal(t, IntervalSlice{Interval{100, 200}, Interval{300, 400}}, i) i.InsertInterval(Interval{50, 70}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 70}, Interval{100, 200}, Interval{300, 400}}) + require.Equal(t, IntervalSlice{Interval{50, 70}, Interval{100, 200}, Interval{300, 400}}, i) i.InsertInterval(Interval{101, 201}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 70}, Interval{100, 201}, Interval{300, 400}}) + require.Equal(t, IntervalSlice{Interval{50, 70}, Interval{100, 201}, Interval{300, 400}}, i) i.InsertInterval(Interval{99, 202}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 70}, Interval{99, 202}, Interval{300, 400}}) + require.Equal(t, IntervalSlice{Interval{50, 70}, Interval{99, 202}, Interval{300, 400}}, i) i.InsertInterval(Interval{102, 302}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 70}, Interval{99, 400}}) + require.Equal(t, IntervalSlice{Interval{50, 70}, Interval{99, 400}}, i) i.InsertInterval(Interval{500, 600}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 70}, Interval{99, 400}, Interval{500, 600}}) + require.Equal(t, IntervalSlice{Interval{50, 70}, Interval{99, 400}, Interval{500, 600}}, i) i.InsertInterval(Interval{50, 100}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 400}, Interval{500, 600}}) + require.Equal(t, IntervalSlice{Interval{50, 400}, Interval{500, 600}}, i) i.InsertInterval(Interval{900, 1000}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 400}, Interval{500, 600}, Interval{900, 1000}}) + require.Equal(t, IntervalSlice{Interval{50, 400}, Interval{500, 600}, Interval{900, 1000}}, i) i.InsertInterval(Interval{1010, 1020}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{50, 400}, Interval{500, 600}, Interval{900, 1000}, Interval{1010, 1020}}) + require.Equal(t, IntervalSlice{Interval{50, 400}, Interval{500, 600}, Interval{900, 1000}, Interval{1010, 1020}}, i) i.InsertInterval(Interval{49, 1000}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{49, 1000}, Interval{1010, 1020}}) + require.Equal(t, IntervalSlice{Interval{49, 1000}, Interval{1010, 1020}}, i) i.InsertInterval(Interval{1, 1012}) - c.Assert(i, check.DeepEquals, IntervalSlice{Interval{1, 1020}}) + require.Equal(t, IntervalSlice{Interval{1, 1020}}, i) } -func (t *mysqlTestSuite) TestMysqlGTIDCodec(c *check.C) { +func TestMysqlGTIDCodec(t *testing.T) { us, err := ParseUUIDSet("de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2") - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(us.String(), check.Equals, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2") + require.Equal(t, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2", us.String()) buf := us.Encode() err = us.Decode(buf) - c.Assert(err, check.IsNil) + require.NoError(t, err) gs, err := ParseMysqlGTIDSet("de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2,de278ad0-2106-11e4-9f8e-6edd0ca20948:1-2") - c.Assert(err, check.IsNil) + require.NoError(t, err) buf = gs.Encode() o, err := DecodeMysqlGTIDSet(buf) - c.Assert(err, check.IsNil) - c.Assert(gs, check.DeepEquals, o) + require.NoError(t, err) + require.Equal(t, gs, o) } -func (t *mysqlTestSuite) TestMysqlUpdate(c *check.C) { +func TestMysqlUpdate(t *testing.T) { g1, err := ParseMysqlGTIDSet("3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57") - c.Assert(err, check.IsNil) + require.NoError(t, err) err = g1.Update("3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58") - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(strings.ToUpper(g1.String()), check.Equals, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58") + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", g1.String()) g1, err = ParseMysqlGTIDSet(` 519CE70F-A893-11E9-A95A-B32DC65A7026:1-1154661, @@ -150,13 +133,13 @@ func (t *mysqlTestSuite) TestMysqlUpdate(c *check.C) { 802D69FD-A3B6-11E9-B1EA-50BAB55BA838:1-1221371, F2B50559-A891-11E9-B646-884FF0CA2043:1-479261 `) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = g1.Update(` 802D69FD-A3B6-11E9-B1EA-50BAB55BA838:1221110-1221371, F2B50559-A891-11E9-B646-884FF0CA2043:478509-479266 `) - c.Assert(err, check.IsNil) + require.NoError(t, err) g2, err := ParseMysqlGTIDSet(` 519CE70F-A893-11E9-A95A-B32DC65A7026:1-1154661, @@ -164,51 +147,51 @@ func (t *mysqlTestSuite) TestMysqlUpdate(c *check.C) { 802D69FD-A3B6-11E9-B1EA-50BAB55BA838:1-1221371, F2B50559-A891-11E9-B646-884FF0CA2043:1-479266 `) - c.Assert(err, check.IsNil) - c.Assert(g2.Equal(g1), check.IsTrue) + require.NoError(t, err) + require.True(t, g1.Equal(g2)) } -func (t *mysqlTestSuite) TestMysqlAddGTID(c *check.C) { +func TestMysqlAddGTID(t *testing.T) { g, err := ParseMysqlGTIDSet("3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57") - c.Assert(err, check.IsNil) + require.NoError(t, err) g1 := g.(*MysqlGTIDSet) u, err := uuid.Parse("3E11FA47-71CA-11E1-9E33-C80AA9429562") - c.Assert(err, check.IsNil) + require.NoError(t, err) g1.AddGTID(u, 58) - c.Assert(strings.ToUpper(g1.String()), check.Equals, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58") + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", g1.String()) g1.AddGTID(u, 60) - c.Assert(strings.ToUpper(g1.String()), check.Equals, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58:60") + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58:60", g1.String()) g1.AddGTID(u, 59) - c.Assert(strings.ToUpper(g1.String()), check.Equals, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-60") + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-60", g1.String()) u2, err := uuid.Parse("519CE70F-A893-11E9-A95A-B32DC65A7026") - c.Assert(err, check.IsNil) + require.NoError(t, err) g1.AddGTID(u2, 58) g2, err := ParseMysqlGTIDSet(` 3E11FA47-71CA-11E1-9E33-C80AA9429562:21-60, 519CE70F-A893-11E9-A95A-B32DC65A7026:58 `) - c.Assert(err, check.IsNil) - c.Assert(g2.Equal(g1), check.IsTrue) + require.NoError(t, err) + require.True(t, g2.Equal(g1)) } -func (t *mysqlTestSuite) TestMysqlGTIDContain(c *check.C) { +func TestMysqlGTIDContain(t *testing.T) { g1, err := ParseMysqlGTIDSet("3E11FA47-71CA-11E1-9E33-C80AA9429562:23") - c.Assert(err, check.IsNil) + require.NoError(t, err) g2, err := ParseMysqlGTIDSet("3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57") - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(g2.Contain(g1), check.Equals, true) - c.Assert(g1.Contain(g2), check.Equals, false) + require.True(t, g2.Contain(g1)) + require.False(t, g1.Contain(g2)) } -func (t *mysqlTestSuite) TestMysqlGTIDAdd(c *check.C) { +func TestMysqlGTIDAdd(t *testing.T) { testCases := []struct { left, right, expected string }{ @@ -221,18 +204,17 @@ func (t *mysqlTestSuite) TestMysqlGTIDAdd(c *check.C) { } for _, tc := range testCases { - m1 := t.mysqlGTIDfromString(c, tc.left) - m2 := t.mysqlGTIDfromString(c, tc.right) + m1 := mysqlGTIDfromString(t, tc.left) + m2 := mysqlGTIDfromString(t, tc.right) err := m1.Add(m2) - c.Assert(err, check.IsNil) - c.Assert( - fmt.Sprintf("%s + %s = %s", tc.left, tc.right, strings.ToUpper(m1.String())), - check.Equals, - fmt.Sprintf("%s + %s = %s", tc.left, tc.right, tc.expected)) + require.NoError(t, err) + one := fmt.Sprintf("%s + %s = %s", tc.left, tc.right, strings.ToUpper(m1.String())) + other := fmt.Sprintf("%s + %s = %s", tc.left, tc.right, tc.expected) + require.Equal(t, other, one) } } -func (t *mysqlTestSuite) TestMysqlGTIDMinus(c *check.C) { +func TestMysqlGTIDMinus(t *testing.T) { testCases := []struct { left, right, expected string }{ @@ -251,68 +233,67 @@ func (t *mysqlTestSuite) TestMysqlGTIDMinus(c *check.C) { } for _, tc := range testCases { - m1 := t.mysqlGTIDfromString(c, tc.left) - m2 := t.mysqlGTIDfromString(c, tc.right) + m1 := mysqlGTIDfromString(t, tc.left) + m2 := mysqlGTIDfromString(t, tc.right) err := m1.Minus(m2) - c.Assert(err, check.IsNil) - c.Assert( - fmt.Sprintf("%s - %s = %s", tc.left, tc.right, strings.ToUpper(m1.String())), - check.Equals, - fmt.Sprintf("%s - %s = %s", tc.left, tc.right, tc.expected)) + require.NoError(t, err) + one := fmt.Sprintf("%s - %s = %s", tc.left, tc.right, strings.ToUpper(m1.String())) + other := fmt.Sprintf("%s - %s = %s", tc.left, tc.right, tc.expected) + require.Equal(t, other, one) } } -func (t *mysqlTestSuite) TestMysqlParseBinaryInt8(c *check.C) { +func TestMysqlParseBinaryInt8(t *testing.T) { i8 := ParseBinaryInt8([]byte{128}) - c.Assert(i8, check.Equals, int8(-128)) + require.Equal(t, int8(-128), i8) } -func (t *mysqlTestSuite) TestMysqlParseBinaryUint8(c *check.C) { +func TestMysqlParseBinaryUint8(t *testing.T) { u8 := ParseBinaryUint8([]byte{128}) - c.Assert(u8, check.Equals, uint8(128)) + require.Equal(t, uint8(128), u8) } -func (t *mysqlTestSuite) TestMysqlParseBinaryInt16(c *check.C) { +func TestMysqlParseBinaryInt16(t *testing.T) { i16 := ParseBinaryInt16([]byte{1, 128}) - c.Assert(i16, check.Equals, int16(-128*256+1)) + require.Equal(t, int16(-128*256+1), i16) } -func (t *mysqlTestSuite) TestMysqlParseBinaryUint16(c *check.C) { +func TestMysqlParseBinaryUint16(t *testing.T) { u16 := ParseBinaryUint16([]byte{1, 128}) - c.Assert(u16, check.Equals, uint16(128*256+1)) + require.Equal(t, uint16(128*256+1), u16) } -func (t *mysqlTestSuite) TestMysqlParseBinaryInt24(c *check.C) { +func TestMysqlParseBinaryInt24(t *testing.T) { i32 := ParseBinaryInt24([]byte{1, 2, 128}) - c.Assert(i32, check.Equals, int32(-128*65536+2*256+1)) + require.Equal(t, int32(-128*65536+2*256+1), i32) } -func (t *mysqlTestSuite) TestMysqlParseBinaryUint24(c *check.C) { +func TestMysqlParseBinaryUint24(t *testing.T) { u32 := ParseBinaryUint24([]byte{1, 2, 128}) - c.Assert(u32, check.Equals, uint32(128*65536+2*256+1)) + require.Equal(t, uint32(128*65536+2*256+1), u32) } -func (t *mysqlTestSuite) TestMysqlParseBinaryInt32(c *check.C) { +func TestMysqlParseBinaryInt32(t *testing.T) { i32 := ParseBinaryInt32([]byte{1, 2, 3, 128}) - c.Assert(i32, check.Equals, int32(-128*16777216+3*65536+2*256+1)) + require.Equal(t, int32(-128*16777216+3*65536+2*256+1), i32) } -func (t *mysqlTestSuite) TestMysqlParseBinaryUint32(c *check.C) { +func TestMysqlParseBinaryUint32(t *testing.T) { u32 := ParseBinaryUint32([]byte{1, 2, 3, 128}) - c.Assert(u32, check.Equals, uint32(128*16777216+3*65536+2*256+1)) + require.Equal(t, uint32(128*16777216+3*65536+2*256+1), u32) } -func (t *mysqlTestSuite) TestMysqlParseBinaryInt64(c *check.C) { +func TestMysqlParseBinaryInt64(t *testing.T) { i64 := ParseBinaryInt64([]byte{1, 2, 3, 4, 5, 6, 7, 128}) - c.Assert(i64, check.Equals, -128*int64(72057594037927936)+7*int64(281474976710656)+6*int64(1099511627776)+5*int64(4294967296)+4*16777216+3*65536+2*256+1) + require.Equal(t, -128*int64(72057594037927936)+7*int64(281474976710656)+6*int64(1099511627776)+5*int64(4294967296)+4*16777216+3*65536+2*256+1, i64) } -func (t *mysqlTestSuite) TestMysqlParseBinaryUint64(c *check.C) { +func TestMysqlParseBinaryUint64(t *testing.T) { u64 := ParseBinaryUint64([]byte{1, 2, 3, 4, 5, 6, 7, 128}) - c.Assert(u64, check.Equals, 128*uint64(72057594037927936)+7*uint64(281474976710656)+6*uint64(1099511627776)+5*uint64(4294967296)+4*16777216+3*65536+2*256+1) + require.Equal(t, 128*uint64(72057594037927936)+7*uint64(281474976710656)+6*uint64(1099511627776)+5*uint64(4294967296)+4*16777216+3*65536+2*256+1, u64) } -func (t *mysqlTestSuite) TestErrorCode(c *check.C) { +func TestErrorCode(t *testing.T) { tbls := []struct { msg string code int @@ -324,35 +305,35 @@ func (t *mysqlTestSuite) TestErrorCode(c *check.C) { {"ERROR 1046 (3D000): Unknown error 1046", 1046}, } for _, v := range tbls { - c.Assert(ErrorCode(v.msg), check.Equals, v.code) + require.Equal(t, v.code, ErrorCode(v.msg)) } } -func (t *mysqlTestSuite) TestMysqlNullDecode(c *check.C) { +func TestMysqlNullDecode(t *testing.T) { _, isNull, n := LengthEncodedInt([]byte{0xfb}) - c.Assert(isNull, check.IsTrue) - c.Assert(n, check.Equals, 1) + require.True(t, isNull) + require.Equal(t, 1, n) } -func (t *mysqlTestSuite) TestMysqlUUIDClone(c *check.C) { +func TestMysqlUUIDClone(t *testing.T) { us, err := ParseUUIDSet("de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2") - c.Assert(err, check.IsNil) - c.Assert(us.String(), check.Equals, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2") + require.NoError(t, err) + require.Equal(t, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2", us.String()) clone := us.Clone() - c.Assert(clone.String(), check.Equals, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2") + require.Equal(t, "de278ad0-2106-11e4-9f8e-6edd0ca20947:1-2", clone.String()) } -func (t *mysqlTestSuite) TestMysqlEmptyDecode(c *check.C) { +func TestMysqlEmptyDecode(t *testing.T) { _, isNull, n := LengthEncodedInt(nil) - c.Assert(isNull, check.IsTrue) - c.Assert(n, check.Equals, 0) + require.True(t, isNull) + require.Equal(t, 0, n) } -func (t *mysqlTestSuite) mysqlGTIDfromString(c *check.C, gtidStr string) MysqlGTIDSet { +func mysqlGTIDfromString(t *testing.T, gtidStr string) MysqlGTIDSet { gtid, err := ParseMysqlGTIDSet(gtidStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) return *gtid.(*MysqlGTIDSet) } diff --git a/schema/schema_test.go b/schema/schema_test.go index 799c532c5..46c095076 100644 --- a/schema/schema_test.go +++ b/schema/schema_test.go @@ -105,7 +105,7 @@ func (s *schemaTestSuite) TestSchema() { require.True(s.T(), ta.Columns[9].IsUnsigned) require.Contains(s.T(), ta.Columns[10].Collation, "ucs2") require.Equal(s.T(), uint(256), ta.Columns[10].MaxSize) - require.Equal(s.T(), uint(0), ta.Columns[10].MaxSize) + require.Equal(s.T(), uint(0), ta.Columns[10].FixedSize) require.Contains(s.T(), ta.Columns[11].Collation, "utf8") require.Equal(s.T(), TYPE_STRING, ta.Columns[12].Type) require.Equal(s.T(), uint(10), ta.Columns[12].MaxSize) diff --git a/server/resp_test.go b/server/resp_test.go index 1abb32c8f..3608c60c3 100644 --- a/server/resp_test.go +++ b/server/resp_test.go @@ -49,7 +49,7 @@ func TestConnWriteEOF(t *testing.T) { conn.SetStatus(mysql.SERVER_MORE_RESULTS_EXISTS) err = conn.writeEOF() require.NoError(t, err) - expected = []byte{5, 0, 0, 1, mysql.EOF_HEADER, 0, 8, 0, 0} + expected = []byte{5, 0, 0, 1, mysql.EOF_HEADER, 0, 0, 8, 0} require.Equal(t, expected, clientConn.WriteBuffered) } @@ -74,7 +74,7 @@ func TestConnWriteError(t *testing.T) { // unknown error err = conn.writeError(errors.New("test")) require.NoError(t, err) - expected = []byte{13, 0, 0, 1, mysql.ERR_HEADER, 81, 4, 35, 72, 89, 48, 48, 48, 116, 101, 115, 116} + expected = []byte{13, 0, 0, 2, mysql.ERR_HEADER, 81, 4, 35, 72, 89, 48, 48, 48, 116, 101, 115, 116} require.Equal(t, expected, clientConn.WriteBuffered) } @@ -167,7 +167,7 @@ func TestConnWriteResultset(t *testing.T) { err = conn.writeResultset(r) require.NoError(t, err) // column length 1 - require.Equal(t, []byte{1, 0, 0, 0, 1}, clientConn.WriteBuffered[:5]) + require.Equal(t, []byte{1, 0, 0, 3, 1}, clientConn.WriteBuffered[:5]) // fields and EOF require.Equal(t, []byte{23, 0, 0, 4, 3, 100, 101, 102, 0, 0, 0, 1, 'a', 0, 12, 33, 0, 0, 0, 0, 0, 253, 0, 0, 0, 0, 0}, clientConn.WriteBuffered[5:32]) require.Equal(t, []byte{1, 0, 0, 5, mysql.EOF_HEADER}, clientConn.WriteBuffered[32:37]) @@ -224,7 +224,7 @@ func TestConnWriteFieldValues(t *testing.T) { require.Equal(t, []byte{2, 0, 0, 2, 1, 'd'}, clientConn.WriteBuffered[32:38]) // second row with NULL value - require.Equal(t, []byte{2, 0, 0, 3, 251}, clientConn.WriteBuffered[38:43]) + require.Equal(t, []byte{1, 0, 0, 3, 251}, clientConn.WriteBuffered[38:43]) // EOF require.Equal(t, []byte{1, 0, 0, 4, mysql.EOF_HEADER}, clientConn.WriteBuffered[43:]) From 1aba27feb4b0ff2c20023298aa9e32b24634e1b1 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Fri, 23 Jun 2023 21:50:32 +0800 Subject: [PATCH 07/11] only one file left Signed-off-by: lance6716 --- mysql/mariadb_gtid_test.go | 113 +++++++++++++++++-------------------- mysql/mysql_test.go | 8 +-- 2 files changed, 55 insertions(+), 66 deletions(-) diff --git a/mysql/mariadb_gtid_test.go b/mysql/mariadb_gtid_test.go index 1eab1567c..989c95949 100644 --- a/mysql/mariadb_gtid_test.go +++ b/mysql/mariadb_gtid_test.go @@ -1,23 +1,12 @@ package mysql import ( - "github.com/pingcap/check" -) - -type mariaDBTestSuite struct { -} - -var _ = check.Suite(&mariaDBTestSuite{}) - -func (t *mariaDBTestSuite) SetupSuite(c *check.C) { + "testing" -} - -func (t *mariaDBTestSuite) TearDownSuite(c *check.C) { - -} + "github.com/stretchr/testify/require" +) -func (t *mariaDBTestSuite) TestParseMariaDBGTID(c *check.C) { +func TestParseMariaDBGTID(t *testing.T) { cases := []struct { gtidStr string hashError bool @@ -32,15 +21,15 @@ func (t *mariaDBTestSuite) TestParseMariaDBGTID(c *check.C) { for _, cs := range cases { gtid, err := ParseMariadbGTID(cs.gtidStr) if cs.hashError { - c.Assert(err, check.NotNil) + require.Error(t, err) } else { - c.Assert(err, check.IsNil) - c.Assert(gtid.String(), check.Equals, cs.gtidStr) + require.NoError(t, err) + require.Equal(t, cs.gtidStr, gtid.String()) } } } -func (t *mariaDBTestSuite) TestMariaDBGTIDConatin(c *check.C) { +func TestMariaDBGTIDConatin(t *testing.T) { cases := []struct { originGTIDStr, otherGTIDStr string contain bool @@ -54,23 +43,23 @@ func (t *mariaDBTestSuite) TestMariaDBGTIDConatin(c *check.C) { for _, cs := range cases { originGTID, err := ParseMariadbGTID(cs.originGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) otherGTID, err := ParseMariadbGTID(cs.otherGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(originGTID.Contain(otherGTID), check.Equals, cs.contain) + require.Equal(t, cs.contain, originGTID.Contain(otherGTID)) } } -func (t *mariaDBTestSuite) TestMariaDBGTIDClone(c *check.C) { +func TestMariaDBGTIDClone(t *testing.T) { gtid, err := ParseMariadbGTID("1-1-1") - c.Assert(err, check.IsNil) + require.NoError(t, err) clone := gtid.Clone() - c.Assert(gtid, check.DeepEquals, clone) + require.Equal(t, gtid, clone) } -func (t *mariaDBTestSuite) TestMariaDBForward(c *check.C) { +func TestMariaDBForward(t *testing.T) { cases := []struct { currentGTIDStr, newerGTIDStr string hashError bool @@ -84,22 +73,22 @@ func (t *mariaDBTestSuite) TestMariaDBForward(c *check.C) { for _, cs := range cases { currentGTID, err := ParseMariadbGTID(cs.currentGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) newerGTID, err := ParseMariadbGTID(cs.newerGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) err = currentGTID.forward(newerGTID) if cs.hashError { - c.Assert(err, check.NotNil) - c.Assert(currentGTID.String(), check.Equals, cs.currentGTIDStr) + require.Error(t, err) + require.Equal(t, cs.currentGTIDStr, currentGTID.String()) } else { - c.Assert(err, check.IsNil) - c.Assert(currentGTID.String(), check.Equals, cs.newerGTIDStr) + require.NoError(t, err) + require.Equal(t, cs.newerGTIDStr, currentGTID.String()) } } } -func (t *mariaDBTestSuite) TestParseMariaDBGTIDSet(c *check.C) { +func TestParseMariaDBGTIDSet(t *testing.T) { cases := []struct { gtidStr string subGTIDs map[uint32]string //domain ID => gtid string @@ -115,17 +104,17 @@ func (t *mariaDBTestSuite) TestParseMariaDBGTIDSet(c *check.C) { for _, cs := range cases { gtidSet, err := ParseMariadbGTIDSet(cs.gtidStr) if cs.hasError { - c.Assert(err, check.NotNil) + require.Error(t, err) } else { - c.Assert(err, check.IsNil) + require.NoError(t, err) mariadbGTIDSet, ok := gtidSet.(*MariadbGTIDSet) - c.Assert(ok, check.IsTrue) + require.True(t, ok) // check sub gtid - c.Assert(mariadbGTIDSet.Sets, check.HasLen, len(cs.subGTIDs)) + require.Len(t, mariadbGTIDSet.Sets, len(cs.subGTIDs)) for domainID, gtid := range mariadbGTIDSet.Sets { - c.Assert(mariadbGTIDSet.Sets, check.HasKey, domainID) - c.Assert(gtid.String(), check.Equals, cs.subGTIDs[domainID]) + require.Contains(t, mariadbGTIDSet.Sets, domainID) + require.Equal(t, cs.subGTIDs[domainID], gtid.String()) } // check String() function @@ -137,12 +126,12 @@ func (t *mariaDBTestSuite) TestParseMariaDBGTIDSet(c *check.C) { break } } - c.Assert(inExpectedResult, check.IsTrue) + require.True(t, inExpectedResult) } } } -func (t *mariaDBTestSuite) TestMariaDBGTIDSetUpdate(c *check.C) { +func TestMariaDBGTIDSetUpdate(t *testing.T) { cases := []struct { isNilGTID bool gtidStr string @@ -157,26 +146,26 @@ func (t *mariaDBTestSuite) TestMariaDBGTIDSetUpdate(c *check.C) { for _, cs := range cases { gtidSet, err := ParseMariadbGTIDSet("1-1-1,2-2-2") - c.Assert(err, check.IsNil) + require.NoError(t, err) mariadbGTIDSet, ok := gtidSet.(*MariadbGTIDSet) - c.Assert(ok, check.IsTrue) + require.True(t, ok) if cs.isNilGTID { - c.Assert(mariadbGTIDSet.AddSet(nil), check.IsNil) + require.NoError(t, mariadbGTIDSet.AddSet(nil)) } else { err := gtidSet.Update(cs.gtidStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) } // check sub gtid - c.Assert(mariadbGTIDSet.Sets, check.HasLen, len(cs.subGTIDs)) + require.Len(t, mariadbGTIDSet.Sets, len(cs.subGTIDs)) for domainID, gtid := range mariadbGTIDSet.Sets { - c.Assert(mariadbGTIDSet.Sets, check.HasKey, domainID) - c.Assert(gtid.String(), check.Equals, cs.subGTIDs[domainID]) + require.Contains(t, mariadbGTIDSet.Sets, domainID) + require.Equal(t, cs.subGTIDs[domainID], gtid.String()) } } } -func (t *mariaDBTestSuite) TestMariaDBGTIDSetEqual(c *check.C) { +func TestMariaDBGTIDSetEqual(t *testing.T) { cases := []struct { originGTIDStr, otherGTIDStr string equals bool @@ -190,16 +179,16 @@ func (t *mariaDBTestSuite) TestMariaDBGTIDSetEqual(c *check.C) { for _, cs := range cases { originGTID, err := ParseMariadbGTIDSet(cs.originGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) otherGTID, err := ParseMariadbGTIDSet(cs.otherGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(originGTID.Equal(otherGTID), check.Equals, cs.equals) + require.Equal(t, cs.equals, originGTID.Equal(otherGTID)) } } -func (t *mariaDBTestSuite) TestMariaDBGTIDSetContain(c *check.C) { +func TestMariaDBGTIDSetContain(t *testing.T) { cases := []struct { originGTIDStr, otherGTIDStr string contain bool @@ -214,33 +203,33 @@ func (t *mariaDBTestSuite) TestMariaDBGTIDSetContain(c *check.C) { for _, cs := range cases { originGTIDSet, err := ParseMariadbGTIDSet(cs.originGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) otherGTIDSet, err := ParseMariadbGTIDSet(cs.otherGTIDStr) - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(originGTIDSet.Contain(otherGTIDSet), check.Equals, cs.contain) + require.Equal(t, cs.contain, originGTIDSet.Contain(otherGTIDSet)) } } -func (t *mariaDBTestSuite) TestMariaDBGTIDSetClone(c *check.C) { +func TestMariaDBGTIDSetClone(t *testing.T) { cases := []string{"", "1-1-1", "1-1-1,2-2-2"} for _, str := range cases { gtidSet, err := ParseMariadbGTIDSet(str) - c.Assert(err, check.IsNil) + require.NoError(t, err) - c.Assert(gtidSet.Clone(), check.DeepEquals, gtidSet) + require.Equal(t, gtidSet, gtidSet.Clone()) } } -func (t *mariaDBTestSuite) TestMariaDBGTIDSetSortedString(c *check.C) { +func TestMariaDBGTIDSetSortedString(t *testing.T) { cases := [][]string{{"", ""}, {"1-1-1", "1-1-1"}, {"2-2-2,1-1-1,3-2-1", "1-1-1,2-2-2,3-2-1"}} for _, strs := range cases { gtidSet, err := ParseMariadbGTIDSet(strs[0]) - c.Assert(err, check.IsNil) - c.Assert(gtidSet.String(), check.Equals, strs[1]) + require.NoError(t, err) + require.Equal(t, strs[1], gtidSet.String()) } } diff --git a/mysql/mysql_test.go b/mysql/mysql_test.go index c8f16c19f..bf605e162 100644 --- a/mysql/mysql_test.go +++ b/mysql/mysql_test.go @@ -125,7 +125,7 @@ func TestMysqlUpdate(t *testing.T) { err = g1.Update("3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58") require.NoError(t, err) - require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", g1.String()) + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", strings.ToUpper(g1.String())) g1, err = ParseMysqlGTIDSet(` 519CE70F-A893-11E9-A95A-B32DC65A7026:1-1154661, @@ -161,13 +161,13 @@ func TestMysqlAddGTID(t *testing.T) { require.NoError(t, err) g1.AddGTID(u, 58) - require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", g1.String()) + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58", strings.ToUpper(g1.String())) g1.AddGTID(u, 60) - require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58:60", g1.String()) + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-58:60", strings.ToUpper(g1.String())) g1.AddGTID(u, 59) - require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-60", g1.String()) + require.Equal(t, "3E11FA47-71CA-11E1-9E33-C80AA9429562:21-60", strings.ToUpper(g1.String())) u2, err := uuid.Parse("519CE70F-A893-11E9-A95A-B32DC65A7026") require.NoError(t, err) From 466a5f5e7c21301ccaae35b26e2506b131823f22 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Fri, 23 Jun 2023 22:27:21 +0800 Subject: [PATCH 08/11] finish Signed-off-by: lance6716 --- go.mod | 1 - go.sum | 2 - replication/row_event_test.go | 267 +++++++++++++++------------------- 3 files changed, 121 insertions(+), 149 deletions(-) diff --git a/go.mod b/go.mod index 5021642f4..e8aee825b 100644 --- a/go.mod +++ b/go.mod @@ -9,7 +9,6 @@ require ( github.com/google/uuid v1.3.0 github.com/jmoiron/sqlx v1.3.3 github.com/klauspost/compress v1.16.6 - github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8 github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63 github.com/pingcap/tidb/parser v0.0.0-20221126021158-6b02a5d8ba7d github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24 diff --git a/go.sum b/go.sum index d5f27b2d5..7590a4989 100644 --- a/go.sum +++ b/go.sum @@ -28,8 +28,6 @@ github.com/lib/pq v1.2.0 h1:LXpIM/LZ5xGFhOpXAQUIMM1HdyqzVYM13zNdjCEEcA0= github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg= github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= -github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8 h1:USx2/E1bX46VG32FIw034Au6seQ2fY9NEILmNh/UlQg= -github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8/go.mod h1:B1+S9LNcuMyLH/4HMTViQOJevkGiik3wW2AN9zb2fNQ= github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63 h1:+FZIDR/D97YOPik4N4lPDaUcLDF/EQPogxtlHB2ZZRM= github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63/go.mod h1:X2r9ueLEUZgtx2cIogM0v4Zj5uvvzhuuiu7Pn8HzMPg= diff --git a/replication/row_event_test.go b/replication/row_event_test.go index 13114b464..b1d2a7da5 100644 --- a/replication/row_event_test.go +++ b/replication/row_event_test.go @@ -2,22 +2,16 @@ package replication import ( "fmt" + "testing" - . "github.com/pingcap/check" + "github.com/pingcap/errors" "github.com/shopspring/decimal" + "github.com/stretchr/testify/require" "github.com/go-mysql-org/go-mysql/mysql" ) -type testDecodeSuite struct{} - -var _ = Suite(&testDecodeSuite{}) - -type decodeDecimalChecker struct { - *CheckerInfo -} - -func (_ *decodeDecimalChecker) Check(params []interface{}, names []string) (bool, string) { +func check(params []interface{}, names []string) error { var test int val := struct { Value decimal.Decimal @@ -48,22 +42,18 @@ func (_ *decodeDecimalChecker) Check(params []interface{}, names []string) (bool } errorMsgFmt := fmt.Sprintf("For Test %v: ", test) + "Did not get expected %v(%v), got %v instead." if val.Err != val.EErr { - return false, fmt.Sprintf(errorMsgFmt, "error", val.EErr, val.Err) + return errors.Errorf(errorMsgFmt, "error", val.EErr, val.Err) } if val.Pos != val.EPos { - return false, fmt.Sprintf(errorMsgFmt, "position", val.EPos, val.Pos) + return errors.Errorf(errorMsgFmt, "position", val.EPos, val.Pos) } if !val.Value.Equal(val.EValue) { - return false, fmt.Sprintf(errorMsgFmt, "value", val.EValue, val.Value) + return errors.Errorf(errorMsgFmt, "value", val.EValue, val.Value) } - return true, "" + return nil } -var DecodeDecimalsEquals = &decodeDecimalChecker{ - &CheckerInfo{Name: "Equals", Params: []string{"obtainedValue", "obtainedPos", "obtainedErr", "expectedValue", "expectedPos", "expectedErr", "caseNumber"}}, -} - -func (_ *testDecodeSuite) TestDecodeDecimal(c *C) { +func TestDecodeDecimal(t *testing.T) { // _PLACEHOLDER_ := 0 testcases := []struct { Data []byte @@ -324,17 +314,21 @@ func (_ *testDecodeSuite) TestDecodeDecimal(c *C) { {[]byte{127, 255, 255, 248, 99, 247, 167, 196, 255, 255, 255, 255, 255, 255, 127, 248}, 30, 20, "-1948.14000000000000000000", 14, nil}, {[]byte{127, 248, 99, 247, 167, 196, 255, 255, 255, 255, 255, 255, 255, 255, 255, 13, 0}, 30, 25, "-1948.1400000000000000000000000", 15, nil}, } - for i, tc := range testcases { + for _, tc := range testcases { value, pos, err := decodeDecimal(tc.Data, tc.Precision, tc.Decimals, false) - c.Assert(value.(string), DecodeDecimalsEquals, pos, err, tc.Expected, tc.ExpectedPos, tc.ExpectedErr, i) + require.Equal(t, tc.Expected, value.(string)) + require.Equal(t, tc.ExpectedPos, pos) + require.Equal(t, tc.ExpectedErr, err) value, pos, err = decodeDecimal(tc.Data, tc.Precision, tc.Decimals, true) expectedDecimal, _ := decimal.NewFromString(tc.Expected) - c.Assert(value.(decimal.Decimal), DecodeDecimalsEquals, pos, err, expectedDecimal, tc.ExpectedPos, tc.ExpectedErr, i) + require.True(t, expectedDecimal.Equal(value.(decimal.Decimal))) + require.Equal(t, tc.ExpectedPos, pos) + require.Equal(t, tc.ExpectedErr, err) } } -func (_ *testDecodeSuite) TestLastNull(c *C) { +func TestLastNull(t *testing.T) { // Table format: // desc funnytable; // +-------+------------+------+-----+---------+-------+ @@ -352,7 +346,7 @@ func (_ *testDecodeSuite) TestLastNull(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -368,12 +362,12 @@ func (_ *testDecodeSuite) TestLastNull(c *C) { for _, tbl := range tbls { rows.Rows = nil err = rows.Decode(tbl) - c.Assert(err, IsNil) - c.Assert(rows.Rows, HasLen, 3) + require.NoError(t, err) + require.Len(t, rows.Rows, 3) } } -func (_ *testDecodeSuite) TestParseRowPanic(c *C) { +func TestParseRowPanic(t *testing.T) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 tableMapEvent.TableID = 1810 @@ -389,30 +383,11 @@ func (_ *testDecodeSuite) TestParseRowPanic(c *C) { data := []byte{18, 7, 0, 0, 0, 0, 1, 0, 2, 0, 26, 1, 1, 16, 252, 248, 142, 63, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0} err := rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][0], Equals, int32(16270)) -} - -type simpleDecimalEqualsChecker struct { - *CheckerInfo -} - -var SimpleDecimalEqualsChecker Checker = &simpleDecimalEqualsChecker{ - &CheckerInfo{Name: "Equals", Params: []string{"obtained", "expected"}}, -} - -func (checker *simpleDecimalEqualsChecker) Check(params []interface{}, names []string) (result bool, error string) { - defer func() { - if v := recover(); v != nil { - result = false - error = fmt.Sprint(v) - } - }() - - return params[0].(decimal.Decimal).Equal(params[1].(decimal.Decimal)), "" + require.NoError(t, err) + require.Equal(t, int32(16270), rows.Rows[0][0]) } -func (_ *testDecodeSuite) TestParseJson(c *C) { +func TestParseJson(t *testing.T) { // Table format: // mysql> desc t10; // +-------+---------------+------+-----+---------+-------+ @@ -437,7 +412,7 @@ func (_ *testDecodeSuite) TestParseJson(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -453,8 +428,8 @@ func (_ *testDecodeSuite) TestParseJson(c *C) { for _, tbl := range tbls { rows.Rows = nil err = rows.Decode(tbl) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], Equals, "1") + require.NoError(t, err) + require.Equal(t, "1", rows.Rows[0][1]) } //nolint:misspell @@ -465,11 +440,11 @@ func (_ *testDecodeSuite) TestParseJson(c *C) { for _, ltbl := range longTbls { rows.Rows = nil err = rows.Decode(ltbl) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], Equals, "101") + require.NoError(t, err) + require.Equal(t, "101", rows.Rows[0][1]) } } -func (_ *testDecodeSuite) TestParseJsonDecimal(c *C) { +func TestParseJsonDecimal(t *testing.T) { // Table format: // mysql> desc t10; // +-------+---------------+------+-----+---------+-------+ @@ -494,7 +469,7 @@ func (_ *testDecodeSuite) TestParseJsonDecimal(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := RowsEvent{useDecimal: true} rows.tableIDSize = 6 @@ -510,8 +485,8 @@ func (_ *testDecodeSuite) TestParseJsonDecimal(c *C) { for _, tbl := range tbls { rows.Rows = nil err = rows.Decode(tbl) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], SimpleDecimalEqualsChecker, decimal.NewFromFloat(1)) + require.NoError(t, err) + require.True(t, rows.Rows[0][1].(decimal.Decimal).Equal(decimal.NewFromFloat(1))) } //nolint:misspell @@ -522,12 +497,12 @@ func (_ *testDecodeSuite) TestParseJsonDecimal(c *C) { for _, ltbl := range longTbls { rows.Rows = nil err = rows.Decode(ltbl) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], SimpleDecimalEqualsChecker, decimal.NewFromFloat(101)) + require.NoError(t, err) + require.True(t, rows.Rows[0][1].(decimal.Decimal).Equal(decimal.NewFromFloat(101))) } } -func (_ *testDecodeSuite) TestEnum(c *C) { +func TestEnum(t *testing.T) { // mysql> desc aenum; // +-------+-------------------------------------------+------+-----+---------+-------+ // | Field | Type | Null | Key | Default | Extra | @@ -543,7 +518,7 @@ func (_ *testDecodeSuite) TestEnum(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -555,11 +530,11 @@ func (_ *testDecodeSuite) TestEnum(c *C) { rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], Equals, int64(1)) + require.NoError(t, err) + require.Equal(t, int64(1), rows.Rows[0][1]) } -func (_ *testDecodeSuite) TestMultiBytesEnum(c *C) { +func TestMultiBytesEnum(t *testing.T) { // CREATE TABLE numbers ( // id int auto_increment, // num ENUM( '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '100', '101', '102', '103', '104', '105', '106', '107', '108', '109', '110', '111', '112', '113', '114', '115', '116', '117', '118', '119', '120', '121', '122', '123', '124', '125', '126', '127', '128', '129', '130', '131', '132', '133', '134', '135', '136', '137', '138', '139', '140', '141', '142', '143', '144', '145', '146', '147', '148', '149', '150', '151', '152', '153', '154', '155', '156', '157', '158', '159', '160', '161', '162', '163', '164', '165', '166', '167', '168', '169', '170', '171', '172', '173', '174', '175', '176', '177', '178', '179', '180', '181', '182', '183', '184', '185', '186', '187', '188', '189', '190', '191', '192', '193', '194', '195', '196', '197', '198', '199', '200', '201', '202', '203', '204', '205', '206', '207', '208', '209', '210', '211', '212', '213', '214', '215', '216', '217', '218', '219', '220', '221', '222', '223', '224', '225', '226', '227', '228', '229', '230', '231', '232', '233', '234', '235', '236', '237', '238', '239', '240', '241', '242', '243', '244', '245', '246', '247', '248', '249', '250', '251', '252', '253', '254', '255','256','257' @@ -575,7 +550,7 @@ func (_ *testDecodeSuite) TestMultiBytesEnum(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -587,12 +562,12 @@ func (_ *testDecodeSuite) TestMultiBytesEnum(c *C) { rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], Equals, int64(1)) - c.Assert(rows.Rows[1][1], Equals, int64(257)) + require.NoError(t, err) + require.Equal(t, int64(1), rows.Rows[0][1]) + require.Equal(t, int64(257), rows.Rows[1][1]) } -func (_ *testDecodeSuite) TestSet(c *C) { +func TestSet(t *testing.T) { // mysql> desc aset; // +--------+---------------------------------------------------------------------------------------+------+-----+---------+-------+ // | Field | Type | Null | Key | Default | Extra | @@ -609,7 +584,7 @@ func (_ *testDecodeSuite) TestSet(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -621,11 +596,11 @@ func (_ *testDecodeSuite) TestSet(c *C) { rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][1], Equals, int64(5)) + require.NoError(t, err) + require.Equal(t, int64(5), rows.Rows[0][1]) } -func (_ *testDecodeSuite) TestJsonNull(c *C) { +func TestJsonNull(t *testing.T) { // Table: // desc hj_order_preview // +------------------+------------+------+-----+-------------------+----------------+ @@ -648,7 +623,7 @@ func (_ *testDecodeSuite) TestJsonNull(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -661,11 +636,11 @@ func (_ *testDecodeSuite) TestJsonNull(c *C) { rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][3], HasLen, 0) + require.NoError(t, err) + require.Len(t, rows.Rows[0][3], 0) } -func (_ *testDecodeSuite) TestJsonCompatibility(c *C) { +func TestJsonCompatibility(t *testing.T) { // Table: // mysql> desc t11; // +----------+--------------+------+-----+---------+-------------------+ @@ -687,7 +662,7 @@ func (_ *testDecodeSuite) TestJsonCompatibility(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tableMapEventData) - c.Assert(err, IsNil) + require.NoError(t, err) rows := new(RowsEvent) rows.tableIDSize = 6 @@ -698,44 +673,44 @@ func (_ *testDecodeSuite) TestJsonCompatibility(c *C) { data := []byte("l\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\xff\xf8\x01\x00\x00\x00\x02{}\x05\x00\x00\x00\x00\x00\x00\x04\x00") rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[0][2], DeepEquals, "{}") + require.NoError(t, err) + require.Equal(t, "{}", rows.Rows[0][2]) // after MySQL 5.7.22 data = []byte("l\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\xff\xff\xf8\x01\x00\x00\x00\x02{}\x05\x00\x00\x00\x00\x00\x00\x04\x00\xf8\x01\x00\x00\x00\n{\"a\":1234}\r\x00\x00\x00\x00\x01\x00\x0c\x00\x0b\x00\x01\x00\x05\xd2\x04a") rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[1][2], DeepEquals, "{}") - c.Assert(rows.Rows[2][2], DeepEquals, "{\"a\":1234}") + require.NoError(t, err) + require.Equal(t, "{}", rows.Rows[1][2]) + require.Equal(t, "{\"a\":1234}", rows.Rows[2][2]) data = []byte("l\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\xff\xff\xf8\x01\x00\x00\x00\n{\"a\":1234}\r\x00\x00\x00\x00\x01\x00\x0c\x00\x0b\x00\x01\x00\x05\xd2\x04a\xf8\x01\x00\x00\x00\x02{}\x05\x00\x00\x00\x00\x00\x00\x04\x00") rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[1][2], DeepEquals, "{\"a\":1234}") - c.Assert(rows.Rows[2][2], DeepEquals, "{}") + require.NoError(t, err) + require.Equal(t, "{\"a\":1234}", rows.Rows[1][2]) + require.Equal(t, "{}", rows.Rows[2][2]) // before MySQL 5.7.22 rows.ignoreJSONDecodeErr = true data = []byte("l\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\xff\xff\xf8\x01\x00\x00\x00\x02{}\x05\x00\x00\x00\x00\x01\x00\x0c\x00\xf8\x01\x00\x00\x00\n{\"a\":1234}\r\x00\x00\x00\x00\x01\x00\x0c\x00\x0b\x00\x01\x00\x05\xd2\x04a") rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) - c.Assert(rows.Rows[1][2], DeepEquals, "null") - c.Assert(rows.Rows[2][2], DeepEquals, "{\"a\":1234}") + require.NoError(t, err) + require.Equal(t, "null", rows.Rows[1][2]) + require.Equal(t, "{\"a\":1234}", rows.Rows[2][2]) rows.ignoreJSONDecodeErr = false data = []byte("l\x00\x00\x00\x00\x00\x01\x00\x02\x00\x04\xff\xff\xf8\x01\x00\x00\x00\n{\"a\":1234}\r\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x01\x00\x05\xd2\x04a\xf8\x01\x00\x00\x00\x02{}\x05\x00\x00\x00\x00\x00\x00\x04\x00") rows.Rows = nil err = rows.Decode(data) - c.Assert(err, IsNil) + require.NoError(t, err) // this value is wrong in binlog, but can be parsed without error - c.Assert(rows.Rows[1][2], DeepEquals, "{}") - c.Assert(rows.Rows[2][2], DeepEquals, "{}") + require.Equal(t, "{}", rows.Rows[1][2]) + require.Equal(t, "{}", rows.Rows[2][2]) } -func (_ *testDecodeSuite) TestDecodeDatetime2(c *C) { +func TestDecodeDatetime2(t *testing.T) { testcases := []struct { data []byte dec uint16 @@ -754,21 +729,21 @@ func (_ *testDecodeSuite) TestDecodeDatetime2(c *C) { } for _, tc := range testcases { value, _, err := decodeDatetime2(tc.data, tc.dec) - c.Assert(err, IsNil) - switch t := value.(type) { + require.NoError(t, err) + switch v := value.(type) { case fracTime: - c.Assert(tc.getFracTime, IsTrue) - c.Assert(t.String(), Equals, tc.expected) + require.True(t, tc.getFracTime) + require.Equal(t, tc.expected, v.String()) case string: - c.Assert(tc.getFracTime, IsFalse) - c.Assert(t, Equals, tc.expected) + require.False(t, tc.getFracTime) + require.Equal(t, tc.expected, v) default: - c.Errorf("invalid value type: %T", value) + require.FailNow(t, "invalid value type: %T", value) } } } -func (_ *testDecodeSuite) TestTableMapNullable(c *C) { +func TestTableMapNullable(t *testing.T) { /* create table _null (c1 int null, c2 int not null default '2', c3 timestamp default now(), c4 text); */ @@ -788,17 +763,17 @@ func (_ *testDecodeSuite) TestTableMapNullable(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tc) - c.Assert(err, IsNil) - c.Assert(int(tableMapEvent.ColumnCount), Equals, len(nullables)) + require.NoError(t, err) + require.Equal(t, int(tableMapEvent.ColumnCount), len(nullables)) for i := 0; i < int(tableMapEvent.ColumnCount); i++ { available, nullable := tableMapEvent.Nullable(i) - c.Assert(available, Equals, true) - c.Assert(nullable, Equals, nullables[i]) + require.True(t, available) + require.Equal(t, nullables[i], nullable) } } } -func (_ *testDecodeSuite) TestTableMapOptMetaNames(c *C) { +func TestTableMapOptMetaNames(t *testing.T) { /* CREATE TABLE `_types` ( `b_bit` bit(64) NOT NULL DEFAULT b'0', @@ -916,21 +891,21 @@ func (_ *testDecodeSuite) TestTableMapOptMetaNames(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tc.data) - c.Assert(err, IsNil) + require.NoError(t, err) if tc.hasNames { - c.Assert(tableMapEvent.ColumnNameString(), DeepEquals, colNames) - c.Assert(tableMapEvent.SetStrValueString(), DeepEquals, setVals) - c.Assert(tableMapEvent.EnumStrValueString(), DeepEquals, enumVals) + require.Equal(t, colNames, tableMapEvent.ColumnNameString()) + require.Equal(t, setVals, tableMapEvent.SetStrValueString()) + require.Equal(t, enumVals, tableMapEvent.EnumStrValueString()) } else { - c.Assert(tableMapEvent.ColumnNameString(), DeepEquals, []string(nil)) - c.Assert(tableMapEvent.SetStrValueString(), DeepEquals, [][]string(nil)) - c.Assert(tableMapEvent.EnumStrValueString(), DeepEquals, [][]string(nil)) + require.Equal(t, []string(nil), tableMapEvent.ColumnNameString()) + require.Equal(t, [][]string(nil), tableMapEvent.SetStrValueString()) + require.Equal(t, [][]string(nil), tableMapEvent.EnumStrValueString()) } } } -func (_ *testDecodeSuite) TestTableMapOptMetaPrimaryKey(c *C) { +func TestTableMapOptMetaPrimaryKey(t *testing.T) { /* create table _prim (id2 int, col varchar(30), id1 bigint, primary key (id1, id2)); */ @@ -1002,13 +977,13 @@ func (_ *testDecodeSuite) TestTableMapOptMetaPrimaryKey(c *C) { tableMapEvent := new(TableMapEvent) tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tc.data) - c.Assert(err, IsNil) - c.Assert(tableMapEvent.PrimaryKey, DeepEquals, tc.expectedPrimaryKey) - c.Assert(tableMapEvent.PrimaryKeyPrefix, DeepEquals, tc.expectedPrimaryKeyPrefix) + require.NoError(t, err) + require.Equal(t, tc.expectedPrimaryKey, tableMapEvent.PrimaryKey) + require.Equal(t, tc.expectedPrimaryKeyPrefix, tableMapEvent.PrimaryKeyPrefix) } } -func (_ *testDecodeSuite) TestTableMapHelperMaps(c *C) { +func TestTableMapHelperMaps(t *testing.T) { /* CREATE TABLE `_types` ( `b_bit` bit(64) NOT NULL DEFAULT b'0', @@ -1175,17 +1150,17 @@ func (_ *testDecodeSuite) TestTableMapHelperMaps(c *C) { tableMapEvent.flavor = tc.flavor tableMapEvent.tableIDSize = 6 err := tableMapEvent.Decode(tc.data) - c.Assert(err, IsNil) - c.Assert(tableMapEvent.UnsignedMap(), DeepEquals, tc.unsignedMap) - c.Assert(tableMapEvent.CollationMap(), DeepEquals, tc.collationMap) - c.Assert(tableMapEvent.EnumSetCollationMap(), DeepEquals, tc.enumSetCollationMap) - c.Assert(tableMapEvent.EnumStrValueMap(), DeepEquals, tc.enumStrValueMap) - c.Assert(tableMapEvent.SetStrValueMap(), DeepEquals, tc.setStrValueMap) - c.Assert(tableMapEvent.GeometryTypeMap(), DeepEquals, tc.geometryTypeMap) + require.NoError(t, err) + require.Equal(t, tc.unsignedMap, tableMapEvent.UnsignedMap()) + require.Equal(t, tc.collationMap, tableMapEvent.CollationMap()) + require.Equal(t, tc.enumSetCollationMap, tableMapEvent.EnumSetCollationMap()) + require.Equal(t, tc.enumStrValueMap, tableMapEvent.EnumStrValueMap()) + require.Equal(t, tc.setStrValueMap, tableMapEvent.SetStrValueMap()) + require.Equal(t, tc.geometryTypeMap, tableMapEvent.GeometryTypeMap()) } } -func (_ *testDecodeSuite) TestInvalidEvent(c *C) { +func TestInvalidEvent(t *testing.T) { data := "@\x01\x00\x00\x00\x00\x01\x00\x02\xff\xfc\x01\x00\x00\x00\x00B\x14U\x16\x8ew" table := &TableMapEvent{ tableIDSize: 6, @@ -1205,10 +1180,10 @@ func (_ *testDecodeSuite) TestInvalidEvent(c *C) { e2.tables = map[uint64]*TableMapEvent{} e2.tables[0x140] = table err := e2.Decode([]byte(data)) - c.Assert(err, NotNil) + require.NoError(t, err) } -func (_ *testDecodeSuite) TestDecodeTime2(c *C) { +func TestDecodeTime2(t *testing.T) { testcases := []struct { data []byte dec uint16 @@ -1233,8 +1208,8 @@ func (_ *testDecodeSuite) TestDecodeTime2(c *C) { } for _, tc := range testcases { value, _, err := decodeTime2(tc.data, tc.dec) - c.Assert(err, IsNil) - c.Assert(value, Equals, tc.expected) + require.NoError(t, err) + require.Equal(t, tc.expected, value) } } @@ -1310,40 +1285,40 @@ var decimalData = []decimalTest{ }, } -func (_ *testDecodeSuite) BenchmarkUseDecimal(c *C) { +func BenchmarkUseDecimal(b *testing.B) { e := &RowsEvent{useDecimal: true} - c.ResetTimer() - for i := 0; i < c.N; i++ { + b.ResetTimer() + for i := 0; i < b.N; i++ { for _, d := range decimalData { _, _, _ = e.decodeValue(d.dumpData, mysql.MYSQL_TYPE_NEWDECIMAL, d.meta, false) } } } -func (_ *testDecodeSuite) BenchmarkNotUseDecimal(c *C) { +func BenchmarkNotUseDecimal(b *testing.B) { e := &RowsEvent{useDecimal: false} - c.ResetTimer() - for i := 0; i < c.N; i++ { + b.ResetTimer() + for i := 0; i < b.N; i++ { for _, d := range decimalData { _, _, _ = e.decodeValue(d.dumpData, mysql.MYSQL_TYPE_NEWDECIMAL, d.meta, false) } } } -func (_ *testDecodeSuite) TestDecimal(c *C) { +func TestDecimal(t *testing.T) { e := &RowsEvent{useDecimal: true} e2 := &RowsEvent{useDecimal: false} for _, d := range decimalData { v, _, err := e.decodeValue(d.dumpData, mysql.MYSQL_TYPE_NEWDECIMAL, d.meta, false) - c.Assert(err, IsNil) + require.NoError(t, err) // no trailing zero dec, err := decimal.NewFromString(d.num) - c.Assert(err, IsNil) - c.Assert(dec.Equal(v.(decimal.Decimal)), IsTrue) + require.NoError(t, err) + require.True(t, dec.Equal(v.(decimal.Decimal))) v, _, err = e2.decodeValue(d.dumpData, mysql.MYSQL_TYPE_NEWDECIMAL, d.meta, false) - c.Assert(err, IsNil) - c.Assert(v.(string), Equals, d.num) + require.NoError(t, err) + require.Equal(t, d.num, v.(string)) } } @@ -1362,10 +1337,10 @@ var intData = [][]byte{ {12, 0, 0, 0}, } -func (_ *testDecodeSuite) BenchmarkInt(c *C) { +func BenchmarkInt(b *testing.B) { e := &RowsEvent{} - c.ResetTimer() - for i := 0; i < c.N; i++ { + b.ResetTimer() + for i := 0; i < b.N; i++ { for _, d := range intData { _, _, _ = e.decodeValue(d, mysql.MYSQL_TYPE_LONG, 0, false) } From af37082c42ce84b0051d59dfd7595df97c9598c2 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Fri, 23 Jun 2023 22:52:49 +0800 Subject: [PATCH 09/11] fix one wrong change Signed-off-by: lance6716 --- replication/row_event_test.go | 46 +---------------------------------- 1 file changed, 1 insertion(+), 45 deletions(-) diff --git a/replication/row_event_test.go b/replication/row_event_test.go index b1d2a7da5..8d71bf017 100644 --- a/replication/row_event_test.go +++ b/replication/row_event_test.go @@ -1,58 +1,14 @@ package replication import ( - "fmt" "testing" - "github.com/pingcap/errors" "github.com/shopspring/decimal" "github.com/stretchr/testify/require" "github.com/go-mysql-org/go-mysql/mysql" ) -func check(params []interface{}, names []string) error { - var test int - val := struct { - Value decimal.Decimal - Pos int - Err error - EValue decimal.Decimal - EPos int - EErr error - }{} - - for i, name := range names { - switch name { - case "obtainedValue": - val.Value, _ = params[i].(decimal.Decimal) - case "obtainedPos": - val.Pos, _ = params[i].(int) - case "obtainedErr": - val.Err, _ = params[i].(error) - case "expectedValue": - val.EValue, _ = params[i].(decimal.Decimal) - case "expectedPos": - val.EPos, _ = params[i].(int) - case "expectedErr": - val.EErr, _ = params[i].(error) - case "caseNumber": - test = params[i].(int) - } - } - errorMsgFmt := fmt.Sprintf("For Test %v: ", test) + "Did not get expected %v(%v), got %v instead." - if val.Err != val.EErr { - return errors.Errorf(errorMsgFmt, "error", val.EErr, val.Err) - } - if val.Pos != val.EPos { - return errors.Errorf(errorMsgFmt, "position", val.EPos, val.Pos) - } - if !val.Value.Equal(val.EValue) { - return errors.Errorf(errorMsgFmt, "value", val.EValue, val.Value) - } - return nil -} - func TestDecodeDecimal(t *testing.T) { // _PLACEHOLDER_ := 0 testcases := []struct { @@ -1180,7 +1136,7 @@ func TestInvalidEvent(t *testing.T) { e2.tables = map[uint64]*TableMapEvent{} e2.tables[0x140] = table err := e2.Decode([]byte(data)) - require.NoError(t, err) + require.Error(t, err) } func TestDecodeTime2(t *testing.T) { From c955c9809638e4f3a00812f07be2f0425c1989c7 Mon Sep 17 00:00:00 2001 From: lance6716 Date: Fri, 23 Jun 2023 23:32:00 +0800 Subject: [PATCH 10/11] don't know why a test fails Signed-off-by: lance6716 --- canal/canal_test.go | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/canal/canal_test.go b/canal/canal_test.go index ef6230eab..744058192 100644 --- a/canal/canal_test.go +++ b/canal/canal_test.go @@ -20,7 +20,7 @@ type canalTestSuite struct { c *Canal } -func TestCanal(t *testing.T) { +func TestCanalSuite(t *testing.T) { suite.Run(t, new(canalTestSuite)) } @@ -78,7 +78,7 @@ func (s *canalTestSuite) SetupSuite() { s.execute("SET GLOBAL binlog_format = 'ROW'") - s.c.SetEventHandler(&testEventHandler{t: s.T()}) + s.c.SetEventHandler(&testEventHandler{}) go func() { set, _ := mysql.ParseGTIDSet("mysql", "") err = s.c.StartFromGTID(set) @@ -105,7 +105,6 @@ func (s *canalTestSuite) execute(query string, args ...interface{}) *mysql.Resul type testEventHandler struct { DummyEventHandler - t *testing.T } func (h *testEventHandler) OnRow(e *RowsEvent) error { @@ -121,10 +120,6 @@ func (h *testEventHandler) String() string { return "testEventHandler" } -func (h *testEventHandler) OnPosSynced(header *replication.EventHeader, p mysql.Position, set mysql.GTIDSet, f bool) error { - return nil -} - func (s *canalTestSuite) TestCanal() { <-s.c.WaitDumpDone() From 7a6928aeea698929c01e41b04a4de5f73426430e Mon Sep 17 00:00:00 2001 From: lance6716 Date: Sun, 25 Jun 2023 16:46:58 +0800 Subject: [PATCH 11/11] split test group Signed-off-by: lance6716 --- .github/workflows/ci.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4c2ec0791..879da94a5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -37,7 +37,10 @@ jobs: - name: Checkout code uses: actions/checkout@v1 - name: Run tests - run: go test ./... + run: | + # separate test to avoid RESET MASTER conflict + go test $(go list ./... | grep -v canal) + go test $(go list ./... | grep canal) golangci: name: golangci