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
diff --git a/canal/canal_test.go b/canal/canal_test.go
index 80f463d2b..744058192 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 TestCanalSuite(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{})
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,14 @@ 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
}
func (h *testEventHandler) OnRow(e *RowsEvent) error {
@@ -122,45 +120,41 @@ 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(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 +164,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 +195,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 +227,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 +269,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 +311,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..85dba1e98 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(0x61), 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.Subset(t, data, fixt)
}
}
diff --git a/client/client_test.go b/client/client_test.go
index a7cc81999..7fddd9dad 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.GreaterOrEqual(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..f3c1e4fae 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..3f7575613 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..6f506c1ee 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
}
diff --git a/failover/failover_test.go b/failover/failover_test.go
index 2c6246efa..fe72305ff 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
}
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/mysql/mariadb_gtid_test.go b/mysql/mariadb_gtid_test.go
index 6d0ce22c3..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 eb27aebfd..bf605e162 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", strings.ToUpper(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", strings.ToUpper(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", strings.ToUpper(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", strings.ToUpper(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/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/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..78bddc345 100644
--- a/replication/event_test.go
+++ b/replication/event_test.go
@@ -1,34 +1,36 @@
package replication
import (
- . "github.com/pingcap/check"
+ "testing"
+
+ "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 +40,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 +65,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 +74,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 +83,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 +92,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..8b70f9e44 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.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) {
// 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/replication/row_event_test.go b/replication/row_event_test.go
index 13114b464..8d71bf017 100644
--- a/replication/row_event_test.go
+++ b/replication/row_event_test.go
@@ -1,69 +1,15 @@
package replication
import (
- "fmt"
+ "testing"
- . "github.com/pingcap/check"
"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) {
- 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 false, fmt.Sprintf(errorMsgFmt, "error", val.EErr, val.Err)
- }
- if val.Pos != val.EPos {
- return false, fmt.Sprintf(errorMsgFmt, "position", val.EPos, val.Pos)
- }
- if !val.Value.Equal(val.EValue) {
- return false, fmt.Sprintf(errorMsgFmt, "value", val.EValue, val.Value)
- }
- return true, ""
-}
-
-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 +270,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 +302,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 +318,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 +339,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 +368,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 +384,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 +396,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 +425,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 +441,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 +453,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 +474,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 +486,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 +506,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 +518,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 +540,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 +552,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 +579,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 +592,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 +618,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 +629,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 +685,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 +719,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 +847,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 +933,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 +1106,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 +1136,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.Error(t, err)
}
-func (_ *testDecodeSuite) TestDecodeTime2(c *C) {
+func TestDecodeTime2(t *testing.T) {
testcases := []struct {
data []byte
dec uint16
@@ -1233,8 +1164,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 +1241,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 +1293,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)
}
diff --git a/replication/time_test.go b/replication/time_test.go
index 3a06aaf69..84065d7c0 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 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,
}
- c.Assert(t.String(), Equals, "2018-07-30 15:00:00")
+ require.Equal(tt, "2018-07-30 15:00:00", t.String())
}
-
-var _ = Suite(&testTimeSuite{})
diff --git a/schema/schema_test.go b/schema/schema_test.go
index 5d86bffb4..46c095076 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.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)
+ 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].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)
+ 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)
}
diff --git a/server/caching_sha2_cache_test.go b/server/caching_sha2_cache_test.go
index 85b6fb67c..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..3608c60c3 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, 0, 8, 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, 2, 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, 3, 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{1, 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 e1ce748b1..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"
)