diff --git a/server/schedule/placement/config_test.go b/server/schedule/placement/config_test.go index 0e51aed73d3..eeb9e7d3b0e 100644 --- a/server/schedule/placement/config_test.go +++ b/server/schedule/placement/config_test.go @@ -15,15 +15,13 @@ package placement import ( - . "github.com/pingcap/check" -) - -var _ = Suite(&testConfigSuite{}) + "testing" -type testConfigSuite struct { -} + "github.com/stretchr/testify/require" +) -func (s *testConfigSuite) TestTrim(c *C) { +func TestTrim(t *testing.T) { + re := require.New(t) rc := newRuleConfig() rc.setRule(&Rule{GroupID: "g1", ID: "id1"}) rc.setRule(&Rule{GroupID: "g1", ID: "id2"}) @@ -76,7 +74,7 @@ func (s *testConfigSuite) TestTrim(c *C) { p := rc.beginPatch() tc.ops(p) p.trim() - c.Assert(p.mut.rules, DeepEquals, tc.mutRules) - c.Assert(p.mut.groups, DeepEquals, tc.mutGroups) + re.Equal(tc.mutRules, p.mut.rules) + re.Equal(tc.mutGroups, p.mut.groups) } } diff --git a/server/schedule/placement/fit_test.go b/server/schedule/placement/fit_test.go index e3804de33ef..0a070c38f65 100644 --- a/server/schedule/placement/fit_test.go +++ b/server/schedule/placement/fit_test.go @@ -18,17 +18,15 @@ import ( "fmt" "strconv" "strings" + "testing" - . "github.com/pingcap/check" "github.com/pingcap/kvproto/pkg/metapb" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "github.com/tikv/pd/server/core" ) -var _ = Suite(&testFitSuite{}) - -type testFitSuite struct{} - -func (s *testFitSuite) makeStores() StoreSet { +func makeStores() StoreSet { stores := core.NewStoresInfo() for zone := 1; zone <= 5; zone++ { for rack := 1; rack <= 5; rack++ { @@ -50,7 +48,7 @@ func (s *testFitSuite) makeStores() StoreSet { } // example: "1111_leader,1234,2111_learner" -func (s *testFitSuite) makeRegion(def string) *core.RegionInfo { +func makeRegion(def string) *core.RegionInfo { var regionMeta metapb.Region var leader *metapb.Peer for _, peerDef := range strings.Split(def, ",") { @@ -71,7 +69,7 @@ func (s *testFitSuite) makeRegion(def string) *core.RegionInfo { // example: "3/voter/zone=zone1+zone2,rack=rack2/zone,rack,host" // count role constraints location_labels -func (s *testFitSuite) makeRule(def string) *Rule { +func makeRule(def string) *Rule { var rule Rule splits := strings.Split(def, "/") rule.Count, _ = strconv.Atoi(splits[0]) @@ -92,7 +90,7 @@ func (s *testFitSuite) makeRule(def string) *Rule { return &rule } -func (s *testFitSuite) checkPeerMatch(peers []*metapb.Peer, expect string) bool { +func checkPeerMatch(peers []*metapb.Peer, expect string) bool { if len(peers) == 0 && expect == "" { return true } @@ -111,8 +109,9 @@ func (s *testFitSuite) checkPeerMatch(peers []*metapb.Peer, expect string) bool return len(m) == 0 } -func (s *testFitSuite) TestFitRegion(c *C) { - stores := s.makeStores() +func TestFitRegion(t *testing.T) { + re := require.New(t) + stores := makeStores() cases := []struct { region string @@ -140,34 +139,34 @@ func (s *testFitSuite) TestFitRegion(c *C) { } for _, cc := range cases { - region := s.makeRegion(cc.region) + region := makeRegion(cc.region) var rules []*Rule for _, r := range cc.rules { - rules = append(rules, s.makeRule(r)) + rules = append(rules, makeRule(r)) } rf := fitRegion(stores.GetStores(), region, rules) expects := strings.Split(cc.fitPeers, "/") for i, f := range rf.RuleFits { - c.Assert(s.checkPeerMatch(f.Peers, expects[i]), IsTrue) + re.True(checkPeerMatch(f.Peers, expects[i])) } if len(rf.RuleFits) < len(expects) { - c.Assert(s.checkPeerMatch(rf.OrphanPeers, expects[len(rf.RuleFits)]), IsTrue) + re.True(checkPeerMatch(rf.OrphanPeers, expects[len(rf.RuleFits)])) } } } - -func (s *testFitSuite) TestIsolationScore(c *C) { - stores := s.makeStores() +func TestIsolationScore(t *testing.T) { + as := assert.New(t) + stores := makeStores() testCases := []struct { - peers1 []uint64 - Checker - peers2 []uint64 + checker func(interface{}, interface{}, ...interface{}) bool + peers1 []uint64 + peers2 []uint64 }{ - {[]uint64{1111, 1112}, Less, []uint64{1111, 1121}}, - {[]uint64{1111, 1211}, Less, []uint64{1111, 2111}}, - {[]uint64{1111, 1211, 1311, 2111, 3111}, Less, []uint64{1111, 1211, 2111, 2211, 3111}}, - {[]uint64{1111, 1211, 2111, 2211, 3111}, Equals, []uint64{1111, 2111, 2211, 3111, 3211}}, - {[]uint64{1111, 1211, 2111, 2211, 3111}, Greater, []uint64{1111, 1121, 2111, 2211, 3111}}, + {as.Less, []uint64{1111, 1112}, []uint64{1111, 1121}}, + {as.Less, []uint64{1111, 1211}, []uint64{1111, 2111}}, + {as.Less, []uint64{1111, 1211, 1311, 2111, 3111}, []uint64{1111, 1211, 2111, 2211, 3111}}, + {as.Equal, []uint64{1111, 1211, 2111, 2211, 3111}, []uint64{1111, 2111, 2211, 3111, 3211}}, + {as.Greater, []uint64{1111, 1211, 2111, 2211, 3111}, []uint64{1111, 1121, 2111, 2211, 3111}}, } makePeers := func(ids []uint64) []*fitPeer { @@ -185,6 +184,6 @@ func (s *testFitSuite) TestIsolationScore(c *C) { peers1, peers2 := makePeers(tc.peers1), makePeers(tc.peers2) score1 := isolationScore(peers1, []string{"zone", "rack", "host"}) score2 := isolationScore(peers2, []string{"zone", "rack", "host"}) - c.Assert(score1, tc.Checker, score2) + tc.checker(score1, score2) } } diff --git a/server/schedule/placement/label_constraint_test.go b/server/schedule/placement/label_constraint_test.go index 705ea639c8d..dd6feebe94f 100644 --- a/server/schedule/placement/label_constraint_test.go +++ b/server/schedule/placement/label_constraint_test.go @@ -17,19 +17,12 @@ package placement import ( "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" "github.com/tikv/pd/server/core" ) -func TestPlacement(t *testing.T) { - TestingT(t) -} - -var _ = Suite(&testLabelConstraintsSuite{}) - -type testLabelConstraintsSuite struct{} - -func (s *testLabelConstraintsSuite) TestLabelConstraint(c *C) { +func TestLabelConstraint(t *testing.T) { + re := require.New(t) stores := []map[string]string{ {"zone": "zone1", "rack": "rack1"}, // 1 {"zone": "zone1", "rack": "rack2"}, // 2 @@ -61,11 +54,11 @@ func (s *testLabelConstraintsSuite) TestLabelConstraint(c *C) { matched = append(matched, j+1) } } - c.Assert(matched, DeepEquals, expect[i]) + re.Equal(expect[i], matched) } } - -func (s *testLabelConstraintsSuite) TestLabelConstraints(c *C) { +func TestLabelConstraints(t *testing.T) { + re := require.New(t) stores := []map[string]string{ {}, // 1 {"k1": "v1"}, // 2 @@ -100,6 +93,6 @@ func (s *testLabelConstraintsSuite) TestLabelConstraints(c *C) { matched = append(matched, j+1) } } - c.Assert(matched, DeepEquals, expect[i]) + re.Equal(expect[i], matched) } } diff --git a/server/schedule/placement/region_rule_cache_test.go b/server/schedule/placement/region_rule_cache_test.go index 54f32ad26ac..f38d13eba87 100644 --- a/server/schedule/placement/region_rule_cache_test.go +++ b/server/schedule/placement/region_rule_cache_test.go @@ -15,15 +15,17 @@ package placement import ( + "testing" "time" - . "github.com/pingcap/check" "github.com/pingcap/kvproto/pkg/metapb" "github.com/pingcap/kvproto/pkg/pdpb" + "github.com/stretchr/testify/require" "github.com/tikv/pd/server/core" ) -func (s *testRuleSuite) TestRegionRuleFitCache(c *C) { +func TestRegionRuleFitCache(t *testing.T) { + re := require.New(t) originRegion := mockRegion(3, 0) originRules := addExtraRules(0) originStores := mockStores(3) @@ -174,20 +176,20 @@ func (s *testRuleSuite) TestRegionRuleFitCache(c *C) { }, } for _, testcase := range testcases { - c.Log(testcase.name) - c.Assert(cache.IsUnchanged(testcase.region, testcase.rules, mockStores(3)), Equals, testcase.unchanged) + t.Log(testcase.name) + re.Equal(testcase.unchanged, cache.IsUnchanged(testcase.region, testcase.rules, mockStores(3))) } for _, testcase := range testcases { - c.Log(testcase.name) - c.Assert(cache.IsUnchanged(testcase.region, testcase.rules, mockStoresNoHeartbeat(3)), Equals, false) + t.Log(testcase.name) + re.Equal(false, cache.IsUnchanged(testcase.region, testcase.rules, mockStoresNoHeartbeat(3))) } // Invalid Input4 - c.Assert(cache.IsUnchanged(mockRegion(3, 0), addExtraRules(0), nil), IsFalse) + re.False(cache.IsUnchanged(mockRegion(3, 0), addExtraRules(0), nil)) // Invalid Input5 - c.Assert(cache.IsUnchanged(mockRegion(3, 0), addExtraRules(0), []*core.StoreInfo{}), IsFalse) + re.False(cache.IsUnchanged(mockRegion(3, 0), addExtraRules(0), []*core.StoreInfo{})) // origin rules changed, assert whether cache is changed originRules[0].Version++ - c.Assert(cache.IsUnchanged(originRegion, originRules, originStores), IsFalse) + re.False(cache.IsUnchanged(originRegion, originRules, originStores)) } func mockRegionRuleFitCache(region *core.RegionInfo, rules []*Rule, regionStores []*core.StoreInfo) *RegionRuleFitCache { diff --git a/server/schedule/placement/rule_manager_test.go b/server/schedule/placement/rule_manager_test.go index ae750fe5f9b..7818a6cebba 100644 --- a/server/schedule/placement/rule_manager_test.go +++ b/server/schedule/placement/rule_manager_test.go @@ -16,43 +16,42 @@ package placement import ( "encoding/hex" + "testing" - . "github.com/pingcap/check" "github.com/pingcap/kvproto/pkg/metapb" + "github.com/stretchr/testify/require" "github.com/tikv/pd/pkg/codec" "github.com/tikv/pd/server/core" "github.com/tikv/pd/server/storage" "github.com/tikv/pd/server/storage/endpoint" ) -var _ = Suite(&testManagerSuite{}) - -type testManagerSuite struct { - store endpoint.RuleStorage - manager *RuleManager -} - -func (s *testManagerSuite) SetUpTest(c *C) { - s.store = storage.NewStorageWithMemoryBackend() +func newTestManager(t *testing.T) (endpoint.RuleStorage, *RuleManager) { + re := require.New(t) + store := storage.NewStorageWithMemoryBackend() var err error - s.manager = NewRuleManager(s.store, nil, nil) - err = s.manager.Initialize(3, []string{"zone", "rack", "host"}) - c.Assert(err, IsNil) + manager := NewRuleManager(store, nil, nil) + err = manager.Initialize(3, []string{"zone", "rack", "host"}) + re.NoError(err) + return store, manager } -func (s *testManagerSuite) TestDefault(c *C) { - rules := s.manager.GetAllRules() - c.Assert(rules, HasLen, 1) - c.Assert(rules[0].GroupID, Equals, "pd") - c.Assert(rules[0].ID, Equals, "default") - c.Assert(rules[0].Index, Equals, 0) - c.Assert(rules[0].StartKey, HasLen, 0) - c.Assert(rules[0].EndKey, HasLen, 0) - c.Assert(rules[0].Role, Equals, Voter) - c.Assert(rules[0].LocationLabels, DeepEquals, []string{"zone", "rack", "host"}) +func TestDefault(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) + rules := manager.GetAllRules() + re.Len(rules, 1) + re.Equal("pd", rules[0].GroupID) + re.Equal("default", rules[0].ID) + re.Equal(0, rules[0].Index) + re.Len(rules[0].StartKey, 0) + re.Len(rules[0].EndKey, 0) + re.Equal(Voter, rules[0].Role) + re.Equal([]string{"zone", "rack", "host"}, rules[0].LocationLabels) } - -func (s *testManagerSuite) TestAdjustRule(c *C) { +func TestAdjustRule(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) rules := []Rule{ {GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, {GroupID: "", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, @@ -65,32 +64,38 @@ func (s *testManagerSuite) TestAdjustRule(c *C) { {GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: -1}, {GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3, LabelConstraints: []LabelConstraint{{Op: "foo"}}}, } - c.Assert(s.manager.adjustRule(&rules[0], "group"), IsNil) - c.Assert(rules[0].StartKey, DeepEquals, []byte{0x12, 0x3a, 0xbc}) - c.Assert(rules[0].EndKey, DeepEquals, []byte{0x12, 0x3a, 0xbf}) - c.Assert(s.manager.adjustRule(&rules[1], ""), NotNil) + re.NoError(manager.adjustRule(&rules[0], "group")) + + re.Equal([]byte{0x12, 0x3a, 0xbc}, rules[0].StartKey) + re.Equal([]byte{0x12, 0x3a, 0xbf}, rules[0].EndKey) + re.Error(manager.adjustRule(&rules[1], "")) + for i := 2; i < len(rules); i++ { - c.Assert(s.manager.adjustRule(&rules[i], "group"), NotNil) + re.Error(manager.adjustRule(&rules[i], "group")) + } - s.manager.SetKeyType(core.Table.String()) - c.Assert(s.manager.adjustRule(&Rule{GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, "group"), NotNil) - s.manager.SetKeyType(core.Txn.String()) - c.Assert(s.manager.adjustRule(&Rule{GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, "group"), NotNil) - c.Assert(s.manager.adjustRule(&Rule{ + manager.SetKeyType(core.Table.String()) + re.Error(manager.adjustRule(&Rule{GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, "group")) + + manager.SetKeyType(core.Txn.String()) + re.Error(manager.adjustRule(&Rule{GroupID: "group", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3}, "group")) + + re.Error(manager.adjustRule(&Rule{ GroupID: "group", ID: "id", StartKeyHex: hex.EncodeToString(codec.EncodeBytes([]byte{0})), EndKeyHex: "123abf", Role: "voter", Count: 3, - }, "group"), NotNil) + }, "group")) } - -func (s *testManagerSuite) TestLeaderCheck(c *C) { - c.Assert(s.manager.SetRule(&Rule{GroupID: "pd", ID: "default", Role: "learner", Count: 3}), ErrorMatches, ".*needs at least one leader or voter.*") - c.Assert(s.manager.SetRule(&Rule{GroupID: "g2", ID: "33", Role: "leader", Count: 2}), ErrorMatches, ".*define multiple leaders by count 2.*") - c.Assert(s.manager.Batch([]RuleOp{ +func TestLeaderCheck(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) + re.Regexp(".*needs at least one leader or voter.*", manager.SetRule(&Rule{GroupID: "pd", ID: "default", Role: "learner", Count: 3}).Error()) + re.Regexp(".*define multiple leaders by count 2.*", manager.SetRule(&Rule{GroupID: "g2", ID: "33", Role: "leader", Count: 2}).Error()) + re.Regexp(".*multiple leader replicas.*", manager.Batch([]RuleOp{ { Rule: &Rule{GroupID: "g2", ID: "foo1", Role: "leader", Count: 1}, Action: RuleOpAdd, @@ -99,49 +104,53 @@ func (s *testManagerSuite) TestLeaderCheck(c *C) { Rule: &Rule{GroupID: "g2", ID: "foo2", Role: "leader", Count: 1}, Action: RuleOpAdd, }, - }), ErrorMatches, ".*multiple leader replicas.*") + }).Error()) } - -func (s *testManagerSuite) TestSaveLoad(c *C) { +func TestSaveLoad(t *testing.T) { + re := require.New(t) + store, manager := newTestManager(t) rules := []*Rule{ {GroupID: "pd", ID: "default", Role: "voter", Count: 5}, {GroupID: "foo", ID: "baz", StartKeyHex: "", EndKeyHex: "abcd", Role: "voter", Count: 1}, {GroupID: "foo", ID: "bar", Role: "learner", Count: 1}, } for _, r := range rules { - c.Assert(s.manager.SetRule(r.Clone()), IsNil) + re.NoError(manager.SetRule(r.Clone())) } - m2 := NewRuleManager(s.store, nil, nil) + m2 := NewRuleManager(store, nil, nil) err := m2.Initialize(3, []string{"no", "labels"}) - c.Assert(err, IsNil) - c.Assert(m2.GetAllRules(), HasLen, 3) - c.Assert(m2.GetRule("pd", "default").String(), Equals, rules[0].String()) - c.Assert(m2.GetRule("foo", "baz").String(), Equals, rules[1].String()) - c.Assert(m2.GetRule("foo", "bar").String(), Equals, rules[2].String()) + re.NoError(err) + re.Len(m2.GetAllRules(), 3) + re.Equal(rules[0].String(), m2.GetRule("pd", "default").String()) + re.Equal(rules[1].String(), m2.GetRule("foo", "baz").String()) + re.Equal(rules[2].String(), m2.GetRule("foo", "bar").String()) } - -// https://github.com/tikv/pd/issues/3886 -func (s *testManagerSuite) TestSetAfterGet(c *C) { - rule := s.manager.GetRule("pd", "default") +func TestSetAfterGet(t *testing.T) { + re := require.New(t) + store, manager := newTestManager(t) + rule := manager.GetRule("pd", "default") rule.Count = 1 - s.manager.SetRule(rule) + manager.SetRule(rule) - m2 := NewRuleManager(s.store, nil, nil) + m2 := NewRuleManager(store, nil, nil) err := m2.Initialize(100, []string{}) - c.Assert(err, IsNil) + re.NoError(err) rule = m2.GetRule("pd", "default") - c.Assert(rule.Count, Equals, 1) + re.Equal(1, rule.Count) } -func (s *testManagerSuite) checkRules(c *C, rules []*Rule, expect [][2]string) { - c.Assert(rules, HasLen, len(expect)) +func checkRules(t *testing.T, rules []*Rule, expect [][2]string) { + re := require.New(t) + re.Len(rules, len(expect)) for i := range rules { - c.Assert(rules[i].Key(), DeepEquals, expect[i]) + re.Equal(expect[i], rules[i].Key()) } } -func (s *testManagerSuite) TestKeys(c *C) { +func TestKeys(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) rules := []*Rule{ {GroupID: "1", ID: "1", Role: "voter", Count: 1, StartKeyHex: "", EndKeyHex: ""}, {GroupID: "2", ID: "2", Role: "voter", Count: 1, StartKeyHex: "11", EndKeyHex: "ff"}, @@ -150,24 +159,24 @@ func (s *testManagerSuite) TestKeys(c *C) { toDelete := []RuleOp{} for _, r := range rules { - s.manager.SetRule(r) + manager.SetRule(r) toDelete = append(toDelete, RuleOp{ Rule: r, Action: RuleOpDel, DeleteByIDPrefix: false, }) } - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"pd", "default"}}) - s.manager.Batch(toDelete) - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"pd", "default"}}) + checkRules(t, manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"pd", "default"}}) + manager.Batch(toDelete) + checkRules(t, manager.GetAllRules(), [][2]string{{"pd", "default"}}) rules = append(rules, &Rule{GroupID: "3", ID: "4", Role: "voter", Count: 1, StartKeyHex: "44", EndKeyHex: "ee"}, &Rule{GroupID: "3", ID: "5", Role: "voter", Count: 1, StartKeyHex: "44", EndKeyHex: "dd"}) - s.manager.SetRules(rules) - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"3", "4"}, {"3", "5"}, {"pd", "default"}}) + manager.SetRules(rules) + checkRules(t, manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"3", "4"}, {"3", "5"}, {"pd", "default"}}) - s.manager.DeleteRule("pd", "default") - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"3", "4"}, {"3", "5"}}) + manager.DeleteRule("pd", "default") + checkRules(t, manager.GetAllRules(), [][2]string{{"1", "1"}, {"2", "2"}, {"2", "3"}, {"3", "4"}, {"3", "5"}}) splitKeys := [][]string{ {"", "", "11", "22", "44", "dd", "ee", "ff"}, @@ -176,10 +185,10 @@ func (s *testManagerSuite) TestKeys(c *C) { {"22", "ef", "44", "dd", "ee"}, } for _, keys := range splitKeys { - splits := s.manager.GetSplitKeys(s.dhex(keys[0]), s.dhex(keys[1])) - c.Assert(splits, HasLen, len(keys)-2) + splits := manager.GetSplitKeys(dhex(keys[0]), dhex(keys[1])) + re.Len(splits, len(keys)-2) for i := range splits { - c.Assert(splits[i], DeepEquals, s.dhex(keys[i+2])) + re.Equal(dhex(keys[i+2]), splits[i]) } } @@ -190,12 +199,12 @@ func (s *testManagerSuite) TestKeys(c *C) { {{"11", "33"}}, } for _, keys := range regionKeys { - region := core.NewRegionInfo(&metapb.Region{StartKey: s.dhex(keys[0][0]), EndKey: s.dhex(keys[0][1])}, nil) - rules := s.manager.GetRulesForApplyRegion(region) - c.Assert(rules, HasLen, len(keys)-1) + region := core.NewRegionInfo(&metapb.Region{StartKey: dhex(keys[0][0]), EndKey: dhex(keys[0][1])}, nil) + rules := manager.GetRulesForApplyRegion(region) + re.Len(rules, len(keys)-1) for i := range rules { - c.Assert(rules[i].StartKeyHex, Equals, keys[i+1][0]) - c.Assert(rules[i].EndKeyHex, Equals, keys[i+1][1]) + re.Equal(keys[i+1][0], rules[i].StartKeyHex) + re.Equal(keys[i+1][1], rules[i].EndKeyHex) } } @@ -205,11 +214,11 @@ func (s *testManagerSuite) TestKeys(c *C) { {"33", "", "", "11", "ff", "22", "dd"}, } for _, keys := range ruleByKeys { - rules := s.manager.GetRulesByKey(s.dhex(keys[0])) - c.Assert(rules, HasLen, (len(keys)-1)/2) + rules := manager.GetRulesByKey(dhex(keys[0])) + re.Len(rules, (len(keys)-1)/2) for i := range rules { - c.Assert(rules[i].StartKeyHex, Equals, keys[i*2+1]) - c.Assert(rules[i].EndKeyHex, Equals, keys[i*2+2]) + re.Equal(keys[i*2+1], rules[i].StartKeyHex) + re.Equal(keys[i*2+2], rules[i].EndKeyHex) } } @@ -220,126 +229,125 @@ func (s *testManagerSuite) TestKeys(c *C) { {"4"}, } for _, keys := range rulesByGroup { - rules := s.manager.GetRulesByGroup(keys[0]) - c.Assert(rules, HasLen, (len(keys)-1)/2) + rules := manager.GetRulesByGroup(keys[0]) + re.Len(rules, (len(keys)-1)/2) for i := range rules { - c.Assert(rules[i].StartKeyHex, Equals, keys[i*2+1]) - c.Assert(rules[i].EndKeyHex, Equals, keys[i*2+2]) + re.Equal(keys[i*2+1], rules[i].StartKeyHex) + re.Equal(keys[i*2+2], rules[i].EndKeyHex) } } } - -func (s *testManagerSuite) TestDeleteByIDPrefix(c *C) { - s.manager.SetRules([]*Rule{ +func TestDeleteByIDPrefix(t *testing.T) { + _, manager := newTestManager(t) + manager.SetRules([]*Rule{ {GroupID: "g1", ID: "foo1", Role: "voter", Count: 1}, {GroupID: "g2", ID: "foo1", Role: "voter", Count: 1}, {GroupID: "g2", ID: "foobar", Role: "voter", Count: 1}, {GroupID: "g2", ID: "baz2", Role: "voter", Count: 1}, }) - s.manager.DeleteRule("pd", "default") - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"g1", "foo1"}, {"g2", "baz2"}, {"g2", "foo1"}, {"g2", "foobar"}}) + manager.DeleteRule("pd", "default") + checkRules(t, manager.GetAllRules(), [][2]string{{"g1", "foo1"}, {"g2", "baz2"}, {"g2", "foo1"}, {"g2", "foobar"}}) - s.manager.Batch([]RuleOp{{ + manager.Batch([]RuleOp{{ Rule: &Rule{GroupID: "g2", ID: "foo"}, Action: RuleOpDel, DeleteByIDPrefix: true, }}) - s.checkRules(c, s.manager.GetAllRules(), [][2]string{{"g1", "foo1"}, {"g2", "baz2"}}) + checkRules(t, manager.GetAllRules(), [][2]string{{"g1", "foo1"}, {"g2", "baz2"}}) } - -func (s *testManagerSuite) TestRangeGap(c *C) { - // |-- default --| - // cannot delete the last rule - err := s.manager.DeleteRule("pd", "default") - c.Assert(err, NotNil) - - err = s.manager.SetRule(&Rule{GroupID: "pd", ID: "foo", StartKeyHex: "", EndKeyHex: "abcd", Role: "voter", Count: 1}) - c.Assert(err, IsNil) +func TestRangeGap(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) + err := manager.DeleteRule("pd", "default") + re.Error(err) + + err = manager.SetRule(&Rule{GroupID: "pd", ID: "foo", StartKeyHex: "", EndKeyHex: "abcd", Role: "voter", Count: 1}) + re.NoError(err) // |-- default --| // |-- foo --| // still cannot delete default since it will cause ("abcd", "") has no rules inside. - err = s.manager.DeleteRule("pd", "default") - c.Assert(err, NotNil) - err = s.manager.SetRule(&Rule{GroupID: "pd", ID: "bar", StartKeyHex: "abcd", EndKeyHex: "", Role: "voter", Count: 1}) - c.Assert(err, IsNil) + err = manager.DeleteRule("pd", "default") + re.Error(err) + err = manager.SetRule(&Rule{GroupID: "pd", ID: "bar", StartKeyHex: "abcd", EndKeyHex: "", Role: "voter", Count: 1}) + re.NoError(err) // now default can be deleted. - err = s.manager.DeleteRule("pd", "default") - c.Assert(err, IsNil) + err = manager.DeleteRule("pd", "default") + re.NoError(err) // cannot change range since it will cause ("abaa", "abcd") has no rules inside. - err = s.manager.SetRule(&Rule{GroupID: "pd", ID: "foo", StartKeyHex: "", EndKeyHex: "abaa", Role: "voter", Count: 1}) - c.Assert(err, NotNil) + err = manager.SetRule(&Rule{GroupID: "pd", ID: "foo", StartKeyHex: "", EndKeyHex: "abaa", Role: "voter", Count: 1}) + re.Error(err) } - -func (s *testManagerSuite) TestGroupConfig(c *C) { - // group pd +func TestGroupConfig(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) pd1 := &RuleGroup{ID: "pd"} - c.Assert(s.manager.GetRuleGroup("pd"), DeepEquals, pd1) + re.Equal(pd1, manager.GetRuleGroup("pd")) // update group pd pd2 := &RuleGroup{ID: "pd", Index: 100, Override: true} - err := s.manager.SetRuleGroup(pd2) - c.Assert(err, IsNil) - c.Assert(s.manager.GetRuleGroup("pd"), DeepEquals, pd2) + err := manager.SetRuleGroup(pd2) + re.NoError(err) + re.Equal(pd2, manager.GetRuleGroup("pd")) // new group g without config - err = s.manager.SetRule(&Rule{GroupID: "g", ID: "1", Role: "voter", Count: 1}) - c.Assert(err, IsNil) + err = manager.SetRule(&Rule{GroupID: "g", ID: "1", Role: "voter", Count: 1}) + re.NoError(err) g1 := &RuleGroup{ID: "g"} - c.Assert(s.manager.GetRuleGroup("g"), DeepEquals, g1) - c.Assert(s.manager.GetRuleGroups(), DeepEquals, []*RuleGroup{g1, pd2}) + re.Equal(g1, manager.GetRuleGroup("g")) + re.Equal([]*RuleGroup{g1, pd2}, manager.GetRuleGroups()) // update group g g2 := &RuleGroup{ID: "g", Index: 2, Override: true} - err = s.manager.SetRuleGroup(g2) - c.Assert(err, IsNil) - c.Assert(s.manager.GetRuleGroups(), DeepEquals, []*RuleGroup{g2, pd2}) + err = manager.SetRuleGroup(g2) + re.NoError(err) + re.Equal([]*RuleGroup{g2, pd2}, manager.GetRuleGroups()) // delete pd group, restore to default config - err = s.manager.DeleteRuleGroup("pd") - c.Assert(err, IsNil) - c.Assert(s.manager.GetRuleGroups(), DeepEquals, []*RuleGroup{pd1, g2}) + err = manager.DeleteRuleGroup("pd") + re.NoError(err) + re.Equal([]*RuleGroup{pd1, g2}, manager.GetRuleGroups()) // delete rule, the group is removed too - err = s.manager.DeleteRule("pd", "default") - c.Assert(err, IsNil) - c.Assert(s.manager.GetRuleGroups(), DeepEquals, []*RuleGroup{g2}) + err = manager.DeleteRule("pd", "default") + re.NoError(err) + re.Equal([]*RuleGroup{g2}, manager.GetRuleGroups()) } - -func (s *testManagerSuite) TestRuleVersion(c *C) { - // default rule - rule1 := s.manager.GetRule("pd", "default") - c.Assert(rule1.Version, Equals, uint64(0)) +func TestRuleVersion(t *testing.T) { + re := require.New(t) + _, manager := newTestManager(t) + rule1 := manager.GetRule("pd", "default") + re.Equal(uint64(0), rule1.Version) // create new rule newRule := &Rule{GroupID: "g1", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 3} - err := s.manager.SetRule(newRule) - c.Assert(err, IsNil) - newRule = s.manager.GetRule("g1", "id") - c.Assert(newRule.Version, Equals, uint64(0)) + err := manager.SetRule(newRule) + re.NoError(err) + newRule = manager.GetRule("g1", "id") + re.Equal(uint64(0), newRule.Version) // update rule newRule = &Rule{GroupID: "g1", ID: "id", StartKeyHex: "123abc", EndKeyHex: "123abf", Role: "voter", Count: 2} - err = s.manager.SetRule(newRule) - c.Assert(err, IsNil) - newRule = s.manager.GetRule("g1", "id") - c.Assert(newRule.Version, Equals, uint64(1)) + err = manager.SetRule(newRule) + re.NoError(err) + newRule = manager.GetRule("g1", "id") + re.Equal(uint64(1), newRule.Version) // delete rule - err = s.manager.DeleteRule("g1", "id") - c.Assert(err, IsNil) + err = manager.DeleteRule("g1", "id") + re.NoError(err) // recreate new rule - err = s.manager.SetRule(newRule) - c.Assert(err, IsNil) + err = manager.SetRule(newRule) + re.NoError(err) // assert version should be 0 again - newRule = s.manager.GetRule("g1", "id") - c.Assert(newRule.Version, Equals, uint64(0)) + newRule = manager.GetRule("g1", "id") + re.Equal(uint64(0), newRule.Version) } - -func (s *testManagerSuite) TestCheckApplyRules(c *C) { +func TestCheckApplyRules(t *testing.T) { + re := require.New(t) err := checkApplyRules([]*Rule{ { Role: Leader, Count: 1, }, }) - c.Assert(err, IsNil) + re.NoError(err) err = checkApplyRules([]*Rule{ { @@ -347,7 +355,7 @@ func (s *testManagerSuite) TestCheckApplyRules(c *C) { Count: 1, }, }) - c.Assert(err, IsNil) + re.NoError(err) err = checkApplyRules([]*Rule{ { @@ -359,7 +367,7 @@ func (s *testManagerSuite) TestCheckApplyRules(c *C) { Count: 1, }, }) - c.Assert(err, IsNil) + re.NoError(err) err = checkApplyRules([]*Rule{ { @@ -367,7 +375,7 @@ func (s *testManagerSuite) TestCheckApplyRules(c *C) { Count: 3, }, }) - c.Assert(err, ErrorMatches, "multiple leader replicas") + re.Regexp("multiple leader replicas", err.Error()) err = checkApplyRules([]*Rule{ { @@ -379,7 +387,7 @@ func (s *testManagerSuite) TestCheckApplyRules(c *C) { Count: 1, }, }) - c.Assert(err, ErrorMatches, "multiple leader replicas") + re.Regexp("multiple leader replicas", err.Error()) err = checkApplyRules([]*Rule{ { @@ -391,10 +399,10 @@ func (s *testManagerSuite) TestCheckApplyRules(c *C) { Count: 1, }, }) - c.Assert(err, ErrorMatches, "needs at least one leader or voter") + re.Regexp("needs at least one leader or voter", err.Error()) } -func (s *testManagerSuite) dhex(hk string) []byte { +func dhex(hk string) []byte { k, err := hex.DecodeString(hk) if err != nil { panic("decode fail") diff --git a/server/schedule/placement/rule_test.go b/server/schedule/placement/rule_test.go index 2e0ea8566c5..94f623ef93d 100644 --- a/server/schedule/placement/rule_test.go +++ b/server/schedule/placement/rule_test.go @@ -17,15 +17,13 @@ package placement import ( "encoding/hex" "math/rand" + "testing" - . "github.com/pingcap/check" + "github.com/stretchr/testify/require" ) -var _ = Suite(&testRuleSuite{}) - -type testRuleSuite struct{} - -func (s *testRuleSuite) TestPrepareRulesForApply(c *C) { +func TestPrepareRulesForApply(t *testing.T) { + re := require.New(t) rules := []*Rule{ {GroupID: "g1", Index: 0, ID: "id5"}, {GroupID: "g1", Index: 0, ID: "id6"}, @@ -56,13 +54,13 @@ func (s *testRuleSuite) TestPrepareRulesForApply(c *C) { sortRules(rules) rules = prepareRulesForApply(rules) - c.Assert(len(rules), Equals, len(expected)) + re.Equal(len(expected), len(rules)) for i := range rules { - c.Assert(rules[i].Key(), Equals, expected[i]) + re.Equal(expected[i], rules[i].Key()) } } - -func (s *testRuleSuite) TestGroupProperties(c *C) { +func TestGroupProperties(t *testing.T) { + re := require.New(t) testCases := []struct { rules []*Rule expect [][2]string @@ -103,15 +101,14 @@ func (s *testRuleSuite) TestGroupProperties(c *C) { rand.Shuffle(len(tc.rules), func(i, j int) { tc.rules[i], tc.rules[j] = tc.rules[j], tc.rules[i] }) sortRules(tc.rules) rules := prepareRulesForApply(tc.rules) - c.Assert(rules, HasLen, len(tc.expect)) + re.Len(rules, len(tc.expect)) for i := range rules { - c.Assert(rules[i].Key(), Equals, tc.expect[i]) + re.Equal(tc.expect[i], rules[i].Key()) } } } - -// TODO: fulfill unit test case to cover BuildRuleList -func (s *testRuleSuite) TestBuildRuleList(c *C) { +func TestBuildRuleList(t *testing.T) { + re := require.New(t) defaultRule := &Rule{ GroupID: "pd", ID: "default", @@ -121,9 +118,9 @@ func (s *testRuleSuite) TestBuildRuleList(c *C) { Count: 3, } byteStart, err := hex.DecodeString("a1") - c.Check(err, IsNil) + re.NoError(err) byteEnd, err := hex.DecodeString("a2") - c.Check(err, IsNil) + re.NoError(err) ruleMeta := &Rule{ GroupID: "pd", ID: "meta", @@ -182,10 +179,10 @@ func (s *testRuleSuite) TestBuildRuleList(c *C) { } for _, testcase := range testcases { - c.Log(testcase.name) + t.Log(testcase.name) config := &ruleConfig{rules: testcase.rules} result, err := buildRuleList(config) - c.Assert(err, IsNil) - c.Assert(result.ranges, DeepEquals, testcase.expect.ranges) + re.NoError(err) + re.Equal(testcase.expect.ranges, result.ranges) } }