diff --git a/cdc/sink/dispatcher/default_test.go b/cdc/sink/dispatcher/default_test.go
index 93fe3952af1..ccddd3052e6 100644
--- a/cdc/sink/dispatcher/default_test.go
+++ b/cdc/sink/dispatcher/default_test.go
@@ -14,17 +14,15 @@
 package dispatcher
 
 import (
-	"github.com/pingcap/check"
+	"testing"
+
 	"github.com/pingcap/tiflow/cdc/model"
-	"github.com/pingcap/tiflow/pkg/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-type DefaultDispatcherSuite struct{}
-
-var _ = check.Suite(&DefaultDispatcherSuite{})
+func TestDefaultDispatcher(t *testing.T) {
+	t.Parallel()
 
-func (s DefaultDispatcherSuite) TestDefaultDispatcher(c *check.C) {
-	defer testleak.AfterTest(c)()
 	testCases := []struct {
 		row             *model.RowChangedEvent
 		exceptPartition int32
@@ -197,6 +195,32 @@ func (s DefaultDispatcherSuite) TestDefaultDispatcher(c *check.C) {
 	}
 	p := newDefaultDispatcher(16, false)
 	for _, tc := range testCases {
-		c.Assert(p.Dispatch(tc.row), check.Equals, tc.exceptPartition)
+		require.Equal(t, tc.exceptPartition, p.Dispatch(tc.row))
 	}
 }
+
+func TestDefaultDispatcherWithOldValue(t *testing.T) {
+	t.Parallel()
+
+	row := &model.RowChangedEvent{
+		Table: &model.TableName{
+			Schema: "test",
+			Table:  "t3",
+		},
+		Columns: []*model.Column{
+			{
+				Name:  "id",
+				Value: 2,
+				Flag:  model.HandleKeyFlag | model.PrimaryKeyFlag,
+			}, {
+				Name:  "a",
+				Value: 3,
+				Flag:  model.UniqueKeyFlag,
+			},
+		},
+		IndexColumns: [][]int{{0}, {1}},
+	}
+
+	p := newDefaultDispatcher(16, true)
+	require.Equal(t, int32(3), p.Dispatch(row))
+}
diff --git a/cdc/sink/dispatcher/index_value_test.go b/cdc/sink/dispatcher/index_value_test.go
index 5f0890885c2..b52ed548883 100644
--- a/cdc/sink/dispatcher/index_value_test.go
+++ b/cdc/sink/dispatcher/index_value_test.go
@@ -14,17 +14,15 @@
 package dispatcher
 
 import (
-	"github.com/pingcap/check"
+	"testing"
+
 	"github.com/pingcap/tiflow/cdc/model"
-	"github.com/pingcap/tiflow/pkg/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-type IndexValueDispatcherSuite struct{}
-
-var _ = check.Suite(&IndexValueDispatcherSuite{})
+func TestIndexValueDispatcher(t *testing.T) {
+	t.Parallel()
 
-func (s IndexValueDispatcherSuite) TestIndexValueDispatcher(c *check.C) {
-	defer testleak.AfterTest(c)()
 	testCases := []struct {
 		row             *model.RowChangedEvent
 		exceptPartition int32
@@ -151,6 +149,6 @@ func (s IndexValueDispatcherSuite) TestIndexValueDispatcher(c *check.C) {
 	}
 	p := newIndexValueDispatcher(16)
 	for _, tc := range testCases {
-		c.Assert(p.Dispatch(tc.row), check.Equals, tc.exceptPartition)
+		require.Equal(t, tc.exceptPartition, p.Dispatch(tc.row))
 	}
 }
diff --git a/cdc/sink/dispatcher/switcher_test.go b/cdc/sink/dispatcher/switcher_test.go
index 6f3caf20143..ca3eeab003a 100644
--- a/cdc/sink/dispatcher/switcher_test.go
+++ b/cdc/sink/dispatcher/switcher_test.go
@@ -14,30 +14,29 @@
 package dispatcher
 
 import (
-	"github.com/pingcap/check"
+	"testing"
+
 	"github.com/pingcap/tiflow/cdc/model"
 	"github.com/pingcap/tiflow/pkg/config"
-	"github.com/pingcap/tiflow/pkg/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-type SwitcherSuite struct{}
-
-var _ = check.Suite(&SwitcherSuite{})
+func TestSwitcher(t *testing.T) {
+	t.Parallel()
 
-func (s SwitcherSuite) TestSwitcher(c *check.C) {
-	defer testleak.AfterTest(c)()
 	d, err := NewDispatcher(config.GetDefaultReplicaConfig(), 4)
-	c.Assert(err, check.IsNil)
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	require.Nil(t, err)
+	require.IsType(t, &defaultDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "test", Table: "test",
 		},
-	}), check.FitsTypeOf, &defaultDispatcher{})
+	}))
 
 	d, err = NewDispatcher(&config.ReplicaConfig{
 		Sink: &config.SinkConfig{
 			DispatchRules: []*config.DispatchRule{
-				{Matcher: []string{"test_default.*"}, Dispatcher: "default"},
+				{Matcher: []string{"test_default1.*"}, Dispatcher: "default"},
+				{Matcher: []string{"test_default2.*"}, Dispatcher: "unknown-dispatcher"},
 				{Matcher: []string{"test_table.*"}, Dispatcher: "table"},
 				{Matcher: []string{"test_index_value.*"}, Dispatcher: "index-value"},
 				{Matcher: []string{"test.*"}, Dispatcher: "rowid"},
@@ -45,35 +44,40 @@ func (s SwitcherSuite) TestSwitcher(c *check.C) {
 			},
 		},
 	}, 4)
-	c.Assert(err, check.IsNil)
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	require.Nil(t, err)
+	require.IsType(t, &indexValueDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "test", Table: "table1",
 		},
-	}), check.FitsTypeOf, &indexValueDispatcher{})
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	}))
+	require.IsType(t, &tsDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "sbs", Table: "table2",
 		},
