diff --git a/ddl/placement/bundle_test.go b/ddl/placement/bundle_test.go index de02ca6cd51eb..b59f349609f87 100644 --- a/ddl/placement/bundle_test.go +++ b/ddl/placement/bundle_test.go @@ -16,48 +16,45 @@ package placement import ( "encoding/hex" - "errors" + "fmt" + "testing" - . "github.com/pingcap/check" "github.com/pingcap/failpoint" "github.com/pingcap/tidb/parser/model" "github.com/pingcap/tidb/tablecodec" "github.com/pingcap/tidb/util/codec" + "github.com/stretchr/testify/require" ) -var _ = Suite(&testBundleSuite{}) - -type testBundleSuite struct{} - -func (s *testBundleSuite) TestEmpty(c *C) { +func TestEmpty(t *testing.T) { bundle := &Bundle{ID: GroupID(1)} - c.Assert(bundle.IsEmpty(), IsTrue) + require.True(t, bundle.IsEmpty()) bundle = &Bundle{ID: GroupID(1), Index: 1} - c.Assert(bundle.IsEmpty(), IsFalse) + require.False(t, bundle.IsEmpty()) bundle = &Bundle{ID: GroupID(1), Override: true} - c.Assert(bundle.IsEmpty(), IsFalse) + require.False(t, bundle.IsEmpty()) bundle = &Bundle{ID: GroupID(1), Rules: []*Rule{{ID: "434"}}} - c.Assert(bundle.IsEmpty(), IsFalse) + require.False(t, bundle.IsEmpty()) bundle = &Bundle{ID: GroupID(1), Index: 1, Override: true} - c.Assert(bundle.IsEmpty(), IsFalse) + require.False(t, bundle.IsEmpty()) } -func (s *testBundleSuite) TestClone(c *C) { +func TestCloneBundle(t *testing.T) { bundle := &Bundle{ID: GroupID(1), Rules: []*Rule{{ID: "434"}}} newBundle := bundle.Clone() newBundle.ID = GroupID(2) newBundle.Rules[0] = &Rule{ID: "121"} - c.Assert(bundle, DeepEquals, &Bundle{ID: GroupID(1), Rules: []*Rule{{ID: "434"}}}) - c.Assert(newBundle, DeepEquals, &Bundle{ID: GroupID(2), Rules: []*Rule{{ID: "121"}}}) + require.Equal(t, &Bundle{ID: GroupID(1), Rules: []*Rule{{ID: "434"}}}, bundle) + require.Equal(t, &Bundle{ID: GroupID(2), Rules: []*Rule{{ID: "121"}}}, newBundle) } -func (s *testBundleSuite) TestObjectID(c *C) { +func TestObjectID(t *testing.T) { type TestCase struct { name string bundleID string @@ -72,20 +69,19 @@ func (s *testBundleSuite) TestObjectID(c *C) { {"id of negatives", "TiDB_DDL_-10", 0, ErrInvalidBundleID}, {"id of positive integer", "TiDB_DDL_10", 10, nil}, } - for _, t := range tests { - comment := Commentf("%s", t.name) - bundle := Bundle{ID: t.bundleID} + for _, test := range tests { + bundle := Bundle{ID: test.bundleID} id, err := bundle.ObjectID() - if t.err == nil { - c.Assert(err, IsNil, comment) - c.Assert(id, Equals, t.expectedID, comment) + if test.err == nil { + require.NoError(t, err, test.name) + require.Equal(t, test.expectedID, id, test.name) } else { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + require.ErrorIs(t, err, test.err, test.name) } } } -func (s *testBundleSuite) TestGetLeaderDCByBundle(c *C) { +func TestGetLeaderDCByBundle(t *testing.T) { testcases := []struct { name string bundle *Bundle @@ -330,49 +326,48 @@ func (s *testBundleSuite) TestGetLeaderDCByBundle(c *C) { }, } for _, testcase := range testcases { - comment := Commentf("%s", testcase.name) result, ok := testcase.bundle.GetLeaderDC("zone") if len(testcase.expectedDC) > 0 { - c.Assert(ok, Equals, true, comment) + require.True(t, ok, testcase.name) } else { - c.Assert(ok, Equals, false, comment) + require.False(t, ok, testcase.name) } - c.Assert(result, Equals, testcase.expectedDC, comment) + require.Equal(t, testcase.expectedDC, result, testcase.name) } } -func (s *testBundleSuite) TestString(c *C) { +func TestString(t *testing.T) { bundle := &Bundle{ ID: GroupID(1), } rules1, err := NewRules(Voter, 3, `["+zone=sh", "+zone=sh"]`) - c.Assert(err, IsNil) + require.NoError(t, err) rules2, err := NewRules(Voter, 4, `["-zone=sh", "+zone=bj"]`) - c.Assert(err, IsNil) + require.NoError(t, err) bundle.Rules = append(rules1, rules2...) - c.Assert(bundle.String(), Equals, "{\"group_id\":\"TiDB_DDL_1\",\"group_index\":0,\"group_override\":false,\"rules\":[{\"group_id\":\"\",\"id\":\"\",\"start_key\":\"\",\"end_key\":\"\",\"role\":\"voter\",\"count\":3,\"label_constraints\":[{\"key\":\"zone\",\"op\":\"in\",\"values\":[\"sh\"]}]},{\"group_id\":\"\",\"id\":\"\",\"start_key\":\"\",\"end_key\":\"\",\"role\":\"voter\",\"count\":4,\"label_constraints\":[{\"key\":\"zone\",\"op\":\"notIn\",\"values\":[\"sh\"]},{\"key\":\"zone\",\"op\":\"in\",\"values\":[\"bj\"]}]}]}") + require.Equal(t, "{\"group_id\":\"TiDB_DDL_1\",\"group_index\":0,\"group_override\":false,\"rules\":[{\"group_id\":\"\",\"id\":\"\",\"start_key\":\"\",\"end_key\":\"\",\"role\":\"voter\",\"count\":3,\"label_constraints\":[{\"key\":\"zone\",\"op\":\"in\",\"values\":[\"sh\"]}]},{\"group_id\":\"\",\"id\":\"\",\"start_key\":\"\",\"end_key\":\"\",\"role\":\"voter\",\"count\":4,\"label_constraints\":[{\"key\":\"zone\",\"op\":\"notIn\",\"values\":[\"sh\"]},{\"key\":\"zone\",\"op\":\"in\",\"values\":[\"bj\"]}]}]}", bundle.String()) - c.Assert(failpoint.Enable("github.com/pingcap/tidb/ddl/placement/MockMarshalFailure", `return(true)`), IsNil) + require.NoError(t, failpoint.Enable("github.com/pingcap/tidb/ddl/placement/MockMarshalFailure", `return(true)`)) defer func() { - c.Assert(failpoint.Disable("github.com/pingcap/tidb/ddl/placement/MockMarshalFailure"), IsNil) + require.NoError(t, failpoint.Disable("github.com/pingcap/tidb/ddl/placement/MockMarshalFailure")) }() - c.Assert(bundle.String(), Equals, "") + require.Equal(t, "", bundle.String()) } -func (s *testBundleSuite) TestNew(c *C) { - c.Assert(NewBundle(3), DeepEquals, &Bundle{ID: GroupID(3)}) - c.Assert(NewBundle(-1), DeepEquals, &Bundle{ID: GroupID(-1)}) +func TestNewBundle(t *testing.T) { + require.Equal(t, &Bundle{ID: GroupID(3)}, NewBundle(3)) + require.Equal(t, &Bundle{ID: GroupID(-1)}, NewBundle(-1)) _, err := NewBundleFromConstraintsOptions(nil) - c.Assert(err, NotNil) + require.Error(t, err) _, err = NewBundleFromSugarOptions(nil) - c.Assert(err, NotNil) + require.Error(t, err) _, err = NewBundleFromOptions(nil) - c.Assert(err, NotNil) + require.Error(t, err) } -func (s *testBundleSuite) TestNewBundleFromOptions(c *C) { +func TestNewBundleFromOptions(t *testing.T) { type TestCase struct { name string input *model.PlacementSettings @@ -706,42 +701,42 @@ func (s *testBundleSuite) TestNewBundleFromOptions(c *C) { err: ErrInvalidConstraintsRelicas, }) - for _, t := range tests { - bundle, err := newBundleFromOptions(t.input) - comment := Commentf("[%s]\nerr1 %s\nerr2 %s", t.name, err, t.err) - if t.err != nil { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + for _, test := range tests { + bundle, err := newBundleFromOptions(test.input) + comment := fmt.Sprintf("[%s]\nerr1 %s\nerr2 %s", test.name, err, test.err) + if test.err != nil { + require.ErrorIs(t, err, test.err, comment) } else { - c.Assert(err, IsNil, comment) - matchRules(t.output, bundle.Rules, comment.CheckCommentString(), c) + require.NoError(t, err, comment) + matchRules(test.output, bundle.Rules, comment, t) } } } -func (s *testBundleSuite) TestResetBundleWithSingleRule(c *C) { +func TestResetBundleWithSingleRule(t *testing.T) { bundle := &Bundle{ ID: GroupID(1), } rules, err := NewRules(Voter, 3, `["+zone=sh", "+zone=sh"]`) - c.Assert(err, IsNil) + require.NoError(t, err) bundle.Rules = rules bundle.Reset(RuleIndexTable, []int64{3}) - c.Assert(bundle.ID, Equals, GroupID(3)) - c.Assert(bundle.Override, Equals, true) - c.Assert(bundle.Index, Equals, RuleIndexTable) - c.Assert(bundle.Rules, HasLen, 1) - c.Assert(bundle.Rules[0].GroupID, Equals, bundle.ID) + require.Equal(t, GroupID(3), bundle.ID) + require.Equal(t, true, bundle.Override) + require.Equal(t, RuleIndexTable, bundle.Index) + require.Len(t, bundle.Rules, 1) + require.Equal(t, bundle.ID, bundle.Rules[0].GroupID) startKey := hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(3))) - c.Assert(bundle.Rules[0].StartKeyHex, Equals, startKey) + require.Equal(t, startKey, bundle.Rules[0].StartKeyHex) endKey := hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(4))) - c.Assert(bundle.Rules[0].EndKeyHex, Equals, endKey) + require.Equal(t, endKey, bundle.Rules[0].EndKeyHex) } -func (s *testBundleSuite) TestResetBundleWithMultiRules(c *C) { +func TestResetBundleWithMultiRules(t *testing.T) { // build a bundle with three rules. bundle, err := NewBundleFromOptions(&model.PlacementSettings{ LeaderConstraints: `["+zone=bj"]`, @@ -751,129 +746,129 @@ func (s *testBundleSuite) TestResetBundleWithMultiRules(c *C) { LearnerConstraints: `["+zone=cd"]`, Constraints: `["+disk=ssd"]`, }) - c.Assert(err, IsNil) - c.Assert(len(bundle.Rules), Equals, 3) + require.NoError(t, err) + require.Equal(t, 3, len(bundle.Rules)) // test if all the three rules are basic rules even the start key are not set. bundle.Reset(RuleIndexTable, []int64{1, 2, 3}) - c.Assert(bundle.ID, Equals, GroupID(1)) - c.Assert(bundle.Index, Equals, RuleIndexTable) - c.Assert(bundle.Override, Equals, true) - c.Assert(len(bundle.Rules), Equals, 3*3) + require.Equal(t, GroupID(1), bundle.ID) + require.Equal(t, RuleIndexTable, bundle.Index) + require.Equal(t, true, bundle.Override) + require.Equal(t, 3*3, len(bundle.Rules)) // for id 1. startKey := hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(1))) endKey := hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(2))) - c.Assert(bundle.Rules[0].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[0].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[1].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[1].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[2].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[2].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[0].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[0].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[1].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[1].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[2].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[2].EndKeyHex) // for id 2. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(2))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(3))) - c.Assert(bundle.Rules[3].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[3].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[4].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[4].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[5].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[5].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[3].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[3].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[4].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[4].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[5].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[5].EndKeyHex) // for id 3. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(3))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(4))) - c.Assert(bundle.Rules[6].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[6].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[7].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[7].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[8].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[8].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[6].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[6].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[7].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[7].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[8].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[8].EndKeyHex) // test if bundle has redundant rules. // for now, the bundle has 9 rules, each table id or partition id has the three with them. // once we reset this bundle for another ids, for example, adding partitions. we should // extend the basic rules(3 of them) to the new partition id. bundle.Reset(RuleIndexTable, []int64{1, 3, 4, 5}) - c.Assert(bundle.ID, Equals, GroupID(1)) - c.Assert(bundle.Index, Equals, RuleIndexTable) - c.Assert(bundle.Override, Equals, true) - c.Assert(len(bundle.Rules), Equals, 3*4) + require.Equal(t, GroupID(1), bundle.ID) + require.Equal(t, RuleIndexTable, bundle.Index) + require.Equal(t, true, bundle.Override) + require.Equal(t, 3*4, len(bundle.Rules)) // for id 1. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(1))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(2))) - c.Assert(bundle.Rules[0].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[0].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[1].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[1].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[2].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[2].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[0].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[0].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[1].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[1].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[2].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[2].EndKeyHex) // for id 3. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(3))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(4))) - c.Assert(bundle.Rules[3].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[3].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[4].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[4].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[5].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[5].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[3].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[3].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[4].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[4].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[5].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[5].EndKeyHex) // for id 4. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(4))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(5))) - c.Assert(bundle.Rules[6].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[6].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[7].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[7].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[8].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[8].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[6].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[6].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[7].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[7].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[8].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[8].EndKeyHex) // for id 5. startKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(5))) endKey = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(6))) - c.Assert(bundle.Rules[9].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[9].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[10].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[10].EndKeyHex, Equals, endKey) - c.Assert(bundle.Rules[11].StartKeyHex, Equals, startKey) - c.Assert(bundle.Rules[11].EndKeyHex, Equals, endKey) + require.Equal(t, startKey, bundle.Rules[9].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[9].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[10].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[10].EndKeyHex) + require.Equal(t, startKey, bundle.Rules[11].StartKeyHex) + require.Equal(t, endKey, bundle.Rules[11].EndKeyHex) } -func (s *testBundleSuite) TestTidy(c *C) { +func TestTidy(t *testing.T) { bundle := &Bundle{ ID: GroupID(1), } rules0, err := NewRules(Voter, 1, `["+zone=sh", "+zone=sh"]`) - c.Assert(err, IsNil) - c.Assert(rules0, HasLen, 1) + require.NoError(t, err) + require.Len(t, rules0, 1) rules0[0].Count = 0 // test prune useless rules rules1, err := NewRules(Voter, 4, `["-zone=sh", "+zone=bj"]`) - c.Assert(err, IsNil) - c.Assert(rules1, HasLen, 1) + require.NoError(t, err) + require.Len(t, rules1, 1) rules2, err := NewRules(Voter, 4, `["-zone=sh", "+zone=bj"]`) - c.Assert(err, IsNil) + require.NoError(t, err) bundle.Rules = append(bundle.Rules, rules0...) bundle.Rules = append(bundle.Rules, rules1...) bundle.Rules = append(bundle.Rules, rules2...) err = bundle.Tidy() - c.Assert(err, IsNil) - c.Assert(bundle.Rules, HasLen, 2) - c.Assert(bundle.Rules[0].ID, Equals, "1") - c.Assert(bundle.Rules[0].Constraints, HasLen, 3) - c.Assert(bundle.Rules[0].Constraints[2], DeepEquals, Constraint{ + require.NoError(t, err) + require.Len(t, bundle.Rules, 2) + require.Equal(t, "1", bundle.Rules[0].ID) + require.Len(t, bundle.Rules[0].Constraints, 3) + require.Equal(t, Constraint{ Op: NotIn, Key: EngineLabelKey, Values: []string{EngineLabelTiFlash}, - }) - c.Assert(bundle.Rules[1].ID, Equals, "2") + }, bundle.Rules[0].Constraints[2]) + require.Equal(t, "2", bundle.Rules[1].ID) // merge rules3, err := NewRules(Follower, 4, "") - c.Assert(err, IsNil) - c.Assert(rules3, HasLen, 1) + require.NoError(t, err) + require.Len(t, rules3, 1) rules4, err := NewRules(Follower, 5, "") - c.Assert(err, IsNil) - c.Assert(rules4, HasLen, 1) + require.NoError(t, err) + require.Len(t, rules4, 1) rules0[0].Role = Voter bundle.Rules = append(bundle.Rules, rules0...) @@ -881,19 +876,19 @@ func (s *testBundleSuite) TestTidy(c *C) { bundle.Rules = append(bundle.Rules, rules4...) chkfunc := func() { - c.Assert(err, IsNil) - c.Assert(bundle.Rules, HasLen, 3) - c.Assert(bundle.Rules[0].ID, Equals, "0") - c.Assert(bundle.Rules[1].ID, Equals, "1") - c.Assert(bundle.Rules[2].ID, Equals, "follower") - c.Assert(bundle.Rules[2].Count, Equals, 9) - c.Assert(bundle.Rules[2].Constraints, DeepEquals, Constraints{ + require.NoError(t, err) + require.Len(t, bundle.Rules, 3) + require.Equal(t, "0", bundle.Rules[0].ID) + require.Equal(t, "1", bundle.Rules[1].ID) + require.Equal(t, "follower", bundle.Rules[2].ID) + require.Equal(t, 9, bundle.Rules[2].Count) + require.Equal(t, Constraints{ { Op: NotIn, Key: EngineLabelKey, Values: []string{EngineLabelTiFlash}, }, - }) + }, bundle.Rules[2].Constraints) } err = bundle.Tidy() chkfunc() @@ -907,15 +902,13 @@ func (s *testBundleSuite) TestTidy(c *C) { // it should be stable bundle2 := bundle.Clone() err = bundle2.Tidy() - c.Assert(err, IsNil) - c.Assert(bundle2, DeepEquals, bundle) + require.NoError(t, err) + require.Equal(t, bundle, bundle2) bundle.Rules[2].Constraints = append(bundle.Rules[2].Constraints, Constraint{ Op: In, Key: EngineLabelKey, Values: []string{EngineLabelTiFlash}, }) - c.Log(bundle.Rules[2]) - err = bundle.Tidy() - c.Assert(errors.Is(err, ErrConflictingConstraints), IsTrue) + require.ErrorIs(t, bundle.Tidy(), ErrConflictingConstraints) } diff --git a/ddl/placement/common_test.go b/ddl/placement/common_test.go index 75c3285965dbd..b22226f29c948 100644 --- a/ddl/placement/common_test.go +++ b/ddl/placement/common_test.go @@ -17,19 +17,11 @@ package placement import ( "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -func TestT(t *testing.T) { - TestingT(t) -} - -var _ = Suite(&testCommonSuite{}) - -type testCommonSuite struct{} - -func (t *testCommonSuite) TestGroup(c *C) { - c.Assert(GroupID(1), Equals, "TiDB_DDL_1") - c.Assert(GroupID(90), Equals, "TiDB_DDL_90") - c.Assert(GroupID(-1), Equals, "TiDB_DDL_-1") +func TestGroup(t *testing.T) { + require.Equal(t, "TiDB_DDL_1", GroupID(1)) + require.Equal(t, "TiDB_DDL_90", GroupID(90)) + require.Equal(t, "TiDB_DDL_-1", GroupID(-1)) } diff --git a/ddl/placement/constraint_test.go b/ddl/placement/constraint_test.go index a83aaa0098ab1..739d7bf6b5ba6 100644 --- a/ddl/placement/constraint_test.go +++ b/ddl/placement/constraint_test.go @@ -15,23 +15,20 @@ package placement import ( - "errors" + "fmt" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -var _ = Suite(&testConstraintSuite{}) - -type testConstraintSuite struct{} - -func (t *testConstraintSuite) TestNewFromYaml(c *C) { +func TestNewFromYaml(t *testing.T) { _, err := NewConstraintsFromYaml([]byte("[]")) - c.Assert(err, IsNil) + require.NoError(t, err) _, err = NewConstraintsFromYaml([]byte("]")) - c.Assert(err, NotNil) + require.Error(t, err) } -func (t *testConstraintSuite) TestNew(c *C) { +func TestNewConstraint(t *testing.T) { type TestCase struct { name string input string @@ -114,19 +111,19 @@ func (t *testConstraintSuite) TestNew(c *C) { }, } - for _, t := range tests { - label, err := NewConstraint(t.input) - comment := Commentf("%s: %v", t.name, err) - if t.err == nil { - c.Assert(err, IsNil, comment) - c.Assert(label, DeepEquals, t.label, comment) + for _, test := range tests { + label, err := NewConstraint(test.input) + comment := fmt.Sprintf("%s: %v", test.name, err) + if test.err == nil { + require.NoError(t, err, comment) + require.Equal(t, test.label, label, comment) } else { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + require.ErrorIs(t, err, test.err, comment) } } } -func (t *testConstraintSuite) TestRestore(c *C) { +func TestRestoreConstraint(t *testing.T) { type TestCase struct { name string input Constraint @@ -136,7 +133,7 @@ func (t *testConstraintSuite) TestRestore(c *C) { var tests []TestCase input, err := NewConstraint("+zone=bj") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ name: "normal, op in", input: input, @@ -144,7 +141,7 @@ func (t *testConstraintSuite) TestRestore(c *C) { }) input, err = NewConstraint("+ zone = bj ") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ name: "normal with spaces, op in", input: input, @@ -152,7 +149,7 @@ func (t *testConstraintSuite) TestRestore(c *C) { }) input, err = NewConstraint("- zone = bj ") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ name: "normal with spaces, op not in", input: input, @@ -189,19 +186,19 @@ func (t *testConstraintSuite) TestRestore(c *C) { err: ErrInvalidConstraintFormat, }) - for _, t := range tests { - output, err := t.input.Restore() - comment := Commentf("%s: %v", t.name, err) - if t.err == nil { - c.Assert(err, IsNil, comment) - c.Assert(output, Equals, t.output, comment) + for _, test := range tests { + output, err := test.input.Restore() + comment := fmt.Sprintf("%s: %v", test.name, err) + if test.err == nil { + require.NoError(t, err, comment) + require.Equal(t, test.output, output, comment) } else { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + require.ErrorIs(t, err, test.err, comment) } } } -func (t *testConstraintSuite) TestCompatibleWith(c *C) { +func TestCompatibleWith(t *testing.T) { type TestCase struct { name string i1 Constraint @@ -211,9 +208,9 @@ func (t *testConstraintSuite) TestCompatibleWith(c *C) { var tests []TestCase i1, err := NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) i2, err := NewConstraint("-zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "case 2", i1, i2, @@ -221,9 +218,9 @@ func (t *testConstraintSuite) TestCompatibleWith(c *C) { }) i1, err = NewConstraint("+zone=bj") - c.Assert(err, IsNil) + require.NoError(t, err) i2, err = NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "case 3", i1, i2, @@ -231,9 +228,9 @@ func (t *testConstraintSuite) TestCompatibleWith(c *C) { }) i1, err = NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) i2, err = NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "case 1", i1, i2, @@ -241,9 +238,9 @@ func (t *testConstraintSuite) TestCompatibleWith(c *C) { }) i1, err = NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) i2, err = NewConstraint("+dc=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "normal 1", i1, i2, @@ -251,17 +248,16 @@ func (t *testConstraintSuite) TestCompatibleWith(c *C) { }) i1, err = NewConstraint("-zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) i2, err = NewConstraint("-zone=bj") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "normal 2", i1, i2, ConstraintCompatible, }) - for _, t := range tests { - comment := Commentf("%s", t.name) - c.Assert(t.i1.CompatibleWith(&t.i2), Equals, t.output, comment) + for _, test := range tests { + require.Equal(t, test.output, test.i1.CompatibleWith(&test.i2), test.name) } } diff --git a/ddl/placement/constraints_test.go b/ddl/placement/constraints_test.go index ef15c878943c9..17a4b03843255 100644 --- a/ddl/placement/constraints_test.go +++ b/ddl/placement/constraints_test.go @@ -15,30 +15,27 @@ package placement import ( - "errors" + "fmt" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -var _ = Suite(&testConstraintsSuite{}) - -type testConstraintsSuite struct{} - -func (t *testConstraintsSuite) TestNew(c *C) { +func TestNewConstraints(t *testing.T) { _, err := NewConstraints(nil) - c.Assert(err, IsNil) + require.NoError(t, err) _, err = NewConstraints([]string{}) - c.Assert(err, IsNil) + require.NoError(t, err) _, err = NewConstraints([]string{"+zonesh"}) - c.Assert(errors.Is(err, ErrInvalidConstraintFormat), IsTrue) + require.ErrorIs(t, err, ErrInvalidConstraintFormat) _, err = NewConstraints([]string{"+zone=sh", "-zone=sh"}) - c.Assert(errors.Is(err, ErrConflictingConstraints), IsTrue) + require.ErrorIs(t, err, ErrConflictingConstraints) } -func (t *testConstraintsSuite) TestAdd(c *C) { +func TestAdd(t *testing.T) { type TestCase struct { name string labels Constraints @@ -48,9 +45,9 @@ func (t *testConstraintsSuite) TestAdd(c *C) { var tests []TestCase labels, err := NewConstraints([]string{"+zone=sh"}) - c.Assert(err, IsNil) + require.NoError(t, err) label, err := NewConstraint("-zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "always false match", labels, label, @@ -58,9 +55,9 @@ func (t *testConstraintsSuite) TestAdd(c *C) { }) labels, err = NewConstraints([]string{"+zone=sh"}) - c.Assert(err, IsNil) + require.NoError(t, err) label, err = NewConstraint("+zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "duplicated constraints, skip", labels, label, @@ -78,7 +75,7 @@ func (t *testConstraintsSuite) TestAdd(c *C) { }) labels, err = NewConstraints([]string{"+zone=sh"}) - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "invalid label in operand", labels, Constraint{Op: "["}, @@ -98,28 +95,28 @@ func (t *testConstraintsSuite) TestAdd(c *C) { }) labels, err = NewConstraints([]string{"+zone=sh"}) - c.Assert(err, IsNil) + require.NoError(t, err) label, err = NewConstraint("-zone=bj") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "normal", labels, label, nil, }) - for _, t := range tests { - err := t.labels.Add(t.label) - comment := Commentf("%s: %v", t.name, err) - if t.err == nil { - c.Assert(err, IsNil, comment) - c.Assert(t.labels[len(t.labels)-1], DeepEquals, t.label, comment) + for _, test := range tests { + err := test.labels.Add(test.label) + comment := fmt.Sprintf("%s: %v", test.name, err) + if test.err == nil { + require.NoError(t, err, comment) + require.Equal(t, test.label, test.labels[len(test.labels)-1], comment) } else { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + require.ErrorIs(t, err, test.err, comment) } } } -func (t *testConstraintsSuite) TestRestore(c *C) { +func TestRestoreConstraints(t *testing.T) { type TestCase struct { name string input Constraints @@ -136,9 +133,9 @@ func (t *testConstraintsSuite) TestRestore(c *C) { }) input1, err := NewConstraint("+zone=bj") - c.Assert(err, IsNil) + require.NoError(t, err) input2, err := NewConstraint("-zone=sh") - c.Assert(err, IsNil) + require.NoError(t, err) tests = append(tests, TestCase{ "normal2", Constraints{input1, input2}, @@ -157,14 +154,14 @@ func (t *testConstraintsSuite) TestRestore(c *C) { ErrInvalidConstraintFormat, }) - for _, t := range tests { - res, err := t.input.Restore() - comment := Commentf("%s: %v", t.name, err) - if t.err == nil { - c.Assert(err, IsNil, comment) - c.Assert(res, Equals, t.output, comment) + for _, test := range tests { + res, err := test.input.Restore() + comment := fmt.Sprintf("%s: %v", test.name, err) + if test.err == nil { + require.NoError(t, err, comment) + require.Equal(t, test.output, res, comment) } else { - c.Assert(errors.Is(err, t.err), IsTrue, comment) + require.ErrorIs(t, err, test.err, comment) } } } diff --git a/ddl/placement/meta_bundle_test.go b/ddl/placement/meta_bundle_test.go index a556849121df8..f53599bd2e14c 100644 --- a/ddl/placement/meta_bundle_test.go +++ b/ddl/placement/meta_bundle_test.go @@ -19,8 +19,8 @@ import ( "encoding/hex" "encoding/json" "fmt" + "testing" - . "github.com/pingcap/check" "github.com/pingcap/tidb/ddl/placement" "github.com/pingcap/tidb/kv" "github.com/pingcap/tidb/meta" @@ -28,11 +28,10 @@ import ( "github.com/pingcap/tidb/store/mockstore" "github.com/pingcap/tidb/tablecodec" "github.com/pingcap/tidb/util/codec" + "github.com/stretchr/testify/require" ) -var _ = Suite(&testMetaBundleSuite{}) - -type testMetaBundleSuite struct { +type metaBundleSuite struct { policy1 *model.PolicyInfo policy2 *model.PolicyInfo policy3 *model.PolicyInfo @@ -42,7 +41,8 @@ type testMetaBundleSuite struct { tbl4 *model.TableInfo } -func (s *testMetaBundleSuite) SetUpSuite(c *C) { +func createMetaBundleSuite() *metaBundleSuite { + s := new(metaBundleSuite) s.policy1 = &model.PolicyInfo{ ID: 11, Name: model.NewCIStr("p1"), @@ -124,154 +124,160 @@ func (s *testMetaBundleSuite) SetUpSuite(c *C) { ID: 104, Name: model.NewCIStr("t4"), } + return s } -func (s *testMetaBundleSuite) prepareMeta(c *C, store kv.Storage) { - c.Assert(kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { - t := meta.NewMeta(txn) - c.Assert(t.CreatePolicy(s.policy1), IsNil) - c.Assert(t.CreatePolicy(s.policy2), IsNil) - c.Assert(t.CreatePolicy(s.policy3), IsNil) +func (s *metaBundleSuite) prepareMeta(t *testing.T, store kv.Storage) { + err := kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { + m := meta.NewMeta(txn) + require.NoError(t, m.CreatePolicy(s.policy1)) + require.NoError(t, m.CreatePolicy(s.policy2)) + require.NoError(t, m.CreatePolicy(s.policy3)) return nil - }), IsNil) + }) + require.NoError(t, err) } -func (s *testMetaBundleSuite) TestNewTableBundle(c *C) { - store := newMockStore(c) - defer func() { - c.Assert(store.Close(), IsNil) - }() - s.prepareMeta(c, store) - c.Assert(kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { - t := meta.NewMeta(txn) +func TestNewTableBundle(t *testing.T) { + store, err := mockstore.NewMockStore() + require.NoError(t, err) + defer func() { require.NoError(t, store.Close()) }() + + s := createMetaBundleSuite() + s.prepareMeta(t, store) + require.NoError(t, kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { + m := meta.NewMeta(txn) // tbl1 - bundle, err := placement.NewTableBundle(t, s.tbl1) - c.Assert(err, IsNil) - s.checkTableBundle(c, s.tbl1, bundle) + bundle, err := placement.NewTableBundle(m, s.tbl1) + require.NoError(t, err) + s.checkTableBundle(t, s.tbl1, bundle) // tbl2 - bundle, err = placement.NewTableBundle(t, s.tbl2) - c.Assert(err, IsNil) - s.checkTableBundle(c, s.tbl2, bundle) + bundle, err = placement.NewTableBundle(m, s.tbl2) + require.NoError(t, err) + s.checkTableBundle(t, s.tbl2, bundle) // tbl3 - bundle, err = placement.NewTableBundle(t, s.tbl3) - c.Assert(err, IsNil) - s.checkTableBundle(c, s.tbl3, bundle) + bundle, err = placement.NewTableBundle(m, s.tbl3) + require.NoError(t, err) + s.checkTableBundle(t, s.tbl3, bundle) // tbl4 - bundle, err = placement.NewTableBundle(t, s.tbl4) - c.Assert(err, IsNil) - s.checkTableBundle(c, s.tbl4, bundle) + bundle, err = placement.NewTableBundle(m, s.tbl4) + require.NoError(t, err) + s.checkTableBundle(t, s.tbl4, bundle) return nil - }), IsNil) + })) } -func (s *testMetaBundleSuite) TestNewPartitionBundle(c *C) { - store := newMockStore(c) - defer func() { - c.Assert(store.Close(), IsNil) - }() - s.prepareMeta(c, store) +func TestNewPartitionBundle(t *testing.T) { + store, err := mockstore.NewMockStore() + require.NoError(t, err) + defer func() { require.NoError(t, store.Close()) }() - c.Assert(kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { - t := meta.NewMeta(txn) + s := createMetaBundleSuite() + s.prepareMeta(t, store) + + require.NoError(t, kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { + m := meta.NewMeta(txn) // tbl1.par0 - bundle, err := placement.NewPartitionBundle(t, s.tbl1.Partition.Definitions[0]) - c.Assert(err, IsNil) - s.checkPartitionBundle(c, s.tbl1.Partition.Definitions[0], bundle) + bundle, err := placement.NewPartitionBundle(m, s.tbl1.Partition.Definitions[0]) + require.NoError(t, err) + s.checkPartitionBundle(t, s.tbl1.Partition.Definitions[0], bundle) // tbl1.par1 - bundle, err = placement.NewPartitionBundle(t, s.tbl1.Partition.Definitions[1]) - c.Assert(err, IsNil) - s.checkPartitionBundle(c, s.tbl1.Partition.Definitions[1], bundle) + bundle, err = placement.NewPartitionBundle(m, s.tbl1.Partition.Definitions[1]) + require.NoError(t, err) + s.checkPartitionBundle(t, s.tbl1.Partition.Definitions[1], bundle) return nil - }), IsNil) + })) } -func (s *testMetaBundleSuite) TestNewPartitionListBundles(c *C) { - store := newMockStore(c) - defer func() { - c.Assert(store.Close(), IsNil) - }() - s.prepareMeta(c, store) +func TestNewPartitionListBundles(t *testing.T) { + store, err := mockstore.NewMockStore() + require.NoError(t, err) + defer func() { require.NoError(t, store.Close()) }() + + s := createMetaBundleSuite() + s.prepareMeta(t, store) - c.Assert(kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { - t := meta.NewMeta(txn) + require.NoError(t, kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { + m := meta.NewMeta(txn) - bundles, err := placement.NewPartitionListBundles(t, s.tbl1.Partition.Definitions) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 1) - s.checkPartitionBundle(c, s.tbl1.Partition.Definitions[1], bundles[0]) + bundles, err := placement.NewPartitionListBundles(m, s.tbl1.Partition.Definitions) + require.NoError(t, err) + require.Len(t, bundles, 1) + s.checkPartitionBundle(t, s.tbl1.Partition.Definitions[1], bundles[0]) - bundles, err = placement.NewPartitionListBundles(t, []model.PartitionDefinition{}) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 0) + bundles, err = placement.NewPartitionListBundles(m, []model.PartitionDefinition{}) + require.NoError(t, err) + require.Len(t, bundles, 0) - bundles, err = placement.NewPartitionListBundles(t, []model.PartitionDefinition{ + bundles, err = placement.NewPartitionListBundles(m, []model.PartitionDefinition{ s.tbl1.Partition.Definitions[0], s.tbl1.Partition.Definitions[2], }) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 0) + require.NoError(t, err) + require.Len(t, bundles, 0) return nil - }), IsNil) + })) } -func (s *testMetaBundleSuite) TestNewFullTableBundles(c *C) { - store := newMockStore(c) - defer func() { - c.Assert(store.Close(), IsNil) - }() - s.prepareMeta(c, store) +func TestNewFullTableBundles(t *testing.T) { + store, err := mockstore.NewMockStore() + require.NoError(t, err) + defer func() { require.NoError(t, store.Close()) }() + + s := createMetaBundleSuite() + s.prepareMeta(t, store) - c.Assert(kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { - t := meta.NewMeta(txn) + require.NoError(t, kv.RunInNewTxn(context.TODO(), store, false, func(ctx context.Context, txn kv.Transaction) error { + m := meta.NewMeta(txn) - bundles, err := placement.NewFullTableBundles(t, s.tbl1) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 2) - s.checkTableBundle(c, s.tbl1, bundles[0]) - s.checkPartitionBundle(c, s.tbl1.Partition.Definitions[1], bundles[1]) + bundles, err := placement.NewFullTableBundles(m, s.tbl1) + require.NoError(t, err) + require.Len(t, bundles, 2) + s.checkTableBundle(t, s.tbl1, bundles[0]) + s.checkPartitionBundle(t, s.tbl1.Partition.Definitions[1], bundles[1]) - bundles, err = placement.NewFullTableBundles(t, s.tbl2) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 1) - s.checkPartitionBundle(c, s.tbl2.Partition.Definitions[0], bundles[0]) + bundles, err = placement.NewFullTableBundles(m, s.tbl2) + require.NoError(t, err) + require.Len(t, bundles, 1) + s.checkPartitionBundle(t, s.tbl2.Partition.Definitions[0], bundles[0]) - bundles, err = placement.NewFullTableBundles(t, s.tbl3) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 1) - s.checkTableBundle(c, s.tbl3, bundles[0]) + bundles, err = placement.NewFullTableBundles(m, s.tbl3) + require.NoError(t, err) + require.Len(t, bundles, 1) + s.checkTableBundle(t, s.tbl3, bundles[0]) - bundles, err = placement.NewFullTableBundles(t, s.tbl4) - c.Assert(err, IsNil) - c.Assert(len(bundles), Equals, 0) + bundles, err = placement.NewFullTableBundles(m, s.tbl4) + require.NoError(t, err) + require.Len(t, bundles, 0) return nil - }), IsNil) + })) } -func (s *testMetaBundleSuite) checkTwoJSONObjectEquals(c *C, expected interface{}, got interface{}) { +func (s *metaBundleSuite) checkTwoJSONObjectEquals(t *testing.T, expected interface{}, got interface{}) { expectedJSON, err := json.Marshal(expected) - c.Assert(err, IsNil) + require.NoError(t, err) expectedStr := string(expectedJSON) gotJSON, err := json.Marshal(got) - c.Assert(err, IsNil) + require.NoError(t, err) gotStr := string(gotJSON) - c.Assert(gotStr, Equals, expectedStr) + require.Equal(t, expectedStr, gotStr) } -func (s *testMetaBundleSuite) checkTableBundle(c *C, tbl *model.TableInfo, got *placement.Bundle) { +func (s *metaBundleSuite) checkTableBundle(t *testing.T, tbl *model.TableInfo, got *placement.Bundle) { if tbl.PlacementPolicyRef == nil { - c.Assert(got, IsNil) + require.Nil(t, got) return } @@ -279,7 +285,7 @@ func (s *testMetaBundleSuite) checkTableBundle(c *C, tbl *model.TableInfo, got * ID: fmt.Sprintf("TiDB_DDL_%d", tbl.ID), Index: placement.RuleIndexTable, Override: true, - Rules: s.expectedRules(c, tbl.PlacementPolicyRef), + Rules: s.expectedRules(t, tbl.PlacementPolicyRef), } for idx, rule := range expected.Rules { @@ -292,7 +298,7 @@ func (s *testMetaBundleSuite) checkTableBundle(c *C, tbl *model.TableInfo, got * if tbl.Partition != nil { for _, par := range tbl.Partition.Definitions { - rules := s.expectedRules(c, tbl.PlacementPolicyRef) + rules := s.expectedRules(t, tbl.PlacementPolicyRef) for idx, rule := range rules { rule.GroupID = expected.ID rule.Index = placement.RuleIndexPartition @@ -304,12 +310,12 @@ func (s *testMetaBundleSuite) checkTableBundle(c *C, tbl *model.TableInfo, got * } } - s.checkTwoJSONObjectEquals(c, expected, got) + s.checkTwoJSONObjectEquals(t, expected, got) } -func (s *testMetaBundleSuite) checkPartitionBundle(c *C, def model.PartitionDefinition, got *placement.Bundle) { +func (s *metaBundleSuite) checkPartitionBundle(t *testing.T, def model.PartitionDefinition, got *placement.Bundle) { if def.PlacementPolicyRef == nil { - c.Assert(got, IsNil) + require.Nil(t, got) return } @@ -317,7 +323,7 @@ func (s *testMetaBundleSuite) checkPartitionBundle(c *C, def model.PartitionDefi ID: fmt.Sprintf("TiDB_DDL_%d", def.ID), Index: placement.RuleIndexPartition, Override: true, - Rules: s.expectedRules(c, def.PlacementPolicyRef), + Rules: s.expectedRules(t, def.PlacementPolicyRef), } for idx, rule := range expected.Rules { @@ -328,10 +334,10 @@ func (s *testMetaBundleSuite) checkPartitionBundle(c *C, def model.PartitionDefi rule.EndKeyHex = hex.EncodeToString(codec.EncodeBytes(nil, tablecodec.GenTablePrefix(def.ID+1))) } - s.checkTwoJSONObjectEquals(c, expected, got) + s.checkTwoJSONObjectEquals(t, expected, got) } -func (s *testMetaBundleSuite) expectedRules(c *C, ref *model.PolicyRefInfo) []*placement.Rule { +func (s *metaBundleSuite) expectedRules(t *testing.T, ref *model.PolicyRefInfo) []*placement.Rule { if ref == nil { return []*placement.Rule{} } @@ -345,18 +351,14 @@ func (s *testMetaBundleSuite) expectedRules(c *C, ref *model.PolicyRefInfo) []*p case s.policy3.ID: policy = s.policy3 default: - c.FailNow() + t.FailNow() } - c.Assert(ref.Name, Equals, policy.Name) + + require.Equal(t, policy.Name, ref.Name) settings := policy.PlacementSettings bundle, err := placement.NewBundleFromOptions(settings) - c.Assert(err, IsNil) - return bundle.Rules -} + require.NoError(t, err) -func newMockStore(c *C) kv.Storage { - store, err := mockstore.NewMockStore() - c.Assert(err, IsNil) - return store + return bundle.Rules } diff --git a/ddl/placement/rule_test.go b/ddl/placement/rule_test.go index a48dc38faa33c..bee9807b486bd 100644 --- a/ddl/placement/rule_test.go +++ b/ddl/placement/rule_test.go @@ -16,10 +16,10 @@ package placement import ( "errors" + "fmt" "reflect" "testing" - . "github.com/pingcap/check" "github.com/stretchr/testify/require" ) @@ -32,24 +32,7 @@ func TestClone(t *testing.T) { require.Equal(t, &Rule{ID: "121"}, newRule) } -func matchRules(t1, t2 []*Rule, prefix string, c *C) { - c.Assert(len(t2), Equals, len(t1), Commentf(prefix)) - for i := range t1 { - found := false - for j := range t2 { - ok, _ := DeepEquals.Check([]interface{}{t2[j], t1[i]}, []string{}) - if ok { - found = true - break - } - } - if !found { - c.Errorf("%s\n\ncan not found %d rule\n%+v\n%+v", prefix, i, t1[i], t2) - } - } -} - -func matchRulesT(t1, t2 []*Rule, prefix string, t *testing.T) { +func matchRules(t1, t2 []*Rule, prefix string, t *testing.T) { require.Equal(t, len(t2), len(t1), prefix) for i := range t1 { found := false @@ -157,11 +140,11 @@ func TestNewRuleAndNewRules(t *testing.T) { }) for _, tt := range tests { - comment := Commentf("[%s]", tt.name) + comment := fmt.Sprintf("[%s]", tt.name) output, err := NewRules(Voter, tt.replicas, tt.input) if tt.err == nil { require.NoError(t, err, comment) - matchRulesT(tt.output, output, comment.CheckCommentString(), t) + matchRules(tt.output, output, comment, t) } else { require.True(t, errors.Is(err, tt.err), "[%s]\n%s\n%s\n", tt.name, err, tt.err) }