diff --git a/dm/common/common_test.go b/dm/common/common_test.go
index b9dc6f11c7..636b1ade45 100644
--- a/dm/common/common_test.go
+++ b/dm/common/common_test.go
@@ -18,18 +18,10 @@ import (
"path"
"testing"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-func TestCommon(t *testing.T) {
- check.TestingT(t)
-}
-
-type testCommon struct{}
-
-var _ = check.Suite(&testCommon{})
-
-func (t *testCommon) TestKeyAdapter(c *check.C) {
+func TestKeyAdapter(t *testing.T) {
testCases := []struct {
keys []string
adapter KeyAdapter
@@ -84,14 +76,14 @@ func (t *testCommon) TestKeyAdapter(c *check.C) {
for _, ca := range testCases {
encKey := ca.adapter.Encode(ca.keys...)
- c.Assert(encKey, check.Equals, ca.want)
+ require.Equal(t, ca.want, encKey)
decKey, err := ca.adapter.Decode(encKey)
- c.Assert(err, check.IsNil)
- c.Assert(decKey, check.DeepEquals, ca.keys)
+ require.NoError(t, err)
+ require.Equal(t, ca.keys, decKey)
}
}
-func (t *testCommon) TestEncodeAsPrefix(c *check.C) {
+func TestEncodeAsPrefix(t *testing.T) {
testCases := []struct {
keys []string
adapter KeyAdapter
@@ -106,22 +98,22 @@ func (t *testCommon) TestEncodeAsPrefix(c *check.C) {
for _, ca := range testCases {
encKey := ca.adapter.Encode(ca.keys...)
- c.Assert(encKey, check.Equals, ca.want)
+ require.Equal(t, ca.want, encKey)
_, err := ca.adapter.Decode(encKey)
- c.Assert(err, check.NotNil)
+ require.NotNil(t, err)
}
}
-func (t *testCommon) TestIsErrNetClosing(c *check.C) {
+func TestIsErrNetClosing(t *testing.T) {
server, err := net.Listen("tcp", "localhost:0")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = server.Close()
- c.Assert(IsErrNetClosing(err), check.IsFalse)
+ require.False(t, IsErrNetClosing(err))
_, err = server.Accept()
- c.Assert(IsErrNetClosing(err), check.IsTrue)
+ require.True(t, IsErrNetClosing(err))
}
-func (t *testCommon) TestJoinUseSlash(c *check.C) {
+func TestJoinUseSlash(t *testing.T) {
// because we use "/" in Encode
- c.Assert(path.Join("a", "b"), check.Equals, "a/b")
+ require.Equal(t, "a/b", path.Join("a", "b"))
}
diff --git a/dm/config/source_converter_test.go b/dm/config/source_converter_test.go
index cf044729e0..09712d5954 100644
--- a/dm/config/source_converter_test.go
+++ b/dm/config/source_converter_test.go
@@ -16,21 +16,13 @@ package config
import (
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/openapi/fixtures"
+ "github.com/stretchr/testify/require"
)
-func TestConfig(t *testing.T) {
- check.TestingT(t)
-}
-
-type testConfig struct{}
-
-var _ = check.Suite(&testConfig{})
-
-func (t *testConfig) TestConverterWithSourceAndOpenAPISource(c *check.C) {
+func TestConverterWithSourceAndOpenAPISource(t *testing.T) {
sourceCfg1, err := SourceCfgFromYaml(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// 1. test user create source from dmctl, after convert to openapi.Source then convert back to source config
sourceCfg2 := OpenAPISourceToSourceCfg(SourceCfgToOpenAPISource(sourceCfg1))
@@ -40,12 +32,12 @@ func (t *testConfig) TestConverterWithSourceAndOpenAPISource(c *check.C) {
sourceCfg2.From.MaxAllowedPacket = sourceCfg1.From.MaxAllowedPacket
// we only need to make sure the source config that user can see is the same as the source config that user create
- c.Assert(sourceCfg1.String(), check.Equals, sourceCfg2.String())
+ require.Equal(t, sourceCfg2.String(), sourceCfg1.String())
// 2. test user create source from openapi, after convert to source config then convert back to openapi.Source
openapiSource1, err := fixtures.GenOpenAPISourceForTest()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
openapiSource2 := SourceCfgToOpenAPISource(OpenAPISourceToSourceCfg(openapiSource1))
openapiSource2.Password = openapiSource1.Password // we set passwd to "******" for privacy
- c.Assert(openapiSource1, check.DeepEquals, openapiSource2)
+ require.Equal(t, openapiSource2, openapiSource1)
}
diff --git a/dm/config/task_cli_args_test.go b/dm/config/task_cli_args_test.go
index 515f3979a5..2ac62c5cba 100644
--- a/dm/config/task_cli_args_test.go
+++ b/dm/config/task_cli_args_test.go
@@ -15,8 +15,9 @@ package config
import (
"encoding/json"
+ "testing"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
type testStruct struct {
@@ -29,7 +30,7 @@ func (t *testStruct) ToJSON() string {
return string(cfg)
}
-func (t *testConfig) TestTaskCliArgsDowngrade(c *check.C) {
+func TestTaskCliArgsDowngrade(t *testing.T) {
s := testStruct{
TaskCliArgs: TaskCliArgs{"123", "1s", "1s"},
FutureField: "456",
@@ -37,38 +38,38 @@ func (t *testConfig) TestTaskCliArgsDowngrade(c *check.C) {
data := s.ToJSON()
expected := `{"start_time":"123","safe_mode_duration":"1s","wait_time_on_stop":"1s","future_field":"456"}`
- c.Assert(data, check.Equals, expected)
+ require.Equal(t, expected, data)
afterDowngrade := &TaskCliArgs{}
- c.Assert(afterDowngrade.Decode([]byte(data)), check.IsNil)
- c.Assert(afterDowngrade.StartTime, check.Equals, "123")
+ require.NoError(t, afterDowngrade.Decode([]byte(data)))
+ require.Equal(t, "123", afterDowngrade.StartTime)
}
-func (t *testConfig) TestTaskCliArgsVerify(c *check.C) {
+func TestTaskCliArgsVerify(t *testing.T) {
empty := TaskCliArgs{}
- c.Assert(empty.Verify(), check.IsNil)
+ require.NoError(t, empty.Verify())
rightStartTime := TaskCliArgs{StartTime: "2006-01-02T15:04:05"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
rightStartTime = TaskCliArgs{StartTime: "2006-01-02 15:04:05"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
rightStartTime = TaskCliArgs{StartTime: "2006-01-02T15:04:05+08:00"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
rightStartTime = TaskCliArgs{StartTime: "2006-01-02 15:04:05+08:00"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
rightStartTime = TaskCliArgs{StartTime: "2006-01-02T15:04:05+0800"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
rightStartTime = TaskCliArgs{StartTime: "2006-01-02 15:04:05+0800"}
- c.Assert(rightStartTime.Verify(), check.IsNil)
+ require.NoError(t, rightStartTime.Verify())
wrongStartTime := TaskCliArgs{StartTime: "15:04:05"}
- c.Assert(wrongStartTime.Verify(), check.NotNil)
+ require.Error(t, wrongStartTime.Verify())
rightSafeModeDuration := TaskCliArgs{SafeModeDuration: "1s"}
- c.Assert(rightSafeModeDuration.Verify(), check.IsNil)
+ require.NoError(t, rightSafeModeDuration.Verify())
wrongSafeModeDuration := TaskCliArgs{SafeModeDuration: "1"}
- c.Assert(wrongSafeModeDuration.Verify(), check.NotNil)
+ require.Error(t, wrongSafeModeDuration.Verify())
rightWaitTimeOnStop := TaskCliArgs{WaitTimeOnStop: "1s"}
- c.Assert(rightWaitTimeOnStop.Verify(), check.IsNil)
+ require.NoError(t, rightWaitTimeOnStop.Verify())
wrongWaitTimeOnStop := TaskCliArgs{WaitTimeOnStop: "1"}
- c.Assert(wrongWaitTimeOnStop.Verify(), check.NotNil)
+ require.Error(t, wrongWaitTimeOnStop.Verify())
}
diff --git a/dm/config/task_converters_test.go b/dm/config/task_converters_test.go
index 98f06ae943..3452a268e0 100644
--- a/dm/config/task_converters_test.go
+++ b/dm/config/task_converters_test.go
@@ -17,7 +17,6 @@ import (
"testing"
"github.com/google/uuid"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/util/filter"
"github.com/pingcap/tiflow/dm/config/dbconfig"
"github.com/pingcap/tiflow/dm/config/security"
@@ -28,7 +27,7 @@ import (
"github.com/stretchr/testify/require"
)
-func (t *testConfig) TestTaskGetTargetDBCfg(c *check.C) {
+func TestTaskGetTargetDBCfg(t *testing.T) {
certAllowedCn := []string{"test"}
task := &openapi.Task{
TargetConfig: openapi.TaskTargetDataBase{
@@ -40,24 +39,24 @@ func (t *testConfig) TestTaskGetTargetDBCfg(c *check.C) {
},
}
dbCfg := GetTargetDBCfgFromOpenAPITask(task)
- c.Assert(dbCfg.Host, check.Equals, task.TargetConfig.Host)
- c.Assert(dbCfg.Password, check.Equals, task.TargetConfig.Password)
- c.Assert(dbCfg.Port, check.Equals, task.TargetConfig.Port)
- c.Assert(dbCfg.User, check.Equals, task.TargetConfig.User)
- c.Assert(dbCfg.Security, check.NotNil)
- c.Assert([]string{dbCfg.Security.CertAllowedCN[0]}, check.DeepEquals, certAllowedCn)
+ require.Equal(t, task.TargetConfig.Host, dbCfg.Host)
+ require.Equal(t, task.TargetConfig.Password, dbCfg.Password)
+ require.Equal(t, task.TargetConfig.Port, dbCfg.Port)
+ require.Equal(t, task.TargetConfig.User, dbCfg.User)
+ require.NotNil(t, dbCfg.Security)
+ require.Equal(t, certAllowedCn, []string{dbCfg.Security.CertAllowedCN[0]})
}
-func (t *testConfig) TestOpenAPITaskToSubTaskConfigs(c *check.C) {
- testNoShardTaskToSubTaskConfigs(c)
- testShardAndFilterTaskToSubTaskConfigs(c)
+func TestOpenAPITaskToSubTaskConfigs(t *testing.T) {
+ testNoShardTaskToSubTaskConfigs(t)
+ testShardAndFilterTaskToSubTaskConfigs(t)
}
-func testNoShardTaskToSubTaskConfigs(c *check.C) {
+func testNoShardTaskToSubTaskConfigs(t *testing.T) {
task, err := fixtures.GenNoShardOpenAPITaskForTest()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceCfg1, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source1Name := task.SourceConfig.SourceConf[0].SourceName
sourceCfg1.SourceID = task.SourceConfig.SourceConf[0].SourceName
sourceCfgMap := map[string]*SourceConfig{source1Name: sourceCfg1}
@@ -77,33 +76,33 @@ func testNoShardTaskToSubTaskConfigs(c *check.C) {
newMeta := "new_dm_meta"
task.MetaSchema = &newMeta
subTaskConfigList, err := OpenAPITaskToSubTaskConfigs(&task, toDBCfg, sourceCfgMap)
- c.Assert(err, check.IsNil)
- c.Assert(subTaskConfigList, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, subTaskConfigList, 1)
subTaskConfig := subTaskConfigList[0]
// check task name and mode
- c.Assert(subTaskConfig.Name, check.Equals, task.Name)
+ require.Equal(t, task.Name, subTaskConfig.Name)
// check task meta
- c.Assert(subTaskConfig.MetaSchema, check.Equals, *task.MetaSchema)
- c.Assert(subTaskConfig.Meta, check.IsNil)
+ require.Equal(t, *task.MetaSchema, subTaskConfig.MetaSchema)
+ require.Nil(t, subTaskConfig.Meta)
// check shard config
- c.Assert(subTaskConfig.ShardMode, check.Equals, "")
+ require.Equal(t, "", subTaskConfig.ShardMode)
// check online schema change
- c.Assert(subTaskConfig.OnlineDDL, check.Equals, true)
+ require.Equal(t, true, subTaskConfig.OnlineDDL)
// check case sensitive
- c.Assert(subTaskConfig.CaseSensitive, check.Equals, sourceCfg1.CaseSensitive)
+ require.Equal(t, sourceCfg1.CaseSensitive, subTaskConfig.CaseSensitive)
// check from
- c.Assert(subTaskConfig.From.Host, check.Equals, sourceCfg1.From.Host)
+ require.Equal(t, sourceCfg1.From.Host, subTaskConfig.From.Host)
// check to
- c.Assert(subTaskConfig.To.Host, check.Equals, toDBCfg.Host)
+ require.Equal(t, toDBCfg.Host, subTaskConfig.To.Host)
// check dumpling loader syncer config
- c.Assert(subTaskConfig.MydumperConfig.Threads, check.Equals, *task.SourceConfig.FullMigrateConf.ExportThreads)
- c.Assert(subTaskConfig.LoaderConfig.Dir, check.Equals, fmt.Sprintf(
- "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name))
- c.Assert(subTaskConfig.LoaderConfig.PoolSize, check.Equals, *task.SourceConfig.FullMigrateConf.ImportThreads)
- c.Assert(subTaskConfig.SyncerConfig.WorkerCount, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplThreads)
- c.Assert(subTaskConfig.SyncerConfig.Batch, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplBatch)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ExportThreads, subTaskConfig.MydumperConfig.Threads)
+ require.Equal(t, fmt.Sprintf(
+ "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name), subTaskConfig.LoaderConfig.Dir)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ImportThreads, subTaskConfig.LoaderConfig.PoolSize)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplThreads, subTaskConfig.SyncerConfig.WorkerCount)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplBatch, subTaskConfig.SyncerConfig.Batch)
// check route
- c.Assert(subTaskConfig.RouteRules, check.HasLen, 1)
+ require.Len(t, subTaskConfig.RouteRules, 1)
rule := subTaskConfig.RouteRules[0]
sourceSchema := task.TableMigrateRule[0].Source.Schema
@@ -111,45 +110,45 @@ func testNoShardTaskToSubTaskConfigs(c *check.C) {
tartgetSchema := task.TableMigrateRule[0].Target.Schema
tartgetTable := task.TableMigrateRule[0].Target.Table
- c.Assert(rule.SchemaPattern, check.Equals, sourceSchema)
- c.Assert(rule.TablePattern, check.Equals, sourceTable)
- c.Assert(rule.TargetSchema, check.Equals, *tartgetSchema)
- c.Assert(rule.TargetTable, check.Equals, *tartgetTable)
+ require.Equal(t, sourceSchema, rule.SchemaPattern)
+ require.Equal(t, sourceTable, rule.TablePattern)
+ require.Equal(t, *tartgetSchema, rule.TargetSchema)
+ require.Equal(t, *tartgetTable, rule.TargetTable)
// check filter
- c.Assert(subTaskConfig.FilterRules, check.HasLen, 0)
+ require.Len(t, subTaskConfig.FilterRules, 0)
// check balist
- c.Assert(subTaskConfig.BAList, check.NotNil)
+ require.NotNil(t, subTaskConfig.BAList)
bAListFromOpenAPITask := &filter.Rules{
DoTables: []*filter.Table{{Schema: sourceSchema, Name: sourceTable}},
}
- c.Assert(subTaskConfig.BAList, check.DeepEquals, bAListFromOpenAPITask)
+ require.Equal(t, bAListFromOpenAPITask, subTaskConfig.BAList)
// check ignore check items
- c.Assert(subTaskConfig.IgnoreCheckingItems, check.IsNil)
+ require.Nil(t, subTaskConfig.IgnoreCheckingItems)
// check io total bytes counter and uuid
- c.Assert(subTaskConfig.IOTotalBytes, check.NotNil)
- c.Assert(subTaskConfig.DumpIOTotalBytes, check.NotNil)
- c.Assert(subTaskConfig.IOTotalBytes.Load(), check.Equals, uint64(0))
- c.Assert(subTaskConfig.DumpIOTotalBytes.Load(), check.Equals, uint64(0))
- c.Assert(subTaskConfig.UUID, check.HasLen, len(uuid.NewString()))
- c.Assert(subTaskConfig.DumpUUID, check.HasLen, len(uuid.NewString()))
+ require.NotNil(t, subTaskConfig.IOTotalBytes)
+ require.NotNil(t, subTaskConfig.DumpIOTotalBytes)
+ require.Equal(t, uint64(0), subTaskConfig.IOTotalBytes.Load())
+ require.Equal(t, uint64(0), subTaskConfig.DumpIOTotalBytes.Load())
+ require.Len(t, subTaskConfig.UUID, len(uuid.NewString()))
+ require.Len(t, subTaskConfig.DumpUUID, len(uuid.NewString()))
// check security items
- c.Assert(string(subTaskConfig.To.Security.SSLCABytes), check.Equals, task.TargetConfig.Security.SslCaContent)
- c.Assert(string(subTaskConfig.To.Security.SSLCertBytes), check.Equals, task.TargetConfig.Security.SslCertContent)
- c.Assert(string(subTaskConfig.To.Security.SSLKeyBytes), check.Equals, task.TargetConfig.Security.SslKeyContent)
- c.Assert(string(subTaskConfig.LoaderConfig.Security.SSLCABytes), check.Equals, task.SourceConfig.FullMigrateConf.Security.SslCaContent)
- c.Assert(string(subTaskConfig.LoaderConfig.Security.SSLCertBytes), check.Equals, task.SourceConfig.FullMigrateConf.Security.SslCertContent)
- c.Assert(string(subTaskConfig.LoaderConfig.Security.SSLKeyBytes), check.Equals, task.SourceConfig.FullMigrateConf.Security.SslKeyContent)
+ require.Equal(t, task.TargetConfig.Security.SslCaContent, string(subTaskConfig.To.Security.SSLCABytes))
+ require.Equal(t, task.TargetConfig.Security.SslCertContent, string(subTaskConfig.To.Security.SSLCertBytes))
+ require.Equal(t, task.TargetConfig.Security.SslKeyContent, string(subTaskConfig.To.Security.SSLKeyBytes))
+ require.Equal(t, task.SourceConfig.FullMigrateConf.Security.SslCaContent, string(subTaskConfig.LoaderConfig.Security.SSLCABytes))
+ require.Equal(t, task.SourceConfig.FullMigrateConf.Security.SslCertContent, string(subTaskConfig.LoaderConfig.Security.SSLCertBytes))
+ require.Equal(t, task.SourceConfig.FullMigrateConf.Security.SslKeyContent, string(subTaskConfig.LoaderConfig.Security.SSLKeyBytes))
}
-func testShardAndFilterTaskToSubTaskConfigs(c *check.C) {
+func testShardAndFilterTaskToSubTaskConfigs(t *testing.T) {
task, err := fixtures.GenShardAndFilterOpenAPITaskForTest()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceCfg1, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source1Name := task.SourceConfig.SourceConf[0].SourceName
sourceCfg1.SourceID = source1Name
sourceCfg2, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source2Name := task.SourceConfig.SourceConf[1].SourceName
sourceCfg2.SourceID = source2Name
@@ -161,54 +160,54 @@ func testShardAndFilterTaskToSubTaskConfigs(c *check.C) {
}
sourceCfgMap := map[string]*SourceConfig{source1Name: sourceCfg1, source2Name: sourceCfg2}
subTaskConfigList, err := OpenAPITaskToSubTaskConfigs(&task, toDBCfg, sourceCfgMap)
- c.Assert(err, check.IsNil)
- c.Assert(subTaskConfigList, check.HasLen, 2)
+ require.NoError(t, err)
+ require.Len(t, subTaskConfigList, 2)
// check sub task 1
subTask1Config := subTaskConfigList[0]
// check task name and mode
- c.Assert(subTask1Config.Name, check.Equals, task.Name)
+ require.Equal(t, task.Name, subTask1Config.Name)
// check task meta
- c.Assert(subTask1Config.MetaSchema, check.Equals, *task.MetaSchema)
- c.Assert(subTask1Config.Meta, check.NotNil)
- c.Assert(subTask1Config.Meta.BinLogGTID, check.Equals, *task.SourceConfig.SourceConf[0].BinlogGtid)
- c.Assert(subTask1Config.Meta.BinLogName, check.Equals, *task.SourceConfig.SourceConf[0].BinlogName)
- c.Assert(subTask1Config.Meta.BinLogPos, check.Equals, uint32(*task.SourceConfig.SourceConf[0].BinlogPos))
+ require.Equal(t, *task.MetaSchema, subTask1Config.MetaSchema)
+ require.NotNil(t, subTask1Config.Meta)
+ require.Equal(t, *task.SourceConfig.SourceConf[0].BinlogGtid, subTask1Config.Meta.BinLogGTID)
+ require.Equal(t, *task.SourceConfig.SourceConf[0].BinlogName, subTask1Config.Meta.BinLogName)
+ require.Equal(t, uint32(*task.SourceConfig.SourceConf[0].BinlogPos), subTask1Config.Meta.BinLogPos)
// check shard config
- c.Assert(subTask1Config.ShardMode, check.Equals, string(openapi.TaskShardModeOptimistic))
- c.Assert(subTask1Config.StrictOptimisticShardMode, check.IsTrue)
+ require.Equal(t, string(openapi.TaskShardModeOptimistic), subTask1Config.ShardMode)
+ require.True(t, subTask1Config.StrictOptimisticShardMode)
// check online schema change
- c.Assert(subTask1Config.OnlineDDL, check.Equals, true)
+ require.Equal(t, true, subTask1Config.OnlineDDL)
// check case sensitive
- c.Assert(subTask1Config.CaseSensitive, check.Equals, sourceCfg1.CaseSensitive)
+ require.Equal(t, sourceCfg1.CaseSensitive, subTask1Config.CaseSensitive)
// check from
- c.Assert(subTask1Config.From.Host, check.Equals, sourceCfg1.From.Host)
+ require.Equal(t, sourceCfg1.From.Host, subTask1Config.From.Host)
// check to
- c.Assert(subTask1Config.To.Host, check.Equals, toDBCfg.Host)
+ require.Equal(t, toDBCfg.Host, subTask1Config.To.Host)
// check dumpling loader syncer config
- c.Assert(subTask1Config.MydumperConfig.Threads, check.Equals, *task.SourceConfig.FullMigrateConf.ExportThreads)
- c.Assert(subTask1Config.LoaderConfig.Dir, check.Equals, fmt.Sprintf(
- "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name))
- c.Assert(subTask1Config.LoaderConfig.PoolSize, check.Equals, *task.SourceConfig.FullMigrateConf.ImportThreads)
- c.Assert(subTask1Config.SyncerConfig.WorkerCount, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplThreads)
- c.Assert(subTask1Config.SyncerConfig.Batch, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplBatch)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ExportThreads, subTask1Config.MydumperConfig.Threads)
+ require.Equal(t, fmt.Sprintf(
+ "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name), subTask1Config.LoaderConfig.Dir)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ImportThreads, subTask1Config.LoaderConfig.PoolSize)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplThreads, subTask1Config.SyncerConfig.WorkerCount)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplBatch, subTask1Config.SyncerConfig.Batch)
// check route
- c.Assert(subTask1Config.RouteRules, check.HasLen, 1)
+ require.Len(t, subTask1Config.RouteRules, 1)
rule := subTask1Config.RouteRules[0]
source1Schema := task.TableMigrateRule[0].Source.Schema
source1Table := task.TableMigrateRule[0].Source.Table
tartgetSchema := task.TableMigrateRule[0].Target.Schema
tartgetTable := task.TableMigrateRule[0].Target.Table
- c.Assert(rule.SchemaPattern, check.Equals, source1Schema)
- c.Assert(rule.TablePattern, check.Equals, source1Table)
- c.Assert(rule.TargetSchema, check.Equals, *tartgetSchema)
- c.Assert(rule.TargetTable, check.Equals, *tartgetTable)
+ require.Equal(t, source1Schema, rule.SchemaPattern)
+ require.Equal(t, source1Table, rule.TablePattern)
+ require.Equal(t, *tartgetSchema, rule.TargetSchema)
+ require.Equal(t, *tartgetTable, rule.TargetTable)
// check filter
filterARule, ok := task.BinlogFilterRule.Get("filterA")
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
filterIgnoreEvents := *filterARule.IgnoreEvent
- c.Assert(filterIgnoreEvents, check.HasLen, 1)
+ require.Len(t, filterIgnoreEvents, 1)
filterEvents := []bf.EventType{bf.EventType(filterIgnoreEvents[0])}
filterRulesFromOpenAPITask := &bf.BinlogEventRule{
Action: bf.Ignore,
@@ -217,79 +216,79 @@ func testShardAndFilterTaskToSubTaskConfigs(c *check.C) {
SchemaPattern: source1Schema,
TablePattern: source1Table,
}
- c.Assert(filterRulesFromOpenAPITask.Valid(), check.IsNil)
- c.Assert(subTask1Config.FilterRules, check.HasLen, 1)
- c.Assert(subTask1Config.FilterRules[0], check.DeepEquals, filterRulesFromOpenAPITask)
+ require.NoError(t, filterRulesFromOpenAPITask.Valid())
+ require.Len(t, subTask1Config.FilterRules, 1)
+ require.Equal(t, filterRulesFromOpenAPITask, subTask1Config.FilterRules[0])
// check balist
- c.Assert(subTask1Config.BAList, check.NotNil)
+ require.NotNil(t, subTask1Config.BAList)
bAListFromOpenAPITask := &filter.Rules{
DoTables: []*filter.Table{{Schema: source1Schema, Name: source1Table}},
}
- c.Assert(subTask1Config.BAList, check.DeepEquals, bAListFromOpenAPITask)
+ require.Equal(t, bAListFromOpenAPITask, subTask1Config.BAList)
// check ignore check items
- c.Assert(subTask1Config.IgnoreCheckingItems, check.IsNil)
+ require.Nil(t, subTask1Config.IgnoreCheckingItems)
// check sub task 2
subTask2Config := subTaskConfigList[1]
// check task name and mode
- c.Assert(subTask2Config.Name, check.Equals, task.Name)
+ require.Equal(t, task.Name, subTask2Config.Name)
// check task meta
- c.Assert(subTask2Config.MetaSchema, check.Equals, *task.MetaSchema)
- c.Assert(subTask2Config.Meta, check.NotNil)
- c.Assert(subTask2Config.Meta.BinLogGTID, check.Equals, *task.SourceConfig.SourceConf[1].BinlogGtid)
- c.Assert(subTask2Config.Meta.BinLogName, check.Equals, *task.SourceConfig.SourceConf[1].BinlogName)
- c.Assert(subTask2Config.Meta.BinLogPos, check.Equals, uint32(*task.SourceConfig.SourceConf[1].BinlogPos))
+ require.Equal(t, *task.MetaSchema, subTask2Config.MetaSchema)
+ require.NotNil(t, subTask2Config.Meta)
+ require.Equal(t, *task.SourceConfig.SourceConf[1].BinlogGtid, subTask2Config.Meta.BinLogGTID)
+ require.Equal(t, *task.SourceConfig.SourceConf[1].BinlogName, subTask2Config.Meta.BinLogName)
+ require.Equal(t, uint32(*task.SourceConfig.SourceConf[1].BinlogPos), subTask2Config.Meta.BinLogPos)
// check shard config
- c.Assert(subTask2Config.ShardMode, check.Equals, string(openapi.TaskShardModeOptimistic))
+ require.Equal(t, string(openapi.TaskShardModeOptimistic), subTask2Config.ShardMode)
// check online schema change
- c.Assert(subTask2Config.OnlineDDL, check.Equals, true)
+ require.Equal(t, true, subTask2Config.OnlineDDL)
// check case sensitive
- c.Assert(subTask2Config.CaseSensitive, check.Equals, sourceCfg2.CaseSensitive)
+ require.Equal(t, sourceCfg2.CaseSensitive, subTask2Config.CaseSensitive)
// check from
- c.Assert(subTask2Config.From.Host, check.Equals, sourceCfg2.From.Host)
+ require.Equal(t, sourceCfg2.From.Host, subTask2Config.From.Host)
// check to
- c.Assert(subTask2Config.To.Host, check.Equals, toDBCfg.Host)
+ require.Equal(t, toDBCfg.Host, subTask2Config.To.Host)
// check dumpling loader syncer config
- c.Assert(subTask2Config.MydumperConfig.Threads, check.Equals, *task.SourceConfig.FullMigrateConf.ExportThreads)
- c.Assert(subTask2Config.LoaderConfig.Dir, check.Equals, fmt.Sprintf(
- "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name))
- c.Assert(subTask2Config.LoaderConfig.PoolSize, check.Equals, *task.SourceConfig.FullMigrateConf.ImportThreads)
- c.Assert(subTask2Config.SyncerConfig.WorkerCount, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplThreads)
- c.Assert(subTask2Config.SyncerConfig.Batch, check.Equals, *task.SourceConfig.IncrMigrateConf.ReplBatch)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ExportThreads, subTask2Config.MydumperConfig.Threads)
+ require.Equal(t, fmt.Sprintf(
+ "%s.%s", *task.SourceConfig.FullMigrateConf.DataDir, task.Name), subTask2Config.LoaderConfig.Dir)
+ require.Equal(t, *task.SourceConfig.FullMigrateConf.ImportThreads, subTask2Config.LoaderConfig.PoolSize)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplThreads, subTask2Config.SyncerConfig.WorkerCount)
+ require.Equal(t, *task.SourceConfig.IncrMigrateConf.ReplBatch, subTask2Config.SyncerConfig.Batch)
// check route
- c.Assert(subTask2Config.RouteRules, check.HasLen, 1)
+ require.Len(t, subTask2Config.RouteRules, 1)
rule = subTask2Config.RouteRules[0]
source2Schema := task.TableMigrateRule[1].Source.Schema
source2Table := task.TableMigrateRule[1].Source.Table
- c.Assert(rule.SchemaPattern, check.Equals, source2Schema)
- c.Assert(rule.TablePattern, check.Equals, source2Table)
- c.Assert(rule.TargetSchema, check.Equals, *tartgetSchema)
- c.Assert(rule.TargetTable, check.Equals, *tartgetTable)
+ require.Equal(t, source2Schema, rule.SchemaPattern)
+ require.Equal(t, source2Table, rule.TablePattern)
+ require.Equal(t, *tartgetSchema, rule.TargetSchema)
+ require.Equal(t, *tartgetTable, rule.TargetTable)
// check filter
_, ok = task.BinlogFilterRule.Get("filterB")
- c.Assert(ok, check.IsFalse)
- c.Assert(subTask2Config.FilterRules, check.HasLen, 0)
+ require.False(t, ok)
+ require.Len(t, subTask2Config.FilterRules, 0)
// check balist
- c.Assert(subTask2Config.BAList, check.NotNil)
+ require.NotNil(t, subTask2Config.BAList)
bAListFromOpenAPITask = &filter.Rules{
DoTables: []*filter.Table{{Schema: source2Schema, Name: source2Table}},
}
- c.Assert(subTask2Config.BAList, check.DeepEquals, bAListFromOpenAPITask)
+ require.Equal(t, bAListFromOpenAPITask, subTask2Config.BAList)
// check ignore check items
- c.Assert(subTask2Config.IgnoreCheckingItems, check.IsNil)
+ require.Nil(t, subTask2Config.IgnoreCheckingItems)
}
-func (t *testConfig) TestSubTaskConfigsToOpenAPITask(c *check.C) {
- testNoShardSubTaskConfigsToOpenAPITask(c)
- testShardAndFilterSubTaskConfigsToOpenAPITask(c)
+func TestSubTaskConfigsToOpenAPITask(t *testing.T) {
+ testNoShardSubTaskConfigsToOpenAPITask(t)
+ testShardAndFilterSubTaskConfigsToOpenAPITask(t)
}
-func testNoShardSubTaskConfigsToOpenAPITask(c *check.C) {
+func testNoShardSubTaskConfigsToOpenAPITask(t *testing.T) {
task, err := fixtures.GenNoShardOpenAPITaskForTest()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceCfg1, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source1Name := task.SourceConfig.SourceConf[0].SourceName
sourceCfg1.SourceID = task.SourceConfig.SourceConf[0].SourceName
sourceCfgMap := map[string]*SourceConfig{source1Name: sourceCfg1}
@@ -306,8 +305,8 @@ func testNoShardSubTaskConfigsToOpenAPITask(c *check.C) {
},
}
subTaskConfigList, err := OpenAPITaskToSubTaskConfigs(&task, toDBCfg, sourceCfgMap)
- c.Assert(err, check.IsNil)
- c.Assert(subTaskConfigList, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, subTaskConfigList, 1)
// prepare sub task config
subTaskConfigMap := make(map[string]map[string]*SubTaskConfig)
@@ -315,20 +314,20 @@ func testNoShardSubTaskConfigsToOpenAPITask(c *check.C) {
subTaskConfigMap[task.Name][source1Name] = subTaskConfigList[0]
taskList := SubTaskConfigsToOpenAPITaskList(subTaskConfigMap)
- c.Assert(taskList, check.HasLen, 1)
+ require.Len(t, taskList, 1)
newTask := taskList[0]
- c.Assert(&task, check.DeepEquals, newTask)
+ require.Equal(t, newTask, &task)
}
-func testShardAndFilterSubTaskConfigsToOpenAPITask(c *check.C) {
+func testShardAndFilterSubTaskConfigsToOpenAPITask(t *testing.T) {
task, err := fixtures.GenShardAndFilterOpenAPITaskForTest()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceCfg1, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source1Name := task.SourceConfig.SourceConf[0].SourceName
sourceCfg1.SourceID = source1Name
sourceCfg2, err := SourceCfgFromYamlAndVerify(SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
source2Name := task.SourceConfig.SourceConf[1].SourceName
sourceCfg2.SourceID = source2Name
@@ -340,8 +339,8 @@ func testShardAndFilterSubTaskConfigsToOpenAPITask(c *check.C) {
}
sourceCfgMap := map[string]*SourceConfig{source1Name: sourceCfg1, source2Name: sourceCfg2}
subTaskConfigList, err := OpenAPITaskToSubTaskConfigs(&task, toDBCfg, sourceCfgMap)
- c.Assert(err, check.IsNil)
- c.Assert(subTaskConfigList, check.HasLen, 2)
+ require.NoError(t, err)
+ require.Len(t, subTaskConfigList, 2)
// prepare sub task config
subTaskConfigMap := make(map[string]map[string]*SubTaskConfig)
@@ -350,14 +349,14 @@ func testShardAndFilterSubTaskConfigsToOpenAPITask(c *check.C) {
subTaskConfigMap[task.Name][source2Name] = subTaskConfigList[1]
taskList := SubTaskConfigsToOpenAPITaskList(subTaskConfigMap)
- c.Assert(taskList, check.HasLen, 1)
+ require.Len(t, taskList, 1)
newTask := taskList[0]
// because subtask config not have filter-rule-name, so we need to add it manually
oldRuleName := "filterA"
newRuleName := genFilterRuleName(source1Name, 0)
oldRule, ok := task.BinlogFilterRule.Get(oldRuleName)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
newRule := openapi.Task_BinlogFilterRule{}
newRule.Set(newRuleName, oldRule)
task.BinlogFilterRule = &newRule
@@ -372,7 +371,7 @@ func testShardAndFilterSubTaskConfigsToOpenAPITask(c *check.C) {
task.TableMigrateRule[0], task.TableMigrateRule[1] = task.TableMigrateRule[1], task.TableMigrateRule[0]
}
- c.Assert(&task, check.DeepEquals, newTask)
+ require.Equal(t, newTask, &task)
}
func TestConvertWithIgnoreCheckItems(t *testing.T) {
diff --git a/dm/ctl/common/config_test.go b/dm/ctl/common/config_test.go
index a052ee2d7d..3e419112ea 100644
--- a/dm/ctl/common/config_test.go
+++ b/dm/ctl/common/config_test.go
@@ -16,18 +16,10 @@ package common
import (
"testing"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-func TestConfig(t *testing.T) {
- check.TestingT(t)
-}
-
-var _ = check.Suite(&testConfigSuite{})
-
-type testConfigSuite struct{}
-
-func (t *testConfigSuite) TestInteractiveQuotes(c *check.C) {
+func TestInteractiveQuotes(t *testing.T) {
cases := []struct {
input string
expected []string
@@ -48,6 +40,6 @@ func (t *testConfigSuite) TestInteractiveQuotes(c *check.C) {
for _, ca := range cases {
got := SplitArgsRespectQuote(ca.input)
- c.Assert(got, check.DeepEquals, ca.expected)
+ require.Equal(t, ca.expected, got)
}
}
diff --git a/dm/ctl/master/operate_task_test.go b/dm/ctl/master/operate_task_test.go
index d21270e2b9..9005ae2cde 100644
--- a/dm/ctl/master/operate_task_test.go
+++ b/dm/ctl/master/operate_task_test.go
@@ -14,50 +14,52 @@
package master
import (
- "github.com/pingcap/check"
+ "testing"
+
"github.com/spf13/cobra"
+ "github.com/stretchr/testify/require"
)
-func (t *testCtlMaster) TestParseBatchTaskParameters(c *check.C) {
+func TestParseBatchTaskParameters(t *testing.T) {
{
cmd := prepareTestCmd()
_ = cmd.ParseFlags([]string{"task-name"})
_, _, err := parseOperateSourceTaskParams(cmd)
- c.Assert(err, check.Not(check.IsNil))
+ require.Error(t, err)
}
{
cmd := prepareTestCmd()
_, _, err := parseOperateSourceTaskParams(cmd)
- c.Assert(err, check.Not(check.IsNil))
+ require.Error(t, err)
}
{
cmd := prepareTestCmd()
_ = cmd.ParseFlags([]string{"-s", "source-name", "-s", "source-name2"})
_, _, err := parseOperateSourceTaskParams(cmd)
- c.Assert(err, check.Not(check.IsNil))
+ require.Error(t, err)
}
{
cmd := prepareTestCmd()
_ = cmd.ParseFlags([]string{"-s", "source-name"})
source, _, err := parseOperateSourceTaskParams(cmd)
- c.Assert(source, check.Equals, "source-name")
- c.Assert(err, check.IsNil)
+ require.Equal(t, "source-name", source)
+ require.NoError(t, err)
}
{
cmd := prepareTestCmd()
_ = cmd.ParseFlags([]string{"-s", "source-name"})
source, batchSize, err := parseOperateSourceTaskParams(cmd)
- c.Assert(source, check.Equals, "source-name")
- c.Assert(batchSize, check.Equals, defaultBatchSize)
- c.Assert(err, check.IsNil)
+ require.Equal(t, "source-name", source)
+ require.Equal(t, defaultBatchSize, batchSize)
+ require.NoError(t, err)
}
{
cmd := prepareTestCmd()
_ = cmd.ParseFlags([]string{"-s", "source-name", "--batch-size", "2"})
source, batchSize, err := parseOperateSourceTaskParams(cmd)
- c.Assert(source, check.Equals, "source-name")
- c.Assert(batchSize, check.Equals, 2)
- c.Assert(err, check.IsNil)
+ require.Equal(t, "source-name", source)
+ require.Equal(t, 2, batchSize)
+ require.NoError(t, err)
}
}
diff --git a/dm/ctl/master/query_status_test.go b/dm/ctl/master/query_status_test.go
index df6dee021c..3c34c7a925 100644
--- a/dm/ctl/master/query_status_test.go
+++ b/dm/ctl/master/query_status_test.go
@@ -17,36 +17,28 @@ import (
"sort"
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pb"
+ "github.com/stretchr/testify/require"
)
-func TestCtlMaster(t *testing.T) {
- check.TestingT(t)
-}
-
-type testCtlMaster struct{}
-
-var _ = check.Suite(&testCtlMaster{})
-
-func generateAndCheckTaskResult(c *check.C, resp *pb.QueryStatusListResponse, expectedResult []*taskInfo) {
+func generateAndCheckTaskResult(t *testing.T, resp *pb.QueryStatusListResponse, expectedResult []*taskInfo) {
result, hasFalseResult := wrapTaskResult(resp)
- c.Assert(hasFalseResult, check.IsFalse)
- c.Assert(result.Result, check.IsTrue)
- c.Assert(result.Tasks, check.HasLen, 1)
+ require.False(t, hasFalseResult)
+ require.True(t, result.Result)
+ require.Len(t, result.Tasks, 1)
sort.Strings(result.Tasks[0].Sources)
- c.Assert(result.Tasks, check.DeepEquals, expectedResult)
+ require.Equal(t, expectedResult, result.Tasks)
}
-func subTestSameSubTaskStatus(c *check.C, resp *pb.QueryStatusListResponse, expectedResult []*taskInfo, stage pb.Stage) {
+func subTestSameSubTaskStatus(t *testing.T, resp *pb.QueryStatusListResponse, expectedResult []*taskInfo, stage pb.Stage) {
for i := range resp.Sources {
resp.Sources[i].SubTaskStatus[0].Stage = stage
}
expectedResult[0].TaskStatus = stage.String()
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
}
-func (t *testCtlMaster) TestWrapTaskResult(c *check.C) {
+func TestWrapTaskResult(t *testing.T) {
resp := new(pb.QueryStatusListResponse)
resp.Result = true
@@ -86,7 +78,7 @@ func (t *testCtlMaster) TestWrapTaskResult(c *check.C) {
TaskStatus: stageError + " - Some error occurred in subtask" + extraInfo,
Sources: []string{"mysql-replica-01", "mysql-replica-02", "mysql-replica-03"},
}}
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// Should return error when subtask unit is "Sync" while relay status is not running
resp.Sources[2].SubTaskStatus[0].Result = nil
resp.Sources[0].SubTaskStatus[0].Unit = pb.UnitType_Sync
@@ -98,31 +90,31 @@ func (t *testCtlMaster) TestWrapTaskResult(c *check.C) {
},
}
expectedResult[0].TaskStatus = stageError + " - Relay status is " + stageError + extraInfo
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// relay status is Paused
resp.Sources[0].SourceStatus.RelayStatus = &pb.RelayStatus{Stage: pb.Stage_Paused}
expectedResult[0].TaskStatus = stageError + " - Relay status is " + pb.Stage_Paused.String() + extraInfo
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// relay status is Stopped
resp.Sources[0].SourceStatus.RelayStatus = &pb.RelayStatus{Stage: pb.Stage_Stopped}
expectedResult[0].TaskStatus = stageError + " - Relay status is " + pb.Stage_Stopped.String() + extraInfo
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// one subtask is paused and no error occurs, should return paused
resp.Sources[2].SubTaskStatus[0].Result = nil
resp.Sources[0].SubTaskStatus[0].Unit = 0
resp.Sources[0].SourceStatus.RelayStatus = nil
expectedResult[0].TaskStatus = pb.Stage_Paused.String()
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// All subtasks are Finished/Stopped/.../New
stageArray := []pb.Stage{pb.Stage_Finished, pb.Stage_Stopped, pb.Stage_Paused, pb.Stage_Running, pb.Stage_New}
for _, stage := range stageArray {
- subTestSameSubTaskStatus(c, resp, expectedResult, stage)
+ subTestSameSubTaskStatus(t, resp, expectedResult, stage)
}
// All subtasks are New except the last one(which is Finished)
resp.Sources[2].SubTaskStatus[0].Stage = pb.Stage_Finished
expectedResult[0].TaskStatus = pb.Stage_Running.String()
- generateAndCheckTaskResult(c, resp, expectedResult)
+ generateAndCheckTaskResult(t, resp, expectedResult)
// test situation with two tasks
resp.Sources = append(resp.Sources, &pb.QueryStatusResponse{
@@ -137,8 +129,8 @@ func (t *testCtlMaster) TestWrapTaskResult(c *check.C) {
}},
})
result, hasFalseResult := wrapTaskResult(resp)
- c.Assert(hasFalseResult, check.IsFalse)
- c.Assert(result.Tasks, check.HasLen, 2)
+ require.False(t, hasFalseResult)
+ require.Len(t, result.Tasks, 2)
if result.Tasks[0].TaskName == "test2" {
result.Tasks[0], result.Tasks[1] = result.Tasks[1], result.Tasks[0]
}
@@ -154,18 +146,18 @@ func (t *testCtlMaster) TestWrapTaskResult(c *check.C) {
Sources: []string{"mysql-replica-04"},
},
}
- c.Assert(result.Tasks, check.DeepEquals, expectedResult)
+ require.Equal(t, expectedResult, result.Tasks)
resp.Result = false
_, hasFalseResult = wrapTaskResult(resp)
- c.Assert(hasFalseResult, check.IsTrue)
+ require.True(t, hasFalseResult)
resp.Result = true
resp.Sources[0].Result = false
_, hasFalseResult = wrapTaskResult(resp)
- c.Assert(hasFalseResult, check.IsTrue)
+ require.True(t, hasFalseResult)
resp.Sources[0].Result = true
_, hasFalseResult = wrapTaskResult(resp)
- c.Assert(hasFalseResult, check.IsFalse)
+ require.False(t, hasFalseResult)
}
diff --git a/dm/dumpling/dumpling_test.go b/dm/dumpling/dumpling_test.go
index 52d40367d7..ed13e3ab49 100644
--- a/dm/dumpling/dumpling_test.go
+++ b/dm/dumpling/dumpling_test.go
@@ -20,7 +20,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
"github.com/docker/go-units"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
"github.com/pingcap/tidb/dumpling/export"
"github.com/pingcap/tidb/pkg/util/filter"
@@ -34,25 +33,25 @@ import (
"github.com/pingcap/tiflow/engine/pkg/promutil"
"github.com/prometheus/client_golang/prometheus"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
)
-var _ = check.Suite(&testDumplingSuite{})
-
const (
testDumplingSchemaName = "INFORMATION_SCHEMA"
testDumplingTableName = "TABLES"
)
func TestSuite(t *testing.T) {
- check.TestingT(t)
+ suite.Run(t, new(testDumplingSuite))
}
type testDumplingSuite struct {
+ suite.Suite
cfg *config.SubTaskConfig
}
-func (t *testDumplingSuite) SetUpSuite(c *check.C) {
- dir := c.MkDir()
+func (t *testDumplingSuite) SetupSuite() {
+ dir := t.T().TempDir()
t.cfg = &config.SubTaskConfig{
Name: "dumpling_ut",
Timezone: "UTC",
@@ -68,68 +67,68 @@ func (t *testDumplingSuite) SetUpSuite(c *check.C) {
}},
},
}
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+ t.Require().NoError(log.InitLogger(&log.Config{}))
}
-func (t *testDumplingSuite) TestDumpling(c *check.C) {
+func (t *testDumplingSuite) TestDumpling() {
dumpling := NewDumpling(t.cfg)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
err := dumpling.Init(ctx)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
resultCh := make(chan pb.ProcessResult, 1)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessNoError", `return(true)`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessNoError", `return(true)`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessNoError")
dumpling.Process(ctx, resultCh)
- c.Assert(len(resultCh), check.Equals, 1)
+ t.Require().Equal(1, len(resultCh))
result := <-resultCh
- c.Assert(result.IsCanceled, check.IsFalse)
- c.Assert(len(result.Errors), check.Equals, 0)
+ t.Require().False(result.IsCanceled)
+ t.Require().Equal(0, len(result.Errors))
//nolint:errcheck
failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessNoError")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError", `return("unknown error")`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError", `return("unknown error")`))
// nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError")
// return error
dumpling.Process(ctx, resultCh)
- c.Assert(len(resultCh), check.Equals, 1)
+ t.Require().Equal(1, len(resultCh))
result = <-resultCh
- c.Assert(result.IsCanceled, check.IsFalse)
- c.Assert(len(result.Errors), check.Equals, 1)
- c.Assert(result.Errors[0].Message, check.Equals, "unknown error")
+ t.Require().False(result.IsCanceled)
+ t.Require().Equal(1, len(result.Errors))
+ t.Require().Equal("unknown error", result.Errors[0].Message)
// nolint:errcheck
failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError")
// cancel
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessCancel", `return("unknown error")`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessCancel", `return("unknown error")`))
// nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessCancel")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever", `return(true)`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever", `return(true)`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever")
ctx2, cancel2 := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel2()
dumpling.Process(ctx2, resultCh)
- c.Assert(len(resultCh), check.Equals, 1)
+ t.Require().Equal(1, len(resultCh))
result = <-resultCh
- c.Assert(result.IsCanceled, check.IsTrue)
- c.Assert(len(result.Errors), check.Equals, 1)
- c.Assert(result.Errors[0].String(), check.Matches, ".*context deadline exceeded.*")
+ t.Require().True(result.IsCanceled)
+ t.Require().Equal(1, len(result.Errors))
+ t.Require().Regexp(".*context deadline exceeded.*", result.Errors[0].String())
}
-func (t *testDumplingSuite) TestDefaultConfig(c *check.C) {
+func (t *testDumplingSuite) TestDefaultConfig() {
dumpling := NewDumpling(t.cfg)
ctx := context.Background()
- c.Assert(dumpling.Init(ctx), check.IsNil)
- c.Assert(dumpling.dumpConfig.StatementSize, check.Not(check.Equals), export.UnspecifiedSize)
- c.Assert(dumpling.dumpConfig.Rows, check.Not(check.Equals), export.UnspecifiedSize)
+ t.Require().NoError(dumpling.Init(ctx))
+ t.Require().NotEqual(export.UnspecifiedSize, dumpling.dumpConfig.StatementSize)
+ t.Require().NotEqual(export.UnspecifiedSize, dumpling.dumpConfig.Rows)
}
func TestCallStatus(t *testing.T) {
@@ -170,7 +169,7 @@ func TestCallStatus(t *testing.T) {
require.Equal(t, s.Bps, int64(0))
}
-func (t *testDumplingSuite) TestParseArgsWontOverwrite(c *check.C) {
+func (t *testDumplingSuite) TestParseArgsWontOverwrite() {
cfg := &config.SubTaskConfig{
Timezone: "UTC",
}
@@ -184,22 +183,22 @@ func (t *testDumplingSuite) TestParseArgsWontOverwrite(c *check.C) {
d := NewDumpling(cfg)
exportCfg, err := d.constructArgs(context.Background())
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
- c.Assert(exportCfg.StatementSize, check.Equals, uint64(4000))
- c.Assert(exportCfg.FileSize, check.Equals, uint64(1*units.MiB))
+ t.Require().Equal(uint64(4000), exportCfg.StatementSize)
+ t.Require().Equal(uint64(1*units.MiB), exportCfg.FileSize)
f, err2 := tfilter.ParseMySQLReplicationRules(rules)
- c.Assert(err2, check.IsNil)
- c.Assert(exportCfg.TableFilter, check.DeepEquals, tfilter.CaseInsensitive(f))
+ t.Require().NoError(err2)
+ t.Require().Equal(tfilter.CaseInsensitive(f), exportCfg.TableFilter)
- c.Assert(exportCfg.Consistency, check.Equals, "lock")
+ t.Require().Equal("lock", exportCfg.Consistency)
}
-func (t *testDumplingSuite) TestConstructArgs(c *check.C) {
+func (t *testDumplingSuite) TestConstructArgs() {
ctx := context.Background()
- mock := conn.InitMockDB(c)
+ mock := conn.InitMockDB(t.T())
mock.ExpectQuery("SELECT cast\\(TIMEDIFF\\(NOW\\(6\\), UTC_TIMESTAMP\\(6\\)\\) as time\\);").
WillReturnRows(sqlmock.NewRows([]string{""}).AddRow("01:00:00"))
@@ -207,13 +206,13 @@ func (t *testDumplingSuite) TestConstructArgs(c *check.C) {
cfg.ExtraArgs = `--statement-size=100 --where "t>10" --threads 8 -F 50B`
d := NewDumpling(cfg)
exportCfg, err := d.constructArgs(ctx)
- c.Assert(err, check.IsNil)
- c.Assert(exportCfg.StatementSize, check.Equals, uint64(100))
- c.Assert(exportCfg.Where, check.Equals, "t>10")
- c.Assert(exportCfg.Threads, check.Equals, 8)
- c.Assert(exportCfg.FileSize, check.Equals, uint64(50))
- c.Assert(exportCfg.SessionParams, check.NotNil)
- c.Assert(exportCfg.SessionParams["time_zone"], check.Equals, "+01:00")
+ t.Require().NoError(err)
+ t.Require().Equal(uint64(100), exportCfg.StatementSize)
+ t.Require().Equal("t>10", exportCfg.Where)
+ t.Require().Equal(8, exportCfg.Threads)
+ t.Require().Equal(uint64(50), exportCfg.FileSize)
+ t.Require().NotNil(exportCfg.SessionParams)
+ t.Require().Equal("+01:00", exportCfg.SessionParams["time_zone"])
}
func genDumpCfg(t *testing.T) *config.SubTaskConfig {
diff --git a/dm/loader/checkpoint_test.go b/dm/loader/checkpoint_test.go
index 61d6a7758b..b2df6ec653 100644
--- a/dm/loader/checkpoint_test.go
+++ b/dm/loader/checkpoint_test.go
@@ -17,26 +17,30 @@ import (
"context"
"database/sql"
"fmt"
+ "testing"
"github.com/DATA-DOG/go-sqlmock"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config/dbconfig"
"github.com/pingcap/tiflow/dm/pkg/conn"
"github.com/pingcap/tiflow/dm/pkg/log"
+ "github.com/stretchr/testify/suite"
)
-var _ = check.Suite(&lightningCpListSuite{})
-
type lightningCpListSuite struct {
+ suite.Suite
mock sqlmock.Sqlmock
cpList *LightningCheckpointList
}
-func (s *lightningCpListSuite) SetUpTest(c *check.C) {
- s.mock = conn.InitMockDB(c)
+func TestLightningCpListSuite(t *testing.T) {
+ suite.Run(t, new(lightningCpListSuite))
+}
+
+func (s *lightningCpListSuite) SetupTest() {
+ s.mock = conn.InitMockDB(s.T())
baseDB, err := conn.GetDownstreamDB(&dbconfig.DBConfig{})
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
metaSchema := "dm_meta"
cpList := NewLightningCheckpointList(baseDB, "test_lightning", "source1", metaSchema, log.L())
@@ -44,11 +48,11 @@ func (s *lightningCpListSuite) SetUpTest(c *check.C) {
s.cpList = cpList
}
-func (s *lightningCpListSuite) TearDownTest(c *check.C) {
- c.Assert(s.mock.ExpectationsWereMet(), check.IsNil)
+func (s *lightningCpListSuite) TearDownTest() {
+ s.Require().NoError(s.mock.ExpectationsWereMet())
}
-func (s *lightningCpListSuite) TestLightningCheckpointListPrepare(c *check.C) {
+func (s *lightningCpListSuite) TestLightningCheckpointListPrepare() {
ctx := context.Background()
s.mock.ExpectBegin()
s.mock.ExpectExec(fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS %s.*", s.cpList.schema)).WillReturnResult(sqlmock.NewResult(1, 1))
@@ -57,44 +61,44 @@ func (s *lightningCpListSuite) TestLightningCheckpointListPrepare(c *check.C) {
s.mock.ExpectExec(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.*", s.cpList.tableName)).WillReturnResult(sqlmock.NewResult(1, 1))
s.mock.ExpectCommit()
err := s.cpList.Prepare(ctx)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *lightningCpListSuite) TestLightningCheckpointListStatusInit(c *check.C) {
+func (s *lightningCpListSuite) TestLightningCheckpointListStatusInit() {
// no rows in target table, will return default status
s.mock.ExpectQuery(fmt.Sprintf("SELECT status FROM %s WHERE `task_name` = \\? AND `source_name` = \\?", s.cpList.tableName)).
WithArgs(s.cpList.taskName, s.cpList.sourceName).
WillReturnRows(sqlmock.NewRows([]string{"status"}).RowError(0, sql.ErrNoRows))
status, err := s.cpList.taskStatus(context.Background())
- c.Assert(err, check.IsNil)
- c.Assert(status, check.Equals, lightningStatusInit)
+ s.Require().NoError(err)
+ s.Require().Equal(lightningStatusInit, status)
}
-func (s *lightningCpListSuite) TestLightningCheckpointListStatusRunning(c *check.C) {
+func (s *lightningCpListSuite) TestLightningCheckpointListStatusRunning() {
s.mock.ExpectQuery(fmt.Sprintf("SELECT status FROM %s WHERE `task_name` = \\? AND `source_name` = \\?", s.cpList.tableName)).
WithArgs(s.cpList.taskName, s.cpList.sourceName).
WillReturnRows(sqlmock.NewRows([]string{"status"}).AddRow("running"))
status, err := s.cpList.taskStatus(context.Background())
- c.Assert(err, check.IsNil)
- c.Assert(status, check.Equals, lightningStatusRunning)
+ s.Require().NoError(err)
+ s.Require().Equal(lightningStatusRunning, status)
}
-func (s *lightningCpListSuite) TestLightningCheckpointListRegister(c *check.C) {
+func (s *lightningCpListSuite) TestLightningCheckpointListRegister() {
s.mock.ExpectBegin()
s.mock.ExpectExec(fmt.Sprintf("INSERT IGNORE INTO %s \\(`task_name`, `source_name`\\) VALUES \\(\\?, \\?\\)", s.cpList.tableName)).
WithArgs(s.cpList.taskName, s.cpList.sourceName).
WillReturnResult(sqlmock.NewResult(2, 1))
s.mock.ExpectCommit()
err := s.cpList.RegisterCheckPoint(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *lightningCpListSuite) TestLightningCheckpointListUpdateStatus(c *check.C) {
+func (s *lightningCpListSuite) TestLightningCheckpointListUpdateStatus() {
s.mock.ExpectBegin()
s.mock.ExpectExec(fmt.Sprintf("UPDATE %s set status = \\? WHERE `task_name` = \\? AND `source_name` = \\?", s.cpList.tableName)).
WithArgs("running", s.cpList.taskName, s.cpList.sourceName).
WillReturnResult(sqlmock.NewResult(3, 1))
s.mock.ExpectCommit()
err := s.cpList.UpdateStatus(context.Background(), lightningStatusRunning)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
diff --git a/dm/master/agent_pool_test.go b/dm/master/agent_pool_test.go
index b4d1d2bb57..449d36da0c 100644
--- a/dm/master/agent_pool_test.go
+++ b/dm/master/agent_pool_test.go
@@ -16,16 +16,14 @@ package master
import (
"context"
"time"
-
- "github.com/pingcap/check"
)
-func (t *testMaster) TestAgentPool(c *check.C) {
- t.testPool(c)
- t.testEmit(c)
+func (t *testMaster) TestAgentPool() {
+ t.testPool()
+ t.testEmit()
}
-func (t *testMaster) testPool(c *check.C) {
+func (t *testMaster) testPool() {
var (
rate = 10
burst = 100
@@ -43,26 +41,26 @@ func (t *testMaster) testPool(c *check.C) {
for i := 0; i < burst; i++ {
agent := <-pc
- c.Assert(agent.ID, check.Equals, i)
+ t.Require().Equal(i, agent.ID)
}
select {
case <-pc:
- c.Error("should not get agent now")
+ t.T().Error("should not get agent now")
default:
}
for i := 0; i < rate; i++ {
select {
case agent := <-pc:
- c.Assert(agent.ID, check.Equals, i+burst)
+ t.Require().Equal(i+burst, agent.ID)
case <-time.After(time.Millisecond * 200):
// add 100ms time drift here
- c.Error("get agent timeout")
+ t.T().Error("get agent timeout")
}
}
}
-func (t *testMaster) testEmit(c *check.C) {
+func (t *testMaster) testEmit() {
type testWorkerType int
var (
@@ -75,23 +73,23 @@ func (t *testMaster) testEmit(c *check.C) {
ap.Emit(context.Background(), 1, func(args ...interface{}) {
if len(args) != 2 {
- c.Fatalf("args count is not 2, args %v", args)
+ t.T().Fatalf("args count is not 2, args %v", args)
}
id1, ok := args[0].(string)
if !ok {
- c.Fatalf("args[0] is not id, args %+v", args)
+ t.T().Fatalf("args[0] is not id, args %+v", args)
}
if id != id1 {
- c.Fatalf("args[0] is expected id, args[0] %s vs %s", id1, id)
+ t.T().Fatalf("args[0] is expected id, args[0] %s vs %s", id1, id)
}
worker1, ok := args[1].(testWorkerType)
if !ok {
- c.Fatalf("args[1] is not worker client, args %+v", args)
+ t.T().Fatalf("args[1] is not worker client, args %+v", args)
}
if worker1 != worker {
- c.Fatalf("args[1] is not expected worker, args[1] %v vs %v", worker1, worker)
+ t.T().Fatalf("args[1] is not expected worker, args[1] %v vs %v", worker1, worker)
}
}, func(args ...interface{}) {}, []interface{}{id, worker}...)
@@ -99,16 +97,16 @@ func (t *testMaster) testEmit(c *check.C) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
ap.Emit(ctx, 1, func(args ...interface{}) {
- c.FailNow()
+ t.T().FailNow()
}, func(args ...interface{}) {
if len(args) != 1 {
- c.Fatalf("args count is not 1, args %v", args)
+ t.T().Fatalf("args count is not 1, args %v", args)
}
pCounter, ok := args[0].(*int)
if !ok {
- c.Fatalf("args[0] is not *int, args %+v", args)
+ t.T().Fatalf("args[0] is not *int, args %+v", args)
}
*pCounter++
}, []interface{}{&counter}...)
- c.Assert(counter, check.Equals, 1)
+ t.Require().Equal(1, counter)
}
diff --git a/dm/master/bootstrap_test.go b/dm/master/bootstrap_test.go
index eedc1cfb4e..c9b0b740a8 100644
--- a/dm/master/bootstrap_test.go
+++ b/dm/master/bootstrap_test.go
@@ -23,7 +23,6 @@ import (
"time"
"github.com/golang/mock/gomock"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/master/workerrpc"
"github.com/pingcap/tiflow/dm/pb"
@@ -33,41 +32,34 @@ import (
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
filter "github.com/pingcap/tiflow/pkg/binlog-filter"
+ "github.com/stretchr/testify/suite"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
type testMaster struct {
+ suite.Suite
+
workerClients map[string]workerrpc.Client
saveMaxRetryNum int
electionTTLBackup int
- testT *testing.T
testEtcdCluster *integration.ClusterV3
etcdTestCli *clientv3.Client
}
-var testSuite = check.SerialSuites(&testMaster{})
-
func TestMaster(t *testing.T) {
- err := log.InitLogger(&log.Config{})
- if err != nil {
- t.Fatal(err)
- }
- pwd, err = os.Getwd()
- if err != nil {
- t.Fatal(err)
- }
- integration.BeforeTestExternal(t)
- // inject *testing.T to testMaster
- s := testSuite.(*testMaster)
- s.testT = t
-
- check.TestingT(t)
+ suite.Run(t, new(testMaster))
+ suite.Run(t, new(testEtcdSuite))
+ suite.Run(t, new(testConfigSuite))
}
-func (t *testMaster) SetUpSuite(c *check.C) {
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+func (t *testMaster) SetupSuite() {
+ t.Require().NoError(log.InitLogger(&log.Config{}))
+ var err error
+ pwd, err = os.Getwd()
+ t.Require().NoError(err)
+ integration.BeforeTestExternal(t.T())
t.workerClients = make(map[string]workerrpc.Client)
t.saveMaxRetryNum = maxRetryNum
t.electionTTLBackup = electionTTL
@@ -76,43 +68,31 @@ func (t *testMaster) SetUpSuite(c *check.C) {
checkAndAdjustSourceConfigForDMCtlFunc = checkAndNoAdjustSourceConfigMock
}
-func (t *testMaster) TearDownSuite(c *check.C) {
+func (t *testMaster) TearDownSuite() {
maxRetryNum = t.saveMaxRetryNum
electionTTL = t.electionTTLBackup
checkAndAdjustSourceConfigForDMCtlFunc = checkAndAdjustSourceConfig
}
-func (t *testMaster) SetUpTest(c *check.C) {
- t.testEtcdCluster = integration.NewClusterV3(t.testT, &integration.ClusterConfig{Size: 1})
+func (t *testMaster) SetupTest() {
+ t.testEtcdCluster = integration.NewClusterV3(t.T(), &integration.ClusterConfig{Size: 1})
t.etcdTestCli = t.testEtcdCluster.RandClient()
- t.clearEtcdEnv(c)
+ t.clearEtcdEnv()
}
-func (t *testMaster) TearDownTest(c *check.C) {
- t.clearEtcdEnv(c)
- t.testEtcdCluster.Terminate(t.testT)
+func (t *testMaster) TearDownTest() {
+ t.clearEtcdEnv()
+ t.testEtcdCluster.Terminate(t.T())
}
-func (t *testMaster) clearEtcdEnv(c *check.C) {
- c.Assert(ha.ClearTestInfoOperation(t.etcdTestCli), check.IsNil)
-}
-
-func testDefaultMasterServerWithC(c *check.C) *Server {
- cfg := NewConfig()
- err := cfg.FromContent(SampleConfig)
- c.Assert(err, check.IsNil)
- cfg.DataDir = c.MkDir()
- server := NewServer(cfg)
- server.leader.Store(oneselfLeader)
- go server.ap.Start(context.Background())
-
- return server
+func (t *testMaster) clearEtcdEnv() {
+ t.Require().NoError(ha.ClearTestInfoOperation(t.etcdTestCli))
}
-func (t *testMaster) TestCollectSourceConfigFilesV1Import(c *check.C) {
- s := testDefaultMasterServerWithC(c)
+func (t *testMaster) TestCollectSourceConfigFilesV1Import() {
+ s := testDefaultMasterServer(t.T())
defer s.Close()
- s.cfg.V1SourcesPath = c.MkDir()
+ s.cfg.V1SourcesPath = t.T().TempDir()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -121,8 +101,8 @@ func (t *testMaster) TestCollectSourceConfigFilesV1Import(c *check.C) {
// no source file exist.
cfgs, err := s.collectSourceConfigFilesV1Import(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cfgs, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(cfgs, 0)
host := os.Getenv("MYSQL_HOST")
if host == "" {
@@ -139,7 +119,7 @@ func (t *testMaster) TestCollectSourceConfigFilesV1Import(c *check.C) {
password := os.Getenv("MYSQL_PSWD")
cfg1, err := config.SourceCfgFromYaml(config.SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// fix empty map after marshal/unmarshal becomes nil
cfg1.From.Adjust()
cfg1.Tracer = map[string]interface{}{}
@@ -149,36 +129,36 @@ func (t *testMaster) TestCollectSourceConfigFilesV1Import(c *check.C) {
cfg1.From.User = user
cfg1.From.Password = password
cfg1.RelayDir = "relay-dir"
- c.Assert(checkAndAdjustSourceConfigForDMCtlFunc(ctx, cfg1), check.IsNil) // adjust source config.
+ t.Require().NoError(checkAndAdjustSourceConfigForDMCtlFunc(ctx, cfg1)) // adjust source config.
cfg2 := cfg1.Clone()
cfg2.SourceID = "mysql-replica-02"
// write into source files.
data1, err := cfg1.Yaml()
- c.Assert(err, check.IsNil)
- c.Assert(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "source1.yaml"), []byte(data1), 0o644), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "source1.yaml"), []byte(data1), 0o644))
data2, err := cfg2.Yaml()
- c.Assert(err, check.IsNil)
- c.Assert(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "source2.yaml"), []byte(data2), 0o644), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "source2.yaml"), []byte(data2), 0o644))
// collect again, two configs exist.
cfgs, err = s.collectSourceConfigFilesV1Import(tctx)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
for _, cfg := range cfgs {
cfg.From.Session = nil
}
- c.Assert(cfgs, check.HasLen, 2)
- c.Assert(cfgs[cfg1.SourceID], check.DeepEquals, cfg1)
- c.Assert(cfgs[cfg2.SourceID], check.DeepEquals, cfg2)
+ t.Require().Len(cfgs, 2)
+ t.Require().Equal(cfg1, cfgs[cfg1.SourceID])
+ t.Require().Equal(cfg2, cfgs[cfg2.SourceID])
// put a invalid source file.
- c.Assert(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "invalid.yaml"), []byte("invalid-source-data"), 0o644), check.IsNil)
+ t.Require().NoError(os.WriteFile(filepath.Join(s.cfg.V1SourcesPath, "invalid.yaml"), []byte("invalid-source-data"), 0o644))
cfgs, err = s.collectSourceConfigFilesV1Import(tctx)
- c.Assert(terror.ErrConfigYamlTransform.Equal(err), check.IsTrue)
- c.Assert(cfgs, check.HasLen, 0)
+ t.Require().True(terror.ErrConfigYamlTransform.Equal(err))
+ t.Require().Len(cfgs, 0)
}
-func (t *testMaster) TestWaitWorkersReadyV1Import(c *check.C) {
+func (t *testMaster) TestWaitWorkersReadyV1Import() {
oldWaitWorkerV1Timeout := waitWorkerV1Timeout
defer func() {
waitWorkerV1Timeout = oldWaitWorkerV1Timeout
@@ -190,13 +170,13 @@ func (t *testMaster) TestWaitWorkersReadyV1Import(c *check.C) {
tctx := tcontext.NewContext(ctx, log.L())
- s := testDefaultMasterServerWithC(c)
+ s := testDefaultMasterServer(t.T())
defer s.Close()
- s.cfg.V1SourcesPath = c.MkDir()
- c.Assert(s.scheduler.Start(ctx, t.etcdTestCli), check.IsNil)
+ s.cfg.V1SourcesPath = t.T().TempDir()
+ t.Require().NoError(s.scheduler.Start(ctx, t.etcdTestCli))
cfg1, err := config.SourceCfgFromYaml(config.SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg2 := cfg1.Clone()
cfg2.SourceID = "mysql-replica-02"
cfgs := map[string]*config.SourceConfig{
@@ -206,7 +186,8 @@ func (t *testMaster) TestWaitWorkersReadyV1Import(c *check.C) {
// no worker registered, timeout.
err = s.waitWorkersReadyV1Import(tctx, cfgs)
- c.Assert(err, check.ErrorMatches, ".*wait for DM-worker instances timeout.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*wait for DM-worker instances timeout.*", err.Error())
// register one worker.
req1 := &pb.RegisterWorkerRequest{
@@ -214,12 +195,13 @@ func (t *testMaster) TestWaitWorkersReadyV1Import(c *check.C) {
Address: "127.0.0.1:8262",
}
resp1, err := s.RegisterWorker(ctx, req1)
- c.Assert(err, check.IsNil)
- c.Assert(resp1.Result, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(resp1.Result)
// still timeout because no enough workers.
err = s.waitWorkersReadyV1Import(tctx, cfgs)
- c.Assert(err, check.ErrorMatches, ".*wait for DM-worker instances timeout.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*wait for DM-worker instances timeout.*", err.Error())
// register another worker.
go func() {
@@ -229,15 +211,15 @@ func (t *testMaster) TestWaitWorkersReadyV1Import(c *check.C) {
Address: "127.0.0.1:8263",
}
resp2, err2 := s.RegisterWorker(ctx, req2)
- c.Assert(err2, check.IsNil)
- c.Assert(resp2.Result, check.IsTrue)
+ t.Require().NoError(err2)
+ t.Require().True(resp2.Result)
}()
err = s.waitWorkersReadyV1Import(tctx, cfgs)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
-func (t *testMaster) TestSubtaskCfgsStagesV1Import(c *check.C) {
+func (t *testMaster) TestSubtaskCfgsStagesV1Import() {
var (
worker1Name = "worker-1"
worker1Addr = "127.0.0.1:8262"
@@ -250,60 +232,60 @@ func (t *testMaster) TestSubtaskCfgsStagesV1Import(c *check.C) {
)
cfg11 := config.NewSubTaskConfig()
- c.Assert(cfg11.Decode(config.SampleSubtaskConfig, true), check.IsNil)
+ t.Require().NoError(cfg11.Decode(config.SampleSubtaskConfig, true))
cfg11.Dir = "./dump_data"
cfg11.ChunkFilesize = "64"
cfg11.Name = taskName1
cfg11.SourceID = sourceID1
- c.Assert(cfg11.Adjust(true), check.IsNil) // adjust again after manually modified some items.
+ t.Require().NoError(cfg11.Adjust(true)) // adjust again after manually modified some items.
data11, err := cfg11.Toml()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
data11 = strings.ReplaceAll(data11, `chunk-filesize = "64"`, `chunk-filesize = 64`) // different type between v1.0.x and v2.0.x.
cfg12, err := cfg11.Clone()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg12.SourceID = sourceID2
data12, err := cfg12.Toml()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
data12 = strings.ReplaceAll(data12, `chunk-filesize = "64"`, `chunk-filesize = 64`)
cfg21, err := cfg11.Clone()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg21.Dir = "./dump_data"
cfg21.Name = taskName2
- c.Assert(cfg21.Adjust(true), check.IsNil)
+ t.Require().NoError(cfg21.Adjust(true))
data21, err := cfg21.Toml()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
data21 = strings.ReplaceAll(data21, `chunk-filesize = "64"`, `chunk-filesize = 64`)
cfg22, err := cfg21.Clone()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg22.SourceID = sourceID2
data22, err := cfg22.Toml()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
data22 = strings.ReplaceAll(data22, `chunk-filesize = "64"`, `chunk-filesize = 64`)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
tctx := tcontext.NewContext(ctx, log.L())
- s := testDefaultMasterServerWithC(c)
+ s := testDefaultMasterServer(t.T())
defer s.Close()
- s.cfg.V1SourcesPath = c.MkDir()
- c.Assert(s.scheduler.Start(ctx, t.etcdTestCli), check.IsNil)
+ s.cfg.V1SourcesPath = t.T().TempDir()
+ t.Require().NoError(s.scheduler.Start(ctx, t.etcdTestCli))
// no workers exist, no config and status need to get.
cfgs, stages, err := s.getSubtaskCfgsStagesV1Import(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cfgs, check.HasLen, 0)
- c.Assert(stages, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(cfgs, 0)
+ t.Require().Len(stages, 0)
- ctrl := gomock.NewController(c)
+ ctrl := gomock.NewController(t.T())
defer ctrl.Finish()
mockWCli1 := pbmock.NewMockWorkerClient(ctrl)
mockWCli2 := pbmock.NewMockWorkerClient(ctrl)
- c.Assert(s.scheduler.AddWorker(worker1Name, worker1Addr), check.IsNil)
- c.Assert(s.scheduler.AddWorker(worker2Name, worker2Addr), check.IsNil)
+ t.Require().NoError(s.scheduler.AddWorker(worker1Name, worker1Addr))
+ t.Require().NoError(s.scheduler.AddWorker(worker2Name, worker2Addr))
s.scheduler.SetWorkerClientForTest(worker1Name, newMockRPCClient(mockWCli1))
s.scheduler.SetWorkerClientForTest(worker2Name, newMockRPCClient(mockWCli2))
@@ -355,21 +337,21 @@ func (t *testMaster) TestSubtaskCfgsStagesV1Import(c *check.C) {
// all workers return valid config and stage.
cfgs, stages, err = s.getSubtaskCfgsStagesV1Import(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cfgs, check.HasLen, 2)
- c.Assert(stages, check.HasLen, 2)
- c.Assert(cfgs[taskName1], check.HasLen, 2)
- c.Assert(cfgs[taskName2], check.HasLen, 2)
- c.Assert(cfgs[taskName1][sourceID1], check.DeepEquals, *cfg11)
- c.Assert(cfgs[taskName1][sourceID2], check.DeepEquals, *cfg12)
- c.Assert(cfgs[taskName2][sourceID1], check.DeepEquals, *cfg21)
- c.Assert(cfgs[taskName2][sourceID2], check.DeepEquals, *cfg22)
- c.Assert(stages[taskName1], check.HasLen, 2)
- c.Assert(stages[taskName2], check.HasLen, 2)
- c.Assert(stages[taskName1][sourceID1], check.Equals, pb.Stage_Running)
- c.Assert(stages[taskName1][sourceID2], check.Equals, pb.Stage_Running)
- c.Assert(stages[taskName2][sourceID1], check.Equals, pb.Stage_Paused)
- c.Assert(stages[taskName2][sourceID2], check.Equals, pb.Stage_Running)
+ t.Require().NoError(err)
+ t.Require().Len(cfgs, 2)
+ t.Require().Len(stages, 2)
+ t.Require().Len(cfgs[taskName1], 2)
+ t.Require().Len(cfgs[taskName2], 2)
+ t.Require().Equal(*cfg11, cfgs[taskName1][sourceID1])
+ t.Require().Equal(*cfg12, cfgs[taskName1][sourceID2])
+ t.Require().Equal(*cfg21, cfgs[taskName2][sourceID1])
+ t.Require().Equal(*cfg22, cfgs[taskName2][sourceID2])
+ t.Require().Len(stages[taskName1], 2)
+ t.Require().Len(stages[taskName2], 2)
+ t.Require().Equal(pb.Stage_Running, stages[taskName1][sourceID1])
+ t.Require().Equal(pb.Stage_Running, stages[taskName1][sourceID2])
+ t.Require().Equal(pb.Stage_Paused, stages[taskName2][sourceID1])
+ t.Require().Equal(pb.Stage_Running, stages[taskName2][sourceID2])
// one of workers return invalid config.
mockWCli1.EXPECT().OperateV1Meta(
@@ -417,9 +399,10 @@ func (t *testMaster) TestSubtaskCfgsStagesV1Import(c *check.C) {
},
}, nil)
cfgs, stages, err = s.getSubtaskCfgsStagesV1Import(tctx)
- c.Assert(err, check.ErrorMatches, ".*fail to get subtask config and stage.*")
- c.Assert(cfgs, check.HasLen, 0)
- c.Assert(stages, check.HasLen, 0)
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to get subtask config and stage.*", err.Error())
+ t.Require().Len(cfgs, 0)
+ t.Require().Len(stages, 0)
}
func checkAndNoAdjustSourceConfigMock(ctx context.Context, cfg *config.SourceConfig) error {
diff --git a/dm/master/config_test.go b/dm/master/config_test.go
index b71587ad12..a4e475e117 100644
--- a/dm/master/config_test.go
+++ b/dm/master/config_test.go
@@ -26,33 +26,34 @@ import (
"testing"
capturer "github.com/kami-zh/go-capturer"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"go.etcd.io/etcd/server/v3/embed"
)
-var _ = check.Suite(&testConfigSuite{})
-
-type testConfigSuite struct{}
+type testConfigSuite struct {
+ suite.Suite
+}
-func (t *testConfigSuite) SetUpSuite(c *check.C) {
+func (t *testConfigSuite) SetupSuite() {
// initialized the logger to make genEmbedEtcdConfig working.
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+ t.Require().NoError(log.InitLogger(&log.Config{}))
}
-func (t *testConfigSuite) TestPrintSampleConfig(c *check.C) {
+func (t *testConfigSuite) TestPrintSampleConfig() {
// test print sample config
out := capturer.CaptureStdout(func() {
cfg := NewConfig()
err := cfg.Parse([]string{"-print-sample-config"})
- c.Assert(err, check.ErrorMatches, flag.ErrHelp.Error())
+ t.Require().Error(err)
+ t.Require().Regexp(flag.ErrHelp.Error(), err.Error())
})
- c.Assert(strings.TrimSpace(out), check.Equals, strings.TrimSpace(SampleConfig))
+ t.Require().Equal(strings.TrimSpace(SampleConfig), strings.TrimSpace(out))
}
-func (t *testConfigSuite) TestConfig(c *check.C) {
+func (t *testConfigSuite) TestConfig() {
var (
err error
cfg = &Config{}
@@ -81,106 +82,110 @@ func (t *testConfigSuite) TestConfig(c *check.C) {
)
err = cfg.FromContent(SampleConfig)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = cfg.Reload()
- c.Assert(err, check.IsNil)
- c.Assert(cfg.MasterAddr, check.Equals, masterAddr)
+ t.Require().NoError(err)
+ t.Require().Equal(masterAddr, cfg.MasterAddr)
for _, tc := range cases {
cfg = NewConfig()
err = cfg.Parse(tc.args)
if tc.hasError {
- c.Assert(err, check.ErrorMatches, tc.errorReg)
+ t.Require().Error(err)
+ t.Require().Regexp(tc.errorReg, err.Error())
}
}
}
-func (t *testConfigSuite) TestInvalidConfig(c *check.C) {
+func (t *testConfigSuite) TestInvalidConfig() {
var (
err error
cfg = NewConfig()
)
- filepath := path.Join(c.MkDir(), "test_invalid_config.toml")
+ filepath := path.Join(t.T().TempDir(), "test_invalid_config.toml")
// field still remain undecoded in config will cause verify failed
configContent := []byte(`
master-addr = ":8261"
advertise-addr = "127.0.0.1:8261"
aaa = "xxx"`)
err = os.WriteFile(filepath, configContent, 0o644)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = cfg.configFromFile(filepath)
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, "*master config contained unknown configuration options: aaa.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*master config contained unknown configuration options: aaa.*", err.Error())
// invalid `master-addr`
- filepath2 := path.Join(c.MkDir(), "test_invalid_config.toml")
+ filepath2 := path.Join(t.T().TempDir(), "test_invalid_config.toml")
configContent2 := []byte(`master-addr = ""`)
err = os.WriteFile(filepath2, configContent2, 0o644)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = cfg.configFromFile(filepath2)
- c.Assert(err, check.IsNil)
- c.Assert(terror.ErrMasterHostPortNotValid.Equal(cfg.adjust()), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(terror.ErrMasterHostPortNotValid.Equal(cfg.adjust()))
}
-func (t *testConfigSuite) TestGenEmbedEtcdConfig(c *check.C) {
+func (t *testConfigSuite) TestGenEmbedEtcdConfig() {
hostname, err := os.Hostname()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg1 := NewConfig()
cfg1.MasterAddr = ":8261"
cfg1.AdvertiseAddr = "127.0.0.1:8261"
cfg1.InitialClusterState = embed.ClusterStateFlagExisting
- c.Assert(cfg1.adjust(), check.IsNil)
+ t.Require().NoError(cfg1.adjust())
etcdCfg, err := cfg1.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(err, check.IsNil)
- c.Assert(etcdCfg.Name, check.Equals, fmt.Sprintf("dm-master-%s", hostname))
- c.Assert(etcdCfg.Dir, check.Equals, fmt.Sprintf("default.%s", etcdCfg.Name))
- c.Assert(etcdCfg.ListenClientUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "0.0.0.0:8261"}})
- c.Assert(etcdCfg.AdvertiseClientUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "127.0.0.1:8261"}})
- c.Assert(etcdCfg.ListenPeerUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "127.0.0.1:8291"}})
- c.Assert(etcdCfg.AdvertisePeerUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "127.0.0.1:8291"}})
- c.Assert(etcdCfg.InitialCluster, check.DeepEquals, fmt.Sprintf("dm-master-%s=http://127.0.0.1:8291", hostname))
- c.Assert(etcdCfg.ClusterState, check.Equals, embed.ClusterStateFlagExisting)
- c.Assert(etcdCfg.AutoCompactionMode, check.Equals, "periodic")
- c.Assert(etcdCfg.AutoCompactionRetention, check.Equals, "1h")
- c.Assert(etcdCfg.QuotaBackendBytes, check.Equals, int64(2*1024*1024*1024))
+ t.Require().NoError(err)
+ t.Require().Equal(fmt.Sprintf("dm-master-%s", hostname), etcdCfg.Name)
+ t.Require().Equal(fmt.Sprintf("default.%s", etcdCfg.Name), etcdCfg.Dir)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "0.0.0.0:8261"}}, etcdCfg.ListenClientUrls)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "127.0.0.1:8261"}}, etcdCfg.AdvertiseClientUrls)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "127.0.0.1:8291"}}, etcdCfg.ListenPeerUrls)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "127.0.0.1:8291"}}, etcdCfg.AdvertisePeerUrls)
+ t.Require().Equal(fmt.Sprintf("dm-master-%s=http://127.0.0.1:8291", hostname), etcdCfg.InitialCluster)
+ t.Require().Equal(embed.ClusterStateFlagExisting, etcdCfg.ClusterState)
+ t.Require().Equal("periodic", etcdCfg.AutoCompactionMode)
+ t.Require().Equal("1h", etcdCfg.AutoCompactionRetention)
+ t.Require().Equal(int64(2*1024*1024*1024), etcdCfg.QuotaBackendBytes)
cfg2 := *cfg1
cfg2.MasterAddr = "127.0.0.1\n:8261"
cfg2.AdvertiseAddr = "127.0.0.1:8261"
_, err = cfg2.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, "(?m).*invalid master-addr.*")
+ t.Require().True(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp("(?m).*invalid master-addr.*", err.Error())
cfg2.MasterAddr = "172.100.8.8:8261"
cfg2.AdvertiseAddr = "172.100.8.8:8261"
etcdCfg, err = cfg2.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(err, check.IsNil)
- c.Assert(etcdCfg.ListenClientUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "172.100.8.8:8261"}})
- c.Assert(etcdCfg.AdvertiseClientUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "172.100.8.8:8261"}})
+ t.Require().NoError(err)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "172.100.8.8:8261"}}, etcdCfg.ListenClientUrls)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "172.100.8.8:8261"}}, etcdCfg.AdvertiseClientUrls)
cfg3 := *cfg1
cfg3.PeerUrls = "127.0.0.1:\n8291"
_, err = cfg3.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, "(?m).*invalid peer-urls.*")
+ t.Require().True(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp("(?m).*invalid peer-urls.*", err.Error())
cfg3.PeerUrls = "http://172.100.8.8:8291"
etcdCfg, err = cfg3.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(err, check.IsNil)
- c.Assert(etcdCfg.ListenPeerUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "172.100.8.8:8291"}})
+ t.Require().NoError(err)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "172.100.8.8:8291"}}, etcdCfg.ListenPeerUrls)
cfg4 := *cfg1
cfg4.AdvertisePeerUrls = "127.0.0.1:\n8291"
_, err = cfg4.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, "(?m).*invalid advertise-peer-urls.*")
+ t.Require().True(terror.ErrMasterGenEmbedEtcdConfigFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp("(?m).*invalid advertise-peer-urls.*", err.Error())
cfg4.AdvertisePeerUrls = "http://172.100.8.8:8291"
etcdCfg, err = cfg4.genEmbedEtcdConfig(embed.NewConfig())
- c.Assert(err, check.IsNil)
- c.Assert(etcdCfg.AdvertisePeerUrls, check.DeepEquals, []url.URL{{Scheme: "http", Host: "172.100.8.8:8291"}})
+ t.Require().NoError(err)
+ t.Require().Equal([]url.URL{{Scheme: "http", Host: "172.100.8.8:8291"}}, etcdCfg.AdvertisePeerUrls)
}
-func (t *testConfigSuite) TestParseURLs(c *check.C) {
+func (t *testConfigSuite) TestParseURLs() {
cases := []struct {
str string
urls []url.URL
@@ -245,59 +250,59 @@ func (t *testConfigSuite) TestParseURLs(c *check.C) {
}
for _, cs := range cases {
- c.Logf("raw string %s", cs.str)
+ t.T().Logf("raw string %s", cs.str)
urls, err := parseURLs(cs.str)
if cs.hasErr {
- c.Assert(terror.ErrMasterParseURLFail.Equal(err), check.IsTrue)
+ t.Require().True(terror.ErrMasterParseURLFail.Equal(err))
} else {
- c.Assert(err, check.IsNil)
- c.Assert(urls, check.DeepEquals, cs.urls)
+ t.Require().NoError(err)
+ t.Require().Equal(cs.urls, urls)
}
}
}
-func (t *testConfigSuite) TestAdjustAddr(c *check.C) {
+func (t *testConfigSuite) TestAdjustAddr() {
cfg := NewConfig()
- c.Assert(cfg.FromContent(SampleConfig), check.IsNil)
- c.Assert(cfg.adjust(), check.IsNil)
+ t.Require().NoError(cfg.FromContent(SampleConfig))
+ t.Require().NoError(cfg.adjust())
// invalid `advertise-addr`
cfg.AdvertiseAddr = "127.0.0.1"
- c.Assert(terror.ErrMasterAdvertiseAddrNotValid.Equal(cfg.adjust()), check.IsTrue)
+ t.Require().True(terror.ErrMasterAdvertiseAddrNotValid.Equal(cfg.adjust()))
cfg.AdvertiseAddr = "0.0.0.0:8261"
- c.Assert(terror.ErrMasterAdvertiseAddrNotValid.Equal(cfg.adjust()), check.IsTrue)
+ t.Require().True(terror.ErrMasterAdvertiseAddrNotValid.Equal(cfg.adjust()))
// clear `advertise-addr`, still invalid because no `host` in `master-addr`.
cfg.AdvertiseAddr = ""
- c.Assert(terror.ErrMasterHostPortNotValid.Equal(cfg.adjust()), check.IsTrue)
+ t.Require().True(terror.ErrMasterHostPortNotValid.Equal(cfg.adjust()))
cfg.MasterAddr = "127.0.0.1:8261"
- c.Assert(cfg.adjust(), check.IsNil)
- c.Assert(cfg.AdvertiseAddr, check.Equals, cfg.MasterAddr)
+ t.Require().NoError(cfg.adjust())
+ t.Require().Equal(cfg.MasterAddr, cfg.AdvertiseAddr)
}
-func (t *testConfigSuite) TestAdjustOpenAPI(c *check.C) {
+func (t *testConfigSuite) TestAdjustOpenAPI() {
cfg := NewConfig()
- c.Assert(cfg.FromContent(SampleConfig), check.IsNil)
- c.Assert(cfg.adjust(), check.IsNil)
+ t.Require().NoError(cfg.FromContent(SampleConfig))
+ t.Require().NoError(cfg.adjust())
// test default value
- c.Assert(cfg.OpenAPI, check.Equals, false)
- c.Assert(cfg.ExperimentalFeatures.OpenAPI, check.Equals, false)
+ t.Require().Equal(false, cfg.OpenAPI)
+ t.Require().Equal(false, cfg.ExperimentalFeatures.OpenAPI)
// adjust openapi from experimental-features
cfg.ExperimentalFeatures.OpenAPI = true
- c.Assert(cfg.adjust(), check.IsNil)
- c.Assert(cfg.OpenAPI, check.Equals, true)
- c.Assert(cfg.ExperimentalFeatures.OpenAPI, check.Equals, false)
+ t.Require().NoError(cfg.adjust())
+ t.Require().Equal(true, cfg.OpenAPI)
+ t.Require().Equal(false, cfg.ExperimentalFeatures.OpenAPI)
// test from flags
- c.Assert(cfg.Parse([]string{"--openapi=false", "--master-addr=127.0.0.1:8261"}), check.IsNil)
- c.Assert(cfg.adjust(), check.IsNil)
- c.Assert(cfg.OpenAPI, check.Equals, false)
- c.Assert(cfg.Parse([]string{"--openapi=true", "--master-addr=127.0.0.1:8261"}), check.IsNil)
- c.Assert(cfg.adjust(), check.IsNil)
- c.Assert(cfg.OpenAPI, check.Equals, true)
+ t.Require().NoError(cfg.Parse([]string{"--openapi=false", "--master-addr=127.0.0.1:8261"}))
+ t.Require().NoError(cfg.adjust())
+ t.Require().Equal(false, cfg.OpenAPI)
+ t.Require().NoError(cfg.Parse([]string{"--openapi=true", "--master-addr=127.0.0.1:8261"}))
+ t.Require().NoError(cfg.adjust())
+ t.Require().Equal(true, cfg.OpenAPI)
}
func TestAdjustSecretKeyPath(t *testing.T) {
diff --git a/dm/master/etcd_test.go b/dm/master/etcd_test.go
index 2987612e33..6344ab6173 100644
--- a/dm/master/etcd_test.go
+++ b/dm/master/etcd_test.go
@@ -22,66 +22,66 @@ import (
"strings"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/suite"
"github.com/tikv/pd/pkg/utils/tempurl"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed"
)
-var _ = check.Suite(&testEtcdSuite{})
-
-type testEtcdSuite struct{}
+type testEtcdSuite struct {
+ suite.Suite
+}
-func (t *testEtcdSuite) SetUpSuite(c *check.C) {
+func (t *testEtcdSuite) SetupSuite() {
// initialized the logger to make genEmbedEtcdConfig working.
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+ t.Require().NoError(log.InitLogger(&log.Config{}))
}
-func (t *testEtcdSuite) TestStartEtcdFail(c *check.C) {
+func (t *testEtcdSuite) TestStartEtcdFail() {
cfgCluster := NewConfig()
cfgCluster.Name = "dm-master-1"
- cfgCluster.DataDir = c.MkDir()
+ cfgCluster.DataDir = t.T().TempDir()
cfgCluster.MasterAddr = tempurl.Alloc()[len("http://"):]
cfgCluster.PeerUrls = tempurl.Alloc()
- c.Assert(cfgCluster.adjust(), check.IsNil)
+ t.Require().NoError(cfgCluster.adjust())
// add another non-existing member for bootstrapping.
cfgCluster.InitialCluster = fmt.Sprintf("%s=%s,%s=%s",
cfgCluster.Name, cfgCluster.AdvertisePeerUrls,
"dm-master-2", tempurl.Alloc())
- c.Assert(cfgCluster.adjust(), check.IsNil)
+ t.Require().NoError(cfgCluster.adjust())
// start an etcd cluster
cfgClusterEtcd := genEmbedEtcdConfigWithLogger("info")
cfgClusterEtcd, err := cfgCluster.genEmbedEtcdConfig(cfgClusterEtcd)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
e, err := startEtcd(cfgClusterEtcd, nil, nil, 3*time.Second)
- c.Assert(terror.ErrMasterStartEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(e, check.IsNil)
+ t.Require().True(terror.ErrMasterStartEmbedEtcdFail.Equal(err))
+ t.Require().Nil(e)
}
-func (t *testEtcdSuite) TestPrepareJoinEtcd(c *check.C) {
+func (t *testEtcdSuite) TestPrepareJoinEtcd() {
cfgCluster := NewConfig() // used to start an etcd cluster
cfgCluster.Name = "dm-master-1"
- cfgCluster.DataDir = c.MkDir()
+ cfgCluster.DataDir = t.T().TempDir()
cfgCluster.MasterAddr = tempurl.Alloc()[len("http://"):]
cfgCluster.AdvertiseAddr = cfgCluster.MasterAddr
cfgCluster.PeerUrls = tempurl.Alloc()
- c.Assert(cfgCluster.adjust(), check.IsNil)
+ t.Require().NoError(cfgCluster.adjust())
cfgClusterEtcd := genEmbedEtcdConfigWithLogger("info")
cfgClusterEtcd, err := cfgCluster.genEmbedEtcdConfig(cfgClusterEtcd)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfgBefore := t.cloneConfig(cfgCluster) // before `prepareJoinEtcd` applied
- cfgBefore.DataDir = c.MkDir() // overwrite some config items
+ cfgBefore.DataDir = t.T().TempDir() // overwrite some config items
cfgBefore.MasterAddr = tempurl.Alloc()[len("http://"):]
cfgBefore.AdvertiseAddr = cfgBefore.MasterAddr
cfgBefore.PeerUrls = tempurl.Alloc()
cfgBefore.AdvertisePeerUrls = cfgBefore.PeerUrls
- c.Assert(cfgBefore.adjust(), check.IsNil)
+ t.Require().NoError(cfgBefore.adjust())
cfgAfter := t.cloneConfig(cfgBefore) // after `prepareJoinEtcd applied
@@ -90,54 +90,57 @@ func (t *testEtcdSuite) TestPrepareJoinEtcd(c *check.C) {
memberDP := filepath.Join(cfgBefore.DataDir, "member")
// not set `join`, do nothing
- c.Assert(prepareJoinEtcd(cfgAfter), check.IsNil)
- c.Assert(cfgAfter, check.DeepEquals, cfgBefore)
+ t.Require().NoError(prepareJoinEtcd(cfgAfter))
+ t.Require().Equal(cfgBefore, cfgAfter)
// try to join self
cfgAfter.Join = cfgAfter.MasterAddr
err = prepareJoinEtcd(cfgAfter)
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*fail to join embed etcd: join self.*is forbidden.*")
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to join embed etcd: join self.*is forbidden.*", err.Error())
// update `join` to a valid item
cfgBefore.Join = joinCluster
// join with persistent data
- c.Assert(os.WriteFile(joinFP, []byte(joinCluster), privateDirMode), check.IsNil)
+ t.Require().NoError(os.WriteFile(joinFP, []byte(joinCluster), privateDirMode))
cfgAfter = t.cloneConfig(cfgBefore)
- c.Assert(prepareJoinEtcd(cfgAfter), check.IsNil)
- c.Assert(cfgAfter.InitialCluster, check.Equals, joinCluster)
- c.Assert(cfgAfter.InitialClusterState, check.Equals, embed.ClusterStateFlagExisting)
- c.Assert(os.Remove(joinFP), check.IsNil) // remove the persistent data
+ t.Require().NoError(prepareJoinEtcd(cfgAfter))
+ t.Require().Equal(joinCluster, cfgAfter.InitialCluster)
+ t.Require().Equal(embed.ClusterStateFlagExisting, cfgAfter.InitialClusterState)
+ t.Require().NoError(os.Remove(joinFP)) // remove the persistent data
// join with invalid persistent data
- c.Assert(os.Mkdir(joinFP, privateDirMode), check.IsNil) // use directory as invalid persistent data (file)
+ t.Require().NoError(os.Mkdir(joinFP, privateDirMode)) // use directory as invalid persistent data (file)
cfgAfter = t.cloneConfig(cfgBefore)
err = prepareJoinEtcd(cfgAfter)
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*fail to join embed etcd: read persistent join data.*")
- c.Assert(os.Remove(joinFP), check.IsNil) // remove the persistent data
- c.Assert(cfgAfter, check.DeepEquals, cfgBefore) // not changed
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to join embed etcd: read persistent join data.*", err.Error())
+ t.Require().NoError(os.Remove(joinFP)) // remove the persistent data
+ t.Require().Equal(cfgBefore, cfgAfter) // not changed
// restart with previous data
- c.Assert(os.Mkdir(memberDP, privateDirMode), check.IsNil)
- c.Assert(os.Mkdir(filepath.Join(memberDP, "wal"), privateDirMode), check.IsNil)
- c.Assert(prepareJoinEtcd(cfgAfter), check.IsNil)
- c.Assert(cfgAfter.InitialCluster, check.Equals, "")
- c.Assert(cfgAfter.InitialClusterState, check.Equals, embed.ClusterStateFlagExisting)
- c.Assert(os.RemoveAll(memberDP), check.IsNil) // remove previous data
+ t.Require().NoError(os.Mkdir(memberDP, privateDirMode))
+ t.Require().NoError(os.Mkdir(filepath.Join(memberDP, "wal"), privateDirMode))
+ t.Require().NoError(prepareJoinEtcd(cfgAfter))
+ t.Require().Equal("", cfgAfter.InitialCluster)
+ t.Require().Equal(embed.ClusterStateFlagExisting, cfgAfter.InitialClusterState)
+ t.Require().NoError(os.RemoveAll(memberDP)) // remove previous data
// start an etcd cluster
e1, err := startEtcd(cfgClusterEtcd, nil, nil, etcdStartTimeout)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e1.Close()
// same `name`, duplicate
cfgAfter = t.cloneConfig(cfgBefore)
err = prepareJoinEtcd(cfgAfter)
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*fail to join embed etcd: missing data or joining a duplicate member.*")
- c.Assert(cfgAfter, check.DeepEquals, cfgBefore) // not changed
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to join embed etcd: missing data or joining a duplicate member.*", err.Error())
+ t.Require().Equal(cfgBefore, cfgAfter) // not changed
// set a different name
cfgBefore.Name = "dm-master-2"
@@ -146,13 +149,14 @@ func (t *testEtcdSuite) TestPrepareJoinEtcd(c *check.C) {
cfgAfter = t.cloneConfig(cfgBefore)
cfgAfter.AdvertisePeerUrls = "invalid-advertise-peer-urls"
err = prepareJoinEtcd(cfgAfter)
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*fail to join embed etcd: add member.*")
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to join embed etcd: add member.*", err.Error())
// join with existing cluster
cfgAfter = t.cloneConfig(cfgBefore)
- c.Assert(prepareJoinEtcd(cfgAfter), check.IsNil)
- c.Assert(cfgAfter.InitialClusterState, check.Equals, embed.ClusterStateFlagExisting)
+ t.Require().NoError(prepareJoinEtcd(cfgAfter))
+ t.Require().Equal(embed.ClusterStateFlagExisting, cfgAfter.InitialClusterState)
obtainClusters := strings.Split(cfgAfter.InitialCluster, ",")
sort.Strings(obtainClusters)
expectedClusters := []string{
@@ -160,31 +164,32 @@ func (t *testEtcdSuite) TestPrepareJoinEtcd(c *check.C) {
fmt.Sprintf("%s=%s", cfgAfter.Name, cfgAfter.PeerUrls),
}
sort.Strings(expectedClusters)
- c.Assert(obtainClusters, check.DeepEquals, expectedClusters)
+ t.Require().Equal(expectedClusters, obtainClusters)
// join data should exist now
joinData, err := os.ReadFile(joinFP)
- c.Assert(err, check.IsNil)
- c.Assert(string(joinData), check.Equals, cfgAfter.InitialCluster)
+ t.Require().NoError(err)
+ t.Require().Equal(cfgAfter.InitialCluster, string(joinData))
// prepare join done, but has not start the etcd to complete the join, can not join anymore.
cfgAfter2 := t.cloneConfig(cfgBefore)
cfgAfter2.Name = "dm-master-3" // overwrite some items
- cfgAfter2.DataDir = c.MkDir()
+ cfgAfter2.DataDir = t.T().TempDir()
cfgAfter2.MasterAddr = tempurl.Alloc()[len("http://"):]
cfgAfter2.AdvertiseAddr = cfgAfter2.MasterAddr
cfgAfter2.PeerUrls = tempurl.Alloc()
cfgAfter2.AdvertisePeerUrls = cfgAfter2.PeerUrls
err = prepareJoinEtcd(cfgAfter2)
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*context deadline exceeded.*")
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*context deadline exceeded.*", err.Error())
// start the joining etcd
cfgAfterEtcd := genEmbedEtcdConfigWithLogger("info")
cfgAfterEtcd, err = cfgAfter.genEmbedEtcdConfig(cfgAfterEtcd)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
e2, err := startEtcd(cfgAfterEtcd, nil, nil, etcdStartTimeout)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e2.Close()
// try join again
@@ -194,11 +199,12 @@ func (t *testEtcdSuite) TestPrepareJoinEtcd(c *check.C) {
break
}
// for `etcdserver: unhealthy cluster`, try again later
- c.Assert(terror.ErrMasterJoinEmbedEtcdFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*fail to join embed etcd: add member.*: etcdserver: unhealthy cluster.*")
+ t.Require().True(terror.ErrMasterJoinEmbedEtcdFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*fail to join embed etcd: add member.*: etcdserver: unhealthy cluster.*", err.Error())
time.Sleep(500 * time.Millisecond)
}
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
func (t *testEtcdSuite) cloneConfig(cfg *Config) *Config {
@@ -207,54 +213,55 @@ func (t *testEtcdSuite) cloneConfig(cfg *Config) *Config {
return clone
}
-func (t *testEtcdSuite) TestIsDirExist(c *check.C) {
+func (t *testEtcdSuite) TestIsDirExist() {
d := "./directory-not-exists"
- c.Assert(isDirExist(d), check.IsFalse)
+ t.Require().False(isDirExist(d))
// empty directory
- d = c.MkDir()
- c.Assert(isDirExist(d), check.IsTrue)
+ d = t.T().TempDir()
+ t.Require().True(isDirExist(d))
// data exists in the directory
for i := 1; i <= 3; i++ {
fp := filepath.Join(d, fmt.Sprintf("file.%d", i))
- c.Assert(os.WriteFile(fp, nil, privateDirMode), check.IsNil)
- c.Assert(isDirExist(d), check.IsTrue)
- c.Assert(isDirExist(fp), check.IsFalse) // not a directory
+ t.Require().NoError(os.WriteFile(fp, nil, privateDirMode))
+ t.Require().True(isDirExist(d))
+ t.Require().False(isDirExist(fp)) // not a directory
}
}
-func (t *testEtcdSuite) TestEtcdAutoCompaction(c *check.C) {
+func (t *testEtcdSuite) TestEtcdAutoCompaction() {
cfg := NewConfig()
- c.Assert(cfg.FromContent(SampleConfig), check.IsNil)
+ t.Require().NoError(cfg.FromContent(SampleConfig))
- cfg.DataDir = c.MkDir()
+ cfg.DataDir = t.T().TempDir()
cfg.MasterAddr = tempurl.Alloc()[len("http://"):]
cfg.AdvertiseAddr = cfg.MasterAddr
cfg.AutoCompactionRetention = "1s"
ctx, cancel := context.WithCancel(context.Background())
s := NewServer(cfg)
- c.Assert(s.Start(ctx), check.IsNil)
+ t.Require().NoError(s.Start(ctx))
etcdCli, err := clientv3.New(clientv3.Config{
Endpoints: []string{cfg.MasterAddr},
})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
for i := 0; i < 100; i++ {
_, err = etcdCli.Put(ctx, "key", fmt.Sprintf("%03d", i))
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
time.Sleep(3 * time.Second)
resp, err := etcdCli.Get(ctx, "key")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
utils.WaitSomething(10, time.Second, func() bool {
_, err = etcdCli.Get(ctx, "key", clientv3.WithRev(resp.Header.Revision-1))
return err != nil
})
- c.Assert(err, check.ErrorMatches, ".*required revision has been compacted.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*required revision has been compacted.*", err.Error())
cancel()
s.Close()
diff --git a/dm/master/workerrpc/workerrpc_test.go b/dm/master/workerrpc/workerrpc_test.go
index c4f60f86d8..441aa958cc 100644
--- a/dm/master/workerrpc/workerrpc_test.go
+++ b/dm/master/workerrpc/workerrpc_test.go
@@ -19,36 +19,28 @@ import (
"time"
"github.com/golang/mock/gomock"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/config/security"
"github.com/pingcap/tiflow/dm/pb"
"github.com/pingcap/tiflow/dm/pbmock"
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
"github.com/tikv/pd/pkg/utils/tempurl"
)
-var _ = check.Suite(&testWorkerRPCSuite{})
-
-type testWorkerRPCSuite struct{}
-
-func TestWorkerRPC(t *testing.T) {
- check.TestingT(t)
-}
-
-func (t *testWorkerRPCSuite) TestGRPCClient(c *check.C) {
+func TestGRPCClient(t *testing.T) {
timeout := 3 * time.Second
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
- ctrl := gomock.NewController(c)
+ ctrl := gomock.NewController(t)
defer ctrl.Finish()
// get a random address for DM-worker
addr := tempurl.Alloc()[len("http://"):]
// NOTE: we don't wait for the gRPC connection establish now, in other words no need to wait for the DM-worker instance become online.
rpcCli, err := NewGRPCClient(addr, security.Security{})
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// replace the underlying DM-worker client.
workerCli := pbmock.NewMockWorkerClient(ctrl)
@@ -91,25 +83,25 @@ OUTER:
if req.Type == cmd {
// supported cmd
_, err = rpcCli.SendRequest(ctx, req, timeout)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
continue OUTER
}
}
_, err = rpcCli.SendRequest(ctx, &Request{Type: cmd}, timeout)
- c.Assert(terror.ErrMasterGRPCInvalidReqType.Equal(err), check.IsTrue)
+ require.True(t, terror.ErrMasterGRPCInvalidReqType.Equal(err))
}
// got an error from the underlying RPC.
err2 := errors.New("mock error")
workerCli.EXPECT().QueryStatus(gomock.Any(), reqs[0].QueryStatus).Return(nil, err2)
_, err = rpcCli.SendRequest(ctx, reqs[0], timeout)
- c.Assert(terror.ErrMasterGRPCRequestError.Equal(err), check.IsTrue)
- c.Assert(errors.Cause(err), check.Equals, err2)
+ require.True(t, terror.ErrMasterGRPCRequestError.Equal(err))
+ require.Equal(t, err2, errors.Cause(err))
// close the cli.
- c.Assert(rpcCli.Close(), check.IsNil)
+ require.NoError(t, rpcCli.Close())
// can't send request any more.
_, err = rpcCli.SendRequest(ctx, reqs[0], timeout)
- c.Assert(terror.ErrMasterGRPCSendOnCloseConn.Equal(err), check.IsTrue)
+ require.True(t, terror.ErrMasterGRPCSendOnCloseConn.Equal(err))
}
diff --git a/dm/openapi/logger_test.go b/dm/openapi/logger_test.go
index 13adf646fc..d49970ea37 100644
--- a/dm/openapi/logger_test.go
+++ b/dm/openapi/logger_test.go
@@ -19,20 +19,12 @@ import (
"testing"
"github.com/gin-gonic/gin"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
"go.uber.org/zap"
"go.uber.org/zap/zaptest/observer"
)
-var _ = check.Suite(&zapLoggerSuite{})
-
-type zapLoggerSuite struct{}
-
func TestZapLogger(t *testing.T) {
- check.TestingT(t)
-}
-
-func (t *zapLoggerSuite) TestZapLogger(c *check.C) {
r := gin.New()
obs, logs := observer.New(zap.DebugLevel)
logger := zap.New(obs)
@@ -46,14 +38,14 @@ func (t *zapLoggerSuite) TestZapLogger(c *check.C) {
r.ServeHTTP(res, req)
logFields := logs.All()[0].ContextMap()
- c.Assert(logFields["method"], check.Equals, "GET")
- c.Assert(logFields["request"], check.Equals, "GET /something")
- c.Assert(logFields["status"], check.Equals, int64(200))
- c.Assert(logFields["duration"], check.NotNil)
- c.Assert(logFields["host"], check.NotNil)
- c.Assert(logFields["protocol"], check.NotNil)
- c.Assert(logFields["remote_ip"], check.NotNil)
- c.Assert(logFields["user_agent"], check.NotNil)
- c.Assert(logFields["request"], check.NotNil)
- c.Assert(logFields["error"], check.IsNil)
+ require.Equal(t, "GET", logFields["method"])
+ require.Equal(t, "GET /something", logFields["request"])
+ require.Equal(t, int64(200), logFields["status"])
+ require.NotNil(t, logFields["duration"])
+ require.NotNil(t, logFields["host"])
+ require.NotNil(t, logFields["protocol"])
+ require.NotNil(t, logFields["remote_ip"])
+ require.NotNil(t, logFields["user_agent"])
+ require.NotNil(t, logFields["request"])
+ require.Nil(t, logFields["error"])
}
diff --git a/dm/openapi/swaggerui_test.go b/dm/openapi/swaggerui_test.go
index 3216312041..225ec858f2 100644
--- a/dm/openapi/swaggerui_test.go
+++ b/dm/openapi/swaggerui_test.go
@@ -17,19 +17,11 @@ import (
"strings"
"testing"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&swaggerUISuite{})
-
-type swaggerUISuite struct{}
-
-func TestNewSwaggerDocUI(t *testing.T) {
- check.TestingT(t)
-}
-
-func (t *swaggerUISuite) TestGetSwaggerHTML(c *check.C) {
+func TestGetSwaggerHTML(t *testing.T) {
html, err := GetSwaggerHTML(NewSwaggerConfig("/api/v1/docs/dm.json", ""))
- c.Assert(err, check.IsNil)
- c.Assert(strings.Contains(html, "API documentation"), check.Equals, true)
+ require.NoError(t, err)
+ require.Equal(t, true, strings.Contains(html, "API documentation"))
}
diff --git a/dm/openapi/task_test.go b/dm/openapi/task_test.go
index 5b208e10bf..b0de3a2dca 100644
--- a/dm/openapi/task_test.go
+++ b/dm/openapi/task_test.go
@@ -16,26 +16,18 @@ package openapi
import (
"testing"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&taskSuite{})
-
-type taskSuite struct{}
-
-func TestTask(t *testing.T) {
- check.TestingT(t)
-}
-
-func (t *taskSuite) TestTaskAdjust(c *check.C) {
+func TestTaskAdjust(t *testing.T) {
meta := "test"
// test no error
task1 := &Task{MetaSchema: &meta, OnDuplicate: TaskOnDuplicateError}
- c.Assert(task1.Adjust(), check.IsNil)
- c.Assert(*task1.MetaSchema, check.Equals, meta)
+ require.NoError(t, task1.Adjust())
+ require.Equal(t, meta, *task1.MetaSchema)
// test default meta
task3 := &Task{OnDuplicate: TaskOnDuplicateError}
- c.Assert(task3.Adjust(), check.IsNil)
- c.Assert(*task3.MetaSchema, check.Equals, defaultMetaSchema)
+ require.NoError(t, task3.Adjust())
+ require.Equal(t, defaultMetaSchema, *task3.MetaSchema)
}
diff --git a/dm/pkg/checker/privilege_test.go b/dm/pkg/checker/privilege_test.go
index 710059c09b..3858da85ff 100644
--- a/dm/pkg/checker/privilege_test.go
+++ b/dm/pkg/checker/privilege_test.go
@@ -16,20 +16,11 @@ package checker
import (
"testing"
- tc "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser/mysql"
"github.com/pingcap/tidb/pkg/util/filter"
"github.com/stretchr/testify/require"
)
-func TestClient(t *testing.T) {
- tc.TestingT(t)
-}
-
-var _ = tc.Suite(&testCheckSuite{})
-
-type testCheckSuite struct{}
-
func TestVerifyDumpPrivileges(t *testing.T) {
cases := []struct {
grants []string
diff --git a/dm/pkg/conn/mockdb.go b/dm/pkg/conn/mockdb.go
index 1288e8e1c7..0d6f017d51 100644
--- a/dm/pkg/conn/mockdb.go
+++ b/dm/pkg/conn/mockdb.go
@@ -22,7 +22,6 @@ import (
"time"
"github.com/DATA-DOG/go-sqlmock"
- check "github.com/pingcap/check"
tidbConfig "github.com/pingcap/tidb/pkg/config"
"github.com/pingcap/tidb/pkg/domain"
"github.com/pingcap/tidb/pkg/kv"
@@ -30,6 +29,7 @@ import (
"github.com/pingcap/tidb/pkg/session"
"github.com/pingcap/tidb/pkg/sessionctx/vardef"
"github.com/pingcap/tidb/pkg/store/mockstore"
+ "github.com/stretchr/testify/require"
"github.com/tikv/client-go/v2/testutils"
)
@@ -59,9 +59,9 @@ func (d *mockDBProvider) Apply(config ScopedDBConfig) (*BaseDB, error) {
}
// InitMockDB return a mocked db for unit test.
-func InitMockDB(c *check.C) sqlmock.Sqlmock {
+func InitMockDB(t require.TestingT) sqlmock.Sqlmock {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if mdbp, ok := DefaultDBProvider.(*mockDBProvider); ok {
mdbp.db = db
} else {
diff --git a/dm/pkg/election/election_test.go b/dm/pkg/election/election_test.go
index 8934a558d8..c79c891fd4 100644
--- a/dm/pkg/election/election_test.go
+++ b/dm/pkg/election/election_test.go
@@ -21,49 +21,49 @@ import (
"testing"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/pkg/etcdutil"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/suite"
"github.com/tikv/pd/pkg/utils/tempurl"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed"
)
-var _ = check.SerialSuites(&testElectionSuite{})
-
func TestSuite(t *testing.T) {
- check.TestingT(t)
+ suite.Run(t, new(testElectionSuite))
}
type testElectionSuite struct {
+ suite.Suite
+
etcd *embed.Etcd
endPoint string
notifyBlockTime time.Duration
}
-func (t *testElectionSuite) SetUpTest(c *check.C) {
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+func (t *testElectionSuite) SetupTest() {
+ t.Require().NoError(log.InitLogger(&log.Config{}))
cfg := embed.NewConfig()
cfg.Name = "election-test"
- cfg.Dir = c.MkDir()
+ cfg.Dir = t.T().TempDir()
cfg.ZapLoggerBuilder = embed.NewZapCoreLoggerBuilder(log.L().Logger, log.L().Core(), log.Props().Syncer)
cfg.Logger = "zap"
err := cfg.Validate() // verify & trigger the builder
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
t.endPoint = tempurl.Alloc()
url2, err := url.Parse(t.endPoint)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg.ListenClientUrls = []url.URL{*url2}
cfg.AdvertiseClientUrls = cfg.ListenClientUrls
url2, err = url.Parse(tempurl.Alloc())
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg.ListenPeerUrls = []url.URL{*url2}
cfg.AdvertisePeerUrls = cfg.ListenPeerUrls
@@ -71,22 +71,22 @@ func (t *testElectionSuite) SetUpTest(c *check.C) {
cfg.ClusterState = embed.ClusterStateFlagNew
t.etcd, err = embed.StartEtcd(cfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
select {
case <-t.etcd.Server.ReadyNotify():
case <-time.After(10 * time.Second):
- c.Fatal("start embed etcd timeout")
+ t.T().Fatal("start embed etcd timeout")
}
// some notify leader information is not handled, just reduce the block time and ignore them
t.notifyBlockTime = 100 * time.Millisecond
}
-func (t *testElectionSuite) TearDownTest(c *check.C) {
+func (t *testElectionSuite) TearDownTest() {
t.etcd.Close()
}
-func testElection2After1(t *testElectionSuite, c *check.C, normalExit bool) {
+func (t *testElectionSuite) testElection2After1(normalExit bool) {
var (
timeout = 3 * time.Second
sessionTTL = 60
@@ -99,94 +99,94 @@ func testElection2After1(t *testElectionSuite, c *check.C, normalExit bool) {
addr3 = "127.0.0.1:3"
)
cli, err := etcdutil.CreateClient([]string{t.endPoint}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer cli.Close()
ctx0, cancel0 := context.WithCancel(context.Background())
defer cancel0()
_, err = cli.Delete(ctx0, key, clientv3.WithPrefix())
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ctx1, cancel1 := context.WithCancel(context.Background())
defer cancel1()
if !normalExit {
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/election/mockCampaignLoopExitedAbnormally", `return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/election/mockCampaignLoopExitedAbnormally", `return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/election/mockCampaignLoopExitedAbnormally")
}
e1, err := NewElection(ctx1, cli, sessionTTL, key, ID1, addr1, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e1.Close()
// e1 should become the leader
select {
case leader := <-e1.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e1.IsLeader(), check.IsTrue)
+ t.Require().True(e1.IsLeader())
_, leaderID, leaderAddr, err := e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
if !normalExit {
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/election/mockCampaignLoopExitedAbnormally"), check.IsNil)
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/election/mockCampaignLoopExitedAbnormally"))
}
// start e2
ctx2, cancel2 := context.WithCancel(context.Background())
defer cancel2()
e2, err := NewElection(ctx2, cli, sessionTTL, key, ID2, addr2, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e2.Close()
select {
case leader := <-e2.leaderCh:
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
// but the leader should still be e1
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
- c.Assert(e2.IsLeader(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
+ t.Require().False(e2.IsLeader())
var wg sync.WaitGroup
e1.Close() // stop the campaign for e1
- c.Assert(e1.IsLeader(), check.IsFalse)
+ t.Require().False(e1.IsLeader())
ctx3, cancel3 := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel3()
deleted, err := e2.ClearSessionIfNeeded(ctx3, ID1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
if normalExit {
// for normally exited election, session has already been closed before
- c.Assert(deleted, check.IsFalse)
+ t.Require().False(deleted)
} else {
// for abnormally exited election, session will be cleared here
- c.Assert(deleted, check.IsTrue)
+ t.Require().True(deleted)
}
// e2 should become the leader
select {
case leader := <-e2.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID2)
+ t.Require().Equal(ID2, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e2.IsLeader(), check.IsTrue)
+ t.Require().True(e2.IsLeader())
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e2.ID())
- c.Assert(leaderAddr, check.Equals, addr2)
+ t.Require().NoError(err)
+ t.Require().Equal(e2.ID(), leaderID)
+ t.Require().Equal(addr2, leaderAddr)
// only e2's election info is left in etcd
ctx4, cancel4 := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel4()
resp, err := cli.Get(ctx4, key, clientv3.WithPrefix())
- c.Assert(err, check.IsNil)
- c.Assert(resp.Kvs, check.HasLen, 1)
+ t.Require().NoError(err)
+ t.Require().Len(resp.Kvs, 1)
// if closing the client when campaigning, we should get an error
wg.Add(1)
@@ -194,11 +194,12 @@ func testElection2After1(t *testElectionSuite, c *check.C, normalExit bool) {
defer wg.Done()
select {
case err2 := <-e2.ErrorNotify():
- c.Assert(terror.ErrElectionCampaignFail.Equal(err2), check.IsTrue)
+ t.Require().True(terror.ErrElectionCampaignFail.Equal(err2))
// the old session is done, but we can't create a new one.
- c.Assert(err2, check.ErrorMatches, ".*fail to campaign leader: create a new session.*")
+ t.Require().Error(err2)
+ t.Require().Regexp(".*fail to campaign leader: create a new session.*", err2.Error())
case <-time.After(timeout):
- c.Fatal("do not receive error for e2")
+ t.T().Fatal("do not receive error for e2")
}
}()
cli.Close() // close the client
@@ -208,17 +209,18 @@ func testElection2After1(t *testElectionSuite, c *check.C, normalExit bool) {
ctx5, cancel5 := context.WithCancel(context.Background())
defer cancel5()
_, err = NewElection(ctx5, cli, sessionTTL, key, ID3, addr3, t.notifyBlockTime)
- c.Assert(terror.ErrElectionCampaignFail.Equal(err), check.IsTrue)
- c.Assert(err, check.ErrorMatches, ".*Message: fail to campaign leader: create the initial session, RawCause: context canceled.*")
+ t.Require().True(terror.ErrElectionCampaignFail.Equal(err))
+ t.Require().Error(err)
+ t.Require().Regexp(".*Message: fail to campaign leader: create the initial session, RawCause: context canceled.*", err.Error())
cancel0()
}
-func (t *testElectionSuite) TestElection2After1(c *check.C) {
- testElection2After1(t, c, true)
- testElection2After1(t, c, false)
+func (t *testElectionSuite) TestElection2After1() {
+ t.testElection2After1(true)
+ t.testElection2After1(false)
}
-func (t *testElectionSuite) TestElectionAlways1(c *check.C) {
+func (t *testElectionSuite) TestElectionAlways1() {
var (
timeout = 3 * time.Second
sessionTTL = 60
@@ -229,41 +231,41 @@ func (t *testElectionSuite) TestElectionAlways1(c *check.C) {
addr2 = "127.0.0.1:2345"
)
cli, err := etcdutil.CreateClient([]string{t.endPoint}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer cli.Close()
ctx1, cancel1 := context.WithCancel(context.Background())
defer cancel1()
e1, err := NewElection(ctx1, cli, sessionTTL, key, ID1, addr1, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e1.Close()
// e1 should become the leader
select {
case leader := <-e1.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e1.IsLeader(), check.IsTrue)
+ t.Require().True(e1.IsLeader())
_, leaderID, leaderAddr, err := e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
// start e2
ctx2, cancel2 := context.WithCancel(context.Background())
defer cancel2()
e2, err := NewElection(ctx2, cli, sessionTTL, key, ID2, addr2, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e2.Close()
time.Sleep(100 * time.Millisecond) // wait 100ms to start the campaign
// but the leader should still be e1
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
- c.Assert(e2.IsLeader(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
+ t.Require().False(e2.IsLeader())
// cancel the campaign for e2, should get no errors
var wg sync.WaitGroup
@@ -272,7 +274,7 @@ func (t *testElectionSuite) TestElectionAlways1(c *check.C) {
defer wg.Done()
select {
case err2 := <-e2.ErrorNotify():
- c.Fatalf("cancel the campaign should not get an error, %v", err2)
+ t.T().Fatalf("cancel the campaign should not get an error, %v", err2)
case <-time.After(timeout): // wait 3s
}
}()
@@ -280,15 +282,15 @@ func (t *testElectionSuite) TestElectionAlways1(c *check.C) {
wg.Wait()
// e1 is still the leader
- c.Assert(e1.IsLeader(), check.IsTrue)
+ t.Require().True(e1.IsLeader())
_, leaderID, leaderAddr, err = e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
- c.Assert(e2.IsLeader(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
+ t.Require().False(e2.IsLeader())
}
-func (t *testElectionSuite) TestElectionEvictLeader(c *check.C) {
+func (t *testElectionSuite) TestElectionEvictLeader() {
var (
timeout = 3 * time.Second
sessionTTL = 60
@@ -299,41 +301,41 @@ func (t *testElectionSuite) TestElectionEvictLeader(c *check.C) {
addr2 = "127.0.0.1:2345"
)
cli, err := etcdutil.CreateClient([]string{t.endPoint}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer cli.Close()
ctx1, cancel1 := context.WithCancel(context.Background())
defer cancel1()
e1, err := NewElection(ctx1, cli, sessionTTL, key, ID1, addr1, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e1.Close()
// e1 should become the leader
select {
case leader := <-e1.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e1.IsLeader(), check.IsTrue)
+ t.Require().True(e1.IsLeader())
_, leaderID, leaderAddr, err := e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
// start e2
ctx2, cancel2 := context.WithCancel(context.Background())
defer cancel2()
e2, err := NewElection(ctx2, cli, sessionTTL, key, ID2, addr2, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e2.Close()
time.Sleep(100 * time.Millisecond) // wait 100ms to start the campaign
// but the leader should still be e1
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
- c.Assert(e2.IsLeader(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
+ t.Require().False(e2.IsLeader())
// e1 evict leader, and e2 will be the leader
e1.EvictLeader()
@@ -342,9 +344,9 @@ func (t *testElectionSuite) TestElectionEvictLeader(c *check.C) {
return leaderID == e2.ID()
})
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e2.ID())
- c.Assert(leaderAddr, check.Equals, addr2)
+ t.Require().NoError(err)
+ t.Require().Equal(e2.ID(), leaderID)
+ t.Require().Equal(addr2, leaderAddr)
utils.WaitSomething(10, 10*time.Millisecond, func() bool {
return e2.IsLeader()
})
@@ -357,15 +359,15 @@ func (t *testElectionSuite) TestElectionEvictLeader(c *check.C) {
return leaderID == e1.ID()
})
_, leaderID, leaderAddr, err = e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
utils.WaitSomething(10, 10*time.Millisecond, func() bool {
return e1.IsLeader()
})
}
-func (t *testElectionSuite) TestElectionDeleteKey(c *check.C) {
+func (t *testElectionSuite) TestElectionDeleteKey() {
var (
timeout = 3 * time.Second
sessionTTL = 60
@@ -374,27 +376,27 @@ func (t *testElectionSuite) TestElectionDeleteKey(c *check.C) {
addr = "127.0.0.1:1234"
)
cli, err := etcdutil.CreateClient([]string{t.endPoint}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer cli.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
e, err := NewElection(ctx, cli, sessionTTL, key, ID, addr, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e.Close()
// should become the leader
select {
case leader := <-e.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID)
+ t.Require().Equal(ID, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e.IsLeader(), check.IsTrue)
+ t.Require().True(e.IsLeader())
leaderKey, leaderID, leaderAddr, err := e.LeaderInfo(ctx)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e.ID())
- c.Assert(leaderAddr, check.Equals, addr)
+ t.Require().NoError(err)
+ t.Require().Equal(e.ID(), leaderID)
+ t.Require().Equal(addr, leaderAddr)
// the leader retired after deleted the key
var wg sync.WaitGroup
@@ -403,17 +405,17 @@ func (t *testElectionSuite) TestElectionDeleteKey(c *check.C) {
wg.Done()
select {
case err2 := <-e.ErrorNotify():
- c.Fatalf("delete the leader key should not get an error, %v", err2)
+ t.T().Fatalf("delete the leader key should not get an error, %v", err2)
case leader := <-e.LeaderNotify():
- c.Assert(leader, check.IsNil)
+ t.Require().Nil(leader)
}
}()
_, err = cli.Delete(ctx, leaderKey)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
wg.Wait()
}
-func (t *testElectionSuite) TestElectionSucceedButReturnError(c *check.C) {
+func (t *testElectionSuite) TestElectionSucceedButReturnError() {
var (
timeout = 5 * time.Second
sessionTTL = 60
@@ -424,70 +426,70 @@ func (t *testElectionSuite) TestElectionSucceedButReturnError(c *check.C) {
addr2 = "127.0.0.1:2"
)
cli, err := etcdutil.CreateClient([]string{t.endPoint}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer cli.Close()
ctx1, cancel1 := context.WithCancel(context.Background())
defer cancel1()
e1, err := NewElection(ctx1, cli, sessionTTL, key, ID1, addr1, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e1.Close()
// e1 should become the leader
select {
case leader := <-e1.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
- c.Assert(e1.IsLeader(), check.IsTrue)
+ t.Require().True(e1.IsLeader())
_, leaderID, leaderAddr, err := e1.LeaderInfo(ctx1)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
// start e2
ctx2, cancel2 := context.WithCancel(context.Background())
defer cancel2()
e2, err := NewElection(ctx2, cli, sessionTTL, key, ID2, addr2, t.notifyBlockTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer e2.Close()
select {
case leader := <-e2.leaderCh:
- c.Assert(leader.ID, check.Equals, ID1)
+ t.Require().Equal(ID1, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
// but the leader should still be e1
_, leaderID, leaderAddr, err = e2.LeaderInfo(ctx2)
- c.Assert(err, check.IsNil)
- c.Assert(leaderID, check.Equals, e1.ID())
- c.Assert(leaderAddr, check.Equals, addr1)
- c.Assert(e2.IsLeader(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(e1.ID(), leaderID)
+ t.Require().Equal(addr1, leaderAddr)
+ t.Require().False(e2.IsLeader())
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/election/mockCapaignSucceedButReturnErr", `return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/election/mockCapaignSucceedButReturnErr", `return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/election/mockCapaignSucceedButReturnErr")
e1.Close() // stop the campaign for e1
- c.Assert(e1.IsLeader(), check.IsFalse)
+ t.Require().False(e1.IsLeader())
// e2 should become the leader
select {
case leader := <-e2.LeaderNotify():
- c.Assert(leader.ID, check.Equals, ID2)
+ t.Require().Equal(ID2, leader.ID)
case <-time.After(timeout):
- c.Fatal("leader campaign timeout")
+ t.T().Fatal("leader campaign timeout")
}
// the leader retired after deleted the key
select {
case err2 := <-e2.ErrorNotify():
- c.Fatalf("delete the leader key should not get an error, %v", err2)
+ t.T().Fatalf("delete the leader key should not get an error, %v", err2)
case leader := <-e2.LeaderNotify():
- c.Assert(leader, check.IsNil)
+ t.Require().Nil(leader)
case <-time.After(timeout):
- c.Fatal("leader retire timeout")
+ t.T().Fatal("leader retire timeout")
}
}
diff --git a/dm/pkg/etcdutil/etcdutil_test.go b/dm/pkg/etcdutil/etcdutil_test.go
index de37a5b8ec..0267bf5e0a 100644
--- a/dm/pkg/etcdutil/etcdutil_test.go
+++ b/dm/pkg/etcdutil/etcdutil_test.go
@@ -20,11 +20,11 @@ import (
"testing"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"github.com/tikv/pd/pkg/utils/tempurl"
"go.etcd.io/etcd/api/v3/etcdserverpb"
v3rpc "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
@@ -34,41 +34,36 @@ import (
"go.etcd.io/etcd/tests/v3/integration"
)
-var etcdTestSuite = check.Suite(&testEtcdUtilSuite{})
-
type testEtcdUtilSuite struct {
- testT *testing.T
+ suite.Suite
}
-func (t *testEtcdUtilSuite) SetUpSuite(c *check.C) {
+func (t *testEtcdUtilSuite) SetupSuite() {
// initialized the logger to make genEmbedEtcdConfig working.
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+ t.Require().NoError(log.InitLogger(&log.Config{}))
// this is to trigger `etcd.io/etcd/embed.(*Config).setupLogging()`
// otherwise `newConfig` will datarace with `TestDoOpsInOneTxnWithRetry.NewClusterV3.Launch.m.grpcServer.Serve(m.grpcListener)`
- t.newConfig(c, "not used", 1)
+ t.newConfig("not used", 1)
}
func TestSuite(t *testing.T) {
integration.BeforeTestExternal(t)
- // inject *testing.T to suite
- s := etcdTestSuite.(*testEtcdUtilSuite)
- s.testT = t
- check.TestingT(t)
+ suite.Run(t, new(testEtcdUtilSuite))
}
-func (t *testEtcdUtilSuite) newConfig(c *check.C, name string, portCount int) *embed.Config {
+func (t *testEtcdUtilSuite) newConfig(name string, portCount int) *embed.Config {
cfg := embed.NewConfig()
cfg.Name = name
- cfg.Dir = c.MkDir()
+ cfg.Dir = t.T().TempDir()
cfg.ZapLoggerBuilder = embed.NewZapCoreLoggerBuilder(log.L().Logger, log.L().Core(), log.Props().Syncer)
cfg.Logger = "zap"
- c.Assert(cfg.Validate(), check.IsNil)
+ t.Require().NoError(cfg.Validate())
cfg.ListenClientUrls = []url.URL{}
for i := 0; i < portCount; i++ {
endPoint := tempurl.Alloc()
cu, err2 := url.Parse(endPoint)
- c.Assert(err2, check.IsNil)
+ t.Require().NoError(err2)
cfg.ListenClientUrls = append(cfg.ListenClientUrls, *cu)
}
@@ -78,7 +73,7 @@ func (t *testEtcdUtilSuite) newConfig(c *check.C, name string, portCount int) *e
for i := 0; i < portCount; i++ {
endPoint := tempurl.Alloc()
pu, err2 := url.Parse(endPoint)
- c.Assert(err2, check.IsNil)
+ t.Require().NoError(err2)
cfg.ListenPeerUrls = append(cfg.ListenPeerUrls, *pu)
ic = append(ic, fmt.Sprintf("%s=%s", cfg.Name, pu))
}
@@ -96,109 +91,109 @@ func (t *testEtcdUtilSuite) urlsToStrings(urls []url.URL) []string {
return ret
}
-func (t *testEtcdUtilSuite) startEtcd(c *check.C, cfg *embed.Config) *embed.Etcd {
+func (t *testEtcdUtilSuite) startEtcd(cfg *embed.Config) *embed.Etcd {
e, err := embed.StartEtcd(cfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
timeout := 10 * time.Second
select {
case <-e.Server.ReadyNotify():
case <-time.After(timeout):
e.Server.Stop()
- c.Fatalf("start embed etcd timeout %v", timeout)
+ t.T().Fatalf("start embed etcd timeout %v", timeout)
}
return e
}
-func (t *testEtcdUtilSuite) createEtcdClient(c *check.C, endpoints []string) *clientv3.Client {
+func (t *testEtcdUtilSuite) createEtcdClient(endpoints []string) *clientv3.Client {
cli, err := CreateClient(endpoints, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
return cli
}
-func (t *testEtcdUtilSuite) checkMember(c *check.C, mid uint64, m *etcdserverpb.Member, cfg *embed.Config) {
+func (t *testEtcdUtilSuite) checkMember(mid uint64, m *etcdserverpb.Member, cfg *embed.Config) {
if m.Name != "" { // no name exists after `member add`
- c.Assert(m.Name, check.Equals, cfg.Name)
+ t.Require().Equal(cfg.Name, m.Name)
}
- c.Assert(m.ID, check.Equals, mid)
- require.ElementsMatch(t.testT, m.ClientURLs, t.urlsToStrings(cfg.AdvertiseClientUrls))
- require.ElementsMatch(t.testT, m.PeerURLs, t.urlsToStrings(cfg.AdvertisePeerUrls))
+ t.Require().Equal(mid, m.ID)
+ require.ElementsMatch(t.T(), m.ClientURLs, t.urlsToStrings(cfg.AdvertiseClientUrls))
+ require.ElementsMatch(t.T(), m.PeerURLs, t.urlsToStrings(cfg.AdvertisePeerUrls))
}
-func (t *testEtcdUtilSuite) TestMemberUtil(c *check.C) {
+func (t *testEtcdUtilSuite) TestMemberUtil() {
for i := 1; i <= 3; i++ {
- t.testMemberUtilInternal(c, i)
+ t.testMemberUtilInternal(i)
}
}
-func (t *testEtcdUtilSuite) testMemberUtilInternal(c *check.C, portCount int) {
+func (t *testEtcdUtilSuite) testMemberUtilInternal(portCount int) {
// start a etcd
- cfg1 := t.newConfig(c, "etcd1", portCount)
+ cfg1 := t.newConfig("etcd1", portCount)
endpoints1 := t.urlsToStrings(cfg1.ListenClientUrls)
- etcd1 := t.startEtcd(c, cfg1)
+ etcd1 := t.startEtcd(cfg1)
defer etcd1.Close()
// list member
- cli := t.createEtcdClient(c, endpoints1)
+ cli := t.createEtcdClient(endpoints1)
listResp1, err := ListMembers(cli)
- c.Assert(err, check.IsNil)
- c.Assert(listResp1.Members, check.HasLen, 1)
- t.checkMember(c, uint64(etcd1.Server.ID()), listResp1.Members[0], cfg1)
+ t.Require().NoError(err)
+ t.Require().Len(listResp1.Members, 1)
+ t.checkMember(uint64(etcd1.Server.ID()), listResp1.Members[0], cfg1)
// add member
- cfg2 := t.newConfig(c, "etcd2", portCount)
+ cfg2 := t.newConfig("etcd2", portCount)
cfg2.InitialCluster = cfg1.InitialCluster + "," + cfg2.InitialCluster
cfg2.ClusterState = embed.ClusterStateFlagExisting
addResp, err := AddMember(cli, t.urlsToStrings(cfg2.AdvertisePeerUrls))
- c.Assert(err, check.IsNil)
- c.Assert(addResp.Members, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Len(addResp.Members, 2)
// start the added member
- etcd2 := t.startEtcd(c, cfg2)
+ etcd2 := t.startEtcd(cfg2)
defer etcd2.Close()
- c.Assert(addResp.Member.ID, check.Equals, uint64(etcd2.Server.ID()))
+ t.Require().Equal(uint64(etcd2.Server.ID()), addResp.Member.ID)
// list member again
listResp2, err := ListMembers(cli)
- c.Assert(err, check.IsNil)
- c.Assert(listResp2.Members, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Len(listResp2.Members, 2)
for _, m := range listResp2.Members {
switch m.ID {
case uint64(etcd1.Server.ID()):
- t.checkMember(c, uint64(etcd1.Server.ID()), m, cfg1)
+ t.checkMember(uint64(etcd1.Server.ID()), m, cfg1)
case uint64(etcd2.Server.ID()):
- t.checkMember(c, uint64(etcd2.Server.ID()), m, cfg2)
+ t.checkMember(uint64(etcd2.Server.ID()), m, cfg2)
default:
- c.Fatalf("unknown member %v", m)
+ t.T().Fatalf("unknown member %v", m)
}
}
}
-func (t *testEtcdUtilSuite) TestRemoveMember(c *check.C) {
+func (t *testEtcdUtilSuite) TestRemoveMember() {
// test remove one member that is not the one we connected to.
// if we remove the one we connected to, the test might fail, see more in https://github.com/etcd-io/etcd/pull/7242
- cluster := integration.NewClusterV3(t.testT, &integration.ClusterConfig{Size: 3})
- defer cluster.Terminate(t.testT)
- leaderIdx := cluster.WaitLeader(t.testT)
- c.Assert(leaderIdx, check.Not(check.Equals), -1)
+ cluster := integration.NewClusterV3(t.T(), &integration.ClusterConfig{Size: 3})
+ defer cluster.Terminate(t.T())
+ leaderIdx := cluster.WaitLeader(t.T())
+ t.Require().NotEqual(-1, leaderIdx)
cli := cluster.Client(leaderIdx)
respList, err := ListMembers(cli)
- c.Assert(err, check.IsNil)
- c.Assert(respList.Members, check.HasLen, 3)
+ t.Require().NoError(err)
+ t.Require().Len(respList.Members, 3)
for _, m := range respList.Members {
if m.ID != respList.Header.MemberId {
respRemove, removeErr := RemoveMember(cli, m.ID)
- c.Assert(removeErr, check.IsNil)
- c.Assert(respRemove.Members, check.HasLen, 2)
+ t.Require().NoError(removeErr)
+ t.Require().Len(respRemove.Members, 2)
break
}
}
respList, err = ListMembers(cli)
- c.Assert(err, check.IsNil)
- c.Assert(respList.Members, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Len(respList.Members, 2)
}
-func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry(c *check.C) {
+func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry() {
var (
key1 = "/test/etcdutil/do-ops-in-one-txn-with-retry-1"
key2 = "/test/etcdutil/do-ops-in-one-txn-with-retry-2"
@@ -206,15 +201,15 @@ func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry(c *check.C) {
val2 = "bar"
val = "foo-bar"
)
- cluster := integration.NewClusterV3(t.testT, &integration.ClusterConfig{Size: 1})
- defer cluster.Terminate(t.testT)
+ cluster := integration.NewClusterV3(t.T(), &integration.ClusterConfig{Size: 1})
+ defer cluster.Terminate(t.T())
cli := cluster.RandClient()
resp, rev1, err := DoTxnWithRepeatable(cli, ThenOpFunc(clientv3.OpPut(key1, val1), clientv3.OpPut(key2, val2)))
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(resp.Responses, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Greater(rev1, int64(0))
+ t.Require().Len(resp.Responses, 2)
// both cmps are true
cmp1 := clientv3.Compare(clientv3.Value(key1), "=", val1)
@@ -222,9 +217,9 @@ func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry(c *check.C) {
resp, rev2, err := DoTxnWithRepeatable(cli, FullOpFunc([]clientv3.Cmp{cmp1, cmp2}, []clientv3.Op{
clientv3.OpPut(key1, val), clientv3.OpPut(key2, val),
}, []clientv3.Op{}))
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(resp.Responses, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
+ t.Require().Len(resp.Responses, 2)
// one of cmps are false
cmp1 = clientv3.Compare(clientv3.Value(key1), "=", val)
@@ -232,12 +227,12 @@ func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry(c *check.C) {
resp, rev3, err := DoTxnWithRepeatable(cli, FullOpFunc([]clientv3.Cmp{cmp1, cmp2}, []clientv3.Op{}, []clientv3.Op{
clientv3.OpDelete(key1), clientv3.OpDelete(key2),
}))
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
- c.Assert(resp.Responses, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Greater(rev3, rev2)
+ t.Require().Len(resp.Responses, 2)
// enable failpoint
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/etcdutil/ErrNoSpace", `3*return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/etcdutil/ErrNoSpace", `3*return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/etcdutil/ErrNoSpace")
@@ -245,17 +240,17 @@ func (t *testEtcdUtilSuite) TestDoOpsInOneTxnWithRetry(c *check.C) {
resp, rev2, err = DoTxnWithRepeatable(cli, FullOpFunc([]clientv3.Cmp{clientv3util.KeyMissing(key1), clientv3util.KeyMissing(key2)}, []clientv3.Op{
clientv3.OpPut(key1, val), clientv3.OpPut(key2, val),
}, []clientv3.Op{}))
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(resp.Responses, check.HasLen, 2)
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
+ t.Require().Len(resp.Responses, 2)
}
-func (t *testEtcdUtilSuite) TestIsRetryableError(c *check.C) {
- c.Assert(IsRetryableError(v3rpc.ErrCompacted), check.IsTrue)
- c.Assert(IsRetryableError(v3rpc.ErrNoLeader), check.IsTrue)
- c.Assert(IsRetryableError(v3rpc.ErrNoSpace), check.IsTrue)
+func (t *testEtcdUtilSuite) TestIsRetryableError() {
+ t.Require().True(IsRetryableError(v3rpc.ErrCompacted))
+ t.Require().True(IsRetryableError(v3rpc.ErrNoLeader))
+ t.Require().True(IsRetryableError(v3rpc.ErrNoSpace))
- c.Assert(IsRetryableError(v3rpc.ErrCorrupt), check.IsFalse)
- c.Assert(IsRetryableError(terror.ErrDecodeEtcdKeyFail), check.IsFalse)
- c.Assert(IsRetryableError(nil), check.IsFalse)
+ t.Require().False(IsRetryableError(v3rpc.ErrCorrupt))
+ t.Require().False(IsRetryableError(terror.ErrDecodeEtcdKeyFail))
+ t.Require().False(IsRetryableError(nil))
}
diff --git a/dm/pkg/ha/bound_test.go b/dm/pkg/ha/bound_test.go
index e4975ac1fe..84f0436491 100644
--- a/dm/pkg/ha/bound_test.go
+++ b/dm/pkg/ha/bound_test.go
@@ -17,25 +17,24 @@ import (
"context"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
)
-func (t *testForEtcd) TestSourceBoundJSON(c *check.C) {
+func (s *testForEtcd) TestSourceBoundJSON() {
b1 := NewSourceBound("mysql-replica-1", "dm-worker-1")
j, err := b1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"source":"mysql-replica-1","worker":"dm-worker-1"}`)
- c.Assert(j, check.Equals, b1.String())
+ s.Require().NoError(err)
+ s.Require().Equal(`{"source":"mysql-replica-1","worker":"dm-worker-1"}`, j)
+ s.Require().Equal(b1.String(), j)
b2, err := sourceBoundFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(b2, check.DeepEquals, b1)
+ s.Require().NoError(err)
+ s.Require().Equal(b1, b2)
}
-func (t *testForEtcd) TestSourceBoundEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestSourceBoundEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
watchTimeout = 2 * time.Second
@@ -44,21 +43,21 @@ func (t *testForEtcd) TestSourceBoundEtcd(c *check.C) {
bound1 = NewSourceBound("mysql-replica-1", worker1)
bound2 = NewSourceBound("mysql-replica-2", worker2)
)
- c.Assert(bound1.IsDeleted, check.IsFalse)
+ s.Require().False(bound1.IsDeleted)
// no bound exists.
sbm1, rev1, err := GetSourceBound(etcdTestCli, "")
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(sbm1, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Len(sbm1, 0)
// put two bounds.
rev2, err := PutSourceBound(etcdTestCli, bound1)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
rev3, err := PutSourceBound(etcdTestCli, bound2)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
+ s.Require().NoError(err)
+ s.Require().Greater(rev3, rev2)
// watch the PUT operation for the bound1.
boundCh := make(chan SourceBound, 10)
@@ -68,36 +67,36 @@ func (t *testForEtcd) TestSourceBoundEtcd(c *check.C) {
cancel()
close(boundCh)
close(errCh)
- c.Assert(len(boundCh), check.Equals, 1)
+ s.Require().Equal(1, len(boundCh))
bound1.Revision = rev2
- c.Assert(<-boundCh, check.DeepEquals, bound1)
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().Equal(bound1, <-boundCh)
+ s.Require().Equal(0, len(errCh))
// get bound1 back.
sbm2, rev4, err := GetSourceBound(etcdTestCli, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(sbm2, check.HasLen, 1)
- c.Assert(sbm2[worker1], check.DeepEquals, bound1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
+ s.Require().Len(sbm2, 1)
+ s.Require().Equal(bound1, sbm2[worker1])
// get bound1 and bound2 back.
sbm2, rev4, err = GetSourceBound(etcdTestCli, "")
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(sbm2, check.HasLen, 2)
- c.Assert(sbm2[worker1], check.DeepEquals, bound1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
+ s.Require().Len(sbm2, 2)
+ s.Require().Equal(bound1, sbm2[worker1])
bound2.Revision = rev3
- c.Assert(sbm2[worker2], check.DeepEquals, bound2)
+ s.Require().Equal(bound2, sbm2[worker2])
// delete bound1.
rev5, err := DeleteSourceBound(etcdTestCli, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Greater, rev4)
+ s.Require().NoError(err)
+ s.Require().Greater(rev5, rev4)
// delete bound2.
rev6, err := DeleteSourceBound(etcdTestCli, worker2)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, rev5)
+ s.Require().NoError(err)
+ s.Require().Greater(rev6, rev5)
// watch the DELETE operation for bound1.
boundCh = make(chan SourceBound, 10)
@@ -107,21 +106,21 @@ func (t *testForEtcd) TestSourceBoundEtcd(c *check.C) {
cancel()
close(boundCh)
close(errCh)
- c.Assert(len(boundCh), check.Equals, 1)
+ s.Require().Equal(1, len(boundCh))
bo := <-boundCh
- c.Assert(bo.IsDeleted, check.IsTrue)
- c.Assert(bo.Revision, check.Equals, rev5)
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().True(bo.IsDeleted)
+ s.Require().Equal(rev5, bo.Revision)
+ s.Require().Equal(0, len(errCh))
// get again, bound1 not exists now.
sbm3, rev7, err := GetSourceBound(etcdTestCli, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(sbm3, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(sbm3, 0)
}
-func (t *testForEtcd) TestGetSourceBoundConfigEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestGetSourceBoundConfigEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
worker = "dm-worker-1"
@@ -129,31 +128,32 @@ func (t *testForEtcd) TestGetSourceBoundConfigEtcd(c *check.C) {
bound = NewSourceBound(source, worker)
)
cfg, err := config.LoadFromFile(sourceSampleFilePath)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cfg.SourceID = source
// no source bound and config
bound1, cfg1, rev1, err := GetSourceBoundConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(bound1.IsEmpty(), check.IsTrue)
- c.Assert(cfg1, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().True(bound1.IsEmpty())
+ s.Require().Nil(cfg1)
rev2, err := PutSourceBound(etcdTestCli, bound)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get source bound and config, but config is empty
// nolint:dogsled
_, _, _, err = GetSourceBoundConfig(etcdTestCli, worker)
- c.Assert(err, check.ErrorMatches, ".*doesn't have related source config in etcd.*")
+ s.Require().Error(err)
+ s.Require().Regexp(".*doesn't have related source config in etcd.*", err.Error())
rev3, err := PutSourceCfg(etcdTestCli, cfg)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
+ s.Require().NoError(err)
+ s.Require().Greater(rev3, rev2)
// get source bound and config
bound2, cfg2, rev4, err := GetSourceBoundConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
bound.Revision = rev2
- c.Assert(bound2, check.DeepEquals, bound)
- c.Assert(cfg2, check.DeepEquals, cfg)
+ s.Require().Equal(bound, bound2)
+ s.Require().Equal(cfg, cfg2)
}
diff --git a/dm/pkg/ha/keepalive_test.go b/dm/pkg/ha/keepalive_test.go
index 6960890116..c93e9045f0 100644
--- a/dm/pkg/ha/keepalive_test.go
+++ b/dm/pkg/ha/keepalive_test.go
@@ -20,7 +20,6 @@ import (
"sync/atomic"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/utils"
)
@@ -28,11 +27,11 @@ import (
// minLeaseTTL is 1 in etcd cluster.
var keepAliveTTL = int64(0)
-func (t *testForEtcd) TestWorkerKeepAlive(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestWorkerKeepAlive() {
+ defer clearTestInfoOperation(s.T())
wwm, rev, err := GetKeepAliveWorkers(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(wwm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(wwm, 0)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -56,17 +55,17 @@ func (t *testForEtcd) TestWorkerKeepAlive(c *check.C) {
cancels = append(cancels, cancel1)
go func(ctx context.Context) {
err1 := KeepAlive(ctx, etcdTestCli, worker, keepAliveTTL)
- c.Assert(err1, check.IsNil, check.Commentf("if \"context canceled\", retry later\ncause: context used in `KeepAlive` exceed timeout of 10s (`etcdutil.DefaultRequestTimeout`)"))
+ s.Require().NoError(err1, "if \"context canceled\", retry later\ncause: context used in `KeepAlive` exceed timeout of 10s (`etcdutil.DefaultRequestTimeout`)")
atomic.AddInt32(&finished, 1)
}(ctx1)
select {
case ev := <-evCh:
- c.Assert(ev.IsDeleted, check.IsFalse)
- c.Assert(ev.WorkerName, check.Equals, worker)
- c.Assert(ev.JoinTime.Before(curTime), check.IsFalse)
+ s.Require().False(ev.IsDeleted)
+ s.Require().Equal(worker, ev.WorkerName)
+ s.Require().False(ev.JoinTime.Before(curTime))
case <-time.After(timeout):
- c.Fatal("fail to receive put ev " + strconv.Itoa(i) + " before timeout")
+ s.T().Fatal("fail to receive put ev " + strconv.Itoa(i) + " before timeout")
}
}
@@ -75,32 +74,32 @@ func (t *testForEtcd) TestWorkerKeepAlive(c *check.C) {
cancel1()
select {
case ev := <-evCh:
- c.Assert(ev.IsDeleted, check.IsTrue)
- c.Assert(ev.WorkerName, check.Equals, worker)
+ s.Require().True(ev.IsDeleted)
+ s.Require().Equal(worker, ev.WorkerName)
case <-time.After(timeout):
- c.Fatal("fail to receive delete ev " + strconv.Itoa(i+1) + " before timeout")
+ s.T().Fatal("fail to receive delete ev " + strconv.Itoa(i+1) + " before timeout")
}
}
waitKeepAliveQuit := utils.WaitSomething(100, timeout, func() bool {
return atomic.LoadInt32(&finished) == 5
})
- c.Assert(waitKeepAliveQuit, check.IsTrue)
+ s.Require().True(waitKeepAliveQuit)
cancel()
select {
case <-closed:
case <-time.After(timeout):
- c.Fatal("fail to quit WatchWorkerEvent before timeout")
+ s.T().Fatal("fail to quit WatchWorkerEvent before timeout")
}
- c.Assert(errCh, check.HasLen, 0)
+ s.Require().Len(errCh, 0)
}
-func (t *testForEtcd) TestKeepAliveRevokeLease(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestKeepAliveRevokeLease() {
+ defer clearTestInfoOperation(s.T())
wwm, rev, err := GetKeepAliveWorkers(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(wwm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(wwm, 0)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
@@ -121,7 +120,7 @@ func (t *testForEtcd) TestKeepAliveRevokeLease(c *check.C) {
go func(ctx context.Context, cancel1 context.CancelFunc) {
err1 := KeepAlive(ctx, etcdTestCli, worker, hugeKeepAliveTTL)
cancel1()
- c.Assert(err1, check.IsNil)
+ s.Require().NoError(err1)
atomic.AddInt32(&finished, 1)
}(ctx1, cancel1)
}
@@ -129,9 +128,9 @@ func (t *testForEtcd) TestKeepAliveRevokeLease(c *check.C) {
ctx1, cancel1 := context.WithTimeout(ctx, 10*time.Second)
WatchWorkerEvent(ctx1, etcdTestCli, rev, evCh, errCh)
cancel1()
- c.Assert(evCh, check.HasLen, 100)
- c.Assert(errCh, check.HasLen, 0)
- c.Assert(atomic.LoadInt32(&finished), check.Equals, int32(50))
+ s.Require().Len(evCh, 100)
+ s.Require().Len(errCh, 0)
+ s.Require().Equal(int32(50), atomic.LoadInt32(&finished))
for len(evCh) > 0 {
ev := <-evCh
if ev.IsDeleted {
@@ -143,6 +142,6 @@ func (t *testForEtcd) TestKeepAliveRevokeLease(c *check.C) {
sort.Strings(putEvent)
sort.Strings(deleteEvent)
sort.Strings(workerSet)
- c.Assert(putEvent, check.DeepEquals, workerSet)
- c.Assert(deleteEvent, check.DeepEquals, workerSet)
+ s.Require().Equal(workerSet, putEvent)
+ s.Require().Equal(workerSet, deleteEvent)
}
diff --git a/dm/pkg/ha/load_task_test.go b/dm/pkg/ha/load_task_test.go
index 57ef487028..ba2c9dd96d 100644
--- a/dm/pkg/ha/load_task_test.go
+++ b/dm/pkg/ha/load_task_test.go
@@ -16,11 +16,9 @@ package ha
import (
"context"
"time"
-
- "github.com/pingcap/check"
)
-func (t *testForEtcd) TestLoadTaskEtcd(c *check.C) {
+func (s *testForEtcd) TestLoadTaskEtcd() {
var (
worker1 = "worker1"
worker2 = "worker2"
@@ -30,81 +28,81 @@ func (t *testForEtcd) TestLoadTaskEtcd(c *check.C) {
task2 = "task2"
watchTimeout = 2 * time.Second
)
- defer clearTestInfoOperation(c)
+ defer clearTestInfoOperation(s.T())
// no load worker exist.
tlswm, rev1, err := GetAllLoadTask(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(tlswm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(tlswm, 0)
// put load worker for task1, source1, worker1
rev2, err := PutLoadTask(etcdTestCli, task1, source1, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get worker for task1, source1
worker, rev3, err := GetLoadTask(etcdTestCli, task1, source1)
- c.Assert(err, check.IsNil)
- c.Assert(worker, check.Equals, worker1)
- c.Assert(rev3, check.Equals, rev2)
+ s.Require().NoError(err)
+ s.Require().Equal(worker1, worker)
+ s.Require().Equal(rev2, rev3)
// put load worker for task1, source1, worker1 again
rev4, err := PutLoadTask(etcdTestCli, task1, source1, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
+ s.Require().NoError(err)
+ s.Require().Greater(rev4, rev3)
// get worker for task1, source1 again
worker, rev5, err := GetLoadTask(etcdTestCli, task1, source1)
- c.Assert(err, check.IsNil)
- c.Assert(worker, check.Equals, worker1)
- c.Assert(rev5, check.Equals, rev4)
+ s.Require().NoError(err)
+ s.Require().Equal(worker1, worker)
+ s.Require().Equal(rev4, rev5)
// put load worker for task1, source2, worker2
rev6, err := PutLoadTask(etcdTestCli, task1, source2, worker2)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, rev5)
+ s.Require().NoError(err)
+ s.Require().Greater(rev6, rev5)
// get all load worker
tlswm, rev7, err := GetAllLoadTask(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(tlswm, check.HasLen, 1)
- c.Assert(tlswm, check.HasKey, task1)
- c.Assert(tlswm[task1], check.HasKey, source1)
- c.Assert(tlswm[task1], check.HasKey, source2)
- c.Assert(tlswm[task1][source1], check.Equals, worker1)
- c.Assert(tlswm[task1][source2], check.Equals, worker2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(tlswm, 1)
+ s.Require().Contains(tlswm, task1)
+ s.Require().Contains(tlswm[task1], source1)
+ s.Require().Contains(tlswm[task1], source2)
+ s.Require().Equal(worker1, tlswm[task1][source1])
+ s.Require().Equal(worker2, tlswm[task1][source2])
// Delete load worker for task1, source1
rev8, succ, err := DelLoadTask(etcdTestCli, task1, source1)
- c.Assert(err, check.IsNil)
- c.Assert(rev8, check.Greater, rev7)
- c.Assert(succ, check.IsTrue)
+ s.Require().NoError(err)
+ s.Require().Greater(rev8, rev7)
+ s.Require().True(succ)
worker, rev9, err := GetLoadTask(etcdTestCli, task1, source1)
- c.Assert(err, check.IsNil)
- c.Assert(rev9, check.Equals, rev8)
- c.Assert(worker, check.Equals, "")
+ s.Require().NoError(err)
+ s.Require().Equal(rev8, rev9)
+ s.Require().Equal("", worker)
worker, rev10, err := GetLoadTask(etcdTestCli, task1, source2)
- c.Assert(err, check.IsNil)
- c.Assert(rev10, check.Equals, rev9)
- c.Assert(worker, check.Equals, worker2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev9, rev10)
+ s.Require().Equal(worker2, worker)
// Delete load worker by task
rev11, succ, err := DelLoadTaskByTask(etcdTestCli, task1)
- c.Assert(err, check.IsNil)
- c.Assert(rev11, check.Greater, rev10)
- c.Assert(succ, check.IsTrue)
+ s.Require().NoError(err)
+ s.Require().Greater(rev11, rev10)
+ s.Require().True(succ)
tslwm, rev12, err := GetAllLoadTask(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev12, check.Equals, rev11)
- c.Assert(tslwm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev11, rev12)
+ s.Require().Len(tslwm, 0)
rev13, err := PutLoadTask(etcdTestCli, task2, source1, worker2)
- c.Assert(err, check.IsNil)
- c.Assert(rev13, check.Greater, rev12)
+ s.Require().NoError(err)
+ s.Require().Greater(rev13, rev12)
// watch operations for the load worker.
loadTaskCh := make(chan LoadTask, 10)
@@ -114,18 +112,18 @@ func (t *testForEtcd) TestLoadTaskEtcd(c *check.C) {
cancel()
close(loadTaskCh)
close(errCh)
- c.Assert(len(loadTaskCh), check.Equals, 3)
+ s.Require().Equal(3, len(loadTaskCh))
delLoadTask1 := <-loadTaskCh
- c.Assert(delLoadTask1.Task, check.Equals, task1)
- c.Assert(delLoadTask1.Source, check.Equals, source1)
- c.Assert(delLoadTask1.IsDelete, check.IsTrue)
+ s.Require().Equal(task1, delLoadTask1.Task)
+ s.Require().Equal(source1, delLoadTask1.Source)
+ s.Require().True(delLoadTask1.IsDelete)
DelLoadTask2 := <-loadTaskCh
- c.Assert(DelLoadTask2.Task, check.Equals, task1)
- c.Assert(DelLoadTask2.Source, check.Equals, source2)
- c.Assert(DelLoadTask2.IsDelete, check.IsTrue)
+ s.Require().Equal(task1, DelLoadTask2.Task)
+ s.Require().Equal(source2, DelLoadTask2.Source)
+ s.Require().True(DelLoadTask2.IsDelete)
putLoadTask := <-loadTaskCh
- c.Assert(putLoadTask.Task, check.Equals, task2)
- c.Assert(putLoadTask.Source, check.Equals, source1)
- c.Assert(putLoadTask.IsDelete, check.IsFalse)
- c.Assert(putLoadTask.Worker, check.Equals, worker2)
+ s.Require().Equal(task2, putLoadTask.Task)
+ s.Require().Equal(source1, putLoadTask.Source)
+ s.Require().False(putLoadTask.IsDelete)
+ s.Require().Equal(worker2, putLoadTask.Worker)
}
diff --git a/dm/pkg/ha/openapi_task_config_test.go b/dm/pkg/ha/openapi_task_config_test.go
index dce9ca10b8..e5d55e544f 100644
--- a/dm/pkg/ha/openapi_task_config_test.go
+++ b/dm/pkg/ha/openapi_task_config_test.go
@@ -14,77 +14,76 @@
package ha
import (
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/openapi"
"github.com/pingcap/tiflow/dm/openapi/fixtures"
"github.com/pingcap/tiflow/dm/pkg/terror"
)
-func (t *testForEtcd) TestOpenAPITaskConfigEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestOpenAPITaskConfigEtcd() {
+ defer clearTestInfoOperation(s.T())
task1, err := fixtures.GenNoShardOpenAPITaskForTest()
task1.Name = "test-1"
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
task2, err := fixtures.GenShardAndFilterOpenAPITaskForTest()
task2.Name = "test-2"
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// no openapi task config exist.
task1InEtcd, err := GetOpenAPITaskTemplate(etcdTestCli, task1.Name)
- c.Assert(err, check.IsNil)
- c.Assert(task1InEtcd, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(task1InEtcd)
task2InEtcd, err := GetOpenAPITaskTemplate(etcdTestCli, task2.Name)
- c.Assert(err, check.IsNil)
- c.Assert(task2InEtcd, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(task2InEtcd)
tasks, err := GetAllOpenAPITaskTemplate(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(tasks, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(tasks, 0)
// put openapi task config .
- c.Assert(PutOpenAPITaskTemplate(etcdTestCli, task1, false), check.IsNil)
- c.Assert(PutOpenAPITaskTemplate(etcdTestCli, task2, false), check.IsNil)
+ s.Require().NoError(PutOpenAPITaskTemplate(etcdTestCli, task1, false))
+ s.Require().NoError(PutOpenAPITaskTemplate(etcdTestCli, task2, false))
task1InEtcd, err = GetOpenAPITaskTemplate(etcdTestCli, task1.Name)
- c.Assert(err, check.IsNil)
- c.Assert(*task1InEtcd, check.DeepEquals, task1)
+ s.Require().NoError(err)
+ s.Require().Equal(task1, *task1InEtcd)
task2InEtcd, err = GetOpenAPITaskTemplate(etcdTestCli, task2.Name)
- c.Assert(err, check.IsNil)
- c.Assert(*task2InEtcd, check.DeepEquals, task2)
+ s.Require().NoError(err)
+ s.Require().Equal(task2, *task2InEtcd)
tasks, err = GetAllOpenAPITaskTemplate(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(tasks, check.HasLen, 2)
+ s.Require().NoError(err)
+ s.Require().Len(tasks, 2)
// put openapi task config again without overwrite will fail
- c.Assert(terror.ErrOpenAPITaskConfigExist.Equal(PutOpenAPITaskTemplate(etcdTestCli, task1, false)), check.IsTrue)
+ s.Require().True(terror.ErrOpenAPITaskConfigExist.Equal(PutOpenAPITaskTemplate(etcdTestCli, task1, false)))
// in overwrite mode, it will overwrite the old one.
task1.TaskMode = openapi.TaskTaskModeFull
- c.Assert(PutOpenAPITaskTemplate(etcdTestCli, task1, true), check.IsNil)
+ s.Require().NoError(PutOpenAPITaskTemplate(etcdTestCli, task1, true))
task1InEtcd, err = GetOpenAPITaskTemplate(etcdTestCli, task1.Name)
- c.Assert(err, check.IsNil)
- c.Assert(*task1InEtcd, check.DeepEquals, task1)
+ s.Require().NoError(err)
+ s.Require().Equal(task1, *task1InEtcd)
// put task config that not exist will fail
task3, err := fixtures.GenNoShardOpenAPITaskForTest()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
task3.Name = "test-3"
- c.Assert(terror.ErrOpenAPITaskConfigNotExist.Equal(UpdateOpenAPITaskTemplate(etcdTestCli, task3)), check.IsTrue)
+ s.Require().True(terror.ErrOpenAPITaskConfigNotExist.Equal(UpdateOpenAPITaskTemplate(etcdTestCli, task3)))
// update exist openapi task config will success
task1.TaskMode = openapi.TaskTaskModeAll
- c.Assert(UpdateOpenAPITaskTemplate(etcdTestCli, task1), check.IsNil)
+ s.Require().NoError(UpdateOpenAPITaskTemplate(etcdTestCli, task1))
task1InEtcd, err = GetOpenAPITaskTemplate(etcdTestCli, task1.Name)
- c.Assert(err, check.IsNil)
- c.Assert(*task1InEtcd, check.DeepEquals, task1)
+ s.Require().NoError(err)
+ s.Require().Equal(task1, *task1InEtcd)
// delete task config
- c.Assert(DeleteOpenAPITaskTemplate(etcdTestCli, task1.Name), check.IsNil)
+ s.Require().NoError(DeleteOpenAPITaskTemplate(etcdTestCli, task1.Name))
tasks, err = GetAllOpenAPITaskTemplate(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(tasks, check.HasLen, 1)
+ s.Require().NoError(err)
+ s.Require().Len(tasks, 1)
}
diff --git a/dm/pkg/ha/ops_test.go b/dm/pkg/ha/ops_test.go
index c9dd238516..f2859ee0e8 100644
--- a/dm/pkg/ha/ops_test.go
+++ b/dm/pkg/ha/ops_test.go
@@ -14,13 +14,12 @@
package ha
import (
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pb"
)
-func (t *testForEtcd) TestOpsEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestOpsEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
source = "mysql-replica-1"
@@ -38,112 +37,112 @@ func (t *testForEtcd) TestOpsEtcd(c *check.C) {
)
sourceCfg, err := config.LoadFromFile(sourceSampleFilePath)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
sourceCfg.SourceID = source
- c.Assert(subtaskCfg1.Decode(config.SampleSubtaskConfig, true), check.IsNil)
+ s.Require().NoError(subtaskCfg1.Decode(config.SampleSubtaskConfig, true))
subtaskCfg1.SourceID = source
subtaskCfg1.Name = task1
- c.Assert(subtaskCfg1.Adjust(true), check.IsNil)
+ s.Require().NoError(subtaskCfg1.Adjust(true))
subtaskCfg2 := subtaskCfg1
subtaskCfg2.Name = task2
- c.Assert(subtaskCfg2.Adjust(true), check.IsNil)
+ s.Require().NoError(subtaskCfg2.Adjust(true))
// put relay stage and source bound.
rev1, err := PutRelayStageRelayConfigSourceBound(etcdTestCli, relayStage, bound)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
// put source config.
rev2, err := PutSourceCfg(etcdTestCli, sourceCfg)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get them back.
st1, rev3, err := GetRelayStage(etcdTestCli, source)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
relayStage.Revision = rev1
- c.Assert(st1, check.DeepEquals, relayStage)
+ s.Require().Equal(relayStage, st1)
sbm1, rev3, err := GetSourceBound(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(sbm1, check.HasLen, 1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(sbm1, 1)
bound.Revision = rev1
- c.Assert(sbm1[worker], check.DeepEquals, bound)
+ s.Require().Equal(bound, sbm1[worker])
scm1, rev3, err := GetSourceCfg(etcdTestCli, source, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
soCfg1 := scm1[source]
- c.Assert(soCfg1, check.DeepEquals, sourceCfg)
+ s.Require().Equal(sourceCfg, soCfg1)
// delete source config, relay stage and source bound.
rev4, err := DeleteSourceCfgRelayStageSourceBound(etcdTestCli, source, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
+ s.Require().NoError(err)
+ s.Require().Greater(rev4, rev3)
// try to get them back again.
st2, rev5, err := GetRelayStage(etcdTestCli, source)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(st2, check.Equals, emptyStage)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Equal(emptyStage, st2)
sbm2, rev5, err := GetSourceBound(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(sbm2, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Len(sbm2, 0)
scm2, rev5, err := GetSourceCfg(etcdTestCli, source, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(scm2, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Len(scm2, 0)
// put subtask config and subtask stage.
rev6, err := PutSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{subtaskCfg1, subtaskCfg2}, []Stage{subtaskStage1, subtaskStage2}, []Stage{validatorStage})
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, rev5)
+ s.Require().NoError(err)
+ s.Require().Greater(rev6, rev5)
// get them back.
stcm, rev7, err := GetSubTaskCfg(etcdTestCli, source, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(stcm, check.HasLen, 2)
- c.Assert(stcm[task1], check.DeepEquals, subtaskCfg1)
- c.Assert(stcm[task2], check.DeepEquals, subtaskCfg2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(stcm, 2)
+ s.Require().Equal(subtaskCfg1, stcm[task1])
+ s.Require().Equal(subtaskCfg2, stcm[task2])
stsm, rev7, err := GetSubTaskStage(etcdTestCli, source, "")
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(stsm, check.HasLen, 2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(stsm, 2)
subtaskStage1.Revision = rev6
subtaskStage2.Revision = rev6
- c.Assert(stsm[task1], check.DeepEquals, subtaskStage1)
- c.Assert(stsm[task2], check.DeepEquals, subtaskStage2)
+ s.Require().Equal(subtaskStage1, stsm[task1])
+ s.Require().Equal(subtaskStage2, stsm[task2])
validatorStages, rev7, err := GetValidatorStage(etcdTestCli, source, "", rev6)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(validatorStages, check.HasLen, 1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(validatorStages, 1)
validatorStage.Revision = rev6
- c.Assert(validatorStages[task2], check.DeepEquals, validatorStage)
+ s.Require().Equal(validatorStage, validatorStages[task2])
// get with task name
validatorStages, rev7, err = GetValidatorStage(etcdTestCli, source, task2, rev6)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Equals, rev6)
- c.Assert(validatorStages, check.HasLen, 1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev6, rev7)
+ s.Require().Len(validatorStages, 1)
validatorStage.Revision = rev6
- c.Assert(validatorStages[task2], check.DeepEquals, validatorStage)
+ s.Require().Equal(validatorStage, validatorStages[task2])
// delete them.
rev8, err := DeleteSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{subtaskCfg1, subtaskCfg2}, []Stage{subtaskStage1, subtaskStage2}, []Stage{validatorStage})
- c.Assert(err, check.IsNil)
- c.Assert(rev8, check.Greater, rev7)
+ s.Require().NoError(err)
+ s.Require().Greater(rev8, rev7)
// try to get them back again.
stcm, rev9, err := GetSubTaskCfg(etcdTestCli, source, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev9, check.Equals, rev8)
- c.Assert(stcm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev8, rev9)
+ s.Require().Len(stcm, 0)
stsm, rev9, err = GetSubTaskStage(etcdTestCli, source, "")
- c.Assert(err, check.IsNil)
- c.Assert(rev9, check.Equals, rev8)
- c.Assert(stsm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev8, rev9)
+ s.Require().Len(stsm, 0)
validatorStages, rev9, err = GetValidatorStage(etcdTestCli, source, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev9, check.Equals, rev8)
- c.Assert(validatorStages, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev8, rev9)
+ s.Require().Len(validatorStages, 0)
}
diff --git a/dm/pkg/ha/relay_test.go b/dm/pkg/ha/relay_test.go
index d89dbed167..976eff9026 100644
--- a/dm/pkg/ha/relay_test.go
+++ b/dm/pkg/ha/relay_test.go
@@ -14,50 +14,50 @@
package ha
import (
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
)
-func (t *testForEtcd) TestGetRelayConfigEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestGetRelayConfigEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
worker = "dm-worker-1"
source = "mysql-replica-1"
)
cfg, err := config.LoadFromFile(sourceSampleFilePath)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cfg.SourceID = source
// no relay source and config
cfg1, rev1, err := GetRelayConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(cfg1, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Nil(cfg1)
rev2, err := PutRelayConfig(etcdTestCli, source, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get relay source and config, but config is empty
_, _, err = GetRelayConfig(etcdTestCli, worker)
- c.Assert(err, check.ErrorMatches, ".*doesn't have related source config in etcd.*")
+ s.Require().Error(err)
+ s.Require().Regexp(".*doesn't have related source config in etcd.*", err.Error())
rev3, err := PutSourceCfg(etcdTestCli, cfg)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
+ s.Require().NoError(err)
+ s.Require().Greater(rev3, rev2)
// get relay source and config
cfg2, rev4, err := GetRelayConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(cfg2, check.DeepEquals, cfg)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
+ s.Require().Equal(cfg, cfg2)
rev5, err := DeleteRelayConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Greater, rev4)
+ s.Require().NoError(err)
+ s.Require().Greater(rev5, rev4)
// though source config is saved in etcd, relay source is deleted so return nothing
cfg3, rev6, err := GetRelayConfig(etcdTestCli, worker)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Equals, rev5)
- c.Assert(cfg3, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Equal(rev5, rev6)
+ s.Require().Nil(cfg3)
}
diff --git a/dm/pkg/ha/source_test.go b/dm/pkg/ha/source_test.go
index da60e34cbc..d4b719b363 100644
--- a/dm/pkg/ha/source_test.go
+++ b/dm/pkg/ha/source_test.go
@@ -21,8 +21,9 @@ import (
"path"
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
+ "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
@@ -82,97 +83,97 @@ func TestHA(t *testing.T) {
etcdTestCli = mockCluster.RandClient()
- check.TestingT(t)
+ suite.Run(t, new(testForEtcd))
}
// clear keys in etcd test cluster.
-func clearTestInfoOperation(c *check.C) {
- c.Assert(ClearTestInfoOperation(etcdTestCli), check.IsNil)
+func clearTestInfoOperation(t require.TestingT) {
+ require.NoError(t, ClearTestInfoOperation(etcdTestCli))
}
-type testForEtcd struct{}
-
-var _ = check.Suite(&testForEtcd{})
+type testForEtcd struct {
+ suite.Suite
+}
-func (t *testForEtcd) SetUpTest(c *check.C) {
- createTestFixture(c)
+func (s *testForEtcd) SetupTest() {
+ createTestFixture(s.T())
}
-func createTestFixture(c *check.C) {
- dir := c.MkDir()
+func createTestFixture(t *testing.T) {
+ dir := t.TempDir()
caFilePath = path.Join(dir, caFile)
err := os.WriteFile(caFilePath, []byte(caFileContent), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
certFilePath = path.Join(dir, certFile)
err = os.WriteFile(certFilePath, []byte(certFileContent), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
keyFilePath = path.Join(dir, keyFile)
err = os.WriteFile(keyFilePath, []byte(keyFileContent), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceSampleFilePath = path.Join(dir, sourceSampleFile)
sourceFileContent := fmt.Sprintf(sourceFileContent, caFilePath, certFilePath, keyFilePath)
err = os.WriteFile(sourceSampleFilePath, []byte(sourceFileContent), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
-func (t *testForEtcd) TestSourceEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestSourceEtcd() {
+ defer clearTestInfoOperation(s.T())
cfg, err := config.LoadFromFile(sourceSampleFilePath)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
source := cfg.SourceID
cfgExtra := *cfg
cfgExtra.SourceID = "mysql-replica-2"
// no source config exist.
scm1, rev1, err := GetSourceCfg(etcdTestCli, source, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(scm1, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Len(scm1, 0)
cfgM, _, err := GetSourceCfg(etcdTestCli, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(cfgM, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(cfgM, 0)
// put a source config.
- c.Assert(cfg.From.Security.LoadTLSContent(), check.IsNil)
+ s.Require().NoError(cfg.From.Security.LoadTLSContent())
rev2, err := PutSourceCfg(etcdTestCli, cfg)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get the config back.
scm2, rev3, err := GetSourceCfg(etcdTestCli, source, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
cfg2 := scm2[source]
- c.Assert(cfg2, check.DeepEquals, cfg)
+ s.Require().Equal(cfg, cfg2)
noContentBytes := []byte("test no content")
- c.Assert(bytes.Contains(cfg2.From.Security.SSLCABytes, noContentBytes), check.Equals, true)
- c.Assert(bytes.Contains(cfg2.From.Security.SSLKeyBytes, noContentBytes), check.Equals, true)
- c.Assert(bytes.Contains(cfg2.From.Security.SSLCertBytes, noContentBytes), check.Equals, true)
+ s.Require().Equal(true, bytes.Contains(cfg2.From.Security.SSLCABytes, noContentBytes))
+ s.Require().Equal(true, bytes.Contains(cfg2.From.Security.SSLKeyBytes, noContentBytes))
+ s.Require().Equal(true, bytes.Contains(cfg2.From.Security.SSLCertBytes, noContentBytes))
// put another source config.
rev2, err = PutSourceCfg(etcdTestCli, &cfgExtra)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// get all two config.
cfgM, rev3, err = GetSourceCfg(etcdTestCli, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(cfgM, check.HasLen, 2)
- c.Assert(cfgM[source], check.DeepEquals, cfg)
- c.Assert(cfgM[cfgExtra.SourceID], check.DeepEquals, &cfgExtra)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(cfgM, 2)
+ s.Require().Equal(cfg, cfgM[source])
+ s.Require().Equal(&cfgExtra, cfgM[cfgExtra.SourceID])
// delete the config.
deleteOp := deleteSourceCfgOp(source)
deleteResp, err := etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// get again, not exists now.
scm3, rev4, err := GetSourceCfg(etcdTestCli, source, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, deleteResp.Header.Revision)
- c.Assert(scm3, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(deleteResp.Header.Revision, rev4)
+ s.Require().Len(scm3, 0)
}
diff --git a/dm/pkg/ha/stage_test.go b/dm/pkg/ha/stage_test.go
index c377555618..ef97aa9b8e 100644
--- a/dm/pkg/ha/stage_test.go
+++ b/dm/pkg/ha/stage_test.go
@@ -17,37 +17,36 @@ import (
"context"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pb"
)
-func (t *testForEtcd) TestStageJSON(c *check.C) {
+func (s *testForEtcd) TestStageJSON() {
// stage for relay.
rs1 := NewRelayStage(pb.Stage_Running, "mysql-replica-1")
j, err := rs1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"expect":2,"source":"mysql-replica-1"}`)
- c.Assert(j, check.Equals, rs1.String())
+ s.Require().NoError(err)
+ s.Require().Equal(`{"expect":2,"source":"mysql-replica-1"}`, j)
+ s.Require().Equal(rs1.String(), j)
rs2, err := stageFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(rs2, check.DeepEquals, rs1)
+ s.Require().NoError(err)
+ s.Require().Equal(rs1, rs2)
// stage for subtask.
sts1 := NewSubTaskStage(pb.Stage_Paused, "mysql-replica-1", "task1")
j, err = sts1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"expect":3,"source":"mysql-replica-1","task":"task1"}`)
- c.Assert(j, check.Equals, sts1.String())
+ s.Require().NoError(err)
+ s.Require().Equal(`{"expect":3,"source":"mysql-replica-1","task":"task1"}`, j)
+ s.Require().Equal(sts1.String(), j)
sts2, err := stageFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(sts2, check.DeepEquals, sts1)
+ s.Require().NoError(err)
+ s.Require().Equal(sts1, sts2)
}
-func (t *testForEtcd) TestRelayStageEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestRelayStageEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
watchTimeout = 2 * time.Second
@@ -57,18 +56,18 @@ func (t *testForEtcd) TestRelayStageEtcd(c *check.C) {
stage1 = NewRelayStage(pb.Stage_Running, source1)
stage2 = NewRelayStage(pb.Stage_Paused, source2)
)
- c.Assert(stage1.IsDeleted, check.IsFalse)
+ s.Require().False(stage1.IsDeleted)
// no relay stage exist.
st1, rev1, err := GetRelayStage(etcdTestCli, source1)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(st1, check.DeepEquals, emptyStage)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Equal(emptyStage, st1)
// put two stage.
rev2, err := PutRelayStage(etcdTestCli, stage1, stage2)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// watch the PUT operation for stage1.
stageCh := make(chan Stage, 10)
@@ -78,32 +77,32 @@ func (t *testForEtcd) TestRelayStageEtcd(c *check.C) {
cancel()
close(stageCh)
close(errCh)
- c.Assert(len(stageCh), check.Equals, 1)
+ s.Require().Equal(1, len(stageCh))
stage1.Revision = rev2
- c.Assert(<-stageCh, check.DeepEquals, stage1)
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().Equal(stage1, <-stageCh)
+ s.Require().Equal(0, len(errCh))
// get stage1 back.
st2, rev3, err := GetRelayStage(etcdTestCli, source1)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(st2, check.DeepEquals, stage1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Equal(stage1, st2)
// get two stages.
stm, rev3, err := GetAllRelayStage(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stm, check.HasLen, 2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(stm, 2)
stage2.Revision = rev2
- c.Assert(stm[source1], check.DeepEquals, stage1)
- c.Assert(stm[source2], check.DeepEquals, stage2)
+ s.Require().Equal(stage1, stm[source1])
+ s.Require().Equal(stage2, stm[source2])
// delete stage1.
deleteOp := deleteRelayStageOp(source1)
resp, err := etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
rev4 := resp.Header.Revision
- c.Assert(rev4, check.Greater, rev3)
+ s.Require().Greater(rev4, rev3)
// watch the DELETE operation for stage1.
stageCh = make(chan Stage, 10)
@@ -113,20 +112,20 @@ func (t *testForEtcd) TestRelayStageEtcd(c *check.C) {
cancel()
close(stageCh)
close(errCh)
- c.Assert(len(stageCh), check.Equals, 1)
+ s.Require().Equal(1, len(stageCh))
st3 := <-stageCh
- c.Assert(st3.IsDeleted, check.IsTrue)
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().True(st3.IsDeleted)
+ s.Require().Equal(0, len(errCh))
// get again, not exists now.
st4, rev5, err := GetRelayStage(etcdTestCli, source1)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(st4, check.DeepEquals, emptyStage)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Equal(emptyStage, st4)
}
-func (t *testForEtcd) TestSubTaskStageEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestSubTaskStageEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
watchTimeout = 2 * time.Second
@@ -139,14 +138,14 @@ func (t *testForEtcd) TestSubTaskStageEtcd(c *check.C) {
// no stage exists.
st1, rev1, err := GetSubTaskStage(etcdTestCli, source, task1)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(st1, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Len(st1, 0)
// put two stages.
rev2, err := PutSubTaskStage(etcdTestCli, stage1, stage2)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// watch the PUT operation for stages.
stageCh := make(chan Stage, 10)
@@ -156,41 +155,41 @@ func (t *testForEtcd) TestSubTaskStageEtcd(c *check.C) {
cancel()
close(stageCh)
close(errCh)
- c.Assert(len(stageCh), check.Equals, 2)
+ s.Require().Equal(2, len(stageCh))
stage1.Revision = rev2
stage2.Revision = rev2
- c.Assert(<-stageCh, check.DeepEquals, stage1)
- c.Assert(<-stageCh, check.DeepEquals, stage2)
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().Equal(stage1, <-stageCh)
+ s.Require().Equal(stage2, <-stageCh)
+ s.Require().Equal(0, len(errCh))
// get stages back without specified task.
stm, rev3, err := GetSubTaskStage(etcdTestCli, source, "")
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stm, check.HasLen, 2)
- c.Assert(stm[task1], check.DeepEquals, stage1)
- c.Assert(stm[task2], check.DeepEquals, stage2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(stm, 2)
+ s.Require().Equal(stage1, stm[task1])
+ s.Require().Equal(stage2, stm[task2])
// get the stage back with specified task.
stm, rev3, err = GetSubTaskStage(etcdTestCli, source, task1)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(stm[task1], check.DeepEquals, stage1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(stm, 1)
+ s.Require().Equal(stage1, stm[task1])
// get all stages.
stmm, rev3, err := GetAllSubTaskStage(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stmm, check.HasLen, 1)
- c.Assert(stmm[source], check.HasLen, 2)
- c.Assert(stmm[source][task1], check.DeepEquals, stage1)
- c.Assert(stmm[source][task2], check.DeepEquals, stage2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(stmm, 1)
+ s.Require().Len(stmm[source], 2)
+ s.Require().Equal(stage1, stmm[source][task1])
+ s.Require().Equal(stage2, stmm[source][task2])
// delete two stages.
rev4, err := DeleteSubTaskStage(etcdTestCli, stage1, stage2)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
+ s.Require().NoError(err)
+ s.Require().Greater(rev4, rev3)
// watch the DELETE operation for stages.
stageCh = make(chan Stage, 10)
@@ -200,49 +199,49 @@ func (t *testForEtcd) TestSubTaskStageEtcd(c *check.C) {
cancel()
close(stageCh)
close(errCh)
- c.Assert(len(stageCh), check.Equals, 2)
+ s.Require().Equal(2, len(stageCh))
for st2 := range stageCh {
- c.Assert(st2.IsDeleted, check.IsTrue)
+ s.Require().True(st2.IsDeleted)
}
- c.Assert(len(errCh), check.Equals, 0)
+ s.Require().Equal(0, len(errCh))
// get again, not exists now.
stm, rev5, err := GetSubTaskStage(etcdTestCli, source, task1)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(stm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Len(stm, 0)
}
-func (t *testForEtcd) TestGetSubTaskStageConfigEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestGetSubTaskStageConfigEtcd() {
+ defer clearTestInfoOperation(s.T())
cfg := config.SubTaskConfig{}
- c.Assert(cfg.Decode(config.SampleSubtaskConfig, true), check.IsNil)
+ s.Require().NoError(cfg.Decode(config.SampleSubtaskConfig, true))
source := cfg.SourceID
task := cfg.Name
stage := NewSubTaskStage(pb.Stage_Running, source, task)
// no subtask stage and config
stm, validatorM, scm, rev1, err := GetSubTaskStageConfig(etcdTestCli, source)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(stm, check.HasLen, 0)
- c.Assert(validatorM, check.HasLen, 0)
- c.Assert(scm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Len(stm, 0)
+ s.Require().Len(validatorM, 0)
+ s.Require().Len(scm, 0)
// put subtask config and stage at the same time
rev2, err := PutSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{cfg}, []Stage{stage}, []Stage{stage})
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get subtask config and stage at the same time
stm, validatorM, scm, rev3, err := GetSubTaskStageConfig(etcdTestCli, source)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(validatorM, check.HasLen, 1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(stm, 1)
+ s.Require().Len(validatorM, 1)
stage.Revision = rev2
- c.Assert(stm[task], check.DeepEquals, stage)
- c.Assert(validatorM[task], check.DeepEquals, stage)
- c.Assert(scm[task], check.DeepEquals, cfg)
+ s.Require().Equal(stage, stm[task])
+ s.Require().Equal(stage, validatorM[task])
+ s.Require().Equal(cfg, scm[task])
}
diff --git a/dm/pkg/ha/subtask_test.go b/dm/pkg/ha/subtask_test.go
index f0c3f9029c..a5deca0e3a 100644
--- a/dm/pkg/ha/subtask_test.go
+++ b/dm/pkg/ha/subtask_test.go
@@ -16,15 +16,14 @@ package ha
import (
"context"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
)
-func (t *testForEtcd) TestSubTaskEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestSubTaskEtcd() {
+ defer clearTestInfoOperation(s.T())
cfg1 := config.SubTaskConfig{}
- c.Assert(cfg1.Decode(config.SampleSubtaskConfig, true), check.IsNil)
+ s.Require().NoError(cfg1.Decode(config.SampleSubtaskConfig, true))
source := cfg1.SourceID
taskName1 := cfg1.Name
@@ -32,76 +31,76 @@ func (t *testForEtcd) TestSubTaskEtcd(c *check.C) {
cfg2 := cfg1
cfg2.Name = taskName2
err := cfg2.Adjust(true)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// no subtask config exist.
tsm1, rev1, err := GetSubTaskCfg(etcdTestCli, source, taskName1, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(tsm1, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
+ s.Require().Len(tsm1, 0)
// put subtask configs.
rev2, err := PutSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{cfg1, cfg2}, []Stage{}, nil)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get single config back.
tsm2, rev3, err := GetSubTaskCfg(etcdTestCli, source, taskName1, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(tsm2, check.HasLen, 1)
- c.Assert(tsm2, check.HasKey, taskName1)
- c.Assert(tsm2[taskName1], check.DeepEquals, cfg1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(tsm2, 1)
+ s.Require().Contains(tsm2, taskName1)
+ s.Require().Equal(cfg1, tsm2[taskName1])
tsm3, rev4, err := GetSubTaskCfg(etcdTestCli, source, "", 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(tsm3, check.HasLen, 2)
- c.Assert(tsm3, check.HasKey, taskName1)
- c.Assert(tsm3, check.HasKey, taskName2)
- c.Assert(tsm3[taskName1], check.DeepEquals, cfg1)
- c.Assert(tsm3[taskName2], check.DeepEquals, cfg2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
+ s.Require().Len(tsm3, 2)
+ s.Require().Contains(tsm3, taskName1)
+ s.Require().Contains(tsm3, taskName2)
+ s.Require().Equal(cfg1, tsm3[taskName1])
+ s.Require().Equal(cfg2, tsm3[taskName2])
// get all subtask configs.
stmm, rev4, err := GetAllSubTaskCfg(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(stmm, check.HasLen, 1)
- c.Assert(stmm[source], check.HasLen, 2)
- c.Assert(stmm[source][taskName1], check.DeepEquals, cfg1)
- c.Assert(stmm[source][taskName2], check.DeepEquals, cfg2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev3, rev4)
+ s.Require().Len(stmm, 1)
+ s.Require().Len(stmm[source], 2)
+ s.Require().Equal(cfg1, stmm[source][taskName1])
+ s.Require().Equal(cfg2, stmm[source][taskName2])
// delete the config.
deleteOps := deleteSubTaskCfgOp(cfg1)
_, err = etcdTestCli.Txn(context.Background()).Then(deleteOps...).Commit()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
deleteOps = deleteSubTaskCfgOp(cfg2)
deleteResp, err := etcdTestCli.Txn(context.Background()).Then(deleteOps...).Commit()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// get again, not exists now.
tsm4, rev5, err := GetSubTaskCfg(etcdTestCli, source, taskName1, 0)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, deleteResp.Header.Revision)
- c.Assert(tsm4, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Equal(deleteResp.Header.Revision, rev5)
+ s.Require().Len(tsm4, 0)
// put subtask config.
rev6, err := PutSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{cfg1}, []Stage{}, nil)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, int64(0))
+ s.Require().NoError(err)
+ s.Require().Greater(rev6, int64(0))
// update subtask config.
cfg3 := cfg1
cfg3.SourceID = "testForRevision"
rev7, err := PutSubTaskCfgStage(etcdTestCli, []config.SubTaskConfig{cfg3}, []Stage{}, nil)
- c.Assert(err, check.IsNil)
- c.Assert(rev7, check.Greater, rev6)
+ s.Require().NoError(err)
+ s.Require().Greater(rev7, rev6)
// get subtask from rev6. shoule be equal to cfg1
tsm5, rev8, err := GetSubTaskCfg(etcdTestCli, source, taskName1, rev6)
- c.Assert(err, check.IsNil)
- c.Assert(rev8, check.Equals, rev7)
- c.Assert(tsm5, check.HasLen, 1)
- c.Assert(tsm5, check.HasKey, taskName1)
- c.Assert(tsm5[taskName1], check.DeepEquals, cfg1)
+ s.Require().NoError(err)
+ s.Require().Equal(rev7, rev8)
+ s.Require().Len(tsm5, 1)
+ s.Require().Contains(tsm5, taskName1)
+ s.Require().Equal(cfg1, tsm5[taskName1])
}
diff --git a/dm/pkg/ha/task_cli_args_test.go b/dm/pkg/ha/task_cli_args_test.go
index 6d6652d59a..998d19c195 100644
--- a/dm/pkg/ha/task_cli_args_test.go
+++ b/dm/pkg/ha/task_cli_args_test.go
@@ -14,12 +14,11 @@
package ha
import (
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
)
-func (t *testForEtcd) TestTaskCliArgs(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestTaskCliArgs() {
+ defer clearTestInfoOperation(s.T())
task := "test-task-cli-args"
source1 := "source1"
@@ -27,8 +26,8 @@ func (t *testForEtcd) TestTaskCliArgs(c *check.C) {
checkNotExist := func(source string) {
ret, err := GetTaskCliArgs(etcdTestCli, task, source)
- c.Assert(err, check.IsNil)
- c.Assert(ret, check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(ret)
}
checkNotExist(source1)
@@ -38,40 +37,40 @@ func (t *testForEtcd) TestTaskCliArgs(c *check.C) {
StartTime: "123",
}
err := PutTaskCliArgs(etcdTestCli, task, []string{source1}, args)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
ret, err := GetTaskCliArgs(etcdTestCli, task, source1)
- c.Assert(err, check.IsNil)
- c.Assert(ret, check.NotNil)
- c.Assert(*ret, check.Equals, args)
+ s.Require().NoError(err)
+ s.Require().NotNil(ret)
+ s.Require().Equal(args, *ret)
checkNotExist(source2)
// put will overwrite
args.StartTime = "456"
err = PutTaskCliArgs(etcdTestCli, task, []string{source1, source2}, args)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
ret, err = GetTaskCliArgs(etcdTestCli, task, source1)
- c.Assert(err, check.IsNil)
- c.Assert(ret, check.NotNil)
- c.Assert(*ret, check.Equals, args)
+ s.Require().NoError(err)
+ s.Require().NotNil(ret)
+ s.Require().Equal(args, *ret)
ret, err = GetTaskCliArgs(etcdTestCli, task, source2)
- c.Assert(err, check.IsNil)
- c.Assert(ret, check.NotNil)
- c.Assert(*ret, check.Equals, args)
+ s.Require().NoError(err)
+ s.Require().NotNil(ret)
+ s.Require().Equal(args, *ret)
// test delete one source
err = DeleteTaskCliArgs(etcdTestCli, task, []string{source1})
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkNotExist(source1)
ret, err = GetTaskCliArgs(etcdTestCli, task, source2)
- c.Assert(err, check.IsNil)
- c.Assert(ret, check.NotNil)
- c.Assert(*ret, check.Equals, args)
+ s.Require().NoError(err)
+ s.Require().NotNil(ret)
+ s.Require().Equal(args, *ret)
// test delete all source
err = DeleteAllTaskCliArgs(etcdTestCli, task)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkNotExist(source2)
}
diff --git a/dm/pkg/ha/worker_test.go b/dm/pkg/ha/worker_test.go
index a11aa0953b..e2b4bc7d5d 100644
--- a/dm/pkg/ha/worker_test.go
+++ b/dm/pkg/ha/worker_test.go
@@ -13,25 +13,21 @@
package ha
-import (
- "github.com/pingcap/check"
-)
-
-func (t *testForEtcd) TestWorkerInfoJSON(c *check.C) {
+func (s *testForEtcd) TestWorkerInfoJSON() {
i1 := NewWorkerInfo("dm-worker-1", "192.168.0.100:8262")
j, err := i1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"name":"dm-worker-1","addr":"192.168.0.100:8262"}`)
- c.Assert(j, check.Equals, i1.String())
+ s.Require().NoError(err)
+ s.Require().Equal(`{"name":"dm-worker-1","addr":"192.168.0.100:8262"}`, j)
+ s.Require().Equal(i1.String(), j)
i2, err := workerInfoFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(i2, check.DeepEquals, i1)
+ s.Require().NoError(err)
+ s.Require().Equal(i1, i2)
}
-func (t *testForEtcd) TestWorkerInfoEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (s *testForEtcd) TestWorkerInfoEtcd() {
+ defer clearTestInfoOperation(s.T())
var (
worker1 = "dm-worker-1"
@@ -42,34 +38,34 @@ func (t *testForEtcd) TestWorkerInfoEtcd(c *check.C) {
// get without info.
ifm, _, err := GetAllWorkerInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 0)
+ s.Require().NoError(err)
+ s.Require().Len(ifm, 0)
// put two info.
rev1, err := PutWorkerInfo(etcdTestCli, info1)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
+ s.Require().NoError(err)
+ s.Require().Greater(rev1, int64(0))
rev2, err := PutWorkerInfo(etcdTestCli, info2)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ s.Require().NoError(err)
+ s.Require().Greater(rev2, rev1)
// get again, with two info.
ifm, rev3, err := GetAllWorkerInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(ifm, check.HasLen, 2)
- c.Assert(ifm[worker1], check.DeepEquals, info1)
- c.Assert(ifm[worker2], check.DeepEquals, info2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev2, rev3)
+ s.Require().Len(ifm, 2)
+ s.Require().Equal(info1, ifm[worker1])
+ s.Require().Equal(info2, ifm[worker2])
// delete info1.
rev4, err := DeleteWorkerInfoRelayConfig(etcdTestCli, worker1)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
+ s.Require().NoError(err)
+ s.Require().Greater(rev4, rev3)
// get again, with only one info.
ifm, rev5, err := GetAllWorkerInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm[worker2], check.DeepEquals, info2)
+ s.Require().NoError(err)
+ s.Require().Equal(rev4, rev5)
+ s.Require().Len(ifm, 1)
+ s.Require().Equal(info2, ifm[worker2])
}
diff --git a/dm/pkg/shardddl/optimism/column_test.go b/dm/pkg/shardddl/optimism/column_test.go
index ab11f03839..744e27402f 100644
--- a/dm/pkg/shardddl/optimism/column_test.go
+++ b/dm/pkg/shardddl/optimism/column_test.go
@@ -14,15 +14,13 @@
package optimism
import (
- "github.com/pingcap/check"
-)
-
-type testColumn struct{}
+ "testing"
-var _ = check.Suite(&testColumn{})
+ "github.com/stretchr/testify/require"
+)
-func (t *testColumn) TestColumnETCD(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestColumnETCD(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
task = "test"
@@ -38,24 +36,24 @@ func (t *testColumn) TestColumnETCD(c *check.C) {
lockID = genDDLLockID(info1)
)
rev1, putted, err := PutDroppedColumns(etcdTestCli, lockID, source1, upSchema1, upTable1, []string{"a"}, DropNotDone)
- c.Assert(err, check.IsNil)
- c.Assert(putted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, putted)
rev2, putted, err := PutDroppedColumns(etcdTestCli, lockID, source1, upSchema1, upTable1, []string{"b"}, DropNotDone)
- c.Assert(err, check.IsNil)
- c.Assert(putted, check.IsTrue)
- c.Assert(rev2, check.Greater, rev1)
+ require.NoError(t, err)
+ require.True(t, putted)
+ require.Greater(t, rev2, rev1)
rev3, putted, err := PutDroppedColumns(etcdTestCli, lockID, source1, upSchema2, upTable2, []string{"b"}, DropNotDone)
- c.Assert(err, check.IsNil)
- c.Assert(putted, check.IsTrue)
- c.Assert(rev3, check.Greater, rev2)
+ require.NoError(t, err)
+ require.True(t, putted)
+ require.Greater(t, rev3, rev2)
rev4, putted, err := PutDroppedColumns(etcdTestCli, lockID, source2, upSchema1, upTable1, []string{"b"}, DropNotDone)
- c.Assert(err, check.IsNil)
- c.Assert(putted, check.IsTrue)
- c.Assert(rev4, check.Greater, rev3)
+ require.NoError(t, err)
+ require.True(t, putted)
+ require.Greater(t, rev4, rev3)
rev5, putted, err := PutDroppedColumns(etcdTestCli, lockID, source2, upSchema1, upTable1, []string{"b", "c"}, DropNotDone)
- c.Assert(err, check.IsNil)
- c.Assert(putted, check.IsTrue)
- c.Assert(rev5, check.Greater, rev4)
+ require.NoError(t, err)
+ require.True(t, putted)
+ require.Greater(t, rev5, rev4)
expectedColm := map[string]map[string]map[string]map[string]map[string]DropColumnStage{
lockID: {
@@ -73,19 +71,19 @@ func (t *testColumn) TestColumnETCD(c *check.C) {
},
}
colm, rev6, err := GetAllDroppedColumns(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(colm, check.DeepEquals, expectedColm)
- c.Assert(rev6, check.Equals, rev5)
+ require.NoError(t, err)
+ require.Equal(t, expectedColm, colm)
+ require.Equal(t, rev5, rev6)
rev7, deleted, err := DeleteDroppedColumns(etcdTestCli, lockID, "b", "c")
- c.Assert(err, check.IsNil)
- c.Assert(deleted, check.IsTrue)
- c.Assert(rev7, check.Greater, rev6)
+ require.NoError(t, err)
+ require.True(t, deleted)
+ require.Greater(t, rev7, rev6)
delete(expectedColm[lockID], "b")
delete(expectedColm[lockID], "c")
colm, rev8, err := GetAllDroppedColumns(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(colm, check.DeepEquals, expectedColm)
- c.Assert(rev8, check.Equals, rev7)
+ require.NoError(t, err)
+ require.Equal(t, expectedColm, colm)
+ require.Equal(t, rev7, rev8)
}
diff --git a/dm/pkg/shardddl/optimism/info_test.go b/dm/pkg/shardddl/optimism/info_test.go
index 77768f5385..59a4454b78 100644
--- a/dm/pkg/shardddl/optimism/info_test.go
+++ b/dm/pkg/shardddl/optimism/info_test.go
@@ -16,11 +16,12 @@ package optimism
import (
"context"
"encoding/json"
+ "flag"
+ "os"
"sync"
"testing"
"time"
- "github.com/pingcap/check"
tiddl "github.com/pingcap/tidb/pkg/ddl"
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/parser"
@@ -29,48 +30,48 @@ import (
"github.com/pingcap/tidb/pkg/util/mock"
"github.com/pingcap/tiflow/dm/common"
"github.com/pingcap/tiflow/dm/pkg/etcdutil"
+ "github.com/stretchr/testify/require"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
var etcdTestCli *clientv3.Client
-func TestInfo(t *testing.T) {
- integration.BeforeTestExternal(t)
- mockCluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
- defer mockCluster.Terminate(t)
-
+func TestMain(m *testing.M) {
+ // integration.NewClusterV3 consults testing.Short, which panics if
+ // called before the testing flags are parsed.
+ flag.Parse()
+ mockCluster := integration.NewClusterV3(&testing.T{}, &integration.ClusterConfig{Size: 1})
etcdTestCli = mockCluster.RandClient()
- check.TestingT(t)
+ code := m.Run()
+
+ mockCluster.Terminate(&testing.T{})
+ os.Exit(code)
}
// clear keys in etcd test cluster.
-func clearTestInfoOperation(c *check.C) {
- c.Assert(ClearTestInfoOperationColumn(etcdTestCli), check.IsNil)
+func clearTestInfoOperation(t *testing.T) {
+ require.NoError(t, ClearTestInfoOperationColumn(etcdTestCli))
}
-func createTableInfo(c *check.C, p *parser.Parser, se sessionctx.Context, tableID int64, sql string) *model.TableInfo {
+func createTableInfo(t *testing.T, p *parser.Parser, se sessionctx.Context, tableID int64, sql string) *model.TableInfo {
node, err := p.ParseOneStmt(sql, "utf8mb4", "utf8mb4_bin")
if err != nil {
- c.Fatalf("fail to parse stmt, %v", err)
+ t.Fatalf("fail to parse stmt, %v", err)
}
createStmtNode, ok := node.(*ast.CreateTableStmt)
if !ok {
- c.Fatalf("%s is not a CREATE TABLE statement", sql)
+ t.Fatalf("%s is not a CREATE TABLE statement", sql)
}
info, err := tiddl.MockTableInfo(se, createStmtNode, tableID)
if err != nil {
- c.Fatalf("fail to create table info, %v", err)
+ t.Fatalf("fail to create table info, %v", err)
}
return info
}
-type testForEtcd struct{}
-
-var _ = check.Suite(&testForEtcd{})
-
-func (t *testForEtcd) TestInfoJSON(c *check.C) {
+func TestInfoJSON(t *testing.T) {
i1 := NewInfo("test", "mysql-replica-1",
"db-1", "tbl-1", "db", "tbl", []string{
"ALTER TABLE tbl ADD COLUMN c1 INT",
@@ -78,19 +79,19 @@ func (t *testForEtcd) TestInfoJSON(c *check.C) {
}, nil, nil)
j, err := i1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","down-schema":"db","down-table":"tbl","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT","ALTER TABLE tbl ADD COLUMN c2 INT"],"table-info-before":null,"table-info-after":null,"ignore-conflict":false}`)
- c.Assert(j, check.Equals, i1.String())
+ require.NoError(t, err)
+ require.Equal(t, `{"task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","down-schema":"db","down-table":"tbl","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT","ALTER TABLE tbl ADD COLUMN c2 INT"],"table-info-before":null,"table-info-after":null,"ignore-conflict":false}`, j)
+ require.Equal(t, i1.String(), j)
j = i1.ShortString()
- c.Assert(j, check.Equals, `{"task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","down-schema":"db","down-table":"tbl","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT","ALTER TABLE tbl ADD COLUMN c2 INT"],"table-before":"","table-after":"","is-deleted":false,"version":0,"revision":0,"ignore-conflict":false}`)
+ require.Equal(t, `{"task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","down-schema":"db","down-table":"tbl","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT","ALTER TABLE tbl ADD COLUMN c2 INT"],"table-before":"","table-after":"","is-deleted":false,"version":0,"revision":0,"ignore-conflict":false}`, j)
i2, err := infoFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(i2, check.DeepEquals, i1)
+ require.NoError(t, err)
+ require.Equal(t, i1, i2)
}
-func (t *testForEtcd) TestEtcdInfoUpgrade(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestEtcdInfoUpgrade(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
source1 = "mysql-replica-1"
@@ -104,10 +105,10 @@ func (t *testForEtcd) TestEtcdInfoUpgrade(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 222
- tblI1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- tblI2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- tblI3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
- tblI4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT, c3 INT)`)
+ tblI1 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ tblI2 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ tblI3 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
+ tblI4 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT, c3 INT)`)
i11 = NewInfo(task1, source1, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c1 INT"}, tblI1, []*model.TableInfo{tblI2})
i12 = NewInfo(task1, source2, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c2 INT"}, tblI2, []*model.TableInfo{tblI3})
i21 = NewInfo(task2, source1, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c3 INT"}, tblI3, []*model.TableInfo{tblI4})
@@ -118,27 +119,27 @@ func (t *testForEtcd) TestEtcdInfoUpgrade(c *check.C) {
// put the oldInfo
rev1, err := putOldInfo(etcdTestCli, oi11)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rev2, err := putOldInfo(etcdTestCli, oi11)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ require.NoError(t, err)
+ require.Greater(t, rev2, rev1)
// put another key and get again with 2 info.
rev3, err := putOldInfo(etcdTestCli, oi12)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
+ require.NoError(t, err)
+ require.Greater(t, rev3, rev2)
// get all infos.
ifm, rev4, err := GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm[task1], check.HasLen, 2)
- c.Assert(ifm[task1][source1], check.HasLen, 1)
- c.Assert(ifm[task1][source1][upSchema], check.HasLen, 1)
- c.Assert(ifm[task1][source2], check.HasLen, 1)
- c.Assert(ifm[task1][source2][upSchema], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Equal(t, rev3, rev4)
+ require.Len(t, ifm, 1)
+ require.Contains(t, ifm, task1)
+ require.Len(t, ifm[task1], 2)
+ require.Len(t, ifm[task1][source1], 1)
+ require.Len(t, ifm[task1][source1][upSchema], 1)
+ require.Len(t, ifm[task1][source2], 1)
+ require.Len(t, ifm[task1][source2][upSchema], 1)
i11WithVer := i11
i11WithVer.Version = 2
@@ -146,8 +147,8 @@ func (t *testForEtcd) TestEtcdInfoUpgrade(c *check.C) {
i12WithVer := i12
i12WithVer.Version = 1
i12WithVer.Revision = rev4
- c.Assert(ifm[task1][source1][upSchema][upTable], check.DeepEquals, i11WithVer)
- c.Assert(ifm[task1][source2][upSchema][upTable], check.DeepEquals, i12WithVer)
+ require.Equal(t, i11WithVer, ifm[task1][source1][upSchema][upTable])
+ require.Equal(t, i12WithVer, ifm[task1][source2][upSchema][upTable])
// start the watcher.
wch := make(chan Info, 10)
@@ -165,17 +166,17 @@ func (t *testForEtcd) TestEtcdInfoUpgrade(c *check.C) {
// version start from 1
// simulate v2.0.1 worker and v2.0.2 master
rev5, err := putOldInfo(etcdTestCli, oi21)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
infoWithVer := <-wch
i21WithVer := i21
i21WithVer.Version = 1
i21WithVer.Revision = rev5
- c.Assert(infoWithVer, check.DeepEquals, i21WithVer)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, i21WithVer, infoWithVer)
+ require.Equal(t, 0, len(ech))
}
-func (t *testForEtcd) TestInfoEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestInfoEtcd(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
watchTimeout = 2 * time.Second
@@ -190,10 +191,10 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 222
- tblI1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- tblI2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- tblI3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
- tblI4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT, c3 INT)`)
+ tblI1 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ tblI2 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ tblI3 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
+ tblI4 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT, c3 INT)`)
i11 = NewInfo(task1, source1, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c1 INT"}, tblI1, []*model.TableInfo{tblI2})
i12 = NewInfo(task1, source2, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c2 INT"}, tblI2, []*model.TableInfo{tblI3})
i21 = NewInfo(task2, source1, upSchema, upTable, downSchema, downTable, []string{"ALTER TABLE bar ADD COLUMN c3 INT"}, tblI3, []*model.TableInfo{tblI4})
@@ -201,38 +202,38 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
// put the same key twice.
rev1, err := PutInfo(etcdTestCli, i11)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rev2, err := PutInfo(etcdTestCli, i11)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ require.NoError(t, err)
+ require.Greater(t, rev2, rev1)
// get with only 1 info.
ifm, rev3, err := GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm[task1], check.HasLen, 1)
- c.Assert(ifm[task1][source1], check.HasLen, 1)
- c.Assert(ifm[task1][source1][upSchema], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Equal(t, rev2, rev3)
+ require.Len(t, ifm, 1)
+ require.Contains(t, ifm, task1)
+ require.Len(t, ifm[task1], 1)
+ require.Len(t, ifm[task1][source1], 1)
+ require.Len(t, ifm[task1][source1][upSchema], 1)
i11WithVer := i11
i11WithVer.Version = 2
i11WithVer.Revision = rev2
- c.Assert(ifm[task1][source1][upSchema][upTable], check.DeepEquals, i11WithVer)
+ require.Equal(t, i11WithVer, ifm[task1][source1][upSchema][upTable])
// put another key and get again with 2 info.
rev4, err := PutInfo(etcdTestCli, i12)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm[task1], check.HasLen, 2)
- c.Assert(ifm[task1][source1][upSchema][upTable], check.DeepEquals, i11WithVer)
+ require.NoError(t, err)
+ require.Len(t, ifm, 1)
+ require.Contains(t, ifm, task1)
+ require.Len(t, ifm[task1], 2)
+ require.Equal(t, i11WithVer, ifm[task1][source1][upSchema][upTable])
i12WithVer := i12
i12WithVer.Version = 1
i12WithVer.Revision = rev4
- c.Assert(ifm[task1][source2][upSchema][upTable], check.DeepEquals, i12WithVer)
+ require.Equal(t, i12WithVer, ifm[task1][source2][upSchema][upTable])
// start the watcher.
wch := make(chan Info, 10)
@@ -249,44 +250,44 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
// put another key for a different task.
// version start from 1
rev5, err := PutInfo(etcdTestCli, i21)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
infoWithVer := <-wch
i21WithVer := i21
i21WithVer.Version = 1
i21WithVer.Revision = rev5
- c.Assert(infoWithVer, check.DeepEquals, i21WithVer)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, i21WithVer, infoWithVer)
+ require.Equal(t, 0, len(ech))
// put again
// version increase
rev6, err := PutInfo(etcdTestCli, i21)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
infoWithVer = <-wch
i21WithVer.Version++
i21WithVer.Revision = rev6
- c.Assert(infoWithVer, check.DeepEquals, i21WithVer)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, i21WithVer, infoWithVer)
+ require.Equal(t, 0, len(ech))
// delete i21.
deleteOp := deleteInfoOp(i21)
resp, err := etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
- c.Assert(resp.Succeeded, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, resp.Succeeded)
select {
case err2 := <-ech:
- c.Fatal(err2)
+ t.Fatal(err2)
case <-wch:
}
// put again
// version reset to 1
rev7, err := PutInfo(etcdTestCli, i21)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
infoWithVer = <-wch
i21WithVer.Version = 1
i21WithVer.Revision = rev7
- c.Assert(infoWithVer, check.DeepEquals, i21WithVer)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, i21WithVer, infoWithVer)
+ require.Equal(t, 0, len(ech))
watchCancel()
wg.Wait()
@@ -296,20 +297,20 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
// delete i12.
deleteOp = deleteInfoOp(i12)
resp, err = etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// get again.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 2)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm, check.HasKey, task2)
- c.Assert(ifm[task1], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, ifm, 2)
+ require.Contains(t, ifm, task1)
+ require.Contains(t, ifm, task2)
+ require.Len(t, ifm[task1], 1)
i11WithVer.Revision = ifm[task1][source1][upSchema][upTable].Revision
- c.Assert(ifm[task1][source1][upSchema][upTable], check.DeepEquals, i11WithVer)
- c.Assert(ifm[task2], check.HasLen, 1)
+ require.Equal(t, i11WithVer, ifm[task1][source1][upSchema][upTable])
+ require.Len(t, ifm[task2], 1)
i21WithVer.Revision = ifm[task2][source1][upSchema][upTable].Revision
- c.Assert(ifm[task2][source1][upSchema][upTable], check.DeepEquals, i21WithVer)
+ require.Equal(t, i21WithVer, ifm[task2][source1][upSchema][upTable])
// watch the deletion for i12.
wch = make(chan Info, 10)
@@ -319,12 +320,12 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
cancel()
close(wch)
close(ech)
- c.Assert(len(wch), check.Equals, 1)
+ require.Equal(t, 1, len(wch))
info := <-wch
i12c := i12
i12c.IsDeleted = true
- c.Assert(info, check.DeepEquals, i12c)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, i12c, info)
+ require.Equal(t, 0, len(ech))
}
func newOldInfo(task, source, upSchema, upTable, downSchema, downTable string,
diff --git a/dm/pkg/shardddl/optimism/keeper_test.go b/dm/pkg/shardddl/optimism/keeper_test.go
index 246566c5c8..180fdc0d2c 100644
--- a/dm/pkg/shardddl/optimism/keeper_test.go
+++ b/dm/pkg/shardddl/optimism/keeper_test.go
@@ -16,31 +16,16 @@ package optimism
import (
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/util/mock"
"github.com/pingcap/tiflow/dm/config/dbconfig"
"github.com/pingcap/tiflow/dm/pkg/conn"
"github.com/pingcap/tiflow/dm/pkg/terror"
- "go.etcd.io/etcd/tests/v3/integration"
+ "github.com/stretchr/testify/require"
)
-type testKeeper struct{}
-
-var _ = check.Suite(&testKeeper{})
-
-func TestKeeper(t *testing.T) {
- integration.BeforeTestExternal(t)
- mockCluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
- defer mockCluster.Terminate(t)
-
- etcdTestCli = mockCluster.RandClient()
-
- check.TestingT(t)
-}
-
-func (t *testKeeper) TestLockKeeper(c *check.C) {
+func TestLockKeeper(t *testing.T) {
var (
lk = NewLockKeeper(getDownstreamMeta)
upSchema = "foo_1"
@@ -56,8 +41,8 @@ func (t *testKeeper) TestLockKeeper(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- tiBefore = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- tiAfter = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ tiBefore = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ tiAfter = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
i11 = NewInfo(task1, source1, upSchema, upTable, downSchema, downTable, DDLs, tiBefore, []*model.TableInfo{tiAfter})
i12 = NewInfo(task1, source2, upSchema, upTable, downSchema, downTable, DDLs, tiBefore, []*model.TableInfo{tiAfter})
@@ -74,80 +59,80 @@ func (t *testKeeper) TestLockKeeper(c *check.C) {
// lock with 2 sources.
lockID1, newDDLs, cols, err := lk.TrySync(etcdTestCli, i11, tts1)
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.Equals, "task1-`foo`.`bar`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "task1-`foo`.`bar`", lockID1)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
lock1 := lk.FindLock(lockID1)
- c.Assert(lock1, check.NotNil)
- c.Assert(lock1.ID, check.Equals, lockID1)
- c.Assert(lk.FindLockByInfo(i11).ID, check.Equals, lockID1)
+ require.NotNil(t, lock1)
+ require.Equal(t, lockID1, lock1.ID)
+ require.Equal(t, lockID1, lk.FindLockByInfo(i11).ID)
lks := lk.FindLocksByTask("hahaha")
- c.Assert(len(lks), check.Equals, 0)
+ require.Equal(t, 0, len(lks))
lks = lk.FindLocksByTask(task1)
- c.Assert(len(lks), check.Equals, 1)
- c.Assert(lks[0].ID, check.Equals, lockID1)
+ require.Equal(t, 1, len(lks))
+ require.Equal(t, lockID1, lks[0].ID)
synced, remain := lock1.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
lockID1, newDDLs, cols, err = lk.TrySync(etcdTestCli, i12, tts1)
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.Equals, "task1-`foo`.`bar`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "task1-`foo`.`bar`", lockID1)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
lock1 = lk.FindLock(lockID1)
- c.Assert(lock1, check.NotNil)
- c.Assert(lock1.ID, check.Equals, lockID1)
+ require.NotNil(t, lock1)
+ require.Equal(t, lockID1, lock1.ID)
synced, remain = lock1.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
// lock with only 1 source.
lockID2, newDDLs, cols, err := lk.TrySync(etcdTestCli, i21, tts2)
- c.Assert(err, check.IsNil)
- c.Assert(lockID2, check.Equals, "task2-`foo`.`bar`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "task2-`foo`.`bar`", lockID2)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
lock2 := lk.FindLock(lockID2)
- c.Assert(lock2, check.NotNil)
- c.Assert(lock2.ID, check.Equals, lockID2)
+ require.NotNil(t, lock2)
+ require.Equal(t, lockID2, lock2.ID)
synced, remain = lock2.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
lks = lk.FindLocksByTask(task1)
- c.Assert(len(lks), check.Equals, 1)
- c.Assert(lks[0].ID, check.Equals, lockID1)
+ require.Equal(t, 1, len(lks))
+ require.Equal(t, lockID1, lks[0].ID)
lks = lk.FindLocksByTask(task2)
- c.Assert(len(lks), check.Equals, 1)
- c.Assert(lks[0].ID, check.Equals, lockID2)
+ require.Equal(t, 1, len(lks))
+ require.Equal(t, lockID2, lks[0].ID)
// try to find not-exists lock.
lockIDNotExists := "lock-not-exists"
- c.Assert(lk.FindLock(lockIDNotExists), check.IsNil)
+ require.Nil(t, lk.FindLock(lockIDNotExists))
// all locks.
locks := lk.Locks()
- c.Assert(locks, check.HasLen, 2)
- c.Assert(locks[lockID1], check.Equals, lock1) // compare pointer
- c.Assert(locks[lockID2], check.Equals, lock2)
+ require.Len(t, locks, 2)
+ require.Equal(t, lock1, locks[lockID1]) // compare pointer
+ require.Equal(t, lock2, locks[lockID2])
// remove lock.
- c.Assert(lk.RemoveLock(lockID1), check.IsTrue)
- c.Assert(lk.RemoveLock(lockIDNotExists), check.IsFalse)
- c.Assert(lk.Locks(), check.HasLen, 1)
+ require.True(t, lk.RemoveLock(lockID1))
+ require.False(t, lk.RemoveLock(lockIDNotExists))
+ require.Len(t, lk.Locks(), 1)
// clear locks.
lk.Clear()
// no locks exist.
- c.Assert(lk.Locks(), check.HasLen, 0)
+ require.Len(t, lk.Locks(), 0)
}
-func (t *testKeeper) TestLockKeeperMultipleTarget(c *check.C) {
+func TestLockKeeperMultipleTarget(t *testing.T) {
var (
lk = NewLockKeeper(getDownstreamMeta)
task = "test-lock-keeper-multiple-target"
@@ -162,8 +147,8 @@ func (t *testKeeper) TestLockKeeperMultipleTarget(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- tiBefore = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- tiAfter = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ tiBefore = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ tiAfter = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
i11 = NewInfo(task, source, upSchema, upTables[0], downSchema, downTable1, DDLs, tiBefore, []*model.TableInfo{tiAfter})
i12 = NewInfo(task, source, upSchema, upTables[1], downSchema, downTable1, DDLs, tiBefore, []*model.TableInfo{tiAfter})
@@ -184,61 +169,61 @@ func (t *testKeeper) TestLockKeeperMultipleTarget(c *check.C) {
// lock for target1.
lockID1, newDDLs, cols, err := lk.TrySync(etcdTestCli, i11, tts1)
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.DeepEquals, "test-lock-keeper-multiple-target-`foo`.`bar`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "test-lock-keeper-multiple-target-`foo`.`bar`", lockID1)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
// lock for target2.
lockID2, newDDLs, cols, err := lk.TrySync(etcdTestCli, i21, tts2)
- c.Assert(err, check.IsNil)
- c.Assert(lockID2, check.DeepEquals, "test-lock-keeper-multiple-target-`foo`.`rab`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "test-lock-keeper-multiple-target-`foo`.`rab`", lockID2)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
// check two locks exist.
lock1 := lk.FindLock(lockID1)
- c.Assert(lock1, check.NotNil)
- c.Assert(lock1.ID, check.Equals, lockID1)
- c.Assert(lk.FindLockByInfo(i11).ID, check.Equals, lockID1)
+ require.NotNil(t, lock1)
+ require.Equal(t, lockID1, lock1.ID)
+ require.Equal(t, lockID1, lk.FindLockByInfo(i11).ID)
synced, remain := lock1.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
lock2 := lk.FindLock(lockID2)
- c.Assert(lock2, check.NotNil)
- c.Assert(lock2.ID, check.Equals, lockID2)
- c.Assert(lk.FindLockByInfo(i21).ID, check.Equals, lockID2)
+ require.NotNil(t, lock2)
+ require.Equal(t, lockID2, lock2.ID)
+ require.Equal(t, lockID2, lk.FindLockByInfo(i21).ID)
synced, remain = lock2.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
// sync for two locks.
lockID1, newDDLs, cols, err = lk.TrySync(etcdTestCli, i12, tts1)
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.DeepEquals, "test-lock-keeper-multiple-target-`foo`.`bar`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "test-lock-keeper-multiple-target-`foo`.`bar`", lockID1)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
lockID2, newDDLs, cols, err = lk.TrySync(etcdTestCli, i22, tts2)
- c.Assert(err, check.IsNil)
- c.Assert(lockID2, check.DeepEquals, "test-lock-keeper-multiple-target-`foo`.`rab`")
- c.Assert(newDDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, "test-lock-keeper-multiple-target-`foo`.`rab`", lockID2)
+ require.Equal(t, DDLs, newDDLs)
+ require.Equal(t, []string{}, cols)
lock1 = lk.FindLock(lockID1)
- c.Assert(lock1, check.NotNil)
- c.Assert(lock1.ID, check.Equals, lockID1)
+ require.NotNil(t, lock1)
+ require.Equal(t, lockID1, lock1.ID)
synced, remain = lock1.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
lock2 = lk.FindLock(lockID2)
- c.Assert(lock2, check.NotNil)
- c.Assert(lock2.ID, check.Equals, lockID2)
+ require.NotNil(t, lock2)
+ require.Equal(t, lockID2, lock2.ID)
synced, remain = lock2.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
}
-func (t *testKeeper) TestTableKeeper(c *check.C) {
+func TestTableKeeper(t *testing.T) {
var (
tk = NewTableKeeper()
task1 = "task-1"
@@ -291,128 +276,128 @@ func (t *testKeeper) TestTableKeeper(c *check.C) {
}
// no tables exist before Init/Update.
- c.Assert(tk.FindTables(task1, downSchema, downTable), check.IsNil)
+ require.Nil(t, tk.FindTables(task1, downSchema, downTable))
for schema, tables := range tt11.UpTables {
for table := range tables {
- c.Assert(tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable), check.IsFalse)
+ require.False(t, tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable))
}
}
// Init with `nil` is fine.
tk.Init(nil)
- c.Assert(tk.FindTables(task1, downSchema, downTable), check.IsNil)
+ require.Nil(t, tk.FindTables(task1, downSchema, downTable))
// tables for task1 exit after Init.
tk.Init(stm)
tts := tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 2)
- c.Assert(tts[0], check.DeepEquals, tt11)
- c.Assert(tts[1], check.DeepEquals, tt12)
+ require.Len(t, tts, 2)
+ require.Equal(t, tt11, tts[0])
+ require.Equal(t, tt12, tts[1])
for schema, tables := range tt11.UpTables {
for table := range tables {
- c.Assert(tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable), check.IsTrue)
+ require.True(t, tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable))
}
}
// adds new tables.
addTables, dropTables := tk.Update(st21)
- c.Assert(addTables, check.HasLen, 1)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 1)
+ require.Len(t, dropTables, 0)
tts = tk.FindTables(task2, downSchema, downTable)
- c.Assert(tts, check.HasLen, 1)
- c.Assert(tts[0], check.DeepEquals, tt21)
+ require.Len(t, tts, 1)
+ require.Equal(t, tt21, tts[0])
// updates/appends new tables.
addTables, dropTables = tk.Update(st22)
- c.Assert(addTables, check.HasLen, 1)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 1)
+ require.Len(t, dropTables, 0)
tts = tk.FindTables(task2, downSchema, downTable)
- c.Assert(tts, check.HasLen, 1)
- c.Assert(tts[0], check.DeepEquals, tt22)
+ require.Len(t, tts, 1)
+ require.Equal(t, tt22, tts[0])
for schema, tables := range tt22.UpTables {
for table := range tables {
- c.Assert(tk.SourceTableExist(tt22.Task, tt22.Source, schema, table, downSchema, downTable), check.IsTrue)
+ require.True(t, tk.SourceTableExist(tt22.Task, tt22.Source, schema, table, downSchema, downTable))
}
}
// deletes tables.
st22.IsDeleted = true
addTables, dropTables = tk.Update(st22)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 2)
- c.Assert(tk.FindTables(task2, downSchema, downTable), check.IsNil)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 2)
+ require.Nil(t, tk.FindTables(task2, downSchema, downTable))
for schema, tables := range tt22.UpTables {
for table := range tables {
- c.Assert(tk.SourceTableExist(tt22.Task, tt22.Source, schema, table, downSchema, downTable), check.IsFalse)
+ require.False(t, tk.SourceTableExist(tt22.Task, tt22.Source, schema, table, downSchema, downTable))
}
}
// try to delete, but not exist.
addTables, dropTables = tk.Update(st22)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 0)
st22.Task = "not-exist"
addTables, dropTables = tk.Update(st22)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 0)
// tables for task1 not affected.
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 2)
- c.Assert(tts[0], check.DeepEquals, tt11)
- c.Assert(tts[1], check.DeepEquals, tt12)
+ require.Len(t, tts, 2)
+ require.Equal(t, tt11, tts[0])
+ require.Equal(t, tt12, tts[1])
for schema, tables := range tt11.UpTables {
for table := range tables {
- c.Assert(tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable), check.IsTrue)
+ require.True(t, tk.SourceTableExist(tt11.Task, tt11.Source, schema, table, downSchema, downTable))
}
}
// add a table for st11.
- c.Assert(tk.AddTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable), check.IsTrue)
- c.Assert(tk.AddTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable), check.IsFalse)
+ require.True(t, tk.AddTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable))
+ require.False(t, tk.AddTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable))
tts = tk.FindTables(task1, downSchema, downTable)
st11n := tts[0]
- c.Assert(st11n.UpTables, check.HasKey, "db-2")
- c.Assert(st11n.UpTables["db-2"], check.HasKey, "tbl-3")
+ require.Contains(t, st11n.UpTables, "db-2")
+ require.Contains(t, st11n.UpTables["db-2"], "tbl-3")
// removed the added table in st11.
- c.Assert(tk.RemoveTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable), check.IsTrue)
- c.Assert(tk.RemoveTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable), check.IsFalse)
+ require.True(t, tk.RemoveTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable))
+ require.False(t, tk.RemoveTable(task1, st11.Source, "db-2", "tbl-3", downSchema, downTable))
tts = tk.FindTables(task1, downSchema, downTable)
st11n = tts[0]
- c.Assert(st11n.UpTables["db-2"], check.IsNil)
+ require.Nil(t, st11n.UpTables["db-2"])
// adds for not existing task takes no effect.
- c.Assert(tk.AddTable("not-exist", st11.Source, "db-2", "tbl-3", downSchema, downTable), check.IsFalse)
+ require.False(t, tk.AddTable("not-exist", st11.Source, "db-2", "tbl-3", downSchema, downTable))
// adds for not existing source takes effect.
- c.Assert(tk.AddTable(task1, "new-source", "db-2", "tbl-3", downSchema, downTable), check.IsTrue)
+ require.True(t, tk.AddTable(task1, "new-source", "db-2", "tbl-3", downSchema, downTable))
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 3)
- c.Assert(tts[2].Source, check.Equals, "new-source")
- c.Assert(tts[2].UpTables["db-2"], check.HasKey, "tbl-3")
+ require.Len(t, tts, 3)
+ require.Equal(t, "new-source", tts[2].Source)
+ require.Contains(t, tts[2].UpTables["db-2"], "tbl-3")
// removes for not existing task/source takes no effect.
- c.Assert(tk.RemoveTable("not-exit", st12.Source, "db", "tbl-1", downSchema, downTable), check.IsFalse)
- c.Assert(tk.RemoveTable(task1, "not-exit", "db", "tbl-1", downSchema, downTable), check.IsFalse)
+ require.False(t, tk.RemoveTable("not-exit", st12.Source, "db", "tbl-1", downSchema, downTable))
+ require.False(t, tk.RemoveTable(task1, "not-exit", "db", "tbl-1", downSchema, downTable))
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts[1], check.DeepEquals, tt12)
+ require.Equal(t, tt12, tts[1])
- c.Assert(tk.RemoveTableByTask("hahaha"), check.IsFalse)
+ require.False(t, tk.RemoveTableByTask("hahaha"))
tk.RemoveTableByTaskAndSources("hahaha", nil)
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 3)
+ require.Len(t, tts, 3)
tk.RemoveTableByTaskAndSources(task1, []string{"hahaha"})
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 3)
+ require.Len(t, tts, 3)
tk.RemoveTableByTaskAndSources(task1, []string{source1, source2})
tts = tk.FindTables(task1, downSchema, downTable)
- c.Assert(tts, check.HasLen, 1)
- c.Assert(tts[0].Source, check.Equals, "new-source")
- c.Assert(tts[0].UpTables["db-2"], check.HasKey, "tbl-3")
+ require.Len(t, tts, 1)
+ require.Equal(t, "new-source", tts[0].Source)
+ require.Contains(t, tts[0].UpTables["db-2"], "tbl-3")
}
-func (t *testKeeper) TestTargetTablesForTask(c *check.C) {
+func TestTargetTablesForTask(t *testing.T) {
var (
tk = NewTableKeeper()
task1 = "task1"
@@ -429,11 +414,11 @@ func (t *testKeeper) TestTargetTablesForTask(c *check.C) {
)
// not exist task.
- c.Assert(TargetTablesForTask("not-exist", downSchema, downTable1, stm), check.IsNil)
+ require.Nil(t, TargetTablesForTask("not-exist", downSchema, downTable1, stm))
// no tables exist.
tts := TargetTablesForTask(task1, downSchema, downTable1, stm)
- c.Assert(tts, check.DeepEquals, []TargetTable{})
+ require.Equal(t, []TargetTable{}, tts)
// add some tables.
tt11 := stm[task1][source1]
@@ -449,40 +434,40 @@ func (t *testKeeper) TestTargetTablesForTask(c *check.C) {
// get tables back.
tts = TargetTablesForTask(task1, downSchema, downTable1, stm)
- c.Assert(tts, check.DeepEquals, []TargetTable{
+ require.Equal(t, []TargetTable{
tt11.TargetTable(downSchema, downTable1),
tt12.TargetTable(downSchema, downTable1),
- })
+ }, tts)
tts = TargetTablesForTask(task2, downSchema, downTable1, stm)
- c.Assert(tts, check.DeepEquals, []TargetTable{
+ require.Equal(t, []TargetTable{
tt21.TargetTable(downSchema, downTable1),
tt22.TargetTable(downSchema, downTable1),
- })
+ }, tts)
tk.Init(stm)
tts = tk.FindTables(task1, downSchema, downTable1)
- c.Assert(tts, check.DeepEquals, []TargetTable{
+ require.Equal(t, []TargetTable{
tt11.TargetTable(downSchema, downTable1),
tt12.TargetTable(downSchema, downTable1),
- })
+ }, tts)
// add some tables for another target table.
- c.Assert(tk.AddTable(task1, source1, "foo-1", "bar-3", downSchema, downTable2), check.IsTrue)
- c.Assert(tk.AddTable(task1, source1, "foo-1", "bar-4", downSchema, downTable2), check.IsTrue)
+ require.True(t, tk.AddTable(task1, source1, "foo-1", "bar-3", downSchema, downTable2))
+ require.True(t, tk.AddTable(task1, source1, "foo-1", "bar-4", downSchema, downTable2))
tts = tk.FindTables(task1, downSchema, downTable2)
- c.Assert(tts, check.DeepEquals, []TargetTable{
+ require.Equal(t, []TargetTable{
newTargetTable(task1, source1, downSchema, downTable2,
map[string]map[string]struct{}{
"foo-1": {"bar-3": struct{}{}, "bar-4": struct{}{}},
}),
- })
+ }, tts)
}
func getDownstreamMeta(string) (*dbconfig.DBConfig, string) {
return nil, ""
}
-func (t *testKeeper) TestGetDownstreamMeta(c *check.C) {
+func TestGetDownstreamMeta(t *testing.T) {
var (
task1 = "hahaha"
task2 = "hihihi"
@@ -497,51 +482,51 @@ func (t *testKeeper) TestGetDownstreamMeta(c *check.C) {
}
}
- conn.InitMockDB(c)
+ conn.InitMockDB(t)
lk := NewLockKeeper(getDownstreamMetaFunc)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 0)
+ require.Len(t, lk.downstreamMetaMap, 0)
downstreamMeta, err := lk.getDownstreamMeta(task3)
- c.Assert(downstreamMeta, check.IsNil)
- c.Assert(terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err), check.IsTrue)
+ require.Nil(t, downstreamMeta)
+ require.True(t, terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err))
downstreamMeta, err = lk.getDownstreamMeta(task1)
- c.Assert(err, check.IsNil)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 1)
- c.Assert(downstreamMeta, check.Equals, lk.downstreamMetaMap[task1])
+ require.NoError(t, err)
+ require.Len(t, lk.downstreamMetaMap, 1)
+ require.Equal(t, lk.downstreamMetaMap[task1], downstreamMeta)
downstreamMeta2, err := lk.getDownstreamMeta(task1)
- c.Assert(err, check.IsNil)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 1)
- c.Assert(downstreamMeta, check.Equals, downstreamMeta2)
+ require.NoError(t, err)
+ require.Len(t, lk.downstreamMetaMap, 1)
+ require.Equal(t, downstreamMeta2, downstreamMeta)
downstreamMeta3, err := lk.getDownstreamMeta(task2)
- c.Assert(err, check.IsNil)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 2)
- c.Assert(lk.downstreamMetaMap, check.HasKey, task1)
- c.Assert(lk.downstreamMetaMap, check.HasKey, task2)
- c.Assert(downstreamMeta3, check.Equals, lk.downstreamMetaMap[task2])
+ require.NoError(t, err)
+ require.Len(t, lk.downstreamMetaMap, 2)
+ require.Contains(t, lk.downstreamMetaMap, task1)
+ require.Contains(t, lk.downstreamMetaMap, task2)
+ require.Equal(t, lk.downstreamMetaMap[task2], downstreamMeta3)
lk.RemoveDownstreamMeta(task3)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 2)
- c.Assert(lk.downstreamMetaMap, check.HasKey, task1)
- c.Assert(lk.downstreamMetaMap, check.HasKey, task2)
+ require.Len(t, lk.downstreamMetaMap, 2)
+ require.Contains(t, lk.downstreamMetaMap, task1)
+ require.Contains(t, lk.downstreamMetaMap, task2)
lk.RemoveDownstreamMeta(task1)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 1)
- c.Assert(lk.downstreamMetaMap, check.HasKey, task2)
- c.Assert(downstreamMeta3, check.Equals, lk.downstreamMetaMap[task2])
+ require.Len(t, lk.downstreamMetaMap, 1)
+ require.Contains(t, lk.downstreamMetaMap, task2)
+ require.Equal(t, lk.downstreamMetaMap[task2], downstreamMeta3)
downstreamMeta, err = lk.getDownstreamMeta(task1)
- c.Assert(err, check.IsNil)
- c.Assert(lk.downstreamMetaMap, check.HasLen, 2)
- c.Assert(downstreamMeta, check.Equals, lk.downstreamMetaMap[task1])
- c.Assert(downstreamMeta3, check.Equals, lk.downstreamMetaMap[task2])
+ require.NoError(t, err)
+ require.Len(t, lk.downstreamMetaMap, 2)
+ require.Equal(t, lk.downstreamMetaMap[task1], downstreamMeta)
+ require.Equal(t, lk.downstreamMetaMap[task2], downstreamMeta3)
lk.Clear()
- c.Assert(lk.downstreamMetaMap, check.HasLen, 0)
+ require.Len(t, lk.downstreamMetaMap, 0)
}
-func (t *testKeeper) TestUpdateSourceTables(c *check.C) {
+func TestUpdateSourceTables(t *testing.T) {
var (
tk = NewTableKeeper()
task1 = "task-1"
@@ -573,18 +558,18 @@ func (t *testKeeper) TestUpdateSourceTables(c *check.C) {
// put st11
addTables, dropTables := tk.Update(st11)
- c.Assert(addTables, check.HasLen, 2)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 2)
+ require.Len(t, dropTables, 0)
// put st11 again
addTables, dropTables = tk.Update(st11)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 0)
// put st12
addTables, dropTables = tk.Update(st12)
- c.Assert(addTables, check.HasLen, 2)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 2)
+ require.Len(t, dropTables, 0)
// update and put st12
newST := NewSourceTables(task1, source2)
@@ -596,16 +581,16 @@ func (t *testKeeper) TestUpdateSourceTables(c *check.C) {
newST.RemoveTable("db", "tbl-1", downSchema, downTable)
newST.AddTable("db", "tbl-3", downSchema, downTable)
addTables, dropTables = tk.Update(newST)
- c.Assert(addTables, check.HasLen, 1)
- c.Assert(dropTables, check.HasLen, 1)
+ require.Len(t, addTables, 1)
+ require.Len(t, dropTables, 1)
// put st12 again
addTables, dropTables = tk.Update(newST)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 0)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 0)
// delete source table
newST.IsDeleted = true
addTables, dropTables = tk.Update(newST)
- c.Assert(addTables, check.HasLen, 0)
- c.Assert(dropTables, check.HasLen, 2)
+ require.Len(t, addTables, 0)
+ require.Len(t, dropTables, 2)
}
diff --git a/dm/pkg/shardddl/optimism/lock_test.go b/dm/pkg/shardddl/optimism/lock_test.go
index f952463d4c..a5dd00bd04 100644
--- a/dm/pkg/shardddl/optimism/lock_test.go
+++ b/dm/pkg/shardddl/optimism/lock_test.go
@@ -19,7 +19,6 @@ import (
"testing"
"github.com/DATA-DOG/go-sqlmock"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/parser/ast"
@@ -31,32 +30,27 @@ import (
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
- "go.etcd.io/etcd/tests/v3/integration"
+ "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
)
-type testLock struct{}
-
-var _ = check.Suite(&testLock{})
+type testLock struct {
+ suite.Suite
+}
func TestLock(t *testing.T) {
- integration.BeforeTestExternal(t)
- mockCluster := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
- defer mockCluster.Terminate(t)
-
- etcdTestCli = mockCluster.RandClient()
-
- check.TestingT(t)
+ suite.Run(t, new(testLock))
}
-func (t *testLock) SetUpSuite(c *check.C) {
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+func (t *testLock) SetupSuite() {
+ t.Require().NoError(log.InitLogger(&log.Config{}))
}
-func (t *testLock) TearDownSuite(c *check.C) {
- clearTestInfoOperation(c)
+func (t *testLock) TearDownSuite() {
+ clearTestInfoOperation(t.T())
}
-func (t *testLock) TestLockTrySyncNormal(c *check.C) {
+func (t *testLock) TestLockTrySyncNormal() {
var (
ID = "test_lock_try_sync_normal-`foo`.`bar`"
task = "test_lock_try_sync_normal"
@@ -73,11 +67,11 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c2 BIGINT", "ALTER TABLE bar ADD COLUMN c3 TEXT"}
DDLs3 = []string{"ALTER TABLE bar DROP COLUMN c3"}
DDLs4 = []string{"ALTER TABLE bar DROP COLUMN c2", "ALTER TABLE bar DROP COLUMN c1"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT, c3 TEXT)`)
- ti2_1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT, c3 TEXT)`)
+ ti2_1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
ti4 = ti0
ti4_1 = ti1
tables = map[string]map[string]struct{}{
@@ -104,8 +98,8 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: all tables execute a single & same DDL (schema become larger).
syncedCount := 0
@@ -116,7 +110,7 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
synced := source != source2 // tables before the last source have synced.
for _, db2 := range dbs {
for _, tbl2 := range tbls {
- c.Assert(ready[source2][db2][tbl2], check.Equals, synced)
+ t.Require().Equal(synced, ready[source2][db2][tbl2])
}
}
}
@@ -126,113 +120,113 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
for _, tbl := range tbls {
info := newInfoWithVersion(task, source, db, tbl, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
syncedCount++
synced, remain := l.IsSynced()
- c.Assert(synced, check.Equals, syncedCount == tableCount)
- c.Assert(remain, check.Equals, tableCount-syncedCount)
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().Equal(syncedCount == tableCount, synced)
+ t.Require().Equal(tableCount-syncedCount, remain)
+ t.Require().Equal(l.synced, synced)
}
}
}
// synced again after all tables applied the DDL.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: TrySync again after synced is idempotent.
info := newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: need to add more than one DDL to reach the desired schema (schema become larger).
// add two columns for one table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsTrue)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
// TrySync again is idempotent (more than one DDL).
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsTrue)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
// add only the first column for another table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs2[0:1], ti1, []*model.TableInfo{ti2_1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2[0:1])
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2[0:1], DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsTrue)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
synced, remain := l.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, tableCount-1)
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().False(synced)
+ t.Require().Equal(tableCount-1, remain)
+ t.Require().Equal(l.synced, synced)
cmp, err := l.tables[sources[0]][dbs[0]][tbls[0]].Compare(l.tables[sources[0]][dbs[0]][tbls[1]])
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 1)
+ t.Require().NoError(err)
+ t.Require().Equal(1, cmp)
// TrySync again is idempotent
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs2[0:1], ti1, []*model.TableInfo{ti2_1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2[0:1])
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2[0:1], DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsTrue)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
// add the second column for another table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs2[1:2], ti2_1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2[1:2])
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2[1:2], DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsTrue) // ready now.
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[1]]) // ready now.
synced, remain = l.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, tableCount-2)
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().False(synced)
+ t.Require().Equal(tableCount-2, remain)
+ t.Require().Equal(l.synced, synced)
cmp, err = l.tables[sources[0]][dbs[0]][tbls[0]].Compare(l.tables[sources[0]][dbs[0]][tbls[1]])
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
// Try again (for the second DDL).
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs2[1:2], ti2_1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2[1:2])
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2[1:2], DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
- t.trySyncForAllTablesLarger(c, l, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, tts, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.trySyncForAllTablesLarger(l, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, tts, vers)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: all tables execute a single & same DDL (schema become smaller).
syncedCount = 0
@@ -243,7 +237,7 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
synced = source == source2 // tables before the last source have not synced.
for _, db2 := range dbs {
for _, tbl2 := range tbls {
- c.Assert(ready[source2][db2][tbl2], check.Equals, synced)
+ t.Require().Equal(synced, ready[source2][db2][tbl2])
}
}
}
@@ -254,92 +248,92 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
syncedCount++
info = newInfoWithVersion(task, source, db, tbl, downSchema, downTable, DDLs3, ti2, []*model.TableInfo{ti3}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(cols, check.DeepEquals, []string{"c3"})
+ t.Require().NoError(err)
+ t.Require().Equal(vers, l.versions)
+ t.Require().Equal([]string{"c3"}, cols)
synced, remain = l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().Equal(l.synced, synced)
if syncedCount == tableCount {
- c.Assert(DDLs, check.DeepEquals, DDLs3)
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ t.Require().Equal(DDLs3, DDLs)
+ t.Require().True(synced)
+ t.Require().Equal(0, remain)
} else {
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, syncedCount)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().False(synced)
+ t.Require().Equal(syncedCount, remain)
}
}
}
}
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: need to drop more than one DDL to reach the desired schema (schema become smaller).
// drop two columns for one table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs4, ti3, []*model.TableInfo{ti4_1, ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c2", "c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c2", "c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsFalse)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsTrue)
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[1]])
// TrySync again is idempotent.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs4, ti3, []*model.TableInfo{ti4_1, ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c2", "c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c2", "c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsFalse)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsTrue)
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().True(ready[sources[0]][dbs[0]][tbls[1]])
// drop only the first column for another table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs4[0:1], ti3, []*model.TableInfo{ti4_1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsFalse)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
cmp, err = l.tables[sources[0]][dbs[0]][tbls[0]].Compare(l.tables[sources[0]][dbs[0]][tbls[1]])
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync again (only the first DDL).
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs4[0:1], ti3, []*model.TableInfo{ti4_1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
// drop the second column for another table.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs4[1:2], ti4_1, []*model.TableInfo{ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[sources[0]][dbs[0]][tbls[0]], check.IsFalse)
- c.Assert(ready[sources[0]][dbs[0]][tbls[1]], check.IsFalse)
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[0]])
+ t.Require().False(ready[sources[0]][dbs[0]][tbls[1]])
cmp, err = l.tables[sources[0]][dbs[0]][tbls[0]].Compare(l.tables[sources[0]][dbs[0]][tbls[1]])
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
// TrySync again (for the second DDL).
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[1], downSchema, downTable, DDLs4[1:2], ti4_1, []*model.TableInfo{ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
// try drop columns for other tables to reach the same schema.
remain = tableCount - 2
@@ -349,24 +343,24 @@ func (t *testLock) TestLockTrySyncNormal(c *check.C) {
if synced2 { // do not `TrySync` again for previous two (un-synced now).
info = newInfoWithVersion(task, source, schema, table, downSchema, downTable, DDLs4, ti3, []*model.TableInfo{ti4_1, ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(cols, check.DeepEquals, []string{"c2", "c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{"c2", "c1"}, cols)
+ t.Require().Equal(vers, l.versions)
remain--
if remain == 0 {
- c.Assert(DDLs, check.DeepEquals, DDLs4)
+ t.Require().Equal(DDLs4, DDLs)
} else {
- c.Assert(DDLs, check.DeepEquals, []string{})
+ t.Require().Equal([]string{}, DDLs)
}
}
}
}
}
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
}
-func (t *testLock) TestLockTrySyncIndex(c *check.C) {
+func (t *testLock) TestLockTrySyncIndex() {
// nolint:dupl
var (
ID = "test_lock_try_sync_index-`foo`.`bar`"
@@ -381,8 +375,8 @@ func (t *testLock) TestLockTrySyncIndex(c *check.C) {
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar DROP INDEX idx_c1"}
DDLs2 = []string{"ALTER TABLE bar ADD UNIQUE INDEX idx_c1(c1)"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
ti2 = ti0
tables = map[string]map[string]struct{}{
db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
@@ -401,55 +395,55 @@ func (t *testLock) TestLockTrySyncIndex(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// try sync for one table, `DROP INDEX` returned directly (to make schema become more compatible).
// `DROP INDEX` is handled like `ADD COLUMN`.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
synced, remain := l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ t.Require().Equal(l.synced, synced)
+ t.Require().False(synced)
+ t.Require().Equal(1, remain)
// try sync for another table, also got `DROP INDEX` now.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
// try sync for one table, `ADD INDEX` not returned directly (to keep the schema more compatible).
// `ADD INDEX` is handled like `DROP COLUMN`.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{}) // no DDLs returned
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs) // no DDLs returned
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
synced, remain = l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ t.Require().Equal(l.synced, synced)
+ t.Require().False(synced)
+ t.Require().Equal(1, remain)
// try sync for another table, got `ADD INDEX` now.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
}
-func (t *testLock) TestLockTrySyncNullNotNull(c *check.C) {
+func (t *testLock) TestLockTrySyncNullNotNull() {
// nolint:dupl
var (
ID = "test_lock_try_sync_null_not_null-`foo`.`bar`"
@@ -464,8 +458,8 @@ func (t *testLock) TestLockTrySyncNullNotNull(c *check.C) {
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar MODIFY COLUMN c1 INT NOT NULL DEFAULT 1234"}
DDLs2 = []string{"ALTER TABLE bar MODIFY COLUMN c1 INT NULL DEFAULT 1234"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT NULL DEFAULT 1234)`)
- ti1 = createTableInfo(c, p, se, tblID,
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT NULL DEFAULT 1234)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID,
`CREATE TABLE bar (id INT PRIMARY KEY, c1 INT NOT NULL DEFAULT 1234)`)
ti2 = ti0
tables = map[string]map[string]struct{}{
@@ -485,45 +479,45 @@ func (t *testLock) TestLockTrySyncNullNotNull(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
for i := 0; i < 2; i++ { // two round
// try sync for one table, from `NULL` to `NOT NULL`, no DDLs returned.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// try sync for another table, DDLs returned.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// try sync for one table, from `NOT NULL` to `NULL`, DDLs returned.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// try sync for another table, from `NOT NULL` to `NULL`, DDLs, returned.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
}
}
-func (t *testLock) TestLockTrySyncIntBigint(c *check.C) {
+func (t *testLock) TestLockTrySyncIntBigint() {
var (
ID = "test_lock_try_sync_int_bigint-`foo`.`bar`"
task = "test_lock_try_sync_int_bigint"
@@ -536,8 +530,8 @@ func (t *testLock) TestLockTrySyncIntBigint(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar MODIFY COLUMN c1 BIGINT NOT NULL DEFAULT 1234"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT NOT NULL DEFAULT 1234)`)
- ti1 = createTableInfo(c, p, se, tblID,
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT NOT NULL DEFAULT 1234)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID,
`CREATE TABLE bar (id INT PRIMARY KEY, c1 BIGINT NOT NULL DEFAULT 1234)`)
tables = map[string]map[string]struct{}{
db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
@@ -556,27 +550,27 @@ func (t *testLock) TestLockTrySyncIntBigint(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// try sync for one table, from `INT` to `BIGINT`, DDLs returned.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// try sync for another table, DDLs returned.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
}
-func (t *testLock) TestLockTrySyncNoDiff(c *check.C) {
+func (t *testLock) TestLockTrySyncNoDiff() {
var (
ID = "test_lock_try_sync_no_diff-`foo`.`bar`"
task = "test_lock_try_sync_no_diff"
@@ -589,8 +583,8 @@ func (t *testLock) TestLockTrySyncNoDiff(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar RENAME c1 TO c2"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti1 = createTableInfo(c, p, se, tblID,
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID,
`CREATE TABLE bar (id INT PRIMARY KEY, c2 INT)`) // `c1` dropped, `c2` added
tables = map[string]map[string]struct{}{
db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
@@ -609,19 +603,19 @@ func (t *testLock) TestLockTrySyncNoDiff(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// try sync for one table.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismNeedSkipAndRedirect.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().True(terror.ErrShardDDLOptimismNeedSkipAndRedirect.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
}
-func (t *testLock) TestLockTrySyncNewTable(c *check.C) {
+func (t *testLock) TestLockTrySyncNewTable() {
var (
ID = "test_lock_try_sync_new_table-`foo`.`bar`"
task = "test_lock_try_sync_new_table"
@@ -637,8 +631,8 @@ func (t *testLock) TestLockTrySyncNewTable(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 INT"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
tables = map[string]map[string]struct{}{db1: {tbl1: struct{}{}}}
tts = []TargetTable{newTargetTable(task, source1, downSchema, downTable, tables)}
@@ -654,25 +648,25 @@ func (t *testLock) TestLockTrySyncNewTable(c *check.C) {
)
// only one table exists before TrySync.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// TrySync for a new table as the caller.
info := newInfoWithVersion(task, source2, db2, tbl2, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready, check.HasLen, 2)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db1], check.HasLen, 1)
- c.Assert(ready[source1][db1][tbl1], check.IsFalse)
- c.Assert(ready[source2], check.HasLen, 1)
- c.Assert(ready[source2][db2], check.HasLen, 1)
- c.Assert(ready[source2][db2][tbl2], check.IsTrue)
+ t.Require().Len(ready, 2)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db1], 1)
+ t.Require().False(ready[source1][db1][tbl1])
+ t.Require().Len(ready[source2], 1)
+ t.Require().Len(ready[source2][db2], 1)
+ t.Require().True(ready[source2][db2][tbl2])
// TrySync for two new tables as extra sources.
// newly added work table use tableInfoBefore as table info
@@ -685,42 +679,42 @@ func (t *testLock) TestLockTrySyncNewTable(c *check.C) {
info = newInfoWithVersion(task, source1, db1, tbl1, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 2)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db1], check.HasLen, 2)
- c.Assert(ready[source1][db1][tbl1], check.IsTrue)
- c.Assert(ready[source1][db1][tbl2], check.IsFalse) // new table use ti0 as init table
- c.Assert(ready[source2], check.HasLen, 1)
- c.Assert(ready[source2][db2], check.HasLen, 2)
- c.Assert(ready[source2][db2][tbl1], check.IsFalse)
- c.Assert(ready[source2][db2][tbl2], check.IsTrue)
+ t.Require().Len(ready, 2)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db1], 2)
+ t.Require().True(ready[source1][db1][tbl1])
+ t.Require().False(ready[source1][db1][tbl2]) // new table use ti0 as init table
+ t.Require().Len(ready[source2], 1)
+ t.Require().Len(ready[source2][db2], 2)
+ t.Require().False(ready[source2][db2][tbl1])
+ t.Require().True(ready[source2][db2][tbl2])
info = newInfoWithVersion(task, source1, db1, tbl2, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 2)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db1], check.HasLen, 2)
- c.Assert(ready[source1][db1][tbl1], check.IsTrue)
- c.Assert(ready[source1][db1][tbl2], check.IsTrue)
- c.Assert(ready[source2], check.HasLen, 1)
- c.Assert(ready[source2][db2], check.HasLen, 2)
- c.Assert(ready[source2][db2][tbl1], check.IsFalse)
- c.Assert(ready[source2][db2][tbl2], check.IsTrue)
+ t.Require().Len(ready, 2)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db1], 2)
+ t.Require().True(ready[source1][db1][tbl1])
+ t.Require().True(ready[source1][db1][tbl2])
+ t.Require().Len(ready[source2], 1)
+ t.Require().Len(ready[source2][db2], 2)
+ t.Require().False(ready[source2][db2][tbl1])
+ t.Require().True(ready[source2][db2][tbl2])
}
-func (t *testLock) TestLockTrySyncRevert(c *check.C) {
+func (t *testLock) TestLockTrySyncRevert() {
var (
ID = "test_lock_try_sync_revert-`foo`.`bar`"
task = "test_lock_try_sync_revert"
@@ -735,15 +729,15 @@ func (t *testLock) TestLockTrySyncRevert(c *check.C) {
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 TEXT"}
DDLs2 = []string{"ALTER TABLE bar DROP COLUMN c1"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
ti2 = ti0
DDLs3 = []string{"ALTER TABLE bar ADD COLUMN c1 TEXT", "ALTER TABLE bar ADD COLUMN c2 INT"}
DDLs4 = []string{"ALTER TABLE bar DROP COLUMN c2"}
DDLs5 = []string{"ALTER TABLE bar DROP COLUMN c1"}
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 INT)`)
- ti4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 INT)`)
+ ti4 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
ti5 = ti0
DDLs6 = DDLs3
@@ -765,149 +759,149 @@ func (t *testLock) TestLockTrySyncRevert(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: revert for single DDL.
// TrySync for one table.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err := l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err := l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// revert for the table, become synced again.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// Simulate watch done operation from dm-worker
op := NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], DDLs2, ConflictNone, "", true, []string{"c1"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
// CASE: revert for multiple DDLs.
// TrySync for one table.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs3, ti0, []*model.TableInfo{ti4, ti3}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs3)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs3, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// revert part of the DDLs.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs4, ti3, []*model.TableInfo{ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs4)
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs4, DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// revert the reset part of the DDLs.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs5, ti4, []*model.TableInfo{ti5}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs5)
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs5, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// Simulate watch done operation from dm-worker
op = NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], DDLs4, ConflictNone, "", true, []string{"c2"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
op = NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], DDLs5, ConflictNone, "", true, []string{"c1"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
// CASE: revert part of multiple DDLs.
// TrySync for one table.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs6, ti0, []*model.TableInfo{ti7, ti6}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs6)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs6, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// revert part of the DDLs.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs7, ti3, []*model.TableInfo{ti7}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs7)
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs7, DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for another table.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs8, ti0, []*model.TableInfo{ti8}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs8)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs8, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
}
-func (t *testLock) TestLockTrySyncConflictNonIntrusive(c *check.C) {
+func (t *testLock) TestLockTrySyncConflictNonIntrusive() {
var (
ID = "test_lock_try_sync_conflict_non_intrusive-`foo`.`bar`"
task = "test_lock_try_sync_conflict_non_intrusive"
@@ -923,10 +917,10 @@ func (t *testLock) TestLockTrySyncConflictNonIntrusive(c *check.C) {
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c1 DATETIME", "ALTER TABLE bar ADD COLUMN c2 INT"}
DDLs3 = []string{"ALTER TABLE bar DROP COLUMN c1"}
DDLs4 = DDLs2
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME, c2 INT)`)
- ti2_1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME, c2 INT)`)
+ ti2_1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
ti3 = ti0
ti4 = ti2
ti4_1 = ti2_1
@@ -943,94 +937,94 @@ func (t *testLock) TestLockTrySyncConflictNonIntrusive(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// TrySync for the first table, construct the joined schema.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err := l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err := l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for the second table with another schema (add two columns, one of them will cause conflict).
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismTrySyncFail.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().True(terror.ErrShardDDLOptimismTrySyncFail.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
// join table isn't updated
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
// TrySync for the first table to resolve the conflict.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs3, ti1, []*model.TableInfo{ti3}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs3)
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs3, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready() // all table ready
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsTrue)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().True(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
// TrySync for the second table, succeed now
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsTrue)
+ t.Require().True(ready[source][db][tbls[1]])
// Simulate watch done operation from dm-worker
op := NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], DDLs3, ConflictNone, "", true, []string{"c1"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
// TrySync for the first table.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs4, ti0, []*model.TableInfo{ti4_1, ti4}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs4)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs4, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
}
-func (t *testLock) TestLockTrySyncConflictIntrusive(c *check.C) {
+func (t *testLock) TestLockTrySyncConflictIntrusive() {
var (
ID = "test_lock_try_sync_conflict_intrusive-`foo`.`bar`"
task = "test_lock_try_sync_conflict_intrusive"
@@ -1045,21 +1039,21 @@ func (t *testLock) TestLockTrySyncConflictIntrusive(c *check.C) {
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 TEXT"}
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c1 DATETIME", "ALTER TABLE bar ADD COLUMN c2 INT"}
DDLs3 = []string{"ALTER TABLE bar ADD COLUMN c1 DATETIME"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME, c2 INT)`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME, c2 INT)`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
DDLs5 = []string{"ALTER TABLE bar ADD COLUMN c2 TEXT"}
DDLs6 = []string{"ALTER TABLE bar ADD COLUMN c2 DATETIME", "ALTER TABLE bar ADD COLUMN c3 INT"}
DDLs7 = []string{"ALTER TABLE bar ADD COLUMN c3 INT"}
DDLs8_1 = DDLs7
DDLs8_2 = DDLs5
- ti5 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 TEXT)`)
- ti6 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 DATETIME, c3 INT)`)
- ti6_1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 DATETIME)`)
- ti7 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c3 INT)`)
- ti8 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 TEXT, c3 INT)`)
+ ti5 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 TEXT)`)
+ ti6 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 DATETIME, c3 INT)`)
+ ti6_1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 DATETIME)`)
+ ti7 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c3 INT)`)
+ ti8 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT, c2 TEXT, c3 INT)`)
tables = map[string]map[string]struct{}{db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}}}
tts = []TargetTable{newTargetTable(task, source, downSchema, downTable, tables)}
@@ -1073,167 +1067,167 @@ func (t *testLock) TestLockTrySyncConflictIntrusive(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: conflict happen, revert all changes to resolve the conflict.
// TrySync for the first table, construct the joined schema.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err := l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err := l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for the second table with another schema (add two columns, one of them will cause conflict).
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti3, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismTrySyncFail.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().True(terror.ErrShardDDLOptimismTrySyncFail.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
// join table isn't updated
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
// TrySync again.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti3, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismTrySyncFail.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().True(terror.ErrShardDDLOptimismTrySyncFail.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for the second table to replace a new ddl without non-conflict column, the conflict should still exist.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs3, ti0, []*model.TableInfo{ti3}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismTrySyncFail.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().True(terror.ErrShardDDLOptimismTrySyncFail.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
// TrySync for the second table as we did for the first table, the lock should be synced.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: conflict happen, revert part of changes to resolve the conflict.
// TrySync for the first table, construct the joined schema.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs5, ti1, []*model.TableInfo{ti5}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs5)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs5, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().True(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for the second table with another schema (add two columns, one of them will cause conflict).
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs6, ti1, []*model.TableInfo{ti6_1, ti6}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(terror.ErrShardDDLOptimismTrySyncFail.Equal(err), check.IsTrue)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
+ t.Require().True(terror.ErrShardDDLOptimismTrySyncFail.Equal(err))
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[1]])
// TrySync for the second table to replace a new ddl without conflict column, the conflict should be resolved.
// but both of tables are not synced now.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs7, ti1, []*model.TableInfo{ti7}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs7)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs7, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsFalse)
- c.Assert(ready[source][db][tbls[1]], check.IsFalse)
+ t.Require().False(ready[source][db][tbls[0]])
+ t.Require().False(ready[source][db][tbls[1]])
joined, err = l.Joined()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
cmp, err = l.tables[source][db][tbls[1]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ t.Require().NoError(err)
+ t.Require().Equal(-1, cmp)
// TrySync for the first table to become synced.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs8_1, ti5, []*model.TableInfo{ti8}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs8_1)
- c.Assert(cols, check.DeepEquals, []string{})
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs8_1, DDLs)
+ t.Require().Equal([]string{}, cols)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[0]], check.IsTrue)
+ t.Require().True(ready[source][db][tbls[0]])
// TrySync for the second table to become synced.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs8_2, ti7, []*model.TableInfo{ti8}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs8_2)
- c.Assert(cols, check.DeepEquals, []string{})
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs8_2, DDLs)
+ t.Require().Equal([]string{}, cols)
ready = l.Ready()
- c.Assert(ready[source][db][tbls[1]], check.IsTrue)
+ t.Require().True(ready[source][db][tbls[1]])
// all tables synced now.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
}
-func (t *testLock) TestLockTrySyncMultipleChangeDDL(c *check.C) {
+func (t *testLock) TestLockTrySyncMultipleChangeDDL() {
var (
ID = "test_lock_try_sync_normal-`foo`.`bar`"
task = "test_lock_try_sync_normal"
@@ -1250,12 +1244,12 @@ func (t *testLock) TestLockTrySyncMultipleChangeDDL(c *check.C) {
DDLs2 = []string{"ALTER TABLE bar DROP COLUMN c2", "ALTER TABLE bar ADD COLUMN c3 TEXT"}
// DDLs3 = []string{"ALTER TABLE bar DROP COLUMN c3"}
// DDLs4 = []string{"ALTER TABLE bar DROP COLUMN c2", "ALTER TABLE bar DROP COLUMN c1"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti1_1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c2 INT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c3 TEXT)`)
- ti2_1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- // ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti1_1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c2 INT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c3 TEXT)`)
+ ti2_1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ // ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 BIGINT)`)
// ti4 = ti0
// ti4_1 = ti1
tables = map[string]map[string]struct{}{
@@ -1282,24 +1276,24 @@ func (t *testLock) TestLockTrySyncMultipleChangeDDL(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// inconsistent ddls and table infos
info := newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs1[:1], ti0, []*model.TableInfo{ti1_1, ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(terror.ErrMasterInconsistentOptimisticDDLsAndInfo.Equal(err), check.IsTrue)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().True(terror.ErrMasterInconsistentOptimisticDDLsAndInfo.Equal(err))
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(terror.ErrMasterInconsistentOptimisticDDLsAndInfo.Equal(err), check.IsTrue)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().True(terror.ErrMasterInconsistentOptimisticDDLsAndInfo.Equal(err))
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: all tables execute a same multiple change DDLs1
syncedCount := 0
@@ -1318,32 +1312,32 @@ func (t *testLock) TestLockTrySyncMultipleChangeDDL(c *check.C) {
for _, tbl := range tbls {
info = newInfoWithVersion(task, source, db, tbl, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1_1, ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, resultDDLs1[source][db][tbl])
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(resultDDLs1[source][db][tbl], DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
syncedCount++
synced, _ := l.IsSynced()
- c.Assert(synced, check.Equals, syncedCount == tableCount)
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().Equal(syncedCount == tableCount, synced)
+ t.Require().Equal(l.synced, synced)
}
}
}
// synced again after all tables applied the DDL.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: TrySync again after synced is idempotent.
// both ddl will sync again
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1_1, ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: all tables execute a same multiple change DDLs2
syncedCount = 0
@@ -1362,34 +1356,34 @@ func (t *testLock) TestLockTrySyncMultipleChangeDDL(c *check.C) {
for _, tbl := range tbls {
info = newInfoWithVersion(task, source, db, tbl, downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, resultDDLs2[source][db][tbl])
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(resultDDLs2[source][db][tbl], DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
syncedCount++
synced, _ := l.IsSynced()
- c.Assert(synced, check.Equals, syncedCount == tableCount)
- c.Assert(synced, check.Equals, l.synced)
+ t.Require().Equal(syncedCount == tableCount, synced)
+ t.Require().Equal(l.synced, synced)
}
}
}
// synced again after all tables applied the DDL.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: TrySync again after synced is idempotent.
info = newInfoWithVersion(task, sources[0], dbs[0], tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2_1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{"c2"})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{"c2"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
}
-func (t *testLock) TestTryRemoveTable(c *check.C) {
+func (t *testLock) TestTryRemoveTable() {
var (
ID = "test_lock_try_remove_table-`foo`.`bar`"
task = "test_lock_try_remove_table"
@@ -1404,9 +1398,9 @@ func (t *testLock) TestTryRemoveTable(c *check.C) {
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 INT"}
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c2 INT"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
tables = map[string]map[string]struct{}{db: {tbl1: struct{}{}, tbl2: struct{}{}}}
tts = []TargetTable{newTargetTable(task, source, downSchema, downTable, tables)}
@@ -1420,23 +1414,23 @@ func (t *testLock) TestTryRemoveTable(c *check.C) {
)
// only one table exists before TrySync.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// CASE: remove a table as normal.
// TrySync for the first table.
info := newInfoWithVersion(task, source, db, tbl1, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source], check.HasLen, 1)
- c.Assert(ready[source][db], check.HasLen, 2)
- c.Assert(ready[source][db][tbl1], check.IsTrue)
- c.Assert(ready[source][db][tbl2], check.IsFalse)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source], 1)
+ t.Require().Len(ready[source][db], 2)
+ t.Require().True(ready[source][db][tbl1])
+ t.Require().False(ready[source][db][tbl2])
// TryRemoveTable for the second table.
l.columns = map[string]map[string]map[string]map[string]DropColumnStage{
@@ -1445,48 +1439,48 @@ func (t *testLock) TestTryRemoveTable(c *check.C) {
},
}
col := l.TryRemoveTable(source, db, tbl2)
- c.Assert(col, check.DeepEquals, []string{"col"})
+ t.Require().Equal([]string{"col"}, col)
delete(vers[source][db], tbl2)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source], check.HasLen, 1)
- c.Assert(ready[source][db], check.HasLen, 1)
- c.Assert(ready[source][db][tbl1], check.IsTrue)
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source], 1)
+ t.Require().Len(ready[source][db], 1)
+ t.Require().True(ready[source][db][tbl1])
+ t.Require().Equal(vers, l.versions)
// CASE: remove a table will rebuild joined schema now.
// TrySync to add the second back.
vers[source][db][tbl2] = 0
info = newInfoWithVersion(task, source, db, tbl2, downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source], check.HasLen, 1)
- c.Assert(ready[source][db], check.HasLen, 2)
- c.Assert(ready[source][db][tbl1], check.IsFalse)
- c.Assert(ready[source][db][tbl2], check.IsTrue)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source], 1)
+ t.Require().Len(ready[source][db], 2)
+ t.Require().False(ready[source][db][tbl1])
+ t.Require().True(ready[source][db][tbl2])
// TryRemoveTable for the second table.
- c.Assert(l.TryRemoveTable(source, db, tbl2), check.HasLen, 0)
+ t.Require().Len(l.TryRemoveTable(source, db, tbl2), 0)
delete(vers[source][db], tbl2)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source], check.HasLen, 1)
- c.Assert(ready[source][db], check.HasLen, 1)
- c.Assert(ready[source][db][tbl1], check.IsTrue) // the joined schema is rebuild.
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source], 1)
+ t.Require().Len(ready[source][db], 1)
+ t.Require().True(ready[source][db][tbl1]) // the joined schema is rebuild.
+ t.Require().Equal(vers, l.versions)
// CASE: try to remove for not-exists table.
- c.Assert(l.TryRemoveTable(source, db, "not-exist"), check.HasLen, 0)
- c.Assert(l.TryRemoveTable(source, "not-exist", tbl1), check.HasLen, 0)
- c.Assert(l.TryRemoveTable("not-exist", db, tbl1), check.HasLen, 0)
+ t.Require().Len(l.TryRemoveTable(source, db, "not-exist"), 0)
+ t.Require().Len(l.TryRemoveTable(source, "not-exist", tbl1), 0)
+ t.Require().Len(l.TryRemoveTable("not-exist", db, tbl1), 0)
}
-func (t *testLock) TestTryRemoveTableWithSources(c *check.C) {
+func (t *testLock) TestTryRemoveTableWithSources() {
var (
ID = "test_lock_try_remove_table-`foo`.`bar`"
task = "test_lock_try_remove_table"
@@ -1501,8 +1495,8 @@ func (t *testLock) TestTryRemoveTableWithSources(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar DROP COLUMN c1"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
tables = map[string]map[string]struct{}{db: {tbl1: struct{}{}, tbl2: struct{}{}}}
tts = []TargetTable{newTargetTable(task, source1, downSchema, downTable, tables), newTargetTable(task, source2, downSchema, downTable, tables)}
@@ -1519,71 +1513,71 @@ func (t *testLock) TestTryRemoveTableWithSources(c *check.C) {
)
// only one table exists before TrySync.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// TrySync for the first table.
info := newInfoWithVersion(task, source1, db, tbl1, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready := l.Ready()
- c.Assert(ready, check.HasLen, 2)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db], check.HasLen, 2)
- c.Assert(ready[source1][db][tbl1], check.IsFalse)
- c.Assert(ready[source1][db][tbl2], check.IsTrue)
- c.Assert(ready[source2], check.HasLen, 1)
- c.Assert(ready[source2][db], check.HasLen, 2)
- c.Assert(ready[source2][db][tbl1], check.IsTrue)
- c.Assert(ready[source2][db][tbl2], check.IsTrue)
+ t.Require().Len(ready, 2)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db], 2)
+ t.Require().False(ready[source1][db][tbl1])
+ t.Require().True(ready[source1][db][tbl2])
+ t.Require().Len(ready[source2], 1)
+ t.Require().Len(ready[source2][db], 2)
+ t.Require().True(ready[source2][db][tbl1])
+ t.Require().True(ready[source2][db][tbl2])
// TryRemoveTableBySources with nil
- c.Assert(len(l.TryRemoveTableBySources(nil)), check.Equals, 0)
+ t.Require().Equal(0, len(l.TryRemoveTableBySources(nil)))
ready = l.Ready()
- c.Assert(ready, check.HasLen, 2)
+ t.Require().Len(ready, 2)
// TryRemoveTableBySources with wrong source
tts = tts[:1]
- c.Assert(len(l.TryRemoveTableBySources([]string{"hahaha"})), check.Equals, 0)
+ t.Require().Equal(0, len(l.TryRemoveTableBySources([]string{"hahaha"})))
ready = l.Ready()
- c.Assert(ready, check.HasLen, 2)
+ t.Require().Len(ready, 2)
// TryRemoveTableBySources with source2
- c.Assert(len(l.TryRemoveTableBySources([]string{source2})), check.Equals, 0)
+ t.Require().Equal(0, len(l.TryRemoveTableBySources([]string{source2})))
ready = l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db], check.HasLen, 2)
- c.Assert(ready[source1][db][tbl1], check.IsFalse)
- c.Assert(ready[source1][db][tbl2], check.IsTrue)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db], 2)
+ t.Require().False(ready[source1][db][tbl1])
+ t.Require().True(ready[source1][db][tbl2])
delete(vers, source2)
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.HasTables(), check.IsTrue)
+ t.Require().Equal(vers, l.versions)
+ t.Require().True(l.HasTables())
// TrySync with second table
info = newInfoWithVersion(task, source1, db, tbl2, downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().Equal(vers, l.versions)
ready = l.Ready()
- c.Assert(ready, check.HasLen, 1)
- c.Assert(ready[source1], check.HasLen, 1)
- c.Assert(ready[source1][db], check.HasLen, 2)
- c.Assert(ready[source1][db][tbl1], check.IsTrue)
- c.Assert(ready[source1][db][tbl2], check.IsTrue)
+ t.Require().Len(ready, 1)
+ t.Require().Len(ready[source1], 1)
+ t.Require().Len(ready[source1][db], 2)
+ t.Require().True(ready[source1][db][tbl1])
+ t.Require().True(ready[source1][db][tbl2])
// TryRemoveTableBySources with source1,source2
cols = l.TryRemoveTableBySources([]string{source1})
- c.Assert(cols, check.DeepEquals, []string{"c1"})
- c.Assert(l.HasTables(), check.IsFalse)
+ t.Require().Equal([]string{"c1"}, cols)
+ t.Require().False(l.HasTables())
}
-func (t *testLock) TestLockTryMarkDone(c *check.C) {
+func (t *testLock) TestLockTryMarkDone() {
var (
ID = "test_lock_try_mark_done-`foo`.`bar`"
task = "test_lock_try_mark_done"
@@ -1598,9 +1592,9 @@ func (t *testLock) TestLockTryMarkDone(c *check.C) {
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 INT"}
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c1 INT", "ALTER TABLE bar ADD COLUMN c2 INT"}
DDLs3 = []string{"ALTER TABLE bar ADD COLUMN c2 INT"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, c2 INT)`)
ti3 = ti2
tables = map[string]map[string]struct{}{db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}}}
@@ -1615,79 +1609,79 @@ func (t *testLock) TestLockTryMarkDone(c *check.C) {
)
// the initial status is synced but not resolved.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, no table has done the DDLs operation.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// mark done for the synced table, the lock is un-resolved.
- c.Assert(l.TryMarkDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[1]), check.IsFalse)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().True(l.TryMarkDone(source, db, tbls[0]))
+ t.Require().True(l.IsDone(source, db, tbls[0]))
+ t.Require().False(l.IsDone(source, db, tbls[1]))
+ t.Require().False(l.IsResolved())
// TrySync for the second table, the joined schema become larger.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti1, ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// the first table is still keep `done` (for the previous DDLs operation)
- c.Assert(l.IsDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[1]), check.IsFalse)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().True(l.IsDone(source, db, tbls[0]))
+ t.Require().False(l.IsDone(source, db, tbls[1]))
+ t.Require().False(l.IsResolved())
// mark done for the second table, both of them are done (for different DDLs operations)
- c.Assert(l.TryMarkDone(source, db, tbls[1]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[1]), check.IsTrue)
+ t.Require().True(l.TryMarkDone(source, db, tbls[1]))
+ t.Require().True(l.IsDone(source, db, tbls[0]))
+ t.Require().True(l.IsDone(source, db, tbls[1]))
// but the lock is still not resolved because tables have different schemas.
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, all tables become synced.
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs3, ti1, []*model.TableInfo{ti3}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs3)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs3, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// the first table become not-done, and the lock is un-resolved.
- c.Assert(l.IsDone(source, db, tbls[0]), check.IsFalse)
- c.Assert(l.IsDone(source, db, tbls[1]), check.IsTrue)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().False(l.IsDone(source, db, tbls[0]))
+ t.Require().True(l.IsDone(source, db, tbls[1]))
+ t.Require().False(l.IsResolved())
// mark done for the first table.
- c.Assert(l.TryMarkDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[0]), check.IsTrue)
- c.Assert(l.IsDone(source, db, tbls[1]), check.IsTrue)
+ t.Require().True(l.TryMarkDone(source, db, tbls[0]))
+ t.Require().True(l.IsDone(source, db, tbls[0]))
+ t.Require().True(l.IsDone(source, db, tbls[1]))
// the lock become resolved now.
- c.Assert(l.IsResolved(), check.IsTrue)
+ t.Require().True(l.IsResolved())
// TryMarkDone for not-existing table take no effect.
- c.Assert(l.TryMarkDone(source, db, "not-exist"), check.IsFalse)
- c.Assert(l.TryMarkDone(source, "not-exist", tbls[0]), check.IsFalse)
- c.Assert(l.TryMarkDone("not-exist", db, tbls[0]), check.IsFalse)
+ t.Require().False(l.TryMarkDone(source, db, "not-exist"))
+ t.Require().False(l.TryMarkDone(source, "not-exist", tbls[0]))
+ t.Require().False(l.TryMarkDone("not-exist", db, tbls[0]))
// check IsDone for not-existing table take no effect.
- c.Assert(l.IsDone(source, db, "not-exist"), check.IsFalse)
- c.Assert(l.IsDone(source, "not-exist", tbls[0]), check.IsFalse)
- c.Assert(l.IsDone("not-exist", db, tbls[0]), check.IsFalse)
+ t.Require().False(l.IsDone(source, db, "not-exist"))
+ t.Require().False(l.IsDone(source, "not-exist", tbls[0]))
+ t.Require().False(l.IsDone("not-exist", db, tbls[0]))
}
-func (t *testLock) TestAddDifferentFieldLenColumns(c *check.C) {
+func (t *testLock) TestAddDifferentFieldLenColumns() {
var (
ID = "test_lock_add_diff_flen_cols-`foo`.`bar`"
task = "test_lock_add_diff_flen_cols"
@@ -1700,9 +1694,9 @@ func (t *testLock) TestAddDifferentFieldLenColumns(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 VARCHAR(4))`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 VARCHAR(5))`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 VARCHAR(4))`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 VARCHAR(5))`)
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 VARCHAR(4)"}
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c1 VARCHAR(5)"}
@@ -1722,37 +1716,40 @@ func (t *testLock) TestAddDifferentFieldLenColumns(c *check.C) {
}
)
col, err := AddDifferentFieldLenColumns(ID, DDLs1[0], table1, table2)
- c.Assert(col, check.Equals, "c1")
- c.Assert(err, check.IsNil)
+ t.Require().Equal("c1", col)
+ t.Require().NoError(err)
col, err = AddDifferentFieldLenColumns(ID, DDLs2[0], table2, table3)
- c.Assert(col, check.Equals, "c1")
- c.Assert(err, check.ErrorMatches, ".*add columns with different field lengths.*")
+ t.Require().Equal("c1", col)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add columns with different field lengths.*", err.Error())
col, err = AddDifferentFieldLenColumns(ID, DDLs1[0], table3, table2)
- c.Assert(col, check.Equals, "c1")
- c.Assert(err, check.ErrorMatches, ".*add columns with different field lengths.*")
+ t.Require().Equal("c1", col)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add columns with different field lengths.*", err.Error())
// the initial status is synced but not resolved.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, no table has done the DDLs operation.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// TrySync for the second table, add a table with a larger field length
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.ErrorMatches, ".*add columns with different field lengths.*")
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add columns with different field lengths.*", err.Error())
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
// case 2: add a column with a smaller field length
l = NewLock(etcdTestCli, ID, task, downSchema, downTable, schemacmp.Encode(ti0), tts, nil)
@@ -1762,23 +1759,24 @@ func (t *testLock) TestAddDifferentFieldLenColumns(c *check.C) {
info = NewInfo(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti2})
info.Version = vers[source][db][tbls[1]]
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// TrySync for the second table, add a table with a smaller field length
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.ErrorMatches, ".*add columns with different field lengths.*")
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add columns with different field lengths.*", err.Error())
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
}
-func (t *testLock) TestAddNotFullyDroppedColumns(c *check.C) {
+func (t *testLock) TestAddNotFullyDroppedColumns() {
var (
ID = "test_lock_add_not_fully_dropped_cols-`foo`.`bar`"
task = "test_lock_add_not_fully_dropped_cols"
@@ -1791,10 +1789,10 @@ func (t *testLock) TestAddNotFullyDroppedColumns(c *check.C) {
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int, c int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c int)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int, c int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c int)`)
DDLs1 = []string{"ALTER TABLE bar DROP COLUMN c"}
DDLs2 = []string{"ALTER TABLE bar DROP COLUMN b"}
@@ -1831,105 +1829,108 @@ func (t *testLock) TestAddNotFullyDroppedColumns(c *check.C) {
}
)
col, err := GetColumnName(ID, DDLs1[0], ast.AlterTableDropColumn)
- c.Assert(col, check.Equals, "c")
- c.Assert(err, check.IsNil)
+ t.Require().Equal("c", col)
+ t.Require().NoError(err)
col, err = GetColumnName(ID, DDLs2[0], ast.AlterTableDropColumn)
- c.Assert(col, check.Equals, "b")
- c.Assert(err, check.IsNil)
+ t.Require().Equal("b", col)
+ t.Require().NoError(err)
// the initial status is synced but not resolved.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, drop column c
DDLs, cols, err := l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"c"})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"c"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, drop column b
DDLs, cols, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{})
- c.Assert(cols, check.DeepEquals, []string{"b"})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs)
+ t.Require().Equal([]string{"b"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
colm, _, err := GetAllDroppedColumns(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(colm, check.DeepEquals, colm1)
+ t.Require().NoError(err)
+ t.Require().Equal(colm1, colm)
// TrySync for the second table, drop column b, this column should be fully dropped
DDLs, cols, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti0, []*model.TableInfo{ti3}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{"b"})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{"b"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
// Simulate watch done operation from dm-worker
op := NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[1], DDLs2, ConflictNone, "", true, []string{"b"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
colm, _, err = GetAllDroppedColumns(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(colm, check.DeepEquals, colm2)
+ t.Require().NoError(err)
+ t.Require().Equal(colm2, colm)
op = NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], []string{}, ConflictNone, "", true, []string{"b"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
colm, _, err = GetAllDroppedColumns(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(colm, check.DeepEquals, colm3)
+ t.Require().NoError(err)
+ t.Require().Equal(colm3, colm)
// TrySync for the first table, add column b, should succeed, because this column is fully dropped in the downstream
DDLs, cols, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs3, ti2, []*model.TableInfo{ti1}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs3)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs3, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
// TrySync for the first table, add column c, should fail, because this column isn't fully dropped in the downstream
_, _, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs4, ti1, []*model.TableInfo{ti0}, vers), tts)
- c.Assert(err, check.ErrorMatches, ".*add column c that wasn't fully dropped in downstream.*")
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add column c that wasn't fully dropped in downstream.*", err.Error())
+ t.Require().False(l.IsResolved())
// TrySync for the second table, drop column c, this column should be fully dropped
DDLs, cols, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs1, ti3, []*model.TableInfo{ti2}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{"c"})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{"c"}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
// Simulate watch done operation from dm-worker
op = NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[1], DDLs1, ConflictNone, "", true, []string{"c"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
// TrySync for the second table, add column c, should fail, because this column isn't fully dropped in the downstream
_, _, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs4, ti1, []*model.TableInfo{ti0}, vers), tts)
- c.Assert(err, check.ErrorMatches, ".*add column c that wasn't fully dropped in downstream.*")
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add column c that wasn't fully dropped in downstream.*", err.Error())
+ t.Require().False(l.IsResolved())
// Simulate watch done operation from dm-worker
op = NewOperation(utils.GenDDLLockID(task, downSchema, downTable), task, source, db, tbls[0], []string{}, ConflictNone, "", true, []string{"c"})
- c.Assert(l.DeleteColumnsByOp(op), check.IsNil)
+ t.Require().NoError(l.DeleteColumnsByOp(op))
// TrySync for the first table, add column c, should succeed, because this column is fully dropped in the downstream
DDLs, cols, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs4, ti1, []*model.TableInfo{ti0}, vers), tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs4)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- c.Assert(l.IsResolved(), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs4, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.Require().False(l.IsResolved())
_, _, err = l.TrySync(newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs5, ti0, []*model.TableInfo{ti1, ti0}, vers), tts)
- c.Assert(err, check.ErrorMatches, ".*add column c that wasn't fully dropped in downstream.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*add column c that wasn't fully dropped in downstream.*", err.Error())
}
-func (t *testLock) trySyncForAllTablesLarger(c *check.C, l *Lock,
+func (t *testLock) trySyncForAllTablesLarger(l *Lock,
ddls []string, tableInfoBefore *model.TableInfo, tis []*model.TableInfo, tts []TargetTable, vers map[string]map[string]map[string]int64,
) {
for source, schemaTables := range l.Ready() {
@@ -1937,36 +1938,36 @@ func (t *testLock) trySyncForAllTablesLarger(c *check.C, l *Lock,
for table := range tables {
info := newInfoWithVersion(l.Task, source, schema, table, l.DownSchema, l.DownTable, ddls, tableInfoBefore, tis, vers)
DDLs2, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(DDLs2, check.DeepEquals, ddls)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(ddls, DDLs2)
}
}
}
}
-func (t *testLock) checkLockSynced(c *check.C, l *Lock) {
+func (t *testLock) checkLockSynced(l *Lock) {
synced, remain := l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ t.Require().Equal(l.synced, synced)
+ t.Require().True(synced)
+ t.Require().Equal(0, remain)
ready := l.Ready()
for _, schemaTables := range ready {
for _, tables := range schemaTables {
for _, synced := range tables {
- c.Assert(synced, check.IsTrue)
+ t.Require().True(synced)
}
}
}
}
-func (t *testLock) checkLockNoDone(c *check.C, l *Lock) {
- c.Assert(l.IsResolved(), check.IsFalse)
+func (t *testLock) checkLockNoDone(l *Lock) {
+ t.Require().False(l.IsResolved())
for source, schemaTables := range l.Ready() {
for schema, tables := range schemaTables {
for table := range tables {
- c.Assert(l.IsDone(source, schema, table), check.IsFalse)
+ t.Require().False(l.IsDone(source, schema, table))
}
}
}
@@ -1981,7 +1982,7 @@ func newInfoWithVersion(task, source, upSchema, upTable, downSchema, downTable s
return info
}
-func (t *testLock) TestLockTrySyncDifferentIndex(c *check.C) {
+func (t *testLock) TestLockTrySyncDifferentIndex() {
var (
ID = "test_lock_try_sync_index-`foo`.`bar`"
task = "test_lock_try_sync_index"
@@ -1995,9 +1996,9 @@ func (t *testLock) TestLockTrySyncDifferentIndex(c *check.C) {
tblID int64 = 111
DDLs1 = []string{"ALTER TABLE bar DROP INDEX idx_c1"}
DDLs2 = []string{"ALTER TABLE bar ADD INDEX new_idx(c1)"}
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, INDEX new_idx(c1))`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, INDEX new_idx(c1))`)
tables = map[string]map[string]struct{}{
db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
}
@@ -2015,56 +2016,56 @@ func (t *testLock) TestLockTrySyncDifferentIndex(c *check.C) {
)
// the initial status is synced.
- t.checkLockSynced(c, l)
- t.checkLockNoDone(c, l)
+ t.checkLockSynced(l)
+ t.checkLockNoDone(l)
// try sync for one table, `DROP INDEX` returned directly (to make schema become more compatible).
// `DROP INDEX` is handled like `ADD COLUMN`.
info := newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs1, ti0, []*model.TableInfo{ti1}, vers)
DDLs, cols, err := l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs1)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs1, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
synced, remain := l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ t.Require().Equal(l.synced, synced)
+ t.Require().False(synced)
+ t.Require().Equal(1, remain)
cmp, err := l.tables[source][db][tbls[1]].Compare(schemacmp.Encode(ti0))
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
// try sync ADD another INDEX for another table
// `ADD INDEX` is handled like `DROP COLUMN`.
info = newInfoWithVersion(task, source, db, tbls[1], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, []string{}) // no DDLs returned
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
+ t.Require().NoError(err)
+ t.Require().Equal([]string{}, DDLs) // no DDLs returned
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
synced, remain = l.IsSynced()
- c.Assert(synced, check.Equals, l.synced)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ t.Require().Equal(l.synced, synced)
+ t.Require().False(synced)
+ t.Require().Equal(1, remain)
joined, err := l.joinFinalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = l.tables[source][db][tbls[0]].Compare(joined)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
// try sync ADD INDEX for first table
info = newInfoWithVersion(task, source, db, tbls[0], downSchema, downTable, DDLs2, ti1, []*model.TableInfo{ti2}, vers)
DDLs, cols, err = l.TrySync(info, tts)
- c.Assert(err, check.IsNil)
- c.Assert(DDLs, check.DeepEquals, DDLs2)
- c.Assert(cols, check.DeepEquals, []string{})
- c.Assert(l.versions, check.DeepEquals, vers)
- t.checkLockSynced(c, l)
+ t.Require().NoError(err)
+ t.Require().Equal(DDLs2, DDLs)
+ t.Require().Equal([]string{}, cols)
+ t.Require().Equal(vers, l.versions)
+ t.checkLockSynced(l)
}
-func (t *testLock) TestFetchTableInfo(c *check.C) {
+func (t *testLock) TestFetchTableInfo() {
var (
meta = "meta"
ID = "test_lock_try_sync_index-`foo`.`bar`"
@@ -2077,7 +2078,7 @@ func (t *testLock) TestFetchTableInfo(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 INT, UNIQUE INDEX idx_c1(c1))`)
tables = map[string]map[string]struct{}{
schema: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
}
@@ -2090,40 +2091,40 @@ func (t *testLock) TestFetchTableInfo(c *check.C) {
// nil downstream meta
l := NewLock(etcdTestCli, ID, task, downSchema, downTable, schemacmp.Encode(ti0), tts, nil)
ti, err := l.FetchTableInfos(task, source, schema, tbls[0])
- c.Assert(terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err), check.IsTrue)
- c.Assert(ti, check.IsNil)
+ t.Require().True(terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err))
+ t.Require().Nil(ti)
// table info not exist
l = NewLock(etcdTestCli, ID, task, downSchema, downTable, schemacmp.Encode(ti0), tts, &DownstreamMeta{dbConfig: &dbconfig.DBConfig{}, meta: meta})
conn.DefaultDBProvider = &conn.DefaultDBProviderImpl{}
- mock := conn.InitMockDB(c)
+ mock := conn.InitMockDB(t.T())
mock.ExpectQuery(query).WithArgs(source, schema, tbls[0]).WillReturnRows(sqlmock.NewRows([]string{"table_info"}))
ti, err = l.FetchTableInfos(task, source, schema, tbls[0])
- c.Assert(terror.ErrDBExecuteFailed.Equal(err), check.IsTrue)
- c.Assert(ti, check.IsNil)
+ t.Require().True(terror.ErrDBExecuteFailed.Equal(err))
+ t.Require().Nil(ti)
// null table info
l = NewLock(etcdTestCli, ID, task, downSchema, downTable, schemacmp.Encode(ti0), tts, &DownstreamMeta{dbConfig: &dbconfig.DBConfig{}, meta: meta})
conn.DefaultDBProvider = &conn.DefaultDBProviderImpl{}
- mock = conn.InitMockDB(c)
+ mock = conn.InitMockDB(t.T())
mock.ExpectQuery(query).WithArgs(source, schema, tbls[0]).WillReturnRows(sqlmock.NewRows([]string{"table_info"}).AddRow("null"))
ti, err = l.FetchTableInfos(task, source, schema, tbls[0])
- c.Assert(terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err), check.IsTrue)
- c.Assert(ti, check.IsNil)
+ t.Require().True(terror.ErrMasterOptimisticDownstreamMetaNotFound.Equal(err))
+ t.Require().Nil(ti)
// succeed
tiBytes, err := json.Marshal(ti0)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
conn.DefaultDBProvider = &conn.DefaultDBProviderImpl{}
- mock = conn.InitMockDB(c)
+ mock = conn.InitMockDB(t.T())
mock.ExpectQuery(query).WithArgs(source, schema, tbls[0]).WillReturnRows(sqlmock.NewRows([]string{"table_info"}).AddRow(tiBytes))
ti, err = l.FetchTableInfos(task, source, schema, tbls[0])
- c.Assert(err, check.IsNil)
- c.Assert(mock.ExpectationsWereMet(), check.IsNil)
- c.Assert(ti, check.DeepEquals, ti0)
+ t.Require().NoError(err)
+ t.Require().NoError(mock.ExpectationsWereMet())
+ t.Require().Equal(ti0, ti)
}
-func (t *testLock) TestCheckAddDropColumns(c *check.C) {
+func (t *testLock) TestCheckAddDropColumns() {
var (
ID = "test-`foo`.`bar`"
task = "test"
@@ -2139,10 +2140,10 @@ func (t *testLock) TestCheckAddDropColumns(c *check.C) {
DDLs2 = "ALTER TABLE bar ADD COLUMN a VARCHAR(2)"
DDLs3 = "ALTER TABLE bar DROP COLUMN col"
DDLs4 = "ALTER TABLE bar ADD COLUMN col int"
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(1))`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(2))`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a VARCHAR(2))`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(1))`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(2))`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a VARCHAR(2))`)
tables = map[string]map[string]struct{}{
db: {tbls[0]: struct{}{}, tbls[1]: struct{}{}},
}
@@ -2158,18 +2159,19 @@ func (t *testLock) TestCheckAddDropColumns(c *check.C) {
col, err := l.checkAddDropColumn(source, db, tbls[0], DDLs1, schemacmp.Encode(ti0), schemacmp.Encode(ti1), nil)
- c.Assert(err, check.IsNil)
- c.Assert(len(col), check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, len(col))
l.tables[source][db][tbls[0]] = schemacmp.Encode(ti1)
col, err = l.checkAddDropColumn(source, db, tbls[1], DDLs2, schemacmp.Encode(ti0), schemacmp.Encode(ti2), nil)
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, ".*add columns with different field lengths.*")
- c.Assert(len(col), check.Equals, 0)
+ t.Require().Error(err)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add columns with different field lengths.*", err.Error())
+ t.Require().Equal(0, len(col))
col, err = l.checkAddDropColumn(source, db, tbls[0], DDLs3, schemacmp.Encode(ti2), schemacmp.Encode(ti3), nil)
- c.Assert(err, check.IsNil)
- c.Assert(col, check.Equals, "col")
+ t.Require().NoError(err)
+ t.Require().Equal("col", col)
l.columns = map[string]map[string]map[string]map[string]DropColumnStage{
"col": {
@@ -2180,12 +2182,13 @@ func (t *testLock) TestCheckAddDropColumns(c *check.C) {
}
col, err = l.checkAddDropColumn(source, db, tbls[0], DDLs4, schemacmp.Encode(ti3), schemacmp.Encode(ti2), nil)
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, ".*add column .* that wasn't fully dropped in downstream.*")
- c.Assert(len(col), check.Equals, 0)
+ t.Require().Error(err)
+ t.Require().Error(err)
+ t.Require().Regexp(".*add column .* that wasn't fully dropped in downstream.*", err.Error())
+ t.Require().Equal(0, len(col))
}
-func (t *testLock) TestJoinTables(c *check.C) {
+func (t *testLock) TestJoinTables() {
var (
source = "mysql-replica-1"
db = "db"
@@ -2193,9 +2196,9 @@ func (t *testLock) TestJoinTables(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(1))`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col varchar(4))`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, a VARCHAR(1))`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col varchar(4))`)
t0 = schemacmp.Encode(ti0)
t1 = schemacmp.Encode(ti1)
t2 = schemacmp.Encode(ti2)
@@ -2215,33 +2218,33 @@ func (t *testLock) TestJoinTables(c *check.C) {
}
joined, err := l.joinNormalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err := joined.Compare(t0)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
joined, err = l.joinFinalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t0)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
_, err = l.joinConflictTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
l.tables[source][db][tbls[0]] = t1
l.finalTables[source][db][tbls[0]] = t1
joined, err = l.joinNormalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
joined, err = l.joinFinalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
_, err = l.joinConflictTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
l.tables[source][db][tbls[1]] = t1
l.finalTables[source][db][tbls[1]] = t1
@@ -2252,32 +2255,33 @@ func (t *testLock) TestJoinTables(c *check.C) {
}
joined, err = l.joinNormalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
joined, err = l.joinFinalTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
joined, err = l.joinConflictTables()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cmp, err = joined.Compare(t2)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
l.tables[source][db][tbls[1]] = t2
_, err = l.joinNormalTables()
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, ".*incompatible mysql type.*")
+ t.Require().Error(err)
+ t.Require().Error(err)
+ t.Require().Regexp(".*incompatible mysql type.*", err.Error())
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
}
-func (t *testLock) TestAddRemoveConflictTable(c *check.C) {
+func (t *testLock) TestAddRemoveConflictTable() {
var (
source = "source"
schema = "schema"
@@ -2287,52 +2291,52 @@ func (t *testLock) TestAddRemoveConflictTable(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
t0 = schemacmp.Encode(ti0)
)
l := &Lock{
conflictTables: make(map[string]map[string]map[string]schemacmp.Table),
}
- c.Assert(l.conflictTables, check.HasLen, 0)
+ t.Require().Len(l.conflictTables, 0)
l.addConflictTable(source, schema, table1, t0)
- c.Assert(l.conflictTables, check.HasLen, 1)
- c.Assert(l.conflictTables[source], check.HasLen, 1)
- c.Assert(l.conflictTables[source][schema], check.HasLen, 1)
+ t.Require().Len(l.conflictTables, 1)
+ t.Require().Len(l.conflictTables[source], 1)
+ t.Require().Len(l.conflictTables[source][schema], 1)
tb := l.conflictTables[source][schema][table1]
cmp, err := tb.Compare(t0)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
l.addConflictTable(source, schema, table1, t0)
- c.Assert(l.conflictTables, check.HasLen, 1)
- c.Assert(l.conflictTables[source], check.HasLen, 1)
- c.Assert(l.conflictTables[source][schema], check.HasLen, 1)
+ t.Require().Len(l.conflictTables, 1)
+ t.Require().Len(l.conflictTables[source], 1)
+ t.Require().Len(l.conflictTables[source][schema], 1)
l.addConflictTable(source, schema, table2, t0)
- c.Assert(l.conflictTables, check.HasLen, 1)
- c.Assert(l.conflictTables[source], check.HasLen, 1)
- c.Assert(l.conflictTables[source][schema], check.HasLen, 2)
+ t.Require().Len(l.conflictTables, 1)
+ t.Require().Len(l.conflictTables[source], 1)
+ t.Require().Len(l.conflictTables[source][schema], 2)
tb = l.conflictTables[source][schema][table2]
cmp, err = tb.Compare(t0)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
l.removeConflictTable(source, schema, table3)
- c.Assert(l.conflictTables[source][schema], check.HasLen, 2)
+ t.Require().Len(l.conflictTables[source][schema], 2)
l.removeConflictTable(source, schema, table1)
- c.Assert(l.conflictTables[source][schema], check.HasLen, 1)
+ t.Require().Len(l.conflictTables[source][schema], 1)
tb = l.conflictTables[source][schema][table2]
cmp, err = tb.Compare(t0)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().Equal(0, cmp)
l.removeConflictTable(source, schema, table2)
- c.Assert(l.conflictTables, check.HasLen, 0)
+ t.Require().Len(l.conflictTables, 0)
}
-func (t *testLock) TestAllTableSmallerLarger(c *check.C) {
+func (t *testLock) TestAllTableSmallerLarger() {
var (
source = "source"
schema = "schema"
@@ -2341,16 +2345,16 @@ func (t *testLock) TestAllTableSmallerLarger(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col int)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col varchar(4))`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (a INT PRIMARY KEY, new_col varchar(4))`)
- ti4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col2 varchar(4))`)
- ti5 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id varchar(4) PRIMARY KEY, new_col int)`)
- ti6 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, new_col int)`)
- ti7 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, new_col varchar(4))`)
- ti8 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, col2 int not null)`)
- ti9 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (a INT PRIMARY KEY, new_col int)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col int)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col varchar(4))`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (a INT PRIMARY KEY, new_col varchar(4))`)
+ ti4 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, new_col2 varchar(4))`)
+ ti5 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id varchar(4) PRIMARY KEY, new_col int)`)
+ ti6 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, new_col int)`)
+ ti7 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, new_col varchar(4))`)
+ ti8 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col int, col2 int not null)`)
+ ti9 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (a INT PRIMARY KEY, new_col int)`)
t0 = schemacmp.Encode(ti0)
t1 = schemacmp.Encode(ti1)
t2 = schemacmp.Encode(ti2)
@@ -2375,245 +2379,245 @@ func (t *testLock) TestAllTableSmallerLarger(c *check.C) {
},
conflictTables: make(map[string]map[string]map[string]schemacmp.Table),
}
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
+ t.Require().True(l.allFinalTableSmaller())
// rename table
l.addConflictTable(source, schema, table1, t1)
l.finalTables[source][schema][table1] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t1)
l.finalTables[source][schema][table2] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
// modify column
l.addConflictTable(source, schema, table1, t2)
l.finalTables[source][schema][table1] = t2
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t2)
l.finalTables[source][schema][table2] = t2
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t2)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t2)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t2, l.tables[source][schema][table1])
+ t.Require().Equal(t2, l.tables[source][schema][table2])
// different rename
l.addConflictTable(source, schema, table1, t3)
l.finalTables[source][schema][table1] = t3
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t4)
l.finalTables[source][schema][table2] = t4
- c.Assert(l.allConflictTableSmaller(), check.IsFalse)
- c.Assert(l.allConflictTableLarger(), check.IsFalse)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().False(l.allConflictTableSmaller())
+ t.Require().False(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t1
l.finalTables[source][schema][table2] = t1
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t1)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t1)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t1, l.tables[source][schema][table1])
+ t.Require().Equal(t1, l.tables[source][schema][table2])
// different modify
l.addConflictTable(source, schema, table1, t2)
l.finalTables[source][schema][table1] = t2
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t5)
l.finalTables[source][schema][table2] = t5
- c.Assert(l.allConflictTableSmaller(), check.IsFalse)
- c.Assert(l.allConflictTableLarger(), check.IsFalse)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().False(l.allConflictTableSmaller())
+ t.Require().False(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t1
l.finalTables[source][schema][table2] = t1
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t1)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t1)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t1, l.tables[source][schema][table1])
+ t.Require().Equal(t1, l.tables[source][schema][table2])
// one table rename, one table modify
l.addConflictTable(source, schema, table1, t4)
l.finalTables[source][schema][table1] = t4
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t5)
l.finalTables[source][schema][table2] = t5
- c.Assert(l.allConflictTableSmaller(), check.IsFalse)
- c.Assert(l.allConflictTableLarger(), check.IsFalse)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().False(l.allConflictTableSmaller())
+ t.Require().False(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t0
l.finalTables[source][schema][table2] = t0
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t0)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t0)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t0, l.tables[source][schema][table1])
+ t.Require().Equal(t0, l.tables[source][schema][table2])
// one table rename, one table add and drop
l.addConflictTable(source, schema, table1, t1)
l.finalTables[source][schema][table1] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.finalTables[source][schema][table2] = t6
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
l.finalTables[source][schema][table2] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t0
l.finalTables[source][schema][table2] = t0
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t0)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t0)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t0, l.tables[source][schema][table1])
+ t.Require().Equal(t0, l.tables[source][schema][table2])
// one table modify, one table add and drop
l.addConflictTable(source, schema, table1, t2)
l.finalTables[source][schema][table1] = t2
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.finalTables[source][schema][table2] = t7
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
l.finalTables[source][schema][table2] = t2
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t0
l.finalTables[source][schema][table2] = t0
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t0)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t0)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t0, l.tables[source][schema][table1])
+ t.Require().Equal(t0, l.tables[source][schema][table2])
// not null no default
l.addConflictTable(source, schema, table1, t8)
l.finalTables[source][schema][table1] = t8
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
l.addConflictTable(source, schema, table2, t8)
l.finalTables[source][schema][table2] = t8
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t0
l.finalTables[source][schema][table2] = t0
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t0)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t0)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t0, l.tables[source][schema][table1])
+ t.Require().Equal(t0, l.tables[source][schema][table2])
// multiple rename
// tb1: rename col to new_col
l.addConflictTable(source, schema, table1, t1)
l.finalTables[source][schema][table1] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
// tb2: rename col to new_col
l.addConflictTable(source, schema, table2, t1)
l.finalTables[source][schema][table2] = t1
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
l.resolveTables()
// tb1: rename id to a
l.addConflictTable(source, schema, table1, t9)
l.finalTables[source][schema][table1] = t9
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table1, t1, t9), check.IsFalse)
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsFalse)
- c.Assert(l.allFinalTableLarger(), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table1, t1, t9))
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().False(l.allFinalTableSmaller())
+ t.Require().False(l.allFinalTableLarger())
// tb2: rename col to new_col (idempotent)
l.tables[source][schema][table2] = t0
l.addConflictTable(source, schema, table2, t1)
l.finalTables[source][schema][table2] = t1
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1), check.IsTrue)
+ t.Require().True(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1))
l.removeConflictTable(source, schema, table2)
l.tables[source][schema][table2] = t1
// tb2: rename id to a
l.addConflictTable(source, schema, table2, t9)
l.finalTables[source][schema][table2] = t9
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t1, t9), check.IsFalse)
- c.Assert(l.allConflictTableSmaller(), check.IsTrue)
- c.Assert(l.allConflictTableLarger(), check.IsTrue)
- c.Assert(l.allFinalTableSmaller(), check.IsTrue)
- c.Assert(l.allFinalTableLarger(), check.IsTrue)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t1, t9))
+ t.Require().True(l.allConflictTableSmaller())
+ t.Require().True(l.allConflictTableLarger())
+ t.Require().True(l.allFinalTableSmaller())
+ t.Require().True(l.allFinalTableLarger())
// reset
l.finalTables[source][schema][table1] = t0
l.finalTables[source][schema][table2] = t0
l.resolveTables()
- c.Assert(l.conflictTables, check.HasLen, 0)
- c.Assert(l.tables, check.DeepEquals, l.finalTables)
- c.Assert(l.tables[source][schema], check.HasLen, 2)
- c.Assert(l.tables[source][schema][table1], check.DeepEquals, t0)
- c.Assert(l.tables[source][schema][table2], check.DeepEquals, t0)
+ t.Require().Len(l.conflictTables, 0)
+ t.Require().Equal(l.finalTables, l.tables)
+ t.Require().Len(l.tables[source][schema], 2)
+ t.Require().Equal(t0, l.tables[source][schema][table1])
+ t.Require().Equal(t0, l.tables[source][schema][table2])
}
-func (t *testLock) TestNoConflictWithOneNormalTable(c *check.C) {
+func (t *testLock) TestNoConflictWithOneNormalTable() {
var (
source = "source"
schema = "schema"
@@ -2622,11 +2626,11 @@ func (t *testLock) TestNoConflictWithOneNormalTable(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, col int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, new_col int)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, col varchar(4))`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, new_col2 int)`)
- ti4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int, new_col int)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, col int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, new_col int)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, col varchar(4))`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, a int, new_col2 int)`)
+ ti4 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, b int, new_col int)`)
t0 = schemacmp.Encode(ti0)
t1 = schemacmp.Encode(ti1)
t2 = schemacmp.Encode(ti2)
@@ -2643,31 +2647,31 @@ func (t *testLock) TestNoConflictWithOneNormalTable(c *check.C) {
// table1 nothing happened.
// table2 rename column
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1))
// mock table1 rename column already
l.tables[source][schema][table1] = t1
// table2 rename column
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1), check.IsTrue)
+ t.Require().True(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1))
// table2 modify column
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t2), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t0, t2))
// table2 different rename
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t3), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t0, t3))
// mock table1 rename another column already
l.tables[source][schema][table1] = t4
// same results
// table2 rename column
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1), check.IsTrue)
+ t.Require().True(l.noConflictWithOneNormalTable(source, schema, table2, t0, t1))
// table2 modify column
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t2), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t0, t2))
// table2 different rename
- c.Assert(l.noConflictWithOneNormalTable(source, schema, table2, t0, t3), check.IsFalse)
+ t.Require().False(l.noConflictWithOneNormalTable(source, schema, table2, t0, t3))
}
-func checkRedirectOp(c *check.C, task, source, schema, table string) bool {
+func checkRedirectOp(t *testing.T, task, source, schema, table string) bool {
ops, _, err := GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if _, ok := ops[task]; !ok {
return false
}
@@ -2684,7 +2688,7 @@ func checkRedirectOp(c *check.C, task, source, schema, table string) bool {
return op.ConflictStage == ConflictResolved
}
-func (t *testLock) TestTrySyncForOneDDL(c *check.C) {
+func (t *testLock) TestTrySyncForOneDDL() {
var (
ID = "test-`foo`.`bar`"
task = "test"
@@ -2697,17 +2701,17 @@ func (t *testLock) TestTrySyncForOneDDL(c *check.C) {
p = parser.New()
se = mock.NewContext()
tblID int64 = 111
- ti0 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int)`)
- ti1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int, col2 int)`)
- ti2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- ti3 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int, col3 int)`)
- ti4 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col2 int)`)
- ti5 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int)`)
- ti6 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 varchar(4))`)
- ti7 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int)`)
- ti8 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 varchar(4), col4 int not null)`)
- ti9 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col2 varchar(4), col4 int not null)`)
- ti10 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int, col4 int not null)`)
+ ti0 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int)`)
+ ti1 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int, col2 int)`)
+ ti2 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ ti3 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col1 int, col3 int)`)
+ ti4 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col2 int)`)
+ ti5 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int)`)
+ ti6 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 varchar(4))`)
+ ti7 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int)`)
+ ti8 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 varchar(4), col4 int not null)`)
+ ti9 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col2 varchar(4), col4 int not null)`)
+ ti10 = createTableInfo(t.T(), p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, col3 int, col4 int not null)`)
t0 = schemacmp.Encode(ti0)
t1 = schemacmp.Encode(ti1)
t2 = schemacmp.Encode(ti2)
@@ -2730,84 +2734,84 @@ func (t *testLock) TestTrySyncForOneDDL(c *check.C) {
// check create table statement
schemaChanged, conflictStage := l.trySyncForOneDDL(source, schema, table1, t0, t0)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check alter table add column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t0, t1)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check create partition, no changed since https://github.com/pingcap/tidb/blob/42075e6ad60ba5d1f860ac845908f0c34ac28253/pkg/util/schemacmp/table.go#L256
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t0, t1)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check alter table drop column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t0, t2)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check table rename column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t1, t3)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictSkipWaitRedirect)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictSkipWaitRedirect, conflictStage)
// check other table add column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t2, t4)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check all table rename column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t4, t5)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// table1 redirect
- c.Assert(checkRedirectOp(c, task, source, schema, table1), check.IsTrue)
+ t.Require().True(checkRedirectOp(t.T(), task, source, schema, table1))
// check one table modify column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t5, t6)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictSkipWaitRedirect)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictSkipWaitRedirect, conflictStage)
// check other table drop column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t3, t7)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check all table modify column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t7, t6)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// table2 redirect
- c.Assert(checkRedirectOp(c, task, source, schema, table2), check.IsTrue)
+ t.Require().True(checkRedirectOp(t.T(), task, source, schema, table2))
// check add column not null no default
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t6, t8)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictSkipWaitRedirect)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictSkipWaitRedirect, conflictStage)
// check idempotent.
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t6, t8)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictSkipWaitRedirect)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictSkipWaitRedirect, conflictStage)
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t6, t8)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// table1 redirect
- c.Assert(checkRedirectOp(c, task, source, schema, table2), check.IsTrue)
+ t.Require().True(checkRedirectOp(t.T(), task, source, schema, table2))
// check idempotent.
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t6, t8)
- c.Assert(schemaChanged, check.IsTrue)
- c.Assert(conflictStage, check.Equals, ConflictNone)
+ t.Require().True(schemaChanged)
+ t.Require().Equal(ConflictNone, conflictStage)
// check multiple conflict DDL
// tb1 rename column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table1, t8, t9)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictSkipWaitRedirect)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictSkipWaitRedirect, conflictStage)
// tb2 modify column
schemaChanged, conflictStage = l.trySyncForOneDDL(source, schema, table2, t8, t10)
- c.Assert(schemaChanged, check.IsFalse)
- c.Assert(conflictStage, check.Equals, ConflictDetected)
+ t.Require().False(schemaChanged)
+ t.Require().Equal(ConflictDetected, conflictStage)
}
diff --git a/dm/pkg/shardddl/optimism/operation_test.go b/dm/pkg/shardddl/optimism/operation_test.go
index 9333faacde..c57192bb54 100644
--- a/dm/pkg/shardddl/optimism/operation_test.go
+++ b/dm/pkg/shardddl/optimism/operation_test.go
@@ -15,28 +15,29 @@ package optimism
import (
"context"
+ "testing"
"time"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-func (t *testForEtcd) TestOperationJSON(c *check.C) {
+func TestOperationJSON(t *testing.T) {
o1 := NewOperation("test-ID", "test", "mysql-replica-1", "db-1", "tbl-1", []string{
"ALTER TABLE tbl ADD COLUMN c1 INT",
}, ConflictDetected, "conflict", true, []string{})
j, err := o1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"id":"test-ID","task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT"],"conflict-stage":"detected","conflict-message":"conflict","done":true,"cols":[]}`)
- c.Assert(j, check.Equals, o1.String())
+ require.NoError(t, err)
+ require.Equal(t, `{"id":"test-ID","task":"test","source":"mysql-replica-1","up-schema":"db-1","up-table":"tbl-1","ddls":["ALTER TABLE tbl ADD COLUMN c1 INT"],"conflict-stage":"detected","conflict-message":"conflict","done":true,"cols":[]}`, j)
+ require.Equal(t, o1.String(), j)
o2, err := operationFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(o2, check.DeepEquals, o1)
+ require.NoError(t, err)
+ require.Equal(t, o1, o2)
}
-func (t *testForEtcd) TestOperationEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestOperationEtcd(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
watchTimeout = 2 * time.Second
@@ -54,12 +55,12 @@ func (t *testForEtcd) TestOperationEtcd(c *check.C) {
// put the same keys twice.
rev1, succ, err := PutOperation(etcdTestCli, false, op11, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, succ)
rev2, succ, err := PutOperation(etcdTestCli, false, op11, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev2, check.Greater, rev1)
+ require.NoError(t, err)
+ require.True(t, succ)
+ require.Greater(t, rev2, rev1)
// start the watcher with the same revision as the last PUT for the specified task and source.
wch := make(chan Operation, 10)
@@ -71,15 +72,15 @@ func (t *testForEtcd) TestOperationEtcd(c *check.C) {
close(ech)
// watch should only get op11.
- c.Assert(len(ech), check.Equals, 0)
- c.Assert(len(wch), check.Equals, 1)
+ require.Equal(t, 0, len(ech))
+ require.Equal(t, 1, len(wch))
op11.Revision = rev2
- c.Assert(<-wch, check.DeepEquals, op11)
+ require.Equal(t, op11, <-wch)
// put for another task.
rev3, succ, err := PutOperation(etcdTestCli, false, op21, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, succ)
// start the watch with an older revision for all tasks and sources.
wch = make(chan Operation, 10)
@@ -91,75 +92,75 @@ func (t *testForEtcd) TestOperationEtcd(c *check.C) {
close(ech)
// watch should get 2 operations.
- c.Assert(len(ech), check.Equals, 0)
- c.Assert(len(wch), check.Equals, 2)
- c.Assert(<-wch, check.DeepEquals, op11)
+ require.Equal(t, 0, len(ech))
+ require.Equal(t, 2, len(wch))
+ require.Equal(t, op11, <-wch)
op21.Revision = rev3
- c.Assert(<-wch, check.DeepEquals, op21)
+ require.Equal(t, op21, <-wch)
// get all operations.
opm, rev4, err := GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(opm, check.HasLen, 2)
- c.Assert(opm, check.HasKey, task1)
- c.Assert(opm, check.HasKey, task2)
- c.Assert(opm[task1], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Equal(t, rev3, rev4)
+ require.Len(t, opm, 2)
+ require.Contains(t, opm, task1)
+ require.Contains(t, opm, task2)
+ require.Len(t, opm[task1], 1)
op11.Revision = rev2
- c.Assert(opm[task1][source1][upSchema][upTable], check.DeepEquals, op11)
- c.Assert(opm[task2], check.HasLen, 1)
+ require.Equal(t, op11, opm[task1][source1][upSchema][upTable])
+ require.Len(t, opm[task2], 1)
op21.Revision = rev3
- c.Assert(opm[task2][source1][upSchema][upTable], check.DeepEquals, op21)
+ require.Equal(t, op21, opm[task2][source1][upSchema][upTable])
// put for `skipDone` with `done` in etcd, the operations should not be skipped.
// case: kv's "the `done` field is not `true`".
rev5, succ, err := PutOperation(etcdTestCli, true, op11, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev5, check.Greater, rev4)
+ require.NoError(t, err)
+ require.True(t, succ)
+ require.Greater(t, rev5, rev4)
// delete op11.
deleteOp := deleteOperationOp(op11)
_, err = etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// get again, op11 should be deleted.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm[task1], check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, opm[task1], 0)
// put for `skipDone` with `done` in etcd, the operations should not be skipped.
// case: kv "not exist".
rev6, succ, err := PutOperation(etcdTestCli, true, op11, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, succ)
// get again, op11 should be putted.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm[task1], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, opm[task1], 1)
op11.Revision = rev6
- c.Assert(opm[task1][source1][upSchema][upTable], check.DeepEquals, op11)
+ require.Equal(t, op11, opm[task1][source1][upSchema][upTable])
// update op11 to `done`.
op11c := op11
op11c.Done = true
rev7, succ, err := PutOperation(etcdTestCli, true, op11c, 0)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev7, check.Greater, rev6)
+ require.NoError(t, err)
+ require.True(t, succ)
+ require.Greater(t, rev7, rev6)
// put for `skipDone` with `done` in etcd, the operations should not be skipped.
// case: operation modRevision < info's modRevision
rev8, succ, err := PutOperation(etcdTestCli, true, op11c, rev7+10)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev8, check.Greater, rev7)
+ require.NoError(t, err)
+ require.True(t, succ)
+ require.Greater(t, rev8, rev7)
// put for `skipDone` with `done` in etcd, the operations should be skipped.
// case: kv's ("exist" and "the `done` field is `true`").
rev9, succ, err := PutOperation(etcdTestCli, true, op11, rev6)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsFalse)
- c.Assert(rev9, check.Equals, rev8)
+ require.NoError(t, err)
+ require.False(t, succ)
+ require.Equal(t, rev8, rev9)
}
diff --git a/dm/pkg/shardddl/optimism/ops_test.go b/dm/pkg/shardddl/optimism/ops_test.go
index 1673d7ceb8..a6ec4f5632 100644
--- a/dm/pkg/shardddl/optimism/ops_test.go
+++ b/dm/pkg/shardddl/optimism/ops_test.go
@@ -14,11 +14,13 @@
package optimism
import (
- "github.com/pingcap/check"
+ "testing"
+
+ "github.com/stretchr/testify/require"
)
-func (t *testForEtcd) TestDeleteInfosOperationsSchema(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestDeleteInfosOperationsSchema(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
task = "test"
@@ -34,53 +36,53 @@ func (t *testForEtcd) TestDeleteInfosOperationsSchema(c *check.C) {
// put info.
rev, err := PutInfo(etcdTestCli, info)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ifm, _, err := GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, ifm, 1)
infoWithVer := info
infoWithVer.Version = 1
infoWithVer.Revision = rev
- c.Assert(ifm[task][source][upSchema][upTable], check.DeepEquals, infoWithVer)
+ require.Equal(t, infoWithVer, ifm[task][source][upSchema][upTable])
// put operation.
rev, _, err = PutOperation(etcdTestCli, false, op, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
opm, _, err := GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, opm, 1)
op.Revision = rev
- c.Assert(opm[task][source][upSchema][upTable], check.DeepEquals, op)
+ require.Equal(t, op, opm[task][source][upSchema][upTable])
// DELETE info and operation with version 0
_, deleted, err := DeleteInfosOperationsColumns(etcdTestCli, []Info{info}, []Operation{op}, genDDLLockID(info))
- c.Assert(err, check.IsNil)
- c.Assert(deleted, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, deleted)
// data still exist
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, ifm, 1)
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, opm, 1)
// DELETE info and operation with version 1
_, deleted, err = DeleteInfosOperationsColumns(etcdTestCli, []Info{infoWithVer}, []Operation{op}, genDDLLockID(infoWithVer))
- c.Assert(err, check.IsNil)
- c.Assert(deleted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, deleted)
// verify no info & operation exist.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, ifm, 0)
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, opm, 0)
}
-func (t *testForEtcd) TestSourceTablesInfo(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestSourceTablesInfo(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
task = "task"
@@ -98,25 +100,25 @@ func (t *testForEtcd) TestSourceTablesInfo(c *check.C) {
// put source tables
rev1, err := PutSourceTables(etcdTestCli, st1)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
+ require.NoError(t, err)
+ require.Greater(t, rev1, int64(0))
stm, rev2, err := GetAllSourceTables(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Equals, rev1)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(stm[task], check.HasLen, 1)
- c.Assert(stm[task][source], check.DeepEquals, st1)
+ require.NoError(t, err)
+ require.Equal(t, rev1, rev2)
+ require.Len(t, stm, 1)
+ require.Len(t, stm[task], 1)
+ require.Equal(t, st1, stm[task][source])
// put/update source tables
rev4, err := PutSourceTables(etcdTestCli, st2)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev1)
+ require.NoError(t, err)
+ require.Greater(t, rev4, rev1)
stm, rev5, err := GetAllSourceTables(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(stm[task], check.HasLen, 1)
- c.Assert(stm[task][source], check.DeepEquals, st2)
+ require.NoError(t, err)
+ require.Equal(t, rev4, rev5)
+ require.Len(t, stm, 1)
+ require.Len(t, stm[task], 1)
+ require.Equal(t, st2, stm[task][source])
}
diff --git a/dm/pkg/shardddl/optimism/table_test.go b/dm/pkg/shardddl/optimism/table_test.go
index 812f9438e1..3ff6d49f04 100644
--- a/dm/pkg/shardddl/optimism/table_test.go
+++ b/dm/pkg/shardddl/optimism/table_test.go
@@ -18,24 +18,23 @@ import (
"testing"
"time"
- "github.com/pingcap/check"
"github.com/stretchr/testify/require"
)
-func (t *testForEtcd) TestSourceTablesJSON(c *check.C) {
+func TestSourceTablesJSON(t *testing.T) {
st1 := NewSourceTables("test", "mysql-replica-1")
st1.AddTable("db1", "tbl1", "db", "tbl")
j, err := st1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"task":"test","source":"mysql-replica-1","tables":{"db":{"tbl":{"db1":{"tbl1":{}}}}}}`)
- c.Assert(j, check.Equals, st1.String())
+ require.NoError(t, err)
+ require.Equal(t, `{"task":"test","source":"mysql-replica-1","tables":{"db":{"tbl":{"db1":{"tbl1":{}}}}}}`, j)
+ require.Equal(t, st1.String(), j)
st2, err := sourceTablesFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(st2, check.DeepEquals, st1)
+ require.NoError(t, err)
+ require.Equal(t, st1, st2)
}
-func (t *testForEtcd) TestSourceTablesAddRemove(c *check.C) {
+func TestSourceTablesAddRemove(t *testing.T) {
var (
task = "task"
source = "mysql-replica-1"
@@ -46,39 +45,37 @@ func (t *testForEtcd) TestSourceTablesAddRemove(c *check.C) {
)
// no target table exist.
- c.Assert(st.TargetTable(downSchema, downTable1).IsEmpty(), check.IsTrue)
- c.Assert(st.TargetTable(downSchema, downTable2).IsEmpty(), check.IsTrue)
+ require.True(t, st.TargetTable(downSchema, downTable1).IsEmpty())
+ require.True(t, st.TargetTable(downSchema, downTable2).IsEmpty())
// add a table for downTable1.
- c.Assert(st.AddTable("foo1", "bar1", downSchema, downTable1), check.IsTrue)
- c.Assert(st.AddTable("foo1", "bar1", downSchema, downTable1), check.IsFalse)
- c.Assert(st.TargetTable(downSchema, downTable1), check.DeepEquals,
- newTargetTable(task, source, downSchema, downTable1, map[string]map[string]struct{}{
- "foo1": {"bar1": struct{}{}},
- }))
- c.Assert(st.TargetTable(downSchema, downTable2).IsEmpty(), check.IsTrue)
+ require.True(t, st.AddTable("foo1", "bar1", downSchema, downTable1))
+ require.False(t, st.AddTable("foo1", "bar1", downSchema, downTable1))
+ require.Equal(t, newTargetTable(task, source, downSchema, downTable1, map[string]map[string]struct{}{
+ "foo1": {"bar1": struct{}{}},
+ }), st.TargetTable(downSchema, downTable1))
+ require.True(t, st.TargetTable(downSchema, downTable2).IsEmpty())
// add a table for downTable2.
- c.Assert(st.AddTable("foo2", "bar2", downSchema, downTable2), check.IsTrue)
- c.Assert(st.AddTable("foo2", "bar2", downSchema, downTable2), check.IsFalse)
- c.Assert(st.TargetTable(downSchema, downTable2), check.DeepEquals,
- newTargetTable(task, source, downSchema, downTable2, map[string]map[string]struct{}{
- "foo2": {"bar2": struct{}{}},
- }))
+ require.True(t, st.AddTable("foo2", "bar2", downSchema, downTable2))
+ require.False(t, st.AddTable("foo2", "bar2", downSchema, downTable2))
+ require.Equal(t, newTargetTable(task, source, downSchema, downTable2, map[string]map[string]struct{}{
+ "foo2": {"bar2": struct{}{}},
+ }), st.TargetTable(downSchema, downTable2))
// remove a table for downTable1.
- c.Assert(st.RemoveTable("foo1", "bar1", downSchema, downTable1), check.IsTrue)
- c.Assert(st.RemoveTable("foo1", "bar1", downSchema, downTable1), check.IsFalse)
- c.Assert(st.TargetTable(downSchema, downTable1).IsEmpty(), check.IsTrue)
+ require.True(t, st.RemoveTable("foo1", "bar1", downSchema, downTable1))
+ require.False(t, st.RemoveTable("foo1", "bar1", downSchema, downTable1))
+ require.True(t, st.TargetTable(downSchema, downTable1).IsEmpty())
// remove a table for downTable2.
- c.Assert(st.RemoveTable("foo2", "bar2", downSchema, downTable2), check.IsTrue)
- c.Assert(st.RemoveTable("foo2", "bar2", downSchema, downTable2), check.IsFalse)
- c.Assert(st.TargetTable(downSchema, downTable2).IsEmpty(), check.IsTrue)
+ require.True(t, st.RemoveTable("foo2", "bar2", downSchema, downTable2))
+ require.False(t, st.RemoveTable("foo2", "bar2", downSchema, downTable2))
+ require.True(t, st.TargetTable(downSchema, downTable2).IsEmpty())
}
-func (t *testForEtcd) TestSourceTablesEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func TestSourceTablesEtcd(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
watchTimeout = 2 * time.Second
@@ -98,19 +95,19 @@ func (t *testForEtcd) TestSourceTablesEtcd(c *check.C) {
// put two SourceTables.
rev1, err := PutSourceTables(etcdTestCli, st1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rev2, err := PutSourceTables(etcdTestCli, st2)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ require.NoError(t, err)
+ require.Greater(t, rev2, rev1)
// get with two SourceTables.
stm, rev3, err := GetAllSourceTables(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(stm[task], check.HasLen, 2)
- c.Assert(stm[task][source1], check.DeepEquals, st1)
- c.Assert(stm[task][source2], check.DeepEquals, st2)
+ require.NoError(t, err)
+ require.Equal(t, rev2, rev3)
+ require.Len(t, stm, 1)
+ require.Len(t, stm[task], 2)
+ require.Equal(t, st1, stm[task][source1])
+ require.Equal(t, st2, stm[task][source2])
// watch with an older revision for all SourceTables.
wch := make(chan SourceTables, 10)
@@ -122,22 +119,22 @@ func (t *testForEtcd) TestSourceTablesEtcd(c *check.C) {
close(ech)
// get two source tables.
- c.Assert(len(wch), check.Equals, 2)
- c.Assert(<-wch, check.DeepEquals, st1)
- c.Assert(<-wch, check.DeepEquals, st2)
- c.Assert(len(ech), check.Equals, 0)
+ require.Equal(t, 2, len(wch))
+ require.Equal(t, st1, <-wch)
+ require.Equal(t, st2, <-wch)
+ require.Equal(t, 0, len(ech))
// delete tow sources tables.
_, err = DeleteSourceTables(etcdTestCli, st1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rev4, err := DeleteSourceTables(etcdTestCli, st2)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// get without SourceTables.
stm, rev5, err := GetAllSourceTables(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(stm, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Equal(t, rev4, rev5)
+ require.Len(t, stm, 0)
// watch the deletion for SourceTables.
wch = make(chan SourceTables, 10)
@@ -147,12 +144,12 @@ func (t *testForEtcd) TestSourceTablesEtcd(c *check.C) {
cancel()
close(wch)
close(ech)
- c.Assert(len(wch), check.Equals, 1)
+ require.Equal(t, 1, len(wch))
std := <-wch
- c.Assert(std.IsDeleted, check.IsTrue)
- c.Assert(std.Task, check.Equals, st2.Task)
- c.Assert(std.Source, check.Equals, st2.Source)
- c.Assert(len(ech), check.Equals, 0)
+ require.True(t, std.IsDeleted)
+ require.Equal(t, st2.Task, std.Task)
+ require.Equal(t, st2.Source, std.Source)
+ require.Equal(t, 0, len(ech))
}
func TestToRouteTable(t *testing.T) {
diff --git a/dm/pkg/shardddl/pessimism/info_test.go b/dm/pkg/shardddl/pessimism/info_test.go
index 2fb67cd803..406e7cde48 100644
--- a/dm/pkg/shardddl/pessimism/info_test.go
+++ b/dm/pkg/shardddl/pessimism/info_test.go
@@ -20,10 +20,11 @@ import (
"testing"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/util/dbutil"
"github.com/pingcap/tiflow/dm/common"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
@@ -37,39 +38,39 @@ func TestInfo(t *testing.T) {
etcdTestCli = mockCluster.RandClient()
- check.TestingT(t)
+ suite.Run(t, new(testForEtcd))
}
// clear keys in etcd test cluster.
-func clearTestInfoOperation(c *check.C) {
+func clearTestInfoOperation(t require.TestingT) {
clearInfo := clientv3.OpDelete(common.ShardDDLPessimismInfoKeyAdapter.Path(), clientv3.WithPrefix())
clearOp := clientv3.OpDelete(common.ShardDDLPessimismOperationKeyAdapter.Path(), clientv3.WithPrefix())
_, err := etcdTestCli.Txn(context.Background()).Then(clearInfo, clearOp).Commit()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
-type testForEtcd struct{}
-
-var _ = check.Suite(&testForEtcd{})
+type testForEtcd struct {
+ suite.Suite
+}
-func (t *testForEtcd) TestInfoJSON(c *check.C) {
+func (t *testForEtcd) TestInfoJSON() {
i1 := NewInfo("test", "mysql-replica-1", "foo", "bar", []string{
"ALTER TABLE bar ADD COLUMN c1 INT",
"ALTER TABLE bar ADD COLUMN c2 INT",
})
j, err := i1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"task":"test","source":"mysql-replica-1","schema":"foo","table":"bar","ddls":["ALTER TABLE bar ADD COLUMN c1 INT","ALTER TABLE bar ADD COLUMN c2 INT"]}`)
- c.Assert(j, check.Equals, i1.String())
+ t.Require().NoError(err)
+ t.Require().Equal(`{"task":"test","source":"mysql-replica-1","schema":"foo","table":"bar","ddls":["ALTER TABLE bar ADD COLUMN c1 INT","ALTER TABLE bar ADD COLUMN c2 INT"]}`, j)
+ t.Require().Equal(i1.String(), j)
i2, err := infoFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(i2, check.DeepEquals, i1)
+ t.Require().NoError(err)
+ t.Require().Equal(i1, i2)
}
-func (t *testForEtcd) TestInfoEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (t *testForEtcd) TestInfoEtcd() {
+ defer clearTestInfoOperation(t.T())
var (
source1 = "mysql-replica-1"
@@ -89,30 +90,30 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
// put the same key twice.
rev1, err := PutInfo(etcdTestCli, i11)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
rev2, err := PutInfo(etcdTestCli, i11)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
// get with only 1 info.
ifm, rev3, err := GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm[task1], check.HasLen, 1)
- c.Assert(ifm[task1][source1], check.DeepEquals, i11)
+ t.Require().NoError(err)
+ t.Require().Equal(rev2, rev3)
+ t.Require().Len(ifm, 1)
+ t.Require().Contains(ifm, task1)
+ t.Require().Len(ifm[task1], 1)
+ t.Require().Equal(i11, ifm[task1][source1])
// put another key and get again with 2 info.
rev4, err := PutInfo(etcdTestCli, i12)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm[task1], check.HasLen, 2)
- c.Assert(ifm[task1][source1], check.DeepEquals, i11)
- c.Assert(ifm[task1][source2], check.DeepEquals, i12)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 1)
+ t.Require().Contains(ifm, task1)
+ t.Require().Len(ifm[task1], 2)
+ t.Require().Equal(i11, ifm[task1][source1])
+ t.Require().Equal(i12, ifm[task1][source2])
// start the watcher.
wch := make(chan Info, 10)
@@ -129,7 +130,7 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
// put another key for a different task.
_, err = PutInfo(etcdTestCli, i21)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// wait response of WatchInfoPut, increase waiting time when resource shortage
utils.WaitSomething(10, 500*time.Millisecond, func() bool {
return len(wch) != 0
@@ -138,29 +139,29 @@ func (t *testForEtcd) TestInfoEtcd(c *check.C) {
wg.Wait()
// watch should only get i21.
- c.Assert(len(wch), check.Equals, 1)
- c.Assert(len(ech), check.Equals, 0)
- c.Assert(<-wch, check.DeepEquals, i21)
+ t.Require().Equal(1, len(wch))
+ t.Require().Equal(0, len(ech))
+ t.Require().Equal(i21, <-wch)
// delete i12.
deleteOp := deleteInfoOp(i12)
_, err = etcdTestCli.Txn(context.Background()).Then(deleteOp).Commit()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// get again.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 2)
- c.Assert(ifm, check.HasKey, task1)
- c.Assert(ifm, check.HasKey, task2)
- c.Assert(ifm[task1], check.HasLen, 1)
- c.Assert(ifm[task1][source1], check.DeepEquals, i11)
- c.Assert(ifm[task2], check.HasLen, 1)
- c.Assert(ifm[task2][source1], check.DeepEquals, i21)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 2)
+ t.Require().Contains(ifm, task1)
+ t.Require().Contains(ifm, task2)
+ t.Require().Len(ifm[task1], 1)
+ t.Require().Equal(i11, ifm[task1][source1])
+ t.Require().Len(ifm[task2], 1)
+ t.Require().Equal(i21, ifm[task2][source1])
}
-func (t *testForEtcd) TestPutInfoIfOpNotDone(c *check.C) {
- defer clearTestInfoOperation(c)
+func (t *testForEtcd) TestPutInfoIfOpNotDone() {
+ defer clearTestInfoOperation(t.T())
var (
source = "mysql-replica-1"
@@ -175,39 +176,39 @@ func (t *testForEtcd) TestPutInfoIfOpNotDone(c *check.C) {
// put info success because no operation exist.
rev1, putted, err := PutInfoIfOpNotDone(etcdTestCli, info)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(putted, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev1, int64(0))
+ t.Require().True(putted)
// put a non-done operation.
rev2, putted, err := PutOperations(etcdTestCli, false, op)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(putted, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
+ t.Require().True(putted)
// still can put info.
rev3, putted, err := PutInfoIfOpNotDone(etcdTestCli, info)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
- c.Assert(putted, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev3, rev2)
+ t.Require().True(putted)
// change op to `done` and put it.
op.Done = true
rev4, putted, err := PutOperations(etcdTestCli, false, op)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
- c.Assert(putted, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev4, rev3)
+ t.Require().True(putted)
// can't put info anymore.
rev5, putted, err := PutInfoIfOpNotDone(etcdTestCli, info)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(putted, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(rev4, rev5)
+ t.Require().False(putted)
// try put anther info, but still can't put it.
info.DDLs = []string{"ALTER TABLE bar ADD COLUMN c2 INT"}
rev6, putted, err := PutInfoIfOpNotDone(etcdTestCli, info)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Equals, rev5)
- c.Assert(putted, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(rev5, rev6)
+ t.Require().False(putted)
}
diff --git a/dm/pkg/shardddl/pessimism/keeper_test.go b/dm/pkg/shardddl/pessimism/keeper_test.go
index 7d54f81c50..6275e3c7d9 100644
--- a/dm/pkg/shardddl/pessimism/keeper_test.go
+++ b/dm/pkg/shardddl/pessimism/keeper_test.go
@@ -14,14 +14,12 @@
package pessimism
import (
- "github.com/pingcap/check"
-)
-
-type testLockKeeper struct{}
+ "testing"
-var _ = check.Suite(&testLockKeeper{})
+ "github.com/stretchr/testify/require"
+)
-func (t *testLockKeeper) TestLockKeeper(c *check.C) {
+func TestLockKeeper(t *testing.T) {
var (
lk = NewLockKeeper()
schema = "foo"
@@ -38,47 +36,47 @@ func (t *testLockKeeper) TestLockKeeper(c *check.C) {
// lock with 2 sources.
lockID1, synced, remain, err := lk.TrySync(info11, []string{source1, source2})
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.Equals, "task1-`foo`.`bar`")
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ require.NoError(t, err)
+ require.Equal(t, "task1-`foo`.`bar`", lockID1)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
lockID1, synced, remain, err = lk.TrySync(info12, []string{source1, source2})
- c.Assert(err, check.IsNil)
- c.Assert(lockID1, check.Equals, "task1-`foo`.`bar`")
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.NoError(t, err)
+ require.Equal(t, "task1-`foo`.`bar`", lockID1)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
// lock with only 1 source.
lockID2, synced, remain, err := lk.TrySync(info21, []string{source1})
- c.Assert(err, check.IsNil)
- c.Assert(lockID2, check.Equals, "task2-`foo`.`bar`")
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.NoError(t, err)
+ require.Equal(t, "task2-`foo`.`bar`", lockID2)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
// find lock.
lock1 := lk.FindLock(lockID1)
- c.Assert(lock1, check.NotNil)
- c.Assert(lock1.ID, check.Equals, lockID1)
+ require.NotNil(t, lock1)
+ require.Equal(t, lockID1, lock1.ID)
lock2 := lk.FindLock(lockID2)
- c.Assert(lock2, check.NotNil)
- c.Assert(lock2.ID, check.Equals, lockID2)
+ require.NotNil(t, lock2)
+ require.Equal(t, lockID2, lock2.ID)
lockIDNotExists := "lock-not-exists"
- c.Assert(lk.FindLock(lockIDNotExists), check.IsNil)
+ require.Nil(t, lk.FindLock(lockIDNotExists))
// all locks.
locks := lk.Locks()
- c.Assert(locks, check.HasLen, 2)
- c.Assert(locks[lockID1], check.Equals, lock1) // compare pointer
- c.Assert(locks[lockID2], check.Equals, lock2)
+ require.Len(t, locks, 2)
+ require.Equal(t, lock1, locks[lockID1]) // compare pointer
+ require.Equal(t, lock2, locks[lockID2])
// remove lock.
- c.Assert(lk.RemoveLock(lockID1), check.IsTrue)
- c.Assert(lk.RemoveLock(lockIDNotExists), check.IsFalse)
- c.Assert(lk.Locks(), check.HasLen, 1)
+ require.True(t, lk.RemoveLock(lockID1))
+ require.False(t, lk.RemoveLock(lockIDNotExists))
+ require.Len(t, lk.Locks(), 1)
// clear locks.
lk.Clear()
// no locks exist.
- c.Assert(lk.Locks(), check.HasLen, 0)
+ require.Len(t, lk.Locks(), 0)
}
diff --git a/dm/pkg/shardddl/pessimism/lock_test.go b/dm/pkg/shardddl/pessimism/lock_test.go
index 87026cdf62..6079dbd9bb 100644
--- a/dm/pkg/shardddl/pessimism/lock_test.go
+++ b/dm/pkg/shardddl/pessimism/lock_test.go
@@ -14,15 +14,13 @@
package pessimism
import (
- "github.com/pingcap/check"
+ "testing"
+
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
)
-type testLock struct{}
-
-var _ = check.Suite(&testLock{})
-
-func (t *testLock) TestLock(c *check.C) {
+func TestLock(t *testing.T) {
var (
ID = "test-`foo`.`bar`"
task = "test"
@@ -40,101 +38,101 @@ func (t *testLock) TestLock(c *check.C) {
// DDLs mismatch.
synced, remain, err := l1.TrySync(source1, DDLs[1:], []string{source1})
- c.Assert(terror.ErrMasterShardingDDLDiff.Equal(err), check.IsTrue)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
- c.Assert(l1.Ready(), check.DeepEquals, map[string]bool{source1: false})
+ require.True(t, terror.ErrMasterShardingDDLDiff.Equal(err))
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
+ require.Equal(t, map[string]bool{source1: false}, l1.Ready())
synced, _ = l1.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(l1.IsDone(source1), check.IsFalse)
- c.Assert(l1.IsResolved(), check.IsFalse)
+ require.False(t, synced)
+ require.False(t, l1.IsDone(source1))
+ require.False(t, l1.IsResolved())
// synced.
synced, remain, err = l1.TrySync(source1, DDLs, []string{source1})
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
- c.Assert(l1.Ready(), check.DeepEquals, map[string]bool{source1: true})
+ require.NoError(t, err)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
+ require.Equal(t, map[string]bool{source1: true}, l1.Ready())
synced, _ = l1.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(l1.IsDone(source1), check.IsFalse)
- c.Assert(l1.IsResolved(), check.IsFalse)
+ require.True(t, synced)
+ require.False(t, l1.IsDone(source1))
+ require.False(t, l1.IsResolved())
// mark done.
l1.MarkDone(source1)
- c.Assert(l1.IsDone(source1), check.IsTrue)
- c.Assert(l1.IsResolved(), check.IsTrue)
+ require.True(t, l1.IsDone(source1))
+ require.True(t, l1.IsResolved())
// create the lock with 2 sources.
l2 := NewLock(ID, task, source1, DDLs, []string{source1, source2})
// join a new source.
synced, remain, err = l2.TrySync(source1, DDLs, []string{source2, source3})
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 2)
- c.Assert(l2.Ready(), check.DeepEquals, map[string]bool{
+ require.NoError(t, err)
+ require.False(t, synced)
+ require.Equal(t, 2, remain)
+ require.Equal(t, map[string]bool{
source1: true,
source2: false,
source3: false,
- })
+ }, l2.Ready())
// sync other sources.
synced, remain, err = l2.TrySync(source2, DDLs, []string{})
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
- c.Assert(l2.Ready(), check.DeepEquals, map[string]bool{
+ require.NoError(t, err)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
+ require.Equal(t, map[string]bool{
source1: true,
source2: true,
source3: false,
- })
+ }, l2.Ready())
synced, remain, err = l2.TrySync(source3, DDLs, nil)
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
- c.Assert(l2.Ready(), check.DeepEquals, map[string]bool{
+ require.NoError(t, err)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
+ require.Equal(t, map[string]bool{
source1: true,
source2: true,
source3: true,
- })
+ }, l2.Ready())
// done none.
- c.Assert(l2.IsDone(source1), check.IsFalse)
- c.Assert(l2.IsDone(source2), check.IsFalse)
- c.Assert(l2.IsDone(source3), check.IsFalse)
- c.Assert(l2.IsResolved(), check.IsFalse)
+ require.False(t, l2.IsDone(source1))
+ require.False(t, l2.IsDone(source2))
+ require.False(t, l2.IsDone(source3))
+ require.False(t, l2.IsResolved())
// done some.
l2.MarkDone(source1)
l2.MarkDone(source2)
- c.Assert(l2.IsDone(source1), check.IsTrue)
- c.Assert(l2.IsDone(source2), check.IsTrue)
- c.Assert(l2.IsDone(source3), check.IsFalse)
- c.Assert(l2.IsResolved(), check.IsFalse)
+ require.True(t, l2.IsDone(source1))
+ require.True(t, l2.IsDone(source2))
+ require.False(t, l2.IsDone(source3))
+ require.False(t, l2.IsResolved())
// done all.
l2.MarkDone(source3)
- c.Assert(l2.IsDone(source3), check.IsTrue)
- c.Assert(l2.IsResolved(), check.IsTrue)
+ require.True(t, l2.IsDone(source3))
+ require.True(t, l2.IsResolved())
// mark on not existing source has no effect.
l2.MarkDone("not-exist-source")
- c.Assert(l2.IsResolved(), check.IsTrue)
+ require.True(t, l2.IsResolved())
// create the lock with 2 sources.
l3 := NewLock(ID, task, source1, DDLs, []string{source1, source2})
l3.ForceSynced()
synced, remain = l3.IsSynced()
- c.Assert(synced, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ require.True(t, synced)
+ require.Equal(t, 0, remain)
// revert the synced stage.
l3.RevertSynced([]string{source2})
synced, remain = l3.IsSynced()
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ require.False(t, synced)
+ require.Equal(t, 1, remain)
ready := l3.Ready()
- c.Assert(ready[source1], check.IsTrue)
- c.Assert(ready[source2], check.IsFalse)
+ require.True(t, ready[source1])
+ require.False(t, ready[source2])
}
diff --git a/dm/pkg/shardddl/pessimism/operation_test.go b/dm/pkg/shardddl/pessimism/operation_test.go
index 80a012441d..3b97b63452 100644
--- a/dm/pkg/shardddl/pessimism/operation_test.go
+++ b/dm/pkg/shardddl/pessimism/operation_test.go
@@ -18,24 +18,23 @@ import (
"fmt"
"time"
- "github.com/pingcap/check"
"go.etcd.io/etcd/api/v3/mvccpb"
clientv3 "go.etcd.io/etcd/client/v3"
)
-func (t *testForEtcd) TestOperationJSON(c *check.C) {
+func (t *testForEtcd) TestOperationJSON() {
o1 := NewOperation("test-ID", "test", "mysql-replica-1", []string{
"ALTER TABLE bar ADD COLUMN c1 INT",
}, true, false)
j, err := o1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"id":"test-ID","task":"test","source":"mysql-replica-1","ddls":["ALTER TABLE bar ADD COLUMN c1 INT"],"exec":true,"done":false}`)
- c.Assert(j, check.Equals, o1.String())
+ t.Require().NoError(err)
+ t.Require().Equal(`{"id":"test-ID","task":"test","source":"mysql-replica-1","ddls":["ALTER TABLE bar ADD COLUMN c1 INT"],"exec":true,"done":false}`, j)
+ t.Require().Equal(o1.String(), j)
o2, err := operationFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(o2, check.DeepEquals, o1)
+ t.Require().NoError(err)
+ t.Require().Equal(o1, o2)
}
func watchExactOperations(
@@ -74,8 +73,8 @@ func watchExactOperations(
return ops, nil
}
-func (t *testForEtcd) TestOperationEtcd(c *check.C) {
- defer clearTestInfoOperation(c)
+func (t *testForEtcd) TestOperationEtcd() {
+ defer clearTestInfoOperation(t.T())
var (
task1 = "test1"
@@ -94,113 +93,113 @@ func (t *testForEtcd) TestOperationEtcd(c *check.C) {
// put the same keys twice.
rev1, succ, err := PutOperations(etcdTestCli, false, op11, op12)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(succ)
rev2, succ, err := PutOperations(etcdTestCli, false, op11, op12)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev2, check.Greater, rev1)
+ t.Require().NoError(err)
+ t.Require().True(succ)
+ t.Require().Greater(rev2, rev1)
// start the watcher with the same revision as the last PUT for the specified task and source.
ops, err := watchExactOperations(context.Background(), etcdTestCli, mvccpb.PUT, task1, source1, rev2, 1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// watch should only get op11.
- c.Assert(ops[0], check.DeepEquals, op11)
+ t.Require().Equal(op11, ops[0])
// put for another task.
rev3, succ, err := PutOperations(etcdTestCli, false, op21)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(succ)
// start the watch with an older revision for all tasks and sources.
ops, err = watchExactOperations(context.Background(), etcdTestCli, mvccpb.PUT, "", "", rev2, 3)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// watch should get 3 operations.
- c.Assert(ops[0], check.DeepEquals, op11)
- c.Assert(ops[1], check.DeepEquals, op12)
- c.Assert(ops[2], check.DeepEquals, op21)
+ t.Require().Equal(op11, ops[0])
+ t.Require().Equal(op12, ops[1])
+ t.Require().Equal(op21, ops[2])
// get all operations.
opm, rev4, err := GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Equals, rev3)
- c.Assert(opm, check.HasLen, 2)
- c.Assert(opm, check.HasKey, task1)
- c.Assert(opm, check.HasKey, task2)
- c.Assert(opm[task1], check.HasLen, 2)
- c.Assert(opm[task1][source1], check.DeepEquals, op11)
- c.Assert(opm[task1][source2], check.DeepEquals, op12)
- c.Assert(opm[task2], check.HasLen, 1)
- c.Assert(opm[task2][source1], check.DeepEquals, op21)
+ t.Require().NoError(err)
+ t.Require().Equal(rev3, rev4)
+ t.Require().Len(opm, 2)
+ t.Require().Contains(opm, task1)
+ t.Require().Contains(opm, task2)
+ t.Require().Len(opm[task1], 2)
+ t.Require().Equal(op11, opm[task1][source1])
+ t.Require().Equal(op12, opm[task1][source2])
+ t.Require().Len(opm[task2], 1)
+ t.Require().Equal(op21, opm[task2][source1])
// put for `skipDone` with `done` in etcd, the operations should not be skipped.
// case: all of kvs "the `done` field is not `true`".
rev5, succ, err := PutOperations(etcdTestCli, true, op11, op12)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev5, check.Greater, rev4)
+ t.Require().NoError(err)
+ t.Require().True(succ)
+ t.Require().Greater(rev5, rev4)
// delete op11.
rev6, err := DeleteOperations(etcdTestCli, op11)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, rev5)
+ t.Require().NoError(err)
+ t.Require().Greater(rev6, rev5)
// start watch with an older revision for the deleted op11.
ops, err = watchExactOperations(context.Background(), etcdTestCli, mvccpb.DELETE, op11.Task, op11.Source, rev5, 1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// watch should got the previous deleted operation.
op11d := ops[0]
- c.Assert(op11d.IsDeleted, check.IsTrue)
+ t.Require().True(op11d.IsDeleted)
op11d.IsDeleted = false // reset to false
- c.Assert(op11d, check.DeepEquals, op11)
+ t.Require().Equal(op11, op11d)
// get again, op11 should be deleted.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm[task1], check.HasLen, 1)
- c.Assert(opm[task1][source2], check.DeepEquals, op12)
+ t.Require().NoError(err)
+ t.Require().Len(opm[task1], 1)
+ t.Require().Equal(op12, opm[task1][source2])
// put for `skipDone` with `done` in etcd, the operations should not be skipped.
// case: all of kvs "not exist".
rev7, succ, err := PutOperations(etcdTestCli, true, op11, op13)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsTrue)
- c.Assert(rev7, check.Greater, rev6)
+ t.Require().NoError(err)
+ t.Require().True(succ)
+ t.Require().Greater(rev7, rev6)
// get again, op11 and op13 should be putted.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm[task1], check.HasLen, 3)
- c.Assert(opm[task1][source1], check.DeepEquals, op11)
- c.Assert(opm[task1][source2], check.DeepEquals, op12)
- c.Assert(opm[task1][source3], check.DeepEquals, op13)
+ t.Require().NoError(err)
+ t.Require().Len(opm[task1], 3)
+ t.Require().Equal(op11, opm[task1][source1])
+ t.Require().Equal(op12, opm[task1][source2])
+ t.Require().Equal(op13, opm[task1][source3])
// update op12 to `done`.
op12c := op12
op12c.Done = true
putOp, err := putOperationOp(op12c)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
txnResp, err := etcdTestCli.Txn(context.Background()).Then(putOp).Commit()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// delete op13.
rev8, err := DeleteOperations(etcdTestCli, op13)
- c.Assert(err, check.IsNil)
- c.Assert(rev8, check.Greater, txnResp.Header.Revision)
+ t.Require().NoError(err)
+ t.Require().Greater(rev8, txnResp.Header.Revision)
// put for `skipDone` with `done` in etcd, the operations should be skipped.
// case: any of kvs ("exist" and "the `done` field is `true`").
rev9, succ, err := PutOperations(etcdTestCli, true, op12, op13)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsFalse)
- c.Assert(rev9, check.Equals, rev8)
+ t.Require().NoError(err)
+ t.Require().False(succ)
+ t.Require().Equal(rev8, rev9)
// get again, op13 not putted.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm[task1], check.HasLen, 2)
- c.Assert(opm[task1][source1], check.DeepEquals, op11)
- c.Assert(opm[task1][source2], check.DeepEquals, op12c)
+ t.Require().NoError(err)
+ t.Require().Len(opm[task1], 2)
+ t.Require().Equal(op11, opm[task1][source1])
+ t.Require().Equal(op12c, opm[task1][source2])
// FIXME: the right result:
// the operations should *NOT* be skipped.
@@ -209,7 +208,7 @@ func (t *testForEtcd) TestOperationEtcd(c *check.C) {
// - some of kvs "not exist"
// after FIXED, this test case will fail and need to be updated.
rev10, succ, err := PutOperations(etcdTestCli, true, op11, op13)
- c.Assert(err, check.IsNil)
- c.Assert(succ, check.IsFalse)
- c.Assert(rev10, check.Equals, rev9)
+ t.Require().NoError(err)
+ t.Require().False(succ)
+ t.Require().Equal(rev9, rev10)
}
diff --git a/dm/pkg/shardddl/pessimism/ops_test.go b/dm/pkg/shardddl/pessimism/ops_test.go
index 4d32768329..b68a9a6999 100644
--- a/dm/pkg/shardddl/pessimism/ops_test.go
+++ b/dm/pkg/shardddl/pessimism/ops_test.go
@@ -13,12 +13,8 @@
package pessimism
-import (
- "github.com/pingcap/check"
-)
-
-func (t *testForEtcd) TestPutOperationDeleteInfo(c *check.C) {
- defer clearTestInfoOperation(c)
+func (t *testForEtcd) TestPutOperationDeleteInfo() {
+ defer clearTestInfoOperation(t.T())
var (
task = "test"
@@ -30,88 +26,88 @@ func (t *testForEtcd) TestPutOperationDeleteInfo(c *check.C) {
// put info.
_, err := PutInfo(etcdTestCli, info)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// verify the info exists.
ifm, _, err := GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task)
- c.Assert(ifm[task][source], check.DeepEquals, info)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 1)
+ t.Require().Contains(ifm, task)
+ t.Require().Equal(info, ifm[task][source])
// verify no operations exist.
opm, _, err := GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(opm, 0)
// put operation & delete info.
done, _, err := PutOperationDeleteExistInfo(etcdTestCli, op, info)
- c.Assert(err, check.IsNil)
- c.Assert(done, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(done)
// verify no info exit.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 0)
// verify the operation exists.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
- c.Assert(opm, check.HasKey, task)
- c.Assert(opm[task][source], check.DeepEquals, op)
+ t.Require().NoError(err)
+ t.Require().Len(opm, 1)
+ t.Require().Contains(opm, task)
+ t.Require().Equal(op, opm[task][source])
// try to put operation & delete info again, succeed(to support reentrant).
done, _, err = PutOperationDeleteExistInfo(etcdTestCli, op, info)
- c.Assert(err, check.IsNil)
- c.Assert(done, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(done)
// PUT info and operation.
_, err = PutInfo(etcdTestCli, info)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, _, err = PutOperations(etcdTestCli, true, op)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// verify the info exists.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm, check.HasKey, task)
- c.Assert(ifm[task][source], check.DeepEquals, info)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 1)
+ t.Require().Contains(ifm, task)
+ t.Require().Equal(info, ifm[task][source])
// verify the operation exists.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
- c.Assert(opm, check.HasKey, task)
- c.Assert(opm[task][source], check.DeepEquals, op)
+ t.Require().NoError(err)
+ t.Require().Len(opm, 1)
+ t.Require().Contains(opm, task)
+ t.Require().Equal(op, opm[task][source])
// DELETE info and operation.
_, err = DeleteInfosOperations(etcdTestCli, []Info{info}, []Operation{op})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// verify no info exit.
ifm, _, err = GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(ifm, 0)
// verify no operations exist.
opm, _, err = GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(opm, 0)
// put a done operation into etcd and try to delete operation again.
op.Done = true
_, _, err = PutOperations(etcdTestCli, true, op)
op.Done = false
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// try to put operation & delete info again, fail(operation not equal).
done, _, err = PutOperationDeleteExistInfo(etcdTestCli, op, info)
- c.Assert(err, check.IsNil)
- c.Assert(done, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().False(done)
// DELETE info and operation.
_, err = DeleteInfosOperations(etcdTestCli, []Info{info}, []Operation{op})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
diff --git a/dm/pkg/upgrade/upgrade_test.go b/dm/pkg/upgrade/upgrade_test.go
index 225ae9b56f..ca32f1e277 100644
--- a/dm/pkg/upgrade/upgrade_test.go
+++ b/dm/pkg/upgrade/upgrade_test.go
@@ -18,8 +18,9 @@ import (
"fmt"
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/common"
+ "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
@@ -34,51 +35,44 @@ var (
func TestUpgrade(t *testing.T) {
integration.BeforeTestExternal(t)
- suite.(*testForEtcd).testT = t
- suiteForBigTxn.(*testForBigTxn).testT = t
-
- check.TestingT(t)
+ suite.Run(t, new(testForEtcd))
+ suite.Run(t, new(testForBigTxn))
}
-func clearTestData(c *check.C) {
+func clearTestData(t require.TestingT) {
clearVersion := clientv3.OpDelete(common.ClusterVersionKey)
_, err := etcdTestCli.Txn(context.Background()).Then(clearVersion).Commit()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
type testForEtcd struct {
- testT *testing.T
+ suite.Suite
}
type testForBigTxn struct {
- testT *testing.T
+ suite.Suite
}
-var (
- suite = check.SerialSuites(&testForEtcd{})
- suiteForBigTxn = check.SerialSuites(&testForBigTxn{})
-)
-
-func (t *testForEtcd) SetUpSuite(c *check.C) {
- mockCluster = integration.NewClusterV3(t.testT, &integration.ClusterConfig{Size: 1})
+func (t *testForEtcd) SetupSuite() {
+ mockCluster = integration.NewClusterV3(t.T(), &integration.ClusterConfig{Size: 1})
etcdTestCli = mockCluster.RandClient()
}
-func (t *testForEtcd) TearDownSuite(c *check.C) {
- mockCluster.Terminate(t.testT)
+func (t *testForEtcd) TearDownSuite() {
+ mockCluster.Terminate(t.T())
}
-func (t *testForBigTxn) SetUpSuite(c *check.C) {
- bigTxnCluster = integration.NewClusterV3(t.testT, &integration.ClusterConfig{Size: 1, MaxTxnOps: 2048})
+func (t *testForBigTxn) SetupSuite() {
+ bigTxnCluster = integration.NewClusterV3(t.T(), &integration.ClusterConfig{Size: 1, MaxTxnOps: 2048})
bigTxnTestCli = bigTxnCluster.RandClient()
}
-func (t *testForBigTxn) TearDownSuite(c *check.C) {
- bigTxnCluster.Terminate(t.testT)
+func (t *testForBigTxn) TearDownSuite() {
+ bigTxnCluster.Terminate(t.T())
}
-func (t *testForEtcd) TestTryUpgrade(c *check.C) {
- defer clearTestData(c)
+func (t *testForEtcd) TestTryUpgrade() {
+ defer clearTestData(t.T())
// mock upgrade functions.
oldUpgrades := upgrades
@@ -95,26 +89,26 @@ func (t *testForEtcd) TestTryUpgrade(c *check.C) {
// no previous version exist, new cluster.
ver, rev1, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(ver.NotSet(), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev1, int64(0))
+ t.Require().True(ver.NotSet())
// try to upgrade, run actual upgrade functions
- c.Assert(TryUpgrade(etcdTestCli, newUpgradeContext()), check.IsNil)
+ t.Require().NoError(TryUpgrade(etcdTestCli, newUpgradeContext()))
ver, rev2, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(ver, check.DeepEquals, CurrentVersion)
- c.Assert(mockVerNo, check.Equals, uint64(5))
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
+ t.Require().Equal(CurrentVersion, ver)
+ t.Require().Equal(uint64(5), mockVerNo)
// try to upgrade again, do nothing because the version is the same.
mockVerNo = 0
- c.Assert(TryUpgrade(etcdTestCli, newUpgradeContext()), check.IsNil)
+ t.Require().NoError(TryUpgrade(etcdTestCli, newUpgradeContext()))
ver, rev3, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(ver, check.DeepEquals, CurrentVersion)
- c.Assert(mockVerNo, check.Equals, uint64(0))
+ t.Require().NoError(err)
+ t.Require().Equal(rev2, rev3)
+ t.Require().Equal(CurrentVersion, ver)
+ t.Require().Equal(uint64(0), mockVerNo)
// mock a newer current version.
oldCurrentVer := CurrentVersion
@@ -125,60 +119,62 @@ func (t *testForEtcd) TestTryUpgrade(c *check.C) {
CurrentVersion = newerVer
// try to upgrade, to a newer version, upgrade operations applied.
- c.Assert(TryUpgrade(etcdTestCli, newUpgradeContext()), check.IsNil)
+ t.Require().NoError(TryUpgrade(etcdTestCli, newUpgradeContext()))
ver, rev4, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
- c.Assert(ver, check.DeepEquals, newerVer)
- c.Assert(mockVerNo, check.Equals, currentInternalNo+1)
+ t.Require().NoError(err)
+ t.Require().Greater(rev4, rev3)
+ t.Require().Equal(newerVer, ver)
+ t.Require().Equal(currentInternalNo+1, mockVerNo)
// try to upgrade, to an older version, do nothing.
mockVerNo = 0
CurrentVersion = oldCurrentVer
- c.Assert(TryUpgrade(etcdTestCli, newUpgradeContext()), check.IsNil)
+ t.Require().NoError(TryUpgrade(etcdTestCli, newUpgradeContext()))
ver, rev5, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev5, check.Equals, rev4)
- c.Assert(ver, check.DeepEquals, newerVer) // not changed.
- c.Assert(mockVerNo, check.Equals, uint64(0))
+ t.Require().NoError(err)
+ t.Require().Equal(rev4, rev5)
+ t.Require().Equal(newerVer, ver) // not changed.
+ t.Require().Equal(uint64(0), mockVerNo)
}
-func (t *testForEtcd) TestUpgradeToVer3(c *check.C) {
+func (t *testForEtcd) TestUpgradeToVer3() {
ctx := context.Background()
source := "source-1"
oldKey := common.UpstreamConfigKeyAdapterV1.Encode(source)
oldVal := "test"
_, err := etcdTestCli.Put(ctx, oldKey, oldVal)
- c.Assert(err, check.IsNil)
- c.Assert(upgradeToVer3(ctx, etcdTestCli), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(upgradeToVer3(ctx, etcdTestCli))
newKey := common.UpstreamConfigKeyAdapter.Encode(source)
resp, err := etcdTestCli.Get(ctx, newKey)
- c.Assert(err, check.IsNil)
- c.Assert(resp.Kvs, check.HasLen, 1)
- c.Assert(string(resp.Kvs[0].Value), check.Equals, oldVal)
+ t.Require().NoError(err)
+ t.Require().Len(resp.Kvs, 1)
+ t.Require().Equal(oldVal, string(resp.Kvs[0].Value))
// test won't overwrite new value
newVal := "test2"
_, err = etcdTestCli.Put(ctx, newKey, newVal)
- c.Assert(err, check.IsNil)
- c.Assert(upgradeToVer3(ctx, etcdTestCli), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(upgradeToVer3(ctx, etcdTestCli))
resp, err = etcdTestCli.Get(ctx, newKey)
- c.Assert(err, check.IsNil)
- c.Assert(resp.Kvs, check.HasLen, 1)
- c.Assert(string(resp.Kvs[0].Value), check.Equals, newVal)
+ t.Require().NoError(err)
+ t.Require().Len(resp.Kvs, 1)
+ t.Require().Equal(newVal, string(resp.Kvs[0].Value))
for i := 0; i < 500; i++ {
key := common.UpstreamConfigKeyAdapterV1.Encode(fmt.Sprintf("%s-%d", source, i))
val := fmt.Sprintf("%s-%d", oldVal, i)
_, err := etcdTestCli.Put(ctx, key, val)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
- c.Assert(upgradeToVer3(ctx, etcdTestCli), check.ErrorMatches, ".*too many operations in txn request.*")
+ err = upgradeToVer3(ctx, etcdTestCli)
+ t.Require().Error(err)
+ t.Require().Regexp(".*too many operations in txn request.*", err.Error())
}
-func (t *testForBigTxn) TestUpgradeToVer3(c *check.C) {
+func (t *testForBigTxn) TestUpgradeToVer3() {
source := "source-1"
oldVal := "test"
ctx := context.Background()
@@ -187,7 +183,7 @@ func (t *testForBigTxn) TestUpgradeToVer3(c *check.C) {
key := common.UpstreamConfigKeyAdapterV1.Encode(fmt.Sprintf("%s-%d", source, i))
val := fmt.Sprintf("%s-%d", oldVal, i)
_, err := bigTxnTestCli.Put(ctx, key, val)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
- c.Assert(upgradeToVer3(ctx, bigTxnTestCli), check.IsNil)
+ t.Require().NoError(upgradeToVer3(ctx, bigTxnTestCli))
}
diff --git a/dm/pkg/upgrade/version_test.go b/dm/pkg/upgrade/version_test.go
index 02466a9fd1..c432bd5a3b 100644
--- a/dm/pkg/upgrade/version_test.go
+++ b/dm/pkg/upgrade/version_test.go
@@ -13,60 +13,56 @@
package upgrade
-import (
- "github.com/pingcap/check"
-)
-
-func (t *testForEtcd) TestVersionJSON(c *check.C) {
+func (t *testForEtcd) TestVersionJSON() {
v1 := NewVersion(1, "v2.0.0")
j, err := v1.toJSON()
- c.Assert(err, check.IsNil)
- c.Assert(j, check.Equals, `{"internal-no":1,"release-ver":"v2.0.0"}`)
- c.Assert(j, check.Equals, v1.String())
+ t.Require().NoError(err)
+ t.Require().Equal(`{"internal-no":1,"release-ver":"v2.0.0"}`, j)
+ t.Require().Equal(v1.String(), j)
v2, err := versionFromJSON(j)
- c.Assert(err, check.IsNil)
- c.Assert(v2, check.DeepEquals, v1)
+ t.Require().NoError(err)
+ t.Require().Equal(v1, v2)
}
-func (t *testForEtcd) TestVersionFunc(c *check.C) {
+func (t *testForEtcd) TestVersionFunc() {
var ve Version
- c.Assert(ve.NotSet(), check.IsTrue)
- c.Assert(CurrentVersion.NotSet(), check.IsFalse)
+ t.Require().True(ve.NotSet())
+ t.Require().False(CurrentVersion.NotSet())
v1 := NewVersion(1, "v2.0.0")
v2 := NewVersion(2, "v2.1.0")
- c.Assert(v1.Compare(v2), check.Equals, -1)
- c.Assert(v2.Compare(v1), check.Equals, 1)
+ t.Require().Equal(-1, v1.Compare(v2))
+ t.Require().Equal(1, v2.Compare(v1))
v11 := v1
- c.Assert(v11.Compare(v1), check.Equals, 0)
+ t.Require().Equal(0, v11.Compare(v1))
// we only compare InternalNo now, if we should compare release version later, this should be fail.
v12 := NewVersion(v1.InternalNo, "another-release-ver")
- c.Assert(v12.Compare(v1), check.Equals, 0)
+ t.Require().Equal(0, v12.Compare(v1))
// MinVersion should < any current version.
- c.Assert(MinVersion.Compare(CurrentVersion), check.Equals, -1)
+ t.Require().Equal(-1, MinVersion.Compare(CurrentVersion))
}
-func (t *testForEtcd) TestVersionEtcd(c *check.C) {
- defer clearTestData(c)
+func (t *testForEtcd) TestVersionEtcd() {
+ defer clearTestData(t.T())
// try to get the version, but not exist.
ver, rev1, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
- c.Assert(ver.NotSet(), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Greater(rev1, int64(0))
+ t.Require().True(ver.NotSet())
// put current version into etcd.
rev2, err := PutVersion(etcdTestCli, CurrentVersion)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
+ t.Require().NoError(err)
+ t.Require().Greater(rev2, rev1)
// get the version back.
ver, rev3, err := GetVersion(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Equals, rev2)
- c.Assert(ver, check.DeepEquals, CurrentVersion)
+ t.Require().NoError(err)
+ t.Require().Equal(rev2, rev3)
+ t.Require().Equal(CurrentVersion, ver)
}
diff --git a/dm/pkg/v1dbschema/schema_test.go b/dm/pkg/v1dbschema/schema_test.go
index 300b06a612..c97668450b 100644
--- a/dm/pkg/v1dbschema/schema_test.go
+++ b/dm/pkg/v1dbschema/schema_test.go
@@ -21,20 +21,21 @@ import (
"github.com/DATA-DOG/go-sqlmock"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/config/dbconfig"
"github.com/pingcap/tiflow/dm/pkg/conn"
tcontext "github.com/pingcap/tiflow/dm/pkg/context"
"github.com/pingcap/tiflow/dm/pkg/gtid"
+ "github.com/stretchr/testify/suite"
)
func TestSuite(t *testing.T) {
- check.TestingT(t)
+ suite.Run(t, new(testSchema))
}
type testSchema struct {
+ suite.Suite
host string
port int
user string
@@ -43,17 +44,15 @@ type testSchema struct {
mockDB sqlmock.Sqlmock
}
-var _ = check.Suite(&testSchema{})
-
-func (t *testSchema) SetUpSuite(c *check.C) {
- t.setUpDBConn(c)
+func (t *testSchema) SetupSuite() {
+ t.setUpDBConn()
}
-func (t *testSchema) TestTearDown(c *check.C) {
+func (t *testSchema) TestTearDown() {
t.db.Close()
}
-func (t *testSchema) setUpDBConn(c *check.C) {
+func (t *testSchema) setUpDBConn() {
t.host = os.Getenv("MYSQL_HOST")
if t.host == "" {
t.host = "127.0.0.1"
@@ -78,12 +77,12 @@ func (t *testSchema) setUpDBConn(c *check.C) {
cfg.Adjust()
var err error
- t.mockDB = conn.InitMockDB(c)
+ t.mockDB = conn.InitMockDB(t.T())
t.db, err = conn.GetUpstreamDB(cfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
-func (t *testSchema) TestSchemaV106ToV20x(c *check.C) {
+func (t *testSchema) TestSchemaV106ToV20x() {
var (
tctx = tcontext.Background()
cfg = &config.SubTaskConfig{
@@ -101,10 +100,10 @@ func (t *testSchema) TestSchemaV106ToV20x(c *check.C) {
endGS, _ = gtid.ParserGTID(gmysql.MySQLFlavor, "ccb992ad-a557-11ea-ba6a-0242ac140002:1-16")
)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/v1dbschema/MockGetGTIDsForPos", `return("ccb992ad-a557-11ea-ba6a-0242ac140002:10-16")`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/v1dbschema/MockGetGTIDsForPos", `return("ccb992ad-a557-11ea-ba6a-0242ac140002:10-16")`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/v1dbschema/MockGetGTIDsForPos")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("ccb992ad-a557-11ea-ba6a-0242ac140002:1-9")`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("ccb992ad-a557-11ea-ba6a-0242ac140002:1-9")`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged")
@@ -118,13 +117,13 @@ func (t *testSchema) TestSchemaV106ToV20x(c *check.C) {
t.mockDB.ExpectBegin()
t.mockDB.ExpectExec("UPDATE `dm_meta_v106_test`.`test_onlineddl`.*").WithArgs(cfg.SourceID, fmt.Sprint(cfg.ServerID)).WillReturnResult(sqlmock.NewErrorResult(nil))
t.mockDB.ExpectCommit()
- c.Assert(UpdateSchema(tctx, t.db, cfg), check.IsNil)
- c.Assert(t.mockDB.ExpectationsWereMet(), check.IsNil)
+ t.Require().NoError(UpdateSchema(tctx, t.db, cfg))
+ t.Require().NoError(t.mockDB.ExpectationsWereMet())
// update schema with GTID enabled.
cfg.EnableGTID = true
// reset mockDB conn because last UpdateSchema would close the conn.
- t.setUpDBConn(c)
+ t.setUpDBConn()
// mock updateSyncerCheckpoint
t.mockDB.ExpectQuery("SELECT binlog_name, binlog_pos FROM `dm_meta_v106_test`.`test_syncer_checkpoint`.*").
WithArgs(cfg.SourceID, true).WillReturnRows(sqlmock.NewRows([]string{"binlog_name", "binlog_pos"}).
@@ -141,6 +140,6 @@ func (t *testSchema) TestSchemaV106ToV20x(c *check.C) {
t.mockDB.ExpectBegin()
t.mockDB.ExpectExec("UPDATE `dm_meta_v106_test`.`test_onlineddl`.*").WithArgs(cfg.SourceID, fmt.Sprint(cfg.ServerID)).WillReturnResult(sqlmock.NewErrorResult(nil))
t.mockDB.ExpectCommit()
- c.Assert(UpdateSchema(tctx, t.db, cfg), check.IsNil)
- c.Assert(t.mockDB.ExpectationsWereMet(), check.IsNil)
+ t.Require().NoError(UpdateSchema(tctx, t.db, cfg))
+ t.Require().NoError(t.mockDB.ExpectationsWereMet())
}
diff --git a/dm/pkg/v1workermeta/api_test.go b/dm/pkg/v1workermeta/api_test.go
index 0406965bbf..ecb255816e 100644
--- a/dm/pkg/v1workermeta/api_test.go
+++ b/dm/pkg/v1workermeta/api_test.go
@@ -18,18 +18,15 @@ import (
"os"
"path/filepath"
"runtime"
+ "testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pb"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/require"
)
-type testAPI struct{}
-
-var _ = check.Suite(&testAPI{})
-
-func (t *testAPI) TestAPI(c *check.C) {
+func TestAPI(t *testing.T) {
// nolint:dogsled
_, currFile, _, _ := runtime.Caller(0)
srcMetaPath := filepath.Join(filepath.Dir(currFile), "v106_data_for_test")
@@ -42,116 +39,116 @@ func (t *testAPI) TestAPI(c *check.C) {
dbPath = oldDBPath
}()
- metaPath = c.MkDir()
+ metaPath = t.TempDir()
dbPath = filepath.Join(metaPath, "kv")
// copy test data to a temp directory.
- copyDir(c, dbPath, srcDBPath)
+ copyDir(t, dbPath, srcDBPath)
// get subtasks meta.
meta, err := GetSubtasksMeta()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// verify tasks meta.
// - task_single:
// - no shard task, Running stage.
// - task_shard
// - shard task, Paused stage.
- c.Assert(meta, check.HasLen, 2)
- c.Assert(meta, check.HasKey, "task_single")
- c.Assert(meta, check.HasKey, "task_shard")
- c.Assert(meta["task_single"].Stage, check.Equals, pb.Stage_Running)
- c.Assert(meta["task_shard"].Stage, check.Equals, pb.Stage_Paused)
+ require.Len(t, meta, 2)
+ require.Contains(t, meta, "task_single")
+ require.Contains(t, meta, "task_shard")
+ require.Equal(t, pb.Stage_Running, meta["task_single"].Stage)
+ require.Equal(t, pb.Stage_Paused, meta["task_shard"].Stage)
taskSingleCfg, err := SubTaskConfigFromV1TOML(meta["task_single"].Task)
- c.Assert(err, check.IsNil)
- c.Assert(taskSingleCfg.IsSharding, check.IsFalse)
- c.Assert(taskSingleCfg.MydumperConfig.ChunkFilesize, check.Equals, "64")
+ require.NoError(t, err)
+ require.False(t, taskSingleCfg.IsSharding)
+ require.Equal(t, "64", taskSingleCfg.MydumperConfig.ChunkFilesize)
taskShardCfg, err := SubTaskConfigFromV1TOML(meta["task_shard"].Task)
- c.Assert(err, check.IsNil)
- c.Assert(taskShardCfg.IsSharding, check.IsTrue)
- c.Assert(taskSingleCfg.MydumperConfig.ChunkFilesize, check.Equals, "64")
+ require.NoError(t, err)
+ require.True(t, taskShardCfg.IsSharding)
+ require.Equal(t, "64", taskSingleCfg.MydumperConfig.ChunkFilesize)
// try to get meta again, the same as before.
meta2, err := GetSubtasksMeta()
- c.Assert(err, check.IsNil)
- c.Assert(meta2, check.DeepEquals, meta)
+ require.NoError(t, err)
+ require.Equal(t, meta, meta2)
// remove all metadata.
- c.Assert(RemoveSubtasksMeta(), check.IsNil)
+ require.NoError(t, RemoveSubtasksMeta())
// verify removed.
- c.Assert(utils.IsDirExists(metaPath), check.IsFalse)
+ require.False(t, utils.IsDirExists(metaPath))
// try to get meta again, nothing exists.
meta3, err := GetSubtasksMeta()
- c.Assert(err, check.IsNil)
- c.Assert(meta3, check.IsNil)
+ require.NoError(t, err)
+ require.Nil(t, meta3)
// remove empty path is invalid.
- c.Assert(terror.ErrInvalidV1WorkerMetaPath.Equal(RemoveSubtasksMeta()), check.IsTrue)
+ require.True(t, terror.ErrInvalidV1WorkerMetaPath.Equal(RemoveSubtasksMeta()))
// remove an invalid meta path.
- metaPath = c.MkDir()
+ metaPath = t.TempDir()
dbPath = filepath.Join(metaPath, "kv")
- c.Assert(os.Mkdir(dbPath, 0o644), check.IsNil)
- c.Assert(terror.ErrInvalidV1WorkerMetaPath.Equal(RemoveSubtasksMeta()), check.IsTrue)
+ require.NoError(t, os.Mkdir(dbPath, 0o644))
+ require.True(t, terror.ErrInvalidV1WorkerMetaPath.Equal(RemoveSubtasksMeta()))
}
-func copyDir(c *check.C, dst, src string) {
+func copyDir(t *testing.T, dst, src string) {
si, err := os.Stat(src)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if !si.IsDir() {
- c.Fatalf("source %s is not a directory", src)
+ t.Fatalf("source %s is not a directory", src)
}
_, err = os.Stat(dst)
if err != nil && !os.IsNotExist(err) {
- c.Fatalf("fail to get stat for source %s", src)
+ t.Fatalf("fail to get stat for source %s", src)
}
if err == nil {
- c.Fatalf("destination %s already exists", dst)
+ t.Fatalf("destination %s already exists", dst)
}
err = os.MkdirAll(dst, si.Mode())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
entries, err := os.ReadDir(src)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, entry := range entries {
srcPath := filepath.Join(src, entry.Name())
dstPath := filepath.Join(dst, entry.Name())
if entry.IsDir() {
- copyDir(c, dstPath, srcPath)
+ copyDir(t, dstPath, srcPath)
} else {
info, err := entry.Info()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// Skip symlinks.
if info.Mode()&os.ModeSymlink != 0 {
continue
}
- copyFile(c, dstPath, srcPath)
+ copyFile(t, dstPath, srcPath)
}
}
}
-func copyFile(c *check.C, dst, src string) {
+func copyFile(t *testing.T, dst, src string) {
in, err := os.Open(src)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
defer in.Close()
out, err := os.Create(dst)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
defer out.Close()
_, err = io.Copy(out, in)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
si, err := os.Stat(src)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = os.Chmod(dst, si.Mode())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
diff --git a/dm/pkg/v1workermeta/meta_test.go b/dm/pkg/v1workermeta/meta_test.go
index b7b9ffdbd1..b5e67ea325 100644
--- a/dm/pkg/v1workermeta/meta_test.go
+++ b/dm/pkg/v1workermeta/meta_test.go
@@ -17,21 +17,13 @@ import (
"path"
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pb"
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
"github.com/syndtr/goleveldb/leveldb"
)
-func TestSuite(t *testing.T) {
- check.TestingT(t)
-}
-
-type testMeta struct{}
-
-var _ = check.Suite(&testMeta{})
-
var (
testTask1 = &config.SubTaskConfig{
Name: "task1",
@@ -46,12 +38,12 @@ var (
testTask2Meta *pb.V1SubTaskMeta
)
-func testSetUpDB(c *check.C) *leveldb.DB {
- c.Assert(testTask1.Adjust(true), check.IsNil)
- c.Assert(testTask2.Adjust(true), check.IsNil)
+func testSetUpDB(t *testing.T) *leveldb.DB {
+ require.NoError(t, testTask1.Adjust(true))
+ require.NoError(t, testTask2.Adjust(true))
testTask1Str, err := testTask1.Toml()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testTask1Meta = &pb.V1SubTaskMeta{
Op: pb.TaskOp_Start,
Name: testTask1.Name,
@@ -60,7 +52,7 @@ func testSetUpDB(c *check.C) *leveldb.DB {
}
testTask2Str, err := testTask2.Toml()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testTask2Meta = &pb.V1SubTaskMeta{
Op: pb.TaskOp_Start,
Name: testTask2.Name,
@@ -68,68 +60,70 @@ func testSetUpDB(c *check.C) *leveldb.DB {
Task: []byte(testTask2Str),
}
- dir := c.MkDir()
+ dir := t.TempDir()
dbDir := path.Join(dir, "kv")
db, err := openDB(dbDir, defaultKVConfig)
if err != nil {
- c.Fatalf("fail to open leveldb %v", err)
+ t.Fatalf("fail to open leveldb %v", err)
}
return db
}
-func (t *testMeta) TestNewMetaDB(c *check.C) {
- db := testSetUpDB(c)
+func TestNewMetaDB(t *testing.T) {
+ db := testSetUpDB(t)
defer db.Close()
metaDB, err := newMeta(db)
- c.Assert(err, check.IsNil)
- c.Assert(metaDB.tasks, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, metaDB.tasks, 0)
// check nil db
metaDB, err = newMeta(nil)
- c.Assert(terror.ErrWorkerLogInvalidHandler.Equal(err), check.IsTrue)
- c.Assert(metaDB, check.IsNil)
+ require.True(t, terror.ErrWorkerLogInvalidHandler.Equal(err))
+ require.Nil(t, metaDB)
}
-func (t *testMeta) TestTask(c *check.C) {
- db := testSetUpDB(c)
+func TestTask(t *testing.T) {
+ db := testSetUpDB(t)
defer db.Close()
// set task meta
- c.Assert(terror.ErrWorkerLogInvalidHandler.Equal(setTaskMeta(nil, nil)), check.IsTrue)
+ require.True(t, terror.ErrWorkerLogInvalidHandler.Equal(setTaskMeta(nil, nil)))
err := setTaskMeta(db, nil)
- c.Assert(err, check.ErrorMatches, ".*empty task.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*empty task.*", err.Error())
err = setTaskMeta(db, &pb.V1SubTaskMeta{})
- c.Assert(err, check.ErrorMatches, ".*empty task.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*empty task.*", err.Error())
- c.Assert(setTaskMeta(db, testTask1Meta), check.IsNil)
- c.Assert(setTaskMeta(db, testTask2Meta), check.IsNil)
+ require.NoError(t, setTaskMeta(db, testTask1Meta))
+ require.NoError(t, setTaskMeta(db, testTask2Meta))
// load task meta
metaDB, err := newMeta(db)
- c.Assert(err, check.IsNil)
- c.Assert(metaDB.tasks, check.DeepEquals, map[string]*pb.V1SubTaskMeta{
+ require.NoError(t, err)
+ require.Equal(t, map[string]*pb.V1SubTaskMeta{
"task1": testTask1Meta,
"task2": testTask2Meta,
- })
+ }, metaDB.tasks)
// delete task meta
- c.Assert(deleteTaskMeta(db, "task1"), check.IsNil)
+ require.NoError(t, deleteTaskMeta(db, "task1"))
// load task meta
metaDB, err = newMeta(db)
- c.Assert(err, check.IsNil)
- c.Assert(metaDB.tasks, check.DeepEquals, map[string]*pb.V1SubTaskMeta{
+ require.NoError(t, err)
+ require.Equal(t, map[string]*pb.V1SubTaskMeta{
"task2": testTask2Meta,
- })
+ }, metaDB.tasks)
// delete task meta
- c.Assert(deleteTaskMeta(db, "task2"), check.IsNil)
+ require.NoError(t, deleteTaskMeta(db, "task2"))
// load task meta
metaDB, err = newMeta(db)
- c.Assert(err, check.IsNil)
- c.Assert(metaDB.tasks, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, metaDB.tasks, 0)
}
diff --git a/dm/relay/file_test.go b/dm/relay/file_test.go
index c5901be437..6a8be5a8c2 100644
--- a/dm/relay/file_test.go
+++ b/dm/relay/file_test.go
@@ -16,18 +16,15 @@ package relay
import (
"os"
"path/filepath"
+ "testing"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testFileSuite{})
-
-type testFileSuite struct{}
-
-func (t *testFileSuite) TestCollectBinlogFiles(c *check.C) {
+func TestCollectBinlogFiles(t *testing.T) {
var (
valid = []string{
"mysql-bin.000001",
@@ -46,70 +43,70 @@ func (t *testFileSuite) TestCollectBinlogFiles(c *check.C) {
)
files, err := CollectAllBinlogFiles("")
- c.Assert(err, check.NotNil)
- c.Assert(files, check.IsNil)
+ require.Error(t, err)
+ require.Nil(t, files)
- dir := c.MkDir()
+ dir := t.TempDir()
// create all valid binlog files
for _, fn := range valid {
err = os.WriteFile(filepath.Join(dir, fn), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
files, err = CollectAllBinlogFiles(dir)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid)
+ require.NoError(t, err)
+ require.Equal(t, valid, files)
// create some invalid binlog files
for _, fn := range invalid {
err = os.WriteFile(filepath.Join(dir, fn), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
files, err = CollectAllBinlogFiles(dir)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid)
+ require.NoError(t, err)
+ require.Equal(t, valid, files)
// create some invalid meta files
for _, fn := range meta {
err = os.WriteFile(filepath.Join(dir, fn), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
files, err = CollectAllBinlogFiles(dir)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid)
+ require.NoError(t, err)
+ require.Equal(t, valid, files)
// collect newer files, none
files, err = CollectBinlogFilesCmp(dir, valid[len(valid)-1], FileCmpBigger)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, []string{}, files)
// collect newer files, some
files, err = CollectBinlogFilesCmp(dir, valid[0], FileCmpBigger)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid[1:])
+ require.NoError(t, err)
+ require.Equal(t, valid[1:], files)
// collect newer or equal files, all
files, err = CollectBinlogFilesCmp(dir, valid[0], FileCmpBiggerEqual)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid)
+ require.NoError(t, err)
+ require.Equal(t, valid, files)
// collect newer or equal files, some
files, err = CollectBinlogFilesCmp(dir, valid[1], FileCmpBiggerEqual)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid[1:])
+ require.NoError(t, err)
+ require.Equal(t, valid[1:], files)
// collect older files, none
files, err = CollectBinlogFilesCmp(dir, valid[0], FileCmpLess)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, []string{})
+ require.NoError(t, err)
+ require.Equal(t, []string{}, files)
// collect older files, some
files, err = CollectBinlogFilesCmp(dir, valid[len(valid)-1], FileCmpLess)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, valid[:len(valid)-1])
+ require.NoError(t, err)
+ require.Equal(t, valid[:len(valid)-1], files)
}
-func (t *testFileSuite) TestCollectBinlogFilesCmp(c *check.C) {
+func TestCollectBinlogFilesCmp(t *testing.T) {
var (
dir string
baseFile string
@@ -124,36 +121,37 @@ func (t *testFileSuite) TestCollectBinlogFilesCmp(c *check.C) {
// empty dir
files, err := CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(terror.ErrEmptyRelayDir.Equal(err), check.IsTrue)
- c.Assert(files, check.IsNil)
+ require.True(t, terror.ErrEmptyRelayDir.Equal(err))
+ require.Nil(t, files)
// empty base filename, not found
- dir = c.MkDir()
+ dir = t.TempDir()
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(errors.IsNotFound(err), check.IsTrue)
- c.Assert(files, check.IsNil)
+ require.True(t, errors.IsNotFound(err))
+ require.Nil(t, files)
// base file not found
baseFile = utils.MetaFilename
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(errors.IsNotFound(err), check.IsTrue)
- c.Assert(files, check.IsNil)
+ require.True(t, errors.IsNotFound(err))
+ require.Nil(t, files)
// create a meta file
filename := filepath.Join(dir, utils.MetaFilename)
err = os.WriteFile(filename, nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// invalid base filename, is a meta filename
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.ErrorMatches, ".*invalid binlog filename.*")
- c.Assert(files, check.IsNil)
+ require.Error(t, err)
+ require.Regexp(t, ".*invalid binlog filename.*", err.Error())
+ require.Nil(t, files)
// create some binlog files
for _, f := range binlogFiles {
filename = filepath.Join(dir, f)
err = os.WriteFile(filename, nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
// > base file
@@ -161,128 +159,133 @@ func (t *testFileSuite) TestCollectBinlogFilesCmp(c *check.C) {
var i int
for i, baseFile = range binlogFiles {
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, binlogFiles[i+1:])
+ require.NoError(t, err)
+ require.Equal(t, binlogFiles[i+1:], files)
}
// >= base file
cmp = FileCmpBiggerEqual
for i, baseFile = range binlogFiles {
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, binlogFiles[i:])
+ require.NoError(t, err)
+ require.Equal(t, binlogFiles[i:], files)
}
// < base file
cmp = FileCmpLess
for i, baseFile = range binlogFiles {
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, binlogFiles[:i])
+ require.NoError(t, err)
+ require.Equal(t, binlogFiles[:i], files)
}
// add a basename mismatch binlog file
filename = filepath.Join(dir, "bin-mysql.100000")
err = os.WriteFile(filename, nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// test again, should ignore it
for i, baseFile = range binlogFiles {
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, binlogFiles[:i])
+ require.NoError(t, err)
+ require.Equal(t, binlogFiles[:i], files)
}
// other cmp not supported yet
cmps := []FileCmp{FileCmpLessEqual, FileCmpEqual}
for _, cmp = range cmps {
files, err = CollectBinlogFilesCmp(dir, baseFile, cmp)
- c.Assert(err, check.ErrorMatches, ".*not supported.*")
- c.Assert(files, check.IsNil)
+ require.Error(t, err)
+ require.Regexp(t, ".*not supported.*", err.Error())
+ require.Nil(t, files)
}
}
-func (t *testFileSuite) TestGetFirstBinlogName(c *check.C) {
+func TestGetFirstBinlogName(t *testing.T) {
var (
- baseDir = c.MkDir()
+ baseDir = t.TempDir()
uuid = "b60868af-5a6f-11e9-9ea3-0242ac160006.000001"
subDir = filepath.Join(baseDir, uuid)
)
// sub directory not exist
name, err := getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.ErrorMatches, ".*(no such file or directory|The system cannot find the file specified).*")
- c.Assert(name, check.Equals, "")
+ require.Error(t, err)
+ require.Regexp(t, ".*(no such file or directory|The system cannot find the file specified).*", err.Error())
+ require.Equal(t, "", name)
// empty directory
err = os.MkdirAll(subDir, 0o700)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
name, err = getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.ErrorMatches, ".*not found.*")
- c.Assert(name, check.Equals, "")
+ require.Error(t, err)
+ require.Regexp(t, ".*not found.*", err.Error())
+ require.Equal(t, "", name)
// has file, but not a valid binlog file. Now the error message is binlog files not found
filename := "invalid.bin"
err = os.WriteFile(filepath.Join(subDir, filename), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.ErrorMatches, ".*not found.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*not found.*", err.Error())
err = os.Remove(filepath.Join(subDir, filename))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// has a valid binlog file
filename = "z-mysql-bin.000002" // z prefix, make it become not the _first_ if possible.
err = os.WriteFile(filepath.Join(subDir, filename), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
name, err = getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.IsNil)
- c.Assert(name, check.Equals, filename)
+ require.NoError(t, err)
+ require.Equal(t, filename, name)
// has one more earlier binlog file
filename = "z-mysql-bin.000001"
err = os.WriteFile(filepath.Join(subDir, filename), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
name, err = getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.IsNil)
- c.Assert(name, check.Equals, filename)
+ require.NoError(t, err)
+ require.Equal(t, filename, name)
// has a meta file
err = os.WriteFile(filepath.Join(subDir, utils.MetaFilename), nil, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
name, err = getFirstBinlogName(baseDir, uuid)
- c.Assert(err, check.IsNil)
- c.Assert(name, check.Equals, filename)
+ require.NoError(t, err)
+ require.Equal(t, filename, name)
}
-func (t *testFileSuite) TestFileSizeUpdated(c *check.C) {
+func TestFileSizeUpdated(t *testing.T) {
var (
filename = "mysql-bin.000001"
- filePath = filepath.Join(c.MkDir(), filename)
+ filePath = filepath.Join(t.TempDir(), filename)
data = []byte("meaningless file content")
latestSize = int64(len(data))
)
// file not exists
cmp, err := fileSizeUpdated(filePath, latestSize)
- c.Assert(err, check.ErrorMatches, ".*(no such file or directory|The system cannot find the file specified).*")
- c.Assert(cmp, check.Equals, 0)
+ require.Error(t, err)
+ require.Regexp(t, ".*(no such file or directory|The system cannot find the file specified).*", err.Error())
+ require.Equal(t, 0, cmp)
// create and write the file
err = os.WriteFile(filePath, data, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// equal
cmp, err = fileSizeUpdated(filePath, latestSize)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 0)
+ require.NoError(t, err)
+ require.Equal(t, 0, cmp)
// less than
cmp, err = fileSizeUpdated(filePath, latestSize+1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, -1)
+ require.NoError(t, err)
+ require.Equal(t, -1, cmp)
// greater than
cmp, err = fileSizeUpdated(filePath, latestSize-1)
- c.Assert(err, check.IsNil)
- c.Assert(cmp, check.Equals, 1)
+ require.NoError(t, err)
+ require.Equal(t, 1, cmp)
}
diff --git a/dm/relay/file_util_test.go b/dm/relay/file_util_test.go
index 46a4ca301d..1d5c57aa55 100644
--- a/dm/relay/file_util_test.go
+++ b/dm/relay/file_util_test.go
@@ -19,68 +19,68 @@ import (
"io"
"os"
"path/filepath"
+ "testing"
"time"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
"github.com/go-mysql-org/go-mysql/replication"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tiflow/dm/pkg/binlog/event"
"github.com/pingcap/tiflow/dm/pkg/gtid"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testFileUtilSuite{})
-
-type testFileUtilSuite struct{}
-
-func (t *testFileUtilSuite) TestCheckBinlogHeaderExist(c *check.C) {
+func TestCheckBinlogHeaderExist(t *testing.T) {
// file not exists
- filename := filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename := filepath.Join(t.TempDir(), "test-mysql-bin.000001")
exist, err := checkBinlogHeaderExist(filename)
- c.Assert(err, check.ErrorMatches, ".*(no such file or directory|The system cannot find the file specified).*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*(no such file or directory|The system cannot find the file specified).*", err.Error())
+ require.False(t, exist)
// empty file
err = os.WriteFile(filename, nil, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkBinlogHeaderExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, exist)
// no enough data
err = os.WriteFile(filename, replication.BinLogFileHeader[:len(replication.BinLogFileHeader)-1], 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkBinlogHeaderExist(filename)
- c.Assert(err, check.ErrorMatches, ".*has no enough data.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*has no enough data.*", err.Error())
+ require.False(t, exist)
// equal
err = os.WriteFile(filename, replication.BinLogFileHeader, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkBinlogHeaderExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, exist)
// more data
err = os.WriteFile(filename, bytes.Repeat(replication.BinLogFileHeader, 2), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkBinlogHeaderExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, exist)
// invalid data
invalidData := make([]byte, len(replication.BinLogFileHeader))
copy(invalidData, replication.BinLogFileHeader)
invalidData[0]++
err = os.WriteFile(filename, invalidData, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkBinlogHeaderExist(filename)
- c.Assert(err, check.ErrorMatches, ".*header not valid.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*header not valid.*", err.Error())
+ require.False(t, exist)
}
-func (t *testFileUtilSuite) TestCheckFormatDescriptionEventExist(c *check.C) {
+func TestCheckFormatDescriptionEventExist(t *testing.T) {
var (
header = &replication.EventHeader{
Timestamp: uint32(time.Now().Unix()),
@@ -90,57 +90,61 @@ func (t *testFileUtilSuite) TestCheckFormatDescriptionEventExist(c *check.C) {
latestPos uint32 = 4
)
formatDescEv, err := event.GenFormatDescriptionEvent(header, latestPos)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// file not exists
- filename := filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename := filepath.Join(t.TempDir(), "test-mysql-bin.000001")
exist, err := checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.ErrorMatches, ".*(no such file or directory|The system cannot find the file specified).*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*(no such file or directory|The system cannot find the file specified).*", err.Error())
+ require.False(t, exist)
// empty file
err = os.WriteFile(filename, nil, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.ErrorMatches, ".*no binlog file header at the beginning.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*no binlog file header at the beginning.*", err.Error())
+ require.False(t, exist)
// only file header
err = os.WriteFile(filename, replication.BinLogFileHeader, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, exist)
// no enough data, < EventHeaderSize
var buff bytes.Buffer
buff.Write(replication.BinLogFileHeader)
buff.Write(formatDescEv.RawData[:replication.EventHeaderSize-1])
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(errors.Cause(err), check.Equals, io.EOF)
- c.Assert(exist, check.IsFalse)
+ require.Equal(t, io.EOF, errors.Cause(err))
+ require.False(t, exist)
// no enough data, = EventHeaderSize
buff.Reset()
buff.Write(replication.BinLogFileHeader)
buff.Write(formatDescEv.RawData[:replication.EventHeaderSize])
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.ErrorMatches, ".*get event err EOF.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*get event err EOF.*", err.Error())
+ require.False(t, exist)
// no enough data, > EventHeaderSize, < EventSize
buff.Reset()
buff.Write(replication.BinLogFileHeader)
buff.Write(formatDescEv.RawData[:replication.EventHeaderSize+1])
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.ErrorMatches, ".*get event err EOF.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*get event err EOF.*", err.Error())
+ require.False(t, exist)
// exactly the event
buff.Reset()
@@ -149,33 +153,34 @@ func (t *testFileUtilSuite) TestCheckFormatDescriptionEventExist(c *check.C) {
dataCopy := make([]byte, buff.Len())
copy(dataCopy, buff.Bytes())
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, exist)
// more than the event
buff.Write([]byte("more data"))
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.IsNil)
- c.Assert(exist, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, exist)
// other event type
queryEv, err := event.GenQueryEvent(header, latestPos, 0, 0, 0, nil, []byte("schema"), []byte("BEGIN"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
buff.Reset()
buff.Write(replication.BinLogFileHeader)
buff.Write(queryEv.RawData)
err = os.WriteFile(filename, buff.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
exist, err = checkFormatDescriptionEventExist(filename)
- c.Assert(err, check.ErrorMatches, ".*expect FormatDescriptionEvent.*")
- c.Assert(exist, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*expect FormatDescriptionEvent.*", err.Error())
+ require.False(t, exist)
}
-func (t *testFileUtilSuite) TestCheckIsDuplicateEvent(c *check.C) {
+func TestCheckIsDuplicateEvent(t *testing.T) {
// use a binlog event generator to generate some binlog events.
var (
flavor = gmysql.MySQLFlavor
@@ -188,14 +193,14 @@ func (t *testFileUtilSuite) TestCheckIsDuplicateEvent(c *check.C) {
allData bytes.Buffer
)
previousGTIDSet, err := gtid.ParserGTID(flavor, previousGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID, err := gtid.ParserGTID(flavor, latestGTIDStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
g, err := event.NewGenerator(flavor, serverID, latestPos, latestGTID, previousGTIDSet, latestXID)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// file header with FormatDescriptionEvent and PreviousGTIDsEvent
events, data, err := g.GenFileHeader(0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
allEvents = append(allEvents, events...)
allData.Write(data)
// CREATE DATABASE/TABLE
@@ -206,28 +211,28 @@ func (t *testFileUtilSuite) TestCheckIsDuplicateEvent(c *check.C) {
}
for _, query := range queries {
events, data, err = g.GenDDLEvents("db", query, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
allEvents = append(allEvents, events...)
allData.Write(data)
}
// write the events to a file
- filename := filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename := filepath.Join(t.TempDir(), "test-mysql-bin.000001")
err = os.WriteFile(filename, allData.Bytes(), 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// all events in the file
for _, ev := range allEvents {
duplicate, err2 := checkIsDuplicateEvent(filename, ev)
- c.Assert(err2, check.IsNil)
- c.Assert(duplicate, check.IsTrue)
+ require.Nil(t, err2)
+ require.True(t, duplicate)
}
// event not in the file, because its start pos > file size
events, _, err = g.GenDDLEvents("", "BEGIN", 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
duplicate, err := checkIsDuplicateEvent(filename, events[0])
- c.Assert(err, check.IsNil)
- c.Assert(duplicate, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, duplicate)
// event not in the file, because event start pos < file size < event end pos, invalid
lastEvent := allEvents[len(allEvents)-1]
@@ -235,39 +240,43 @@ func (t *testFileUtilSuite) TestCheckIsDuplicateEvent(c *check.C) {
latestPos = lastEvent.Header.LogPos - lastEvent.Header.EventSize
eventSize := lastEvent.Header.EventSize + 1 // greater event size
dummyEv, err := event.GenDummyEvent(&header, latestPos, eventSize)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
duplicate, err = checkIsDuplicateEvent(filename, dummyEv)
- c.Assert(err, check.ErrorMatches, ".*file size.*is between event's start pos.*")
- c.Assert(duplicate, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*file size.*is between event's start pos.*", err.Error())
+ require.False(t, duplicate)
// event's start pos not match any event in the file, invalid
latestPos = lastEvent.Header.LogPos - lastEvent.Header.EventSize - 1 // start pos mismatch
eventSize = lastEvent.Header.EventSize
dummyEv, err = event.GenDummyEvent(&header, latestPos, eventSize)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
duplicate, err = checkIsDuplicateEvent(filename, dummyEv)
- c.Assert(err, check.ErrorMatches, "*diff from passed-in event.*")
- c.Assert(duplicate, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*diff from passed-in event.*", err.Error())
+ require.False(t, duplicate)
// event's start/end pos matched, but content mismatched, invalid
latestPos = lastEvent.Header.LogPos - lastEvent.Header.EventSize
eventSize = lastEvent.Header.EventSize
dummyEv, err = event.GenDummyEvent(&header, latestPos, eventSize)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
duplicate, err = checkIsDuplicateEvent(filename, dummyEv)
- c.Assert(err, check.ErrorMatches, ".*diff from passed-in event.*")
- c.Assert(duplicate, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*diff from passed-in event.*", err.Error())
+ require.False(t, duplicate)
// file not exists, invalid
filename += ".no-exist"
duplicate, err = checkIsDuplicateEvent(filename, lastEvent)
- c.Assert(err, check.ErrorMatches, ".*get stat for.*")
- c.Assert(duplicate, check.IsFalse)
+ require.Error(t, err)
+ require.Regexp(t, ".*get stat for.*", err.Error())
+ require.False(t, duplicate)
}
-func (t *testFileUtilSuite) TestGetTxnPosGTIDsMySQL(c *check.C) {
+func TestGetTxnPosGTIDsMySQL(t *testing.T) {
var (
- filename = filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename = filepath.Join(t.TempDir(), "test-mysql-bin.000001")
flavor = gmysql.MySQLFlavor
previousGTIDSetStr = "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-14,53bfca22-690d-11e7-8a62-18ded7a37b78:1-495,406a3f61-690d-11e7-87c5-6c92bf46f384:123-456,686e1ab6-c47e-11e7-a42c-6c92bf46f384:234-567"
latestGTIDStr1 = "3ccc475b-2343-11e7-be21-6c0b84d59f30:14"
@@ -278,12 +287,12 @@ func (t *testFileUtilSuite) TestGetTxnPosGTIDsMySQL(c *check.C) {
expectedGTIDsStr2 = "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-18,53bfca22-690d-11e7-8a62-18ded7a37b78:1-506,406a3f61-690d-11e7-87c5-6c92bf46f384:123-456,686e1ab6-c47e-11e7-a42c-6c92bf46f384:234-567"
)
- t.testGetTxnPosGTIDs(c, filename, flavor, previousGTIDSetStr, latestGTIDStr1, latestGTIDStr2, expectedGTIDsStr1, expectedGTIDsStr2)
+ testGetTxnPosGTIDs(t, filename, flavor, previousGTIDSetStr, latestGTIDStr1, latestGTIDStr2, expectedGTIDsStr1, expectedGTIDsStr2)
}
-func (t *testFileUtilSuite) TestGetTxnPosGTIDMariaDB(c *check.C) {
+func TestGetTxnPosGTIDMariaDB(t *testing.T) {
var (
- filename = filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename = filepath.Join(t.TempDir(), "test-mysql-bin.000001")
flavor = gmysql.MariaDBFlavor
previousGTIDSetStr = "1-11-1,2-11-2"
latestGTIDStr1 = "1-11-1"
@@ -294,38 +303,38 @@ func (t *testFileUtilSuite) TestGetTxnPosGTIDMariaDB(c *check.C) {
expectedGTIDsStr2 = "1-11-5,2-11-13"
)
- t.testGetTxnPosGTIDs(c, filename, flavor, previousGTIDSetStr, latestGTIDStr1, latestGTIDStr2, expectedGTIDsStr1, expectedGTIDsStr2)
+ testGetTxnPosGTIDs(t, filename, flavor, previousGTIDSetStr, latestGTIDStr1, latestGTIDStr2, expectedGTIDsStr1, expectedGTIDsStr2)
}
-func (t *testFileUtilSuite) testGetTxnPosGTIDs(c *check.C, filename, flavor, previousGTIDSetStr,
+func testGetTxnPosGTIDs(t *testing.T, filename, flavor, previousGTIDSetStr,
latestGTIDStr1, latestGTIDStr2, expectedGTIDsStr1, expectedGTIDsStr2 string,
) {
parser2 := parser.New()
// different SIDs in GTID set
previousGTIDSet, err := gtid.ParserGTID(flavor, previousGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID1, err := gtid.ParserGTID(flavor, latestGTIDStr1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID2, err := gtid.ParserGTID(flavor, latestGTIDStr2)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
- g, _, baseData := genBinlogEventsWithGTIDs(c, flavor, previousGTIDSet, latestGTID1, latestGTID2)
+ g, _, baseData := genBinlogEventsWithGTIDs(t, flavor, previousGTIDSet, latestGTID1, latestGTID2)
// expected latest pos/GTID set
expectedPos := int64(len(baseData))
expectedGTIDs, err := gtid.ParserGTID(flavor, expectedGTIDsStr1) // 3 DDL + 10 DML
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// write the events to a file
err = os.WriteFile(filename, baseData, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// not extra data exists
pos, gSet, err := getTxnPosGTIDs(context.Background(), filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.DeepEquals, expectedPos)
- c.Assert(gSet, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.Equal(t, expectedPos, pos)
+ require.Equal(t, expectedGTIDs, gSet)
// generate another transaction, DML
var (
@@ -347,62 +356,62 @@ func (t *testFileUtilSuite) testGetTxnPosGTIDs(c *check.C, filename, flavor, pre
},
}
extraEvents, extraData, err := g.GenDMLEvents(eventType, dmlData, 0)
- c.Assert(err, check.IsNil)
- c.Assert(extraEvents, check.HasLen, 5) // [GTID, BEGIN, TableMap, UPDATE, XID]
+ require.NoError(t, err)
+ require.Len(t, extraEvents, 5) // [GTID, BEGIN, TableMap, UPDATE, XID]
// write an incomplete event to the file
corruptData := extraEvents[0].RawData[:len(extraEvents[0].RawData)-2]
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(corruptData)
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check again
pos, gSet, err = getTxnPosGTIDs(context.Background(), filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.DeepEquals, expectedPos)
- c.Assert(gSet, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.Equal(t, expectedPos, pos)
+ require.Equal(t, expectedGTIDs, gSet)
// truncate extra data
f, err = os.OpenFile(filename, os.O_WRONLY, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = f.Truncate(expectedPos)
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// write an incomplete transaction with some completed events
for i := 0; i < len(extraEvents)-1; i++ {
f, err = os.OpenFile(filename, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(extraEvents[i].RawData) // write the event
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check again
pos, gSet, err = getTxnPosGTIDs(context.Background(), filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.DeepEquals, expectedPos)
- c.Assert(gSet, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.Equal(t, expectedPos, pos)
+ require.Equal(t, expectedGTIDs, gSet)
}
// write a completed event (and a completed transaction) to the file
f, err = os.OpenFile(filename, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(extraEvents[len(extraEvents)-1].RawData) // write the event
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check again
expectedPos += int64(len(extraData))
expectedGTIDs, err = gtid.ParserGTID(flavor, expectedGTIDsStr2) // 3 DDL + 11 DML
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
pos, gSet, err = getTxnPosGTIDs(context.Background(), filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.DeepEquals, expectedPos)
- c.Assert(gSet, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.Equal(t, expectedPos, pos)
+ require.Equal(t, expectedGTIDs, gSet)
}
-func (t *testFileUtilSuite) TestGetTxnPosGTIDsNoGTID(c *check.C) {
+func TestGetTxnPosGTIDsNoGTID(t *testing.T) {
// generate some events but without GTID enabled
var (
header = &replication.EventHeader{
@@ -410,38 +419,38 @@ func (t *testFileUtilSuite) TestGetTxnPosGTIDsNoGTID(c *check.C) {
ServerID: 11,
}
latestPos uint32 = 4
- filename = filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename = filepath.Join(t.TempDir(), "test-mysql-bin.000001")
)
// FormatDescriptionEvent
formatDescEv, err := event.GenFormatDescriptionEvent(header, latestPos)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestPos = formatDescEv.Header.LogPos
// QueryEvent, DDL
queryEv, err := event.GenQueryEvent(header, latestPos, 0, 0, 0, nil, []byte("db"), []byte("CREATE DATABASE db"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestPos = queryEv.Header.LogPos
// write events to the file
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(formatDescEv.RawData)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(queryEv.RawData)
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check latest pos/GTID set
pos, gSet, err := getTxnPosGTIDs(context.Background(), filename, parser.New())
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.Equals, int64(latestPos))
- c.Assert(gSet, check.IsNil) // GTID not enabled
+ require.NoError(t, err)
+ require.Equal(t, int64(latestPos), pos)
+ require.Nil(t, gSet) // GTID not enabled
}
-func (t *testFileUtilSuite) TestGetTxnPosGTIDsIllegalGTIDMySQL(c *check.C) {
+func TestGetTxnPosGTIDsIllegalGTIDMySQL(t *testing.T) {
// generate some events with GTID enabled, but without PreviousGTIDEvent
var (
header = &replication.EventHeader{
@@ -453,12 +462,12 @@ func (t *testFileUtilSuite) TestGetTxnPosGTIDsIllegalGTIDMySQL(c *check.C) {
// GTID event
gtidEv, err := event.GenGTIDEvent(header, latestPos, 0, "3ccc475b-2343-11e7-be21-6c0b84d59f30", 14, 10, 10)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
- t.testGetTxnPosGTIDsIllegalGTID(c, gtidEv, ".*should have a PreviousGTIDsEvent before the GTIDEvent.*")
+ testGetTxnPosGTIDsIllegalGTID(t, gtidEv, ".*should have a PreviousGTIDsEvent before the GTIDEvent.*")
}
-func (t *testFileUtilSuite) TestGetTxnPosGTIDsIllegalGTIDMairaDB(c *check.C) {
+func TestGetTxnPosGTIDsIllegalGTIDMairaDB(t *testing.T) {
// generate some events with GTID enabled, but without MariaDBGTIDEvent
var (
header = &replication.EventHeader{
@@ -470,44 +479,45 @@ func (t *testFileUtilSuite) TestGetTxnPosGTIDsIllegalGTIDMairaDB(c *check.C) {
// GTID event
mariaDBGTIDEv, err := event.GenMariaDBGTIDEvent(header, latestPos, 10, 10)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
- t.testGetTxnPosGTIDsIllegalGTID(c, mariaDBGTIDEv, ".*should have a MariadbGTIDListEvent before the MariadbGTIDEvent.*")
+ testGetTxnPosGTIDsIllegalGTID(t, mariaDBGTIDEv, ".*should have a MariadbGTIDListEvent before the MariadbGTIDEvent.*")
}
-func (t *testFileUtilSuite) testGetTxnPosGTIDsIllegalGTID(c *check.C, gtidEv *replication.BinlogEvent, errRegStr string) {
+func testGetTxnPosGTIDsIllegalGTID(t *testing.T, gtidEv *replication.BinlogEvent, errRegStr string) {
var (
header = &replication.EventHeader{
Timestamp: uint32(time.Now().Unix()),
ServerID: 11,
}
latestPos uint32 = 4
- filename = filepath.Join(c.MkDir(), "test-mysql-bin.000001")
+ filename = filepath.Join(t.TempDir(), "test-mysql-bin.000001")
)
// FormatDescriptionEvent
formatDescEv, err := event.GenFormatDescriptionEvent(header, latestPos)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// write events to the file
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(formatDescEv.RawData)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(gtidEv.RawData)
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check latest pos/GTID set
pos, gSet, err := getTxnPosGTIDs(context.Background(), filename, parser.New())
- c.Assert(err, check.ErrorMatches, errRegStr)
- c.Assert(pos, check.Equals, int64(0))
- c.Assert(gSet, check.IsNil)
+ require.Error(t, err)
+ require.Regexp(t, errRegStr, err.Error())
+ require.Equal(t, int64(0), pos)
+ require.Nil(t, gSet)
}
-func (t *testFileUtilSuite) TestDontTruncateOnlyHeader(c *check.C) {
+func TestDontTruncateOnlyHeader(t *testing.T) {
var (
header = &replication.EventHeader{
Timestamp: uint32(time.Now().Unix()),
@@ -519,35 +529,35 @@ func (t *testFileUtilSuite) TestDontTruncateOnlyHeader(c *check.C) {
)
formatDescEv, err := event.GenFormatDescriptionEvent(header, uint32(latestPos))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestPos += len(formatDescEv.RawData)
mysqlGTIDev, _ := event.GenPreviousGTIDsEvent(header, uint32(latestPos), previousGSetMySQL)
mariaDBGTIDev, _ := event.GenMariaDBGTIDListEvent(header, uint32(latestPos), previousGSetMariaDB)
- t.testDontTruncate(c, []*replication.BinlogEvent{formatDescEv, mysqlGTIDev})
- t.testDontTruncate(c, []*replication.BinlogEvent{formatDescEv, mariaDBGTIDev})
+ testDontTruncate(t, []*replication.BinlogEvent{formatDescEv, mysqlGTIDev})
+ testDontTruncate(t, []*replication.BinlogEvent{formatDescEv, mariaDBGTIDev})
}
-func (t *testFileUtilSuite) testDontTruncate(c *check.C, events []*replication.BinlogEvent) {
+func testDontTruncate(t *testing.T, events []*replication.BinlogEvent) {
var (
- filename = filepath.Join(c.MkDir(), "dont-truncate.000001")
+ filename = filepath.Join(t.TempDir(), "dont-truncate.000001")
parser2 = parser.New()
)
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, ev := range events {
_, err = f.Write(ev.RawData)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
stat, _ := f.Stat()
pos, _, err := getTxnPosGTIDs(context.Background(), filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(pos, check.Equals, stat.Size())
+ require.NoError(t, err)
+ require.Equal(t, stat.Size(), pos)
}
}
diff --git a/dm/relay/local_reader_test.go b/dm/relay/local_reader_test.go
index addf7595fa..c72300db53 100644
--- a/dm/relay/local_reader_test.go
+++ b/dm/relay/local_reader_test.go
@@ -25,13 +25,13 @@ import (
"strconv"
"strings"
"sync"
+ "testing"
"time"
"github.com/BurntSushi/toml"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
"github.com/go-mysql-org/go-mysql/replication"
"github.com/google/uuid"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/pkg/binlog/event"
@@ -40,27 +40,32 @@ import (
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
)
var parseFileTimeout = 10 * time.Second
-var _ = check.Suite(&testReaderSuite{})
+func TestReaderSuite(t *testing.T) {
+ suite.Run(t, new(testReaderSuite))
+}
type testReaderSuite struct {
+ suite.Suite
lastPos uint32
lastGTID gmysql.GTIDSet
}
-func (t *testReaderSuite) SetUpSuite(c *check.C) {
+func (t *testReaderSuite) SetupSuite() {
var err error
t.lastPos = 0
t.lastGTID, err = gtid.ParserGTID(gmysql.MySQLFlavor, "ba8f633f-1f15-11eb-b1c7-0242ac110002:1")
- c.Assert(err, check.IsNil)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(10000)"), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(10000)"))
}
-func (t *testReaderSuite) TearDownSuite(c *check.C) {
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"), check.IsNil)
+func (t *testReaderSuite) TearDownSuite() {
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"))
}
func newBinlogReaderForTest(logger log.Logger, cfg *BinlogReaderConfig, notify bool, uuid string) *BinlogReader {
@@ -81,10 +86,10 @@ func (t *testReaderSuite) setActiveRelayLog(r Process, uuid, filename string, of
writer.out.offset.Store(offset)
}
-func (t *testReaderSuite) createBinlogFileParseState(c *check.C, relayLogDir, relayLogFile string, offset int64, possibleLast bool) *binlogFileParseState {
+func (t *testReaderSuite) createBinlogFileParseState(relayLogDir, relayLogFile string, offset int64, possibleLast bool) *binlogFileParseState {
fullPath := filepath.Join(relayLogDir, relayLogFile)
f, err := os.Open(fullPath)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
return &binlogFileParseState{
possibleLast: possibleLast,
@@ -97,9 +102,9 @@ func (t *testReaderSuite) createBinlogFileParseState(c *check.C, relayLogDir, re
}
}
-func (t *testReaderSuite) TestparseFileAsPossibleFileNotExist(c *check.C) {
+func (t *testReaderSuite) TestparseFileAsPossibleFileNotExist() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
currentUUID = "b60868af-5a6f-11e9-9ea3-0242ac160006.000001"
filename = "test-mysql-bin.000001"
relayDir = path.Join(baseDir, currentUUID)
@@ -107,17 +112,18 @@ func (t *testReaderSuite) TestparseFileAsPossibleFileNotExist(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
needSwitch, lastestPos, err := r.parseFileAsPossible(context.Background(), nil, filename, 4, relayDir, true, false)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(lastestPos, check.Equals, int64(0))
- c.Assert(err, check.ErrorMatches, ".*no such file or directory.*")
+ t.Require().False(needSwitch)
+ t.Require().Equal(int64(0), lastestPos)
+ t.Require().Error(err)
+ t.Require().Regexp(".*no such file or directory.*", err.Error())
}
-func (t *testReaderSuite) TestParseFileBase(c *check.C) {
+func (t *testReaderSuite) TestParseFileBase() {
var (
filename = "test-mysql-bin.000001"
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
possibleLast = false
- baseEvents, _, _ = t.genBinlogEvents(c, t.lastPos, t.lastGTID)
+ baseEvents, _, _ = t.genBinlogEvents(t.lastPos, t.lastGTID)
s = newLocalStreamer()
)
ctx, cancel := context.WithCancel(context.Background())
@@ -128,9 +134,9 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
relayDir := filepath.Join(baseDir, currentUUID)
fullPath := filepath.Join(relayDir, filename)
err1 := os.MkdirAll(relayDir, 0o700)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
f, err1 := os.OpenFile(fullPath, os.O_CREATE|os.O_WRONLY, 0o600)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
defer f.Close()
// empty relay log file, got EOF when reading format description event separately and possibleLast = false
@@ -140,26 +146,26 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
t.setActiveRelayLog(r.relay, currentUUID, filename, 0)
- state := t.createBinlogFileParseState(c, relayDir, filename, 100, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, 100, possibleLast)
needSwitch, needReParse, err := r.parseFile(testCtx, s, true, state)
- c.Assert(errors.Cause(err), check.Equals, io.EOF)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(100))
- c.Assert(state.formatDescEventRead, check.IsFalse)
- c.Assert(state.skipGTID, check.Equals, false)
+ t.Require().Equal(io.EOF, errors.Cause(err))
+ t.Require().False(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(100), state.latestPos)
+ t.Require().False(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
}
// write some events to binlog file
_, err1 = f.Write(replication.BinLogFileHeader)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
for _, ev := range baseEvents {
_, err1 = f.Write(ev.RawData)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
}
fileSize, _ := f.Seek(0, io.SeekCurrent)
- t.purgeStreamer(c, s)
+ t.purgeStreamer(s)
// base test with only one valid binlog file
{
@@ -168,35 +174,35 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
t.setActiveRelayLog(r.relay, currentUUID, filename, fileSize)
- state := t.createBinlogFileParseState(c, relayDir, filename, 4, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, 4, possibleLast)
needSwitch, needReParse, err := r.parseFile(testCtx, s, true, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(baseEvents[len(baseEvents)-1].Header.LogPos))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().False(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(baseEvents[len(baseEvents)-1].Header.LogPos), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().False(state.skipGTID)
// try get events back, firstParse should have fake RotateEvent
var fakeRotateEventCount int
i := 0
for {
ev, err2 := s.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
if ev.Header.Timestamp == 0 || ev.Header.LogPos == 0 {
if ev.Header.EventType == replication.ROTATE_EVENT {
fakeRotateEventCount++
}
continue // ignore fake event
}
- c.Assert(ev, check.DeepEquals, baseEvents[i])
+ t.Require().Equal(baseEvents[i], ev)
i++
if i >= len(baseEvents) {
break
}
}
- c.Assert(fakeRotateEventCount, check.Equals, 1)
- t.verifyNoEventsInStreamer(c, s)
+ t.Require().Equal(1, fakeRotateEventCount)
+ t.verifyNoEventsInStreamer(s)
}
// try get events back, since firstParse=false, should have no fake RotateEvent
@@ -206,40 +212,40 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
t.setActiveRelayLog(r.relay, currentUUID, filename, fileSize)
- state := t.createBinlogFileParseState(c, relayDir, filename, 4, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, 4, possibleLast)
needSwitch, needReParse, err := r.parseFile(testCtx, s, false, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(baseEvents[len(baseEvents)-1].Header.LogPos))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.Equals, false)
+ t.Require().NoError(err)
+ t.Require().False(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(baseEvents[len(baseEvents)-1].Header.LogPos), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
fakeRotateEventCount := 0
i := 0
for {
ev, err2 := s.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
if ev.Header.Timestamp == 0 || ev.Header.LogPos == 0 {
if ev.Header.EventType == replication.ROTATE_EVENT {
fakeRotateEventCount++
}
continue // ignore fake event
}
- c.Assert(ev, check.DeepEquals, baseEvents[i])
+ t.Require().Equal(baseEvents[i], ev)
i++
if i >= len(baseEvents) {
break
}
}
- c.Assert(fakeRotateEventCount, check.Equals, 0)
- t.verifyNoEventsInStreamer(c, s)
+ t.Require().Equal(0, fakeRotateEventCount)
+ t.verifyNoEventsInStreamer(s)
}
// generate another non-fake RotateEvent
rotateEv, err := event.GenRotateEvent(baseEvents[0].Header, uint32(fileSize), []byte("mysql-bin.888888"), 4)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = f.Write(rotateEv.RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
fileSize, _ = f.Seek(0, io.SeekCurrent)
// latest is still the end_log_pos of the last event, not the next relay file log file's position
@@ -249,15 +255,15 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
t.setActiveRelayLog(r.relay, currentUUID, filename, fileSize)
- state := t.createBinlogFileParseState(c, relayDir, filename, 4, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, 4, possibleLast)
needSwitch, needReParse, err := r.parseFile(testCtx, s, true, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(rotateEv.Header.LogPos))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.Equals, false)
- t.purgeStreamer(c, s)
+ t.Require().NoError(err)
+ t.Require().False(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(rotateEv.Header.LogPos), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
+ t.purgeStreamer(s)
}
// parse from offset > 4
@@ -268,41 +274,41 @@ func (t *testReaderSuite) TestParseFileBase(c *check.C) {
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
t.setActiveRelayLog(r.relay, currentUUID, filename, fileSize)
offset := int64(rotateEv.Header.LogPos - rotateEv.Header.EventSize)
- state := t.createBinlogFileParseState(c, relayDir, filename, offset, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, offset, possibleLast)
needSwitch, needReParse, err := r.parseFile(testCtx, s, false, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(rotateEv.Header.LogPos))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.Equals, false)
+ t.Require().NoError(err)
+ t.Require().False(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(rotateEv.Header.LogPos), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
// should only get a RotateEvent
i := 0
for {
ev, err2 := s.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
switch ev.Header.EventType {
case replication.ROTATE_EVENT:
- c.Assert(ev.RawData, check.DeepEquals, rotateEv.RawData)
+ t.Require().Equal(rotateEv.RawData, ev.RawData)
i++
default:
- c.Fatalf("got unexpected event %+v", ev.Header)
+ t.T().Fatalf("got unexpected event %+v", ev.Header)
}
if i >= 1 {
break
}
}
- t.verifyNoEventsInStreamer(c, s)
+ t.verifyNoEventsInStreamer(s)
}
}
-func (t *testReaderSuite) TestParseFileRelayNeedSwitchSubDir(c *check.C) {
+func (t *testReaderSuite) TestParseFileRelayNeedSwitchSubDir() {
var (
filename = "test-mysql-bin.000001"
nextFilename = "test-mysql-bin.666888"
notUsedGTIDSetStr = t.lastGTID.String()
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
offset int64
possibleLast = true
currentUUID = "b60868af-5a6f-11e9-9ea3-0242ac160006.000001"
@@ -318,49 +324,49 @@ func (t *testReaderSuite) TestParseFileRelayNeedSwitchSubDir(c *check.C) {
// create the current relay log file and meta
err := os.MkdirAll(relayDir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_WRONLY, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer f.Close()
_, err = f.Write(replication.BinLogFileHeader)
offset = 4
- c.Assert(err, check.IsNil)
- t.createMetaFile(c, relayDir, filename, uint32(offset), notUsedGTIDSetStr)
+ t.Require().NoError(err)
+ t.createMetaFile(relayDir, filename, uint32(offset), notUsedGTIDSetStr)
r.subDirs = []string{currentUUID, switchedUUID}
- t.writeUUIDs(c, baseDir, r.subDirs)
+ t.writeUUIDs(baseDir, r.subDirs)
err = os.MkdirAll(nextRelayDir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = os.WriteFile(nextFullPath, replication.BinLogFileHeader, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// has relay log file in next sub directory, need to switch
ctx2, cancel2 := context.WithTimeout(context.Background(), parseFileTimeout)
defer cancel2()
- t.createMetaFile(c, nextRelayDir, filename, uint32(offset), notUsedGTIDSetStr)
- state := t.createBinlogFileParseState(c, relayDir, filename, offset, possibleLast)
+ t.createMetaFile(nextRelayDir, filename, uint32(offset), notUsedGTIDSetStr)
+ state := t.createBinlogFileParseState(relayDir, filename, offset, possibleLast)
state.formatDescEventRead = true
t.setActiveRelayLog(r.relay, "next", "next", 4)
needSwitch, needReParse, err := r.parseFile(ctx2, s, true, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsTrue)
- c.Assert(needReParse, check.IsFalse)
- c.Assert(state.latestPos, check.Equals, int64(4))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.Equals, false)
- t.purgeStreamer(c, s)
+ t.Require().NoError(err)
+ t.Require().True(needSwitch)
+ t.Require().False(needReParse)
+ t.Require().Equal(int64(4), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
+ t.purgeStreamer(s)
// NOTE: if we want to test the returned `needReParse` of `needSwitchSubDir`,
// then we need to mock `fileSizeUpdated` or inject some delay or delay.
}
-func (t *testReaderSuite) TestParseFileRelayWithIgnorableError(c *check.C) {
+func (t *testReaderSuite) TestParseFileRelayWithIgnorableError() {
var (
filename = "test-mysql-bin.000001"
notUsedGTIDSetStr = t.lastGTID.String()
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
possibleLast = true
- baseEvents, _, _ = t.genBinlogEvents(c, t.lastPos, t.lastGTID)
+ baseEvents, _, _ = t.genBinlogEvents(t.lastPos, t.lastGTID)
currentUUID = "b60868af-5a6f-11e9-9ea3-0242ac160006.000001"
relayDir = filepath.Join(baseDir, currentUUID)
fullPath = filepath.Join(relayDir, filename)
@@ -370,66 +376,66 @@ func (t *testReaderSuite) TestParseFileRelayWithIgnorableError(c *check.C) {
// create the current relay log file and write some events
err := os.MkdirAll(relayDir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_WRONLY, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer f.Close()
- t.createMetaFile(c, relayDir, filename, 0, notUsedGTIDSetStr)
+ t.createMetaFile(relayDir, filename, 0, notUsedGTIDSetStr)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = f.Write(baseEvents[0].RawData[:replication.EventHeaderSize])
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// meet io.EOF error when read event and ignore it.
{
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
- state := t.createBinlogFileParseState(c, relayDir, filename, 4, possibleLast)
+ state := t.createBinlogFileParseState(relayDir, filename, 4, possibleLast)
state.formatDescEventRead = true
t.setActiveRelayLog(r.relay, currentUUID, filename, 100)
needSwitch, needReParse, err := r.parseFile(context.Background(), s, true, state)
- c.Assert(err, check.IsNil)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(needReParse, check.IsTrue)
- c.Assert(state.latestPos, check.Equals, int64(4))
- c.Assert(state.formatDescEventRead, check.IsTrue)
- c.Assert(state.skipGTID, check.Equals, false)
+ t.Require().NoError(err)
+ t.Require().False(needSwitch)
+ t.Require().True(needReParse)
+ t.Require().Equal(int64(4), state.latestPos)
+ t.Require().True(state.formatDescEventRead)
+ t.Require().Equal(false, state.skipGTID)
}
}
-func (t *testReaderSuite) TestUpdateUUIDs(c *check.C) {
+func (t *testReaderSuite) TestUpdateUUIDs() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
cfg = &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r = newBinlogReaderForTest(log.L(), cfg, true, "")
)
- c.Assert(r.subDirs, check.HasLen, 0)
+ t.Require().Len(r.subDirs, 0)
// index file not exists, got nothing
err := r.updateSubDirs()
- c.Assert(err, check.IsNil)
- c.Assert(r.subDirs, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(r.subDirs, 0)
// valid UUIDs in the index file, got them back
UUIDs := []string{
"b60868af-5a6f-11e9-9ea3-0242ac160006.000001",
"b60868af-5a6f-11e9-9ea3-0242ac160007.000002",
}
- uuidBytes := t.uuidListToBytes(c, UUIDs)
+ uuidBytes := t.uuidListToBytes(UUIDs)
err = os.WriteFile(r.indexPath, uuidBytes, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = r.updateSubDirs()
- c.Assert(err, check.IsNil)
- c.Assert(r.subDirs, check.DeepEquals, UUIDs)
+ t.Require().NoError(err)
+ t.Require().Equal(UUIDs, r.subDirs)
}
-func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
+func (t *testReaderSuite) TestStartSyncByPos() {
var (
filenamePrefix = "test-mysql-bin.00000"
notUsedGTIDSetStr = t.lastGTID.String()
- baseDir = c.MkDir()
- baseEvents, lastPos, lastGTID = t.genBinlogEvents(c, t.lastPos, t.lastGTID)
+ baseDir = t.T().TempDir()
+ baseEvents, lastPos, lastGTID = t.genBinlogEvents(t.lastPos, t.lastGTID)
eventsBuf bytes.Buffer
UUIDs = []string{
"b60868af-5a6f-11e9-9ea3-0242ac160006.000001",
@@ -443,22 +449,22 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
// prepare binlog data
_, err := eventsBuf.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
for _, ev := range baseEvents {
_, err = eventsBuf.Write(ev.RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
// create the index file
- uuidBytes := t.uuidListToBytes(c, UUIDs)
+ uuidBytes := t.uuidListToBytes(UUIDs)
err = os.WriteFile(r.indexPath, uuidBytes, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// create sub directories
for _, uuid := range UUIDs {
subDir := filepath.Join(baseDir, uuid)
err = os.MkdirAll(subDir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
// 1. generate relay log files
@@ -472,42 +478,42 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
// don't add rotate event for the last file because we'll append more events to it.
if !(i == 2 && j == i+1) {
rotateEvent, err2 := event.GenRotateEvent(baseEvents[0].Header, lastPos, []byte(filenamePrefix+strconv.Itoa(j+1)), 4)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
content = append(content, rotateEvent.RawData...)
}
err = os.WriteFile(filename, content, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
- t.createMetaFile(c, path.Join(baseDir, UUIDs[i]), filenamePrefix+strconv.Itoa(i+1),
+ t.createMetaFile(path.Join(baseDir, UUIDs[i]), filenamePrefix+strconv.Itoa(i+1),
startPos.Pos, notUsedGTIDSetStr)
}
// start the reader
s, err := r.StartSyncByPos(startPos)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// get events from the streamer
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
- obtainBaseEvents := readNEvents(ctx, c, s, (1+2+3)*(len(baseEvents)+1)-1, false)
- t.verifyNoEventsInStreamer(c, s)
+ obtainBaseEvents := readNEvents(ctx, t.T(), s, (1+2+3)*(len(baseEvents)+1)-1, false)
+ t.verifyNoEventsInStreamer(s)
// verify obtain base events
for i := 0; i < len(obtainBaseEvents); i += len(baseEvents) {
- c.Assert(obtainBaseEvents[i:i+len(baseEvents)], check.DeepEquals, baseEvents)
+ t.Require().Equal(baseEvents, obtainBaseEvents[i:i+len(baseEvents)])
// skip rotate event which is not added in baseEvents
i++
}
// 2. write more events to the last file
lastFilename := filepath.Join(baseDir, UUIDs[2], filenamePrefix+strconv.Itoa(3))
- extraEvents, _, _ := t.genBinlogEvents(c, lastPos, lastGTID)
+ extraEvents, _, _ := t.genBinlogEvents(lastPos, lastGTID)
lastF, err := os.OpenFile(lastFilename, os.O_WRONLY|os.O_APPEND, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer lastF.Close()
for _, ev := range extraEvents {
_, err = lastF.Write(ev.RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
r.notifyCh <- struct{}{}
@@ -515,7 +521,7 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
obtainExtraEvents := make([]*replication.BinlogEvent, 0, len(extraEvents))
for {
ev, err2 := s.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
if ev.Header.Timestamp == 0 || ev.Header.LogPos == 0 || ev.Header.EventType == replication.FORMAT_DESCRIPTION_EVENT {
continue // ignore fake event and FormatDescriptionEvent, go-mysql may send extra FormatDescriptionEvent
}
@@ -524,22 +530,22 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
break
}
}
- t.verifyNoEventsInStreamer(c, s)
+ t.verifyNoEventsInStreamer(s)
// verify obtain extra events
- c.Assert(obtainExtraEvents, check.DeepEquals, extraEvents)
+ t.Require().Equal(extraEvents, obtainExtraEvents)
// 3. create new file in the last directory
lastFilename = filepath.Join(baseDir, UUIDs[2], filenamePrefix+strconv.Itoa(4))
err = os.WriteFile(lastFilename, eventsBuf.Bytes(), 0o600)
- c.Assert(err, check.IsNil)
- t.createMetaFile(c, path.Join(baseDir, UUIDs[2]), lastFilename, lastPos, notUsedGTIDSetStr)
+ t.Require().NoError(err)
+ t.createMetaFile(path.Join(baseDir, UUIDs[2]), lastFilename, lastPos, notUsedGTIDSetStr)
r.notifyCh <- struct{}{}
obtainExtraEvents2 := make([]*replication.BinlogEvent, 0, len(baseEvents)-1)
for {
ev, err2 := s.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
if ev.Header.Timestamp == 0 || ev.Header.LogPos == 0 || ev.Header.EventType == replication.FORMAT_DESCRIPTION_EVENT {
continue // ignore fake event and FormatDescriptionEvent, go-mysql may send extra FormatDescriptionEvent
}
@@ -548,10 +554,10 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
break
}
}
- t.verifyNoEventsInStreamer(c, s)
+ t.verifyNoEventsInStreamer(s)
// verify obtain extra events
- c.Assert(obtainExtraEvents2, check.DeepEquals, baseEvents[1:])
+ t.Require().Equal(baseEvents[1:], obtainExtraEvents2)
// NOTE: load new UUIDs dynamically not supported yet
@@ -559,17 +565,17 @@ func (t *testReaderSuite) TestStartSyncByPos(c *check.C) {
r.Close()
}
-func readNEvents(ctx context.Context, c *check.C, s reader.Streamer, l int, tolerateMayDup bool) []*replication.BinlogEvent {
+func readNEvents(ctx context.Context, t *testing.T, s reader.Streamer, l int, tolerateMayDup bool) []*replication.BinlogEvent {
var result []*replication.BinlogEvent
for {
ev, err2 := s.GetEvent(ctx)
if tolerateMayDup {
if err2 != nil {
- c.Assert(errors.ErrorEqual(ErrorMaybeDuplicateEvent, err2), check.IsTrue)
+ require.True(t, errors.ErrorEqual(ErrorMaybeDuplicateEvent, err2))
continue
}
} else {
- c.Assert(err2, check.IsNil)
+ require.NoError(t, err2)
}
if ev.Header.Timestamp == 0 && ev.Header.LogPos == 0 {
continue // ignore fake event
@@ -583,9 +589,9 @@ func readNEvents(ctx context.Context, c *check.C, s reader.Streamer, l int, tole
return result
}
-func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
+func (t *testReaderSuite) TestStartSyncByGTID() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
events []*replication.BinlogEvent
cfg = &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r = newBinlogReaderForTest(log.L(), cfg, false, "")
@@ -706,9 +712,9 @@ func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
}
// write index file
- uuidBytes := t.uuidListToBytes(c, r.subDirs)
+ uuidBytes := t.uuidListToBytes(r.subDirs)
err := os.WriteFile(r.indexPath, uuidBytes, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
var allEvents []*replication.BinlogEvent
var allResults []string
@@ -718,10 +724,10 @@ func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
for i, subDir := range testCase {
lastPos = 4
lastGTID, err = gtid.ParserGTID(gmysql.MySQLFlavor, subDir.gtidStr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
uuidDir := path.Join(baseDir, subDir.uuid)
err = os.MkdirAll(uuidDir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
for _, fileEventResult := range subDir.fileEventResult {
eventTypes := []replication.EventType{}
@@ -733,20 +739,20 @@ func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
}
// generate events
- events, lastPos, lastGTID, previousGset = t.genEvents(c, eventTypes, lastPos, lastGTID, previousGset)
+ events, lastPos, lastGTID, previousGset = t.genEvents(eventTypes, lastPos, lastGTID, previousGset)
allEvents = append(allEvents, events...)
// write binlog file
f, err2 := os.OpenFile(path.Join(uuidDir, fileEventResult.filename), os.O_CREATE|os.O_WRONLY, 0o600)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
for _, ev := range events {
_, err = f.Write(ev.RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
f.Close()
- t.createMetaFile(c, uuidDir, fileEventResult.filename, lastPos, previousGset.String())
+ t.createMetaFile(uuidDir, fileEventResult.filename, lastPos, previousGset.String())
}
if i == 0 {
eventsNumOfFirstServer = len(allEvents)
@@ -754,30 +760,30 @@ func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
}
startGTID, err := gtid.ParserGTID(gmysql.MySQLFlavor, "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
s, err := r.StartSyncByGTID(startGTID.Clone())
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
- obtainBaseEvents := readNEvents(ctx, c, s, len(allEvents), true)
+ obtainBaseEvents := readNEvents(ctx, t.T(), s, len(allEvents), true)
preGset, err := gmysql.ParseGTIDSet(gmysql.MySQLFlavor, "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
gtidEventCount := 0
for i, ev := range obtainBaseEvents {
- c.Assert(ev.Header, check.DeepEquals, allEvents[i].Header)
+ t.Require().Equal(allEvents[i].Header, ev.Header)
if _, ok := ev.Event.(*replication.GTIDEvent); ok {
gtidStr, _ := event.GetGTIDStr(ev)
- c.Assert(preGset.Update(gtidStr), check.IsNil)
+ t.Require().NoError(preGset.Update(gtidStr))
// get pos by preGset
pos, err2 := r.getPosByGTID(preGset.Clone())
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
// check result
- c.Assert(pos.Name, check.Equals, allResults[gtidEventCount])
- c.Assert(pos.Pos, check.Equals, uint32(4))
+ t.Require().Equal(allResults[gtidEventCount], pos.Name)
+ t.Require().Equal(uint32(4), pos.Pos)
gtidEventCount++
}
}
@@ -796,66 +802,67 @@ func (t *testReaderSuite) TestStartSyncByGTID(c *check.C) {
}
excludeStr := strings.Join(excludeStrs, ",")
excludeGset, err := gmysql.ParseGTIDSet(gmysql.MySQLFlavor, excludeStr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// StartSyncByGtid exclude first uuid
s, err = r.StartSyncByGTID(excludeGset)
- c.Assert(err, check.IsNil)
- obtainBaseEvents = readNEvents(ctx, c, s, eventsNumOfFirstServer, true)
+ t.Require().NoError(err)
+ obtainBaseEvents = readNEvents(ctx, t.T(), s, eventsNumOfFirstServer, true)
gset := excludeGset.Clone()
// should not receive any event not from first server
for i, event := range obtainBaseEvents {
switch event.Header.EventType {
case replication.HEARTBEAT_EVENT:
- c.FailNow()
+ t.T().FailNow()
case replication.GTID_EVENT:
// check gtid event comes from first uuid subdir
ev, _ := event.Event.(*replication.GTIDEvent)
u, _ := uuid.FromBytes(ev.SID)
- c.Assert(u.String(), check.Equals, includeServerUUID)
- c.Assert(event.Header, check.DeepEquals, allEvents[i].Header)
- c.Assert(gset.Update(fmt.Sprintf("%s:%d", u.String(), ev.GNO)), check.IsNil)
+ t.Require().Equal(includeServerUUID, u.String())
+ t.Require().Equal(allEvents[i].Header, event.Header)
+ t.Require().NoError(gset.Update(fmt.Sprintf("%s:%d", u.String(), ev.GNO)))
default:
- c.Assert(event.Header, check.DeepEquals, allEvents[i].Header)
+ t.Require().Equal(allEvents[i].Header, event.Header)
}
}
// gset same as preGset now
- c.Assert(gset.Equal(preGset), check.IsTrue)
+ t.Require().True(gset.Equal(preGset))
// purge first uuid subdir's first binlog file
- c.Assert(os.Remove(path.Join(baseDir, includeUUID, "mysql.000001")), check.IsNil)
+ t.Require().Nil(os.Remove(path.Join(baseDir, includeUUID, "mysql.000001")))
r.Close()
r = newBinlogReaderForTest(log.L(), cfg, true, "")
_, err = r.StartSyncByGTID(preGset)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
r.Close()
r = newBinlogReaderForTest(log.L(), cfg, true, "")
_, err = r.StartSyncByGTID(excludeGset)
// error because file has been purge
- c.Assert(terror.ErrNoRelayPosMatchGTID.Equal(err), check.IsTrue)
+ t.Require().True(terror.ErrNoRelayPosMatchGTID.Equal(err))
// purge first uuid subdir
- c.Assert(os.RemoveAll(path.Join(baseDir, includeUUID)), check.IsNil)
+ t.Require().Nil(os.RemoveAll(path.Join(baseDir, includeUUID)))
r.Close()
r = newBinlogReaderForTest(log.L(), cfg, true, "")
_, err = r.StartSyncByGTID(preGset)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
r.Close()
r = newBinlogReaderForTest(log.L(), cfg, true, "")
_, err = r.StartSyncByGTID(excludeGset)
// error because subdir has been purge
- c.Assert(err, check.ErrorMatches, ".*no such file or directory.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*no such file or directory.*", err.Error())
cancel()
}
-func (t *testReaderSuite) TestStartSyncError(c *check.C) {
+func (t *testReaderSuite) TestStartSyncError() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
UUIDs = []string{
"b60868af-5a6f-11e9-9ea3-0242ac160006.000001",
}
@@ -865,67 +872,72 @@ func (t *testReaderSuite) TestStartSyncError(c *check.C) {
r := newBinlogReaderForTest(log.L(), cfg, true, "")
err := r.checkRelayPos(startPos)
- c.Assert(err, check.ErrorMatches, ".*empty UUIDs not valid.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*empty UUIDs not valid.*", err.Error())
// no startup pos specified
s, err := r.StartSyncByPos(gmysql.Position{})
- c.Assert(terror.ErrBinlogFileNotSpecified.Equal(err), check.IsTrue)
- c.Assert(s, check.IsNil)
+ t.Require().True(terror.ErrBinlogFileNotSpecified.Equal(err))
+ t.Require().Nil(s)
// empty UUIDs
s, err = r.StartSyncByPos(startPos)
- c.Assert(err, check.ErrorMatches, ".*empty UUIDs not valid.*")
- c.Assert(s, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Regexp(".*empty UUIDs not valid.*", err.Error())
+ t.Require().Nil(s)
s, err = r.StartSyncByGTID(t.lastGTID.Clone())
- c.Assert(err, check.ErrorMatches, ".*no relay pos match gtid.*")
- c.Assert(s, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Regexp(".*no relay pos match gtid.*", err.Error())
+ t.Require().Nil(s)
// write UUIDs into index file
r = newBinlogReaderForTest(log.L(), cfg, true, "") // create a new reader
- uuidBytes := t.uuidListToBytes(c, UUIDs)
+ uuidBytes := t.uuidListToBytes(UUIDs)
err = os.WriteFile(r.indexPath, uuidBytes, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// the startup relay log file not found
s, err = r.StartSyncByPos(startPos)
- c.Assert(err, check.ErrorMatches, fmt.Sprintf(".*%s.*not found.*", startPos.Name))
- c.Assert(s, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Regexp(fmt.Sprintf(".*%s.*not found.*", startPos.Name), err.Error())
+ t.Require().Nil(s)
s, err = r.StartSyncByGTID(t.lastGTID.Clone())
- c.Assert(err, check.ErrorMatches, ".*no such file or directory.*")
- c.Assert(s, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Regexp(".*no such file or directory.*", err.Error())
+ t.Require().Nil(s)
// can not re-start the reader
r.running = true
s, err = r.StartSyncByPos(startPos)
- c.Assert(terror.ErrReaderAlreadyRunning.Equal(err), check.IsTrue)
- c.Assert(s, check.IsNil)
+ t.Require().True(terror.ErrReaderAlreadyRunning.Equal(err))
+ t.Require().Nil(s)
r.Close()
r.running = true
s, err = r.StartSyncByGTID(t.lastGTID.Clone())
- c.Assert(terror.ErrReaderAlreadyRunning.Equal(err), check.IsTrue)
- c.Assert(s, check.IsNil)
+ t.Require().True(terror.ErrReaderAlreadyRunning.Equal(err))
+ t.Require().Nil(s)
r.Close()
// too big startPos
uuid := UUIDs[0]
err = os.MkdirAll(filepath.Join(baseDir, uuid), 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
parsedStartPosName := "test-mysql-bin.000001"
relayLogFilePath := filepath.Join(baseDir, uuid, parsedStartPosName)
err = os.WriteFile(relayLogFilePath, make([]byte, 100), 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
startPos.Pos = 10000
s, err = r.StartSyncByPos(startPos)
- c.Assert(terror.ErrRelayLogGivenPosTooBig.Equal(err), check.IsTrue)
- c.Assert(s, check.IsNil)
+ t.Require().True(terror.ErrRelayLogGivenPosTooBig.Equal(err))
+ t.Require().Nil(s)
}
-func (t *testReaderSuite) TestAdvanceCurrentGTIDSet(c *check.C) {
+func (t *testReaderSuite) TestAdvanceCurrentGTIDSet() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
cfg = &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r = newBinlogReaderForTest(log.L(), cfg, true, "")
mysqlGset, _ = gmysql.ParseMysqlGTIDSet("b60868af-5a6f-11e9-9ea3-0242ac160006:1-6")
@@ -934,32 +946,32 @@ func (t *testReaderSuite) TestAdvanceCurrentGTIDSet(c *check.C) {
r.prevGset = mysqlGset.Clone()
r.currGset = nil
notUpdated, err := r.advanceCurrentGtidSet("b60868af-5a6f-11e9-9ea3-0242ac160006:6")
- c.Assert(err, check.IsNil)
- c.Assert(notUpdated, check.IsTrue)
- c.Assert(mysqlGset.Equal(r.currGset), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(notUpdated)
+ t.Require().True(mysqlGset.Equal(r.currGset))
notUpdated, err = r.advanceCurrentGtidSet("b60868af-5a6f-11e9-9ea3-0242ac160006:7")
- c.Assert(err, check.IsNil)
- c.Assert(notUpdated, check.IsFalse)
- c.Assert(mysqlGset.Equal(r.prevGset), check.IsTrue)
- c.Assert(r.currGset.String(), check.Equals, "b60868af-5a6f-11e9-9ea3-0242ac160006:1-7")
+ t.Require().NoError(err)
+ t.Require().False(notUpdated)
+ t.Require().True(mysqlGset.Equal(r.prevGset))
+ t.Require().Equal("b60868af-5a6f-11e9-9ea3-0242ac160006:1-7", r.currGset.String())
r.cfg.Flavor = gmysql.MariaDBFlavor
r.prevGset = mariadbGset.Clone()
r.currGset = nil
notUpdated, err = r.advanceCurrentGtidSet("0-1-3")
- c.Assert(err, check.IsNil)
- c.Assert(notUpdated, check.IsTrue)
- c.Assert(mariadbGset.Equal(r.currGset), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(notUpdated)
+ t.Require().True(mariadbGset.Equal(r.currGset))
notUpdated, err = r.advanceCurrentGtidSet("0-1-6")
- c.Assert(err, check.IsNil)
- c.Assert(notUpdated, check.IsFalse)
- c.Assert(mariadbGset.Equal(r.prevGset), check.IsTrue)
- c.Assert(r.currGset.String(), check.Equals, "0-1-6")
+ t.Require().NoError(err)
+ t.Require().False(notUpdated)
+ t.Require().True(mariadbGset.Equal(r.prevGset))
+ t.Require().Equal("0-1-6", r.currGset.String())
}
-func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
+func (t *testReaderSuite) TestReParseUsingGTID() {
var (
- baseDir = c.MkDir()
+ baseDir = t.T().TempDir()
cfg = &BinlogReaderConfig{RelayDir: baseDir, Flavor: gmysql.MySQLFlavor}
r = newBinlogReaderForTest(log.L(), cfg, true, "")
uuid = "ba8f633f-1f15-11eb-b1c7-0242ac110002.000001"
@@ -969,25 +981,25 @@ func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
)
startGTID, err := gtid.ParserGTID(gmysql.MySQLFlavor, "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
lastGTID, err := gtid.ParserGTID(gmysql.MySQLFlavor, gtidStr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// prepare a minimal relay log file
- c.Assert(os.WriteFile(r.indexPath, []byte(uuid), 0o600), check.IsNil)
+ t.Require().Nil(os.WriteFile(r.indexPath, []byte(uuid), 0o600))
uuidDir := path.Join(baseDir, uuid)
- c.Assert(os.MkdirAll(uuidDir, 0o700), check.IsNil)
+ t.Require().Nil(os.MkdirAll(uuidDir, 0o700))
f, err := os.OpenFile(path.Join(uuidDir, file), os.O_CREATE|os.O_WRONLY, 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = f.Write(replication.BinLogFileHeader)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
meta := LocalMeta{BinLogName: file, BinLogPos: latestPos, BinlogGTID: startGTID.String()}
metaFile, err := os.Create(path.Join(uuidDir, utils.MetaFilename))
- c.Assert(err, check.IsNil)
- c.Assert(toml.NewEncoder(metaFile).Encode(&meta), check.IsNil)
- c.Assert(metaFile.Close(), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(toml.NewEncoder(metaFile).Encode(&meta))
+ t.Require().NoError(metaFile.Close())
// prepare some regular events,
// FORMAT_DESC + PREVIOUS_GTIDS, some events generated from a DDL, some events generated from a DML
@@ -996,18 +1008,18 @@ func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
replication.QUERY_EVENT,
replication.XID_EVENT,
}
- events, _, _, latestGTIDSet := t.genEvents(c, genType, 4, lastGTID, startGTID)
- c.Assert(events, check.HasLen, 1+1+2+5)
+ events, _, _, latestGTIDSet := t.genEvents(genType, 4, lastGTID, startGTID)
+ t.Require().Len(events, 1+1+2+5)
// write FORMAT_DESC + PREVIOUS_GTIDS
_, err = f.Write(events[0].RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = f.Write(events[1].RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// we use latestGTIDSet to start sync, which means we already received all binlog events, so expect no DML/DDL
s, err := r.StartSyncByGTID(latestGTIDSet)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
var wg sync.WaitGroup
wg.Add(1)
@@ -1030,8 +1042,8 @@ func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
if err2 == context.Canceled {
break
}
- c.Assert(err2, check.IsNil)
- c.Assert(ev.Header.EventType, check.Equals, expected[ev.Header.LogPos])
+ t.Require().Nil(err2)
+ t.Require().Equal(expected[ev.Header.LogPos], ev.Header.EventType)
}
wg.Done()
}()
@@ -1040,7 +1052,7 @@ func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
// hope a second is enough to trigger needReParse
time.Sleep(time.Second)
_, err = f.Write(events[i].RawData)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_ = f.Sync()
select {
case r.notifyCh <- struct{}{}:
@@ -1052,7 +1064,7 @@ func (t *testReaderSuite) TestReParseUsingGTID(c *check.C) {
wg.Wait()
}
-func (t *testReaderSuite) genBinlogEvents(c *check.C, latestPos uint32, latestGTID gmysql.GTIDSet) ([]*replication.BinlogEvent, uint32, gmysql.GTIDSet) {
+func (t *testReaderSuite) genBinlogEvents(latestPos uint32, latestGTID gmysql.GTIDSet) ([]*replication.BinlogEvent, uint32, gmysql.GTIDSet) {
var (
header = &replication.EventHeader{
Timestamp: uint32(time.Now().Unix()),
@@ -1063,7 +1075,7 @@ func (t *testReaderSuite) genBinlogEvents(c *check.C, latestPos uint32, latestGT
if latestPos <= 4 { // generate a FormatDescriptionEvent if needed
ev, err := event.GenFormatDescriptionEvent(header, 4)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
latestPos = ev.Header.LogPos
events = append(events, ev)
}
@@ -1072,7 +1084,7 @@ func (t *testReaderSuite) genBinlogEvents(c *check.C, latestPos uint32, latestGT
count := 5 + rand.Intn(5)
for i := 0; i < count; i++ {
evs, err := event.GenDDLEvents(gmysql.MySQLFlavor, 1, latestPos, latestGTID, fmt.Sprintf("db_%d", i), fmt.Sprintf("CREATE TABLE %d (c1 INT)", i), true, false, 0)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
events = append(events, evs.Events...)
latestPos = evs.LatestPos
latestGTID = evs.LatestGTID
@@ -1082,7 +1094,6 @@ func (t *testReaderSuite) genBinlogEvents(c *check.C, latestPos uint32, latestGT
}
func (t *testReaderSuite) genEvents(
- c *check.C,
eventTypes []replication.EventType,
latestPos uint32,
latestGTID gmysql.GTIDSet,
@@ -1100,7 +1111,7 @@ func (t *testReaderSuite) genEvents(
if latestPos <= 4 { // generate a FormatDescriptionEvent if needed
ev, err := event.GenFormatDescriptionEvent(header, 4)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
latestPos = ev.Header.LogPos
events = append(events, ev)
}
@@ -1109,15 +1120,15 @@ func (t *testReaderSuite) genEvents(
switch eventType {
case replication.QUERY_EVENT:
evs, err := event.GenDDLEvents(gmysql.MySQLFlavor, 1, latestPos, latestGTID, fmt.Sprintf("db_%d", i), fmt.Sprintf("CREATE TABLE %d (c1 int)", i), true, false, 0)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
events = append(events, evs.Events...)
latestPos = evs.LatestPos
latestGTID = evs.LatestGTID
_, ok := evs.Events[0].Event.(*replication.GTIDEvent)
- c.Assert(ok, check.IsTrue)
+ t.Require().True(ok)
gtidStr, _ := event.GetGTIDStr(evs.Events[0])
err = originSet.Update(gtidStr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
case replication.XID_EVENT:
insertDMLData := []*event.DMLData{
{
@@ -1129,23 +1140,23 @@ func (t *testReaderSuite) genEvents(
},
}
evs, err := event.GenDMLEvents(gmysql.MySQLFlavor, 1, latestPos, latestGTID, replication.WRITE_ROWS_EVENTv2, 10, insertDMLData, true, false, 0)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
events = append(events, evs.Events...)
latestPos = evs.LatestPos
latestGTID = evs.LatestGTID
_, ok := evs.Events[0].Event.(*replication.GTIDEvent)
- c.Assert(ok, check.IsTrue)
+ t.Require().True(ok)
gtidStr, _ := event.GetGTIDStr(evs.Events[0])
err = originSet.Update(gtidStr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
case replication.ROTATE_EVENT:
ev, err := event.GenRotateEvent(header, latestPos, []byte("next_log"), 4)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
events = append(events, ev)
latestPos = 4
case replication.PREVIOUS_GTIDS_EVENT:
ev, err := event.GenPreviousGTIDsEvent(header, latestPos, pGset)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
events = append(events, ev)
latestPos = ev.Header.LogPos
}
@@ -1153,7 +1164,7 @@ func (t *testReaderSuite) genEvents(
return events, latestPos, latestGTID, originSet
}
-func (t *testReaderSuite) purgeStreamer(c *check.C, s reader.Streamer) {
+func (t *testReaderSuite) purgeStreamer(s reader.Streamer) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()
@@ -1165,55 +1176,55 @@ func (t *testReaderSuite) purgeStreamer(c *check.C, s reader.Streamer) {
case err == ctx.Err():
return
default:
- c.Fatalf("purge streamer with error %v", err)
+ t.T().Fatalf("purge streamer with error %v", err)
}
}
}
-func (t *testReaderSuite) verifyNoEventsInStreamer(c *check.C, s reader.Streamer) {
+func (t *testReaderSuite) verifyNoEventsInStreamer(s reader.Streamer) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()
ev, err := s.GetEvent(ctx)
if err != ctx.Err() {
- c.Fatalf("got event %v with error %v from streamer", ev, err)
+ t.T().Fatalf("got event %v with error %v from streamer", ev, err)
}
}
-func (t *testReaderSuite) uuidListToBytes(c *check.C, uuids []string) []byte {
+func (t *testReaderSuite) uuidListToBytes(uuids []string) []byte {
var buf bytes.Buffer
for _, uuid := range uuids {
_, err := buf.WriteString(uuid)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = buf.WriteString("\n")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
return buf.Bytes()
}
// nolint:unparam
-func (t *testReaderSuite) writeUUIDs(c *check.C, relayDir string, uuids []string) []byte {
+func (t *testReaderSuite) writeUUIDs(relayDir string, uuids []string) []byte {
indexPath := path.Join(relayDir, utils.UUIDIndexFilename)
var buf bytes.Buffer
for _, uuid := range uuids {
_, err := buf.WriteString(uuid)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = buf.WriteString("\n")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
// write the index file
err := os.WriteFile(indexPath, buf.Bytes(), 0o600)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
return buf.Bytes()
}
-func (t *testReaderSuite) createMetaFile(c *check.C, relayDirPath, binlogFileName string, pos uint32, gtid string) {
+func (t *testReaderSuite) createMetaFile(relayDirPath, binlogFileName string, pos uint32, gtid string) {
meta := LocalMeta{BinLogName: binlogFileName, BinLogPos: pos, BinlogGTID: gtid}
metaFile, err2 := os.Create(path.Join(relayDirPath, utils.MetaFilename))
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
err := toml.NewEncoder(metaFile).Encode(&meta)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
metaFile.Close()
}
@@ -1249,7 +1260,7 @@ func (m *mockFileWriterForActiveTest) IsActive(uuid, filename string) (bool, int
return v.active, v.offset
}
-func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
+func (t *testReaderSuite) TestwaitBinlogChanged() {
var (
relayFiles = []string{
"mysql-bin.000001",
@@ -1263,7 +1274,7 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
)
// create relay log dir
- subDir := c.MkDir()
+ subDir := t.T().TempDir()
// join the file path
for i, rf := range relayFiles {
relayPaths[i] = filepath.Join(subDir, rf)
@@ -1274,9 +1285,9 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
rotateRelayFile := func(filename string) {
meta := LocalMeta{BinLogName: filename, BinLogPos: binlogPos, BinlogGTID: binlogGTID}
metaFile, err2 := os.Create(path.Join(subDir, utils.MetaFilename))
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
err := toml.NewEncoder(metaFile).Encode(&meta)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_ = metaFile.Close()
}
@@ -1285,12 +1296,13 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: "", Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[0], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[0], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, ".*no such file or directory*")
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().Error(err)
+ t.Require().Error(err)
+ t.Require().Regexp(".*no such file or directory*", err.Error())
}
// write meta
@@ -1306,15 +1318,16 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
relayLogFile: "not-exist-file",
}
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.NotNil)
- c.Assert(err, check.ErrorMatches, ".*no such file or directory*")
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().Error(err)
+ t.Require().Error(err)
+ t.Require().Regexp(".*no such file or directory*", err.Error())
}
// create the first relay file
err1 := os.WriteFile(relayPaths[0], data, 0o600)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
// rotate relay file
rotateRelayFile(relayFiles[1])
@@ -1323,12 +1336,12 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: "", Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[0], size+100, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[0], size+100, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.NotNil)
- c.Assert(terror.ErrRelayLogFileSizeSmaller.Equal(err), check.IsTrue)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().Error(err)
+ t.Require().True(terror.ErrRelayLogFileSizeSmaller.Equal(err))
}
// return changed file in meta
@@ -1336,11 +1349,11 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: "", Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[0], size, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[0], size, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().NoError(err)
}
// file increased when checking meta
@@ -1348,11 +1361,11 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: "", Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[0], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[0], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsTrue)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().True(reParse)
+ t.Require().NoError(err)
}
// context timeout (no new write)
@@ -1362,30 +1375,30 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: "", Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "current-uuid") // no notify
t.setActiveRelayLog(r.relay, "current-uuid", relayFiles[0], 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[0], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[0], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(newCtx, state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().NoError(err)
}
// this dir is different from the dir of current binlog file, but for test it doesn't matter
- relayDir := c.MkDir()
- t.writeUUIDs(c, relayDir, []string{"xxx.000001", "invalid uuid"})
+ relayDir := t.T().TempDir()
+ t.writeUUIDs(relayDir, []string{"xxx.000001", "invalid uuid"})
// getSwitchPath return error(invalid uuid file)
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "xxx.000001")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(terror.ErrRelayParseUUIDSuffix.Equal(err), check.IsTrue)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().True(terror.ErrRelayParseUUIDSuffix.Equal(err))
}
- t.writeUUIDs(c, relayDir, []string{"xxx.000001", "xxx.000002"})
+ t.writeUUIDs(relayDir, []string{"xxx.000001", "xxx.000002"})
_ = os.MkdirAll(filepath.Join(relayDir, "xxx.000002"), 0o700)
_ = os.WriteFile(filepath.Join(relayDir, "xxx.000002", "mysql.000001"), nil, 0o600)
@@ -1395,42 +1408,42 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "xxx.000001")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
_ = os.Remove(relayPaths[1])
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(terror.ErrGetRelayLogStat.Equal(err), check.IsTrue)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().True(terror.ErrGetRelayLogStat.Equal(err))
}
err1 = os.WriteFile(relayPaths[1], nil, 0o600)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
// binlog dir switched, but last file smaller
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "xxx.000001")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], size, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], size, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsFalse)
- c.Assert(terror.ErrRelayLogFileSizeSmaller.Equal(err), check.IsTrue)
+ t.Require().False(needSwitch)
+ t.Require().False(reParse)
+ t.Require().True(terror.ErrRelayLogFileSizeSmaller.Equal(err))
}
err1 = os.WriteFile(relayPaths[1], data, 0o600)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
// binlog dir switched, but last file bigger
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "xxx.000001")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsTrue)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().True(reParse)
+ t.Require().NoError(err)
}
// binlog dir switched, but last file not changed
@@ -1438,11 +1451,11 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, false, "xxx.000001")
t.setActiveRelayLog(r.relay, "next", "next", 0)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], size, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], size, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsTrue)
- c.Assert(reParse, check.IsFalse)
- c.Assert(err, check.IsNil)
+ t.Require().True(needSwitch)
+ t.Require().False(reParse)
+ t.Require().NoError(err)
}
// got notified and active pos > current read pos
@@ -1450,11 +1463,11 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, "xxx.000001")
t.setActiveRelayLog(r.relay, r.currentSubDir, relayFiles[1], size)
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsTrue)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().True(reParse)
+ t.Require().NoError(err)
}
// got notified but not active
@@ -1466,11 +1479,11 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
{true, 0},
{false, 0},
}}
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsTrue)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().True(reParse)
+ t.Require().NoError(err)
}
// got notified, first notified is active but has already read to that offset
@@ -1487,17 +1500,17 @@ func (t *testReaderSuite) TestwaitBinlogChanged(c *check.C) {
{true, 0},
{true, size},
}}
- state := t.createBinlogFileParseState(c, subDir, relayFiles[1], 0, true)
+ state := t.createBinlogFileParseState(subDir, relayFiles[1], 0, true)
needSwitch, reParse, err := r.waitBinlogChanged(context.Background(), state)
- c.Assert(needSwitch, check.IsFalse)
- c.Assert(reParse, check.IsTrue)
- c.Assert(err, check.IsNil)
+ t.Require().False(needSwitch)
+ t.Require().True(reParse)
+ t.Require().NoError(err)
}
}
-func (t *testReaderSuite) TestGetSwitchPath(c *check.C) {
+func (t *testReaderSuite) TestGetSwitchPath() {
var (
- relayDir = c.MkDir()
+ relayDir = t.T().TempDir()
UUIDs = []string{
"53ea0ed1-9bf8-11e6-8bea-64006a897c73.000001",
"53ea0ed1-9bf8-11e6-8bea-64006a897c72.000002",
@@ -1509,53 +1522,54 @@ func (t *testReaderSuite) TestGetSwitchPath(c *check.C) {
UUIDs = append(UUIDs, "invalid.uuid")
// invalid UUID in UUIDs, error
- t.writeUUIDs(c, relayDir, UUIDs)
+ t.writeUUIDs(relayDir, UUIDs)
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, currentUUID)
switchPath, err := r.getSwitchPath()
- c.Assert(switchPath, check.IsNil)
- c.Assert(terror.ErrRelayParseUUIDSuffix.Equal(err), check.IsTrue)
+ t.Require().Nil(switchPath)
+ t.Require().True(terror.ErrRelayParseUUIDSuffix.Equal(err))
}
UUIDs = UUIDs[:len(UUIDs)-1] // remove the invalid UUID
- t.writeUUIDs(c, relayDir, UUIDs)
+ t.writeUUIDs(relayDir, UUIDs)
// no next sub directory
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, UUIDs[0])
switchPath, err := r.getSwitchPath()
- c.Assert(switchPath, check.IsNil)
- c.Assert(err, check.ErrorMatches, fmt.Sprintf(".*%s.*(no such file or directory|The system cannot find the file specified).*", UUIDs[1]))
+ t.Require().Nil(switchPath)
+ t.Require().Error(err)
+ t.Require().Regexp(fmt.Sprintf(".*%s.*(no such file or directory|The system cannot find the file specified).*", UUIDs[1]), err.Error())
}
err1 := os.Mkdir(filepath.Join(relayDir, UUIDs[1]), 0o700)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
// uuid directory exist, but no binlog file inside
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, UUIDs[0])
switchPath, err := r.getSwitchPath()
- c.Assert(switchPath, check.IsNil)
- c.Assert(err, check.IsNil)
+ t.Require().Nil(switchPath)
+ t.Require().NoError(err)
}
// create a relay log file in the next sub directory
nextBinlogPath := filepath.Join(relayDir, UUIDs[1], "mysql-bin.000001")
err1 = os.MkdirAll(filepath.Dir(nextBinlogPath), 0o700)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
err1 = os.WriteFile(nextBinlogPath, nil, 0o600)
- c.Assert(err1, check.IsNil)
+ t.Require().Nil(err1)
// switch to the next
{
cfg := &BinlogReaderConfig{RelayDir: relayDir, Flavor: gmysql.MySQLFlavor}
r := newBinlogReaderForTest(log.L(), cfg, true, UUIDs[0])
switchPath, err := r.getSwitchPath()
- c.Assert(switchPath.nextUUID, check.Equals, UUIDs[1])
- c.Assert(switchPath.nextBinlogName, check.Equals, filepath.Base(nextBinlogPath))
- c.Assert(err, check.IsNil)
+ t.Require().Equal(UUIDs[1], switchPath.nextUUID)
+ t.Require().Equal(filepath.Base(nextBinlogPath), switchPath.nextBinlogName)
+ t.Require().NoError(err)
}
}
diff --git a/dm/relay/meta_test.go b/dm/relay/meta_test.go
index b90a5031eb..2a2b1377b8 100644
--- a/dm/relay/meta_test.go
+++ b/dm/relay/meta_test.go
@@ -18,16 +18,13 @@ import (
"os"
"path"
"strings"
+ "testing"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/gtid"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testMetaSuite{})
-
-type testMetaSuite struct{}
-
type MetaTestCase struct {
uuid string
uuidWithSuffix string
@@ -35,8 +32,8 @@ type MetaTestCase struct {
gset mysql.GTIDSet
}
-func (r *testMetaSuite) TestLocalMeta(c *check.C) {
- dir := c.MkDir()
+func TestLocalMeta(t *testing.T) {
+ dir := t.TempDir()
gset0, _ := gtid.ParserGTID("mysql", "")
gset1, _ := gtid.ParserGTID("mysql", "85ab69d1-b21f-11e6-9c5e-64006a8978d2:1-12")
@@ -75,27 +72,27 @@ func (r *testMetaSuite) TestLocalMeta(c *check.C) {
// load, but empty
lm := NewLocalMeta("mysql", dir)
err := lm.Load()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
uuid, pos := lm.Pos()
- c.Assert(uuid, check.Equals, "")
- c.Assert(pos, check.DeepEquals, minCheckpoint)
+ require.Equal(t, "", uuid)
+ require.Equal(t, minCheckpoint, pos)
uuid, gset := lm.GTID()
- c.Assert(uuid, check.Equals, "")
- c.Assert(gset, check.DeepEquals, gset0)
+ require.Equal(t, "", uuid)
+ require.Equal(t, gset0, gset)
err = lm.Save(minCheckpoint, nil)
- c.Assert(err, check.NotNil)
+ require.Error(t, err)
err = lm.Flush()
- c.Assert(err, check.NotNil)
+ require.Error(t, err)
dirty := lm.Dirty()
- c.Assert(dirty, check.IsFalse)
+ require.False(t, dirty)
// set currentSubDir because lm.doFlush need it
currentUUID := "uuid.000001"
- c.Assert(os.MkdirAll(path.Join(dir, currentUUID), 0o777), check.IsNil)
+ require.NoError(t, os.MkdirAll(path.Join(dir, currentUUID), 0o777))
setLocalMetaWithCurrentUUID := func() {
lm = NewLocalMeta("mysql", dir)
lm.(*LocalMeta).currentSubDir = currentUUID
@@ -107,106 +104,106 @@ func (r *testMetaSuite) TestLocalMeta(c *check.C) {
latestGTIDStr := "85ab69d1-b21f-11e6-9c5e-64006a8978d2:45-57"
cs0 := cases[0]
adjusted, err := lm.AdjustWithStartPos(cs0.pos.Name, cs0.gset.String(), false, latestBinlogName, latestGTIDStr)
- c.Assert(err, check.IsNil)
- c.Assert(adjusted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, adjusted)
uuid, pos = lm.Pos()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(pos.Name, check.Equals, cs0.pos.Name)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, cs0.pos.Name, pos.Name)
uuid, gset = lm.GTID()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(gset.String(), check.Equals, "")
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, "", gset.String())
// adjust to start pos with enableGTID
setLocalMetaWithCurrentUUID()
adjusted, err = lm.AdjustWithStartPos(cs0.pos.Name, cs0.gset.String(), true, latestBinlogName, latestGTIDStr)
- c.Assert(err, check.IsNil)
- c.Assert(adjusted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, adjusted)
uuid, pos = lm.Pos()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(pos.Name, check.Equals, cs0.pos.Name)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, cs0.pos.Name, pos.Name)
uuid, gset = lm.GTID()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(gset, check.DeepEquals, cs0.gset)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, cs0.gset, gset)
// adjust to the last binlog if start pos is empty
setLocalMetaWithCurrentUUID()
adjusted, err = lm.AdjustWithStartPos("", cs0.gset.String(), false, latestBinlogName, latestGTIDStr)
- c.Assert(err, check.IsNil)
- c.Assert(adjusted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, adjusted)
uuid, pos = lm.Pos()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(pos.Name, check.Equals, latestBinlogName)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, latestBinlogName, pos.Name)
uuid, gset = lm.GTID()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(gset.String(), check.Equals, "")
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, "", gset.String())
setLocalMetaWithCurrentUUID()
adjusted, err = lm.AdjustWithStartPos("", "", true, latestBinlogName, latestGTIDStr)
- c.Assert(err, check.IsNil)
- c.Assert(adjusted, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, adjusted)
uuid, pos = lm.Pos()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(pos.Name, check.Equals, latestBinlogName)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, latestBinlogName, pos.Name)
uuid, gset = lm.GTID()
- c.Assert(uuid, check.Equals, currentUUID)
- c.Assert(gset.String(), check.Equals, latestGTIDStr)
+ require.Equal(t, currentUUID, uuid)
+ require.Equal(t, latestGTIDStr, gset.String())
// reset
lm.(*LocalMeta).currentSubDir = ""
for _, cs := range cases {
err = lm.AddDir(cs.uuid, nil, nil, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = lm.Save(cs.pos, cs.gset)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
currentUUID2, pos2 := lm.Pos()
- c.Assert(currentUUID2, check.Equals, cs.uuidWithSuffix)
- c.Assert(pos2, check.DeepEquals, cs.pos)
+ require.Equal(t, cs.uuidWithSuffix, currentUUID2)
+ require.Equal(t, cs.pos, pos2)
currentUUID, gset = lm.GTID()
- c.Assert(currentUUID, check.Equals, cs.uuidWithSuffix)
- c.Assert(gset, check.DeepEquals, cs.gset)
+ require.Equal(t, cs.uuidWithSuffix, currentUUID)
+ require.Equal(t, cs.gset, gset)
dirty = lm.Dirty()
- c.Assert(dirty, check.IsTrue)
+ require.True(t, dirty)
currentDir := lm.Dir()
- c.Assert(strings.HasSuffix(currentDir, cs.uuidWithSuffix), check.IsTrue)
+ require.True(t, strings.HasSuffix(currentDir, cs.uuidWithSuffix))
}
err = lm.Flush()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
dirty = lm.Dirty()
- c.Assert(dirty, check.IsFalse)
+ require.False(t, dirty)
// try adjust to start pos again
csn1 := cases[len(cases)-1]
adjusted, err = lm.AdjustWithStartPos(cs0.pos.Name, cs0.gset.String(), false, "", "")
- c.Assert(err, check.IsNil)
- c.Assert(adjusted, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, adjusted)
uuid, pos = lm.Pos()
- c.Assert(uuid, check.Equals, csn1.uuidWithSuffix)
- c.Assert(pos.Name, check.Equals, csn1.pos.Name)
+ require.Equal(t, csn1.uuidWithSuffix, uuid)
+ require.Equal(t, csn1.pos.Name, pos.Name)
uuid, gset = lm.GTID()
- c.Assert(uuid, check.Equals, csn1.uuidWithSuffix)
- c.Assert(gset, check.DeepEquals, csn1.gset)
+ require.Equal(t, csn1.uuidWithSuffix, uuid)
+ require.Equal(t, csn1.gset, gset)
// create a new LocalMeta, and load it
lm2 := NewLocalMeta("mysql", dir)
err = lm2.Load()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
lastCase := cases[len(cases)-1]
uuid, pos = lm2.Pos()
- c.Assert(uuid, check.Equals, lastCase.uuidWithSuffix)
- c.Assert(pos, check.DeepEquals, lastCase.pos)
+ require.Equal(t, lastCase.uuidWithSuffix, uuid)
+ require.Equal(t, lastCase.pos, pos)
uuid, gset = lm2.GTID()
- c.Assert(uuid, check.Equals, lastCase.uuidWithSuffix)
- c.Assert(gset, check.DeepEquals, lastCase.gset)
+ require.Equal(t, lastCase.uuidWithSuffix, uuid)
+ require.Equal(t, lastCase.gset, gset)
// another case for AddDir, specify pos and GTID
cs := MetaTestCase{
@@ -216,24 +213,24 @@ func (r *testMetaSuite) TestLocalMeta(c *check.C) {
gset: gset5,
}
err = lm.AddDir(cs.uuid, &cs.pos, cs.gset, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
dirty = lm.Dirty()
- c.Assert(dirty, check.IsFalse)
+ require.False(t, dirty)
currentUUID, pos = lm.Pos()
- c.Assert(currentUUID, check.Equals, cs.uuidWithSuffix)
- c.Assert(pos, check.DeepEquals, cs.pos)
+ require.Equal(t, cs.uuidWithSuffix, currentUUID)
+ require.Equal(t, cs.pos, pos)
currentUUID, gset = lm.GTID()
- c.Assert(currentUUID, check.Equals, cs.uuidWithSuffix)
- c.Assert(gset, check.DeepEquals, cs.gset)
+ require.Equal(t, cs.uuidWithSuffix, currentUUID)
+ require.Equal(t, cs.gset, gset)
currentDir := lm.Dir()
- c.Assert(strings.HasSuffix(currentDir, cs.uuidWithSuffix), check.IsTrue)
+ require.True(t, strings.HasSuffix(currentDir, cs.uuidWithSuffix))
}
-func (r *testMetaSuite) TestLocalMetaPotentialDataRace(c *check.C) {
+func TestLocalMetaPotentialDataRace(t *testing.T) {
var err error
lm := NewLocalMeta("mysql", "/FAKE_DIR")
uuidStr := "85ab69d1-b21f-11e6-9c5e-64006a8978d2"
@@ -243,7 +240,7 @@ func (r *testMetaSuite) TestLocalMetaPotentialDataRace(c *check.C) {
mysql.Position{Name: "mysql-bin.000001", Pos: 234},
initGSet,
)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ch1 := make(chan error)
ch2 := make(chan error)
@@ -289,7 +286,7 @@ func (r *testMetaSuite) TestLocalMetaPotentialDataRace(c *check.C) {
close(pendingCh)
ch1Err := <-ch1
ch2Err := <-ch2
- c.Assert(ch1Err, check.IsNil)
- c.Assert(ch2Err, check.IsNil)
- c.Logf("GTID string from the go routine: %s", gtidString)
+ require.NoError(t, ch1Err)
+ require.NoError(t, ch2Err)
+ t.Logf("GTID string from the go routine: %s", gtidString)
}
diff --git a/dm/relay/purger_helper_test.go b/dm/relay/purger_helper_test.go
index 44cf7dfcb2..c735aa5b83 100644
--- a/dm/relay/purger_helper_test.go
+++ b/dm/relay/purger_helper_test.go
@@ -18,33 +18,32 @@ import (
"path/filepath"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/streamer"
"github.com/pingcap/tiflow/dm/pkg/utils"
)
-func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile(c *check.C) {
+func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile() {
// UUID mismatch
safeRelay := &streamer.RelayLogInfo{
SubDir: "not-found-uuid",
}
files, err := getRelayFilesBeforeFile(log.L(), "", t.uuids, safeRelay)
- c.Assert(err, check.NotNil)
- c.Assert(files, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Nil(files)
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// empty relay log dirs
safeRelay = &streamer.RelayLogInfo{
SubDir: t.uuids[len(t.uuids)-1],
}
files, err = getRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.NotNil)
- c.Assert(files, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Nil(files)
// create relay log files
- relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(c, baseDir, -1, -1)
+ relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(baseDir, -1, -1)
// no older
safeRelay = &streamer.RelayLogInfo{
@@ -52,8 +51,8 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile(c *check.C) {
Filename: t.relayFiles[0][0],
}
files, err = getRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.DeepEquals, []*subRelayFiles{})
+ t.Require().NoError(err)
+ t.Require().Equal([]*subRelayFiles{}, files)
// only relay files in first sub dir
safeRelay = &streamer.RelayLogInfo{
@@ -61,11 +60,11 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile(c *check.C) {
Filename: t.relayFiles[1][0],
}
files, err = getRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(len(files), check.Equals, 1)
- c.Assert(files[0].dir, check.Equals, relayDirsPath[0])
- c.Assert(files[0].files, check.DeepEquals, relayFilesPath[0])
- c.Assert(files[0].hasAll, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Equal(1, len(files))
+ t.Require().Equal(relayDirsPath[0], files[0].dir)
+ t.Require().Equal(relayFilesPath[0], files[0].files)
+ t.Require().True(files[0].hasAll)
// relay files in first sub dir, and some in second sub dir
safeRelay = &streamer.RelayLogInfo{
@@ -73,14 +72,14 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile(c *check.C) {
Filename: t.relayFiles[1][len(t.relayFiles[1])-1],
}
files, err = getRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(len(files), check.Equals, 2)
- c.Assert(files[0].dir, check.Equals, relayDirsPath[0])
- c.Assert(files[0].files, check.DeepEquals, relayFilesPath[0])
- c.Assert(files[0].hasAll, check.IsTrue)
- c.Assert(files[1].dir, check.Equals, relayDirsPath[1])
- c.Assert(files[1].files, check.DeepEquals, relayFilesPath[1][:len(t.relayFiles[1])-1])
- c.Assert(files[1].hasAll, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(2, len(files))
+ t.Require().Equal(relayDirsPath[0], files[0].dir)
+ t.Require().Equal(relayFilesPath[0], files[0].files)
+ t.Require().True(files[0].hasAll)
+ t.Require().Equal(relayDirsPath[1], files[1].dir)
+ t.Require().Equal(relayFilesPath[1][:len(t.relayFiles[1])-1], files[1].files)
+ t.Require().False(files[1].hasAll)
// relay files in first and second sub dir, and some in third sub dir
safeRelay = &streamer.RelayLogInfo{
@@ -88,47 +87,47 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFile(c *check.C) {
Filename: t.relayFiles[2][1],
}
files, err = getRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(len(files), check.Equals, 3)
- c.Assert(files[0].dir, check.Equals, relayDirsPath[0])
- c.Assert(files[0].files, check.DeepEquals, relayFilesPath[0])
- c.Assert(files[0].hasAll, check.IsTrue)
- c.Assert(files[1].dir, check.Equals, relayDirsPath[1])
- c.Assert(files[1].files, check.DeepEquals, relayFilesPath[1])
- c.Assert(files[1].hasAll, check.IsTrue)
- c.Assert(files[2].dir, check.Equals, relayDirsPath[2])
- c.Assert(files[2].files, check.DeepEquals, relayFilesPath[2][:1])
- c.Assert(files[2].hasAll, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(3, len(files))
+ t.Require().Equal(relayDirsPath[0], files[0].dir)
+ t.Require().Equal(relayFilesPath[0], files[0].files)
+ t.Require().True(files[0].hasAll)
+ t.Require().Equal(relayDirsPath[1], files[1].dir)
+ t.Require().Equal(relayFilesPath[1], files[1].files)
+ t.Require().True(files[1].hasAll)
+ t.Require().Equal(relayDirsPath[2], files[2].dir)
+ t.Require().Equal(relayFilesPath[2][:1], files[2].files)
+ t.Require().False(files[2].hasAll)
// write a fake meta file to first sub dir
fakeMeta := filepath.Join(relayDirsPath[0], utils.MetaFilename)
- c.Assert(os.WriteFile(fakeMeta, []byte{}, 0o666), check.IsNil)
+ t.Require().Nil(os.WriteFile(fakeMeta, []byte{}, 0o666))
// purge all relay log files in first and second sub dir, and some in third sub dir
err = purgeRelayFilesBeforeFile(log.L(), baseDir, t.uuids, safeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
- c.Assert(utils.IsFileExists(relayFilesPath[2][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[2][1]), check.IsTrue)
- c.Assert(utils.IsFileExists(relayFilesPath[2][2]), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().False(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[2][0]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[2][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[2][2]))
}
-func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFileAndTime(c *check.C) {
+func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFileAndTime() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// empty relay log dirs
safeRelay := &streamer.RelayLogInfo{
SubDir: t.uuids[len(t.uuids)-1],
}
files, err := getRelayFilesBeforeFileAndTime(log.L(), baseDir, t.uuids, safeRelay, time.Now())
- c.Assert(err, check.NotNil)
- c.Assert(files, check.IsNil)
+ t.Require().Error(err)
+ t.Require().Nil(files)
// create relay log files
- relayDirsPath, relayFilesPath, safeTime := t.genRelayLogFiles(c, baseDir, 1, 1)
+ relayDirsPath, relayFilesPath, safeTime := t.genRelayLogFiles(baseDir, 1, 1)
// safeRelay older than safeTime
safeRelay = &streamer.RelayLogInfo{
@@ -136,11 +135,11 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFileAndTime(c *check.C) {
Filename: t.relayFiles[1][0],
}
files, err = getRelayFilesBeforeFileAndTime(log.L(), baseDir, t.uuids, safeRelay, safeTime)
- c.Assert(err, check.IsNil)
- c.Assert(len(files), check.Equals, 1)
- c.Assert(files[0].dir, check.Equals, relayDirsPath[0])
- c.Assert(files[0].files, check.DeepEquals, relayFilesPath[0])
- c.Assert(files[0].hasAll, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().Equal(1, len(files))
+ t.Require().Equal(relayDirsPath[0], files[0].dir)
+ t.Require().Equal(relayFilesPath[0], files[0].files)
+ t.Require().True(files[0].hasAll)
// safeRelay newer than safeTime
safeRelay = &streamer.RelayLogInfo{
@@ -148,26 +147,26 @@ func (t *testPurgerSuite) TestPurgeRelayFilesBeforeFileAndTime(c *check.C) {
Filename: t.relayFiles[2][0],
}
files, err = getRelayFilesBeforeFileAndTime(log.L(), baseDir, t.uuids, safeRelay, safeTime)
- c.Assert(err, check.IsNil)
- c.Assert(len(files), check.Equals, 2)
- c.Assert(files[0].dir, check.Equals, relayDirsPath[0])
- c.Assert(files[0].files, check.DeepEquals, relayFilesPath[0])
- c.Assert(files[0].hasAll, check.IsTrue)
- c.Assert(files[1].dir, check.Equals, relayDirsPath[1])
- c.Assert(files[1].files, check.DeepEquals, relayFilesPath[1][:2])
- c.Assert(files[1].hasAll, check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().Equal(2, len(files))
+ t.Require().Equal(relayDirsPath[0], files[0].dir)
+ t.Require().Equal(relayFilesPath[0], files[0].files)
+ t.Require().True(files[0].hasAll)
+ t.Require().Equal(relayDirsPath[1], files[1].dir)
+ t.Require().Equal(relayFilesPath[1][:2], files[1].files)
+ t.Require().False(files[1].hasAll)
// write a fake meta file to first sub dir
fakeMeta := filepath.Join(relayDirsPath[0], utils.MetaFilename)
- c.Assert(os.WriteFile(fakeMeta, []byte{}, 0o666), check.IsNil)
+ t.Require().Nil(os.WriteFile(fakeMeta, []byte{}, 0o666))
// purge all relay log files in first and second sub dir, and some in third sub dir
err = purgeRelayFilesBeforeFileAndTime(log.L(), baseDir, t.uuids, safeRelay, safeTime)
- c.Assert(err, check.IsNil)
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
- c.Assert(utils.IsFileExists(relayFilesPath[1][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][1]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][2]), check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][0]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][2]))
}
diff --git a/dm/relay/purger_test.go b/dm/relay/purger_test.go
index 34872488e3..e90b8cb6d8 100644
--- a/dm/relay/purger_test.go
+++ b/dm/relay/purger_test.go
@@ -19,56 +19,62 @@ import (
"os"
"path/filepath"
"strings"
+ "testing"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pb"
"github.com/pingcap/tiflow/dm/pkg/streamer"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/suite"
)
-var _ = check.Suite(&testPurgerSuite{
- uuids: []string{
+func TestPurgerSuite(t *testing.T) {
+ suite.Run(t, new(testPurgerSuite))
+}
+
+type testPurgerSuite struct {
+ suite.Suite
+ uuids []string
+ relayFiles [][]string
+ activeRelayLog *streamer.RelayLogInfo
+}
+
+func (t *testPurgerSuite) SetupTest() {
+ t.uuids = []string{
"c6ae5afe-c7a3-11e8-a19d-0242ac130006.000001",
"e9540a0d-f16d-11e8-8cb7-0242ac130008.000002",
"195c342f-f46e-11e8-927c-0242ac150008.000003",
- },
- relayFiles: [][]string{
+ }
+ t.relayFiles = [][]string{
{"mysql-bin.000001", "mysql-bin.000002", "mysql-bin.000003"},
{"mysql-bin.000001", "mysql-bin.000002", "mysql-bin.000003"},
{"mysql-bin.000001", "mysql-bin.000002", "mysql-bin.000003"},
- },
- activeRelayLog: &streamer.RelayLogInfo{
+ }
+ t.activeRelayLog = &streamer.RelayLogInfo{
TaskName: fakeStrategyTaskName,
SubDir: "e9540a0d-f16d-11e8-8cb7-0242ac130008.000002",
SubDirSuffix: 2,
Filename: "mysql-bin.000003", // last in second sub dir
- },
-})
-
-type testPurgerSuite struct {
- uuids []string
- relayFiles [][]string
- activeRelayLog *streamer.RelayLogInfo
+ }
}
func (t *testPurgerSuite) EarliestActiveRelayLog() *streamer.RelayLogInfo {
return t.activeRelayLog
}
-func (t *testPurgerSuite) TestPurgeManuallyInactive(c *check.C) {
+func (t *testPurgerSuite) TestPurgeManuallyInactive() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// prepare files and directories
- relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(c, baseDir, -1, -1)
- c.Assert(len(relayDirsPath), check.Equals, 3)
- c.Assert(len(relayFilesPath), check.Equals, 3)
- c.Assert(len(relayFilesPath[2]), check.Equals, 3)
+ relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(baseDir, -1, -1)
+ t.Require().Equal(3, len(relayDirsPath))
+ t.Require().Equal(3, len(relayFilesPath))
+ t.Require().Equal(3, len(relayFilesPath[2]))
err := t.genUUIDIndexFile(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := config.PurgeConfig{
Interval: 0, // disable automatically
@@ -80,32 +86,32 @@ func (t *testPurgerSuite) TestPurgeManuallyInactive(c *check.C) {
Inactive: true,
}
err = purger.Do(context.Background(), req)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
- c.Assert(utils.IsFileExists(relayFilesPath[1][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][1]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][2]), check.IsTrue)
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][0]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][2]))
for _, fp := range relayFilesPath[2] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
}
-func (t *testPurgerSuite) TestPurgeManuallyTime(c *check.C) {
+func (t *testPurgerSuite) TestPurgeManuallyTime() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// prepare files and directories
- relayDirsPath, relayFilesPath, safeTime := t.genRelayLogFiles(c, baseDir, 1, 0)
- c.Assert(len(relayDirsPath), check.Equals, 3)
- c.Assert(len(relayFilesPath), check.Equals, 3)
- c.Assert(len(relayFilesPath[2]), check.Equals, 3)
+ relayDirsPath, relayFilesPath, safeTime := t.genRelayLogFiles(baseDir, 1, 0)
+ t.Require().Equal(3, len(relayDirsPath))
+ t.Require().Equal(3, len(relayFilesPath))
+ t.Require().Equal(3, len(relayFilesPath[2]))
err := t.genUUIDIndexFile(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := config.PurgeConfig{
Interval: 0, // disable automatically
@@ -117,32 +123,32 @@ func (t *testPurgerSuite) TestPurgeManuallyTime(c *check.C) {
Time: safeTime.Unix(),
}
err = purger.Do(context.Background(), req)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
- c.Assert(utils.IsFileExists(relayFilesPath[1][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][1]), check.IsTrue)
- c.Assert(utils.IsFileExists(relayFilesPath[1][2]), check.IsTrue)
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][0]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][2]))
for _, fp := range relayFilesPath[2] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
}
-func (t *testPurgerSuite) TestPurgeManuallyFilename(c *check.C) {
+func (t *testPurgerSuite) TestPurgeManuallyFilename() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// prepare files and directories
- relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(c, baseDir, -1, -1)
- c.Assert(len(relayDirsPath), check.Equals, 3)
- c.Assert(len(relayFilesPath), check.Equals, 3)
- c.Assert(len(relayFilesPath[2]), check.Equals, 3)
+ relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(baseDir, -1, -1)
+ t.Require().Equal(3, len(relayDirsPath))
+ t.Require().Equal(3, len(relayFilesPath))
+ t.Require().Equal(3, len(relayFilesPath[2]))
err := t.genUUIDIndexFile(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := config.PurgeConfig{
Interval: 0, // disable automatically
@@ -155,35 +161,35 @@ func (t *testPurgerSuite) TestPurgeManuallyFilename(c *check.C) {
SubDir: t.uuids[0],
}
err = purger.Do(context.Background(), req)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
+ t.Require().True(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
- c.Assert(utils.IsFileExists(relayFilesPath[0][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[0][1]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[0][2]), check.IsTrue)
+ t.Require().False(utils.IsFileExists(relayFilesPath[0][0]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[0][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[0][2]))
for _, fp := range relayFilesPath[1] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
for _, fp := range relayFilesPath[2] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
}
-func (t *testPurgerSuite) TestPurgeAutomaticallyTime(c *check.C) {
+func (t *testPurgerSuite) TestPurgeAutomaticallyTime() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// prepare files and directories
- relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(c, baseDir, -1, -1)
- c.Assert(len(relayDirsPath), check.Equals, 3)
- c.Assert(len(relayFilesPath), check.Equals, 3)
- c.Assert(len(relayFilesPath[2]), check.Equals, 3)
+ relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(baseDir, -1, -1)
+ t.Require().Equal(3, len(relayDirsPath))
+ t.Require().Equal(3, len(relayFilesPath))
+ t.Require().Equal(3, len(relayFilesPath[2]))
err := t.genUUIDIndexFile(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := config.PurgeConfig{
Interval: 1, // enable automatically
@@ -196,7 +202,7 @@ func (t *testPurgerSuite) TestPurgeAutomaticallyTime(c *check.C) {
for _, fps := range relayFilesPath {
for _, fp := range fps {
err = os.Chtimes(fp, aTime, mTime)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
}
@@ -205,33 +211,33 @@ func (t *testPurgerSuite) TestPurgeAutomaticallyTime(c *check.C) {
time.Sleep(2 * time.Second) // sleep enough time to purge all inactive relay log files
purger.Close()
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
- c.Assert(utils.IsFileExists(relayFilesPath[1][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][1]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][2]), check.IsTrue)
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][0]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][2]))
for _, fp := range relayFilesPath[2] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
}
-func (t *testPurgerSuite) TestPurgeAutomaticallySpace(c *check.C) {
+func (t *testPurgerSuite) TestPurgeAutomaticallySpace() {
// create relay log dir
- baseDir := c.MkDir()
+ baseDir := t.T().TempDir()
// prepare files and directories
- relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(c, baseDir, -1, -1)
- c.Assert(len(relayDirsPath), check.Equals, 3)
- c.Assert(len(relayFilesPath), check.Equals, 3)
- c.Assert(len(relayFilesPath[2]), check.Equals, 3)
+ relayDirsPath, relayFilesPath, _ := t.genRelayLogFiles(baseDir, -1, -1)
+ t.Require().Equal(3, len(relayDirsPath))
+ t.Require().Equal(3, len(relayFilesPath))
+ t.Require().Equal(3, len(relayFilesPath[2]))
err := t.genUUIDIndexFile(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
storageSize, err := utils.GetStorageSize(baseDir)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := config.PurgeConfig{
Interval: 1, // enable automatically
@@ -243,19 +249,19 @@ func (t *testPurgerSuite) TestPurgeAutomaticallySpace(c *check.C) {
time.Sleep(2 * time.Second) // sleep enough time to purge all inactive relay log files
purger.Close()
- c.Assert(utils.IsDirExists(relayDirsPath[0]), check.IsFalse)
- c.Assert(utils.IsDirExists(relayDirsPath[1]), check.IsTrue)
- c.Assert(utils.IsDirExists(relayDirsPath[2]), check.IsTrue)
+ t.Require().False(utils.IsDirExists(relayDirsPath[0]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[1]))
+ t.Require().True(utils.IsDirExists(relayDirsPath[2]))
- c.Assert(utils.IsFileExists(relayFilesPath[1][0]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][1]), check.IsFalse)
- c.Assert(utils.IsFileExists(relayFilesPath[1][2]), check.IsTrue)
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][0]))
+ t.Require().False(utils.IsFileExists(relayFilesPath[1][1]))
+ t.Require().True(utils.IsFileExists(relayFilesPath[1][2]))
for _, fp := range relayFilesPath[2] {
- c.Assert(utils.IsFileExists(fp), check.IsTrue)
+ t.Require().True(utils.IsFileExists(fp))
}
}
-func (t *testPurgerSuite) genRelayLogFiles(c *check.C, baseDir string, safeTimeIdxI, safeTimeIdxJ int) ([]string, [][]string, time.Time) {
+func (t *testPurgerSuite) genRelayLogFiles(baseDir string, safeTimeIdxI, safeTimeIdxJ int) ([]string, [][]string, time.Time) {
var (
relayDirsPath = make([]string, 0, 3)
relayFilesPath = make([][]string, 0, 3)
@@ -265,7 +271,7 @@ func (t *testPurgerSuite) genRelayLogFiles(c *check.C, baseDir string, safeTimeI
for _, uuid := range t.uuids {
dir := filepath.Join(baseDir, uuid)
err := os.Mkdir(dir, 0o700)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
relayDirsPath = append(relayDirsPath, dir)
}
@@ -276,7 +282,7 @@ func (t *testPurgerSuite) genRelayLogFiles(c *check.C, baseDir string, safeTimeI
for j, fn := range t.relayFiles[i] {
fp := filepath.Join(dir, fn)
err2 := os.WriteFile(fp, []byte("meaningless file content"), 0o644)
- c.Assert(err2, check.IsNil)
+ t.Require().Nil(err2)
relayFilesPath[i] = append(relayFilesPath[i], fp)
if i == safeTimeIdxI && j == safeTimeIdxJ {
@@ -316,7 +322,7 @@ func (i *fakeInterceptor) ForbidPurge() (bool, string) {
return true, i.msg
}
-func (t *testPurgerSuite) TestPurgerInterceptor(c *check.C) {
+func (t *testPurgerSuite) TestPurgerInterceptor() {
cfg := config.PurgeConfig{}
interceptor := newFakeInterceptor()
@@ -326,6 +332,6 @@ func (t *testPurgerSuite) TestPurgerInterceptor(c *check.C) {
Inactive: true,
}
err := purger.Do(context.Background(), req)
- c.Assert(err, check.NotNil)
- c.Assert(strings.Contains(err.Error(), interceptor.msg), check.IsTrue)
+ t.Require().Error(err)
+ t.Require().True(strings.Contains(err.Error(), interceptor.msg))
}
diff --git a/dm/relay/relay_test.go b/dm/relay/relay_test.go
index ec6f3ffbc2..e13ccc5529 100644
--- a/dm/relay/relay_test.go
+++ b/dm/relay/relay_test.go
@@ -27,7 +27,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
"github.com/go-mysql-org/go-mysql/replication"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/failpoint"
"github.com/pingcap/tidb/pkg/parser"
@@ -38,22 +37,15 @@ import (
"github.com/pingcap/tiflow/dm/pkg/gtid"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/utils"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testRelaySuite{})
-
-func TestSuite(t *testing.T) {
- check.TestingT(t)
-}
-
-type testRelaySuite struct{}
-
-func newRelayCfg(c *check.C, flavor string) *Config {
+func newRelayCfg(t *testing.T, flavor string) *Config {
dbCfg := getDBConfigForTest()
return &Config{
EnableGTID: false, // position mode, so auto-positioning can work
Flavor: flavor,
- RelayDir: c.MkDir(),
+ RelayDir: t.TempDir(),
ServerID: 12321,
From: dbconfig.DBConfig{
Host: dbCfg.Host,
@@ -143,7 +135,7 @@ func (w *mockWriter) Flush() error {
return nil
}
-func (t *testRelaySuite) TestTryRecoverLatestFile(c *check.C) {
+func TestTryRecoverLatestFile(t *testing.T) {
var (
uuid = "24ecd093-8cec-11e9-aa0d-0242ac170002"
uuidWithSuffix = fmt.Sprintf("%s.000001", uuid)
@@ -156,90 +148,90 @@ func (t *testRelaySuite) TestTryRecoverLatestFile(c *check.C) {
startPos = gmysql.Position{Name: filename, Pos: 123}
parser2 = parser.New()
- relayCfg = newRelayCfg(c, gmysql.MySQLFlavor)
+ relayCfg = newRelayCfg(t, gmysql.MySQLFlavor)
r = NewRelay(relayCfg).(*Relay)
)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("406a3f61-690d-11e7-87c5-6c92bf46f384:1-122")`), check.IsNil)
+ require.NoError(t, failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("406a3f61-690d-11e7-87c5-6c92bf46f384:1-122")`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged")
cfg := getDBConfigForTest()
- conn.InitMockDB(c)
+ conn.InitMockDB(t)
db, err := conn.GetUpstreamDB(cfg)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
r.db = db
- c.Assert(r.Init(context.Background()), check.IsNil)
+ require.NoError(t, r.Init(context.Background()))
// purge old relay dir
f, err := os.Create(filepath.Join(r.cfg.RelayDir, "old_relay_log"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
f.Close()
- c.Assert(r.PurgeRelayDir(), check.IsNil)
+ require.NoError(t, r.PurgeRelayDir())
files, err := os.ReadDir(r.cfg.RelayDir)
- c.Assert(err, check.IsNil)
- c.Assert(files, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, files, 0)
- c.Assert(r.meta.Load(), check.IsNil)
+ require.NoError(t, r.meta.Load())
// no file specified, no need to recover
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
// save position into meta
- c.Assert(r.meta.AddDir(uuid, &startPos, nil, 0), check.IsNil)
+ require.Nil(t, r.meta.AddDir(uuid, &startPos, nil, 0))
// relay log file does not exists, no need to recover
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
// use a generator to generate some binlog events
previousGTIDSet, err := gtid.ParserGTID(relayCfg.Flavor, previousGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID1, err := gtid.ParserGTID(relayCfg.Flavor, latestGTIDStr1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID2, err := gtid.ParserGTID(relayCfg.Flavor, latestGTIDStr2)
- c.Assert(err, check.IsNil)
- g, events, data := genBinlogEventsWithGTIDs(c, relayCfg.Flavor, previousGTIDSet, latestGTID1, latestGTID2)
+ require.NoError(t, err)
+ g, events, data := genBinlogEventsWithGTIDs(t, relayCfg.Flavor, previousGTIDSet, latestGTID1, latestGTID2)
// write events into relay log file
err = os.WriteFile(filepath.Join(r.meta.Dir(), filename), data, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// all events/transactions are complete, no need to recover
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
// now, we will update position/GTID set in meta to latest location in relay logs
lastEvent := events[len(events)-1]
pos := startPos
pos.Pos = lastEvent.Header.LogPos
- t.verifyMetadata(c, r, uuidWithSuffix, pos, recoverGTIDSetStr, []string{uuidWithSuffix})
+ verifyMetadata(t, r, uuidWithSuffix, pos, recoverGTIDSetStr, []string{uuidWithSuffix})
// write some invalid data into the relay log file
f, err = os.OpenFile(filepath.Join(r.meta.Dir(), filename), os.O_WRONLY|os.O_APPEND, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write([]byte("invalid event data"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
f.Close()
// write a greater GTID sets in meta
greaterGITDSet, err := gtid.ParserGTID(relayCfg.Flavor, greaterGITDSetStr)
- c.Assert(err, check.IsNil)
- c.Assert(r.SaveMeta(startPos, greaterGITDSet), check.IsNil)
+ require.NoError(t, err)
+ require.Nil(t, r.SaveMeta(startPos, greaterGITDSet))
// invalid data truncated, meta updated
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
_, latestPos := r.meta.Pos()
- c.Assert(latestPos, check.DeepEquals, gmysql.Position{Name: filename, Pos: g.LatestPos})
+ require.Equal(t, gmysql.Position{Name: filename, Pos: g.LatestPos}, latestPos)
_, latestGTIDs := r.meta.GTID()
recoverGTIDSet, err := gtid.ParserGTID(relayCfg.Flavor, recoverGTIDSetStr)
- c.Assert(err, check.IsNil)
- c.Assert(latestGTIDs.Equal(recoverGTIDSet), check.IsTrue) // verifyMetadata is not enough
+ require.NoError(t, err)
+ require.True(t, latestGTIDs.Equal(recoverGTIDSet)) // verifyMetadata is not enough
// no relay log file need to recover
- c.Assert(r.SaveMeta(minCheckpoint, latestGTIDs), check.IsNil)
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.SaveMeta(minCheckpoint, latestGTIDs))
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
_, latestPos = r.meta.Pos()
- c.Assert(latestPos, check.DeepEquals, minCheckpoint)
+ require.Equal(t, minCheckpoint, latestPos)
_, latestGTIDs = r.meta.GTID()
- c.Assert(latestGTIDs.Contain(g.LatestGTID), check.IsTrue)
+ require.True(t, latestGTIDs.Contain(g.LatestGTID))
}
-func (t *testRelaySuite) TestTryRecoverMeta(c *check.C) {
+func TestTryRecoverMeta(t *testing.T) {
var (
uuid = "24ecd093-8cec-11e9-aa0d-0242ac170002"
previousGTIDSetStr = "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-14,53bfca22-690d-11e7-8a62-18ded7a37b78:1-495,406a3f61-690d-11e7-87c5-6c92bf46f384:123-456"
@@ -251,64 +243,64 @@ func (t *testRelaySuite) TestTryRecoverMeta(c *check.C) {
startPos = gmysql.Position{Name: filename, Pos: 123}
parser2 = parser.New()
- relayCfg = newRelayCfg(c, gmysql.MySQLFlavor)
+ relayCfg = newRelayCfg(t, gmysql.MySQLFlavor)
r = NewRelay(relayCfg).(*Relay)
)
cfg := getDBConfigForTest()
- conn.InitMockDB(c)
+ conn.InitMockDB(t)
db, err := conn.GetUpstreamDB(cfg)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
r.db = db
- c.Assert(r.Init(context.Background()), check.IsNil)
+ require.NoError(t, r.Init(context.Background()))
recoverGTIDSet, err := gtid.ParserGTID(relayCfg.Flavor, recoverGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
- c.Assert(r.meta.AddDir(uuid, &startPos, nil, 0), check.IsNil)
- c.Assert(r.meta.Load(), check.IsNil)
+ require.Nil(t, r.meta.AddDir(uuid, &startPos, nil, 0))
+ require.NoError(t, r.meta.Load())
// use a generator to generate some binlog events
previousGTIDSet, err := gtid.ParserGTID(relayCfg.Flavor, previousGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID1, err := gtid.ParserGTID(relayCfg.Flavor, latestGTIDStr1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID2, err := gtid.ParserGTID(relayCfg.Flavor, latestGTIDStr2)
- c.Assert(err, check.IsNil)
- g, _, data := genBinlogEventsWithGTIDs(c, relayCfg.Flavor, previousGTIDSet, latestGTID1, latestGTID2)
+ require.NoError(t, err)
+ g, _, data := genBinlogEventsWithGTIDs(t, relayCfg.Flavor, previousGTIDSet, latestGTID1, latestGTID2)
// write events into relay log file
err = os.WriteFile(filepath.Join(r.meta.Dir(), filename), data, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// write some invalid data into the relay log file to trigger a recover.
f, err := os.OpenFile(filepath.Join(r.meta.Dir(), filename), os.O_WRONLY|os.O_APPEND, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write([]byte("invalid event data"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
f.Close()
// recover with empty GTIDs.
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("")`), check.IsNil)
+ require.NoError(t, failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged", `return("")`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/conn/GetGTIDPurged")
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
_, latestPos := r.meta.Pos()
- c.Assert(latestPos, check.DeepEquals, gmysql.Position{Name: filename, Pos: g.LatestPos})
+ require.Equal(t, gmysql.Position{Name: filename, Pos: g.LatestPos}, latestPos)
_, latestGTIDs := r.meta.GTID()
- c.Assert(latestGTIDs.Equal(recoverGTIDSet), check.IsTrue)
+ require.True(t, latestGTIDs.Equal(recoverGTIDSet))
// write some invalid data into the relay log file again.
f, err = os.OpenFile(filepath.Join(r.meta.Dir(), filename), os.O_WRONLY|os.O_APPEND, 0o600)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write([]byte("invalid event data"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
f.Close()
// recover with the subset of GTIDs (previous GTID set).
- c.Assert(r.SaveMeta(startPos, previousGTIDSet), check.IsNil)
- c.Assert(r.tryRecoverLatestFile(context.Background(), parser2), check.IsNil)
+ require.Nil(t, r.SaveMeta(startPos, previousGTIDSet))
+ require.Nil(t, r.tryRecoverLatestFile(context.Background(), parser2))
_, latestPos = r.meta.Pos()
- c.Assert(latestPos, check.DeepEquals, gmysql.Position{Name: filename, Pos: g.LatestPos})
+ require.Equal(t, gmysql.Position{Name: filename, Pos: g.LatestPos}, latestPos)
_, latestGTIDs = r.meta.GTID()
- c.Assert(latestGTIDs.Equal(recoverGTIDSet), check.IsTrue)
+ require.True(t, latestGTIDs.Equal(recoverGTIDSet))
}
type dummyListener bool
@@ -317,27 +309,27 @@ func (d *dummyListener) OnEvent(e *replication.BinlogEvent) {
*d = true
}
-func (t *testRelaySuite) TestListener(c *check.C) {
+func TestListener(t *testing.T) {
relay := NewRelay(&Config{}).(*Relay)
- c.Assert(len(relay.listeners), check.Equals, 0)
+ require.Equal(t, 0, len(relay.listeners))
lis := dummyListener(false)
relay.RegisterListener(&lis)
- c.Assert(len(relay.listeners), check.Equals, 1)
+ require.Equal(t, 1, len(relay.listeners))
relay.notify(nil)
- c.Assert(bool(lis), check.Equals, true)
+ require.Equal(t, true, bool(lis))
relay.UnRegisterListener(&lis)
- c.Assert(len(relay.listeners), check.Equals, 0)
+ require.Equal(t, 0, len(relay.listeners))
lis = false
relay.notify(nil)
- c.Assert(bool(lis), check.Equals, false)
+ require.Equal(t, false, bool(lis))
}
// genBinlogEventsWithGTIDs generates some binlog events used by testFileUtilSuite and testFileWriterSuite.
// now, its generated events including 3 DDL and 10 DML.
-func genBinlogEventsWithGTIDs(c *check.C, flavor string, previousGTIDSet, latestGTID1, latestGTID2 gmysql.GTIDSet) (*event.Generator, []*replication.BinlogEvent, []byte) {
+func genBinlogEventsWithGTIDs(t *testing.T, flavor string, previousGTIDSet, latestGTID1, latestGTID2 gmysql.GTIDSet) (*event.Generator, []*replication.BinlogEvent, []byte) {
var (
serverID uint32 = 11
latestPos uint32
@@ -349,11 +341,11 @@ func genBinlogEventsWithGTIDs(c *check.C, flavor string, previousGTIDSet, latest
// use a binlog event generator to generate some binlog events.
g, err := event.NewGenerator(flavor, serverID, latestPos, latestGTID1, previousGTIDSet, latestXID)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// file header with FormatDescriptionEvent and PreviousGTIDsEvent
events, data, err := g.GenFileHeader(0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
allEvents = append(allEvents, events...)
allData.Write(data)
@@ -366,7 +358,7 @@ func genBinlogEventsWithGTIDs(c *check.C, flavor string, previousGTIDSet, latest
}
for _, query := range queries {
events, data, err = g.GenDDLEvents("db", query, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
allEvents = append(allEvents, events...)
allData.Write(data)
}
@@ -393,7 +385,7 @@ func genBinlogEventsWithGTIDs(c *check.C, flavor string, previousGTIDSet, latest
},
}
events, data, err = g.GenDMLEvents(eventType, dmlData, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
allEvents = append(allEvents, events...)
allData.Write(data)
}
@@ -401,13 +393,13 @@ func genBinlogEventsWithGTIDs(c *check.C, flavor string, previousGTIDSet, latest
return g, allEvents, allData.Bytes()
}
-func (t *testRelaySuite) TestHandleEvent(c *check.C) {
+func TestHandleEvent(t *testing.T) {
// NOTE: we can test metrics later.
var (
reader2 = &mockReader{}
parser2 = parser.New()
writer2 = &mockWriter{}
- relayCfg = newRelayCfg(c, gmysql.MariaDBFlavor)
+ relayCfg = newRelayCfg(t, gmysql.MariaDBFlavor)
r = NewRelay(relayCfg).(*Relay)
eventHeader = &replication.EventHeader{
@@ -423,14 +415,14 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
r.writer = writer2
cfg := getDBConfigForTest()
- conn.InitMockDB(c)
+ conn.InitMockDB(t)
db, err := conn.GetUpstreamDB(cfg)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
r.db = db
- c.Assert(r.Init(context.Background()), check.IsNil)
+ require.NoError(t, r.Init(context.Background()))
// NOTE: we can mock meta later.
- c.Assert(r.meta.Load(), check.IsNil)
- c.Assert(r.meta.AddDir("24ecd093-8cec-11e9-aa0d-0242ac170002", nil, nil, 0), check.IsNil)
+ require.NoError(t, r.meta.Load())
+ require.Nil(t, r.meta.AddDir("24ecd093-8cec-11e9-aa0d-0242ac170002", nil, nil, 0))
// attach GTID sets to QueryEv
queryEv2 := queryEv.Event.(*replication.QueryEvent)
@@ -444,7 +436,7 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
replication.ErrNeedSyncAgain,
} {
handleErr := r.handleEvents(context.Background(), reader2, parser2)
- c.Assert(errors.Cause(handleErr), check.Equals, reader2.err)
+ require.Equal(t, reader2.err, errors.Cause(handleErr))
}
// reader return fake rotate event
@@ -454,26 +446,26 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
writer2.err = errors.New("writer error for testing")
// return with the annotated writer error
err = r.handleEvents(context.Background(), reader2, parser2)
- c.Assert(errors.Cause(err), check.Equals, writer2.err)
+ require.Equal(t, writer2.err, errors.Cause(err))
// after handle rotate event, we save and flush the meta immediately
- c.Assert(r.meta.Dirty(), check.Equals, false)
+ require.Equal(t, false, r.meta.Dirty())
{
lm := r.meta.(*LocalMeta)
- c.Assert(lm.BinLogName, check.Equals, "mysql-bin.666888")
- c.Assert(lm.BinLogPos, check.Equals, uint32(1234))
+ require.Equal(t, "mysql-bin.666888", lm.BinLogName)
+ require.Equal(t, uint32(1234), lm.BinLogPos)
filename := filepath.Join(lm.baseDir, lm.currentSubDir, utils.MetaFilename)
lm2 := &LocalMeta{}
_, err2 := toml.DecodeFile(filename, lm2)
- c.Assert(err2, check.IsNil)
- c.Assert(lm2.BinLogName, check.Equals, "mysql-bin.666888")
- c.Assert(lm2.BinLogPos, check.Equals, uint32(1234))
+ require.Nil(t, err2)
+ require.Equal(t, "mysql-bin.666888", lm2.BinLogName)
+ require.Equal(t, uint32(1234), lm2.BinLogPos)
}
{
lm := r.meta.(*LocalMeta)
backupUUID := lm.currentSubDir
lm.currentSubDir = "not exist"
err = r.handleEvents(context.Background(), reader2, parser2)
- c.Assert(os.IsNotExist(errors.Cause(err)), check.Equals, true)
+ require.Equal(t, true, os.IsNotExist(errors.Cause(err)))
lm.currentSubDir = backupUUID
}
@@ -485,22 +477,22 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
writer2.err = errors.New("writer error for testing")
// return with the annotated writer error
err = r.handleEvents(context.Background(), reader2, parser2)
- c.Assert(errors.Cause(err), check.Equals, writer2.err)
- c.Assert(r.meta.Dirty(), check.Equals, false)
+ require.Equal(t, writer2.err, errors.Cause(err))
+ require.Equal(t, false, r.meta.Dirty())
// writer without error
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()
writer2.err = nil
err = r.handleEvents(ctx, reader2, parser2) // returned when ctx timeout
- c.Assert(errors.Cause(err), check.Equals, ctx.Err())
+ require.Equal(t, ctx.Err(), errors.Cause(err))
// check written event
- c.Assert(writer2.latestEvent, check.Equals, reader2.result.Event)
+ require.Equal(t, reader2.result.Event, writer2.latestEvent)
// check meta
_, pos := r.meta.Pos()
_, gs := r.meta.GTID()
- c.Assert(pos, check.DeepEquals, binlogPos)
- c.Assert(gs.String(), check.Equals, "") // no GTID sets in event yet
+ require.Equal(t, binlogPos, pos)
+ require.Equal(t, "", gs.String()) // no GTID sets in event yet
ctx2, cancel2 := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel2()
@@ -508,15 +500,15 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
// write a QueryEvent with GTID sets
reader2.result.Event = queryEv
err = r.handleEvents(ctx2, reader2, parser2)
- c.Assert(errors.Cause(err), check.Equals, ctx.Err())
+ require.Equal(t, ctx.Err(), errors.Cause(err))
// check written event
- c.Assert(writer2.latestEvent, check.Equals, reader2.result.Event)
+ require.Equal(t, reader2.result.Event, writer2.latestEvent)
// check meta
_, pos = r.meta.Pos()
_, gs = r.meta.GTID()
- c.Assert(pos.Name, check.Equals, binlogPos.Name)
- c.Assert(pos.Pos, check.Equals, queryEv.Header.LogPos)
- c.Assert(gs, check.DeepEquals, queryEv2.GSet) // got GTID sets
+ require.Equal(t, binlogPos.Name, pos.Name)
+ require.Equal(t, queryEv.Header.LogPos, pos.Pos)
+ require.Equal(t, queryEv2.GSet, gs) // got GTID sets
// transformer return ignorable for the event
reader2.err = nil
@@ -527,11 +519,11 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
ctx4, cancel4 := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel4()
err = r.handleEvents(ctx4, reader2, parser2)
- c.Assert(errors.Cause(err), check.Equals, ctx.Err())
+ require.Equal(t, ctx.Err(), errors.Cause(err))
select {
case <-ctx4.Done():
default:
- c.Fatalf("ignorable event for transformer not ignored")
+ t.Fatalf("ignorable event for transformer not ignored")
}
// writer return ignorable for the event
@@ -540,32 +532,32 @@ func (t *testRelaySuite) TestHandleEvent(c *check.C) {
ctx5, cancel5 := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel5()
err = r.handleEvents(ctx5, reader2, parser2)
- c.Assert(errors.Cause(err), check.Equals, ctx.Err())
+ require.Equal(t, ctx.Err(), errors.Cause(err))
select {
case <-ctx5.Done():
default:
- c.Fatalf("ignorable event for writer not ignored")
+ t.Fatalf("ignorable event for writer not ignored")
}
}
-func (t *testRelaySuite) TestReSetupMeta(c *check.C) {
+func TestReSetupMeta(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), conn.DefaultDBTimeout)
defer cancel()
var (
- relayCfg = newRelayCfg(c, gmysql.MySQLFlavor)
+ relayCfg = newRelayCfg(t, gmysql.MySQLFlavor)
r = NewRelay(relayCfg).(*Relay)
)
cfg := getDBConfigForTest()
- mockDB := conn.InitMockDB(c)
+ mockDB := conn.InitMockDB(t)
db, err := conn.GetUpstreamDB(cfg)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
r.db = db
- c.Assert(r.Init(context.Background()), check.IsNil)
+ require.NoError(t, r.Init(context.Background()))
// empty metadata
- c.Assert(r.meta.Load(), check.IsNil)
- t.verifyMetadata(c, r, "", minCheckpoint, "", nil)
+ require.NoError(t, r.meta.Load())
+ verifyMetadata(t, r, "", minCheckpoint, "", nil)
// open connected DB and get its UUID
defer func() {
@@ -574,36 +566,36 @@ func (t *testRelaySuite) TestReSetupMeta(c *check.C) {
}()
mockGetServerUUID(mockDB)
uuid, err := conn.GetServerUUID(tcontext.NewContext(ctx, log.L()), r.db, r.cfg.Flavor)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// re-setup meta with start pos adjusted
r.cfg.EnableGTID = true
r.cfg.BinlogGTID = "24ecd093-8cec-11e9-aa0d-0242ac170002:1-23"
r.cfg.BinLogName = "mysql-bin.000005"
- c.Assert(r.setSyncConfig(), check.IsNil)
+ require.NoError(t, r.setSyncConfig())
// all adjusted gset should be empty since we didn't flush logs
emptyGTID, err := gtid.ParserGTID(r.cfg.Flavor, "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
mockGetServerUUID(mockDB)
mockGetRandomServerID(mockDB)
// mock AddGSetWithPurged
mockDB.ExpectQuery("select @@GLOBAL.gtid_purged").WillReturnRows(sqlmock.NewRows([]string{"@@GLOBAL.gtid_purged"}).AddRow(""))
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/binlog/reader/MockGetEmptyPreviousGTIDFromGTIDSet", "return()"), check.IsNil)
+ require.NoError(t, failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/binlog/reader/MockGetEmptyPreviousGTIDFromGTIDSet", "return()"))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/binlog/reader/MockGetEmptyPreviousGTIDFromGTIDSet")
- c.Assert(r.reSetupMeta(ctx), check.IsNil)
+ require.NoError(t, r.reSetupMeta(ctx))
uuid001 := fmt.Sprintf("%s.000001", uuid)
- t.verifyMetadata(c, r, uuid001, gmysql.Position{Name: r.cfg.BinLogName, Pos: 4}, emptyGTID.String(), []string{uuid001})
+ verifyMetadata(t, r, uuid001, gmysql.Position{Name: r.cfg.BinLogName, Pos: 4}, emptyGTID.String(), []string{uuid001})
// re-setup meta again, often happen when connecting a server behind a VIP.
mockGetServerUUID(mockDB)
mockGetRandomServerID(mockDB)
mockDB.ExpectQuery("select @@GLOBAL.gtid_purged").WillReturnRows(sqlmock.NewRows([]string{"@@GLOBAL.gtid_purged"}).AddRow(""))
- c.Assert(r.reSetupMeta(ctx), check.IsNil)
+ require.NoError(t, r.reSetupMeta(ctx))
uuid002 := fmt.Sprintf("%s.000002", uuid)
- t.verifyMetadata(c, r, uuid002, minCheckpoint, emptyGTID.String(), []string{uuid001, uuid002})
+ verifyMetadata(t, r, uuid002, minCheckpoint, emptyGTID.String(), []string{uuid001, uuid002})
r.cfg.BinLogName = "mysql-bin.000002"
r.cfg.BinlogGTID = "24ecd093-8cec-11e9-aa0d-0242ac170002:1-50,24ecd093-8cec-11e9-aa0d-0242ac170003:1-50"
@@ -611,37 +603,37 @@ func (t *testRelaySuite) TestReSetupMeta(c *check.C) {
mockGetServerUUID(mockDB)
mockGetRandomServerID(mockDB)
mockDB.ExpectQuery("select @@GLOBAL.gtid_purged").WillReturnRows(sqlmock.NewRows([]string{"@@GLOBAL.gtid_purged"}).AddRow(""))
- c.Assert(r.reSetupMeta(ctx), check.IsNil)
- t.verifyMetadata(c, r, uuid002, gmysql.Position{Name: r.cfg.BinLogName, Pos: 4}, emptyGTID.String(), []string{uuid002})
+ require.NoError(t, r.reSetupMeta(ctx))
+ verifyMetadata(t, r, uuid002, gmysql.Position{Name: r.cfg.BinLogName, Pos: 4}, emptyGTID.String(), []string{uuid002})
// re-setup meta again, often happen when connecting a server behind a VIP.
mockGetServerUUID(mockDB)
mockGetRandomServerID(mockDB)
mockDB.ExpectQuery("select @@GLOBAL.gtid_purged").WillReturnRows(sqlmock.NewRows([]string{"@@GLOBAL.gtid_purged"}).AddRow(""))
- c.Assert(r.reSetupMeta(ctx), check.IsNil)
+ require.NoError(t, r.reSetupMeta(ctx))
uuid003 := fmt.Sprintf("%s.000003", uuid)
- t.verifyMetadata(c, r, uuid003, minCheckpoint, emptyGTID.String(), []string{uuid002, uuid003})
- c.Assert(mockDB.ExpectationsWereMet(), check.IsNil)
+ verifyMetadata(t, r, uuid003, minCheckpoint, emptyGTID.String(), []string{uuid002, uuid003})
+ require.NoError(t, mockDB.ExpectationsWereMet())
}
-func (t *testRelaySuite) verifyMetadata(c *check.C, r *Relay, uuidExpected string,
+func verifyMetadata(t *testing.T, r *Relay, uuidExpected string,
posExpected gmysql.Position, gsStrExpected string, uuidsExpected []string,
) {
uuid, pos := r.meta.Pos()
_, gs := r.meta.GTID()
gsExpected, err := gtid.ParserGTID(gmysql.MySQLFlavor, gsStrExpected)
- c.Assert(err, check.IsNil)
- c.Assert(uuid, check.Equals, uuidExpected)
- c.Assert(pos, check.DeepEquals, posExpected)
- c.Assert(gs.Equal(gsExpected), check.IsTrue)
+ require.NoError(t, err)
+ require.Equal(t, uuidExpected, uuid)
+ require.Equal(t, posExpected, pos)
+ require.True(t, gs.Equal(gsExpected))
indexFile := filepath.Join(r.cfg.RelayDir, utils.UUIDIndexFilename)
UUIDs, err := utils.ParseUUIDIndex(indexFile)
- c.Assert(err, check.IsNil)
- c.Assert(UUIDs, check.DeepEquals, uuidsExpected)
+ require.NoError(t, err)
+ require.Equal(t, uuidsExpected, UUIDs)
}
-func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
+func TestPreprocessEvent(t *testing.T) {
type Case struct {
event *replication.BinlogEvent
result preprocessResult
@@ -665,7 +657,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
nextLogName := "mysql-bin.000123"
position := uint64(4)
ev, err := event.GenRotateEvent(header, latestPos, []byte(nextLogName), position)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
cases = append(cases, Case{
event: ev,
result: preprocessResult{
@@ -677,7 +669,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// fake RotateEvent with zero timestamp
header.Timestamp = 0
ev, err = event.GenRotateEvent(header, latestPos, []byte(nextLogName), position)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
cases = append(cases, Case{
event: ev,
result: preprocessResult{
@@ -690,7 +682,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// fake RotateEvent with zero logPos
fakeRotateHeader := *header
ev, err = event.GenRotateEvent(&fakeRotateHeader, latestPos, []byte(nextLogName), position)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ev.Header.LogPos = 0 // set to zero
cases = append(cases, Case{
event: ev,
@@ -703,7 +695,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// QueryEvent for DDL
query := []byte("CREATE TABLE test_tbl (c1 INT)")
ev, err = event.GenQueryEvent(header, latestPos, 0, 0, 0, nil, schema, query)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ev.Event.(*replication.QueryEvent).GSet = gtidSet // set GTIDs manually
cases = append(cases, Case{
event: ev,
@@ -717,7 +709,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// QueryEvent for non-DDL
query = []byte("BEGIN")
ev, err = event.GenQueryEvent(header, latestPos, 0, 0, 0, nil, schema, query)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
cases = append(cases, Case{
event: ev,
result: preprocessResult{
@@ -728,7 +720,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// XIDEvent
xid := uint64(135)
ev, err = event.GenXIDEvent(header, latestPos, xid)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ev.Event.(*replication.XIDEvent).GSet = gtidSet // set GTIDs manually
cases = append(cases, Case{
event: ev,
@@ -763,7 +755,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// other event type without LOG_EVENT_ARTIFICIAL_F
ev, err = event.GenCommonGTIDEvent(gmysql.MySQLFlavor, header.ServerID, latestPos, gtidSet, false, 0)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
cases = append(cases, Case{
event: ev,
result: preprocessResult{
@@ -773,7 +765,7 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
// other event type with LOG_EVENT_ARTIFICIAL_F
ev, err = event.GenTableMapEvent(header, latestPos, 0, []byte("testdb"), []byte("testtbl"), []byte("INT"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ev.Header.Flags |= replication.LOG_EVENT_ARTIFICIAL_F
cases = append(cases, Case{
event: ev,
@@ -785,13 +777,13 @@ func (t *testRelaySuite) TestPreprocessEvent(c *check.C) {
})
for _, cs := range cases {
- c.Assert(relay.preprocessEvent(cs.event, parser2), check.DeepEquals, cs.result)
+ require.Equal(t, cs.result, relay.preprocessEvent(cs.event, parser2))
}
}
-func (t *testRelaySuite) TestRecoverMySQL(c *check.C) {
+func TestRecoverMySQL(t *testing.T) {
var (
- relayDir = c.MkDir()
+ relayDir = t.TempDir()
filename = "test-mysql-bin.000001"
parser2 = parser.New()
flavor = gmysql.MySQLFlavor
@@ -804,147 +796,147 @@ func (t *testRelaySuite) TestRecoverMySQL(c *check.C) {
// different SIDs in GTID set
previousGTIDSet, err := gtid.ParserGTID(flavor, previousGTIDSetStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID1, err := gtid.ParserGTID(flavor, latestGTIDStr1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
latestGTID2, err := gtid.ParserGTID(flavor, latestGTIDStr2)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// generate binlog events
- g, _, baseData := genBinlogEventsWithGTIDs(c, flavor, previousGTIDSet, latestGTID1, latestGTID2)
+ g, _, baseData := genBinlogEventsWithGTIDs(t, flavor, previousGTIDSet, latestGTID1, latestGTID2)
// expected latest pos/GTID set
expectedPos := gmysql.Position{Name: filename, Pos: uint32(len(baseData))}
// 3 DDL + 10 DML
expectedGTIDsStr := "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-18,53bfca22-690d-11e7-8a62-18ded7a37b78:1-505,406a3f61-690d-11e7-87c5-6c92bf46f384:123-456,686e1ab6-c47e-11e7-a42c-6c92bf46f384:234-567"
expectedGTIDs, err := gtid.ParserGTID(flavor, expectedGTIDsStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// write the events to a file
fullName := filepath.Join(relayDir, filename)
err = os.WriteFile(fullName, baseData, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// try recover, but in fact do nothing
result, err := r.doRecovering(context.Background(), relayDir, filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsFalse)
- c.Assert(result.LatestPos, check.DeepEquals, expectedPos)
- c.Assert(result.LatestGTIDs, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.False(t, result.Truncated)
+ require.Equal(t, expectedPos, result.LatestPos)
+ require.Equal(t, expectedGTIDs, result.LatestGTIDs)
// check file size, whether no recovering operation applied
fs, err := os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData)))
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData)), fs.Size())
// generate another transaction, DDL
extraEvents, extraData, err := g.GenDDLEvents("db2", "CREATE DATABASE db2", 0)
- c.Assert(err, check.IsNil)
- c.Assert(extraEvents, check.HasLen, 2) // [GTID, Query]
+ require.NoError(t, err)
+ require.Len(t, extraEvents, 2) // [GTID, Query]
// write an incomplete event to the file
corruptData := extraEvents[0].RawData[:len(extraEvents[0].RawData)-2]
f, err := os.OpenFile(fullName, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, err = f.Write(corruptData)
- c.Assert(err, check.IsNil)
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, err)
+ require.NoError(t, f.Close())
// check file size, increased
fs, err = os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData)+len(corruptData)))
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData)+len(corruptData)), fs.Size())
// try recover, truncate the incomplete event
result, err = r.doRecovering(context.Background(), relayDir, filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsTrue)
- c.Assert(result.LatestPos, check.DeepEquals, expectedPos)
- c.Assert(result.LatestGTIDs, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.True(t, result.Truncated)
+ require.Equal(t, expectedPos, result.LatestPos)
+ require.Equal(t, expectedGTIDs, result.LatestGTIDs)
// check file size, truncated
fs, err = os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData)))
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData)), fs.Size())
// write an incomplete transaction
f, err = os.OpenFile(fullName, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
var extraLen int64
for i := 0; i < len(extraEvents)-1; i++ {
_, err = f.Write(extraEvents[i].RawData)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
extraLen += int64(len(extraEvents[i].RawData))
}
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, f.Close())
// check file size, increased
fs, err = os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData))+extraLen)
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData))+extraLen, fs.Size())
// try recover, truncate the incomplete transaction
result, err = r.doRecovering(context.Background(), relayDir, filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsTrue)
- c.Assert(result.LatestPos, check.DeepEquals, expectedPos)
- c.Assert(result.LatestGTIDs, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.True(t, result.Truncated)
+ require.Equal(t, expectedPos, result.LatestPos)
+ require.Equal(t, expectedGTIDs, result.LatestGTIDs)
// check file size, truncated
fs, err = os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData)))
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData)), fs.Size())
// write an completed transaction
f, err = os.OpenFile(fullName, os.O_WRONLY|os.O_APPEND, 0o644)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for i := 0; i < len(extraEvents); i++ {
_, err = f.Write(extraEvents[i].RawData)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
- c.Assert(f.Close(), check.IsNil)
+ require.NoError(t, f.Close())
// check file size, increased
fs, err = os.Stat(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fs.Size(), check.Equals, int64(len(baseData)+len(extraData)))
+ require.NoError(t, err)
+ require.Equal(t, int64(len(baseData)+len(extraData)), fs.Size())
// try recover, no operation applied
expectedPos.Pos += uint32(len(extraData))
// 4 DDL + 10 DML
expectedGTIDsStr = "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-18,53bfca22-690d-11e7-8a62-18ded7a37b78:1-506,406a3f61-690d-11e7-87c5-6c92bf46f384:123-456,686e1ab6-c47e-11e7-a42c-6c92bf46f384:234-567"
expectedGTIDs, err = gtid.ParserGTID(flavor, expectedGTIDsStr)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
result, err = r.doRecovering(context.Background(), relayDir, filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsFalse)
- c.Assert(result.LatestPos, check.DeepEquals, expectedPos)
- c.Assert(result.LatestGTIDs, check.DeepEquals, expectedGTIDs)
+ require.NoError(t, err)
+ require.False(t, result.Truncated)
+ require.Equal(t, expectedPos, result.LatestPos)
+ require.Equal(t, expectedGTIDs, result.LatestGTIDs)
// compare file data
var allData bytes.Buffer
allData.Write(baseData)
allData.Write(extraData)
fileData, err := os.ReadFile(fullName)
- c.Assert(err, check.IsNil)
- c.Assert(fileData, check.DeepEquals, allData.Bytes())
+ require.NoError(t, err)
+ require.Equal(t, allData.Bytes(), fileData)
}
-func (t *testRelaySuite) TestRecoverMySQLNone(c *check.C) {
- relayDir := c.MkDir()
+func TestRecoverMySQLNone(t *testing.T) {
+ relayDir := t.TempDir()
parser2 := parser.New()
r := NewRelay(&Config{Flavor: gmysql.MySQLFlavor}).(*Relay)
// no file specified to recover
result, err := r.doRecovering(context.Background(), relayDir, "", parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, result.Truncated)
filename := "mysql-bin.000001"
// file not exist, no need to recover
result, err = r.doRecovering(context.Background(), relayDir, filename, parser2)
- c.Assert(err, check.IsNil)
- c.Assert(result.Truncated, check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, result.Truncated)
}
diff --git a/dm/relay/remote_retry_test.go b/dm/relay/remote_retry_test.go
index a0611b132a..3c82d81bc7 100644
--- a/dm/relay/remote_retry_test.go
+++ b/dm/relay/remote_retry_test.go
@@ -16,25 +16,22 @@ package relay
import (
"context"
"errors"
+ "testing"
"time"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testReaderRetrySuite{})
-
-type testReaderRetrySuite struct{}
-
-func (t *testReaderRetrySuite) TestRetry(c *check.C) {
+func TestRetry(t *testing.T) {
rr, err := NewReaderRetry(ReaderRetryConfig{
BackoffRollback: 200 * time.Millisecond,
BackoffMax: 1 * time.Second,
BackoffMin: 1 * time.Millisecond,
BackoffFactor: 2,
})
- c.Assert(err, check.IsNil)
- c.Assert(rr, check.NotNil)
+ require.NoError(t, err)
+ require.NotNil(t, rr)
retryableErr := gmysql.ErrBadConn
unRetryableErr := errors.New("custom error")
@@ -42,28 +39,28 @@ func (t *testReaderRetrySuite) TestRetry(c *check.C) {
// check some times
for i := 0; i < 3; i++ {
- c.Assert(rr.Check(ctx, retryableErr), check.IsTrue)
+ require.True(t, rr.Check(ctx, retryableErr))
}
- c.Assert(rr.bf.Current(), check.Equals, 8*time.Millisecond)
+ require.Equal(t, 8*time.Millisecond, rr.bf.Current())
// check more times, until reach Max
for i := 0; i < 10; i++ {
- c.Assert(rr.Check(ctx, retryableErr), check.IsTrue)
+ require.True(t, rr.Check(ctx, retryableErr))
}
- c.Assert(rr.bf.Current(), check.Equals, rr.cfg.BackoffMax)
+ require.Equal(t, rr.cfg.BackoffMax, rr.bf.Current())
// sleep 1s
time.Sleep(1 * time.Second)
// check with rollback, rollback 5 times, forward 1 time
- c.Assert(rr.Check(ctx, retryableErr), check.IsTrue)
- c.Assert(rr.bf.Current(), check.Equals, 64*time.Millisecond)
+ require.True(t, rr.Check(ctx, retryableErr))
+ require.Equal(t, 64*time.Millisecond, rr.bf.Current())
// check un-retryable error
- c.Assert(rr.Check(ctx, unRetryableErr), check.IsFalse)
+ require.False(t, rr.Check(ctx, unRetryableErr))
// check with context timeout
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
defer cancel()
- c.Assert(rr.Check(ctx, retryableErr), check.IsFalse)
+ require.False(t, rr.Check(ctx, retryableErr))
}
diff --git a/dm/relay/streamer_test.go b/dm/relay/streamer_test.go
index d3825ee33f..e200b31363 100644
--- a/dm/relay/streamer_test.go
+++ b/dm/relay/streamer_test.go
@@ -15,24 +15,21 @@ package relay
import (
"context"
+ "testing"
"time"
"github.com/go-mysql-org/go-mysql/replication"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/pkg/binlog/event"
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testStreamerSuite{})
-
-type testStreamerSuite struct{}
-
-func (t *testStreamerSuite) TestStreamer(c *check.C) {
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(10000)"), check.IsNil)
+func TestStreamer(t *testing.T) {
+ require.NoError(t, failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(10000)"))
defer func() {
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"), check.IsNil)
+ require.NoError(t, failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"))
}()
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
@@ -44,75 +41,75 @@ func (t *testStreamerSuite) TestStreamer(c *check.C) {
ServerID: 11,
}
ev, err := event.GenFormatDescriptionEvent(header, 4)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// 1. get event and error
s := newLocalStreamer() // with buffer
s.ch <- ev
ev2, err := s.GetEvent(ctx)
- c.Assert(err, check.IsNil)
- c.Assert(ev2, check.DeepEquals, ev)
+ require.NoError(t, err)
+ require.Equal(t, ev, ev2)
// read error
errIn := errors.New("error use for streamer test 1")
s.ech <- errIn
ev2, err = s.GetEvent(ctx)
- c.Assert(err, check.Equals, errIn)
- c.Assert(ev2, check.IsNil)
+ require.Equal(t, errIn, err)
+ require.Nil(t, ev2)
// can not get event anymore because got error
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrNeedSyncAgain.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrNeedSyncAgain.Equal(err))
+ require.Nil(t, ev2)
// 2. close with error
s = newLocalStreamer()
errClose := errors.New("error use for streamer test 2")
s.closeWithError(errClose)
ev2, err = s.GetEvent(ctx)
- c.Assert(err, check.Equals, errClose)
- c.Assert(ev2, check.IsNil)
+ require.Equal(t, errClose, err)
+ require.Nil(t, ev2)
// can not get event anymore
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrNeedSyncAgain.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrNeedSyncAgain.Equal(err))
+ require.Nil(t, ev2)
// 3. close without error
s = newLocalStreamer()
s.close()
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrSyncClosed.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrSyncClosed.Equal(err))
+ require.Nil(t, ev2)
// can not get event anymore
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrNeedSyncAgain.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrNeedSyncAgain.Equal(err))
+ require.Nil(t, ev2)
// 4. close with nil error
s = newLocalStreamer()
s.closeWithError(nil)
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrSyncClosed.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrSyncClosed.Equal(err))
+ require.Nil(t, ev2)
// can not get event anymore
ev2, err = s.GetEvent(ctx)
- c.Assert(terror.ErrNeedSyncAgain.Equal(err), check.IsTrue)
- c.Assert(ev2, check.IsNil)
+ require.True(t, terror.ErrNeedSyncAgain.Equal(err))
+ require.Nil(t, ev2)
}
-func (t *testStreamerSuite) TestHeartbeat(c *check.C) {
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(1)"), check.IsNil)
+func TestHeartbeat(t *testing.T) {
+ require.NoError(t, failpoint.Enable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval", "return(1)"))
defer func() {
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"), check.IsNil)
+ require.NoError(t, failpoint.Disable("github.com/pingcap/tiflow/dm/relay/SetHeartbeatInterval"))
}()
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
s := newLocalStreamer()
ev, err := s.GetEvent(ctx)
- c.Assert(err, check.IsNil)
- c.Assert(ev.Header.EventType, check.Equals, replication.HEARTBEAT_EVENT)
+ require.NoError(t, err)
+ require.Equal(t, replication.HEARTBEAT_EVENT, ev.Header.EventType)
}
diff --git a/dm/relay/upstream_reader_test.go b/dm/relay/upstream_reader_test.go
index 022113552e..20fb6eae74 100644
--- a/dm/relay/upstream_reader_test.go
+++ b/dm/relay/upstream_reader_test.go
@@ -15,19 +15,16 @@ package relay
import (
"context"
+ "testing"
"time"
"github.com/go-mysql-org/go-mysql/replication"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/pkg/binlog/reader"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testRemoteReaderSuite{})
-
-type testRemoteReaderSuite struct{}
-
-func (t *testRemoteReaderSuite) TestInterface(c *check.C) {
+func TestInterface(t *testing.T) {
cases := []*replication.BinlogEvent{
{RawData: []byte{1}},
{RawData: []byte{2}},
@@ -43,26 +40,26 @@ func (t *testRemoteReaderSuite) TestInterface(c *check.C) {
// test with position
r := NewUpstreamReader(cfg)
- t.testInterfaceWithReader(c, r, cases)
+ testInterfaceWithReader(t, r, cases)
// test with GTID
cfg.EnableGTID = true
r = NewUpstreamReader(cfg)
- t.testInterfaceWithReader(c, r, cases)
+ testInterfaceWithReader(t, r, cases)
}
-func (t *testRemoteReaderSuite) testInterfaceWithReader(c *check.C, r Reader, cases []*replication.BinlogEvent) {
+func testInterfaceWithReader(t *testing.T, r Reader, cases []*replication.BinlogEvent) {
// replace underlying reader with a mock reader for testing
concreteR := r.(*upstreamReader)
- c.Assert(concreteR, check.NotNil)
+ require.NotNil(t, concreteR)
mockR := reader.NewMockReader()
concreteR.in = mockR
// start reader
err := r.Start()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = r.Start() // call multi times
- c.Assert(err, check.NotNil)
+ require.Error(t, err)
// getEvent by pushing event to mock reader
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
@@ -70,33 +67,33 @@ func (t *testRemoteReaderSuite) testInterfaceWithReader(c *check.C, r Reader, ca
concreteMR := mockR.(*reader.MockReader)
go func() {
for _, cs := range cases {
- c.Assert(concreteMR.PushEvent(ctx, cs), check.IsNil)
+ require.NoError(t, concreteMR.PushEvent(ctx, cs))
}
}()
obtained := make([]*replication.BinlogEvent, 0, len(cases))
for {
result, err2 := r.GetEvent(ctx)
- c.Assert(err2, check.IsNil)
+ require.Nil(t, err2)
obtained = append(obtained, result.Event)
if len(obtained) == len(cases) {
break
}
}
- c.Assert(obtained, check.DeepEquals, cases)
+ require.Equal(t, cases, obtained)
// close reader
err = r.Close()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = r.Close()
- c.Assert(err, check.NotNil) // call multi times
+ require.Error(t, err) // call multi times
// getEvent from a closed reader
result, err := r.GetEvent(ctx)
- c.Assert(err, check.NotNil)
- c.Assert(result.Event, check.IsNil)
+ require.Error(t, err)
+ require.Nil(t, result.Event)
}
-func (t *testRemoteReaderSuite) TestGetEventWithError(c *check.C) {
+func TestGetEventWithError(t *testing.T) {
cfg := &RConfig{
SyncConfig: replication.BinlogSyncerConfig{
ServerID: 101,
@@ -107,7 +104,7 @@ func (t *testRemoteReaderSuite) TestGetEventWithError(c *check.C) {
r := NewUpstreamReader(cfg)
// replace underlying reader with a mock reader for testing
concreteR := r.(*upstreamReader)
- c.Assert(concreteR, check.NotNil)
+ require.NotNil(t, concreteR)
mockR := reader.NewMockReader()
concreteR.in = mockR
@@ -122,7 +119,7 @@ func (t *testRemoteReaderSuite) TestGetEventWithError(c *check.C) {
}
err := r.Start()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// getEvent by pushing event to mock reader
ctx, cancel := context.WithCancel(context.Background())
@@ -130,18 +127,18 @@ func (t *testRemoteReaderSuite) TestGetEventWithError(c *check.C) {
concreteMR := mockR.(*reader.MockReader)
go func() {
for _, cs := range in {
- c.Assert(concreteMR.PushError(ctx, cs), check.IsNil)
+ require.NoError(t, concreteMR.PushError(ctx, cs))
}
}()
results := make([]error, 0, len(expected))
for {
_, err2 := r.GetEvent(ctx)
- c.Assert(err2, check.NotNil)
+ require.NotNil(t, err2)
results = append(results, errors.Cause(err2))
if err2 == errOther {
break // all received
}
}
- c.Assert(results, check.DeepEquals, expected)
+ require.Equal(t, expected, results)
}
diff --git a/dm/relay/util_test.go b/dm/relay/util_test.go
index fe829118fc..e9228afb2d 100644
--- a/dm/relay/util_test.go
+++ b/dm/relay/util_test.go
@@ -17,50 +17,47 @@ import (
"context"
"fmt"
"io"
+ "testing"
"github.com/DATA-DOG/go-sqlmock"
gmysql "github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/pkg/conn"
tcontext "github.com/pingcap/tiflow/dm/pkg/context"
"github.com/pingcap/tiflow/dm/pkg/log"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testUtilSuite{})
-
-type testUtilSuite struct{}
-
-func (t *testUtilSuite) TestIsNewServer(c *check.C) {
+func TestIsNewServer(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), conn.DefaultDBTimeout)
defer cancel()
- mockDB := conn.InitMockDB(c)
+ mockDB := conn.InitMockDB(t)
baseDB, err := conn.GetUpstreamDB(getDBConfigForTest())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
flavor := gmysql.MySQLFlavor
// no prevUUID, is new server.
isNew, err := isNewServer(ctx, "", baseDB, flavor)
- c.Assert(err, check.IsNil)
- c.Assert(isNew, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, isNew)
// different server
mockGetServerUUID(mockDB)
isNew, err = isNewServer(ctx, "not-exists-uuid.000001", baseDB, flavor)
- c.Assert(err, check.IsNil)
- c.Assert(isNew, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, isNew)
// the same server
mockGetServerUUID(mockDB)
currUUID, err := conn.GetServerUUID(tcontext.NewContext(ctx, log.L()), baseDB, flavor)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
mockGetServerUUID(mockDB)
isNew, err = isNewServer(ctx, fmt.Sprintf("%s.000001", currUUID), baseDB, flavor)
- c.Assert(err, check.IsNil)
- c.Assert(isNew, check.IsFalse)
- c.Assert(mockDB.ExpectationsWereMet(), check.IsNil)
+ require.NoError(t, err)
+ require.False(t, isNew)
+ require.NoError(t, mockDB.ExpectationsWereMet())
}
func mockGetServerUUID(mockDB sqlmock.Sqlmock) {
@@ -76,7 +73,7 @@ func mockGetRandomServerID(mockDB sqlmock.Sqlmock) {
sqlmock.NewRows([]string{"Variable_name", "Value"}).AddRow("server_id", "1"))
}
-func (t *testUtilSuite) TestGetNextUUID(c *check.C) {
+func TestGetNextUUID(t *testing.T) {
UUIDs := []string{
"b60868af-5a6f-11e9-9ea3-0242ac160006.000001",
"7acfedb5-3008-4fa2-9776-6bac42b025fe.000002",
@@ -129,16 +126,17 @@ func (t *testUtilSuite) TestGetNextUUID(c *check.C) {
for _, cs := range cases {
nu, nus, err := getNextRelaySubDir(cs.currUUID, cs.UUIDs)
if len(cs.errMsgReg) > 0 {
- c.Assert(err, check.ErrorMatches, cs.errMsgReg)
+ require.Error(t, err)
+ require.Regexp(t, cs.errMsgReg, err.Error())
} else {
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
- c.Assert(nu, check.Equals, cs.nextUUID)
- c.Assert(nus, check.Equals, cs.nextUUIDSuffix)
+ require.Equal(t, cs.nextUUID, nu)
+ require.Equal(t, cs.nextUUIDSuffix, nus)
}
}
-func (t *testUtilSuite) TestIsIgnorableParseError(c *check.C) {
+func TestIsIgnorableParseError(t *testing.T) {
cases := []struct {
err error
ignorable bool
@@ -166,6 +164,6 @@ func (t *testUtilSuite) TestIsIgnorableParseError(c *check.C) {
}
for _, cs := range cases {
- c.Assert(isIgnorableParseError(cs.err), check.Equals, cs.ignorable)
+ require.Equal(t, cs.ignorable, isIgnorableParseError(cs.err))
}
}
diff --git a/dm/syncer/causality_test.go b/dm/syncer/causality_test.go
index db7390c4d3..8e17d891c5 100644
--- a/dm/syncer/causality_test.go
+++ b/dm/syncer/causality_test.go
@@ -19,7 +19,6 @@ import (
"time"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
cdcmodel "github.com/pingcap/tiflow/cdc/model"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pkg/binlog"
@@ -31,7 +30,7 @@ import (
"github.com/stretchr/testify/require"
)
-func (s *testSyncerSuite) TestDetectConflict(c *check.C) {
+func (s *testSyncerSuite) TestDetectConflict() {
ca := &causality{
relation: newCausalityRelation(),
}
@@ -43,25 +42,25 @@ func (s *testSyncerSuite) TestDetectConflict(c *check.C) {
}
assertRelationsEq := func(expectMap map[string]string) {
- c.Assert(ca.relation.len(), check.Equals, len(expectMap))
+ s.Require().Equal(len(expectMap), ca.relation.len())
for k, expV := range expectMap {
v, ok := ca.relation.get(k)
- c.Assert(ok, check.IsTrue)
- c.Assert(v, check.Equals, expV)
+ s.Require().True(ok)
+ s.Require().Equal(expV, v)
}
}
- c.Assert(ca.detectConflict(caseData), check.IsFalse)
+ s.Require().False(ca.detectConflict(caseData))
ca.add(caseData)
assertRelationsEq(excepted)
- c.Assert(ca.detectConflict([]string{"test_4"}), check.IsFalse)
+ s.Require().False(ca.detectConflict([]string{"test_4"}))
ca.add([]string{"test_4"})
excepted["test_4"] = "test_4"
assertRelationsEq(excepted)
conflictData := []string{"test_4", "test_3"}
- c.Assert(ca.detectConflict(conflictData), check.IsTrue)
+ s.Require().True(ca.detectConflict(conflictData))
ca.relation.clear()
- c.Assert(ca.relation.len(), check.Equals, 0)
+ s.Require().Equal(0, ca.relation.len())
}
func TestCausality(t *testing.T) {
@@ -127,10 +126,10 @@ func TestCausality(t *testing.T) {
}
}
-func (s *testSyncerSuite) TestCasualityRelation(c *check.C) {
+func (s *testSyncerSuite) TestCasualityRelation() {
rm := newCausalityRelation()
- c.Assert(rm.len(), check.Equals, 0)
- c.Assert(len(rm.groups), check.Equals, 1)
+ s.Require().Equal(0, rm.len())
+ s.Require().Equal(1, len(rm.groups))
testCases := []struct {
key string
@@ -154,17 +153,17 @@ func (s *testSyncerSuite) TestCasualityRelation(c *check.C) {
rm.set(testcase.key, testcase.val)
}
- c.Assert(rm.len(), check.Equals, len(testCases))
+ s.Require().Equal(len(testCases), rm.len())
for _, testcase := range testCases {
val, ok := rm.get(testcase.key)
- c.Assert(ok, check.Equals, true)
- c.Assert(val, check.Equals, testcase.val)
+ s.Require().Equal(true, ok)
+ s.Require().Equal(testcase.val, val)
}
rm.rotate(1)
rm.gc(1)
- c.Assert(rm.len(), check.Equals, 0)
+ s.Require().Equal(0, rm.len())
// test gc max
for _, testcase := range testCases {
@@ -172,7 +171,7 @@ func (s *testSyncerSuite) TestCasualityRelation(c *check.C) {
}
rm.gc(math.MaxInt64)
- c.Assert(rm.len(), check.Equals, 0)
+ s.Require().Equal(0, rm.len())
// test with rotate
for index, testcase := range testCases {
@@ -180,27 +179,27 @@ func (s *testSyncerSuite) TestCasualityRelation(c *check.C) {
rm.rotate(int64(index))
}
- c.Assert(rm.len(), check.Equals, len(testCases))
+ s.Require().Equal(len(testCases), rm.len())
for _, testcase := range testCases {
val, ok := rm.get(testcase.key)
- c.Assert(ok, check.Equals, true)
- c.Assert(val, check.Equals, testcase.val)
+ s.Require().Equal(true, ok)
+ s.Require().Equal(testcase.val, val)
}
for index := range testCases {
rm.gc(int64(index))
for _, rmMap := range rm.groups[1:] {
- c.Assert(rmMap.prevFlushJobSeq, check.Not(check.Equals), int64(index))
+ s.Require().NotEqual(int64(index), rmMap.prevFlushJobSeq)
}
for ti := 0; ti < index; ti++ {
_, ok := rm.get(testCases[ti].key)
- c.Assert(ok, check.Equals, false)
+ s.Require().Equal(false, ok)
}
}
rm.clear()
- c.Assert(rm.len(), check.Equals, 0)
+ s.Require().Equal(0, rm.len())
}
diff --git a/dm/syncer/checkpoint_test.go b/dm/syncer/checkpoint_test.go
index 22159d2570..d921a6e08e 100644
--- a/dm/syncer/checkpoint_test.go
+++ b/dm/syncer/checkpoint_test.go
@@ -24,7 +24,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/log"
tidbddl "github.com/pingcap/tidb/pkg/ddl"
"github.com/pingcap/tidb/pkg/meta/metabuild"
@@ -42,6 +41,7 @@ import (
"github.com/pingcap/tiflow/dm/pkg/schema"
"github.com/pingcap/tiflow/dm/syncer/dbconn"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"go.uber.org/zap/zapcore"
)
@@ -56,15 +56,14 @@ var (
deleteSchemaPointSQL = ""
)
-var _ = check.Suite(&testCheckpointSuite{})
-
type testCheckpointSuite struct {
+ suite.Suite
cfg *config.SubTaskConfig
mock sqlmock.Sqlmock
tracker *schema.Tracker
}
-func (s *testCheckpointSuite) SetUpSuite(c *check.C) {
+func (s *testCheckpointSuite) SetupSuite() {
s.cfg = &config.SubTaskConfig{
ServerID: 101,
MetaSchema: "test",
@@ -76,10 +75,10 @@ func (s *testCheckpointSuite) SetUpSuite(c *check.C) {
var err error
s.tracker, err = schema.NewTestTracker(context.Background(), s.cfg.Name, nil, dlog.L())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *testCheckpointSuite) TestUpTest(c *check.C) {
+func (s *testCheckpointSuite) TestUpTest() {
s.tracker.Reset()
}
@@ -94,7 +93,7 @@ func (s *testCheckpointSuite) prepareCheckPointSQL() {
}
// this test case uses sqlmock to simulate all SQL operations in tests.
-func (s *testCheckpointSuite) TestCheckPoint(c *check.C) {
+func (s *testCheckpointSuite) TestCheckPoint() {
tctx := tcontext.Background()
cp := NewRemoteCheckPoint(tctx, s.cfg, nil, cpid)
@@ -105,7 +104,7 @@ func (s *testCheckpointSuite) TestCheckPoint(c *check.C) {
var err error
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.mock = mock
s.prepareCheckPointSQL()
@@ -121,33 +120,33 @@ func (s *testCheckpointSuite) TestCheckPoint(c *check.C) {
mock.ExpectCommit()
dbConn, err := db.Conn(tcontext.Background().Context())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
conn := dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{}))
cp.(*RemoteCheckPoint).dbConn = conn
err = cp.(*RemoteCheckPoint).prepare(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.Clear(tctx), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(cp.Clear(tctx))
// test operation for global checkpoint
- s.testGlobalCheckPoint(c, cp)
+ s.testGlobalCheckPoint(cp)
// test operation for table checkpoint
- s.testTableCheckPoint(c, cp)
+ s.testTableCheckPoint(cp)
}
-func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
+func (s *testCheckpointSuite) testGlobalCheckPoint(cp CheckPoint) {
tctx := tcontext.Background()
// global checkpoint init to min
- c.Assert(cp.GlobalPoint().Position, check.Equals, binlog.MinPosition)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, binlog.MinPosition)
+ s.Require().Equal(binlog.MinPosition, cp.GlobalPoint().Position)
+ s.Require().Equal(binlog.MinPosition, cp.FlushedGlobalPoint().Position)
// try load, but should load nothing
s.mock.ExpectQuery(loadCheckPointSQL).WillReturnRows(sqlmock.NewRows(nil))
err := cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, binlog.MinPosition)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, binlog.MinPosition)
+ s.Require().NoError(err)
+ s.Require().Equal(binlog.MinPosition, cp.GlobalPoint().Position)
+ s.Require().Equal(binlog.MinPosition, cp.FlushedGlobalPoint().Position)
oldMode := s.cfg.Mode
oldDir := s.cfg.Dir
@@ -163,7 +162,7 @@ func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
s.mock.ExpectQuery(loadCheckPointSQL).WithArgs(cpid).WillReturnRows(sqlmock.NewRows(nil))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cp.SaveGlobalPoint(binlog.Location{Position: pos1})
s.mock.ExpectBegin()
@@ -174,18 +173,18 @@ func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
cp.DiscardPendingSnapshots()
snap := cp.Snapshot(true)
err = cp.FlushPointsExcept(tctx, snap.id, nil, nil, nil)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().NoError(err)
+ s.Require().Equal(pos1, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
// try load from config
pos1.Pos = 2044
s.cfg.Mode = config.ModeIncrement
s.cfg.Meta = &config.Meta{BinLogName: pos1.Name, BinLogPos: pos1.Pos}
err = cp.LoadMeta(tctx.Ctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().NoError(err)
+ s.Require().Equal(pos1, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
s.cfg.Mode = oldMode
s.cfg.Meta = nil
@@ -196,28 +195,28 @@ func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
Pos: 2052,
}
cp.SaveGlobalPoint(binlog.Location{Position: pos2})
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos2)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().Equal(pos2, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
// test rollback
cp.Rollback()
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().Equal(pos1, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
// save again
cp.SaveGlobalPoint(binlog.Location{Position: pos2})
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos2)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().Equal(pos2, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
// flush + rollback
s.mock.ExpectBegin()
s.mock.ExpectExec("(202)?"+flushCheckPointSQL).WithArgs(cpid, "", "", pos2.Name, pos2.Pos, "", "", 0, "", "null", true).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.FlushPointsExcept(tctx, cp.Snapshot(true).id, nil, nil, nil)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cp.Rollback()
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos2)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos2)
+ s.Require().Equal(pos2, cp.GlobalPoint().Position)
+ s.Require().Equal(pos2, cp.FlushedGlobalPoint().Position)
// try load from DB
pos3 := pos2
@@ -226,16 +225,16 @@ func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
columns := []string{"cp_schema", "cp_table", "binlog_name", "binlog_pos", "binlog_gtid", "exit_safe_binlog_name", "exit_safe_binlog_pos", "exit_safe_binlog_gtid", "table_info", "is_global"}
s.mock.ExpectQuery(loadCheckPointSQL).WithArgs(cpid).WillReturnRows(sqlmock.NewRows(columns).AddRow("", "", pos2.Name, pos2.Pos, "", "", 0, "", "null", true))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos2)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos2)
+ s.Require().NoError(err)
+ s.Require().Equal(pos2, cp.GlobalPoint().Position)
+ s.Require().Equal(pos2, cp.FlushedGlobalPoint().Position)
// test save older point
/*var buf bytes.Buffer
log.SetOutput(&buf)
cp.SaveGlobalPoint(pos1)
- c.Assert(cp.GlobalPoint(), check.Equals, pos2)
- c.Assert(cp.FlushedGlobalPoint(), check.Equals, pos2)
+ s.Require().Equal(pos2, cp.GlobalPoint())
+ s.Require().Equal(pos2, cp.FlushedGlobalPoint())
matchStr := fmt.Sprintf(".*try to save %s is older than current pos %s", pos1, pos2)
matchStr = strings.Replace(strings.Replace(matchStr, ")", "\\)", -1), "(", "\\(", -1)
c.Assert(strings.TrimSpace(buf.String()), Matches, matchStr)
@@ -246,43 +245,43 @@ func (s *testCheckpointSuite) testGlobalCheckPoint(c *check.C, cp CheckPoint) {
s.mock.ExpectExec(clearCheckPointSQL).WithArgs(cpid).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.Clear(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, binlog.MinPosition)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, binlog.MinPosition)
+ s.Require().NoError(err)
+ s.Require().Equal(binlog.MinPosition, cp.GlobalPoint().Position)
+ s.Require().Equal(binlog.MinPosition, cp.FlushedGlobalPoint().Position)
s.mock.ExpectQuery(loadCheckPointSQL).WillReturnRows(sqlmock.NewRows(nil))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, binlog.MinPosition)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, binlog.MinPosition)
+ s.Require().NoError(err)
+ s.Require().Equal(binlog.MinPosition, cp.GlobalPoint().Position)
+ s.Require().Equal(binlog.MinPosition, cp.FlushedGlobalPoint().Position)
// try load from mydumper's output
- dir := c.MkDir()
+ dir := s.T().TempDir()
filename := filepath.Join(dir, "metadata")
err = os.WriteFile(filename, []byte(
fmt.Sprintf("SHOW MASTER STATUS:\n\tLog: %s\n\tPos: %d\n\tGTID:\n\nSHOW SLAVE STATUS:\n\tHost: %s\n\tLog: %s\n\tPos: %d\n\tGTID:\n\n", pos1.Name, pos1.Pos, "slave_host", pos1.Name, pos1.Pos+1000)),
0o644)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.cfg.Mode = config.ModeAll
s.cfg.Dir = dir
- c.Assert(cp.LoadMeta(tctx.Ctx), check.IsNil)
+ s.Require().Nil(cp.LoadMeta(tctx.Ctx))
// should flush because checkpoint hasn't been updated before (cp.globalPointCheckOrSaveTime.IsZero() == true).
snapshot := cp.Snapshot(true)
- c.Assert(snapshot.id, check.Equals, 4)
+ s.Require().Equal(4, snapshot.id)
s.mock.ExpectQuery(loadCheckPointSQL).WillReturnRows(sqlmock.NewRows(nil))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
+ s.Require().NoError(err)
+ s.Require().Equal(pos1, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
s.mock.ExpectBegin()
s.mock.ExpectExec(clearCheckPointSQL).WithArgs(cpid).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.Clear(tctx)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// check dumpling write exitSafeModeLocation in metadata
err = os.WriteFile(filename, []byte(
@@ -302,31 +301,31 @@ SHOW MASTER STATUS: /* AFTER CONNECTION POOL ESTABLISHED */
Pos: %d
GTID:
`, pos1.Name, pos1.Pos, "slave_host", pos1.Name, pos1.Pos+1000, pos2.Name, pos2.Pos)), 0o644)
- c.Assert(err, check.IsNil)
- c.Assert(cp.LoadMeta(tctx.Ctx), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(cp.LoadMeta(tctx.Ctx))
// should flush because exitSafeModeLocation is true
snapshot = cp.Snapshot(true)
- c.Assert(snapshot, check.NotNil)
+ s.Require().NotNil(snapshot)
s.mock.ExpectBegin()
s.mock.ExpectExec("(202)?"+flushCheckPointSQL).WithArgs(cpid, "", "", pos1.Name, pos1.Pos, "", pos2.Name, pos2.Pos, "", "null", true).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.FlushPointsExcept(tctx, snapshot.id, nil, nil, nil)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.mock.ExpectQuery(loadCheckPointSQL).WillReturnRows(sqlmock.NewRows(nil))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.FlushedGlobalPoint().Position, check.Equals, pos1)
- c.Assert(cp.SafeModeExitPoint().Position, check.Equals, pos2)
+ s.Require().NoError(err)
+ s.Require().Equal(pos1, cp.GlobalPoint().Position)
+ s.Require().Equal(pos1, cp.FlushedGlobalPoint().Position)
+ s.Require().Equal(pos2, cp.SafeModeExitPoint().Position)
// when use async flush, even exitSafeModeLocation is true we won't flush
- c.Assert(cp.LoadMeta(tctx.Ctx), check.IsNil)
+ s.Require().Nil(cp.LoadMeta(tctx.Ctx))
snapshot = cp.Snapshot(false)
- c.Assert(snapshot, check.IsNil)
+ s.Require().Nil(snapshot)
}
-func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
+func (s *testCheckpointSuite) testTableCheckPoint(cp CheckPoint) {
var (
tctx = tcontext.Background()
table = &filter.Table{
@@ -348,67 +347,67 @@ func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
// not exist
older := cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsFalse)
+ s.Require().False(older)
// save
cp.SaveTablePoint(table, binlog.Location{Position: pos2}, nil)
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsTrue)
+ s.Require().True(older)
// rollback, to min
cp.Rollback()
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsFalse)
+ s.Require().False(older)
// save again
cp.SaveTablePoint(table, binlog.Location{Position: pos2}, nil)
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsTrue)
+ s.Require().True(older)
// flush + rollback
s.mock.ExpectBegin()
s.mock.ExpectExec("(284)?"+flushCheckPointSQL).WithArgs(cpid, table.Schema, table.Name, pos2.Name, pos2.Pos, "", "", 0, "", sqlmock.AnyArg(), false).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.FlushPointsExcept(tctx, cp.Snapshot(true).id, nil, nil, nil)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cp.Rollback()
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsTrue)
+ s.Require().True(older)
// save
cp.SaveTablePoint(table, binlog.Location{Position: pos2}, nil)
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsTrue)
+ s.Require().True(older)
// delete
s.mock.ExpectBegin()
s.mock.ExpectExec(deleteCheckPointSQL).WithArgs(cpid, schemaName, tableName).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
- c.Assert(cp.DeleteTablePoint(tctx, table), check.IsNil)
+ s.Require().Nil(cp.DeleteTablePoint(tctx, table))
s.mock.ExpectBegin()
s.mock.ExpectExec(deleteSchemaPointSQL).WithArgs(cpid, schemaName).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
- c.Assert(cp.DeleteSchemaPoint(tctx, schemaName), check.IsNil)
+ s.Require().Nil(cp.DeleteSchemaPoint(tctx, schemaName))
ctx := context.Background()
// test save with table info and rollback
- c.Assert(s.tracker.CreateSchemaIfNotExists(schemaName), check.IsNil)
+ s.Require().Nil(s.tracker.CreateSchemaIfNotExists(schemaName))
stmt, err := parseSQL("create table " + tableName + " (c int);")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
err = s.tracker.Exec(ctx, schemaName, stmt)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
ti, err := s.tracker.GetTableInfo(table)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cp.SaveTablePoint(table, binlog.Location{Position: pos1}, ti)
rcp := cp.(*RemoteCheckPoint)
- c.Assert(rcp.points[schemaName][tableName].TableInfo(), check.NotNil)
- c.Assert(rcp.points[schemaName][tableName].flushedPoint.ti, check.IsNil)
+ s.Require().NotNil(rcp.points[schemaName][tableName].TableInfo())
+ s.Require().Nil(rcp.points[schemaName][tableName].flushedPoint.ti)
cp.Rollback()
rcp = cp.(*RemoteCheckPoint)
- c.Assert(rcp.points[schemaName][tableName].TableInfo(), check.IsNil)
- c.Assert(rcp.points[schemaName][tableName].flushedPoint.ti, check.IsNil)
+ s.Require().Nil(rcp.points[schemaName][tableName].TableInfo())
+ s.Require().Nil(rcp.points[schemaName][tableName].flushedPoint.ti)
// test save, flush and rollback to not nil table info
cp.SaveTablePoint(table, binlog.Location{Position: pos1}, ti)
@@ -418,15 +417,15 @@ func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
s.mock.ExpectCommit()
lastGlobalPoint := cp.GlobalPoint()
lastGlobalPointSavedTime := cp.GlobalPointSaveTime()
- c.Assert(cp.FlushPointsExcept(tctx, cp.Snapshot(true).id, nil, nil, nil), check.IsNil)
- c.Assert(cp.GlobalPoint(), check.Equals, lastGlobalPoint)
- c.Assert(cp.GlobalPointSaveTime(), check.Equals, lastGlobalPointSavedTime)
+ s.Require().Nil(cp.FlushPointsExcept(tctx, cp.Snapshot(true).id, nil, nil, nil))
+ s.Require().Equal(lastGlobalPoint, cp.GlobalPoint())
+ s.Require().Equal(lastGlobalPointSavedTime, cp.GlobalPointSaveTime())
stmt, err = parseSQL("alter table " + tableName + " add c2 int;")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
err = s.tracker.Exec(ctx, schemaName, stmt)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
ti2, err := s.tracker.GetTableInfo(table)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cp.SaveTablePoint(table, binlog.Location{Position: pos2}, ti2)
cp.Rollback()
@@ -435,16 +434,16 @@ func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
s.mock.ExpectExec(clearCheckPointSQL).WithArgs(cpid).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
err = cp.Clear(tctx)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsFalse)
+ s.Require().False(older)
// test save table point less than global point
func() {
defer func() {
r := recover()
matchStr := ".*less than global checkpoint.*"
- c.Assert(r, check.Matches, matchStr)
+ s.Require().Regexp(matchStr, r)
}()
cp.SaveGlobalPoint(binlog.Location{Position: pos2})
cp.SaveTablePoint(table, binlog.Location{Position: pos1}, nil)
@@ -458,17 +457,17 @@ func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
lastGlobalPointSavedTime = cp.GlobalPointSaveTime()
err = cp.FlushPointsExcept(tctx, cp.Snapshot(true).id, []*filter.Table{table}, nil, nil)
fmt.Println(cp.GlobalPoint(), lastGlobalPoint)
- c.Assert(cp.GlobalPoint(), check.Equals, lastGlobalPoint)
- c.Assert(cp.GlobalPointSaveTime(), check.Not(check.Equals), lastGlobalPointSavedTime)
- c.Assert(err, check.IsNil)
+ s.Require().Equal(lastGlobalPoint, cp.GlobalPoint())
+ s.Require().NotEqual(lastGlobalPointSavedTime, cp.GlobalPointSaveTime())
+ s.Require().NoError(err)
cp.Rollback()
older = cp.IsOlderThanTablePoint(table, binlog.Location{Position: pos1})
- c.Assert(older, check.IsFalse)
+ s.Require().False(older)
s.mock.ExpectBegin()
s.mock.ExpectExec(clearCheckPointSQL).WithArgs(cpid).WillReturnResult(sqlmock.NewResult(0, 1))
s.mock.ExpectCommit()
- c.Assert(cp.Clear(tctx), check.IsNil)
+ s.Require().Nil(cp.Clear(tctx))
// load table point and exitSafe, with enable GTID
s.cfg.EnableGTID = true
flavor := mysql.MySQLFlavor
@@ -479,12 +478,12 @@ func (s *testCheckpointSuite) testTableCheckPoint(c *check.C, cp CheckPoint) {
sqlmock.NewRows(columns).AddRow("", "", pos2.Name, pos2.Pos, gs.String(), pos2.Name, pos2.Pos, gs.String(), "null", true).
AddRow(schemaName, tableName, pos2.Name, pos2.Pos, gs.String(), "", 0, "", tiBytes, false))
err = cp.Load(tctx)
- c.Assert(err, check.IsNil)
- c.Assert(cp.GlobalPoint(), check.DeepEquals, binlog.NewLocation(pos2, gs))
+ s.Require().NoError(err)
+ s.Require().Equal(binlog.NewLocation(pos2, gs), cp.GlobalPoint())
rcp = cp.(*RemoteCheckPoint)
- c.Assert(rcp.points[schemaName][tableName].TableInfo(), check.NotNil)
- c.Assert(rcp.points[schemaName][tableName].flushedPoint.ti, check.NotNil)
- c.Assert(*rcp.safeModeExitPoint, check.DeepEquals, binlog.NewLocation(pos2, gs))
+ s.Require().NotNil(rcp.points[schemaName][tableName].TableInfo())
+ s.Require().NotNil(rcp.points[schemaName][tableName].flushedPoint.ti)
+ s.Require().Equal(binlog.NewLocation(pos2, gs), *rcp.safeModeExitPoint)
}
func TestRemoteCheckPointLoadIntoSchemaTracker(t *testing.T) {
diff --git a/dm/syncer/compactor_test.go b/dm/syncer/compactor_test.go
index 406f0db206..fa06950112 100644
--- a/dm/syncer/compactor_test.go
+++ b/dm/syncer/compactor_test.go
@@ -19,7 +19,6 @@ import (
"time"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/util/mock"
@@ -59,7 +58,7 @@ func randString(n int) string {
return string(b)
}
-func (s *testSyncerSuite) TestCompactJob(c *check.C) {
+func (s *testSyncerSuite) TestCompactJob() {
compactor := &compactor{
bufferSize: 10000,
logger: log.L(),
@@ -76,7 +75,7 @@ func (s *testSyncerSuite) TestCompactJob(c *check.C) {
targetTable := &cdcmodel.TableName{Schema: "test", Table: "tb"}
schemaStr := "create table test.tb(id int primary key, col1 int, name varchar(24))"
ti, err := createTableInfo(p, se, 0, schemaStr)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
var dml *sqlmodel.RowChange
var dmls []*sqlmodel.RowChange
@@ -152,29 +151,29 @@ func (s *testSyncerSuite) TestCompactJob(c *check.C) {
noCompactNumber := end - i
compactNumber := 0
for _, dml := range dmls[i:end] {
- c.Logf("before compact, dml: %s", dml.String())
+ s.T().Logf("before compact, dml: %s", dml.String())
}
for _, j := range compactor.buffer {
if j != nil {
compactKV = mockExecute(compactKV, []*sqlmodel.RowChange{j.dml})
compactNumber++
- c.Logf("after compact, dml: %s", j.dml.String())
+ s.T().Logf("after compact, dml: %s", j.dml.String())
}
}
- c.Logf("before compact: %d, after compact: %d", noCompactNumber, compactNumber)
- c.Assert(compactKV, check.DeepEquals, kv)
+ s.T().Logf("before compact: %d, after compact: %d", noCompactNumber, compactNumber)
+ s.Require().Equal(kv, compactKV)
compactor.keyMap = make(map[string]map[string]int)
compactor.buffer = compactor.buffer[0:0]
}
}
-func (s *testSyncerSuite) TestCompactorSafeMode(c *check.C) {
+func (s *testSyncerSuite) TestCompactorSafeMode() {
p := parser.New()
se := mock.NewContext()
sourceTable := &cdcmodel.TableName{Schema: "test", Table: "tb"}
schemaStr := "create table test.tb(id int primary key, col1 int, name varchar(24))"
ti, err := createTableInfo(p, se, 0, schemaStr)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
testCases := []struct {
input []*job
@@ -282,7 +281,7 @@ func (s *testSyncerSuite) TestCompactorSafeMode(c *check.C) {
metricsProxies: metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source"),
}
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/syncer/SkipFlushCompactor", `return()`), check.IsNil)
+ s.Require().Nil(failpoint.Enable("github.com/pingcap/tiflow/dm/syncer/SkipFlushCompactor", `return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/syncer/SkipFlushCompactor")
@@ -293,16 +292,16 @@ func (s *testSyncerSuite) TestCompactorSafeMode(c *check.C) {
inCh <- j
}
inCh <- newFlushJob(syncer.cfg.WorkerCount, 1)
- c.Assert(
+ s.Require().Equal(true,
utils.WaitSomething(10, time.Millisecond, func() bool {
return len(outCh) == len(tc.output)+1
- }), check.Equals, true)
+ }))
for i := 0; i <= len(tc.output); i++ {
j := <-outCh
if i < len(tc.output) {
- c.Assert(j.String(), check.Equals, tc.output[i].String())
+ s.Require().Equal(tc.output[i].String(), j.String())
} else {
- c.Assert(j.tp, check.Equals, flush)
+ s.Require().Equal(flush, j.tp)
}
}
}
diff --git a/dm/syncer/dbconn/upstream_db_test.go b/dm/syncer/dbconn/upstream_db_test.go
index fa12465942..6a8983b9f8 100644
--- a/dm/syncer/dbconn/upstream_db_test.go
+++ b/dm/syncer/dbconn/upstream_db_test.go
@@ -17,26 +17,30 @@ import (
"context"
"database/sql"
"fmt"
+ "testing"
"time"
"github.com/go-mysql-org/go-mysql/replication"
"github.com/google/uuid"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/pkg/conn"
tcontext "github.com/pingcap/tiflow/dm/pkg/context"
+ "github.com/stretchr/testify/suite"
)
-var _ = check.Suite(&testDBSuite{})
+func TestDBSuite(t *testing.T) {
+ suite.Run(t, new(testDBSuite))
+}
type testDBSuite struct {
+ suite.Suite
db *sql.DB
syncer *replication.BinlogSyncer
streamer *replication.BinlogStreamer
cfg *config.SubTaskConfig
}
-func (s *testDBSuite) SetUpSuite(c *check.C) {
+func (s *testDBSuite) SetupSuite() {
s.cfg = &config.SubTaskConfig{
From: config.GetDBConfigForTest(),
To: config.GetDBConfigForTest(),
@@ -49,20 +53,23 @@ func (s *testDBSuite) SetUpSuite(c *check.C) {
s.cfg.From.Adjust()
s.cfg.To.Adjust()
- dir := c.MkDir()
+ dir := s.T().TempDir()
s.cfg.RelayDir = dir
var err error
dbAddr := fmt.Sprintf("%s:%s@tcp(%s:%d)/?charset=utf8", s.cfg.From.User, s.cfg.From.Password, s.cfg.From.Host, s.cfg.From.Port)
s.db, err = sql.Open("mysql", dbAddr)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
+ if err = s.db.Ping(); err != nil {
+ s.T().Skipf("skipping suite, upstream MySQL is not available: %v", err)
+ }
- s.resetBinlogSyncer(c)
+ s.resetBinlogSyncer()
_, err = s.db.Exec("SET GLOBAL binlog_format = 'ROW';")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *testDBSuite) resetBinlogSyncer(c *check.C) {
+func (s *testDBSuite) resetBinlogSyncer() {
cfg := replication.BinlogSyncerConfig{
ServerID: s.cfg.ServerID,
Flavor: "mysql",
@@ -80,28 +87,28 @@ func (s *testDBSuite) resetBinlogSyncer(c *check.C) {
}
pos, _, err := conn.GetPosAndGs(tcontext.Background(), conn.NewBaseDBForTest(s.db), "mysql")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.syncer = replication.NewBinlogSyncer(cfg)
s.streamer, err = s.syncer.StartSync(pos)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *testDBSuite) TestGetServerUUID(c *check.C) {
+func (s *testDBSuite) TestGetServerUUID() {
u, err := conn.GetServerUUID(tcontext.Background(), conn.NewBaseDBForTest(s.db), "mysql")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
_, err = uuid.Parse(u)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
}
-func (s *testDBSuite) TestGetServerID(c *check.C) {
+func (s *testDBSuite) TestGetServerID() {
id, err := conn.GetServerID(tcontext.Background(), conn.NewBaseDBForTest(s.db))
- c.Assert(err, check.IsNil)
- c.Assert(id, check.Greater, uint32(0))
+ s.Require().NoError(err)
+ s.Require().Greater(id, uint32(0))
}
-func (s *testDBSuite) TestGetServerUnixTS(c *check.C) {
+func (s *testDBSuite) TestGetServerUnixTS() {
id, err := conn.GetServerUnixTS(context.Background(), conn.NewBaseDBForTest(s.db))
- c.Assert(err, check.IsNil)
- c.Assert(id, check.Greater, int64(0))
+ s.Require().NoError(err)
+ s.Require().Greater(id, int64(0))
}
diff --git a/dm/syncer/ddl_test.go b/dm/syncer/ddl_test.go
index 23d7490fa1..686f8dbb47 100644
--- a/dm/syncer/ddl_test.go
+++ b/dm/syncer/ddl_test.go
@@ -21,7 +21,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/parser/ast"
"github.com/pingcap/tidb/pkg/util/filter"
@@ -40,11 +39,7 @@ import (
"go.uber.org/zap"
)
-var _ = check.Suite(&testDDLSuite{})
-
-type testDDLSuite struct{}
-
-func (s *testDDLSuite) newSubTaskCfg(dbCfg dbconfig.DBConfig) *config.SubTaskConfig {
+func newSubTaskCfg(dbCfg dbconfig.DBConfig) *config.SubTaskConfig {
return &config.SubTaskConfig{
From: dbCfg,
To: dbCfg,
@@ -58,7 +53,7 @@ func (s *testDDLSuite) newSubTaskCfg(dbCfg dbconfig.DBConfig) *config.SubTaskCon
}
}
-func (s *testDDLSuite) TestAnsiQuotes(c *check.C) {
+func TestAnsiQuotes(t *testing.T) {
ansiQuotesCases := []string{
"create database `test`",
"create table `test`.`test`(id int)",
@@ -73,18 +68,18 @@ func (s *testDDLSuite) TestAnsiQuotes(c *check.C) {
mock.ExpectQuery("SHOW VARIABLES LIKE").
WillReturnRows(sqlmock.NewRows([]string{"Variable_name", "Value"}).
AddRow("sql_mode", "ANSI_QUOTES"))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
parser, err := conn.GetParser(tcontext.Background(), conn.NewBaseDBForTest(db))
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, sql := range ansiQuotesCases {
_, err = parser.ParseOneStmt(sql, "", "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
}
-func (s *testDDLSuite) TestDDLWithDashComments(c *check.C) {
+func TestDDLWithDashComments(t *testing.T) {
sql := `--
-- this is a comment.
--
@@ -92,10 +87,10 @@ CREATE TABLE test.test_table_with_c (id int);
`
parser := parser.New()
_, err := parserpkg.Parse(parser, sql, "", "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
-func (s *testDDLSuite) TestCommentQuote(c *check.C) {
+func TestCommentQuote(t *testing.T) {
sql := "ALTER TABLE schemadb.ep_edu_course_message_auto_reply MODIFY answer JSON COMMENT '回复的内容-格式为list，有两个字段：\"answerType\"：//''发送客服消息类型：1-文本消息，2-图片，3-图文链接''； answer：回复内容';"
expectedSQL := "ALTER TABLE `schemadb`.`ep_edu_course_message_auto_reply` MODIFY COLUMN `answer` JSON COMMENT '回复的内容-格式为list，有两个字段：\"answerType\"：//''发送客服消息类型：1-文本消息，2-图片，3-图文链接''； answer：回复内容'"
@@ -110,26 +105,26 @@ func (s *testDDLSuite) TestCommentQuote(c *check.C) {
p: parser.New(),
}
stmt, err := parseOneStmt(qec)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.splitDDLs, err = parserpkg.SplitDDL(stmt, qec.ddlSchema)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
syncer := NewSyncer(&config.SubTaskConfig{Flavor: mysql.MySQLFlavor}, nil, nil)
syncer.tctx = tctx
- c.Assert(syncer.genRouter(), check.IsNil)
+ require.NoError(t, syncer.genRouter())
ddlWorker := NewDDLWorker(&tctx.Logger, syncer)
for _, sql := range qec.splitDDLs {
sqls, err := ddlWorker.processOneDDL(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.appliedDDLs = append(qec.appliedDDLs, sqls...)
}
- c.Assert(len(qec.appliedDDLs), check.Equals, 1)
- c.Assert(qec.appliedDDLs[0], check.Equals, expectedSQL)
+ require.Equal(t, 1, len(qec.appliedDDLs))
+ require.Equal(t, expectedSQL, qec.appliedDDLs[0])
}
-func (s *testDDLSuite) TestResolveDDLSQL(c *check.C) {
+func TestResolveDDLSQL(t *testing.T) {
// duplicate with pkg/parser
sqls := []string{
"create schema `s1`",
@@ -224,7 +219,7 @@ func (s *testDDLSuite) TestResolveDDLSQL(c *check.C) {
syncer.tctx = tctx
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
syncer.tableRouter, err = regexprrouter.NewRegExprRouter(false, []*router.TableRule{
{
@@ -232,7 +227,7 @@ func (s *testDDLSuite) TestResolveDDLSQL(c *check.C) {
TargetSchema: "xs1",
},
})
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testEC := &eventContext{
tctx: tctx,
@@ -250,13 +245,13 @@ func (s *testDDLSuite) TestResolveDDLSQL(c *check.C) {
eventStatusVars: statusVars,
}
stmt, err := parseOneStmt(qec)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.splitDDLs, err = parserpkg.SplitDDL(stmt, qec.ddlSchema)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, sql2 := range qec.splitDDLs {
sqls, err := ddlWorker.processOneDDL(qec, sql2)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, sql3 := range sqls {
if len(sql3) == 0 {
continue
@@ -264,17 +259,17 @@ func (s *testDDLSuite) TestResolveDDLSQL(c *check.C) {
qec.appliedDDLs = append(qec.appliedDDLs, sql3)
}
}
- c.Assert(qec.appliedDDLs, check.DeepEquals, expectedSQLs[i])
- c.Assert(targetSQLs[i], check.HasLen, len(qec.appliedDDLs))
+ require.Equal(t, expectedSQLs[i], qec.appliedDDLs)
+ require.Len(t, targetSQLs[i], len(qec.appliedDDLs))
for j, sql2 := range qec.appliedDDLs {
ddlInfo, err2 := ddlWorker.genDDLInfo(qec, sql2)
- c.Assert(err2, check.IsNil)
- c.Assert(targetSQLs[i][j], check.Equals, ddlInfo.routedDDL)
+ require.NoError(t, err2)
+ require.Equal(t, ddlInfo.routedDDL, targetSQLs[i][j])
}
}
}
-func (s *testDDLSuite) TestRejectForeignKeyDDL(c *check.C) {
+func TestRejectForeignKeyDDL(t *testing.T) {
tctx := tcontext.Background().WithLogger(log.With(zap.String("test", "TestRejectForeignKeyDDL")))
testEC := &eventContext{tctx: tctx}
@@ -286,7 +281,7 @@ func (s *testDDLSuite) TestRejectForeignKeyDDL(c *check.C) {
}
syncer := NewSyncer(cfg, nil, nil)
syncer.tctx = tctx
- c.Assert(syncer.genRouter(), check.IsNil)
+ require.NoError(t, syncer.genRouter())
ddlWorker := NewDDLWorker(&tctx.Logger, syncer)
cases := []string{
@@ -301,8 +296,8 @@ func (s *testDDLSuite) TestRejectForeignKeyDDL(c *check.C) {
p: parser.New(),
}
_, err := ddlWorker.genDDLInfo(qec, sql)
- c.Assert(err, check.NotNil)
- c.Assert(err.Error(), check.Matches, ".*foreign_key_checks=1.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*foreign_key_checks=1.*", err.Error())
}
cfgOff := &config.SubTaskConfig{
@@ -313,7 +308,7 @@ func (s *testDDLSuite) TestRejectForeignKeyDDL(c *check.C) {
}
syncerOff := NewSyncer(cfgOff, nil, nil)
syncerOff.tctx = tctx
- c.Assert(syncerOff.genRouter(), check.IsNil)
+ require.NoError(t, syncerOff.genRouter())
ddlWorkerOff := NewDDLWorker(&tctx.Logger, syncerOff)
qecOff := &queryEventContext{
@@ -323,10 +318,10 @@ func (s *testDDLSuite) TestRejectForeignKeyDDL(c *check.C) {
p: parser.New(),
}
_, err := ddlWorkerOff.genDDLInfo(qecOff, cases[0])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
-func (s *testDDLSuite) TestParseOneStmt(c *check.C) {
+func TestParseOneStmt(t *testing.T) {
cases := []struct {
sql string
isDDL bool
@@ -410,16 +405,16 @@ func (s *testDDLSuite) TestParseOneStmt(c *check.C) {
qec.originSQL = cs.sql
stmt, err := parseOneStmt(qec)
if cs.hasError {
- c.Assert(err, check.NotNil)
+ require.Error(t, err)
} else {
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
_, ok := stmt.(ast.DDLNode)
- c.Assert(ok, check.Equals, cs.isDDL)
+ require.Equal(t, cs.isDDL, ok)
}
}
-func (s *testDDLSuite) TestResolveGeneratedColumnSQL(c *check.C) {
+func TestResolveGeneratedColumnSQL(t *testing.T) {
testCases := []struct {
sql string
expected string
@@ -437,7 +432,7 @@ func (s *testDDLSuite) TestResolveGeneratedColumnSQL(c *check.C) {
tctx := tcontext.Background().WithLogger(log.With(zap.String("test", "TestResolveGeneratedColumnSQL")))
syncer := NewSyncer(&config.SubTaskConfig{Flavor: mysql.MySQLFlavor}, nil, nil)
syncer.tctx = tctx
- c.Assert(syncer.genRouter(), check.IsNil)
+ require.Nil(t, syncer.genRouter())
p := parser.New()
ddlWorker := NewDDLWorker(&tctx.Logger, syncer)
for _, tc := range testCases {
@@ -451,22 +446,22 @@ func (s *testDDLSuite) TestResolveGeneratedColumnSQL(c *check.C) {
p: p,
}
stmt, err := parseOneStmt(qec)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.splitDDLs, err = parserpkg.SplitDDL(stmt, qec.ddlSchema)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, sql := range qec.splitDDLs {
sqls, err := ddlWorker.processOneDDL(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.appliedDDLs = append(qec.appliedDDLs, sqls...)
}
- c.Assert(len(qec.appliedDDLs), check.Equals, 1)
- c.Assert(qec.appliedDDLs[0], check.Equals, tc.expected)
+ require.Equal(t, 1, len(qec.appliedDDLs))
+ require.Equal(t, tc.expected, qec.appliedDDLs[0])
}
}
-func (s *testDDLSuite) TestResolveOnlineDDL(c *check.C) {
+func TestResolveOnlineDDL(t *testing.T) {
cases := []struct {
sql string
expectSQL string
@@ -505,23 +500,23 @@ func (s *testDDLSuite) TestResolveOnlineDDL(c *check.C) {
testEC := &eventContext{tctx: tctx}
cluster, err := conn.NewCluster()
- c.Assert(err, check.IsNil)
- c.Assert(cluster.Start(), check.IsNil)
+ require.NoError(t, err)
+ require.Nil(t, cluster.Start())
mockClusterPort := cluster.Port
dbCfg := config.GetDBConfigForTest()
dbCfg.Port = mockClusterPort
dbCfg.Password = ""
- cfg := s.newSubTaskCfg(dbCfg)
+ cfg := newSubTaskCfg(dbCfg)
var qec *queryEventContext
for _, ca := range cases {
plugin, err := onlineddl.NewRealOnlinePlugin(tctx, cfg, nil)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
syncer := NewSyncer(cfg, nil, nil)
syncer.tctx = tctx
syncer.onlineDDL = plugin
- c.Assert(plugin.Clear(tctx), check.IsNil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ require.Nil(t, plugin.Clear(tctx))
+ require.Nil(t, syncer.genRouter())
qec = &queryEventContext{
eventContext: testEC,
ddlSchema: "test",
@@ -530,26 +525,26 @@ func (s *testDDLSuite) TestResolveOnlineDDL(c *check.C) {
}
qec.originSQL = ca.sql
stmt, err := parseOneStmt(qec)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, ok := stmt.(ast.DDLNode)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
qec.splitDDLs, err = parserpkg.SplitDDL(stmt, qec.ddlSchema)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
ddlWorker := NewDDLWorker(&tctx.Logger, syncer)
for _, sql := range qec.splitDDLs {
sqls, err := ddlWorker.processOneDDL(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.appliedDDLs = append(qec.appliedDDLs, sqls...)
}
if len(ca.expectSQL) != 0 {
- c.Assert(qec.appliedDDLs, check.HasLen, 1)
- c.Assert(qec.appliedDDLs[0], check.Equals, ca.expectSQL)
+ require.Len(t, qec.appliedDDLs, 1)
+ require.Equal(t, ca.expectSQL, qec.appliedDDLs[0])
}
}
cluster.Stop()
}
-func (s *testDDLSuite) TestMistakeOnlineDDLRegex(c *check.C) {
+func TestMistakeOnlineDDLRegex(t *testing.T) {
cases := []struct {
onlineType string
trashName string
@@ -586,21 +581,21 @@ func (s *testDDLSuite) TestMistakeOnlineDDLRegex(c *check.C) {
ec := eventContext{tctx: tctx}
cluster, err := conn.NewCluster()
- c.Assert(err, check.IsNil)
- c.Assert(cluster.Start(), check.IsNil)
+ require.NoError(t, err)
+ require.Nil(t, cluster.Start())
mockClusterPort := cluster.Port
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
dbCfg := config.GetDBConfigForTest()
dbCfg.Port = mockClusterPort
dbCfg.Password = ""
- cfg := s.newSubTaskCfg(dbCfg)
+ cfg := newSubTaskCfg(dbCfg)
for _, ca := range cases {
plugin, err := onlineddl.NewRealOnlinePlugin(tctx, cfg, nil)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
syncer := NewSyncer(cfg, nil, nil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ require.Nil(t, syncer.genRouter())
syncer.onlineDDL = plugin
- c.Assert(plugin.Clear(tctx), check.IsNil)
+ require.Nil(t, plugin.Clear(tctx))
// ghost table
sql := fmt.Sprintf("ALTER TABLE `test`.`%s` ADD COLUMN `n` INT", ca.ghostname)
@@ -611,16 +606,16 @@ func (s *testDDLSuite) TestMistakeOnlineDDLRegex(c *check.C) {
}
ddlWorker := NewDDLWorker(&tctx.Logger, syncer)
sqls, err := ddlWorker.processOneDDL(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
table := ca.ghostname
matchRules := config.ShadowTableRules
if ca.matchGho {
- c.Assert(sqls, check.HasLen, 0)
+ require.Len(t, sqls, 0)
table = ca.trashName
matchRules = config.TrashTableRules
} else {
- c.Assert(sqls, check.HasLen, 1)
- c.Assert(sqls[0], check.Equals, sql)
+ require.Len(t, sqls, 1)
+ require.Equal(t, sql, sqls[0])
}
sql = fmt.Sprintf("RENAME TABLE `test`.`t1` TO `test`.`%s`, `test`.`%s` TO `test`.`t1`", ca.trashName, ca.ghostname)
qec = &queryEventContext{
@@ -629,14 +624,15 @@ func (s *testDDLSuite) TestMistakeOnlineDDLRegex(c *check.C) {
p: p,
}
sqls, err = ddlWorker.processOneDDL(qec, sql)
- c.Assert(terror.ErrConfigOnlineDDLMistakeRegex.Equal(err), check.IsTrue)
- c.Assert(sqls, check.HasLen, 0)
- c.Assert(err, check.ErrorMatches, ".*"+sql+".*"+table+".*"+matchRules+".*")
+ require.True(t, terror.ErrConfigOnlineDDLMistakeRegex.Equal(err))
+ require.Len(t, sqls, 0)
+ require.Error(t, err)
+ require.Regexp(t, ".*"+sql+".*"+table+".*"+matchRules+".*", err.Error())
}
cluster.Stop()
}
-func (s *testDDLSuite) TestDropSchemaInSharding(c *check.C) {
+func TestDropSchemaInSharding(t *testing.T) {
var (
targetTable = &filter.Table{
Schema: "target_db",
@@ -648,22 +644,22 @@ func (s *testDDLSuite) TestDropSchemaInSharding(c *check.C) {
tctx = tcontext.Background()
)
dbCfg := config.GetDBConfigForTest()
- cfg := s.newSubTaskCfg(dbCfg)
+ cfg := newSubTaskCfg(dbCfg)
cfg.ShardMode = config.ShardPessimistic
syncer := NewSyncer(cfg, nil, nil)
// nolint:dogsled
_, _, _, _, err := syncer.sgk.AddGroup(targetTable, []string{source1}, nil, true)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// nolint:dogsled
_, _, _, _, err = syncer.sgk.AddGroup(targetTable, []string{source2}, nil, true)
- c.Assert(err, check.IsNil)
- c.Assert(syncer.sgk.Groups(), check.HasLen, 2)
+ require.NoError(t, err)
+ require.Len(t, syncer.sgk.Groups(), 2)
pessimist := NewPessimistDDL(&syncer.tctx.Logger, syncer)
- c.Assert(pessimist.dropSchemaInSharding(tctx, sourceDB), check.IsNil)
- c.Assert(syncer.sgk.Groups(), check.HasLen, 0)
+ require.Nil(t, pessimist.dropSchemaInSharding(tctx, sourceDB))
+ require.Len(t, syncer.sgk.Groups(), 0)
}
-func (s *testDDLSuite) TestClearOnlineDDL(c *check.C) {
+func TestClearOnlineDDL(t *testing.T) {
var (
targetTable = &filter.Table{
Schema: "target_db",
@@ -676,7 +672,7 @@ func (s *testDDLSuite) TestClearOnlineDDL(c *check.C) {
tctx = tcontext.Background()
)
dbCfg := config.GetDBConfigForTest()
- cfg := s.newSubTaskCfg(dbCfg)
+ cfg := newSubTaskCfg(dbCfg)
cfg.ShardMode = config.ShardPessimistic
syncer := NewSyncer(cfg, nil, nil)
mock := mockOnlinePlugin{
@@ -686,17 +682,17 @@ func (s *testDDLSuite) TestClearOnlineDDL(c *check.C) {
// nolint:dogsled
_, _, _, _, err := syncer.sgk.AddGroup(targetTable, []string{source1}, nil, true)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// nolint:dogsled
_, _, _, _, err = syncer.sgk.AddGroup(targetTable, []string{source2}, nil, true)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
pessimist := NewPessimistDDL(&syncer.tctx.Logger, syncer)
- c.Assert(pessimist.clearOnlineDDL(tctx, targetTable), check.IsNil)
- c.Assert(mock.toFinish, check.HasLen, 0)
+ require.Nil(t, pessimist.clearOnlineDDL(tctx, targetTable))
+ require.Len(t, mock.toFinish, 0)
}
-func (s *testDDLSuite) TestAdjustDatabaseCollation(c *check.C) {
+func TestAdjustDatabaseCollation(t *testing.T) {
statusVarsArray := [][]byte{
{
4, 0, 0, 0, 0, 46, 0,
@@ -752,13 +748,13 @@ func (s *testDDLSuite) TestAdjustDatabaseCollation(c *check.C) {
targetTables: []*filter.Table{tab},
}
stmt, err := p.ParseOneStmt(sql, "", "")
- c.Assert(err, check.IsNil)
- c.Assert(stmt, check.NotNil)
+ require.NoError(t, err)
+ require.NotNil(t, stmt)
ddlInfo.stmtCache = stmt
ddlWorker.adjustCollation(ddlInfo, statusVars, charsetAndDefaultCollationMap, idAndCollationMap)
routedDDL, err := parserpkg.RenameDDLTable(ddlInfo.stmtCache, ddlInfo.targetTables)
- c.Assert(err, check.IsNil)
- c.Assert(routedDDL, check.Equals, expectedSQLs[i][j])
+ require.NoError(t, err)
+ require.Equal(t, expectedSQLs[i][j], routedDDL)
}
}
}
diff --git a/dm/syncer/filter_test.go b/dm/syncer/filter_test.go
index ed8e20f558..c0ec0b25eb 100644
--- a/dm/syncer/filter_test.go
+++ b/dm/syncer/filter_test.go
@@ -20,7 +20,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
"github.com/go-mysql-org/go-mysql/mysql"
"github.com/go-mysql-org/go-mysql/replication"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/util/filter"
"github.com/pingcap/tiflow/dm/config"
@@ -32,31 +31,31 @@ import (
"github.com/pingcap/tiflow/dm/pkg/utils"
"github.com/pingcap/tiflow/dm/syncer/dbconn"
bf "github.com/pingcap/tiflow/pkg/binlog-filter"
+ "github.com/stretchr/testify/suite"
)
type testFilterSuite struct {
+ suite.Suite
baseConn *conn.BaseConn
db *sql.DB
}
-var _ = check.Suite(&testFilterSuite{})
-
-func (s *testFilterSuite) SetUpSuite(c *check.C) {
+func (s *testFilterSuite) SetupSuite() {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.db = db
mock.ExpectClose()
con, err := db.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.baseConn = conn.NewBaseConnForTest(con, nil)
}
-func (s *testFilterSuite) TearDownSuite(c *check.C) {
- c.Assert(s.baseConn.DBConn.Close(), check.IsNil)
- c.Assert(s.db.Close(), check.IsNil)
+func (s *testFilterSuite) TearDownSuite() {
+ s.Require().Nil(s.baseConn.DBConn.Close())
+ s.Require().Nil(s.db.Close())
}
-func (s *testFilterSuite) TestSkipQueryEvent(c *check.C) {
+func (s *testFilterSuite) TestSkipQueryEvent() {
cfg := &config.SubTaskConfig{
Flavor: mysql.MySQLFlavor,
BAList: &filter.Rules{
@@ -64,14 +63,14 @@ func (s *testFilterSuite) TestSkipQueryEvent(c *check.C) {
},
}
syncer := NewSyncer(cfg, nil, nil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().Nil(syncer.genRouter())
var err error
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.ddlDBConn = dbconn.NewDBConn(syncer.cfg, s.baseConn)
syncer.schemaTracker, err = schema.NewTestTracker(context.Background(), syncer.cfg.Name, syncer.ddlDBConn, log.L())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
defer syncer.schemaTracker.Close()
syncer.exprFilterGroup = NewExprFilterGroup(tcontext.Background(), utils.NewSessionCtx(nil), nil)
@@ -86,7 +85,7 @@ func (s *testFilterSuite) TestSkipQueryEvent(c *check.C) {
},
}
syncer.binlogFilter, err = bf.NewBinlogEvent(false, filterRules)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cases := []struct {
sql string
@@ -143,17 +142,17 @@ func (s *testFilterSuite) TestSkipQueryEvent(c *check.C) {
ddlSchema: ca.schema,
}
ddlInfo, err := ddlWorker.genDDLInfo(qec, ca.sql)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
qec.ddlSchema = ca.schema
qec.originSQL = ca.sql
skipped, err2 := syncer.skipQueryEvent(qec, ddlInfo)
- c.Assert(err2, check.IsNil)
- c.Assert(skipped, check.Equals, ca.expectSkipped)
- c.Assert(len(ddlInfo.originDDL) == 0, check.Equals, ca.isEmptySQL)
+ s.Require().Nil(err2)
+ s.Require().Equal(ca.expectSkipped, skipped)
+ s.Require().Equal(ca.isEmptySQL, len(ddlInfo.originDDL) == 0)
}
}
-func (s *testFilterSuite) TestSkipRowsEvent(c *check.C) {
+func (s *testFilterSuite) TestSkipRowsEvent() {
syncer := &Syncer{}
filterRules := []*bf.BinlogEventRule{
{
@@ -166,7 +165,7 @@ func (s *testFilterSuite) TestSkipRowsEvent(c *check.C) {
}
var err error
syncer.binlogFilter, err = bf.NewBinlogEvent(false, filterRules)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.onlineDDL = mockOnlinePlugin{}
cases := []struct {
@@ -196,12 +195,12 @@ func (s *testFilterSuite) TestSkipRowsEvent(c *check.C) {
}
for _, ca := range cases {
needSkip, err2 := syncer.skipRowsEvent(ca.table, ca.eventType)
- c.Assert(err2, check.IsNil)
- c.Assert(needSkip, check.Equals, ca.expected)
+ s.Require().Nil(err2)
+ s.Require().Equal(ca.expected, needSkip)
}
}
-func (s *testFilterSuite) TestSkipByFilter(c *check.C) {
+func (s *testFilterSuite) TestSkipByFilter() {
cfg := &config.SubTaskConfig{
Flavor: mysql.MySQLFlavor,
BAList: &filter.Rules{
@@ -211,7 +210,7 @@ func (s *testFilterSuite) TestSkipByFilter(c *check.C) {
syncer := NewSyncer(cfg, nil, nil)
var err error
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
// test binlog filter
filterRules := []*bf.BinlogEventRule{
{
@@ -239,7 +238,7 @@ func (s *testFilterSuite) TestSkipByFilter(c *check.C) {
},
}
syncer.binlogFilter, err = bf.NewBinlogEvent(false, filterRules)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cases := []struct {
sql string
@@ -267,12 +266,12 @@ func (s *testFilterSuite) TestSkipByFilter(c *check.C) {
}
for _, ca := range cases {
skipped, err2 := syncer.skipByFilter(ca.table, ca.eventType, ca.sql)
- c.Assert(err2, check.IsNil)
- c.Assert(skipped, check.Equals, ca.expectSkipped)
+ s.Require().Nil(err2)
+ s.Require().Equal(ca.expectSkipped, skipped)
}
}
-func (s *testFilterSuite) TestSkipByTable(c *check.C) {
+func (s *testFilterSuite) TestSkipByTable() {
cfg := &config.SubTaskConfig{
Flavor: mysql.MySQLFlavor,
BAList: &filter.Rules{
@@ -282,7 +281,7 @@ func (s *testFilterSuite) TestSkipByTable(c *check.C) {
syncer := NewSyncer(cfg, nil, nil)
var err error
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cases := []struct {
table *filter.Table
@@ -304,6 +303,6 @@ func (s *testFilterSuite) TestSkipByTable(c *check.C) {
}
for _, ca := range cases {
needSkip := syncer.skipByTable(ca.table)
- c.Assert(needSkip, check.Equals, ca.expected)
+ s.Require().Equal(ca.expected, needSkip)
}
}
diff --git a/dm/syncer/job_test.go b/dm/syncer/job_test.go
index 03519901e6..51997a344c 100644
--- a/dm/syncer/job_test.go
+++ b/dm/syncer/job_test.go
@@ -17,7 +17,6 @@ import (
"testing"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/util/filter"
cdcmodel "github.com/pingcap/tiflow/cdc/model"
"github.com/pingcap/tiflow/dm/pkg/binlog"
@@ -25,11 +24,7 @@ import (
"github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testJobSuite{})
-
-type testJobSuite struct{}
-
-func (t *testJobSuite) TestJobTypeString(c *check.C) {
+func TestJobTypeString(t *testing.T) {
testCases := []struct {
tp opType
str string
@@ -60,7 +55,7 @@ func (t *testJobSuite) TestJobTypeString(c *check.C) {
for _, testCase := range testCases {
tpStr := testCase.tp.String()
- c.Assert(tpStr, check.Equals, testCase.str)
+ require.Equal(t, testCase.str, tpStr)
}
}
@@ -113,13 +108,13 @@ func TestJob(t *testing.T) {
}
}
-func (t *testJobSuite) TestQueueBucketName(c *check.C) {
+func TestQueueBucketName(t *testing.T) {
name := queueBucketName(0)
- c.Assert(name, check.Equals, "q_0")
+ require.Equal(t, "q_0", name)
name = queueBucketName(8)
- c.Assert(name, check.Equals, "q_0")
+ require.Equal(t, "q_0", name)
name = queueBucketName(9)
- c.Assert(name, check.Equals, "q_1")
+ require.Equal(t, "q_1", name)
}
diff --git a/dm/syncer/safe-mode/mode_test.go b/dm/syncer/safe-mode/mode_test.go
index 59bd43fb70..b13ee25f3d 100644
--- a/dm/syncer/safe-mode/mode_test.go
+++ b/dm/syncer/safe-mode/mode_test.go
@@ -16,42 +16,34 @@ package mode
import (
"testing"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/util/filter"
tcontext "github.com/pingcap/tiflow/dm/pkg/context"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testModeSuite{})
-
-func TestSuite(t *testing.T) {
- check.TestingT(t)
-}
-
-type testModeSuite struct{}
-
-func (t *testModeSuite) TestMode(c *check.C) {
+func TestMode(t *testing.T) {
m := NewSafeMode()
- c.Assert(m.Enable(), check.IsFalse)
+ require.False(t, m.Enable())
tctx := tcontext.Background()
// Add 1
err := m.Add(tctx, 1)
- c.Assert(err, check.IsNil)
- c.Assert(m.Enable(), check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, m.Enable())
err = m.Add(tctx, -1)
- c.Assert(m.Enable(), check.IsFalse)
- c.Assert(err, check.IsNil)
+ require.False(t, m.Enable())
+ require.NoError(t, err)
// Add n
err = m.Add(tctx, 101)
- c.Assert(m.Enable(), check.IsTrue)
- c.Assert(err, check.IsNil)
+ require.True(t, m.Enable())
+ require.NoError(t, err)
err = m.Add(tctx, -1)
- c.Assert(m.Enable(), check.IsTrue)
- c.Assert(err, check.IsNil)
+ require.True(t, m.Enable())
+ require.NoError(t, err)
err = m.Add(tctx, -100)
- c.Assert(m.Enable(), check.IsFalse)
- c.Assert(err, check.IsNil)
+ require.False(t, m.Enable())
+ require.NoError(t, err)
// IncrForTable
table := &filter.Table{
@@ -59,27 +51,27 @@ func (t *testModeSuite) TestMode(c *check.C) {
Name: "table",
}
err = m.IncrForTable(tctx, table)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = m.IncrForTable(tctx, table) // re-Add
- c.Assert(err, check.IsNil)
- c.Assert(m.Enable(), check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, m.Enable())
err = m.DescForTable(tctx, table)
- c.Assert(err, check.IsNil)
- c.Assert(m.Enable(), check.IsFalse)
+ require.NoError(t, err)
+ require.False(t, m.Enable())
// Add n + IncrForTable
err = m.Add(tctx, 100)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = m.IncrForTable(tctx, table)
- c.Assert(err, check.IsNil)
- c.Assert(m.Enable(), check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, m.Enable())
err = m.Add(tctx, -100)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
err = m.DescForTable(tctx, table)
- c.Assert(m.Enable(), check.IsFalse)
- c.Assert(err, check.IsNil)
+ require.False(t, m.Enable())
+ require.NoError(t, err)
// Add becomes to negative
err = m.Add(tctx, -1)
- c.Assert(err, check.NotNil)
+ require.Error(t, err)
}
diff --git a/dm/syncer/shardddl/optimist_test.go b/dm/syncer/shardddl/optimist_test.go
index 17ec11c55c..5a3b2f8d94 100644
--- a/dm/syncer/shardddl/optimist_test.go
+++ b/dm/syncer/shardddl/optimist_test.go
@@ -16,8 +16,8 @@ package shardddl
import (
"context"
"fmt"
+ "testing"
- "github.com/pingcap/check"
tiddl "github.com/pingcap/tidb/pkg/ddl"
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/parser"
@@ -27,35 +27,32 @@ import (
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/shardddl/optimism"
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
)
-type testOptimist struct{}
-
-var _ = check.Suite(&testOptimist{})
-
// clear keys in etcd test cluster.
-func clearOptimistTestSourceInfoOperation(c *check.C) {
- c.Assert(optimism.ClearTestInfoOperationColumn(etcdTestCli), check.IsNil)
+func clearOptimistTestSourceInfoOperation(t *testing.T) {
+ require.NoError(t, optimism.ClearTestInfoOperationColumn(etcdTestCli))
}
-func createTableInfo(c *check.C, p *parser.Parser, se sessionctx.Context, tableID int64, sql string) *model.TableInfo {
+func createTableInfo(t *testing.T, p *parser.Parser, se sessionctx.Context, tableID int64, sql string) *model.TableInfo {
node, err := p.ParseOneStmt(sql, "utf8mb4", "utf8mb4_bin")
if err != nil {
- c.Fatalf("fail to parse stmt, %v", err)
+ t.Fatalf("fail to parse stmt, %v", err)
}
createStmtNode, ok := node.(*ast.CreateTableStmt)
if !ok {
- c.Fatalf("%s is not a CREATE TABLE statement", sql)
+ t.Fatalf("%s is not a CREATE TABLE statement", sql)
}
info, err := tiddl.MockTableInfo(se, createStmtNode, tableID)
if err != nil {
- c.Fatalf("fail to create table info, %v", err)
+ t.Fatalf("fail to create table info, %v", err)
}
return info
}
-func (t *testOptimist) TestOptimist(c *check.C) {
- defer clearOptimistTestSourceInfoOperation(c)
+func testOptimist(t *testing.T) {
+ defer clearOptimistTestSourceInfoOperation(t)
var (
task = "task-optimist"
@@ -77,9 +74,9 @@ func (t *testOptimist) TestOptimist(c *check.C) {
tblID int64 = 222
DDLs1 = []string{"ALTER TABLE bar ADD COLUMN c1 TEXT"}
DDLs2 = []string{"ALTER TABLE bar ADD COLUMN c1 DATETIME"}
- tiBefore = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
- tiAfter1 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
- tiAfter2 = createTableInfo(c, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
+ tiBefore = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY)`)
+ tiAfter1 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 TEXT)`)
+ tiAfter2 = createTableInfo(t, p, se, tblID, `CREATE TABLE bar (id INT PRIMARY KEY, c1 DATETIME)`)
info1 = o.ConstructInfo("foo-1", "bar-1", downSchema, downTable, DDLs1, tiBefore, []*model.TableInfo{tiAfter1})
op1 = optimism.NewOperation(ID, task, source, info1.UpSchema, info1.UpTable, DDLs1, optimism.ConflictNone, "", false, []string{})
info2 = o.ConstructInfo("foo-1", "bar-2", downSchema, downTable, DDLs2, tiBefore, []*model.TableInfo{tiAfter2})
@@ -95,116 +92,116 @@ func (t *testOptimist) TestOptimist(c *check.C) {
defer cancel()
tables := o.Tables()
- c.Assert(len(tables), check.Equals, 0)
+ require.Equal(t, 0, len(tables))
// init with some source tables.
err := o.Init(sourceTables)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
stm, _, err := optimism.GetAllSourceTables(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(stm, check.HasLen, 1)
- c.Assert(stm[task], check.HasLen, 1)
- c.Assert(stm[task][source], check.DeepEquals, o.tables)
+ require.NoError(t, err)
+ require.Len(t, stm, 1)
+ require.Len(t, stm[task], 1)
+ require.Equal(t, o.tables, stm[task][source])
tables = o.Tables()
- c.Assert(len(tables), check.Equals, 4)
+ require.Equal(t, 4, len(tables))
// no info and operation in pending.
- c.Assert(o.PendingInfo(), check.IsNil)
- c.Assert(o.PendingOperation(), check.IsNil)
+ require.Nil(t, o.PendingInfo())
+ require.Nil(t, o.PendingOperation())
// put shard DDL info.
rev1, err := o.PutInfo(info1)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
+ require.NoError(t, err)
+ require.Greater(t, rev1, int64(0))
// have info in pending.
info1c := o.PendingInfo()
- c.Assert(info1c, check.NotNil)
- c.Assert(*info1c, check.DeepEquals, info1)
+ require.NotNil(t, info1c)
+ require.Equal(t, info1, *info1c)
// put the lock operation.
rev2, putted, err := optimism.PutOperation(etcdTestCli, false, op1, rev1)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(putted, check.IsTrue)
+ require.NoError(t, err)
+ require.Greater(t, rev2, rev1)
+ require.True(t, putted)
// wait for the lock operation.
op1c, err := o.GetOperation(ctx, info1, rev1)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
op1.Revision = rev2
- c.Assert(op1c, check.DeepEquals, op1)
+ require.Equal(t, op1, op1c)
// have operation in pending.
op1cc := o.PendingOperation()
- c.Assert(op1cc, check.NotNil)
- c.Assert(*op1cc, check.DeepEquals, op1)
+ require.NotNil(t, op1cc)
+ require.Equal(t, op1, *op1cc)
// mark the operation as done.
- c.Assert(o.DoneOperation(op1), check.IsNil)
+ require.NoError(t, o.DoneOperation(op1))
// verify the operation and info.
ifm, _, err := optimism.GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 1)
- c.Assert(ifm[task], check.HasLen, 1)
- c.Assert(ifm[task][source], check.HasLen, 1)
- c.Assert(ifm[task][source][info1.UpSchema], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, ifm, 1)
+ require.Len(t, ifm[task], 1)
+ require.Len(t, ifm[task][source], 1)
+ require.Len(t, ifm[task][source][info1.UpSchema], 1)
info1WithVer := info1
info1WithVer.Version = 1
info1WithVer.Revision = rev1
- c.Assert(ifm[task][source][info1.UpSchema][info1.UpTable], check.DeepEquals, info1WithVer)
+ require.Equal(t, info1WithVer, ifm[task][source][info1.UpSchema][info1.UpTable])
opc := op1c
opc.Done = true
opm, _, err := optimism.GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
- c.Assert(opm[task], check.HasLen, 1)
- c.Assert(opm[task][source], check.HasLen, 1)
- c.Assert(opm[task][source][op1.UpSchema], check.HasLen, 1)
+ require.NoError(t, err)
+ require.Len(t, opm, 1)
+ require.Len(t, opm[task], 1)
+ require.Len(t, opm[task][source], 1)
+ require.Len(t, opm[task][source][op1.UpSchema], 1)
// Revision is in DoneOperation, skip this check
opc.Revision = opm[task][source][op1.UpSchema][op1.UpTable].Revision
- c.Assert(opm[task][source][op1.UpSchema][op1.UpTable], check.DeepEquals, opc)
+ require.Equal(t, opc, opm[task][source][op1.UpSchema][op1.UpTable])
// no info and operation in pending now.
- c.Assert(o.PendingInfo(), check.IsNil)
- c.Assert(o.PendingOperation(), check.IsNil)
+ require.Nil(t, o.PendingInfo())
+ require.Nil(t, o.PendingOperation())
// handle `CREATE TABLE`.
rev3, err := o.AddTable(infoCreate)
- c.Assert(err, check.IsNil)
- c.Assert(rev3, check.Greater, rev2)
+ require.NoError(t, err)
+ require.Greater(t, rev3, rev2)
// handle `DROP TABLE`.
rev4, err := o.RemoveTable(infoDrop)
- c.Assert(err, check.IsNil)
- c.Assert(rev4, check.Greater, rev3)
+ require.NoError(t, err)
+ require.Greater(t, rev4, rev3)
ifm, _, err = optimism.GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm[task][source][infoDrop.UpSchema], check.IsNil)
- c.Assert(o.tables.Tables[infoCreate.DownSchema][infoCreate.DownTable][infoCreate.UpSchema], check.IsNil)
+ require.NoError(t, err)
+ require.Nil(t, ifm[task][source][infoDrop.UpSchema])
+ require.Nil(t, o.tables.Tables[infoCreate.DownSchema][infoCreate.DownTable][infoCreate.UpSchema])
// put another info.
rev5, err := o.PutInfo(info2)
- c.Assert(err, check.IsNil)
- c.Assert(o.PendingInfo(), check.NotNil)
- c.Assert(*o.PendingInfo(), check.DeepEquals, info2)
- c.Assert(o.PendingOperation(), check.IsNil)
+ require.NoError(t, err)
+ require.NotNil(t, o.PendingInfo())
+ require.Equal(t, info2, *o.PendingInfo())
+ require.Nil(t, o.PendingOperation())
// put another lock operation.
rev6, putted, err := optimism.PutOperation(etcdTestCli, false, op2, rev5)
- c.Assert(err, check.IsNil)
- c.Assert(rev6, check.Greater, rev5)
- c.Assert(putted, check.IsTrue)
+ require.NoError(t, err)
+ require.Greater(t, rev6, rev5)
+ require.True(t, putted)
// wait for the lock operation.
_, err = o.GetOperation(ctx, info2, rev5)
- c.Assert(err, check.IsNil)
- c.Assert(o.PendingOperation(), check.NotNil)
+ require.NoError(t, err)
+ require.NotNil(t, o.PendingOperation())
op2.Revision = rev6
- c.Assert(*o.PendingOperation(), check.DeepEquals, op2)
+ require.Equal(t, op2, *o.PendingOperation())
// reset the optimist.
o.Reset()
- c.Assert(o.PendingInfo(), check.IsNil)
- c.Assert(o.PendingOperation(), check.IsNil)
+ require.Nil(t, o.PendingInfo())
+ require.Nil(t, o.PendingOperation())
}
diff --git a/dm/syncer/shardddl/pessimist_test.go b/dm/syncer/shardddl/pessimist_test.go
index c54d2bb1f4..91449ffc31 100644
--- a/dm/syncer/shardddl/pessimist_test.go
+++ b/dm/syncer/shardddl/pessimist_test.go
@@ -18,20 +18,16 @@ import (
"testing"
"time"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/common"
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/pkg/shardddl/pessimism"
+ "github.com/stretchr/testify/require"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/tests/v3/integration"
)
var etcdTestCli *clientv3.Client
-type testPessimist struct{}
-
-var _ = check.Suite(&testPessimist{})
-
func TestShardDDL(t *testing.T) {
err := log.InitLogger(&log.Config{})
if err != nil {
@@ -44,19 +40,20 @@ func TestShardDDL(t *testing.T) {
etcdTestCli = mockCluster.RandClient()
- check.TestingT(t)
+ t.Run("Pessimist", testPessimist)
+ t.Run("Optimist", testOptimist)
}
// clear keys in etcd test cluster.
-func clearTestInfoOperation(c *check.C) {
+func clearTestInfoOperation(t *testing.T) {
clearInfo := clientv3.OpDelete(common.ShardDDLPessimismInfoKeyAdapter.Path(), clientv3.WithPrefix())
clearOp := clientv3.OpDelete(common.ShardDDLPessimismOperationKeyAdapter.Path(), clientv3.WithPrefix())
_, err := etcdTestCli.Txn(context.Background()).Then(clearInfo, clearOp).Commit()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
}
-func (t *testPessimist) TestPessimist(c *check.C) {
- defer clearTestInfoOperation(c)
+func testPessimist(t *testing.T) {
+ defer clearTestInfoOperation(t)
var (
task = "task"
@@ -75,84 +72,84 @@ func (t *testPessimist) TestPessimist(c *check.C) {
defer cancel()
// no info and operation in pending
- c.Assert(p.PendingInfo(), check.IsNil)
- c.Assert(p.PendingOperation(), check.IsNil)
+ require.Nil(t, p.PendingInfo())
+ require.Nil(t, p.PendingOperation())
// put shard DDL info.
rev1, err := p.PutInfo(ctx, info)
- c.Assert(err, check.IsNil)
- c.Assert(rev1, check.Greater, int64(0))
+ require.NoError(t, err)
+ require.Greater(t, rev1, int64(0))
// have info in pending
info2 := p.PendingInfo()
- c.Assert(info2, check.NotNil)
- c.Assert(*info2, check.DeepEquals, info)
+ require.NotNil(t, info2)
+ require.Equal(t, info, *info2)
// put the lock operation.
rev2, putted, err := pessimism.PutOperations(etcdTestCli, false, op)
- c.Assert(err, check.IsNil)
- c.Assert(rev2, check.Greater, rev1)
- c.Assert(putted, check.IsTrue)
+ require.NoError(t, err)
+ require.Greater(t, rev2, rev1)
+ require.True(t, putted)
// wait for the lock operation.
op2, err := p.GetOperation(ctx, info, rev1)
- c.Assert(err, check.IsNil)
- c.Assert(op2, check.DeepEquals, op)
+ require.NoError(t, err)
+ require.Equal(t, op, op2)
// have operation in pending.
op3 := p.PendingOperation()
- c.Assert(op3, check.NotNil)
- c.Assert(*op3, check.DeepEquals, op)
+ require.NotNil(t, op3)
+ require.Equal(t, op, *op3)
// mark the operation as done and delete the info.
- c.Assert(p.DoneOperationDeleteInfo(op, info), check.IsNil)
+ require.NoError(t, p.DoneOperationDeleteInfo(op, info))
// make this op reentrant.
- c.Assert(p.DoneOperationDeleteInfo(op, info), check.IsNil)
+ require.NoError(t, p.DoneOperationDeleteInfo(op, info))
// verify the operation and info.
opc := op2
opc.Done = true
opm, _, err := pessimism.GetAllOperations(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(opm, check.HasLen, 1)
- c.Assert(opm[task], check.HasLen, 1)
- c.Assert(opm[task][source], check.DeepEquals, opc)
+ require.NoError(t, err)
+ require.Len(t, opm, 1)
+ require.Len(t, opm[task], 1)
+ require.Equal(t, opc, opm[task][source])
ifm, _, err := pessimism.GetAllInfo(etcdTestCli)
- c.Assert(err, check.IsNil)
- c.Assert(ifm, check.HasLen, 0)
+ require.NoError(t, err)
+ require.Len(t, ifm, 0)
// no info and operation in pending now.
- c.Assert(p.PendingInfo(), check.IsNil)
- c.Assert(p.PendingOperation(), check.IsNil)
+ require.Nil(t, p.PendingInfo())
+ require.Nil(t, p.PendingOperation())
// try to put info again, but timeout because a `done` operation exist in etcd.
ctx2, cancel2 := context.WithTimeout(ctx, time.Second)
defer cancel2()
_, err = p.PutInfo(ctx2, info)
- c.Assert(err, check.Equals, context.DeadlineExceeded)
+ require.Equal(t, context.DeadlineExceeded, err)
// start a goroutine to delete the `done` operation in background, then we can put info again.
go func() {
time.Sleep(500 * time.Millisecond) // wait `PutInfo` to start watch the deletion of the operation.
_, err2 := pessimism.DeleteOperations(etcdTestCli, op)
- c.Assert(err2, check.IsNil)
+ require.NoError(t, err2)
}()
// put info again, but do not complete the flow.
_, err = p.PutInfo(ctx, info)
- c.Assert(err, check.IsNil)
- c.Assert(p.PendingInfo(), check.NotNil)
+ require.NoError(t, err)
+ require.NotNil(t, p.PendingInfo())
// put the lock operation again.
rev3, _, err := pessimism.PutOperations(etcdTestCli, false, op)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// wait for the lock operation.
_, err = p.GetOperation(ctx, info, rev3)
- c.Assert(err, check.IsNil)
- c.Assert(p.PendingOperation(), check.NotNil)
+ require.NoError(t, err)
+ require.NotNil(t, p.PendingOperation())
// reset the pessimist.
p.Reset()
- c.Assert(p.PendingInfo(), check.IsNil)
- c.Assert(p.PendingOperation(), check.IsNil)
+ require.Nil(t, p.PendingInfo())
+ require.Nil(t, p.PendingOperation())
}
diff --git a/dm/syncer/sharding-meta/shardmeta_test.go b/dm/syncer/sharding-meta/shardmeta_test.go
index a662e904d7..2940476a8a 100644
--- a/dm/syncer/sharding-meta/shardmeta_test.go
+++ b/dm/syncer/sharding-meta/shardmeta_test.go
@@ -18,19 +18,11 @@ import (
"testing"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/binlog"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testShardMetaSuite{})
-
-func TestSuite(t *testing.T) {
- check.TestingT(t)
-}
-
-type testShardMetaSuite struct{}
-
-func (t *testShardMetaSuite) TestShardingMeta(c *check.C) {
+func TestShardingMeta(t *testing.T) {
var (
active bool
err error
@@ -62,45 +54,45 @@ func (t *testShardMetaSuite) TestShardingMeta(c *check.C) {
// 1st round sharding DDL sync
for i := 0; i < 7; i++ {
active, err = meta.AddItem(items[i])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if i%3 == 0 {
- c.Assert(active, check.IsTrue)
+ require.True(t, active)
} else {
- c.Assert(active, check.IsFalse)
+ require.False(t, active)
}
}
- c.Assert(meta.GetGlobalItems(), check.DeepEquals, []*DDLItem{items[0], items[1], items[2]})
- c.Assert(meta.GetGlobalActiveDDL(), check.DeepEquals, items[0])
- c.Assert(meta.GetActiveDDLItem(table1), check.DeepEquals, items[0])
- c.Assert(meta.GetActiveDDLItem(table2), check.DeepEquals, items[3])
- c.Assert(meta.GetActiveDDLItem(table3), check.DeepEquals, items[6])
- c.Assert(meta.InSequenceSharding(), check.IsTrue)
+ require.Equal(t, []*DDLItem{items[0], items[1], items[2]}, meta.GetGlobalItems())
+ require.Equal(t, items[0], meta.GetGlobalActiveDDL())
+ require.Equal(t, items[0], meta.GetActiveDDLItem(table1))
+ require.Equal(t, items[3], meta.GetActiveDDLItem(table2))
+ require.Equal(t, items[6], meta.GetActiveDDLItem(table3))
+ require.True(t, meta.InSequenceSharding())
location, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(location.Position, check.DeepEquals, items[0].FirstLocation.Position)
+ require.NoError(t, err)
+ require.Equal(t, items[0].FirstLocation.Position, location.Position)
// find synced in shrading group, and call ShardingMeta.ResolveShardingDDL
- c.Assert(meta.ResolveShardingDDL(), check.IsFalse)
+ require.False(t, meta.ResolveShardingDDL())
- c.Assert(meta.GetGlobalActiveDDL(), check.DeepEquals, items[1])
- c.Assert(meta.GetActiveDDLItem(table1), check.DeepEquals, items[1])
- c.Assert(meta.GetActiveDDLItem(table2), check.DeepEquals, items[4])
- c.Assert(meta.GetActiveDDLItem(table3), check.IsNil)
- c.Assert(meta.InSequenceSharding(), check.IsTrue)
+ require.Equal(t, items[1], meta.GetGlobalActiveDDL())
+ require.Equal(t, items[1], meta.GetActiveDDLItem(table1))
+ require.Equal(t, items[4], meta.GetActiveDDLItem(table2))
+ require.Nil(t, meta.GetActiveDDLItem(table3))
+ require.True(t, meta.InSequenceSharding())
location, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(location.Position, check.DeepEquals, items[1].FirstLocation.Position)
+ require.NoError(t, err)
+ require.Equal(t, items[1].FirstLocation.Position, location.Position)
sqls, args = meta.FlushData(sourceID, tableID)
- c.Assert(sqls, check.HasLen, 4)
- c.Assert(args, check.HasLen, 4)
+ require.Len(t, sqls, 4)
+ require.Len(t, args, 4)
for _, stmt := range sqls {
- c.Assert(stmt, check.Matches, "INSERT INTO .*")
+ require.Regexp(t, "INSERT INTO .*", stmt)
}
for _, arg := range args {
- c.Assert(arg, check.HasLen, 8)
- c.Assert(arg[3], check.Equals, 1)
+ require.Len(t, arg, 8)
+ require.Equal(t, 1, arg[3])
}
// 2nd round sharding DDL sync
@@ -109,44 +101,44 @@ func (t *testShardMetaSuite) TestShardingMeta(c *check.C) {
continue
}
active, err = meta.AddItem(items[i])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if i%3 == 1 {
- c.Assert(active, check.IsTrue)
+ require.True(t, active)
} else {
- c.Assert(active, check.IsFalse)
+ require.False(t, active)
}
}
- c.Assert(meta.GetGlobalActiveDDL(), check.DeepEquals, items[1])
- c.Assert(meta.GetActiveDDLItem(table1), check.DeepEquals, items[1])
- c.Assert(meta.GetActiveDDLItem(table2), check.DeepEquals, items[4])
- c.Assert(meta.GetActiveDDLItem(table3), check.DeepEquals, items[7])
- c.Assert(meta.InSequenceSharding(), check.IsTrue)
+ require.Equal(t, items[1], meta.GetGlobalActiveDDL())
+ require.Equal(t, items[1], meta.GetActiveDDLItem(table1))
+ require.Equal(t, items[4], meta.GetActiveDDLItem(table2))
+ require.Equal(t, items[7], meta.GetActiveDDLItem(table3))
+ require.True(t, meta.InSequenceSharding())
location, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(location.Position, check.DeepEquals, items[1].FirstLocation.Position)
+ require.NoError(t, err)
+ require.Equal(t, items[1].FirstLocation.Position, location.Position)
// find synced in shrading group, and call ShardingMeta.ResolveShardingDDL
- c.Assert(meta.ResolveShardingDDL(), check.IsFalse)
+ require.False(t, meta.ResolveShardingDDL())
- c.Assert(meta.GetGlobalActiveDDL(), check.DeepEquals, items[2])
- c.Assert(meta.GetActiveDDLItem(table1), check.DeepEquals, items[2])
- c.Assert(meta.GetActiveDDLItem(table2), check.DeepEquals, items[5])
- c.Assert(meta.GetActiveDDLItem(table3), check.IsNil)
- c.Assert(meta.InSequenceSharding(), check.IsTrue)
+ require.Equal(t, items[2], meta.GetGlobalActiveDDL())
+ require.Equal(t, items[2], meta.GetActiveDDLItem(table1))
+ require.Equal(t, items[5], meta.GetActiveDDLItem(table2))
+ require.Nil(t, meta.GetActiveDDLItem(table3))
+ require.True(t, meta.InSequenceSharding())
location, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(location.Position, check.DeepEquals, items[2].FirstLocation.Position)
+ require.NoError(t, err)
+ require.Equal(t, items[2].FirstLocation.Position, location.Position)
sqls, args = meta.FlushData(sourceID, tableID)
- c.Assert(sqls, check.HasLen, 4)
- c.Assert(args, check.HasLen, 4)
+ require.Len(t, sqls, 4)
+ require.Len(t, args, 4)
for _, stmt := range sqls {
- c.Assert(stmt, check.Matches, "INSERT INTO .*")
+ require.Regexp(t, "INSERT INTO .*", stmt)
}
for _, arg := range args {
- c.Assert(arg, check.HasLen, 8)
- c.Assert(arg[3], check.Equals, 2)
+ require.Len(t, arg, 8)
+ require.Equal(t, 2, arg[3])
}
// 3rd round sharding DDL sync
@@ -155,41 +147,42 @@ func (t *testShardMetaSuite) TestShardingMeta(c *check.C) {
continue
}
active, err = meta.AddItem(items[i])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if i%3 == 2 {
- c.Assert(active, check.IsTrue)
+ require.True(t, active)
} else {
- c.Assert(active, check.IsFalse)
+ require.False(t, active)
}
}
- c.Assert(meta.GetGlobalActiveDDL(), check.DeepEquals, items[2])
- c.Assert(meta.GetActiveDDLItem(table1), check.DeepEquals, items[2])
- c.Assert(meta.GetActiveDDLItem(table2), check.DeepEquals, items[5])
- c.Assert(meta.GetActiveDDLItem(table3), check.DeepEquals, items[8])
- c.Assert(meta.InSequenceSharding(), check.IsTrue)
+ require.Equal(t, items[2], meta.GetGlobalActiveDDL())
+ require.Equal(t, items[2], meta.GetActiveDDLItem(table1))
+ require.Equal(t, items[5], meta.GetActiveDDLItem(table2))
+ require.Equal(t, items[8], meta.GetActiveDDLItem(table3))
+ require.True(t, meta.InSequenceSharding())
location, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(location.Position, check.DeepEquals, items[2].FirstLocation.Position)
+ require.NoError(t, err)
+ require.Equal(t, items[2].FirstLocation.Position, location.Position)
// find synced in shrading group, and call ShardingMeta.ResolveShardingDDL
- c.Assert(meta.ResolveShardingDDL(), check.IsTrue)
+ require.True(t, meta.ResolveShardingDDL())
- c.Assert(meta.GetGlobalActiveDDL(), check.IsNil)
- c.Assert(meta.GetActiveDDLItem(table1), check.IsNil)
- c.Assert(meta.GetActiveDDLItem(table2), check.IsNil)
- c.Assert(meta.GetActiveDDLItem(table3), check.IsNil)
- c.Assert(meta.InSequenceSharding(), check.IsFalse)
+ require.Nil(t, meta.GetGlobalActiveDDL())
+ require.Nil(t, meta.GetActiveDDLItem(table1))
+ require.Nil(t, meta.GetActiveDDLItem(table2))
+ require.Nil(t, meta.GetActiveDDLItem(table3))
+ require.False(t, meta.InSequenceSharding())
_, err = meta.ActiveDDLFirstLocation()
- c.Assert(err, check.ErrorMatches, fmt.Sprintf("\\[.*\\], Message: activeIdx %d larger than length of global DDLItems: .*", meta.ActiveIdx()))
+ require.Error(t, err)
+ require.Regexp(t, fmt.Sprintf("\\[.*\\], Message: activeIdx %d larger than length of global DDLItems: .*", meta.ActiveIdx()), err.Error())
sqls, args = meta.FlushData(sourceID, tableID)
- c.Assert(sqls, check.HasLen, 1)
- c.Assert(args, check.HasLen, 1)
- c.Assert(sqls[0], check.Matches, "DELETE FROM .*")
- c.Assert(args[0], check.DeepEquals, []interface{}{sourceID, tableID})
+ require.Len(t, sqls, 1)
+ require.Len(t, args, 1)
+ require.Regexp(t, "DELETE FROM .*", sqls[0])
+ require.Equal(t, []interface{}{sourceID, tableID}, args[0])
}
-func (t *testShardMetaSuite) TestShardingMetaWrongSequence(c *check.C) {
+func TestShardingMetaWrongSequence(t *testing.T) {
var (
active bool
err error
@@ -210,15 +203,15 @@ func (t *testShardMetaSuite) TestShardingMetaWrongSequence(c *check.C) {
// 1st round sharding DDL sync
for i := 0; i < 4; i++ {
active, err = meta.AddItem(items[i])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if i%3 == 0 {
- c.Assert(active, check.IsTrue)
+ require.True(t, active)
} else {
- c.Assert(active, check.IsFalse)
+ require.False(t, active)
}
}
// find synced in shrading group, and call ShardingMeta.ResolveShardingDDL
- c.Assert(meta.ResolveShardingDDL(), check.IsFalse)
+ require.False(t, meta.ResolveShardingDDL())
// 2nd round sharding DDL sync
for i := 0; i < 4; i++ {
@@ -226,19 +219,20 @@ func (t *testShardMetaSuite) TestShardingMetaWrongSequence(c *check.C) {
continue
}
active, err = meta.AddItem(items[i])
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if i%3 == 1 {
- c.Assert(active, check.IsTrue)
+ require.True(t, active)
} else {
- c.Assert(active, check.IsFalse)
+ require.False(t, active)
}
}
active, err = meta.AddItem(items[4])
- c.Assert(active, check.IsFalse)
- c.Assert(err, check.ErrorMatches, "\\[.*\\], Message: detect inconsistent DDL sequence from source .*, right DDL sequence should be .*")
+ require.False(t, active)
+ require.Error(t, err)
+ require.Regexp(t, "\\[.*\\], Message: detect inconsistent DDL sequence from source .*, right DDL sequence should be .*", err.Error())
}
-func (t *testShardMetaSuite) TestFlushLoadMeta(c *check.C) {
+func TestFlushLoadMeta(t *testing.T) {
var (
active bool
err error
@@ -258,21 +252,21 @@ func (t *testShardMetaSuite) TestFlushLoadMeta(c *check.C) {
)
for _, item := range items {
active, err = meta.AddItem(item)
- c.Assert(err, check.IsNil)
- c.Assert(active, check.IsTrue)
+ require.NoError(t, err)
+ require.True(t, active)
}
sqls, args := meta.FlushData(sourceID, tableID)
- c.Assert(sqls, check.HasLen, 3)
- c.Assert(args, check.HasLen, 3)
+ require.Len(t, sqls, 3)
+ require.Len(t, args, 3)
for _, arg := range args {
- c.Assert(arg, check.HasLen, 8)
- c.Assert(loadedMeta.RestoreFromData(arg[2].(string), arg[3].(int), arg[4].(bool), []byte(arg[5].(string)), mysql.MySQLFlavor), check.IsNil)
+ require.Len(t, arg, 8)
+ require.NoError(t, loadedMeta.RestoreFromData(arg[2].(string), arg[3].(int), arg[4].(bool), []byte(arg[5].(string)), mysql.MySQLFlavor))
}
- c.Assert(loadedMeta.activeIdx, check.Equals, meta.activeIdx)
- c.Assert(loadedMeta.global.String(), check.Equals, meta.global.String())
- c.Assert(loadedMeta.tableName, check.Equals, meta.tableName)
- c.Assert(len(loadedMeta.sources), check.Equals, len(meta.sources))
+ require.Equal(t, meta.activeIdx, loadedMeta.activeIdx)
+ require.Equal(t, meta.global.String(), loadedMeta.global.String())
+ require.Equal(t, meta.tableName, loadedMeta.tableName)
+ require.Equal(t, len(meta.sources), len(loadedMeta.sources))
for table, source := range loadedMeta.sources {
- c.Assert(source.String(), check.Equals, meta.sources[table].String())
+ require.Equal(t, meta.sources[table].String(), source.String())
}
}
diff --git a/dm/syncer/sharding_group_test.go b/dm/syncer/sharding_group_test.go
index e2d70ef5bd..1d5a81277c 100644
--- a/dm/syncer/sharding_group_test.go
+++ b/dm/syncer/sharding_group_test.go
@@ -20,7 +20,6 @@ import (
"github.com/DATA-DOG/go-sqlmock"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/util/dbutil"
"github.com/pingcap/tidb/pkg/util/filter"
"github.com/pingcap/tiflow/dm/config"
@@ -33,10 +32,9 @@ import (
"github.com/pingcap/tiflow/dm/pkg/terror"
"github.com/pingcap/tiflow/dm/pkg/utils"
"github.com/pingcap/tiflow/dm/syncer/dbconn"
+ "github.com/stretchr/testify/suite"
)
-var _ = check.Suite(&testShardingGroupSuite{})
-
var (
targetTbl = &filter.Table{
Schema: "target_db",
@@ -66,10 +64,11 @@ var (
)
type testShardingGroupSuite struct {
+ suite.Suite
cfg *config.SubTaskConfig
}
-func (t *testShardingGroupSuite) SetUpSuite(c *check.C) {
+func (t *testShardingGroupSuite) SetupSuite() {
t.cfg = &config.SubTaskConfig{
SourceID: "mysql-replica-01",
MetaSchema: "test",
@@ -77,100 +76,100 @@ func (t *testShardingGroupSuite) SetUpSuite(c *check.C) {
}
}
-func (t *testShardingGroupSuite) TestLowestFirstPosInGroups(c *check.C) {
+func (t *testShardingGroupSuite) TestLowestFirstPosInGroups() {
k := NewShardingGroupKeeper(tcontext.Background(), t.cfg, nil)
g1 := NewShardingGroup(k.cfg.SourceID, k.shardMetaSchema, k.shardMetaTable, []string{"db1.tbl1", "db1.tbl2"}, nil, false, "", false)
// nolint:dogsled
_, _, _, err := g1.TrySync("db1.tbl1", pos11, endPos11, ddls1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// lowest
g2 := NewShardingGroup(k.cfg.SourceID, k.shardMetaSchema, k.shardMetaTable, []string{"db2.tbl1", "db2.tbl2"}, nil, false, "", false)
// nolint:dogsled
_, _, _, err = g2.TrySync("db2.tbl1", pos21, endPos21, ddls1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
g3 := NewShardingGroup(k.cfg.SourceID, k.shardMetaSchema, k.shardMetaTable, []string{"db3.tbl1", "db3.tbl2"}, nil, false, "", false)
// nolint:dogsled
_, _, _, err = g3.TrySync("db3.tbl1", pos3, endPos3, ddls1)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
k.groups["db1.tbl"] = g1
k.groups["db2.tbl"] = g2
k.groups["db3.tbl"] = g3
- c.Assert(k.lowestFirstLocationInGroups().Position, check.DeepEquals, pos21.Position)
+ t.Require().Equal(pos21.Position, k.lowestFirstLocationInGroups().Position)
}
-func (t *testShardingGroupSuite) TestMergeAndLeave(c *check.C) {
+func (t *testShardingGroupSuite) TestMergeAndLeave() {
k := NewShardingGroupKeeper(tcontext.Background(), t.cfg, nil)
g1 := NewShardingGroup(k.cfg.SourceID, k.shardMetaSchema, k.shardMetaTable, []string{source1, source2}, nil, false, "", false)
- c.Assert(g1.Sources(), check.DeepEquals, map[string]bool{source1: false, source2: false})
+ t.Require().Equal(map[string]bool{source1: false, source2: false}, g1.Sources())
needShardingHandle, synced, remain, err := g1.Merge([]string{source3})
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsFalse)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 3)
+ t.Require().NoError(err)
+ t.Require().False(needShardingHandle)
+ t.Require().False(synced)
+ t.Require().Equal(3, remain)
// repeat merge has no side effect
needShardingHandle, synced, remain, err = g1.Merge([]string{source3})
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsFalse)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 3)
+ t.Require().NoError(err)
+ t.Require().False(needShardingHandle)
+ t.Require().False(synced)
+ t.Require().Equal(3, remain)
err = g1.Leave([]string{source1})
- c.Assert(err, check.IsNil)
- c.Assert(g1.Sources(), check.DeepEquals, map[string]bool{source3: false, source2: false})
+ t.Require().NoError(err)
+ t.Require().Equal(map[string]bool{source3: false, source2: false}, g1.Sources())
// repeat leave has no side effect
err = g1.Leave([]string{source1})
- c.Assert(err, check.IsNil)
- c.Assert(g1.Sources(), check.DeepEquals, map[string]bool{source3: false, source2: false})
+ t.Require().NoError(err)
+ t.Require().Equal(map[string]bool{source3: false, source2: false}, g1.Sources())
ddls := []string{"DUMMY DDL"}
pos1 := mysql.Position{Name: "mysql-bin.000002", Pos: 123}
endPos1 := mysql.Position{Name: "mysql-bin.000002", Pos: 456}
// nolint:dogsled
_, _, _, err = g1.TrySync(source1, binlog.Location{Position: pos1}, binlog.Location{Position: endPos1}, ddls)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// nolint:dogsled
_, _, _, err = g1.Merge([]string{source1})
- c.Assert(terror.ErrSyncUnitAddTableInSharding.Equal(err), check.IsTrue)
+ t.Require().True(terror.ErrSyncUnitAddTableInSharding.Equal(err))
err = g1.Leave([]string{source2})
- c.Assert(terror.ErrSyncUnitDropSchemaTableInSharding.Equal(err), check.IsTrue)
+ t.Require().True(terror.ErrSyncUnitDropSchemaTableInSharding.Equal(err))
}
-func (t *testShardingGroupSuite) TestSync(c *check.C) {
+func (t *testShardingGroupSuite) TestSync() {
k := NewShardingGroupKeeper(tcontext.Background(), t.cfg, nil)
g1 := NewShardingGroup(k.cfg.SourceID, k.shardMetaSchema, k.shardMetaTable, []string{source1, source2}, nil, false, "", false)
synced, active, remain, err := g1.TrySync(source1, pos11, endPos11, ddls1)
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(active, check.IsTrue)
- c.Assert(remain, check.Equals, 1)
+ t.Require().NoError(err)
+ t.Require().False(synced)
+ t.Require().True(active)
+ t.Require().Equal(1, remain)
synced, active, remain, err = g1.TrySync(source1, pos12, endPos12, ddls2)
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(active, check.IsFalse)
- c.Assert(remain, check.Equals, 1)
+ t.Require().NoError(err)
+ t.Require().False(synced)
+ t.Require().False(active)
+ t.Require().Equal(1, remain)
- c.Assert(g1.FirstLocationUnresolved(), check.DeepEquals, &pos11)
- c.Assert(g1.FirstEndPosUnresolved(), check.DeepEquals, &endPos11)
+ t.Require().Equal(&pos11, g1.FirstLocationUnresolved())
+ t.Require().Equal(&endPos11, g1.FirstEndPosUnresolved())
loc, err := g1.ActiveDDLFirstLocation()
- c.Assert(err, check.IsNil)
- c.Assert(loc, check.DeepEquals, pos11)
+ t.Require().NoError(err)
+ t.Require().Equal(pos11, loc)
// not call `TrySync` for source2, beforeActiveDDL is always true
beforeActiveDDL := g1.CheckSyncing(source2, pos21)
- c.Assert(beforeActiveDDL, check.IsTrue)
+ t.Require().True(beforeActiveDDL)
info := g1.UnresolvedGroupInfo()
shouldBe := &pb.ShardingGroup{Target: "", DDLs: ddls1, FirstLocation: pos11.String(), Synced: []string{source1}, Unsynced: []string{source2}}
- c.Assert(info, check.DeepEquals, shouldBe)
+ t.Require().Equal(shouldBe, info)
// simple sort for [][]string{[]string{"db1", "tbl2"}, []string{"db1", "tbl1"}}
tbls1 := g1.Tables()
@@ -178,48 +177,48 @@ func (t *testShardingGroupSuite) TestSync(c *check.C) {
if tbls1[0].Name != tbls2[0].Name {
tbls1[0], tbls1[1] = tbls1[1], tbls1[0]
}
- c.Assert(tbls1, check.DeepEquals, tbls2)
+ t.Require().Equal(tbls2, tbls1)
// sync first DDL for source2, synced but not resolved
synced, active, remain, err = g1.TrySync(source2, pos21, endPos21, ddls1)
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsTrue)
- c.Assert(active, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().True(synced)
+ t.Require().True(active)
+ t.Require().Equal(0, remain)
// active DDL is at pos21
beforeActiveDDL = g1.CheckSyncing(source2, pos21)
- c.Assert(beforeActiveDDL, check.IsTrue)
+ t.Require().True(beforeActiveDDL)
info = g1.UnresolvedGroupInfo()
sort.Strings(info.Synced)
shouldBe = &pb.ShardingGroup{Target: "", DDLs: ddls1, FirstLocation: pos11.String(), Synced: []string{source1, source2}, Unsynced: []string{}}
- c.Assert(info, check.DeepEquals, shouldBe)
+ t.Require().Equal(shouldBe, info)
resolved := g1.ResolveShardingDDL()
- c.Assert(resolved, check.IsFalse)
+ t.Require().False(resolved)
// next active DDL not present
beforeActiveDDL = g1.CheckSyncing(source2, pos21)
- c.Assert(beforeActiveDDL, check.IsTrue)
+ t.Require().True(beforeActiveDDL)
synced, active, remain, err = g1.TrySync(source2, pos22, endPos22, ddls2)
- c.Assert(err, check.IsNil)
- c.Assert(synced, check.IsTrue)
- c.Assert(active, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().True(synced)
+ t.Require().True(active)
+ t.Require().Equal(0, remain)
resolved = g1.ResolveShardingDDL()
- c.Assert(resolved, check.IsTrue)
+ t.Require().True(resolved)
// caller should reset sharding group if DDL is successful executed
g1.Reset()
info = g1.UnresolvedGroupInfo()
- c.Assert(info, check.IsNil)
- c.Assert(g1.UnresolvedTables(), check.IsNil)
+ t.Require().Nil(info)
+ t.Require().Nil(g1.UnresolvedTables())
}
-func (t *testShardingGroupSuite) TestTableID(c *check.C) {
+func (t *testShardingGroupSuite) TestTableID() {
originTables := []*filter.Table{
{Schema: "db", Name: "table"},
{Schema: `d"b`, Name: `t"able"`},
@@ -229,17 +228,17 @@ func (t *testShardingGroupSuite) TestTableID(c *check.C) {
// ignore isSchemaOnly
tableID := utils.GenTableID(originTable)
table := utils.UnpackTableID(tableID)
- c.Assert(table, check.DeepEquals, originTable)
+ t.Require().Equal(originTable, table)
}
}
-func (t *testShardingGroupSuite) TestKeeper(c *check.C) {
+func (t *testShardingGroupSuite) TestKeeper() {
k := NewShardingGroupKeeper(tcontext.Background(), t.cfg, nil)
k.clear()
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
dbConn, err := db.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
k.db = conn.NewBaseDBForTest(db)
k.dbConn = dbconn.NewDBConn(t.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{}))
mock.ExpectBegin()
@@ -248,107 +247,107 @@ func (t *testShardingGroupSuite) TestKeeper(c *check.C) {
mock.ExpectBegin()
mock.ExpectExec(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s.*", dbutil.TableName(t.cfg.MetaSchema, cputil.SyncerShardMeta(t.cfg.Name)))).WillReturnResult(sqlmock.NewResult(1, 1))
mock.ExpectCommit()
- c.Assert(k.prepare(), check.IsNil)
+ t.Require().Nil(k.prepare())
// test meta
mock.ExpectQuery(" SELECT `target_table_id`, `source_table_id`, `active_index`, `is_global`, `data` FROM `test`.`checkpoint_ut_syncer_sharding_meta`.*").
WillReturnRows(sqlmock.NewRows([]string{"target_table_id", "source_table_id", "active_index", "is_global", "data"}))
meta, err := k.LoadShardMeta(mysql.MySQLFlavor, false)
- c.Assert(err, check.IsNil)
- c.Assert(meta, check.HasLen, 0)
+ t.Require().NoError(err)
+ t.Require().Len(meta, 0)
mock.ExpectQuery(" SELECT `target_table_id`, `source_table_id`, `active_index`, `is_global`, `data` FROM `test`.`checkpoint_ut_syncer_sharding_meta`.*").
WillReturnRows(sqlmock.NewRows([]string{"target_table_id", "source_table_id", "active_index", "is_global", "data"}).
AddRow(target, "", 0, true, "[{\"ddls\":[\"DUMMY DDL\"],\"source\":\"`db1`.`tbl1`\",\"first-position\":{\"Name\":\"mysql-bin.000002\",\"Pos\":123},\"first-gtid-set\":\"\"},{\"ddls\":[\"ANOTHER DUMMY DDL\"],\"source\":\"`db1`.`tbl1`\",\"first-position\":{\"Name\":\"mysql-bin.000002\",\"Pos\":789},\"first-gtid-set\":\"\"}]").
AddRow(target, source1, 0, false, "[{\"ddls\":[\"DUMMY DDL\"],\"source\":\"`db1`.`tbl1`\",\"first-position\":{\"Name\":\"mysql-bin.000002\",\"Pos\":123},\"first-gtid-set\":\"\"},{\"ddls\":[\"ANOTHER DUMMY DDL\"],\"source\":\"`db1`.`tbl1`\",\"first-position\":{\"Name\":\"mysql-bin.000002\",\"Pos\":789},\"first-gtid-set\":\"\"}]"))
meta, err = k.LoadShardMeta(mysql.MySQLFlavor, false)
- c.Assert(err, check.IsNil)
- c.Assert(meta, check.HasLen, 1) // has meta of `target`
+ t.Require().NoError(err)
+ t.Require().Len(meta, 1) // has meta of `target`
// test AddGroup and LeaveGroup
needShardingHandle, group, synced, remain, err := k.AddGroup(targetTbl, []string{source1}, nil, true)
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsFalse)
- c.Assert(group, check.NotNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 0) // first time doesn't return `remain`
+ t.Require().NoError(err)
+ t.Require().False(needShardingHandle)
+ t.Require().NotNil(group)
+ t.Require().False(synced)
+ t.Require().Equal(0, remain) // first time doesn't return `remain`
needShardingHandle, group, synced, remain, err = k.AddGroup(targetTbl, []string{source2}, nil, true)
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsFalse)
- c.Assert(group, check.NotNil)
- c.Assert(synced, check.IsFalse)
- c.Assert(remain, check.Equals, 2)
+ t.Require().NoError(err)
+ t.Require().False(needShardingHandle)
+ t.Require().NotNil(group)
+ t.Require().False(synced)
+ t.Require().Equal(2, remain)
// test LeaveGroup
// nolint:dogsled
_, _, _, remain, err = k.AddGroup(targetTbl, []string{source3}, nil, true)
- c.Assert(err, check.IsNil)
- c.Assert(remain, check.Equals, 3)
+ t.Require().NoError(err)
+ t.Require().Equal(3, remain)
// nolint:dogsled
_, _, _, remain, err = k.AddGroup(targetTbl, []string{source4}, nil, true)
- c.Assert(err, check.IsNil)
- c.Assert(remain, check.Equals, 4)
- c.Assert(k.LeaveGroup(targetTbl, []string{source3, source4}), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().Equal(4, remain)
+ t.Require().Nil(k.LeaveGroup(targetTbl, []string{source3, source4}))
// test TrySync and InSyncing
needShardingHandle, group, synced, active, remain, err := k.TrySync(sourceTbl1, targetTbl, pos12, endPos12, ddls1)
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsTrue)
- c.Assert(group.sources, check.DeepEquals, map[string]bool{source1: true, source2: false})
- c.Assert(synced, check.IsFalse)
- c.Assert(active, check.IsTrue)
- c.Assert(remain, check.Equals, 1)
-
- c.Assert(k.InSyncing(sourceTbl1, &filter.Table{Schema: targetTbl.Schema, Name: "wrong table"}, pos11), check.IsFalse)
+ t.Require().NoError(err)
+ t.Require().True(needShardingHandle)
+ t.Require().Equal(map[string]bool{source1: true, source2: false}, group.sources)
+ t.Require().False(synced)
+ t.Require().True(active)
+ t.Require().Equal(1, remain)
+
+ t.Require().False(k.InSyncing(sourceTbl1, &filter.Table{Schema: targetTbl.Schema, Name: "wrong table"}, pos11))
loc, err := k.ActiveDDLFirstLocation(targetTbl)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// position before active DDL, not in syncing
- c.Assert(binlog.CompareLocation(endPos11, loc, false), check.Equals, -1)
- c.Assert(k.InSyncing(sourceTbl1, targetTbl, endPos11), check.IsFalse)
+ t.Require().Equal(-1, binlog.CompareLocation(endPos11, loc, false))
+ t.Require().False(k.InSyncing(sourceTbl1, targetTbl, endPos11))
// position at/after active DDL, in syncing
- c.Assert(binlog.CompareLocation(pos12, loc, false), check.Equals, 0)
- c.Assert(k.InSyncing(sourceTbl1, targetTbl, pos12), check.IsFalse)
- c.Assert(binlog.CompareLocation(endPos12, loc, false), check.Equals, 1)
- c.Assert(k.InSyncing(sourceTbl1, targetTbl, endPos12), check.IsTrue)
+ t.Require().Equal(0, binlog.CompareLocation(pos12, loc, false))
+ t.Require().False(k.InSyncing(sourceTbl1, targetTbl, pos12))
+ t.Require().Equal(1, binlog.CompareLocation(endPos12, loc, false))
+ t.Require().True(k.InSyncing(sourceTbl1, targetTbl, endPos12))
needShardingHandle, group, synced, active, remain, err = k.TrySync(sourceTbl2, targetTbl, pos21, endPos21, ddls1)
- c.Assert(err, check.IsNil)
- c.Assert(needShardingHandle, check.IsTrue)
- c.Assert(group.sources, check.DeepEquals, map[string]bool{source1: true, source2: true})
- c.Assert(synced, check.IsTrue)
- c.Assert(active, check.IsTrue)
- c.Assert(remain, check.Equals, 0)
+ t.Require().NoError(err)
+ t.Require().True(needShardingHandle)
+ t.Require().Equal(map[string]bool{source1: true, source2: true}, group.sources)
+ t.Require().True(synced)
+ t.Require().True(active)
+ t.Require().Equal(0, remain)
unresolvedTarget, unresolvedTables := k.UnresolvedTables()
- c.Assert(unresolvedTarget, check.DeepEquals, map[string]bool{target: true})
+ t.Require().Equal(map[string]bool{target: true}, unresolvedTarget)
// simple re-order
if unresolvedTables[0].Name > unresolvedTables[1].Name {
unresolvedTables[0], unresolvedTables[1] = unresolvedTables[1], unresolvedTables[0]
}
- c.Assert(unresolvedTables, check.DeepEquals, []*filter.Table{sourceTbl1, sourceTbl2})
+ t.Require().Equal([]*filter.Table{sourceTbl1, sourceTbl2}, unresolvedTables)
unresolvedGroups := k.UnresolvedGroups()
- c.Assert(unresolvedGroups, check.HasLen, 1)
+ t.Require().Len(unresolvedGroups, 1)
g := unresolvedGroups[0]
- c.Assert(g.Unsynced, check.HasLen, 0)
- c.Assert(g.DDLs, check.DeepEquals, ddls1)
- c.Assert(g.FirstLocation, check.DeepEquals, pos12.String())
+ t.Require().Len(g.Unsynced, 0)
+ t.Require().Equal(ddls1, g.DDLs)
+ t.Require().Equal(pos12.String(), g.FirstLocation)
sqls, args := k.PrepareFlushSQLs(unresolvedTarget)
- c.Assert(sqls, check.HasLen, 0)
- c.Assert(args, check.HasLen, 0)
+ t.Require().Len(sqls, 0)
+ t.Require().Len(args, 0)
reset, err := k.ResolveShardingDDL(targetTbl)
- c.Assert(err, check.IsNil)
- c.Assert(reset, check.IsTrue)
+ t.Require().NoError(err)
+ t.Require().True(reset)
k.ResetGroups()
unresolvedTarget, unresolvedTables = k.UnresolvedTables()
- c.Assert(unresolvedTarget, check.HasLen, 0)
- c.Assert(unresolvedTables, check.HasLen, 0)
+ t.Require().Len(unresolvedTarget, 0)
+ t.Require().Len(unresolvedTables, 0)
}
diff --git a/dm/syncer/status_test.go b/dm/syncer/status_test.go
index c346654be3..6a0fadc09f 100644
--- a/dm/syncer/status_test.go
+++ b/dm/syncer/status_test.go
@@ -15,9 +15,9 @@ package syncer
import (
"sync"
+ "testing"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/util/filter"
"github.com/pingcap/tiflow/dm/config"
@@ -27,14 +27,11 @@ import (
"github.com/pingcap/tiflow/dm/pkg/log"
"github.com/pingcap/tiflow/dm/syncer/metrics"
"github.com/pingcap/tiflow/dm/syncer/shardddl"
+ "github.com/stretchr/testify/require"
"go.uber.org/zap"
)
-var _ = check.Suite(&statusSuite{})
-
-type statusSuite struct{}
-
-func (t *statusSuite) TestStatusRace(c *check.C) {
+func TestStatusRace(t *testing.T) {
s := &Syncer{}
l := log.With(zap.String("unit test", "TestStatueRace"))
@@ -62,8 +59,8 @@ func (t *statusSuite) TestStatusRace(c *check.C) {
defer wg.Done()
ret := s.Status(sourceStatus)
status := ret.(*pb.SyncStatus)
- c.Assert(status.MasterBinlog, check.Equals, "(mysql-bin.000123, 223)")
- c.Assert(status.SyncerBinlog, check.Equals, "(mysql-bin.000123, 123)")
+ require.Equal(t, "(mysql-bin.000123, 223)", status.MasterBinlog)
+ require.Equal(t, "(mysql-bin.000123, 123)", status.SyncerBinlog)
}()
}
wg.Wait()
diff --git a/dm/syncer/syncer_test.go b/dm/syncer/syncer_test.go
index 1366cd9bc2..f563e2d91d 100644
--- a/dm/syncer/syncer_test.go
+++ b/dm/syncer/syncer_test.go
@@ -29,7 +29,6 @@ import (
"github.com/go-mysql-org/go-mysql/mysql"
"github.com/go-mysql-org/go-mysql/replication"
_ "github.com/go-sql-driver/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/failpoint"
pclog "github.com/pingcap/log"
"github.com/pingcap/tidb/pkg/infoschema"
@@ -62,14 +61,16 @@ import (
"github.com/pingcap/tiflow/pkg/errorutil"
"github.com/pingcap/tiflow/pkg/sqlmodel"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"go.uber.org/zap"
"go.uber.org/zap/zaptest/observer"
)
-var _ = check.Suite(&testSyncerSuite{})
-
func TestSuite(t *testing.T) {
- check.TestingT(t)
+ suite.Run(t, new(testSyncerSuite))
+ suite.Run(t, new(testFilterSuite))
+ suite.Run(t, new(testShardingGroupSuite))
+ suite.Run(t, new(testCheckpointSuite))
}
type (
@@ -99,6 +100,7 @@ const (
)
type testSyncerSuite struct {
+ suite.Suite
cfg *config.SubTaskConfig
eventsGenerator *event.Generator
}
@@ -141,36 +143,36 @@ func (mp *MockStreamProducer) GenerateStreamFrom(location binlog.Location) (read
return &MockStreamer{mp.events, idx, false}, nil
}
-func (s *testSyncerSuite) SetUpSuite(c *check.C) {
+func (s *testSyncerSuite) SetupSuite() {
s.cfg = genDefaultSubTaskConfig4Test()
- s.resetEventsGenerator(c)
- c.Assert(log.InitLogger(&log.Config{}), check.IsNil)
+ s.resetEventsGenerator()
+ s.Require().Nil(log.InitLogger(&log.Config{}))
}
-func (s *testSyncerSuite) generateEvents(binlogEvents mockBinlogEvents, c *check.C) []*replication.BinlogEvent {
+func (s *testSyncerSuite) generateEvents(binlogEvents mockBinlogEvents) []*replication.BinlogEvent {
events := make([]*replication.BinlogEvent, 0, 1024)
for _, e := range binlogEvents {
switch e.typ {
case DBCreate:
evs, _, err := s.eventsGenerator.GenCreateDatabaseEvents(e.args[0].(string))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
case DBDrop:
evs, _, err := s.eventsGenerator.GenDropDatabaseEvents(e.args[0].(string))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
case TableCreate:
evs, _, err := s.eventsGenerator.GenCreateTableEvents(e.args[0].(string), e.args[1].(string))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
case TableDrop:
evs, _, err := s.eventsGenerator.GenDropTableEvents(e.args[0].(string), e.args[1].(string))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
case DDL:
evs, _, err := s.eventsGenerator.GenDDLEvents(e.args[0].(string), e.args[1].(string), 0)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
case Write, Update, Delete:
@@ -192,36 +194,36 @@ func (s *testSyncerSuite) generateEvents(binlogEvents mockBinlogEvents, c *check
case Delete:
eventType = replication.DELETE_ROWS_EVENTv2
default:
- c.Fatal(fmt.Sprintf("mock event generator don't support event type: %d", e.typ))
+ s.T().Fatal(fmt.Sprintf("mock event generator don't support event type: %d", e.typ))
}
evs, _, err := s.eventsGenerator.GenDMLEvents(eventType, dmlData, 0)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
events = append(events, evs...)
}
}
return events
}
-func (s *testSyncerSuite) resetEventsGenerator(c *check.C) {
+func (s *testSyncerSuite) resetEventsGenerator() {
previousGTIDSetStr := "3ccc475b-2343-11e7-be21-6c0b84d59f30:1-14,406a3f61-690d-11e7-87c5-6c92bf46f384:1-94321383"
previousGTIDSet, err := gtid.ParserGTID(s.cfg.Flavor, previousGTIDSetStr)
if err != nil {
- c.Fatal(err)
+ s.T().Fatal(err)
}
latestGTIDStr := "3ccc475b-2343-11e7-be21-6c0b84d59f30:14"
latestGTID, err := gtid.ParserGTID(s.cfg.Flavor, latestGTIDStr)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
s.eventsGenerator, err = event.NewGenerator(s.cfg.Flavor, s.cfg.ServerID, 0, latestGTID, previousGTIDSet, 0)
if err != nil {
- c.Fatal(err)
+ s.T().Fatal(err)
}
}
-func (s *testSyncerSuite) TearDownSuite(c *check.C) {
+func (s *testSyncerSuite) TearDownSuite() {
os.RemoveAll(s.cfg.Dir)
}
-func (s *testSyncerSuite) TestSampleUnhandledEvents(c *check.C) {
+func (s *testSyncerSuite) TestSampleUnhandledEvents() {
core, logs := observer.New(zap.WarnLevel)
restoreGlobal := pclog.ReplaceGlobals(zap.New(core), nil)
defer restoreGlobal()
@@ -235,22 +237,22 @@ func (s *testSyncerSuite) TestSampleUnhandledEvents(c *check.C) {
syncer.recordUnhandledEvent("unhandled event from transaction payload", &replication.QueryEvent{})
entries := logs.All()
- c.Assert(entries, check.HasLen, 2)
+ s.Require().Len(entries, 2)
seen := make(map[string][]map[string]interface{}, len(entries))
for _, entry := range entries {
seen[entry.Message] = append(seen[entry.Message], entry.ContextMap())
}
- c.Assert(seen["unhandled event"], check.HasLen, 1)
- c.Assert(seen["unhandled event"][0]["type"], check.Equals, "*replication.RowsQueryEvent")
- c.Assert(seen["unhandled event from transaction payload"], check.HasLen, 1)
- c.Assert(seen["unhandled event from transaction payload"][0]["type"], check.Equals, "*replication.QueryEvent")
+ s.Require().Len(seen["unhandled event"], 1)
+ s.Require().Equal("*replication.RowsQueryEvent", seen["unhandled event"][0]["type"])
+ s.Require().Len(seen["unhandled event from transaction payload"], 1)
+ s.Require().Equal("*replication.QueryEvent", seen["unhandled event from transaction payload"][0]["type"])
syncer.recordUnhandledEvent("unhandled event", &replication.RowsQueryEvent{})
syncer.recordUnhandledEvent("unhandled event", &replication.QueryEvent{})
syncer.recordUnhandledEvent("unhandled event from transaction payload", &replication.QueryEvent{})
- c.Assert(logs.All(), check.HasLen, 2)
+ s.Require().Len(logs.All(), 2)
}
func mockGetServerUnixTS(mock sqlmock.Sqlmock) {
@@ -259,7 +261,7 @@ func mockGetServerUnixTS(mock sqlmock.Sqlmock) {
mock.ExpectQuery("SELECT UNIX_TIMESTAMP()").WillReturnRows(rows)
}
-func (s *testSyncerSuite) TestSelectDB(c *check.C) {
+func (s *testSyncerSuite) TestSelectDB() {
s.cfg.BAList = &filter.Rules{
DoDBs: []string{"~^b.*", "s1", "stest"},
}
@@ -287,12 +289,12 @@ func (s *testSyncerSuite) TestSelectDB(c *check.C) {
p := parser.New()
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
err = syncer.genRouter()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
header := &replication.EventHeader{
Timestamp: uint32(time.Now().Unix()),
@@ -304,10 +306,10 @@ func (s *testSyncerSuite) TestSelectDB(c *check.C) {
ddlWorker := NewDDLWorker(&syncer.tctx.Logger, syncer)
for _, cs := range cases {
e, err := event.GenQueryEvent(header, 123, 0, 0, 0, statusVars, cs.schema, cs.query)
- c.Assert(err, check.IsNil)
- c.Assert(e, check.NotNil)
+ s.Require().NoError(err)
+ s.Require().NotNil(e)
ev, ok := e.Event.(*replication.QueryEvent)
- c.Assert(ok, check.IsTrue)
+ s.Require().True(ok)
sql := string(ev.Query)
schema := string(ev.Schema)
@@ -317,16 +319,16 @@ func (s *testSyncerSuite) TestSelectDB(c *check.C) {
eventStatusVars: ev.StatusVars,
}
ddlInfo, err := ddlWorker.genDDLInfo(qec, sql)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
qec.originSQL = sql
needSkip, err := syncer.skipQueryEvent(qec, ddlInfo)
- c.Assert(err, check.IsNil)
- c.Assert(needSkip, check.Equals, cs.skip)
+ s.Require().NoError(err)
+ s.Require().Equal(cs.skip, needSkip)
}
}
-func (s *testSyncerSuite) TestSelectTable(c *check.C) {
+func (s *testSyncerSuite) TestSelectTable() {
s.cfg.BAList = &filter.Rules{
DoDBs: []string{"t2", "stest", "~^ptest*"},
DoTables: []*filter.Table{
@@ -335,7 +337,7 @@ func (s *testSyncerSuite) TestSelectTable(c *check.C) {
{Schema: "~^ptest*", Name: "~^t.*"},
},
}
- s.resetEventsGenerator(c)
+ s.resetEventsGenerator()
events := mockBinlogEvents{
mockBinlogEvent{typ: DBCreate, args: []interface{}{"s1"}},
mockBinlogEvent{typ: TableCreate, args: []interface{}{"s1", "create table s1.log(id int)"}},
@@ -366,7 +368,7 @@ func (s *testSyncerSuite) TestSelectTable(c *check.C) {
mockBinlogEvent{typ: DBDrop, args: []interface{}{"ptest1"}},
}
- allEvents := s.generateEvents(events, c)
+ allEvents := s.generateEvents(events)
res := [][]bool{
{true},
@@ -400,22 +402,22 @@ func (s *testSyncerSuite) TestSelectTable(c *check.C) {
p := parser.New()
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
- c.Assert(err, check.IsNil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(syncer.genRouter())
- checkEventWithTableResult(c, syncer, allEvents, p, res)
+ checkEventWithTableResult(s.T(), syncer, allEvents, p, res)
}
-func (s *testSyncerSuite) TestIgnoreDB(c *check.C) {
+func (s *testSyncerSuite) TestIgnoreDB() {
s.cfg.BAList = &filter.Rules{
IgnoreDBs: []string{"~^b.*", "s1", "stest"},
}
- s.resetEventsGenerator(c)
+ s.resetEventsGenerator()
events := mockBinlogEvents{
mockBinlogEvent{typ: DBCreate, args: []interface{}{"s1"}},
mockBinlogEvent{typ: DBDrop, args: []interface{}{"s1"}},
@@ -431,17 +433,17 @@ func (s *testSyncerSuite) TestIgnoreDB(c *check.C) {
mockBinlogEvent{typ: DBDrop, args: []interface{}{"st"}},
}
- allEvents := s.generateEvents(events, c)
+ allEvents := s.generateEvents(events)
res := []bool{true, true, false, false, true, true, true, true, true, true, false, false}
p := parser.New()
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
- c.Assert(err, check.IsNil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(syncer.genRouter())
i := 0
ddlWorker := NewDDLWorker(&syncer.tctx.Logger, syncer)
@@ -459,17 +461,17 @@ func (s *testSyncerSuite) TestIgnoreDB(c *check.C) {
eventStatusVars: statusVars,
}
ddlInfo, err := ddlWorker.genDDLInfo(qec, sql)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
qec.originSQL = sql
needSkip, err := syncer.skipQueryEvent(qec, ddlInfo)
- c.Assert(err, check.IsNil)
- c.Assert(needSkip, check.Equals, res[i])
+ s.Require().NoError(err)
+ s.Require().Equal(res[i], needSkip)
i++
}
}
-func (s *testSyncerSuite) TestIgnoreTable(c *check.C) {
+func (s *testSyncerSuite) TestIgnoreTable() {
s.cfg.BAList = &filter.Rules{
IgnoreDBs: []string{"t2"},
IgnoreTables: []*filter.Table{
@@ -478,7 +480,7 @@ func (s *testSyncerSuite) TestIgnoreTable(c *check.C) {
},
}
- s.resetEventsGenerator(c)
+ s.resetEventsGenerator()
events := mockBinlogEvents{
mockBinlogEvent{typ: DBCreate, args: []interface{}{"s1"}},
mockBinlogEvent{typ: TableCreate, args: []interface{}{"s1", "create table s1.log(id int)"}},
@@ -506,7 +508,7 @@ func (s *testSyncerSuite) TestIgnoreTable(c *check.C) {
mockBinlogEvent{typ: TableDrop, args: []interface{}{"t2", "log"}},
mockBinlogEvent{typ: DBDrop, args: []interface{}{"t2"}},
}
- allEvents := s.generateEvents(events, c)
+ allEvents := s.generateEvents(events)
res := [][]bool{
{false},
@@ -538,17 +540,17 @@ func (s *testSyncerSuite) TestIgnoreTable(c *check.C) {
p := parser.New()
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.baList, err = filter.New(syncer.cfg.CaseSensitive, syncer.cfg.BAList)
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
- c.Assert(err, check.IsNil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(syncer.genRouter())
- checkEventWithTableResult(c, syncer, allEvents, p, res)
+ checkEventWithTableResult(s.T(), syncer, allEvents, p, res)
}
-func (s *testSyncerSuite) TestSkipDML(c *check.C) {
+func (s *testSyncerSuite) TestSkipDML() {
s.cfg.FilterRules = []*bf.BinlogEventRule{
{
SchemaPattern: "*",
@@ -574,7 +576,7 @@ func (s *testSyncerSuite) TestSkipDML(c *check.C) {
}
s.cfg.BAList = nil
- s.resetEventsGenerator(c)
+ s.resetEventsGenerator()
type SQLChecker struct {
events []*replication.BinlogEvent
@@ -584,61 +586,61 @@ func (s *testSyncerSuite) TestSkipDML(c *check.C) {
sqls := make([]SQLChecker, 0, 16)
- evs := s.generateEvents([]mockBinlogEvent{{DBCreate, []interface{}{"foo"}}}, c)
+ evs := s.generateEvents([]mockBinlogEvent{{DBCreate, []interface{}{"foo"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo", "create table foo.bar(id int)"}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo", "create table foo.bar(id int)"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
- evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(8), "foo", "bar", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
- evs = s.generateEvents([]mockBinlogEvent{{DBDrop, []interface{}{"foo1"}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{DBDrop, []interface{}{"foo1"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{DBCreate, []interface{}{"foo1"}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{DBCreate, []interface{}{"foo1"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo1", "create table foo1.bar1(id int)"}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo1", "create table foo1.bar1(id int)"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
- evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(9), "foo1", "bar1", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
- evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo1", "create table foo1.bar2(id int)"}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{TableCreate, []interface{}{"foo1", "create table foo1.bar2(id int)"}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: false, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Write, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: false})
- evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Update, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}, {int32(1)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
- evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{Delete, []interface{}{uint64(10), "foo1", "bar2", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(2)}}}}})
sqls = append(sqls, SQLChecker{events: evs, isDML: true, expected: true})
p := parser.New()
var err error
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().Nil(syncer.genRouter())
syncer.binlogFilter, err = bf.NewBinlogEvent(false, s.cfg.FilterRules)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
for _, sql := range sqls {
events := sql.events
@@ -646,15 +648,15 @@ func (s *testSyncerSuite) TestSkipDML(c *check.C) {
switch ev := e.Event.(type) {
case *replication.QueryEvent:
_, err = p.ParseOneStmt(string(ev.Query), "", "")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
case *replication.RowsEvent:
table := &filter.Table{
Schema: string(ev.Table.Schema),
Name: string(ev.Table.Table),
}
needSkip, err := syncer.skipRowsEvent(table, e.Header.EventType)
- c.Assert(err, check.IsNil)
- c.Assert(needSkip, check.Equals, sql.expected)
+ s.Require().NoError(err)
+ s.Require().Equal(sql.expected, needSkip)
default:
continue
}
@@ -662,7 +664,7 @@ func (s *testSyncerSuite) TestSkipDML(c *check.C) {
}
}
-func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
+func (s *testSyncerSuite) TestColumnMapping() {
rules := []*cm.Rule{
{
PatternSchema: "stest*",
@@ -680,7 +682,7 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
},
}
- s.resetEventsGenerator(c)
+ s.resetEventsGenerator()
// create db and tables
events := mockBinlogEvents{
@@ -690,7 +692,7 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
mockBinlogEvent{typ: TableCreate, args: []interface{}{"stest_3", "create table stest_3.a(id int)"}},
}
- createEvents := s.generateEvents(events, c)
+ createEvents := s.generateEvents(events)
// dmls
type dml struct {
@@ -701,13 +703,13 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
dmls := make([]dml, 0, 3)
- evs := s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(8), "stest_3", "t_2", []byte{mysql.MYSQL_TYPE_STRING, mysql.MYSQL_TYPE_LONG}, [][]interface{}{{"ian", int32(10)}}}}}, c)
+ evs := s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(8), "stest_3", "t_2", []byte{mysql.MYSQL_TYPE_STRING, mysql.MYSQL_TYPE_LONG}, [][]interface{}{{"ian", int32(10)}}}}})
dmls = append(dmls, dml{events: evs, column: []string{"name", "id"}, data: []interface{}{"ian", int64(1<<59 | 3<<52 | 2<<44 | 10)}})
- evs = s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(9), "stest_3", "log", []byte{mysql.MYSQL_TYPE_STRING}, [][]interface{}{{"10"}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(9), "stest_3", "log", []byte{mysql.MYSQL_TYPE_STRING}, [][]interface{}{{"10"}}}}})
dmls = append(dmls, dml{events: evs, column: []string{"id"}, data: []interface{}{"test:10"}})
- evs = s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(10), "stest_3", "a", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(10)}}}}}, c)
+ evs = s.generateEvents([]mockBinlogEvent{{typ: Write, args: []interface{}{uint64(10), "stest_3", "a", []byte{mysql.MYSQL_TYPE_LONG}, [][]interface{}{{int32(10)}}}}})
dmls = append(dmls, dml{events: evs, column: []string{"id"}, data: []interface{}{int32(10)}})
dmlEvents := make([]*replication.BinlogEvent, 0, 15)
@@ -723,12 +725,12 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
mockBinlogEvent{typ: TableDrop, args: []interface{}{"stest_3", "a"}},
mockBinlogEvent{typ: DBDrop, args: []interface{}{"stest_3"}},
}
- dropEvents := s.generateEvents(events, c)
+ dropEvents := s.generateEvents(events)
p := parser.New()
var err error
mapping, err := cm.NewMapping(false, rules)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
allEvents := createEvents
allEvents = append(allEvents, dmlEvents...)
@@ -738,11 +740,11 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
switch ev := e.Event.(type) {
case *replication.QueryEvent:
_, err = p.ParseOneStmt(string(ev.Query), "", "")
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
case *replication.RowsEvent:
r, _, err := mapping.HandleRowValue(string(ev.Table.Schema), string(ev.Table.Table), dmls[dmlIndex].column, ev.Rows[0])
- c.Assert(err, check.IsNil)
- c.Assert(r, check.DeepEquals, dmls[dmlIndex].data)
+ s.Require().NoError(err)
+ s.Require().Equal(dmls[dmlIndex].data, r)
dmlIndex++
default:
continue
@@ -750,31 +752,31 @@ func (s *testSyncerSuite) TestColumnMapping(c *check.C) {
}
}
-func (s *testSyncerSuite) TestcheckpointID(c *check.C) {
+func (s *testSyncerSuite) TestcheckpointID() {
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
checkpointID := syncer.checkpointID()
- c.Assert(checkpointID, check.Equals, "101")
+ s.Require().Equal("101", checkpointID)
}
// TODO: add `TestSharding` later.
-func (s *testSyncerSuite) TestRun(c *check.C) {
+func (s *testSyncerSuite) TestRun() {
// 1. execute some sqls which will trigger causality
// 2. check the generated jobs
// 3. update config, add route rules, and update syncer
// 4. execute some sqls and then check jobs generated
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
mockGetServerUnixTS(mock)
dbConn, err := db.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDB, checkPointMock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDBConn, err := checkPointDB.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
testJobs.jobs = testJobs.jobs[:0]
@@ -795,7 +797,7 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
}
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.cfg.CheckpointFlushInterval = 30 // defaultCheckpointFlushInterval
syncer.cfg.SafeModeDuration = "60s" // defaultCheckpointFlushInterval * 2
@@ -807,7 +809,7 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
syncer.ddlDBConn = dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{}))
syncer.downstreamTrackConn = dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{}))
syncer.schemaTracker, err = schema.NewTestTracker(context.Background(), s.cfg.Name, syncer.downstreamTrackConn, log.L())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
@@ -822,13 +824,13 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
AddRow("t_1", "create table t_1(id int primary key, name varchar(24), KEY `index1` (`name`))"))
syncer.exprFilterGroup = NewExprFilterGroup(tcontext.Background(), utils.NewSessionCtx(nil), nil)
- c.Assert(syncer.Type(), check.Equals, pb.UnitType_Sync)
+ s.Require().Equal(pb.UnitType_Sync, syncer.Type())
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().Nil(syncer.genRouter())
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
- syncer.setupMockCheckpoint(c, checkPointDBConn, checkPointMock)
+ syncer.setupMockCheckpoint(s.T(), checkPointDBConn, checkPointMock)
syncer.reset()
events1 := mockBinlogEvents{
@@ -847,9 +849,9 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
mockBinlogEvent{typ: DDL, args: []interface{}{"test_1", "alter table test_1.t_3 add primary key(id, name)"}},
}
- mockStreamerProducer := &MockStreamProducer{s.generateEvents(events1, c)}
+ mockStreamerProducer := &MockStreamProducer{s.generateEvents(events1)}
mockStreamer, err := mockStreamerProducer.GenerateStreamFrom(binlog.MustZeroLocation(mysql.MySQLFlavor))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.streamerController = binlogstream.NewStreamerController4Test(
mockStreamerProducer,
mockStreamer,
@@ -953,11 +955,11 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
}
executeSQLAndWait(len(expectJobs1))
- c.Assert(syncer.Status(nil).(*pb.SyncStatus).TotalEvents, check.Equals, int64(0))
+ s.Require().Equal(int64(0), syncer.Status(nil).(*pb.SyncStatus).TotalEvents)
syncer.mockFinishJob(expectJobs1)
testJobs.Lock()
- checkJobs(c, testJobs.jobs, expectJobs1)
+ checkJobs(s.T(), testJobs.jobs, expectJobs1)
testJobs.jobs = testJobs.jobs[:0]
testJobs.Unlock()
@@ -976,7 +978,7 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
// when syncer exit Run(), will flush job
syncer.Pause()
- mockDBProvider := conn.InitMockDB(c)
+ mockDBProvider := conn.InitMockDB(s.T())
mockDBProvider.ExpectQuery("SELECT cast\\(TIMEDIFF\\(NOW\\(6\\), UTC_TIMESTAMP\\(6\\)\\) as time\\);").
WillReturnRows(sqlmock.NewRows([]string{""}).AddRow("01:00:00"))
mockGetServerUnixTS(mock)
@@ -987,8 +989,8 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
sqlmock.NewRows([]string{"Table", "Create Table"}).
AddRow("t_2", "create table t_2(id int primary key, name varchar(24))"))
- c.Assert(syncer.Update(context.Background(), s.cfg), check.IsNil)
- c.Assert(syncer.timezone.String(), check.Equals, "+01:00")
+ s.Require().Nil(syncer.Update(context.Background(), s.cfg))
+ s.Require().Equal("+01:00", syncer.timezone.String())
events2 := mockBinlogEvents{
mockBinlogEvent{typ: Write, args: []interface{}{uint64(8), "test_1", "t_1", []byte{mysql.MYSQL_TYPE_LONG, mysql.MYSQL_TYPE_STRING}, [][]interface{}{{int32(3), "c"}}}},
@@ -1001,11 +1003,11 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
syncer.secondsBehindMaster.Store(100)
syncer.workerJobTSArray[ddlJobIdx].Store(100)
syncer.reset()
- c.Assert(syncer.secondsBehindMaster.Load(), check.Equals, int64(0))
- c.Assert(syncer.workerJobTSArray[ddlJobIdx].Load(), check.Equals, int64(0))
- mockStreamerProducer = &MockStreamProducer{s.generateEvents(events2, c)}
+ s.Require().Equal(int64(0), syncer.secondsBehindMaster.Load())
+ s.Require().Equal(int64(0), syncer.workerJobTSArray[ddlJobIdx].Load())
+ mockStreamerProducer = &MockStreamProducer{s.generateEvents(events2)}
mockStreamer, err = mockStreamerProducer.GenerateStreamFrom(binlog.MustZeroLocation(mysql.MySQLFlavor))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.streamerController = binlogstream.NewStreamerController4Test(
mockStreamerProducer,
mockStreamer,
@@ -1042,12 +1044,12 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
}
executeSQLAndWait(len(expectJobs2))
- c.Assert(syncer.Status(nil).(*pb.SyncStatus).TotalEvents, check.Equals, int64(len(expectJobs1)))
+ s.Require().Equal(int64(len(expectJobs1)), syncer.Status(nil).(*pb.SyncStatus).TotalEvents)
syncer.mockFinishJob(expectJobs2)
- c.Assert(syncer.Status(nil).(*pb.SyncStatus).TotalEvents, check.Equals, int64(len(expectJobs1)+len(expectJobs2)))
+ s.Require().Equal(int64(len(expectJobs1)+len(expectJobs2)), syncer.Status(nil).(*pb.SyncStatus).TotalEvents)
testJobs.RLock()
- checkJobs(c, testJobs.jobs, expectJobs2)
+ checkJobs(s.T(), testJobs.jobs, expectJobs2)
testJobs.RUnlock()
cancel()
@@ -1058,15 +1060,15 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
syncer.sessCtx = utils.NewSessionCtx(map[string]string{"time_zone": "UTC"})
sourceSchemaFromCheckPoint, err := syncer.OperateSchema(ctx, &pb.OperateWorkerSchemaRequest{Op: pb.SchemaOp_GetSchema, Database: "test_1", Table: "t_1"})
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.tableRouter = ®exprrouter.RouteTable{}
- c.Assert(syncer.tableRouter.AddRule(&router.TableRule{
+ s.Require().NoError(syncer.tableRouter.AddRule(&router.TableRule{
SchemaPattern: "test_1",
TablePattern: "t_1",
TargetSchema: "test_1",
TargetTable: "t_2",
- }), check.IsNil)
+ }))
syncer.checkpoint.(*RemoteCheckPoint).points = make(map[string]map[string]*binlogPoint)
@@ -1082,7 +1084,7 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
AddRow("t_2", showTableResultString))
sourceSchemaFromDownstream, err := syncer.OperateSchema(ctx, &pb.OperateWorkerSchemaRequest{Op: pb.SchemaOp_GetSchema, Database: "test_1", Table: "t_1"})
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
sourceSchemaExpected := "CREATE TABLE `t_1` (" +
" `id` int(11) NOT NULL," +
@@ -1090,35 +1092,35 @@ func (s *testSyncerSuite) TestRun(c *check.C) {
" PRIMARY KEY (`id`) /*T![clustered_index] NONCLUSTERED */," +
" KEY `index1` (`name`)" +
") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin"
- c.Assert(sourceSchemaFromCheckPoint, check.Equals, sourceSchemaExpected)
- c.Assert(sourceSchemaFromDownstream, check.Equals, sourceSchemaExpected)
+ s.Require().Equal(sourceSchemaExpected, sourceSchemaFromCheckPoint)
+ s.Require().Equal(sourceSchemaExpected, sourceSchemaFromDownstream)
cancel()
// test OperateSchema ends
syncer.Close()
- c.Assert(syncer.isClosed(), check.IsTrue)
+ s.Require().True(syncer.isClosed())
if err := mock.ExpectationsWereMet(); err != nil {
- c.Errorf("db unfulfilled expectations: %s", err)
+ s.T().Errorf("db unfulfilled expectations: %s", err)
}
if err := checkPointMock.ExpectationsWereMet(); err != nil {
- c.Errorf("checkpointDB unfulfilled expectations: %s", err)
+ s.T().Errorf("checkpointDB unfulfilled expectations: %s", err)
}
}
-func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
+func (s *testSyncerSuite) TestExitSafeModeByConfig() {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
mockGetServerUnixTS(mock)
dbConn, err := db.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDB, checkPointMock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDBConn, err := checkPointDB.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
testJobs.jobs = testJobs.jobs[:0]
@@ -1134,7 +1136,7 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
}
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.fromDB = &dbconn.UpStreamConn{BaseDB: conn.NewBaseDBForTest(db)}
syncer.toDBConns = []*dbconn.DBConn{
@@ -1152,15 +1154,15 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
AddRow("t_1", "create table t_1(id int primary key, name varchar(24))"))
syncer.schemaTracker, err = schema.NewTestTracker(context.Background(), s.cfg.Name, syncer.ddlDBConn, log.L())
- c.Assert(err, check.IsNil)
- c.Assert(syncer.Type(), check.Equals, pb.UnitType_Sync)
+ s.Require().NoError(err)
+ s.Require().Equal(pb.UnitType_Sync, syncer.Type())
syncer.exprFilterGroup = NewExprFilterGroup(tcontext.Background(), utils.NewSessionCtx(nil), nil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().Nil(syncer.genRouter())
syncer.metricsProxies = metrics.DefaultMetricsProxies.CacheForOneTask("task", "worker", "source")
- syncer.setupMockCheckpoint(c, checkPointDBConn, checkPointMock)
+ syncer.setupMockCheckpoint(s.T(), checkPointDBConn, checkPointMock)
syncer.reset()
@@ -1173,9 +1175,9 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
mockBinlogEvent{typ: Update, args: []interface{}{uint64(8), "test_1", "t_1", []byte{mysql.MYSQL_TYPE_LONG, mysql.MYSQL_TYPE_STRING}, [][]interface{}{{int32(2), "b"}, {int32(1), "b"}}}},
}
- generatedEvents1 := s.generateEvents(events1, c)
+ generatedEvents1 := s.generateEvents(events1)
// make sure [18] is last event, and use [18]'s position as safeModeExitLocation
- c.Assert(len(generatedEvents1), check.Equals, 19)
+ s.Require().Equal(19, len(generatedEvents1))
safeModeExitLocation := binlog.MustZeroLocation(mysql.MySQLFlavor)
safeModeExitLocation.Position.Pos = generatedEvents1[18].Header.LogPos
syncer.checkpoint.SaveSafeModeExitPoint(&safeModeExitLocation)
@@ -1186,14 +1188,14 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
mockBinlogEvent{typ: Delete, args: []interface{}{uint64(8), "test_1", "t_1", []byte{mysql.MYSQL_TYPE_LONG, mysql.MYSQL_TYPE_STRING}, [][]interface{}{{int32(1), "a"}}}},
mockBinlogEvent{typ: Update, args: []interface{}{uint64(8), "test_1", "t_1", []byte{mysql.MYSQL_TYPE_LONG, mysql.MYSQL_TYPE_STRING}, [][]interface{}{{int32(2), "b"}, {int32(1), "b"}}}},
}
- generatedEvents2 := s.generateEvents(events2, c)
+ generatedEvents2 := s.generateEvents(events2)
generatedEvents := generatedEvents1
generatedEvents = append(generatedEvents, generatedEvents2...)
mockStreamerProducer := &MockStreamProducer{generatedEvents}
mockStreamer, err := mockStreamerProducer.GenerateStreamFrom(binlog.MustZeroLocation(mysql.MySQLFlavor))
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer.streamerController = binlogstream.NewStreamerController4Test(
mockStreamerProducer,
mockStreamer,
@@ -1217,12 +1219,12 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
checkPointMock.ExpectExec(".*INSERT INTO .* VALUES.* ON DUPLICATE KEY UPDATE.*").WillReturnResult(sqlmock.NewResult(0, 1))
checkPointMock.ExpectCommit()
// disable 1-minute safe mode
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/syncer/SafeModeInitPhaseSeconds", `return("10ms")`), check.IsNil)
+ s.Require().Nil(failpoint.Enable("github.com/pingcap/tiflow/dm/syncer/SafeModeInitPhaseSeconds", `return("10ms")`))
go syncer.Process(ctx, resultCh)
go func() {
for r := range resultCh {
if len(r.Errors) > 0 {
- c.Fatal(r.String())
+ s.T().Fatal(r.String())
}
}
}()
@@ -1278,55 +1280,55 @@ func (s *testSyncerSuite) TestExitSafeModeByConfig(c *check.C) {
}
executeSQLAndWait(len(expectJobs))
- c.Assert(syncer.Status(nil).(*pb.SyncStatus).TotalEvents, check.Equals, int64(0))
+ s.Require().Equal(int64(0), syncer.Status(nil).(*pb.SyncStatus).TotalEvents)
syncer.mockFinishJob(expectJobs)
testJobs.Lock()
- checkJobs(c, testJobs.jobs, expectJobs)
+ checkJobs(s.T(), testJobs.jobs, expectJobs)
testJobs.jobs = testJobs.jobs[:0]
testJobs.Unlock()
cancel()
syncer.Close()
- c.Assert(syncer.isClosed(), check.IsTrue)
+ s.Require().True(syncer.isClosed())
if err := mock.ExpectationsWereMet(); err != nil {
- c.Errorf("db unfulfilled expectations: %s", err)
+ s.T().Errorf("db unfulfilled expectations: %s", err)
}
if err := checkPointMock.ExpectationsWereMet(); err != nil {
- c.Errorf("checkpointDB unfulfilled expectations: %s", err)
+ s.T().Errorf("checkpointDB unfulfilled expectations: %s", err)
}
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/syncer/SafeModeInitPhaseSeconds"), check.IsNil)
+ s.Require().Nil(failpoint.Disable("github.com/pingcap/tiflow/dm/syncer/SafeModeInitPhaseSeconds"))
}
-func (s *testSyncerSuite) TestRemoveMetadataIsFine(c *check.C) {
+func (s *testSyncerSuite) TestRemoveMetadataIsFine() {
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cfg.Mode = config.ModeAll
syncer := NewSyncer(cfg, nil, nil)
fresh, err := syncer.IsFreshTask(context.Background())
- c.Assert(err, check.IsNil)
- c.Assert(fresh, check.IsTrue)
+ s.Require().NoError(err)
+ s.Require().True(fresh)
filename := filepath.Join(s.cfg.Dir, "metadata")
err = os.WriteFile(filename, []byte("SHOW MASTER STATUS:\n\tLog: BAD METADATA"), 0o644)
- c.Assert(err, check.IsNil)
- c.Assert(syncer.checkpoint.LoadMeta(context.Background()), check.NotNil)
+ s.Require().NoError(err)
+ s.Require().Error(syncer.checkpoint.LoadMeta(context.Background()))
err = os.WriteFile(filename, []byte("SHOW MASTER STATUS:\n\tLog: mysql-bin.000003\n\tPos: 1234\n\tGTID:\n\n"), 0o644)
- c.Assert(err, check.IsNil)
- c.Assert(syncer.checkpoint.LoadMeta(context.Background()), check.IsNil)
+ s.Require().NoError(err)
+ s.Require().Nil(syncer.checkpoint.LoadMeta(context.Background()))
- c.Assert(os.Remove(filename), check.IsNil)
+ s.Require().Nil(os.Remove(filename))
// after successful LoadMeta, IsFreshTask should return false so don't load again
fresh, err = syncer.IsFreshTask(context.Background())
- c.Assert(err, check.IsNil)
- c.Assert(fresh, check.IsFalse)
+ s.Require().NoError(err)
+ s.Require().False(fresh)
}
-func (s *testSyncerSuite) TestTrackDDL(c *check.C) {
+func (s *testSyncerSuite) TestTrackDDL() {
var (
testDB = "test_db"
testTbl = "test_tbl"
@@ -1340,17 +1342,17 @@ func (s *testSyncerSuite) TestTrackDDL(c *check.C) {
}
)
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
dbConn, err := db.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDB, checkPointMock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
checkPointDBConn, err := checkPointDB.Conn(context.Background())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
cfg, err := s.cfg.Clone()
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
syncer := NewSyncer(cfg, nil, nil)
syncer.toDBConns = []*dbconn.DBConn{
dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{})),
@@ -1359,10 +1361,10 @@ func (s *testSyncerSuite) TestTrackDDL(c *check.C) {
syncer.ddlDBConn = dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(dbConn, &retry.FiniteRetryStrategy{}))
syncer.checkpoint.(*RemoteCheckPoint).dbConn = dbconn.NewDBConn(s.cfg, conn.NewBaseConnForTest(checkPointDBConn, &retry.FiniteRetryStrategy{}))
syncer.schemaTracker, err = schema.NewTestTracker(context.Background(), s.cfg.Name, syncer.ddlDBConn, log.L())
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
defer syncer.schemaTracker.Close()
syncer.exprFilterGroup = NewExprFilterGroup(tcontext.Background(), utils.NewSessionCtx(nil), nil)
- c.Assert(syncer.genRouter(), check.IsNil)
+ s.Require().Nil(syncer.genRouter())
cases := []struct {
sql string
@@ -1441,19 +1443,19 @@ func (s *testSyncerSuite) TestTrackDDL(c *check.C) {
ddlWorker := NewDDLWorker(&syncer.tctx.Logger, syncer)
for _, ca := range cases {
ddlInfo, err := ddlWorker.genDDLInfo(qec, ca.sql)
- c.Assert(err, check.IsNil)
+ s.Require().NoError(err)
ca.callback()
syncer.foreignKeyRouteTopologyChecked = true
- c.Assert(syncer.trackDDL(testDB, ddlInfo, ec), check.IsNil)
- c.Assert(syncer.foreignKeyRouteTopologyChecked, check.Equals, false)
+ s.Require().Nil(syncer.trackDDL(testDB, ddlInfo, ec))
+ s.Require().False(syncer.foreignKeyRouteTopologyChecked)
syncer.schemaTracker.Reset()
- c.Assert(mock.ExpectationsWereMet(), check.IsNil)
- c.Assert(checkPointMock.ExpectationsWereMet(), check.IsNil)
+ s.Require().Nil(mock.ExpectationsWereMet())
+ s.Require().Nil(checkPointMock.ExpectationsWereMet())
}
}
-func checkEventWithTableResult(c *check.C, syncer *Syncer, allEvents []*replication.BinlogEvent, p *parser.Parser, res [][]bool) {
+func checkEventWithTableResult(t *testing.T, syncer *Syncer, allEvents []*replication.BinlogEvent, p *parser.Parser, res [][]bool) {
i := 0
tctx := tcontext.Background().WithLogger(log.With(zap.String("test", "checkEventWithTableResult")))
ec := &eventContext{
@@ -1472,32 +1474,32 @@ func checkEventWithTableResult(c *check.C, syncer *Syncer, allEvents []*replicat
eventStatusVars: statusVars,
}
stmt, err := parseOneStmt(qec)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
if _, ok := stmt.(ast.DDLNode); !ok {
continue // BEGIN event
}
qec.splitDDLs, err = parserpkg.SplitDDL(stmt, qec.ddlSchema)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for _, sql := range qec.splitDDLs {
sqls, err := ddlWorker.processOneDDL(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
qec.appliedDDLs = append(qec.appliedDDLs, sqls...)
}
if len(qec.appliedDDLs) == 0 {
- c.Assert(res[i], check.HasLen, 1)
- c.Assert(res[i][0], check.Equals, true)
+ require.Len(t, res[i], 1)
+ require.Equal(t, true, res[i][0])
i++
continue
}
for j, sql := range qec.appliedDDLs {
ddlInfo, err := ddlWorker.genDDLInfo(qec, sql)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
needSkip, err := syncer.skipQueryEvent(qec, ddlInfo)
- c.Assert(err, check.IsNil)
- c.Assert(needSkip, check.Equals, res[i][j])
+ require.NoError(t, err)
+ require.Equal(t, res[i][j], needSkip)
}
case *replication.RowsEvent:
table := &filter.Table{
@@ -1505,8 +1507,8 @@ func checkEventWithTableResult(c *check.C, syncer *Syncer, allEvents []*replicat
Name: string(ev.Table.Table),
}
needSkip, err := syncer.skipRowsEvent(table, e.Header.EventType)
- c.Assert(err, check.IsNil)
- c.Assert(needSkip, check.Equals, res[i][0])
+ require.NoError(t, err)
+ require.Equal(t, res[i][0], needSkip)
default:
continue
}
@@ -1540,21 +1542,21 @@ var defaultDMLType = map[sqlmodel.RowChangeType]sqlmodel.DMLType{
sqlmodel.RowChangeDelete: sqlmodel.DMLDelete,
}
-func checkJobs(c *check.C, jobs []*job, expectJobs []*expectJob) {
- c.Assert(len(jobs), check.Equals, len(expectJobs), check.Commentf("jobs = %q", jobs))
+func checkJobs(t *testing.T, jobs []*job, expectJobs []*expectJob) {
+ require.Equal(t, len(expectJobs), len(jobs), "jobs = %q", jobs)
for i, job := range jobs {
- c.Assert(job.tp, check.Equals, expectJobs[i].tp)
+ require.Equal(t, expectJobs[i].tp, job.tp)
if job.tp == ddl {
- c.Assert(job.ddls, check.DeepEquals, expectJobs[i].sqlInJob)
+ require.Equal(t, expectJobs[i].sqlInJob, job.ddls)
continue
}
if job.tp == dml {
if !job.safeMode {
sql, args := job.dml.GenSQL(defaultDMLType[job.dml.Type()])
- c.Assert([]string{sql}, check.DeepEquals, expectJobs[i].sqlInJob)
- c.Assert([][]interface{}{args}, check.DeepEquals, expectJobs[i].args)
+ require.Equal(t, expectJobs[i].sqlInJob, []string{sql})
+ require.Equal(t, expectJobs[i].args, [][]interface{}{args})
continue
}
@@ -1562,17 +1564,17 @@ func checkJobs(c *check.C, jobs []*job, expectJobs []*expectJob) {
switch job.dml.Type() {
case sqlmodel.RowChangeInsert:
sql, args := job.dml.GenSQL(sqlmodel.DMLReplace)
- c.Assert([]string{sql}, check.DeepEquals, expectJobs[i].sqlInJob)
- c.Assert([][]interface{}{args}, check.DeepEquals, expectJobs[i].args)
+ require.Equal(t, expectJobs[i].sqlInJob, []string{sql})
+ require.Equal(t, expectJobs[i].args, [][]interface{}{args})
case sqlmodel.RowChangeUpdate:
sql, args := job.dml.GenSQL(sqlmodel.DMLDelete)
sql2, args2 := job.dml.GenSQL(sqlmodel.DMLReplace)
- c.Assert([]string{sql, sql2}, check.DeepEquals, expectJobs[i].sqlInJob)
- c.Assert([][]interface{}{args, args2}, check.DeepEquals, expectJobs[i].args)
+ require.Equal(t, expectJobs[i].sqlInJob, []string{sql, sql2})
+ require.Equal(t, expectJobs[i].args, [][]interface{}{args, args2})
case sqlmodel.RowChangeDelete:
sql, args := job.dml.GenSQL(sqlmodel.DMLDelete)
- c.Assert([]string{sql}, check.DeepEquals, expectJobs[i].sqlInJob)
- c.Assert([][]interface{}{args}, check.DeepEquals, expectJobs[i].args)
+ require.Equal(t, expectJobs[i].sqlInJob, []string{sql})
+ require.Equal(t, expectJobs[i].args, [][]interface{}{args})
}
}
}
@@ -1645,7 +1647,7 @@ func (s *Syncer) addJobToMemory(job *job) (bool, error) {
return true, nil
}
-func (s *Syncer) setupMockCheckpoint(c *check.C, checkPointDBConn *sql.Conn, checkPointMock sqlmock.Sqlmock) {
+func (s *Syncer) setupMockCheckpoint(t *testing.T, checkPointDBConn *sql.Conn, checkPointMock sqlmock.Sqlmock) {
checkPointMock.ExpectBegin()
checkPointMock.ExpectExec(fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS `%s`", s.cfg.MetaSchema)).WillReturnResult(sqlmock.NewResult(1, 1))
checkPointMock.ExpectCommit()
@@ -1663,7 +1665,7 @@ func (s *Syncer) setupMockCheckpoint(c *check.C, checkPointDBConn *sql.Conn, che
afterFlushFn: s.afterFlushCheckpoint,
updateJobMetricsFn: func(bool, string, *job) {},
}
- c.Assert(s.checkpoint.(*RemoteCheckPoint).prepare(tcontext.Background()), check.IsNil)
+ require.Nil(t, s.checkpoint.(*RemoteCheckPoint).prepare(tcontext.Background()))
// disable flush checkpoint periodically
s.checkpoint.(*RemoteCheckPoint).globalPointSaveTime = time.Now()
}
diff --git a/dm/unit/unit_test.go b/dm/unit/unit_test.go
index 4202e2a0bc..07499ae8ef 100644
--- a/dm/unit/unit_test.go
+++ b/dm/unit/unit_test.go
@@ -19,7 +19,6 @@ import (
"testing"
"github.com/go-sql-driver/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tidb/pkg/lightning/common"
tmysql "github.com/pingcap/tidb/pkg/parser/mysql"
@@ -28,38 +27,31 @@ import (
"github.com/stretchr/testify/require"
)
-func TestSuite(t *testing.T) {
- check.TestingT(t)
-}
-
-var _ = check.Suite(&testUnitSuite{})
-
-type testUnitSuite struct{}
-
-func (t *testUnitSuite) TestIsCtxCanceledProcessErr(c *check.C) {
+func TestIsCtxCanceledProcessErr(t *testing.T) {
err := NewProcessError(context.Canceled)
- c.Assert(IsCtxCanceledProcessErr(err), check.IsTrue)
+ require.True(t, IsCtxCanceledProcessErr(err))
err = NewProcessError(errors.New("123"))
- c.Assert(IsCtxCanceledProcessErr(err), check.IsFalse)
+ require.False(t, IsCtxCanceledProcessErr(err))
terr := terror.ErrDBBadConn
err = NewProcessError(terror.ErrDBBadConn)
- c.Assert(err.GetErrCode(), check.Equals, int32(terr.Code()))
- c.Assert(err.GetErrClass(), check.Equals, terr.Class().String())
- c.Assert(err.GetErrLevel(), check.Equals, terr.Level().String())
- c.Assert(err.GetMessage(), check.Equals, terr.Message())
- c.Assert(err.GetRawCause(), check.Equals, "")
+ require.Equal(t, int32(terr.Code()), err.GetErrCode())
+ require.Equal(t, terr.Class().String(), err.GetErrClass())
+ require.Equal(t, terr.Level().String(), err.GetErrLevel())
+ require.Equal(t, terr.Message(), err.GetMessage())
+ require.Equal(t, "", err.GetRawCause())
}
-func (t *testUnitSuite) TestJoinProcessErrors(c *check.C) {
+func TestJoinProcessErrors(t *testing.T) {
errs := []*pb.ProcessError{
NewProcessError(terror.ErrDBDriverError.Generate()),
NewProcessError(terror.ErrSyncUnitDMLStatementFound.Generate()),
}
- c.Assert(JoinProcessErrors(errs), check.Equals,
- `ErrCode:10001 ErrClass:"database" ErrScope:"not-set" ErrLevel:"high" Message:"database driver error" Workaround:"Please check the database connection and the database config in configuration file." , ErrCode:36014 ErrClass:"sync-unit" ErrScope:"internal" ErrLevel:"high" Message:"only support ROW format binlog, unexpected DML statement found in query event" `)
+ require.Equal(t,
+ `ErrCode:10001 ErrClass:"database" ErrScope:"not-set" ErrLevel:"high" Message:"database driver error" Workaround:"Please check the database connection and the database config in configuration file." , ErrCode:36014 ErrClass:"sync-unit" ErrScope:"internal" ErrLevel:"high" Message:"only support ROW format binlog, unexpected DML statement found in query event" `,
+ JoinProcessErrors(errs))
}
func TestIsResumableError(t *testing.T) {
diff --git a/dm/worker/config_test.go b/dm/worker/config_test.go
index 92a15e70c7..b9fba29bcc 100644
--- a/dm/worker/config_test.go
+++ b/dm/worker/config_test.go
@@ -17,49 +17,46 @@ import (
"flag"
"os"
"strings"
+ "testing"
"github.com/kami-zh/go-capturer"
- "github.com/pingcap/check"
"github.com/pingcap/tiflow/dm/pkg/terror"
+ "github.com/stretchr/testify/require"
)
-var (
- defaultConfigFile = "./dm-worker.toml"
- _ = check.Suite(&testConfigSuite{})
-)
-
-type testConfigSuite struct{}
+var defaultConfigFile = "./dm-worker.toml"
-func (t *testConfigSuite) TestAdjustAddr(c *check.C) {
+func TestAdjustAddr(t *testing.T) {
cfg := NewConfig()
- c.Assert(cfg.configFromFile(defaultConfigFile), check.IsNil)
- c.Assert(cfg.adjust(), check.IsNil)
+ require.NoError(t, cfg.configFromFile(defaultConfigFile))
+ require.NoError(t, cfg.adjust())
// invalid `advertise-addr`
cfg.AdvertiseAddr = "127.0.0.1"
- c.Assert(terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()), check.IsTrue)
+ require.True(t, terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()))
cfg.AdvertiseAddr = "0.0.0.0:8262"
- c.Assert(terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()), check.IsTrue)
+ require.True(t, terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()))
// clear `advertise-addr`, still invalid because no `host` in `worker-addr`.
cfg.AdvertiseAddr = ""
- c.Assert(terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()), check.IsTrue)
+ require.True(t, terror.ErrWorkerHostPortNotValid.Equal(cfg.adjust()))
// TICASE-956
cfg.WorkerAddr = "127.0.0.1:8262"
- c.Assert(cfg.adjust(), check.IsNil)
- c.Assert(cfg.AdvertiseAddr, check.Equals, cfg.WorkerAddr)
+ require.NoError(t, cfg.adjust())
+ require.Equal(t, cfg.WorkerAddr, cfg.AdvertiseAddr)
}
-func (t *testConfigSuite) TestPrintSampleConfig(c *check.C) {
+func TestPrintSampleConfig(t *testing.T) {
buf, err := os.ReadFile(defaultConfigFile)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
// test print sample config
out := capturer.CaptureStdout(func() {
cfg := NewConfig()
err = cfg.Parse([]string{"-print-sample-config"})
- c.Assert(err, check.ErrorMatches, flag.ErrHelp.Error())
+ require.Error(t, err)
+ require.Regexp(t, flag.ErrHelp.Error(), err.Error())
})
- c.Assert(strings.TrimSpace(out), check.Equals, strings.TrimSpace(string(buf)))
+ require.Equal(t, strings.TrimSpace(string(buf)), strings.TrimSpace(out))
}
diff --git a/dm/worker/hub_test.go b/dm/worker/hub_test.go
index f71ea1b0e0..8de0b8b93e 100644
--- a/dm/worker/hub_test.go
+++ b/dm/worker/hub_test.go
@@ -13,12 +13,8 @@
package worker
-import (
- "github.com/pingcap/check"
-)
-
-func (t *testServer) testConidtionHub(c *check.C, s *Server) {
+func (t *testServer) testConidtionHub(s *Server) {
// test condition hub
- c.Assert(GetConditionHub(), check.NotNil)
- c.Assert(GetConditionHub().w, check.DeepEquals, s.getSourceWorker(true))
+ t.Require().NotNil(GetConditionHub())
+ t.Require().Equal(s.getSourceWorker(true), GetConditionHub().w)
}
diff --git a/dm/worker/relay_test.go b/dm/worker/relay_test.go
index 88232e42cf..d61e8b64e2 100644
--- a/dm/worker/relay_test.go
+++ b/dm/worker/relay_test.go
@@ -15,10 +15,10 @@ package worker
import (
"context"
+ "testing"
"time"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/config/dbconfig"
@@ -29,12 +29,9 @@ import (
"github.com/pingcap/tiflow/dm/pkg/utils"
"github.com/pingcap/tiflow/dm/relay"
"github.com/pingcap/tiflow/dm/unit"
+ "github.com/stretchr/testify/require"
)
-type testRelay struct{}
-
-var _ = check.Suite(&testRelay{})
-
/*********** dummy relay log process unit, used only for testing *************/
// DummyRelay is a dummy relay.
@@ -143,7 +140,7 @@ func (d *DummyRelay) PurgeRelayDir() error {
return nil
}
-func (t *testRelay) TestRelay(c *check.C) {
+func TestRelay(t *testing.T) {
originNewRelay := relay.NewRelay
relay.NewRelay = NewDummyRelay
originNewPurger := relay.NewPurger
@@ -153,73 +150,77 @@ func (t *testRelay) TestRelay(c *check.C) {
relay.NewPurger = originNewPurger
}()
- cfg := loadSourceConfigWithoutPassword(c)
+ cfg := loadSourceConfigWithoutPassword(t)
- dir := c.MkDir()
+ dir := t.TempDir()
cfg.RelayDir = dir
cfg.MetaDir = dir
relayHolder := NewRealRelayHolder(cfg)
- c.Assert(relayHolder, check.NotNil)
+ require.NotNil(t, relayHolder)
holder, ok := relayHolder.(*realRelayHolder)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
- t.testInit(c, holder)
- t.testStart(c, holder)
- t.testPauseAndResume(c, holder)
- t.testClose(c, holder)
- t.testStop(c, holder)
+ testRelayInit(t, holder)
+ testRelayStart(t, holder)
+ testRelayPauseAndResume(t, holder)
+ testRelayClose(t, holder)
+ testRelayStop(t, holder)
}
-func (t *testRelay) testInit(c *check.C, holder *realRelayHolder) {
+func testRelayInit(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
ctx := context.Background()
_, err := holder.Init(ctx, nil)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
r, ok := holder.relay.(*DummyRelay)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
initErr := errors.New("init error")
r.InjectInitError(initErr)
defer r.InjectInitError(nil)
_, err = holder.Init(ctx, nil)
- c.Assert(err, check.ErrorMatches, ".*"+initErr.Error()+".*")
+ require.Error(t, err)
+ require.Regexp(t, ".*"+initErr.Error()+".*", err.Error())
}
-func (t *testRelay) testStart(c *check.C, holder *realRelayHolder) {
- c.Assert(holder.Stage(), check.Equals, pb.Stage_New)
- c.Assert(holder.closed.Load(), check.IsFalse)
- c.Assert(holder.Result(), check.IsNil)
+func testRelayStart(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
+ require.Equal(t, pb.Stage_New, holder.Stage())
+ require.False(t, holder.closed.Load())
+ require.Nil(t, holder.Result())
holder.Start()
- c.Assert(waitRelayStage(holder, pb.Stage_Running, 5), check.IsTrue)
- c.Assert(holder.Result(), check.IsNil)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ require.True(t, waitRelayStage(holder, pb.Stage_Running, 5))
+ require.Nil(t, holder.Result())
+ require.False(t, holder.closed.Load())
// test status
status := holder.Status(nil)
- c.Assert(status.Stage, check.Equals, pb.Stage_Running)
- c.Assert(status.Result, check.IsNil)
+ require.Equal(t, pb.Stage_Running, status.Stage)
+ require.Nil(t, status.Result)
- c.Assert(holder.Error(), check.IsNil)
+ require.Nil(t, holder.Error())
// test update and pause -> resume
- t.testUpdate(c, holder)
- c.Assert(holder.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ testRelayUpdate(t, holder)
+ require.Equal(t, pb.Stage_Paused, holder.Stage())
+ require.False(t, holder.closed.Load())
err := holder.Operate(context.Background(), pb.RelayOp_ResumeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(waitRelayStage(holder, pb.Stage_Running, 10), check.IsTrue)
- c.Assert(holder.Result(), check.IsNil)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ require.NoError(t, err)
+ require.True(t, waitRelayStage(holder, pb.Stage_Running, 10))
+ require.Nil(t, holder.Result())
+ require.False(t, holder.closed.Load())
}
-func (t *testRelay) testClose(c *check.C, holder *realRelayHolder) {
+func testRelayClose(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
r, ok := holder.relay.(*DummyRelay)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
processResult := &pb.ProcessResult{
IsCanceled: true,
Errors: []*pb.ProcessError{
@@ -230,60 +231,65 @@ func (t *testRelay) testClose(c *check.C, holder *realRelayHolder) {
defer r.InjectProcessResult(pb.ProcessResult{})
holder.Close()
- c.Assert(waitRelayStage(holder, pb.Stage_Paused, 10), check.IsTrue)
- c.Assert(holder.Result(), check.DeepEquals, processResult)
- c.Assert(holder.closed.Load(), check.IsTrue)
+ require.True(t, waitRelayStage(holder, pb.Stage_Paused, 10))
+ require.Equal(t, processResult, holder.Result())
+ require.True(t, holder.closed.Load())
holder.Close()
- c.Assert(holder.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(holder.Result(), check.DeepEquals, processResult)
- c.Assert(holder.closed.Load(), check.IsTrue)
+ require.Equal(t, pb.Stage_Paused, holder.Stage())
+ require.Equal(t, processResult, holder.Result())
+ require.True(t, holder.closed.Load())
// todo: very strange, and can't resume
status := holder.Status(nil)
- c.Assert(status.Stage, check.Equals, pb.Stage_Stopped)
- c.Assert(status.Result, check.IsNil)
+ require.Equal(t, pb.Stage_Stopped, status.Stage)
+ require.Nil(t, status.Result)
errInfo := holder.Error()
- c.Assert(errInfo.Msg, check.Equals, "relay stopped")
+ require.Equal(t, "relay stopped", errInfo.Msg)
}
-func (t *testRelay) testPauseAndResume(c *check.C, holder *realRelayHolder) {
+func testRelayPauseAndResume(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
err := holder.Operate(context.Background(), pb.RelayOp_PauseRelay)
- c.Assert(err, check.IsNil)
- c.Assert(holder.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ require.NoError(t, err)
+ require.Equal(t, pb.Stage_Paused, holder.Stage())
+ require.False(t, holder.closed.Load())
err = holder.pauseRelay(context.Background(), pb.RelayOp_PauseRelay)
- c.Assert(err, check.ErrorMatches, ".*current stage is Paused.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*current stage is Paused.*", err.Error())
// test status
status := holder.Status(nil)
- c.Assert(status.Stage, check.Equals, pb.Stage_Paused)
+ require.Equal(t, pb.Stage_Paused, status.Stage)
// test update
- t.testUpdate(c, holder)
+ testRelayUpdate(t, holder)
err = holder.Operate(context.Background(), pb.RelayOp_ResumeRelay)
- c.Assert(err, check.IsNil)
- c.Assert(waitRelayStage(holder, pb.Stage_Running, 10), check.IsTrue)
- c.Assert(holder.Result(), check.IsNil)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ require.NoError(t, err)
+ require.True(t, waitRelayStage(holder, pb.Stage_Running, 10))
+ require.Nil(t, holder.Result())
+ require.False(t, holder.closed.Load())
err = holder.Operate(context.Background(), pb.RelayOp_ResumeRelay)
- c.Assert(err, check.ErrorMatches, ".*current stage is Running.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*current stage is Running.*", err.Error())
// test status
status = holder.Status(nil)
- c.Assert(status.Stage, check.Equals, pb.Stage_Running)
- c.Assert(status.Result, check.IsNil)
+ require.Equal(t, pb.Stage_Running, status.Stage)
+ require.Nil(t, status.Result)
// invalid operation
err = holder.Operate(context.Background(), pb.RelayOp_InvalidRelayOp)
- c.Assert(err, check.ErrorMatches, ".*not supported.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*not supported.*", err.Error())
}
-func (t *testRelay) testUpdate(c *check.C, holder *realRelayHolder) {
+func testRelayUpdate(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
cfg := &config.SourceConfig{
From: dbconfig.DBConfig{
Host: "127.0.0.1",
@@ -294,27 +300,29 @@ func (t *testRelay) testUpdate(c *check.C, holder *realRelayHolder) {
}
originStage := holder.Stage()
- c.Assert(holder.Update(context.Background(), cfg), check.IsNil)
- c.Assert(waitRelayStage(holder, originStage, 10), check.IsTrue)
- c.Assert(holder.closed.Load(), check.IsFalse)
+ require.NoError(t, holder.Update(context.Background(), cfg))
+ require.True(t, waitRelayStage(holder, originStage, 10))
+ require.False(t, holder.closed.Load())
r, ok := holder.relay.(*DummyRelay)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
err := errors.New("reload error")
r.InjectReloadError(err)
defer r.InjectReloadError(nil)
- c.Assert(holder.Update(context.Background(), cfg), check.Equals, err)
+ require.Equal(t, err, holder.Update(context.Background(), cfg))
}
-func (t *testRelay) testStop(c *check.C, holder *realRelayHolder) {
+func testRelayStop(t *testing.T, holder *realRelayHolder) {
+ t.Helper()
err := holder.Operate(context.Background(), pb.RelayOp_StopRelay)
- c.Assert(err, check.IsNil)
- c.Assert(holder.Stage(), check.Equals, pb.Stage_Stopped)
- c.Assert(holder.closed.Load(), check.IsTrue)
+ require.NoError(t, err)
+ require.Equal(t, pb.Stage_Stopped, holder.Stage())
+ require.True(t, holder.closed.Load())
err = holder.Operate(context.Background(), pb.RelayOp_StopRelay)
- c.Assert(err, check.ErrorMatches, ".*current stage is already stopped.*")
+ require.Error(t, err)
+ require.Regexp(t, ".*current stage is already stopped.*", err.Error())
}
func waitRelayStage(holder *realRelayHolder, expect pb.Stage, backoff int) bool {
diff --git a/dm/worker/server_test.go b/dm/worker/server_test.go
index 8740df6c79..dce9ca9cd7 100644
--- a/dm/worker/server_test.go
+++ b/dm/worker/server_test.go
@@ -23,7 +23,6 @@ import (
"time"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/failpoint"
"github.com/pingcap/tiflow/dm/config"
@@ -37,6 +36,7 @@ import (
"github.com/pingcap/tiflow/dm/relay"
"github.com/pingcap/tiflow/dm/unit"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"github.com/tikv/pd/pkg/utils/tempurl"
v3rpc "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
clientv3 "go.etcd.io/etcd/client/v3"
@@ -51,21 +51,26 @@ const (
var etcdErrCompacted = v3rpc.ErrCompacted
-func TestServer(t *testing.T) {
- check.TestingT(t)
+// TestWorker is the single entry point that runs all stateful suites in the
+// dm/worker package.
+func TestWorker(t *testing.T) {
+ suite.Run(t, new(testServer))
+ suite.Run(t, new(testServer2))
+ suite.Run(t, new(testWorkerFunctionalities))
+ suite.Run(t, new(testWorkerEtcdCompact))
}
-type testServer struct{}
-
-var _ = check.Suite(&testServer{})
+type testServer struct {
+ suite.Suite
+}
-func (t *testServer) SetUpSuite(c *check.C) {
+func (t *testServer) SetupSuite() {
err := log.InitLogger(&log.Config{})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
getMinLocForSubTaskFunc = getFakeLocForSubTask
}
-func (t *testServer) TearDownSuite(c *check.C) {
+func (t *testServer) TearDownSuite() {
getMinLocForSubTaskFunc = getMinLocForSubTask
}
@@ -96,17 +101,17 @@ func createMockETCD(dir string, host string) (*embed.Etcd, error) {
return ETCD, nil
}
-func (t *testServer) TestServer(c *check.C) {
+func (t *testServer) TestServer() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
workerAddr1 = "127.0.0.1:8262"
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -132,136 +137,136 @@ func (t *testServer) TestServer(c *check.C) {
defer s.Close()
go func() {
err1 := s.Start()
- c.Assert(err1, check.IsNil)
+ t.Require().NoError(err1)
}()
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return !s.closed.Load()
- }), check.IsTrue)
- dir := c.MkDir()
+ }))
+ dir := t.T().TempDir()
- t.testOperateSourceBoundWithoutConfigInEtcd(c, s)
+ t.testOperateSourceBoundWithoutConfigInEtcd(s)
- t.testOperateWorker(c, s, dir, true)
+ t.testOperateWorker(s, dir, true)
// check worker would retry connecting master rather than stop worker directly.
- ETCD = t.testRetryConnectMaster(c, s, ETCD, etcdDir, masterAddr)
+ ETCD = t.testRetryConnectMaster(s, ETCD, etcdDir, masterAddr)
// resume contact with ETCD and start worker again
- t.testOperateWorker(c, s, dir, true)
+ t.testOperateWorker(s, dir, true)
// test condition hub
- t.testConidtionHub(c, s)
+ t.testConidtionHub(s)
- t.testHTTPInterface(c, "status")
- t.testHTTPInterface(c, "metrics")
+ t.testHTTPInterface("status")
+ t.testHTTPInterface("metrics")
// create client
- cli := t.createClient(c, workerAddr1)
+ cli := t.createClient(workerAddr1)
// start task
subtaskCfg := config.SubTaskConfig{}
err = subtaskCfg.Decode(config.SampleSubtaskConfig, true)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subtaskCfg.MydumperPath = mydumperPath
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
_, err = ha.PutSubTaskCfgStage(s.etcdClient, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return checkSubTaskStatus(cli, pb.Stage_Running)
- }), check.IsTrue)
+ }))
- t.testSubTaskRecover(c, s, dir)
+ t.testSubTaskRecover(s, dir)
// pause relay
_, err = ha.PutRelayStage(s.etcdClient, ha.NewRelayStage(pb.Stage_Paused, sourceCfg.SourceID))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return checkRelayStatus(cli, pb.Stage_Paused)
- }), check.IsTrue)
+ }))
// resume relay
_, err = ha.PutRelayStage(s.etcdClient, ha.NewRelayStage(pb.Stage_Running, sourceCfg.SourceID))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return checkRelayStatus(cli, pb.Stage_Running)
- }), check.IsTrue)
+ }))
// pause task
_, err = ha.PutSubTaskStage(s.etcdClient, ha.NewSubTaskStage(pb.Stage_Paused, sourceCfg.SourceID, subtaskCfg.Name))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return checkSubTaskStatus(cli, pb.Stage_Paused)
- }), check.IsTrue)
+ }))
// test refresh source cfg
sourceCfg.MetaDir = "new meta"
_, err = ha.PutSourceCfg(s.etcdClient, sourceCfg)
- c.Assert(err, check.IsNil)
- c.Assert(s.worker.refreshSourceCfg(), check.IsNil)
- c.Assert(s.worker.cfg.MetaDir, check.Equals, sourceCfg.MetaDir)
+ t.Require().NoError(err)
+ t.Require().NoError(s.worker.refreshSourceCfg())
+ t.Require().Equal(sourceCfg.MetaDir, s.worker.cfg.MetaDir)
// check update subtask cfg failed
tomlStr, tomlErr := subtaskCfg.Toml()
- c.Assert(tomlErr, check.IsNil)
+ t.Require().NoError(tomlErr)
ctx := context.Background()
checkReq := &pb.CheckSubtasksCanUpdateRequest{SubtaskCfgTomlString: tomlStr}
checkResp, checkErr := s.CheckSubtasksCanUpdate(ctx, checkReq)
- c.Assert(checkErr, check.IsNil)
- c.Assert(checkResp.Success, check.IsFalse)
+ t.Require().NoError(checkErr)
+ t.Require().False(checkResp.Success)
// test refresh subtask cfg
subtaskCfg.SyncerConfig.Batch = 111
_, err = ha.PutSubTaskCfgStage(s.etcdClient, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{}, []ha.Stage{})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subTask := s.worker.subTaskHolder.findSubTask(subtaskCfg.Name)
subTask.setCurrUnit(subTask.units[2]) // set to syncer unit
- c.Assert(s.worker.tryRefreshSubTaskAndSourceConfig(subTask), check.IsNil)
+ t.Require().NoError(s.worker.tryRefreshSubTaskAndSourceConfig(subTask))
subtaskCfgInWorker := s.worker.subTaskHolder.findSubTask(subtaskCfg.Name)
- c.Assert(subtaskCfgInWorker.cfg.SyncerConfig.Batch, check.Equals, subtaskCfg.SyncerConfig.Batch)
+ t.Require().Equal(subtaskCfg.SyncerConfig.Batch, subtaskCfgInWorker.cfg.SyncerConfig.Batch)
// resume task
_, err = ha.PutSubTaskStage(s.etcdClient, ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return checkSubTaskStatus(cli, pb.Stage_Running)
- }), check.IsTrue)
+ }))
// stop task
_, err = ha.DeleteSubTaskStage(s.etcdClient, ha.NewSubTaskStage(pb.Stage_Stopped, sourceCfg.SourceID, subtaskCfg.Name))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true).subTaskHolder.findSubTask(subtaskCfg.Name) == nil
- }), check.IsTrue)
+ }))
dupServer := NewServer(cfg)
err = dupServer.Start()
- c.Assert(terror.ErrWorkerStartService.Equal(err), check.IsTrue)
- c.Assert(err.Error(), check.Matches, ".*bind: address already in use.*")
+ t.Require().True(terror.ErrWorkerStartService.Equal(err))
+ t.Require().Regexp(".*bind: address already in use.*", err.Error())
- t.testStopWorkerWhenLostConnect(c, s, ETCD)
+ t.testStopWorkerWhenLostConnect(s, ETCD)
s.Close()
- c.Assert(utils.WaitSomething(30, 10*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 10*time.Millisecond, func() bool {
return s.closed.Load()
- }), check.IsTrue)
+ }))
// test source worker, just make sure testing sort
- t.testSourceWorker(c)
+ t.testSourceWorker()
}
-func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
+func (t *testServer) TestHandleSourceBoundAfterError() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
// start etcd server
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
@@ -272,7 +277,7 @@ func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// watch worker event(oneline or offline)
var (
@@ -297,14 +302,14 @@ func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
defer s.Close()
go func() {
err1 := s.Start()
- c.Assert(err1, check.IsNil)
+ t.Require().NoError(err1)
}()
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return !s.closed.Load()
- }), check.IsTrue)
+ }))
// check if the worker is online
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
select {
case ev := <-workerEvCh:
if !ev.IsDeleted {
@@ -313,20 +318,20 @@ func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
default:
}
return false
- }), check.IsTrue)
+ }))
// enable failpoint
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/ha/FailToGetSourceCfg", `return(true)`), check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/pkg/ha/FailToGetSourceCfg", `return(true)`))
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.EnableRelay = false
_, err = ha.PutSourceCfg(etcdCli, sourceCfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
sourceBound := ha.NewSourceBound(sourceCfg.SourceID, s.cfg.Name)
_, err = ha.PutSourceBound(etcdCli, sourceBound)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// do check until worker offline
- c.Assert(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
select {
case ev := <-workerEvCh:
if ev.IsDeleted {
@@ -335,10 +340,10 @@ func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
default:
}
return false
- }), check.IsTrue)
+ }))
// check if the worker is online
- c.Assert(utils.WaitSomething(5, time.Duration(s.cfg.KeepAliveTTL)*time.Second, func() bool {
+ t.Require().True(utils.WaitSomething(5, time.Duration(s.cfg.KeepAliveTTL)*time.Second, func() bool {
select {
case ev := <-workerEvCh:
if !ev.IsDeleted {
@@ -347,106 +352,106 @@ func (t *testServer) TestHandleSourceBoundAfterError(c *check.C) {
default:
}
return false
- }), check.IsTrue)
+ }))
// stop watching and disable failpoint
cancel()
wg.Wait()
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/ha/FailToGetSourceCfg"), check.IsNil)
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/pkg/ha/FailToGetSourceCfg"))
_, err = ha.PutSourceBound(etcdCli, sourceBound)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = ha.PutSourceCfg(etcdCli, sourceCfg)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true) != nil
- }), check.IsTrue)
+ }))
_, err = ha.DeleteSourceBound(etcdCli, s.cfg.Name)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true) == nil
- }), check.IsTrue)
+ }))
}
-func (t *testServer) TestServerQueryValidator(c *check.C) {
+func (t *testServer) TestServerQueryValidator() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
s := NewServer(cfg)
resp, err := s.GetWorkerValidatorStatus(context.Background(), &pb.GetValidationStatusRequest{})
- c.Assert(err, check.IsNil)
- c.Assert(resp.Result, check.IsFalse)
- c.Assert(resp.Msg, check.Matches, ".*no mysql source is being handled in the worker.*")
+ t.Require().NoError(err)
+ t.Require().False(resp.Result)
+ t.Require().Regexp(".*no mysql source is being handled in the worker.*", resp.Msg)
}
-func (t *testServer) TestServerQueryValidatorError(c *check.C) {
+func (t *testServer) TestServerQueryValidatorError() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
s := NewServer(cfg)
resp, err := s.GetValidatorError(context.Background(), &pb.GetValidationErrorRequest{})
- c.Assert(err, check.IsNil)
- c.Assert(resp.Result, check.IsFalse)
- c.Assert(resp.Msg, check.Matches, ".*no mysql source is being handled in the worker.*")
+ t.Require().NoError(err)
+ t.Require().False(resp.Result)
+ t.Require().Regexp(".*no mysql source is being handled in the worker.*", resp.Msg)
}
-func (t *testServer) TestServerOperateValidatorError(c *check.C) {
+func (t *testServer) TestServerOperateValidatorError() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
s := NewServer(cfg)
resp, err := s.OperateValidatorError(context.Background(), &pb.OperateValidationErrorRequest{})
- c.Assert(err, check.IsNil)
- c.Assert(resp.Result, check.IsFalse)
- c.Assert(resp.Msg, check.Matches, ".*no mysql source is being handled in the worker.*")
+ t.Require().NoError(err)
+ t.Require().False(resp.Result)
+ t.Require().Regexp(".*no mysql source is being handled in the worker.*", resp.Msg)
}
-func (t *testServer) TestWatchSourceBoundEtcdCompact(c *check.C) {
+func (t *testServer) TestWatchSourceBoundEtcdCompact() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
startRev = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -460,8 +465,8 @@ func (t *testServer) TestWatchSourceBoundEtcdCompact(c *check.C) {
})
s.etcdClient = etcdCli
s.closed.Store(false)
- c.Assert(err, check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(err)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.EnableRelay = false
ctx, cancel := context.WithCancel(context.Background())
@@ -469,27 +474,27 @@ func (t *testServer) TestWatchSourceBoundEtcdCompact(c *check.C) {
// step 1: Put a source config and source bound to this worker, then delete it
_, err = ha.PutSourceCfg(etcdCli, sourceCfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
sourceBound := ha.NewSourceBound(sourceCfg.SourceID, cfg.Name)
_, err = ha.PutSourceBound(etcdCli, sourceBound)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
rev, err := ha.DeleteSourceBound(etcdCli, cfg.Name)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// step 2: start source at this worker
w, err := s.getOrStartWorker(sourceCfg, true)
- c.Assert(err, check.IsNil)
- c.Assert(w.EnableHandleSubtasks(), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(w.EnableHandleSubtasks())
// step 3: trigger etcd compaction and check whether we can receive it through watcher
_, err = etcdCli.Compact(ctx, rev)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
sourceBoundCh := make(chan ha.SourceBound, 10)
sourceBoundErrCh := make(chan error, 10)
ha.WatchSourceBound(ctx, etcdCli, cfg.Name, startRev, sourceBoundCh, sourceBoundErrCh)
select {
case err = <-sourceBoundErrCh:
- c.Assert(errors.Cause(err), check.Equals, etcdErrCompacted)
+ t.Require().Equal(etcdErrCompacted, errors.Cause(err))
case <-time.After(300 * time.Millisecond):
- c.Fatal("fail to get etcd error compacted")
+ t.T().Fatal("fail to get etcd error compacted")
}
// step 4: watch source bound from startRev
var wg sync.WaitGroup
@@ -497,121 +502,121 @@ func (t *testServer) TestWatchSourceBoundEtcdCompact(c *check.C) {
wg.Add(1)
go func() {
defer wg.Done()
- c.Assert(s.observeSourceBound(ctx1, startRev), check.IsNil)
+ t.Require().NoError(s.observeSourceBound(ctx1, startRev))
}()
// step 4.1: should stop the running worker, source bound has been deleted, should stop this worker
- c.Assert(utils.WaitSomething(20, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(20, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true) == nil
- }), check.IsTrue)
+ }))
// step 4.2: put a new source bound, source should be started
_, err = ha.PutSourceBound(etcdCli, sourceBound)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true) != nil
- }), check.IsTrue)
+ }))
cfg2 := s.getSourceWorker(true).cfg
- c.Assert(cfg2, check.DeepEquals, sourceCfg)
+ t.Require().Equal(sourceCfg, cfg2)
cancel1()
wg.Wait()
- c.Assert(s.stopSourceWorker(sourceCfg.SourceID, true, true), check.IsNil)
+ t.Require().NoError(s.stopSourceWorker(sourceCfg.SourceID, true, true))
// step 5: start observeSourceBound from compacted revision again, should start worker
ctx2, cancel2 := context.WithCancel(ctx)
wg.Add(1)
go func() {
defer wg.Done()
- c.Assert(s.observeSourceBound(ctx2, startRev), check.IsNil)
+ t.Require().NoError(s.observeSourceBound(ctx2, startRev))
}()
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return s.getSourceWorker(true) != nil
- }), check.IsTrue)
+ }))
cfg2 = s.getSourceWorker(true).cfg
- c.Assert(cfg2, check.DeepEquals, sourceCfg)
+ t.Require().Equal(sourceCfg, cfg2)
cancel2()
wg.Wait()
}
-func (t *testServer) testHTTPInterface(c *check.C, uri string) {
+func (t *testServer) testHTTPInterface(uri string) {
// nolint:noctx
resp, err := http.Get("http://127.0.0.1:8262/" + uri)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer resp.Body.Close()
- c.Assert(resp.StatusCode, check.Equals, 200)
+ t.Require().Equal(200, resp.StatusCode)
_, err = io.ReadAll(resp.Body)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
-func (t *testServer) createClient(c *check.C, addr string) pb.WorkerClient {
+func (t *testServer) createClient(addr string) pb.WorkerClient {
//nolint:staticcheck
conn, err := grpc.Dial(addr, grpc.WithInsecure(), grpc.WithBackoffMaxDelay(3*time.Second))
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
return pb.NewWorkerClient(conn)
}
-func (t *testServer) testOperateSourceBoundWithoutConfigInEtcd(c *check.C, s *Server) {
+func (t *testServer) testOperateSourceBoundWithoutConfigInEtcd(s *Server) {
err := s.operateSourceBound(ha.NewSourceBound("sourceWithoutConfigInEtcd", s.cfg.Name))
- c.Assert(terror.ErrWorkerFailToGetSourceConfigFromEtcd.Equal(err), check.IsTrue)
+ t.Require().True(terror.ErrWorkerFailToGetSourceConfigFromEtcd.Equal(err))
}
-func (t *testServer) testOperateWorker(c *check.C, s *Server, dir string, start bool) {
+func (t *testServer) testOperateWorker(s *Server, dir string, start bool) {
// load sourceCfg
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.EnableRelay = true
sourceCfg.RelayDir = dir
- sourceCfg.MetaDir = c.MkDir()
+ sourceCfg.MetaDir = t.T().TempDir()
if start {
// put mysql config into relative etcd key adapter to trigger operation event
_, err := ha.PutSourceCfg(s.etcdClient, sourceCfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = ha.PutRelayStageRelayConfigSourceBound(s.etcdClient, ha.NewRelayStage(pb.Stage_Running, sourceCfg.SourceID),
ha.NewSourceBound(sourceCfg.SourceID, s.cfg.Name))
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// worker should be started and without error
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
w := s.getSourceWorker(true)
return w != nil && !w.closed.Load()
- }), check.IsTrue)
- c.Assert(s.getSourceStatus(true).Result, check.IsNil)
+ }))
+ t.Require().Nil(s.getSourceStatus(true).Result)
} else {
// worker should be started before stopped
w := s.getSourceWorker(true)
- c.Assert(w, check.NotNil)
- c.Assert(w.closed.Load(), check.IsFalse)
+ t.Require().NotNil(w)
+ t.Require().False(w.closed.Load())
_, err := ha.DeleteRelayConfig(s.etcdClient, w.name)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = ha.DeleteSourceCfgRelayStageSourceBound(s.etcdClient, sourceCfg.SourceID, s.cfg.Name)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// worker should be closed and without error
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
currentWorker := s.getSourceWorker(true)
return currentWorker == nil && w.closed.Load()
- }), check.IsTrue)
- c.Assert(s.getSourceStatus(true).Result, check.IsNil)
+ }))
+ t.Require().Nil(s.getSourceStatus(true).Result)
}
}
-func (t *testServer) testRetryConnectMaster(c *check.C, s *Server, etcd *embed.Etcd, dir string, hostName string) *embed.Etcd {
+func (t *testServer) testRetryConnectMaster(s *Server, etcd *embed.Etcd, dir string, hostName string) *embed.Etcd {
etcd.Close()
time.Sleep(6 * time.Second)
// When worker server fail to keepalive with etcd, server should close its worker
- c.Assert(s.getSourceWorker(true), check.IsNil)
- c.Assert(s.getSourceStatus(true).Result, check.IsNil)
+ t.Require().Nil(s.getSourceWorker(true))
+ t.Require().Nil(s.getSourceStatus(true).Result)
ETCD, err := createMockETCD(dir, "http://"+hostName)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
time.Sleep(3 * time.Second)
return ETCD
}
-func (t *testServer) testSubTaskRecover(c *check.C, s *Server, dir string) {
- workerCli := t.createClient(c, "127.0.0.1:8262")
- t.testOperateWorker(c, s, dir, false)
+func (t *testServer) testSubTaskRecover(s *Server, dir string) {
+ workerCli := t.createClient("127.0.0.1:8262")
+ t.testOperateWorker(s, dir, false)
status, err := workerCli.QueryStatus(context.Background(), &pb.QueryStatusRequest{Name: "sub-task-name"})
- c.Assert(err, check.IsNil)
- c.Assert(status.Result, check.IsFalse)
- c.Assert(status.Msg, check.Equals, terror.ErrWorkerNoStart.Error())
+ t.Require().NoError(err)
+ t.Require().False(status.Result)
+ t.Require().Equal(terror.ErrWorkerNoStart.Error(), status.Msg)
- t.testOperateWorker(c, s, dir, true)
+ t.testOperateWorker(s, dir, true)
// because we split starting worker and enabling handling subtasks into two parts, a query-status may occur between
// them, thus get a result of no subtask running
@@ -630,30 +635,30 @@ func (t *testServer) testSubTaskRecover(c *check.C, s *Server, dir string) {
})
status, err = workerCli.QueryStatus(context.Background(), &pb.QueryStatusRequest{Name: "sub-task-name"})
- c.Assert(err, check.IsNil)
- c.Assert(status.Result, check.IsTrue)
- c.Assert(status.SubTaskStatus, check.HasLen, 1)
- c.Assert(status.SubTaskStatus[0].Stage, check.Equals, pb.Stage_Running)
+ t.Require().NoError(err)
+ t.Require().True(status.Result)
+ t.Require().Len(status.SubTaskStatus, 1)
+ t.Require().Equal(pb.Stage_Running, status.SubTaskStatus[0].Stage)
}
-func (t *testServer) testStopWorkerWhenLostConnect(c *check.C, s *Server, etcd *embed.Etcd) {
+func (t *testServer) testStopWorkerWhenLostConnect(s *Server, etcd *embed.Etcd) {
etcd.Close()
- c.Assert(utils.WaitSomething(int(defaultKeepAliveTTL+3), time.Second, func() bool {
+ t.Require().True(utils.WaitSomething(int(defaultKeepAliveTTL+3), time.Second, func() bool {
return s.getSourceWorker(true) == nil
- }), check.IsTrue)
- c.Assert(s.getSourceWorker(true), check.IsNil)
+ }))
+ t.Require().Nil(s.getSourceWorker(true))
}
-func (t *testServer) TestGetMinLocInAllSubTasks(c *check.C) {
+func (t *testServer) TestGetMinLocInAllSubTasks() {
subTaskCfg := map[string]config.SubTaskConfig{
"test2": {Name: "test2"},
"test3": {Name: "test3"},
"test1": {Name: "test1"},
}
minLoc, err := getMinLocInAllSubTasks(context.Background(), subTaskCfg)
- c.Assert(err, check.IsNil)
- c.Assert(minLoc.Position.Name, check.Equals, "mysql-binlog.00001")
- c.Assert(minLoc.Position.Pos, check.Equals, uint32(12))
+ t.Require().NoError(err)
+ t.Require().Equal("mysql-binlog.00001", minLoc.Position.Name)
+ t.Require().Equal(uint32(12), minLoc.Position.Pos)
for k, cfg := range subTaskCfg {
cfg.EnableGTID = true
@@ -661,9 +666,9 @@ func (t *testServer) TestGetMinLocInAllSubTasks(c *check.C) {
}
minLoc, err = getMinLocInAllSubTasks(context.Background(), subTaskCfg)
- c.Assert(err, check.IsNil)
- c.Assert(minLoc.Position.Name, check.Equals, "mysql-binlog.00001")
- c.Assert(minLoc.Position.Pos, check.Equals, uint32(123))
+ t.Require().NoError(err)
+ t.Require().Equal("mysql-binlog.00001", minLoc.Position.Name)
+ t.Require().Equal(uint32(123), minLoc.Position.Pos)
}
func getFakeLocForSubTask(ctx context.Context, subTaskCfg config.SubTaskConfig) (minLoc *binlog.Location, err error) {
@@ -725,24 +730,24 @@ func checkRelayStatus(cli pb.WorkerClient, expect pb.Stage) bool {
return status.SourceStatus.RelayStatus.Stage == expect
}
-func loadSourceConfigWithoutPassword(c *check.C) *config.SourceConfig {
+func loadSourceConfigWithoutPassword(t require.TestingT) *config.SourceConfig {
sourceCfg, err := config.SourceCfgFromYamlAndVerify(config.SampleSourceConfig)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
sourceCfg.From.Password = "" // no password set
return sourceCfg
}
-func (t *testServer) TestServerDataRace(c *check.C) {
+func (t *testServer) TestServerDataRace() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -756,7 +761,7 @@ func (t *testServer) TestServerDataRace(c *check.C) {
go func() {
defer wg.Done()
err1 := s.Start()
- c.Assert(err1 == nil || err1 == terror.ErrWorkerServerClosed, check.IsTrue)
+ t.Require().True(err1 == nil || err1 == terror.ErrWorkerServerClosed)
}()
go func() {
defer wg.Done()
diff --git a/dm/worker/source_worker_test.go b/dm/worker/source_worker_test.go
index fe6ad63dce..44c3837e68 100644
--- a/dm/worker/source_worker_test.go
+++ b/dm/worker/source_worker_test.go
@@ -22,7 +22,6 @@ import (
"time"
"github.com/DATA-DOG/go-sqlmock"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/failpoint"
"github.com/pingcap/tidb/pkg/testkit/testfailpoint"
@@ -37,6 +36,7 @@ import (
"github.com/pingcap/tiflow/dm/syncer"
"github.com/pingcap/tiflow/dm/unit"
"github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/suite"
"github.com/tikv/pd/pkg/utils/tempurl"
clientv3 "go.etcd.io/etcd/client/v3"
)
@@ -55,40 +55,40 @@ func mockShowMasterStatusNoRows(mockDB sqlmock.Sqlmock) {
mockDB.ExpectQuery(`SHOW MASTER STATUS`).WillReturnRows(rows)
}
-type testServer2 struct{}
-
-var _ = check.Suite(&testServer2{})
+type testServer2 struct {
+ suite.Suite
+}
-func (t *testServer2) SetUpSuite(c *check.C) {
+func (t *testServer2) SetupSuite() {
err := log.InitLogger(&log.Config{})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
getMinLocForSubTaskFunc = getFakeLocForSubTask
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`), check.IsNil)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/SkipRefreshFromETCDInUT", `return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`))
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/SkipRefreshFromETCDInUT", `return()`))
}
-func (t *testServer2) TearDownSuite(c *check.C) {
+func (t *testServer2) TearDownSuite() {
getMinLocForSubTaskFunc = getMinLocForSubTask
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"), check.IsNil)
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/SkipRefreshFromETCDInUT"), check.IsNil)
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"))
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/SkipRefreshFromETCDInUT"))
}
-func (t *testServer2) TestTaskAutoResume(c *check.C) {
+func (t *testServer2) TestTaskAutoResume() {
var (
taskName = "sub-task-name"
port = 8263
)
hostName := "127.0.0.1:18261"
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+hostName)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = hostName
- sourceConfig := loadSourceConfigWithoutPassword(c)
+ sourceConfig := loadSourceConfigWithoutPassword(t.T())
sourceConfig.Checker.CheckEnable = true
sourceConfig.Checker.CheckInterval = config.Duration{Duration: 40 * time.Millisecond}
sourceConfig.Checker.BackoffMin = config.Duration{Duration: 20 * time.Millisecond}
@@ -96,7 +96,7 @@ func (t *testServer2) TestTaskAutoResume(c *check.C) {
cfg.WorkerAddr = fmt.Sprintf(":%d", port)
- dir := c.MkDir()
+ dir := t.T().TempDir()
sourceConfig.RelayDir = dir
sourceConfig.MetaDir = dir
sourceConfig.EnableRelay = true
@@ -106,45 +106,45 @@ func (t *testServer2) TestTaskAutoResume(c *check.C) {
NewRelayHolder = NewRealRelayHolder
}()
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever", `return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever", `return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessForever")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/mockCreateUnitsDumpOnly", `return(true)`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/mockCreateUnitsDumpOnly", `return(true)`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/worker/mockCreateUnitsDumpOnly")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/loader/ignoreLoadCheckpointErr", `return()`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/loader/ignoreLoadCheckpointErr", `return()`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/loader/ignoreLoadCheckpointErr")
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError", `return("test auto resume inject error")`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError", `return("test auto resume inject error")`))
//nolint:errcheck
defer failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError")
s := NewServer(cfg)
defer s.Close()
go func() {
- c.Assert(s.Start(), check.IsNil)
+ t.Require().NoError(s.Start())
}()
- c.Assert(utils.WaitSomething(10, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(10, 100*time.Millisecond, func() bool {
if s.closed.Load() {
return false
}
w, err2 := s.getOrStartWorker(sourceConfig, true)
- c.Assert(err2, check.IsNil)
+ t.Require().NoError(err2)
// we set sourceConfig.EnableRelay = true above
- c.Assert(w.EnableRelay(false), check.IsNil)
- c.Assert(w.EnableHandleSubtasks(), check.IsNil)
+ t.Require().NoError(w.EnableRelay(false))
+ t.Require().NoError(w.EnableHandleSubtasks())
return true
- }), check.IsTrue)
+ }))
// start task
var subtaskCfg config.SubTaskConfig
- c.Assert(subtaskCfg.Decode(config.SampleSubtaskConfig, true), check.IsNil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(subtaskCfg.Decode(config.SampleSubtaskConfig, true))
+ t.Require().NoError(err)
subtaskCfg.Mode = "full"
subtaskCfg.Timezone = "UTC"
- c.Assert(s.getSourceWorker(true).StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true), check.IsNil)
+ t.Require().NoError(s.getSourceWorker(true).StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true))
// check task in paused state
- c.Assert(utils.WaitSomething(100, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(100, 100*time.Millisecond, func() bool {
subtaskStatus, _, _ := s.getSourceWorker(true).QueryStatus(context.Background(), taskName)
for _, st := range subtaskStatus {
if st.Name == taskName && st.Stage == pb.Stage_Paused {
@@ -152,12 +152,12 @@ func (t *testServer2) TestTaskAutoResume(c *check.C) {
}
}
return false
- }), check.IsTrue)
+ }))
//nolint:errcheck
failpoint.Disable("github.com/pingcap/tiflow/dm/dumpling/dumpUnitProcessWithError")
rtsc, ok := s.getSourceWorker(true).taskStatusChecker.(*realTaskStatusChecker)
- c.Assert(ok, check.IsTrue)
+ t.Require().True(ok)
defer func() {
// close multiple time
rtsc.Close()
@@ -165,26 +165,26 @@ func (t *testServer2) TestTaskAutoResume(c *check.C) {
}()
// check task will be auto resumed
- c.Assert(utils.WaitSomething(10, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(10, 100*time.Millisecond, func() bool {
sts, _, _ := s.getSourceWorker(true).QueryStatus(context.Background(), taskName)
for _, st := range sts {
if st.Name == taskName && st.Stage == pb.Stage_Running {
return true
}
}
- c.Log(sts)
+ t.T().Log(sts)
return false
- }), check.IsTrue)
+ }))
}
type testWorkerFunctionalities struct {
+ suite.Suite
+
createUnitCount int32
expectedCreateUnitCount int32
}
-var _ = check.Suite(&testWorkerFunctionalities{})
-
-func (t *testWorkerFunctionalities) SetUpSuite(c *check.C) {
+func (t *testWorkerFunctionalities) SetupSuite() {
NewRelayHolder = NewDummyRelayHolder
NewSubTask = NewRealSubTask
createUnits = func(cfg *config.SubTaskConfig, etcdClient *clientv3.Client, worker string, relay relay.Process) []unit.Unit {
@@ -195,28 +195,28 @@ func (t *testWorkerFunctionalities) SetUpSuite(c *check.C) {
return []unit.Unit{mockDumper, mockLoader, mockSync}
}
getMinLocForSubTaskFunc = getFakeLocForSubTask
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`))
}
-func (t *testWorkerFunctionalities) TearDownSuite(c *check.C) {
+func (t *testWorkerFunctionalities) TearDownSuite() {
NewRelayHolder = NewRealRelayHolder
NewSubTask = NewRealSubTask
createUnits = createRealUnits
getMinLocForSubTaskFunc = getMinLocForSubTask
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"), check.IsNil)
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"))
}
-func (t *testWorkerFunctionalities) TestWorkerFunctionalities(c *check.C) {
+func (t *testWorkerFunctionalities) TestWorkerFunctionalities() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -227,137 +227,137 @@ func (t *testWorkerFunctionalities) TestWorkerFunctionalities(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(err)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.EnableRelay = false
subtaskCfg := config.SubTaskConfig{}
err = subtaskCfg.Decode(config.SampleSubtaskConfig, true)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// start worker
w, err := NewSourceWorker(sourceCfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer w.Stop(true)
go func() {
w.Start()
}()
- c.Assert(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
return !w.closed.Load()
- }), check.IsTrue)
+ }))
// test 1: when subTaskEnabled is false, switch on relay
- c.Assert(w.subTaskEnabled.Load(), check.IsFalse)
- t.testEnableRelay(c, w, etcdCli, sourceCfg, cfg)
+ t.Require().False(w.subTaskEnabled.Load())
+ t.testEnableRelay(w, etcdCli, sourceCfg, cfg)
// test2: when subTaskEnabled is false, switch off relay
- c.Assert(w.subTaskEnabled.Load(), check.IsFalse)
- t.testDisableRelay(c, w)
+ t.Require().False(w.subTaskEnabled.Load())
+ t.testDisableRelay(w)
// test3: when relayEnabled is false, switch on subtask
- c.Assert(w.relayEnabled.Load(), check.IsFalse)
+ t.Require().False(w.relayEnabled.Load())
- t.testEnableHandleSubtasks(c, w, etcdCli, subtaskCfg, sourceCfg)
+ t.testEnableHandleSubtasks(w, etcdCli, subtaskCfg, sourceCfg)
// test4: when subTaskEnabled is true, switch on relay
- c.Assert(w.subTaskEnabled.Load(), check.IsTrue)
+ t.Require().True(w.subTaskEnabled.Load())
- t.testEnableRelay(c, w, etcdCli, sourceCfg, cfg)
- c.Assert(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay, check.IsTrue)
+ t.testEnableRelay(w, etcdCli, sourceCfg, cfg)
+ t.Require().True(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay)
t.expectedCreateUnitCount++
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return atomic.LoadInt32(&t.createUnitCount) == t.expectedCreateUnitCount
- }), check.IsTrue)
+ }))
// test5: when subTaskEnabled is true, switch off relay
- c.Assert(w.subTaskEnabled.Load(), check.IsTrue)
- t.testDisableRelay(c, w)
+ t.Require().True(w.subTaskEnabled.Load())
+ t.testDisableRelay(w)
- c.Assert(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay, check.IsFalse)
+ t.Require().False(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay)
t.expectedCreateUnitCount++
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return atomic.LoadInt32(&t.createUnitCount) == t.expectedCreateUnitCount
- }), check.IsTrue)
+ }))
// test6: when relayEnabled is false, switch off subtask
- c.Assert(w.relayEnabled.Load(), check.IsFalse)
+ t.Require().False(w.relayEnabled.Load())
w.DisableHandleSubtasks()
- c.Assert(w.subTaskEnabled.Load(), check.IsFalse)
+ t.Require().False(w.subTaskEnabled.Load())
// prepare for test7 & 8
- t.testEnableRelay(c, w, etcdCli, sourceCfg, cfg)
+ t.testEnableRelay(w, etcdCli, sourceCfg, cfg)
// test7: when relayEnabled is true, switch on subtask
- c.Assert(w.relayEnabled.Load(), check.IsTrue)
+ t.Require().True(w.relayEnabled.Load())
subtaskCfg2 := subtaskCfg
subtaskCfg2.Name = "sub-task-name-2"
// we already added subtaskCfg, so below EnableHandleSubtasks will find an extra subtask
t.expectedCreateUnitCount++
- t.testEnableHandleSubtasks(c, w, etcdCli, subtaskCfg2, sourceCfg)
- c.Assert(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay, check.IsTrue)
- c.Assert(w.subTaskHolder.findSubTask(subtaskCfg2.Name).cfg.UseRelay, check.IsTrue)
+ t.testEnableHandleSubtasks(w, etcdCli, subtaskCfg2, sourceCfg)
+ t.Require().True(w.subTaskHolder.findSubTask(subtaskCfg.Name).cfg.UseRelay)
+ t.Require().True(w.subTaskHolder.findSubTask(subtaskCfg2.Name).cfg.UseRelay)
// test8: when relayEnabled is true, switch off subtask
- c.Assert(w.relayEnabled.Load(), check.IsTrue)
+ t.Require().True(w.relayEnabled.Load())
w.DisableHandleSubtasks()
- c.Assert(w.subTaskEnabled.Load(), check.IsFalse)
+ t.Require().False(w.subTaskEnabled.Load())
}
-func (t *testWorkerFunctionalities) testEnableRelay(c *check.C, w *SourceWorker, etcdCli *clientv3.Client,
+func (t *testWorkerFunctionalities) testEnableRelay(w *SourceWorker, etcdCli *clientv3.Client,
sourceCfg *config.SourceConfig, cfg *Config,
) {
- c.Assert(w.EnableRelay(false), check.IsNil)
+ t.Require().NoError(w.EnableRelay(false))
- c.Assert(w.relayEnabled.Load(), check.IsTrue)
- c.Assert(w.relayHolder.Stage(), check.Equals, pb.Stage_New)
+ t.Require().True(w.relayEnabled.Load())
+ t.Require().Equal(pb.Stage_New, w.relayHolder.Stage())
_, err := ha.PutSourceCfg(etcdCli, sourceCfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = ha.PutRelayStageRelayConfigSourceBound(etcdCli, ha.NewRelayStage(pb.Stage_Running, sourceCfg.SourceID),
ha.NewSourceBound(sourceCfg.SourceID, cfg.Name))
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.relayHolder.Stage() == pb.Stage_Running
- }), check.IsTrue)
+ }))
_, err = ha.DeleteSourceCfgRelayStageSourceBound(etcdCli, sourceCfg.SourceID, cfg.Name)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.relayHolder.Stage() == pb.Stage_Stopped
- }), check.IsTrue)
+ }))
}
-func (t *testWorkerFunctionalities) testDisableRelay(c *check.C, w *SourceWorker) {
+func (t *testWorkerFunctionalities) testDisableRelay(w *SourceWorker) {
w.DisableRelay()
- c.Assert(w.relayEnabled.Load(), check.IsFalse)
- c.Assert(w.relayHolder, check.IsNil)
+ t.Require().False(w.relayEnabled.Load())
+ t.Require().Nil(w.relayHolder)
}
-func (t *testWorkerFunctionalities) testEnableHandleSubtasks(c *check.C, w *SourceWorker, etcdCli *clientv3.Client,
+func (t *testWorkerFunctionalities) testEnableHandleSubtasks(w *SourceWorker, etcdCli *clientv3.Client,
subtaskCfg config.SubTaskConfig, sourceCfg *config.SourceConfig,
) {
- c.Assert(w.EnableHandleSubtasks(), check.IsNil)
- c.Assert(w.subTaskEnabled.Load(), check.IsTrue)
+ t.Require().NoError(w.EnableHandleSubtasks())
+ t.Require().True(w.subTaskEnabled.Load())
_, err := ha.PutSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.subTaskHolder.findSubTask(subtaskCfg.Name) != nil
- }), check.IsTrue)
+ }))
t.expectedCreateUnitCount++
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return atomic.LoadInt32(&t.createUnitCount) == t.expectedCreateUnitCount
- }), check.IsTrue)
+ }))
}
-type testWorkerEtcdCompact struct{}
-
-var _ = check.Suite(&testWorkerEtcdCompact{})
+type testWorkerEtcdCompact struct {
+ suite.Suite
+}
-func (t *testWorkerEtcdCompact) SetUpSuite(c *check.C) {
+func (t *testWorkerEtcdCompact) SetupSuite() {
NewRelayHolder = NewDummyRelayHolder
NewSubTask = func(cfg *config.SubTaskConfig, etcdClient *clientv3.Client, worker string) *SubTask {
cfg.UseRelay = false
@@ -369,29 +369,29 @@ func (t *testWorkerEtcdCompact) SetUpSuite(c *check.C) {
mockSync := NewMockUnit(pb.UnitType_Sync)
return []unit.Unit{mockDumper, mockLoader, mockSync}
}
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`), check.IsNil)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`))
}
-func (t *testWorkerEtcdCompact) TearDownSuite(c *check.C) {
+func (t *testWorkerEtcdCompact) TearDownSuite() {
NewRelayHolder = NewRealRelayHolder
NewSubTask = NewRealSubTask
createUnits = createRealUnits
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"), check.IsNil)
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"))
}
-func (t *testWorkerEtcdCompact) TestWatchSubtaskStageEtcdCompact(c *check.C) {
+func (t *testWorkerEtcdCompact) TestWatchSubtaskStageEtcdCompact() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
startRev = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -402,75 +402,75 @@ func (t *testWorkerEtcdCompact) TestWatchSubtaskStageEtcdCompact(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(err)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.From = config.GetDBConfigForTest()
sourceCfg.EnableRelay = false
// step 1: start worker
w, err := NewSourceWorker(sourceCfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
defer w.Stop(true)
go func() {
w.Start()
}()
- c.Assert(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
return !w.closed.Load()
- }), check.IsTrue)
+ }))
// step 2: Put a subtask config and subtask stage to this source, then delete it
subtaskCfg := config.SubTaskConfig{}
err = subtaskCfg.Decode(config.SampleSubtaskConfig, true)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subtaskCfg.MydumperPath = mydumperPath
_, err = ha.PutSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
rev, err := ha.DeleteSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg},
[]ha.Stage{ha.NewSubTaskStage(pb.Stage_Stopped, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// step 2.1: start a subtask manually
- c.Assert(w.StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true), check.IsNil)
+ t.Require().NoError(w.StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true))
// step 3: trigger etcd compaction and check whether we can receive it through watcher
_, err = etcdCli.Compact(ctx, rev)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subTaskStageCh := make(chan ha.Stage, 10)
subTaskErrCh := make(chan error, 10)
ha.WatchSubTaskStage(ctx, etcdCli, sourceCfg.SourceID, startRev, subTaskStageCh, subTaskErrCh)
select {
case err = <-subTaskErrCh:
- c.Assert(errors.Cause(err), check.Equals, etcdErrCompacted)
+ t.Require().Equal(etcdErrCompacted, errors.Cause(err))
case <-time.After(300 * time.Millisecond):
- c.Fatal("fail to get etcd error compacted")
+ t.T().Fatal("fail to get etcd error compacted")
}
// step 4: watch subtask stage from startRev
- c.Assert(w.subTaskHolder.findSubTask(subtaskCfg.Name), check.NotNil)
+ t.Require().NotNil(w.subTaskHolder.findSubTask(subtaskCfg.Name))
var wg sync.WaitGroup
ctx1, cancel1 := context.WithCancel(ctx)
wg.Add(1)
go func() {
defer wg.Done()
- c.Assert(w.observeSubtaskStage(ctx1, etcdCli, startRev), check.IsNil)
+ t.Require().NoError(w.observeSubtaskStage(ctx1, etcdCli, startRev))
}()
time.Sleep(time.Second)
// step 4.1: after observe, invalid subtask should be removed
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.subTaskHolder.findSubTask(subtaskCfg.Name) == nil
- }), check.IsTrue)
+ }))
// step 4.2: add a new subtask stage, worker should receive and start it
_, err = ha.PutSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().NoError(err)
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.subTaskHolder.findSubTask(subtaskCfg.Name) != nil
- }), check.IsTrue)
- mockDB := conn.InitMockDB(c)
+ }))
+ mockDB := conn.InitMockDB(t.T())
mockShowMasterStatus(mockDB)
status, _, err := w.QueryStatus(ctx1, subtaskCfg.Name)
- c.Assert(err, check.IsNil)
- c.Assert(status, check.HasLen, 1)
- c.Assert(status[0].Name, check.Equals, subtaskCfg.Name)
- c.Assert(status[0].Stage, check.Equals, pb.Stage_Running)
+ t.Require().NoError(err)
+ t.Require().Len(status, 1)
+ t.Require().Equal(subtaskCfg.Name, status[0].Name)
+ t.Require().Equal(pb.Stage_Running, status[0].Stage)
cancel1()
wg.Wait()
w.subTaskHolder.closeAllSubTasks()
@@ -479,36 +479,36 @@ func (t *testWorkerEtcdCompact) TestWatchSubtaskStageEtcdCompact(c *check.C) {
wg.Add(1)
go func() {
defer wg.Done()
- c.Assert(w.observeSubtaskStage(ctx2, etcdCli, startRev), check.IsNil)
+ t.Require().NoError(w.observeSubtaskStage(ctx2, etcdCli, startRev))
}()
time.Sleep(time.Second)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.subTaskHolder.findSubTask(subtaskCfg.Name) != nil
- }), check.IsTrue)
+ }))
mockShowMasterStatus(mockDB)
status, _, err = w.QueryStatus(ctx2, subtaskCfg.Name)
- c.Assert(err, check.IsNil)
- c.Assert(status, check.HasLen, 1)
- c.Assert(status[0].Name, check.Equals, subtaskCfg.Name)
- c.Assert(status[0].Stage, check.Equals, pb.Stage_Running)
+ t.Require().NoError(err)
+ t.Require().Len(status, 1)
+ t.Require().Equal(subtaskCfg.Name, status[0].Name)
+ t.Require().Equal(pb.Stage_Running, status[0].Stage)
w.Stop(true)
cancel2()
wg.Wait()
}
-func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact(c *check.C) {
+func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
startRev = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -519,56 +519,56 @@ func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(err)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.From = config.GetDBConfigForTest()
sourceCfg.EnableRelay = false
//
// step 1: start worker
w, err := NewSourceWorker(sourceCfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
defer w.Stop(true)
go func() {
w.Start()
}()
- c.Assert(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
return !w.closed.Load()
- }), check.IsTrue)
+ }))
//
// step 2: Put a subtask config and subtask stage to this source, then delete it
subtaskCfg := config.SubTaskConfig{}
err = subtaskCfg.Decode(config.SampleSubtaskConfig, true)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subtaskCfg.MydumperPath = mydumperPath
subtaskCfg.ValidatorCfg = config.ValidatorConfig{Mode: config.ValidationNone}
// increase revision
_, err = etcdCli.Put(context.Background(), "/dummy-key", "value")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
rev, err := ha.PutSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg}, []ha.Stage{ha.NewSubTaskStage(pb.Stage_Running, sourceCfg.SourceID, subtaskCfg.Name)}, nil)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
//
// step 2.1: start a subtask manually
- c.Assert(w.StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true), check.IsNil)
+ t.Require().NoError(w.StartSubTask(&subtaskCfg, pb.Stage_Running, pb.Stage_Stopped, true))
//
// step 3: trigger etcd compaction and check whether we can receive it through watcher
_, err = etcdCli.Compact(ctx, rev)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
subTaskStageCh := make(chan ha.Stage, 10)
subTaskErrCh := make(chan error, 10)
ctxForWatch, cancelFunc := context.WithCancel(ctx)
ha.WatchValidatorStage(ctxForWatch, etcdCli, sourceCfg.SourceID, startRev, subTaskStageCh, subTaskErrCh)
select {
case err = <-subTaskErrCh:
- c.Assert(errors.Cause(err), check.Equals, etcdErrCompacted)
+ t.Require().Equal(etcdErrCompacted, errors.Cause(err))
case <-time.After(300 * time.Millisecond):
- c.Fatal("fail to get etcd error compacted")
+ t.T().Fatal("fail to get etcd error compacted")
}
cancelFunc()
@@ -580,14 +580,14 @@ func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact(c *check.C) {
defer subTask.RUnlock()
return subTask.validator
}
- c.Assert(subTask, check.NotNil)
- c.Assert(getValidator(), check.IsNil)
+ t.Require().NotNil(subTask)
+ t.Require().Nil(getValidator())
var wg sync.WaitGroup
ctx1, cancel1 := context.WithCancel(ctx)
wg.Add(1)
go func() {
defer wg.Done()
- c.Assert(w.observeValidatorStage(ctx1, startRev), check.IsNil)
+ t.Require().NoError(w.observeValidatorStage(ctx1, startRev))
}()
time.Sleep(time.Second)
@@ -596,12 +596,12 @@ func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact(c *check.C) {
subTask.units[len(subTask.units)-1] = &syncer.Syncer{} // validator need a Syncer, not a mocked unit
validatorStage := ha.NewValidatorStage(pb.Stage_Running, subtaskCfg.SourceID, subtaskCfg.Name)
_, err = ha.PutSubTaskCfgStage(etcdCli, []config.SubTaskConfig{subtaskCfg}, nil, []ha.Stage{validatorStage})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// validator created
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return getValidator() != nil
- }), check.IsTrue)
+ }))
subTask.units[len(subTask.units)-1] = unitBakup // restore unit
cancel1()
@@ -609,27 +609,28 @@ func (t *testWorkerEtcdCompact) TestWatchValidatorStageEtcdCompact(c *check.C) {
// test operate validator
err = w.operateValidatorStage(ha.Stage{IsDeleted: true})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = w.operateValidatorStage(ha.Stage{Expect: pb.Stage_Running, Task: "not-exist"})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
err = w.operateValidatorStage(ha.Stage{Expect: pb.Stage_Running, Task: subtaskCfg.Name})
- c.Assert(err, check.ErrorMatches, ".*failed to get subtask config.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*failed to get subtask config.*", err.Error())
err = w.operateValidatorStage(ha.Stage{Expect: pb.Stage_Running, Source: subtaskCfg.SourceID, Task: subtaskCfg.Name})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
}
-func (t *testWorkerEtcdCompact) TestWatchRelayStageEtcdCompact(c *check.C) {
+func (t *testWorkerEtcdCompact) TestWatchRelayStageEtcdCompact() {
var (
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
startRev = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
cfg := NewConfig()
- c.Assert(cfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(cfg.Parse([]string{"-config=./dm-worker.toml"}))
cfg.Join = masterAddr
cfg.KeepAliveTTL = keepAliveTTL
cfg.RelayKeepAliveTTL = keepAliveTTL
@@ -640,62 +641,62 @@ func (t *testWorkerEtcdCompact) TestWatchRelayStageEtcdCompact(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
- sourceCfg := loadSourceConfigWithoutPassword(c)
+ t.Require().NoError(err)
+ sourceCfg := loadSourceConfigWithoutPassword(t.T())
sourceCfg.EnableRelay = true
- sourceCfg.RelayDir = c.MkDir()
- sourceCfg.MetaDir = c.MkDir()
+ sourceCfg.RelayDir = t.T().TempDir()
+ sourceCfg.MetaDir = t.T().TempDir()
// step 1: start worker
w, err := NewSourceWorker(sourceCfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
defer w.Stop(true)
go func() {
- c.Assert(w.EnableRelay(false), check.IsNil)
+ t.Require().NoError(w.EnableRelay(false))
w.Start()
}()
- c.Assert(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(50, 100*time.Millisecond, func() bool {
return !w.closed.Load()
- }), check.IsTrue)
+ }))
// step 2: Put a relay stage to this source, then delete it
// put mysql config into relative etcd key adapter to trigger operation event
- c.Assert(w.relayHolder, check.NotNil)
+ t.Require().NotNil(w.relayHolder)
_, err = ha.PutSourceCfg(etcdCli, sourceCfg)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
rev, err := ha.PutRelayStageRelayConfigSourceBound(etcdCli, ha.NewRelayStage(pb.Stage_Running, sourceCfg.SourceID),
ha.NewSourceBound(sourceCfg.SourceID, cfg.Name))
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
// check relay stage, should be running
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.relayHolder.Stage() == pb.Stage_Running
- }), check.IsTrue)
+ }))
// step 3: trigger etcd compaction and check whether we can receive it through watcher, then we delete relay stage
_, err = etcdCli.Compact(ctx, rev)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
_, err = ha.DeleteSourceCfgRelayStageSourceBound(etcdCli, sourceCfg.SourceID, cfg.Name)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
relayStageCh := make(chan ha.Stage, 10)
relayErrCh := make(chan error, 10)
ha.WatchRelayStage(ctx, etcdCli, cfg.Name, startRev, relayStageCh, relayErrCh)
select {
case err := <-relayErrCh:
- c.Assert(errors.Cause(err), check.Equals, etcdErrCompacted)
+ t.Require().Equal(etcdErrCompacted, errors.Cause(err))
case <-time.After(300 * time.Millisecond):
- c.Fatal("fail to get etcd error compacted")
+ t.T().Fatal("fail to get etcd error compacted")
}
// step 4: should stop the running relay because see deletion after compaction
time.Sleep(time.Second)
- c.Assert(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
+ t.Require().True(utils.WaitSomething(30, 100*time.Millisecond, func() bool {
return w.relayHolder.Stage() == pb.Stage_Stopped
- }), check.IsTrue)
+ }))
}
-func (t *testServer) testSourceWorker(c *check.C) {
- cfg := loadSourceConfigWithoutPassword(c)
+func (t *testServer) testSourceWorker() {
+ cfg := loadSourceConfigWithoutPassword(t.T())
- dir := c.MkDir()
+ dir := t.T().TempDir()
cfg.EnableRelay = true
cfg.RelayDir = dir
cfg.MetaDir = dir
@@ -704,12 +705,12 @@ func (t *testServer) testSourceWorker(c *check.C) {
masterAddr = tempurl.Alloc()[len("http://"):]
keepAliveTTL = int64(1)
)
- etcdDir := c.MkDir()
+ etcdDir := t.T().TempDir()
ETCD, err := createMockETCD(etcdDir, "http://"+masterAddr)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
defer ETCD.Close()
workerCfg := NewConfig()
- c.Assert(workerCfg.Parse([]string{"-config=./dm-worker.toml"}), check.IsNil)
+ t.Require().NoError(workerCfg.Parse([]string{"-config=./dm-worker.toml"}))
workerCfg.Join = masterAddr
workerCfg.KeepAliveTTL = keepAliveTTL
workerCfg.RelayKeepAliveTTL = keepAliveTTL
@@ -720,66 +721,70 @@ func (t *testServer) testSourceWorker(c *check.C) {
DialKeepAliveTime: keepaliveTime,
DialKeepAliveTimeout: keepaliveTimeout,
})
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
NewRelayHolder = NewDummyRelayHolderWithInitError
defer func() {
NewRelayHolder = NewRealRelayHolder
}()
w, err := NewSourceWorker(cfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
- c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`), check.IsNil)
- c.Assert(w.EnableRelay(false), check.ErrorMatches, "init error")
- c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"), check.IsNil)
+ t.Require().NoError(err)
+ t.Require().NoError(failpoint.Enable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD", `return(true)`))
+ err = w.EnableRelay(false)
+ t.Require().Error(err)
+ t.Require().Regexp("init error", err.Error())
+ t.Require().NoError(failpoint.Disable("github.com/pingcap/tiflow/dm/worker/MockGetSourceCfgFromETCD"))
NewRelayHolder = NewDummyRelayHolder
w, err = NewSourceWorker(cfg, etcdCli, "", "")
- c.Assert(err, check.IsNil)
- c.Assert(w.GetUnitAndSourceStatusJSON("", nil), check.HasLen, emptyWorkerStatusInfoJSONLength)
+ t.Require().NoError(err)
+ t.Require().Len(w.GetUnitAndSourceStatusJSON("", nil), emptyWorkerStatusInfoJSONLength)
// stop twice
w.Stop(true)
- c.Assert(w.closed.Load(), check.IsTrue)
- c.Assert(w.subTaskHolder.getAllSubTasks(), check.HasLen, 0)
+ t.Require().True(w.closed.Load())
+ t.Require().Len(w.subTaskHolder.getAllSubTasks(), 0)
w.Stop(true)
- c.Assert(w.closed.Load(), check.IsTrue)
- c.Assert(w.subTaskHolder.getAllSubTasks(), check.HasLen, 0)
- c.Assert(w.closed.Load(), check.IsTrue)
+ t.Require().True(w.closed.Load())
+ t.Require().Len(w.subTaskHolder.getAllSubTasks(), 0)
+ t.Require().True(w.closed.Load())
- c.Assert(w.StartSubTask(&config.SubTaskConfig{
+ t.Require().NoError(w.StartSubTask(&config.SubTaskConfig{
Name: "testStartTask",
- }, pb.Stage_Running, pb.Stage_Stopped, true), check.IsNil)
+ }, pb.Stage_Running, pb.Stage_Stopped, true))
task := w.subTaskHolder.findSubTask("testStartTask")
- c.Assert(task, check.NotNil)
- c.Assert(task.Result().String(), check.Matches, ".*worker already closed.*")
+ t.Require().NotNil(task)
+ t.Require().Regexp(".*worker already closed.*", task.Result().String())
- c.Assert(w.StartSubTask(&config.SubTaskConfig{
+ t.Require().NoError(w.StartSubTask(&config.SubTaskConfig{
Name: "testStartTask-in-stopped",
- }, pb.Stage_Stopped, pb.Stage_Stopped, true), check.IsNil)
+ }, pb.Stage_Stopped, pb.Stage_Stopped, true))
task = w.subTaskHolder.findSubTask("testStartTask-in-stopped")
- c.Assert(task, check.NotNil)
- c.Assert(task.Result().String(), check.Matches, ".*worker already closed.*")
+ t.Require().NotNil(task)
+ t.Require().Regexp(".*worker already closed.*", task.Result().String())
err = w.UpdateSubTask(context.Background(), &config.SubTaskConfig{
Name: "testStartTask",
}, true)
- c.Assert(err, check.ErrorMatches, ".*worker already closed.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*worker already closed.*", err.Error())
err = w.OperateSubTask("testSubTask", pb.TaskOp_Delete)
- c.Assert(err, check.ErrorMatches, ".*worker already closed.*")
+ t.Require().Error(err)
+ t.Require().Regexp(".*worker already closed.*", err.Error())
}
-func (t *testServer) TestQueryValidator(c *check.C) {
- cfg := loadSourceConfigWithoutPassword(c)
+func (t *testServer) TestQueryValidator() {
+ cfg := loadSourceConfigWithoutPassword(t.T())
- dir := c.MkDir()
+ dir := t.T().TempDir()
cfg.EnableRelay = true
cfg.RelayDir = dir
cfg.MetaDir = dir
w, err := NewSourceWorker(cfg, nil, "", "")
w.closed.Store(false)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
st := NewSubTaskWithStage(&config.SubTaskConfig{
Name: "testQueryValidator",
ValidatorCfg: config.ValidatorConfig{
@@ -789,14 +794,14 @@ func (t *testServer) TestQueryValidator(c *check.C) {
w.subTaskHolder.recordSubTask(st)
var ret *pb.ValidationStatus
ret, err = w.GetValidatorStatus("invalidTaskName")
- c.Assert(ret, check.IsNil)
- c.Assert(terror.ErrWorkerSubTaskNotFound.Equal(err), check.IsTrue)
+ t.Require().Nil(ret)
+ t.Require().True(terror.ErrWorkerSubTaskNotFound.Equal(err))
}
-func (t *testServer) setupValidator(c *check.C) *SourceWorker {
- cfg := loadSourceConfigWithoutPassword(c)
+func (t *testServer) setupValidator() *SourceWorker {
+ cfg := loadSourceConfigWithoutPassword(t.T())
- dir := c.MkDir()
+ dir := t.T().TempDir()
cfg.EnableRelay = true
cfg.RelayDir = dir
cfg.MetaDir = dir
@@ -810,25 +815,25 @@ func (t *testServer) setupValidator(c *check.C) *SourceWorker {
st.StartValidator(pb.Stage_Running, false)
w.subTaskHolder.recordSubTask(st)
w.closed.Store(false)
- c.Assert(err, check.IsNil)
+ t.Require().NoError(err)
return w
}
-func (t *testServer) TestGetWorkerValidatorErr(c *check.C) {
- w := t.setupValidator(c)
+func (t *testServer) TestGetWorkerValidatorErr() {
+ w := t.setupValidator()
// when subtask name not exists
// return empty array
errs, err := w.GetWorkerValidatorErr("invalidTask", pb.ValidateErrorState_InvalidErr)
- c.Assert(terror.ErrWorkerSubTaskNotFound.Equal(err), check.IsTrue)
- c.Assert(errs, check.IsNil)
+ t.Require().True(terror.ErrWorkerSubTaskNotFound.Equal(err))
+ t.Require().Nil(errs)
}
-func (t *testServer) TestOperateWorkerValidatorErr(c *check.C) {
- w := t.setupValidator(c)
+func (t *testServer) TestOperateWorkerValidatorErr() {
+ w := t.setupValidator()
// when subtask name not exists
// return empty array
taskNotFound := terror.ErrWorkerSubTaskNotFound.Generate("invalidTask")
- c.Assert(w.OperateWorkerValidatorErr("invalidTask", pb.ValidationErrOp_ClearErrOp, 0, true).Error(), check.Equals, taskNotFound.Error())
+ t.Require().Equal(taskNotFound.Error(), w.OperateWorkerValidatorErr("invalidTask", pb.ValidationErrOp_ClearErrOp, 0, true).Error())
}
func TestMasterBinlogOff(t *testing.T) {
diff --git a/dm/worker/subtask_test.go b/dm/worker/subtask_test.go
index cc1f2e0ef5..1ded49153b 100644
--- a/dm/worker/subtask_test.go
+++ b/dm/worker/subtask_test.go
@@ -20,7 +20,6 @@ import (
"time"
"github.com/go-mysql-org/go-mysql/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/errors"
"github.com/pingcap/tiflow/dm/config"
"github.com/pingcap/tiflow/dm/dumpling"
@@ -42,41 +41,37 @@ const (
relayHolderBinlog = "(mysql-bin.00001,150)"
)
-type testSubTask struct{}
-
-var _ = check.Suite(&testSubTask{})
-
-func (t *testSubTask) TestCreateUnits(c *check.C) {
+func TestCreateUnits(t *testing.T) {
cfg := &config.SubTaskConfig{
Mode: "xxx",
Flavor: mysql.MySQLFlavor,
}
worker := "worker"
- c.Assert(createUnits(cfg, nil, worker, nil), check.HasLen, 0)
+ require.Len(t, createUnits(cfg, nil, worker, nil), 0)
cfg.Mode = config.ModeFull
unitsFull := createUnits(cfg, nil, worker, nil)
- c.Assert(unitsFull, check.HasLen, 2)
+ require.Len(t, unitsFull, 2)
_, ok := unitsFull[0].(*dumpling.Dumpling)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
_, ok = unitsFull[1].(*loader.LightningLoader)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
cfg.Mode = config.ModeIncrement
unitsIncr := createUnits(cfg, nil, worker, nil)
- c.Assert(unitsIncr, check.HasLen, 1)
+ require.Len(t, unitsIncr, 1)
_, ok = unitsIncr[0].(*syncer.Syncer)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
cfg.Mode = config.ModeAll
unitsAll := createUnits(cfg, nil, worker, nil)
- c.Assert(unitsAll, check.HasLen, 3)
+ require.Len(t, unitsAll, 3)
_, ok = unitsAll[0].(*dumpling.Dumpling)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
_, ok = unitsAll[1].(*loader.LightningLoader)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
_, ok = unitsAll[2].(*syncer.Syncer)
- c.Assert(ok, check.IsTrue)
+ require.True(t, ok)
}
type MockUnit struct {
@@ -217,14 +212,14 @@ func (u *KillOrderUnit) Type() pb.UnitType { return u.typ }
func (u *KillOrderUnit) IsFreshTask(context.Context) (bool, error) { return true, nil }
-func (t *testSubTask) TestSubTaskNormalUsage(c *check.C) {
+func TestSubTaskNormalUsage(t *testing.T) {
cfg := &config.SubTaskConfig{
Name: "testSubtaskScene",
Mode: config.ModeFull,
}
st := NewSubTask(cfg, nil, "worker")
- c.Assert(st.Stage(), check.DeepEquals, pb.Stage_New)
+ require.Equal(t, pb.Stage_New, st.Stage())
// test empty and fail
defer func() {
@@ -234,8 +229,8 @@ func (t *testSubTask) TestSubTaskNormalUsage(c *check.C) {
return nil
}
st.Run(pb.Stage_Running, pb.Stage_Running, nil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(strings.Contains(st.Result().Errors[0].String(), "has no dm units for mode"), check.IsTrue)
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.True(t, strings.Contains(st.Result().Errors[0].String(), "has no dm units for mode"))
mockDumper := NewMockUnit(pb.UnitType_Dump)
mockLoader := NewMockUnit(pb.UnitType_Load)
@@ -244,24 +239,24 @@ func (t *testSubTask) TestSubTaskNormalUsage(c *check.C) {
}
st.Run(pb.Stage_Running, pb.Stage_Running, nil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
// finish dump
- c.Assert(mockDumper.InjectProcessError(context.Background(), nil), check.IsNil)
+ require.NoError(t, mockDumper.InjectProcessError(context.Background(), nil))
for i := 0; i < 10; i++ {
if st.CurrUnit().Type() == pb.UnitType_Load {
break
}
time.Sleep(time.Millisecond)
}
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// fail loader
- c.Assert(mockLoader.InjectProcessError(context.Background(), errors.New("loader process error")), check.IsNil)
+ require.NoError(t, mockLoader.InjectProcessError(context.Background(), errors.New("loader process error")))
for i := 0; i < 10; i++ {
res := st.Result()
if res != nil && st.Stage() == pb.Stage_Paused {
@@ -269,74 +264,74 @@ func (t *testSubTask) TestSubTaskNormalUsage(c *check.C) {
}
time.Sleep(time.Millisecond)
}
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.NotNil)
- c.Assert(st.Result().Errors, check.HasLen, 1)
- c.Assert(strings.Contains(st.Result().Errors[0].Message, "loader process error"), check.IsTrue)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.NotNil(t, st.Result())
+ require.Len(t, st.Result().Errors, 1)
+ require.True(t, strings.Contains(st.Result().Errors[0].Message, "loader process error"))
+ require.Equal(t, pb.Stage_Paused, st.Stage())
// restore from pausing
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// update in running
- c.Assert(st.Update(context.Background(), nil), check.NotNil)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.NotNil(t, st.Update(context.Background(), nil))
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// Pause
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockLoader, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
// update again
- c.Assert(st.Update(context.Background(), &config.SubTaskConfig{Name: "updateSubtask"}), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
+ require.NoError(t, st.Update(context.Background(), &config.SubTaskConfig{Name: "updateSubtask"}))
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockLoader, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
// run again
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// pause again
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockLoader, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
// run again
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// finish loader
- c.Assert(mockLoader.InjectProcessError(context.Background(), nil), check.IsNil)
+ require.NoError(t, mockLoader.InjectProcessError(context.Background(), nil))
for i := 0; i < 1000; i++ {
if st.Stage() == pb.Stage_Finished {
break
}
time.Sleep(time.Millisecond)
}
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Finished)
- c.Assert(st.Result().Errors, check.HasLen, 0)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Equal(t, pb.Stage_Finished, st.Stage())
+ require.Len(t, st.Result().Errors, 0)
}
-func (t *testSubTask) TestKillWithCauseDoesNotCancelBeforeKill(c *check.C) {
+func TestKillWithCauseDoesNotCancelBeforeKill(t *testing.T) {
cfg := &config.SubTaskConfig{
Name: "testKillOrder",
Mode: config.ModeIncrement,
@@ -356,17 +351,17 @@ func (t *testSubTask) TestKillWithCauseDoesNotCancelBeforeKill(c *check.C) {
<-u.started
st.killWithCause(errors.New("test"))
- c.Assert(u.canceledAtKill, check.IsFalse)
+ require.False(t, u.canceledAtKill)
}
-func (t *testSubTask) TestPauseAndResumeSubtask(c *check.C) {
+func TestPauseAndResumeSubtask(t *testing.T) {
cfg := &config.SubTaskConfig{
Name: "testSubtaskScene",
Mode: config.ModeFull,
}
st := NewSubTask(cfg, nil, "worker")
- c.Assert(st.Stage(), check.DeepEquals, pb.Stage_New)
+ require.Equal(t, pb.Stage_New, st.Stage())
mockDumper := NewMockUnit(pb.UnitType_Dump)
mockLoader := NewMockUnit(pb.UnitType_Load)
@@ -378,110 +373,110 @@ func (t *testSubTask) TestPauseAndResumeSubtask(c *check.C) {
}
st.Run(pb.Stage_Running, pb.Stage_Running, nil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.CheckUnit(), check.IsFalse)
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.False(t, st.CheckUnit())
// pause twice
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
- c.Assert(st.Pause(), check.NotNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
+ require.NotNil(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
// resume
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
-
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
+
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
// resume
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
// fail dumper
- c.Assert(mockDumper.InjectProcessError(context.Background(), errors.New("dumper process error")), check.IsNil)
+ require.NoError(t, mockDumper.InjectProcessError(context.Background(), errors.New("dumper process error")))
// InjectProcessError need 1 second, here we wait 1.5 second
utils.WaitSomething(15, 100*time.Millisecond, func() bool {
return st.Result() != nil
})
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.NotNil)
- c.Assert(st.Result().Errors, check.HasLen, 1)
- c.Assert(strings.Contains(st.Result().Errors[0].Message, "dumper process error"), check.IsTrue)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.NotNil(t, st.Result())
+ require.Len(t, st.Result().Errors, 1)
+ require.True(t, strings.Contains(st.Result().Errors[0].Message, "dumper process error"))
+ require.Equal(t, pb.Stage_Paused, st.Stage())
// pause
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.NotNil)
- c.Assert(st.Result().Errors, check.HasLen, 1)
- c.Assert(st.Result().IsCanceled, check.IsTrue)
- c.Assert(strings.Contains(st.Result().Errors[0].Message, "dumper process error"), check.IsTrue)
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.NotNil(t, st.Result())
+ require.Len(t, st.Result().Errors, 1)
+ require.True(t, st.Result().IsCanceled)
+ require.True(t, strings.Contains(st.Result().Errors[0].Message, "dumper process error"))
// resume twice
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
-
- c.Assert(st.Resume(nil), check.NotNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
+
+ require.NotNil(t, st.Resume(nil))
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
// finish dump
- c.Assert(mockDumper.InjectProcessError(context.Background(), nil), check.IsNil)
+ require.NoError(t, mockDumper.InjectProcessError(context.Background(), nil))
utils.WaitSomething(20, 50*time.Millisecond, func() bool {
return st.CurrUnit().Type() == pb.UnitType_Load
})
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Result(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Nil(t, st.Result())
+ require.Equal(t, pb.Stage_Running, st.Stage())
// finish loader
- c.Assert(mockLoader.InjectProcessError(context.Background(), nil), check.IsNil)
+ require.NoError(t, mockLoader.InjectProcessError(context.Background(), nil))
utils.WaitSomething(20, 50*time.Millisecond, func() bool {
return st.Stage() == pb.Stage_Finished
})
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Finished)
- c.Assert(st.Result().Errors, check.HasLen, 0)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Equal(t, pb.Stage_Finished, st.Stage())
+ require.Len(t, st.Result().Errors, 0)
st.Run(pb.Stage_Finished, pb.Stage_Stopped, nil)
- c.Assert(st.CurrUnit(), check.Equals, mockLoader)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Finished)
- c.Assert(st.Result().Errors, check.HasLen, 0)
+ require.Equal(t, mockLoader, st.CurrUnit())
+ require.Equal(t, pb.Stage_Finished, st.Stage())
+ require.Len(t, st.Result().Errors, 0)
}
-func (t *testSubTask) TestSubtaskWithStage(c *check.C) {
+func TestSubtaskWithStage(t *testing.T) {
cfg := &config.SubTaskConfig{
SourceID: "source",
Name: "testSubtaskScene",
Mode: config.ModeFull,
}
- c.Assert(cfg.Adjust(false), check.IsNil)
+ require.NoError(t, cfg.Adjust(false))
st := NewSubTaskWithStage(cfg, pb.Stage_Paused, nil, "worker")
- c.Assert(st.Stage(), check.DeepEquals, pb.Stage_Paused)
+ require.Equal(t, pb.Stage_Paused, st.Stage())
mockDumper := NewMockUnit(pb.UnitType_Dump)
mockLoader := NewMockUnit(pb.UnitType_Load)
@@ -493,37 +488,37 @@ func (t *testSubTask) TestSubtaskWithStage(c *check.C) {
}
// pause
- c.Assert(st.Pause(), check.NotNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, nil)
- c.Assert(st.Result(), check.IsNil)
+ require.NotNil(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, nil, st.CurrUnit())
+ require.Nil(t, st.Result())
- c.Assert(st.Resume(nil), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
- c.Assert(st.Result(), check.IsNil)
+ require.NoError(t, st.Resume(nil))
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
+ require.Nil(t, st.Result())
// pause again
- c.Assert(st.Pause(), check.IsNil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
- c.Assert(st.CurrUnit(), check.Equals, mockDumper)
+ require.NoError(t, st.Pause())
+ require.Equal(t, pb.Stage_Paused, st.Stage())
+ require.Equal(t, mockDumper, st.CurrUnit())
if st.Result() != nil && (!st.Result().IsCanceled || len(st.Result().Errors) > 0) {
- c.Fatalf("result %+v is not right after closing", st.Result())
+ t.Fatalf("result %+v is not right after closing", st.Result())
}
st = NewSubTaskWithStage(cfg, pb.Stage_Finished, nil, "worker")
- c.Assert(st.Stage(), check.DeepEquals, pb.Stage_Finished)
+ require.Equal(t, pb.Stage_Finished, st.Stage())
createUnits = func(cfg *config.SubTaskConfig, etcdClient *clientv3.Client, worker string, relay relay.Process) []unit.Unit {
return []unit.Unit{mockDumper, mockLoader}
}
st.Run(pb.Stage_Finished, pb.Stage_Stopped, nil)
- c.Assert(st.Stage(), check.Equals, pb.Stage_Finished)
- c.Assert(st.CurrUnit(), check.Equals, nil)
- c.Assert(st.Result(), check.IsNil)
+ require.Equal(t, pb.Stage_Finished, st.Stage())
+ require.Equal(t, nil, st.CurrUnit())
+ require.Nil(t, st.Result())
}
-func (t *testSubTask) TestSubtaskFastQuit(c *check.C) {
+func TestSubtaskFastQuit(t *testing.T) {
// case: test subtask stuck into unitTransWaitCondition
cfg := &config.SubTaskConfig{
Name: "testSubtaskFastQuit",
@@ -555,14 +550,14 @@ func (t *testSubTask) TestSubtaskFastQuit(c *check.C) {
// test Pause
time.Sleep(time.Second) // wait for task to run for some time
- c.Assert(st.Stage(), check.Equals, pb.Stage_Running)
- c.Assert(st.Pause(), check.IsNil)
+ require.Equal(t, pb.Stage_Running, st.Stage())
+ require.NoError(t, st.Pause())
select {
case <-time.After(500 * time.Millisecond):
- c.Fatal("fail to pause subtask in 0.5s when stuck into unitTransWaitCondition")
+ t.Fatal("fail to pause subtask in 0.5s when stuck into unitTransWaitCondition")
case <-finished:
}
- c.Assert(st.Stage(), check.Equals, pb.Stage_Paused)
+ require.Equal(t, pb.Stage_Paused, st.Stage())
st = NewSubTaskWithStage(cfg, pb.Stage_Paused, nil, "worker")
st.units = []unit.Unit{mockLoader, mockSyncer}
@@ -575,17 +570,17 @@ func (t *testSubTask) TestSubtaskFastQuit(c *check.C) {
close(finished)
}()
- c.Assert(utils.WaitSomething(10, 100*time.Millisecond, func() bool {
+ require.True(t, utils.WaitSomething(10, 100*time.Millisecond, func() bool {
return st.Stage() == pb.Stage_Running
- }), check.IsTrue)
+ }))
// test Close
st.Close()
select {
case <-time.After(500 * time.Millisecond):
- c.Fatal("fail to stop subtask in 0.5s when stuck into unitTransWaitCondition")
+ t.Fatal("fail to stop subtask in 0.5s when stuck into unitTransWaitCondition")
case <-finished:
}
- c.Assert(st.Stage(), check.Equals, pb.Stage_Stopped)
+ require.Equal(t, pb.Stage_Stopped, st.Stage())
}
func TestGetValidatorError(t *testing.T) {
diff --git a/go.mod b/go.mod
index db366fb4ba..1319cb5cda 100644
--- a/go.mod
+++ b/go.mod
@@ -69,7 +69,6 @@ require (
github.com/olekukonko/tablewriter v0.0.5
github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2
github.com/pierrec/lz4/v4 v4.1.26
- github.com/pingcap/check v0.0.0-20211026125417-57bd13f7b5f0
github.com/pingcap/errors v0.11.5-0.20260508054701-306e305bcf41
github.com/pingcap/failpoint v0.0.0-20240528011301-b51a646c7c86
github.com/pingcap/kvproto v0.0.0-20260601035955-b2b3bb492278
diff --git a/go.sum b/go.sum
index 430e8295f2..dbd7960202 100644
--- a/go.sum
+++ b/go.sum
@@ -873,9 +873,6 @@ github.com/pierrec/lz4/v4 v4.1.26 h1:GrpZw1gZttORinvzBdXPUXATeqlJjqUG/D87TKMnhjY
github.com/pierrec/lz4/v4 v4.1.26/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
github.com/pingcap/badger v1.5.1-0.20241015064302-38533b6cbf8d h1:eHcokyHxm7HVM+7+Qy1zZwC7NhX9wVNX8oQDcSZw1qI=
github.com/pingcap/badger v1.5.1-0.20241015064302-38533b6cbf8d/go.mod h1:KiO2zumBCWx7yoVYoFRpb+DNrwEPk1pR1LF7NvOACMQ=
-github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8/go.mod h1:B1+S9LNcuMyLH/4HMTViQOJevkGiik3wW2AN9zb2fNQ=
-github.com/pingcap/check v0.0.0-20211026125417-57bd13f7b5f0 h1:HVl5539r48eA+uDuX/ziBmQCxzT1pGrzWbKuXT46Bq0=
-github.com/pingcap/check v0.0.0-20211026125417-57bd13f7b5f0/go.mod h1:PYMCGwN0JHjoqGr3HrZoD+b8Tgx8bKnArhSq8YVzUMc=
github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
github.com/pingcap/errors v0.11.5-0.20190809092503-95897b64e011/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
@@ -890,7 +887,6 @@ github.com/pingcap/goleveldb v0.0.0-20191226122134-f82aafb29989/go.mod h1:O17Xtb
github.com/pingcap/kvproto v0.0.0-20191211054548-3c6b38ea5107/go.mod h1:WWLmULLO7l8IOcQG+t+ItJ3fEcrL5FxF0Wu+HrMy26w=
github.com/pingcap/kvproto v0.0.0-20260601035955-b2b3bb492278 h1:VV03wSSG2XhOwhF79lvT88Z83lwzMT+aZHXrcCIN9B0=
github.com/pingcap/kvproto v0.0.0-20260601035955-b2b3bb492278/go.mod h1:z6+aAHB7dBkA+LyinEX+48/ImRJ3jag0Hg0c7wkhEvE=
-github.com/pingcap/log v0.0.0-20191012051959-b742a5d432e9/go.mod h1:4rbK1p9ILyIfb6hU7OG2CiWSqMXnp3JMbiaVJ6mvoY8=
github.com/pingcap/log v0.0.0-20210625125904-98ed8e2eb1c7/go.mod h1:8AanEdAHATuRurdGxZXBz0At+9avep+ub7U1AGYLIMM=
github.com/pingcap/log v1.1.0/go.mod h1:DWQW5jICDR7UJh4HtxXSM20Churx4CQL0fwL/SoOSA4=
github.com/pingcap/log v1.1.1-0.20250917021125-19901e015dc9 h1:qG9BSvlWFEE5otQGamuWedx9LRm0nrHvsQRQiW8SxEs=
@@ -1481,7 +1477,6 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw
golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191030062658-86caa796c7ab/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191107010934-f79515f33823/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
diff --git a/pkg/diff/checkpoint_test.go b/pkg/diff/checkpoint_test.go
index babf9fd9a8..95b584a097 100644
--- a/pkg/diff/checkpoint_test.go
+++ b/pkg/diff/checkpoint_test.go
@@ -15,41 +15,38 @@ package diff
import (
"context"
+ "testing"
sqlmock "github.com/DATA-DOG/go-sqlmock"
- "github.com/pingcap/check"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testCheckpointSuite{})
-
-type testCheckpointSuite struct{}
-
-func (s *testUtilSuite) TestloadFromCheckPoint(c *check.C) {
+func TestLoadFromCheckPoint(t *testing.T) {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rows := sqlmock.NewRows([]string{"state", "config_hash"}).AddRow("success", "123")
mock.ExpectQuery("SELECT").WillReturnRows(rows)
useCheckpoint, err := loadFromCheckPoint(context.Background(), db, "test", "test", "123")
- c.Assert(err, check.IsNil)
- c.Assert(useCheckpoint, check.Equals, false)
+ require.NoError(t, err)
+ require.Equal(t, false, useCheckpoint)
rows = sqlmock.NewRows([]string{"state", "config_hash"}).AddRow("success", "123")
mock.ExpectQuery("SELECT").WillReturnRows(rows)
useCheckpoint, err = loadFromCheckPoint(context.Background(), db, "test", "test", "456")
- c.Assert(err, check.IsNil)
- c.Assert(useCheckpoint, check.Equals, false)
+ require.NoError(t, err)
+ require.Equal(t, false, useCheckpoint)
rows = sqlmock.NewRows([]string{"state", "config_hash"}).AddRow("failed", "123")
mock.ExpectQuery("SELECT").WillReturnRows(rows)
useCheckpoint, err = loadFromCheckPoint(context.Background(), db, "test", "test", "123")
- c.Assert(err, check.IsNil)
- c.Assert(useCheckpoint, check.Equals, true)
+ require.NoError(t, err)
+ require.Equal(t, true, useCheckpoint)
}
-func (s *testUtilSuite) TestInitChunks(c *check.C) {
+func TestInitChunks(t *testing.T) {
db, _, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
chunks := []*ChunkRange{
{
@@ -69,5 +66,6 @@ func (s *testUtilSuite) TestInitChunks(c *check.C) {
// so just skip the `ExpectQuery` and check the error message
// mock.ExpectQuery("INSERT INTO `sync_diff_inspector`.`chunk` VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?), (?, ?, ?, ?, ?, ?, ?, ?, ?)").WithArgs(......)
err = initChunks(context.Background(), db, "target", "diff_test", "test", chunks)
- c.Assert(err, check.ErrorMatches, ".*INSERT INTO `sync_diff_inspector`.`chunk` VALUES\\(\\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?\\), \\(\\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?\\).*")
+ require.Error(t, err)
+ require.Regexp(t, ".*INSERT INTO `sync_diff_inspector`.`chunk` VALUES\\(\\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?\\), \\(\\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?, \\?\\).*", err.Error())
}
diff --git a/pkg/diff/chunk_test.go b/pkg/diff/chunk_test.go
index dff91bf309..aa4ffb66f3 100644
--- a/pkg/diff/chunk_test.go
+++ b/pkg/diff/chunk_test.go
@@ -14,14 +14,12 @@
package diff
import (
- "github.com/pingcap/check"
-)
-
-var _ = check.Suite(&testChunkSuite{})
+ "testing"
-type testChunkSuite struct{}
+ "github.com/stretchr/testify/require"
+)
-func (*testChunkSuite) TestChunkUpdate(c *check.C) {
+func TestChunkUpdate(t *testing.T) {
chunk := &ChunkRange{
Bounds: []*Bound{
{
@@ -63,18 +61,18 @@ func (*testChunkSuite) TestChunkUpdate(c *check.C) {
for _, cs := range testCases {
newChunk := chunk.copyAndUpdate(cs.boundArgs[0], cs.boundArgs[1], cs.boundArgs[2])
conditions, args := newChunk.toString("")
- c.Assert(conditions, check.Equals, cs.expectStr)
- c.Assert(args, check.DeepEquals, cs.expectArgs)
+ require.Equal(t, cs.expectStr, conditions)
+ require.Equal(t, cs.expectArgs, args)
}
// the origin chunk is not changed
conditions, args := chunk.toString("")
- c.Assert(conditions, check.Equals, "((`a` > ?) OR (`a` = ? AND `b` > ?)) AND ((`a` < ?) OR (`a` = ? AND `b` <= ?))")
+ require.Equal(t, "((`a` > ?) OR (`a` = ? AND `b` > ?)) AND ((`a` < ?) OR (`a` = ? AND `b` <= ?))", conditions)
expectArgs := []string{"1", "1", "3", "2", "2", "4"}
- c.Assert(args, check.DeepEquals, expectArgs)
+ require.Equal(t, expectArgs, args)
}
-func (*testChunkSuite) TestChunkToString(c *check.C) {
+func TestChunkToString(t *testing.T) {
chunk := &ChunkRange{
Bounds: []*Bound{
{
@@ -100,16 +98,16 @@ func (*testChunkSuite) TestChunkToString(c *check.C) {
}
conditions, args := chunk.toString("")
- c.Assert(conditions, check.Equals, "((`a` > ?) OR (`a` = ? AND `b` > ?) OR (`a` = ? AND `b` = ? AND `c` > ?)) AND ((`a` < ?) OR (`a` = ? AND `b` < ?) OR (`a` = ? AND `b` = ? AND `c` <= ?))")
+ require.Equal(t, "((`a` > ?) OR (`a` = ? AND `b` > ?) OR (`a` = ? AND `b` = ? AND `c` > ?)) AND ((`a` < ?) OR (`a` = ? AND `b` < ?) OR (`a` = ? AND `b` = ? AND `c` <= ?))", conditions)
expectArgs := []string{"1", "1", "3", "1", "3", "5", "2", "2", "4", "2", "4", "6"}
for i, arg := range args {
- c.Assert(arg, check.Equals, expectArgs[i])
+ require.Equal(t, expectArgs[i], arg)
}
conditions, args = chunk.toString("latin1")
- c.Assert(conditions, check.Equals, "((`a` COLLATE 'latin1' > ?) OR (`a` = ? AND `b` COLLATE 'latin1' > ?) OR (`a` = ? AND `b` = ? AND `c` COLLATE 'latin1' > ?)) AND ((`a` COLLATE 'latin1' < ?) OR (`a` = ? AND `b` COLLATE 'latin1' < ?) OR (`a` = ? AND `b` = ? AND `c` COLLATE 'latin1' <= ?))")
+ require.Equal(t, "((`a` COLLATE 'latin1' > ?) OR (`a` = ? AND `b` COLLATE 'latin1' > ?) OR (`a` = ? AND `b` = ? AND `c` COLLATE 'latin1' > ?)) AND ((`a` COLLATE 'latin1' < ?) OR (`a` = ? AND `b` COLLATE 'latin1' < ?) OR (`a` = ? AND `b` = ? AND `c` COLLATE 'latin1' <= ?))", conditions)
expectArgs = []string{"1", "1", "3", "1", "3", "5", "2", "2", "4", "2", "4", "6"}
for i, arg := range args {
- c.Assert(arg, check.Equals, expectArgs[i])
+ require.Equal(t, expectArgs[i], arg)
}
}
diff --git a/pkg/diff/diff_test.go b/pkg/diff/diff_test.go
index ed858ba1ea..4ad3f4df29 100644
--- a/pkg/diff/diff_test.go
+++ b/pkg/diff/diff_test.go
@@ -17,24 +17,16 @@ import (
"testing"
_ "github.com/go-sql-driver/mysql"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/util/dbutil"
"github.com/pingcap/tidb/pkg/util/dbutil/dbutiltest"
+ "github.com/stretchr/testify/require"
)
-func TestClient(t *testing.T) {
- check.TestingT(t)
-}
-
-var _ = check.Suite(&testDiffSuite{})
-
-type testDiffSuite struct{}
-
-func (*testDiffSuite) TestGenerateSQLs(c *check.C) {
+func TestGenerateSQLs(t *testing.T) {
createTableSQL := "CREATE TABLE `diff_test`.`atest` (`id` int(24), `name` varchar(24), `birthday` datetime, `update_time` time, `money` decimal(20,2), `id_gen` int(11) GENERATED ALWAYS AS ((`id` + 1)) VIRTUAL, primary key(`id`, `name`))"
tableInfo, err := dbutiltest.GetTableInfoBySQL(createTableSQL, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
rowsData := map[string]*dbutil.ColumnData{
"id": {Data: []byte("1"), IsNull: false},
@@ -47,40 +39,40 @@ func (*testDiffSuite) TestGenerateSQLs(c *check.C) {
replaceSQL := generateDML("replace", rowsData, tableInfo, "diff_test")
deleteSQL := generateDML("delete", rowsData, tableInfo, "diff_test")
- c.Assert(replaceSQL, check.Equals, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,'xxx','2018-01-01 00:00:00','10:10:10',11.1111);")
- c.Assert(deleteSQL, check.Equals, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` = 'xxx' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;")
+ require.Equal(t, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,'xxx','2018-01-01 00:00:00','10:10:10',11.1111);", replaceSQL)
+ require.Equal(t, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` = 'xxx' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;", deleteSQL)
// test the unique key
createTableSQL2 := "CREATE TABLE `diff_test`.`atest` (`id` int(24), `name` varchar(24), `birthday` datetime, `update_time` time, `money` decimal(20,2), unique key(`id`, `name`))"
tableInfo2, err := dbutiltest.GetTableInfoBySQL(createTableSQL2, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
replaceSQL = generateDML("replace", rowsData, tableInfo2, "diff_test")
deleteSQL = generateDML("delete", rowsData, tableInfo2, "diff_test")
- c.Assert(replaceSQL, check.Equals, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,'xxx','2018-01-01 00:00:00','10:10:10',11.1111);")
- c.Assert(deleteSQL, check.Equals, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` = 'xxx' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;")
+ require.Equal(t, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,'xxx','2018-01-01 00:00:00','10:10:10',11.1111);", replaceSQL)
+ require.Equal(t, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` = 'xxx' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;", deleteSQL)
// test value is nil
rowsData["name"] = &dbutil.ColumnData{Data: []byte(""), IsNull: true}
replaceSQL = generateDML("replace", rowsData, tableInfo, "diff_test")
deleteSQL = generateDML("delete", rowsData, tableInfo, "diff_test")
- c.Assert(replaceSQL, check.Equals, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,NULL,'2018-01-01 00:00:00','10:10:10',11.1111);")
- c.Assert(deleteSQL, check.Equals, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` is NULL AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;")
+ require.Equal(t, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (1,NULL,'2018-01-01 00:00:00','10:10:10',11.1111);", replaceSQL)
+ require.Equal(t, "DELETE FROM `diff_test`.`atest` WHERE `id` = 1 AND `name` is NULL AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;", deleteSQL)
rowsData["id"] = &dbutil.ColumnData{Data: []byte(""), IsNull: true}
replaceSQL = generateDML("replace", rowsData, tableInfo, "diff_test")
deleteSQL = generateDML("delete", rowsData, tableInfo, "diff_test")
- c.Assert(replaceSQL, check.Equals, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (NULL,NULL,'2018-01-01 00:00:00','10:10:10',11.1111);")
- c.Assert(deleteSQL, check.Equals, "DELETE FROM `diff_test`.`atest` WHERE `id` is NULL AND `name` is NULL AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;")
+ require.Equal(t, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (NULL,NULL,'2018-01-01 00:00:00','10:10:10',11.1111);", replaceSQL)
+ require.Equal(t, "DELETE FROM `diff_test`.`atest` WHERE `id` is NULL AND `name` is NULL AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;", deleteSQL)
// test value with "'"
rowsData["name"] = &dbutil.ColumnData{Data: []byte("a'a"), IsNull: false}
replaceSQL = generateDML("replace", rowsData, tableInfo, "diff_test")
deleteSQL = generateDML("delete", rowsData, tableInfo, "diff_test")
- c.Assert(replaceSQL, check.Equals, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (NULL,'a\\'a','2018-01-01 00:00:00','10:10:10',11.1111);")
- c.Assert(deleteSQL, check.Equals, "DELETE FROM `diff_test`.`atest` WHERE `id` is NULL AND `name` = 'a\\'a' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;")
+ require.Equal(t, "REPLACE INTO `diff_test`.`atest`(`id`,`name`,`birthday`,`update_time`,`money`) VALUES (NULL,'a\\'a','2018-01-01 00:00:00','10:10:10',11.1111);", replaceSQL)
+ require.Equal(t, "DELETE FROM `diff_test`.`atest` WHERE `id` is NULL AND `name` = 'a\\'a' AND `birthday` = '2018-01-01 00:00:00' AND `update_time` = '10:10:10' AND `money` = 11.1111;", deleteSQL)
}
-func (*testDiffSuite) TestConfigHash(c *check.C) {
+func TestConfigHash(t *testing.T) {
tbDiff := &TableDiff{
Range: "a > 1",
ChunkSize: 1000,
@@ -91,10 +83,10 @@ func (*testDiffSuite) TestConfigHash(c *check.C) {
tbDiff.CheckThreadCount = 10
tbDiff.setConfigHash()
hash2 := tbDiff.configHash
- c.Assert(hash1, check.Equals, hash2)
+ require.Equal(t, hash2, hash1)
tbDiff.Range = "b < 10"
tbDiff.setConfigHash()
hash3 := tbDiff.configHash
- c.Assert(hash1 == hash3, check.Equals, false)
+ require.Equal(t, false, hash1 == hash3)
}
diff --git a/pkg/diff/merge_test.go b/pkg/diff/merge_test.go
index ca08055c53..33e9270d56 100644
--- a/pkg/diff/merge_test.go
+++ b/pkg/diff/merge_test.go
@@ -15,21 +15,18 @@ package diff
import (
"container/heap"
+ "testing"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser"
"github.com/pingcap/tidb/pkg/util/dbutil"
"github.com/pingcap/tidb/pkg/util/dbutil/dbutiltest"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testMergerSuite{})
-
-type testMergerSuite struct{}
-
-func (s *testMergerSuite) TestMerge(c *check.C) {
+func TestMerge(t *testing.T) {
createTableSQL := "create table test.test(id int(24), name varchar(24), age int(24), primary key(id, name));"
tableInfo, err := dbutiltest.GetTableInfoBySQL(createTableSQL, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
_, orderKeyCols := dbutil.SelectUniqueOrderKey(tableInfo)
ids := []string{"3", "2", "2", "4", "1", "NULL"}
@@ -60,7 +57,7 @@ func (s *testMergerSuite) TestMerge(c *check.C) {
rowData := heap.Pop(rowDatas).(RowData)
id := string(rowData.Data["id"].Data)
name := string(rowData.Data["name"].Data)
- c.Assert(id, check.Equals, expectIDs[i])
- c.Assert(name, check.Equals, expectNames[i])
+ require.Equal(t, expectIDs[i], id)
+ require.Equal(t, expectNames[i], name)
}
}
diff --git a/pkg/diff/spliter_test.go b/pkg/diff/spliter_test.go
index 77026ace56..490d808c9b 100644
--- a/pkg/diff/spliter_test.go
+++ b/pkg/diff/spliter_test.go
@@ -15,28 +15,25 @@ package diff
import (
"fmt"
+ "testing"
"time"
sqlmock "github.com/DATA-DOG/go-sqlmock"
- "github.com/pingcap/check"
"github.com/pingcap/tidb/pkg/parser"
ttypes "github.com/pingcap/tidb/pkg/types"
"github.com/pingcap/tidb/pkg/util/codec"
"github.com/pingcap/tidb/pkg/util/dbutil/dbutiltest"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testSpliterSuite{})
-
-type testSpliterSuite struct{}
-
type chunkResult struct {
chunkStr string
args []string
}
-func (s *testSpliterSuite) TestSplitRangeByRandom(c *check.C) {
+func TestSplitRangeByRandom(t *testing.T) {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testCases := []struct {
createTableSQL string
@@ -118,26 +115,26 @@ func (s *testSpliterSuite) TestSplitRangeByRandom(c *check.C) {
for i, testCase := range testCases {
tableInfo, err := dbutiltest.GetTableInfoBySQL(testCase.createTableSQL, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
splitCols, err := getSplitFields(tableInfo, nil)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
createFakeResultForRandomSplit(mock, 0, testCase.randomValues)
chunks, err := splitRangeByRandom(db, testCase.originChunk, testCase.splitCount, "test", "test", splitCols, "", "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for j, chunk := range chunks {
chunkStr, args := chunk.toString("")
- c.Log(i, j, chunkStr, args)
- c.Assert(chunkStr, check.Equals, testCase.expectResult[j].chunkStr)
- c.Assert(args, check.DeepEquals, testCase.expectResult[j].args)
+ t.Log(i, j, chunkStr, args)
+ require.Equal(t, testCase.expectResult[j].chunkStr, chunkStr)
+ require.Equal(t, testCase.expectResult[j].args, args)
}
}
}
-func (s *testSpliterSuite) TestRandomSpliter(c *check.C) {
+func TestRandomSpliter(t *testing.T) {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testCases := []struct {
createTableSQL string
@@ -205,7 +202,7 @@ func (s *testSpliterSuite) TestRandomSpliter(c *check.C) {
for i, testCase := range testCases {
tableInfo, err := dbutiltest.GetTableInfoBySQL(testCase.createTableSQL, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
tableInstance := &TableInstance{
Conn: db,
@@ -215,19 +212,19 @@ func (s *testSpliterSuite) TestRandomSpliter(c *check.C) {
}
splitCols, err := getSplitFields(tableInfo, nil)
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
createFakeResultForRandomSplit(mock, testCase.count, testCase.randomValues)
rSpliter := new(randomSpliter)
chunks, err := rSpliter.split(tableInstance, splitCols, 2, "TRUE", "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for j, chunk := range chunks {
chunkStr, args := chunk.toString("")
- c.Log(i, j, chunkStr, args)
- c.Assert(chunkStr, check.Equals, testCase.expectResult[j].chunkStr)
- c.Assert(args, check.DeepEquals, testCase.expectResult[j].args)
+ t.Log(i, j, chunkStr, args)
+ require.Equal(t, testCase.expectResult[j].chunkStr, chunkStr)
+ require.Equal(t, testCase.expectResult[j].args, args)
}
}
}
@@ -249,13 +246,13 @@ func createFakeResultForRandomSplit(mock sqlmock.Sqlmock, count int, randomValue
}
}
-func (s *testSpliterSuite) TestBucketSpliter(c *check.C) {
+func TestBucketSpliter(t *testing.T) {
db, mock, err := sqlmock.New()
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
createTableSQL := "create table `test`.`test`(`a` int, `b` varchar(10), `c` float, `d` datetime, primary key(`a`, `b`))"
tableInfo, err := dbutiltest.GetTableInfoBySQL(createTableSQL, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
testCases := []struct {
chunkSize int
@@ -429,12 +426,12 @@ func (s *testSpliterSuite) TestBucketSpliter(c *check.C) {
createFakeResultForBucketSplit(mock, testCase.aRandomValues, testCase.bRandomValues)
bSpliter := new(bucketSpliter)
chunks, err := bSpliter.split(tableInstance, testCase.chunkSize, "TRUE", "")
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
for j, chunk := range chunks {
chunkStr, args := chunk.toString("")
- c.Log(i, j, chunkStr, args)
- c.Assert(chunkStr, check.Equals, testCase.expectResult[j].chunkStr)
- c.Assert(args, check.DeepEquals, testCase.expectResult[j].args)
+ t.Log(i, j, chunkStr, args)
+ require.Equal(t, testCase.expectResult[j].chunkStr, chunkStr)
+ require.Equal(t, testCase.expectResult[j].args, args)
}
}
}
diff --git a/pkg/diff/util_test.go b/pkg/diff/util_test.go
index 5b21eadff5..b78b57770a 100644
--- a/pkg/diff/util_test.go
+++ b/pkg/diff/util_test.go
@@ -14,43 +14,41 @@
package diff
import (
- "github.com/pingcap/check"
+ "testing"
+
"github.com/pingcap/tidb/pkg/meta/model"
"github.com/pingcap/tidb/pkg/parser"
pmodel "github.com/pingcap/tidb/pkg/parser/ast"
"github.com/pingcap/tidb/pkg/util/dbutil"
"github.com/pingcap/tidb/pkg/util/dbutil/dbutiltest"
+ "github.com/stretchr/testify/require"
)
-var _ = check.Suite(&testUtilSuite{})
-
-type testUtilSuite struct{}
-
-func (s *testUtilSuite) TestIgnoreColumns(c *check.C) {
+func TestIgnoreColumns(t *testing.T) {
createTableSQL1 := "CREATE TABLE `test`.`atest` (`a` int, `b` int, `c` int, `d` int, primary key(`a`))"
tableInfo1, err := dbutiltest.GetTableInfoBySQL(createTableSQL1, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
tbInfo := ignoreColumns(tableInfo1, []string{"a"})
- c.Assert(tbInfo.Columns, check.HasLen, 3)
- c.Assert(tbInfo.Indices, check.HasLen, 0)
- c.Assert(tbInfo.Columns[2].Offset, check.Equals, 2)
+ require.Len(t, tbInfo.Columns, 3)
+ require.Len(t, tbInfo.Indices, 0)
+ require.Equal(t, 2, tbInfo.Columns[2].Offset)
createTableSQL2 := "CREATE TABLE `test`.`atest` (`a` int, `b` int, `c` int, `d` int, primary key(`a`), index idx(`b`, `c`))"
tableInfo2, err := dbutiltest.GetTableInfoBySQL(createTableSQL2, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
tbInfo = ignoreColumns(tableInfo2, []string{"a", "b"})
- c.Assert(tbInfo.Columns, check.HasLen, 2)
- c.Assert(tbInfo.Indices, check.HasLen, 0)
+ require.Len(t, tbInfo.Columns, 2)
+ require.Len(t, tbInfo.Indices, 0)
createTableSQL3 := "CREATE TABLE `test`.`atest` (`a` int, `b` int, `c` int, `d` int, primary key(`a`), index idx(`b`, `c`))"
tableInfo3, err := dbutiltest.GetTableInfoBySQL(createTableSQL3, parser.New())
- c.Assert(err, check.IsNil)
+ require.NoError(t, err)
tbInfo = ignoreColumns(tableInfo3, []string{"b", "c"})
- c.Assert(tbInfo.Columns, check.HasLen, 2)
- c.Assert(tbInfo.Indices, check.HasLen, 1)
+ require.Len(t, tbInfo.Columns, 2)
+ require.Len(t, tbInfo.Indices, 1)
}
-func (s *testUtilSuite) TestRowContainsCols(c *check.C) {
+func TestRowContainsCols(t *testing.T) {
row := map[string]*dbutil.ColumnData{
"a": nil,
"b": nil,
@@ -68,14 +66,14 @@ func (s *testUtilSuite) TestRowContainsCols(c *check.C) {
}
contain := rowContainsCols(row, cols)
- c.Assert(contain, check.Equals, true)
+ require.Equal(t, true, contain)
delete(row, "a")
contain = rowContainsCols(row, cols)
- c.Assert(contain, check.Equals, false)
+ require.Equal(t, false, contain)
}
-func (s *testUtilSuite) TestRowToString(c *check.C) {
+func TestRowToString(t *testing.T) {
row := make(map[string]*dbutil.ColumnData)
row["id"] = &dbutil.ColumnData{
Data: []byte("1"),
@@ -93,12 +91,12 @@ func (s *testUtilSuite) TestRowToString(c *check.C) {
}
rowStr := rowToString(row)
- c.Assert(rowStr, check.Matches, ".*id: 1.*")
- c.Assert(rowStr, check.Matches, ".*name: abc.*")
- c.Assert(rowStr, check.Matches, ".*info: IsNull.*")
+ require.Regexp(t, ".*id: 1.*", rowStr)
+ require.Regexp(t, ".*name: abc.*", rowStr)
+ require.Regexp(t, ".*info: IsNull.*", rowStr)
}
-func (s *testUtilSuite) TestMinLenInSlices(c *check.C) {
+func TestMinLenInSlices(t *testing.T) {
testCases := []struct {
slices [][]string
expect int
@@ -130,6 +128,6 @@ func (s *testUtilSuite) TestMinLenInSlices(c *check.C) {
for _, testCase := range testCases {
minLen := minLenInSlices(testCase.slices)
- c.Assert(minLen, check.Equals, testCase.expect)
+ require.Equal(t, testCase.expect, minLen)
}
}