-	}), check.FitsTypeOf, &tsDispatcher{})
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	}))
+	require.IsType(t, &defaultDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "sbs", Table: "test",
 		},
-	}), check.FitsTypeOf, &defaultDispatcher{})
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	}))
+	require.IsType(t, &defaultDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+		Table: &model.TableName{
+			Schema: "test_default1", Table: "test",
+		},
+	}))
+	require.IsType(t, &defaultDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
-			Schema: "test_default", Table: "test",
+			Schema: "test_default2", Table: "test",
 		},
-	}), check.FitsTypeOf, &defaultDispatcher{})
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	}))
+	require.IsType(t, &tableDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "test_table", Table: "test",
 		},
-	}), check.FitsTypeOf, &tableDispatcher{})
-	c.Assert(d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
+	}))
+	require.IsType(t, &indexValueDispatcher{}, d.(*dispatcherSwitcher).matchDispatcher(&model.RowChangedEvent{
 		Table: &model.TableName{
 			Schema: "test_index_value", Table: "test",
 		},
-	}), check.FitsTypeOf, &indexValueDispatcher{})
+	}))
 }
diff --git a/cdc/sink/dispatcher/table_test.go b/cdc/sink/dispatcher/table_test.go
index 9b2f17c4108..d0bb114968b 100644
--- a/cdc/sink/dispatcher/table_test.go
+++ b/cdc/sink/dispatcher/table_test.go
@@ -14,17 +14,15 @@
 package dispatcher
 
 import (
-	"github.com/pingcap/check"
+	"testing"
+
 	"github.com/pingcap/tiflow/cdc/model"
-	"github.com/pingcap/tiflow/pkg/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-type TableDispatcherSuite struct{}
-
-var _ = check.Suite(&TableDispatcherSuite{})
+func TestTableDispatcher(t *testing.T) {
+	t.Parallel()
 
-func (s TableDispatcherSuite) TestTableDispatcher(c *check.C) {
-	defer testleak.AfterTest(c)()
 	testCases := []struct {
 		row             *model.RowChangedEvent
 		exceptPartition int32
@@ -81,6 +79,6 @@ func (s TableDispatcherSuite) TestTableDispatcher(c *check.C) {
 	}
 	p := newTableDispatcher(16)
 	for _, tc := range testCases {
-		c.Assert(p.Dispatch(tc.row), check.Equals, tc.exceptPartition)
+		require.Equal(t, tc.exceptPartition, p.Dispatch(tc.row))
 	}
 }
diff --git a/cdc/sink/dispatcher/ts_test.go b/cdc/sink/dispatcher/ts_test.go
index f4eac2471bb..a5f33019f9f 100644
--- a/cdc/sink/dispatcher/ts_test.go
+++ b/cdc/sink/dispatcher/ts_test.go
@@ -16,19 +16,13 @@ package dispatcher
 import (
 	"testing"
 
-	"github.com/pingcap/check"
 	"github.com/pingcap/tiflow/cdc/model"
-	"github.com/pingcap/tiflow/pkg/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-func Test(t *testing.T) { check.TestingT(t) }
+func TestTsDispatcher(t *testing.T) {
+	t.Parallel()
 
-type TsDispatcherSuite struct{}
-
-var _ = check.Suite(&TsDispatcherSuite{})
-
-func (s TsDispatcherSuite) TestTsDispatcher(c *check.C) {
-	defer testleak.AfterTest(c)()
 	testCases := []struct {
 		row             *model.RowChangedEvent
 		exceptPartition int32
@@ -78,6 +72,6 @@ func (s TsDispatcherSuite) TestTsDispatcher(c *check.C) {
 	}
 	p := &tsDispatcher{partitionNum: 16}
 	for _, tc := range testCases {
-		c.Assert(p.Dispatch(tc.row), check.Equals, tc.exceptPartition)
+		require.Equal(t, tc.exceptPartition, p.Dispatch(tc.row))
 	}
 }