domain: migrate test-infra to testify (part 0)

domain/db_test.go

@@ -15,49 +15,43 @@ package domain_test
 
 import (
 	"context"
+	"testing"
 	"time"
 
-	. "github.com/pingcap/check"
 	"github.com/pingcap/tidb/session"
 	"github.com/pingcap/tidb/store/mockstore"
-	"github.com/pingcap/tidb/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-type dbTestSuite struct{}
+func TestIntegration(t *testing.T) {
+	t.Parallel()
 
-var _ = Suite(&dbTestSuite{})
-
-func (ts *dbTestSuite) TestIntegration(c *C) {
-	testleak.BeforeTest()
-	defer testleak.AfterTest(c)()
-	var err error
 	lease := 50 * time.Millisecond
 	store, err := mockstore.NewMockStore()
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer func() {
 		err := store.Close()
-		c.Assert(err, IsNil)
+		require.NoError(t, err)
 	}()
 	session.SetSchemaLease(lease)
 	domain, err := session.BootstrapSession(store)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	defer domain.Close()
 
 	// for NotifyUpdatePrivilege
 	createRoleSQL := `CREATE ROLE 'test'@'localhost';`
 	se, err := session.CreateSession4Test(store)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	_, err = se.Execute(context.Background(), createRoleSQL)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	// for BindHandle
 	_, err = se.Execute(context.Background(), "use test")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	_, err = se.Execute(context.Background(), "drop table if exists t")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	_, err = se.Execute(context.Background(), "create table t(i int, s varchar(20), index index_t(i, s))")
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 	_, err = se.Execute(context.Background(), "create global binding for select * from t where i>100 using select * from t use index(index_t) where i>100")
-	c.Assert(err, IsNil)
-	c.Assert(err, IsNil, Commentf("err %v", err))
+	require.NoError(t, err)
 }

domain/domainctx_test.go

@@ -14,27 +14,23 @@
 package domain
 
 import (
-	. "github.com/pingcap/check"
+	"testing"
+
 	"github.com/pingcap/tidb/util/mock"
-	"github.com/pingcap/tidb/util/testleak"
+	"github.com/stretchr/testify/require"
 )
 
-var _ = Suite(&testDomainCtxSuite{})
-
-type testDomainCtxSuite struct {
-}
+func TestDomainCtx(t *testing.T) {
+	t.Parallel()
 
-func (s *testDomainCtxSuite) TestDomain(c *C) {
-	defer testleak.AfterTest(c)()
 	ctx := mock.NewContext()
-
-	c.Assert(domainKey.String(), Not(Equals), "")
+	require.NotEqual(t, "", domainKey.String())
 
 	BindDomain(ctx, nil)
 	v := GetDomain(ctx)
-	c.Assert(v, IsNil)
+	require.Nil(t, v)
 
 	ctx.ClearValue(domainKey)
 	v = GetDomain(ctx)
-	c.Assert(v, IsNil)
+	require.Nil(t, v)
 }

domain/main_test.go

@@ -0,0 +1,30 @@
+// Copyright 2021 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package domain
+
+import (
+	"testing"
+
+	"github.com/pingcap/tidb/util/testbridge"
+	"go.uber.org/goleak"
+)
+
+func TestMain(m *testing.M) {
+	testbridge.WorkaroundGoCheckFlags()
+	opts := []goleak.Option{
+		goleak.IgnoreTopFunction("go.etcd.io/etcd/pkg/logutil.(*MergeLogger).outputLoop"),
+		goleak.IgnoreTopFunction("go.opencensus.io/stats/view.(*worker).start"),
+	}
+	goleak.VerifyTestMain(m, opts...)
+}

domain/schema_checker_test.go

@@ -14,14 +14,17 @@
 package domain
 
 import (
+	"testing"
 	"time"
 
-	. "github.com/pingcap/check"
 	"github.com/pingcap/parser/terror"
+	"github.com/stretchr/testify/require"
 	"github.com/tikv/client-go/v2/tikv"
 )
 
-func (s *testSuite) TestSchemaCheckerSimple(c *C) {
+func TestSchemaCheckerSimple(t *testing.T) {
+	t.Parallel()
+
 	lease := 5 * time.Millisecond
 	validator := NewSchemaValidator(lease, nil)
 	checker := &SchemaChecker{SchemaValidator: validator}
@@ -34,32 +37,35 @@ func (s *testSuite) TestSchemaCheckerSimple(c *C) {
 	// checker's schema version is the same as the current schema version.
 	checker.schemaVer = 4
 	_, err := checker.Check(ts)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
 
 	// checker's schema version is less than the current schema version, and it doesn't exist in validator's items.
 	// checker's related table ID isn't in validator's changed table IDs.
 	checker.schemaVer = 2
 	checker.relatedTableIDs = []int64{3}
 	_, err = checker.Check(ts)
-	c.Assert(err, IsNil)
+	require.NoError(t, err)
+
 	// The checker's schema version isn't in validator's items.
 	checker.schemaVer = 1
 	checker.relatedTableIDs = []int64{3}
 	_, err = checker.Check(ts)
-	c.Assert(terror.ErrorEqual(err, ErrInfoSchemaChanged), IsTrue)
+	require.True(t, terror.ErrorEqual(err, ErrInfoSchemaChanged))
+
 	// checker's related table ID is in validator's changed table IDs.
 	checker.relatedTableIDs = []int64{2}
 	_, err = checker.Check(ts)
-	c.Assert(terror.ErrorEqual(err, ErrInfoSchemaChanged), IsTrue)
+	require.True(t, terror.ErrorEqual(err, ErrInfoSchemaChanged))
 
 	// validator's latest schema version is expired.
 	time.Sleep(lease + time.Microsecond)
 	checker.schemaVer = 4
 	checker.relatedTableIDs = []int64{3}
 	_, err = checker.Check(ts)
-	c.Assert(err, IsNil)
-	nowTS := uint64(time.Now().UnixNano())
+	require.NoError(t, err)
+
 	// Use checker.SchemaValidator.Check instead of checker.Check here because backoff make CI slow.
+	nowTS := uint64(time.Now().UnixNano())
 	_, result := checker.SchemaValidator.Check(nowTS, checker.schemaVer, checker.relatedTableIDs)
-	c.Assert(result, Equals, ResultUnknown)
+	require.Equal(t, ResultUnknown, result)
 }

domain/topn_slow_query_test.go

@@ -14,16 +14,15 @@
 package domain
 
 import (
+	"testing"
 	"time"
 
-	. "github.com/pingcap/check"
+	"github.com/stretchr/testify/require"
 )
 
-var _ = Suite(&testTopNSlowQuerySuite{})
+func TestPush(t *testing.T) {
+	t.Parallel()
 
-type testTopNSlowQuerySuite struct{}
-
-func (t *testTopNSlowQuerySuite) TestPush(c *C) {
 	slowQuery := newTopNSlowQueries(10, 0, 10)
 	// Insert data into the heap.
 	slowQuery.Append(&SlowQueryInfo{Duration: 300 * time.Millisecond})
@@ -36,40 +35,42 @@ func (t *testTopNSlowQuerySuite) TestPush(c *C) {
 	slowQuery.Append(&SlowQueryInfo{Duration: 1000 * time.Millisecond})
 	slowQuery.Append(&SlowQueryInfo{Duration: 1100 * time.Millisecond})
 	slowQuery.Append(&SlowQueryInfo{Duration: 1200 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 300*time.Millisecond)
-	checkHeap(&slowQuery.user, c)
+	require.Equal(t, 300*time.Millisecond, slowQuery.user.data[0].Duration)
+	checkHeap(&slowQuery.user, t)
 
 	// Update all data in the heap.
 	slowQuery.Append(&SlowQueryInfo{Duration: 1300 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 400*time.Millisecond)
+	require.Equal(t, 400*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1400 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 500*time.Millisecond)
+	require.Equal(t, 500*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1500 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 600*time.Millisecond)
+	require.Equal(t, 600*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1500 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 700*time.Millisecond)
+	require.Equal(t, 700*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1600 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 800*time.Millisecond)
+	require.Equal(t, 800*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1700 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 900*time.Millisecond)
+	require.Equal(t, 900*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1800 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1000*time.Millisecond)
+	require.Equal(t, 1000*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 1900 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1100*time.Millisecond)
+	require.Equal(t, 1100*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 2000 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1200*time.Millisecond)
+	require.Equal(t, 1200*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 2100 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1300*time.Millisecond)
-	checkHeap(&slowQuery.user, c)
+	require.Equal(t, 1300*time.Millisecond, slowQuery.user.data[0].Duration)
+	checkHeap(&slowQuery.user, t)
 
 	// Data smaller than heap top will not be inserted.
 	slowQuery.Append(&SlowQueryInfo{Duration: 1200 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1300*time.Millisecond)
+	require.Equal(t, 1300*time.Millisecond, slowQuery.user.data[0].Duration)
 	slowQuery.Append(&SlowQueryInfo{Duration: 666 * time.Millisecond})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 1300*time.Millisecond)
+	require.Equal(t, 1300*time.Millisecond, slowQuery.user.data[0].Duration)
 }
 
-func (t *testTopNSlowQuerySuite) TestRemoveExpired(c *C) {
+func TestRemoveExpired(t *testing.T) {
+	t.Parallel()
+
 	now := time.Now()
 	slowQuery := newTopNSlowQueries(6, 3*time.Second, 10)
 
@@ -78,66 +79,71 @@ func (t *testTopNSlowQuerySuite) TestRemoveExpired(c *C) {
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(2 * time.Second), Duration: 4})
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(3 * time.Second), Duration: 3})
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(4 * time.Second), Duration: 2})
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 2*time.Nanosecond)
+	require.Equal(t, 2*time.Nanosecond, slowQuery.user.data[0].Duration)
 
 	slowQuery.RemoveExpired(now.Add(5 * time.Second))
-	c.Assert(len(slowQuery.user.data), Equals, 2)
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 2*time.Nanosecond)
+	require.Len(t, slowQuery.user.data, 2)
+	require.Equal(t, 2*time.Nanosecond, slowQuery.user.data[0].Duration)
 
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(3 * time.Second), Duration: 3})
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(4 * time.Second), Duration: 2})
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(5 * time.Second), Duration: 1})
 	slowQuery.Append(&SlowQueryInfo{Start: now.Add(6 * time.Second), Duration: 0})
-	c.Assert(len(slowQuery.user.data), Equals, 6)
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 0*time.Nanosecond)
+	require.Len(t, slowQuery.user.data, 6)
+	require.Equal(t, 0*time.Nanosecond, slowQuery.user.data[0].Duration)
 
 	slowQuery.RemoveExpired(now.Add(6 * time.Second))
-	c.Assert(len(slowQuery.user.data), Equals, 4)
-	c.Assert(slowQuery.user.data[0].Duration, Equals, 0*time.Nanosecond)
+	require.Len(t, slowQuery.user.data, 4)
+	require.Equal(t, 0*time.Nanosecond, slowQuery.user.data[0].Duration)
 }
 
-func checkHeap(q *slowQueryHeap, c *C) {
-	for i := 0; i < len(q.data); i++ {
-		left := 2*i + 1
-		right := 2*i + 2
-		if left < len(q.data) {
-			c.Assert(q.data[i].Duration, LessEqual, q.data[left].Duration)
-		}
-		if right < len(q.data) {
-			c.Assert(q.data[i].Duration, LessEqual, q.data[right].Duration)
-		}
-	}
-}
+func TestQueue(t *testing.T) {
+	t.Parallel()
 
-func (t *testTopNSlowQuerySuite) TestQueue(c *C) {
 	q := newTopNSlowQueries(10, time.Minute, 5)
 	q.Append(&SlowQueryInfo{SQL: "aaa"})
 	q.Append(&SlowQueryInfo{SQL: "bbb"})
 	q.Append(&SlowQueryInfo{SQL: "ccc"})
 
 	query := q.recent.Query(1)
-	c.Assert(query[0].SQL, Equals, "ccc")
+	require.Equal(t, "ccc", query[0].SQL)
+
 	query = q.recent.Query(2)
-	c.Assert(query[0].SQL, Equals, "ccc")
-	c.Assert(query[1].SQL, Equals, "bbb")
+	require.Equal(t, "ccc", query[0].SQL)
+	require.Equal(t, "bbb", query[1].SQL)
+
 	query = q.recent.Query(6)
-	c.Assert(query[0].SQL, Equals, "ccc")
-	c.Assert(query[1].SQL, Equals, "bbb")
-	c.Assert(query[2].SQL, Equals, "aaa")
+	require.Equal(t, "ccc", query[0].SQL)
+	require.Equal(t, "bbb", query[1].SQL)
+	require.Equal(t, "aaa", query[2].SQL)
 
 	q.Append(&SlowQueryInfo{SQL: "ddd"})
 	q.Append(&SlowQueryInfo{SQL: "eee"})
 	q.Append(&SlowQueryInfo{SQL: "fff"})
 	q.Append(&SlowQueryInfo{SQL: "ggg"})
 
 	query = q.recent.Query(3)
-	c.Assert(query[0].SQL, Equals, "ggg")
-	c.Assert(query[1].SQL, Equals, "fff")
-	c.Assert(query[2].SQL, Equals, "eee")
+	require.Equal(t, "ggg", query[0].SQL)
+	require.Equal(t, "fff", query[1].SQL)
+	require.Equal(t, "eee", query[2].SQL)
+
 	query = q.recent.Query(6)
-	c.Assert(query[0].SQL, Equals, "ggg")
-	c.Assert(query[1].SQL, Equals, "fff")
-	c.Assert(query[2].SQL, Equals, "eee")
-	c.Assert(query[3].SQL, Equals, "ddd")
-	c.Assert(query[4].SQL, Equals, "ccc")
+	require.Equal(t, "ggg", query[0].SQL)
+	require.Equal(t, "fff", query[1].SQL)
+	require.Equal(t, "eee", query[2].SQL)
+	require.Equal(t, "ddd", query[3].SQL)
+	require.Equal(t, "ccc", query[4].SQL)
+}
+
+func checkHeap(q *slowQueryHeap, t *testing.T) {
+	for i := 0; i < len(q.data); i++ {
+		left := 2*i + 1
+		right := 2*i + 2
+		if left < len(q.data) {
+			require.LessOrEqual(t, q.data[i].Duration, q.data[left].Duration)
+		}
+		if right < len(q.data) {
+			require.LessOrEqual(t, q.data[i].Duration, q.data[right].Duration)
+		}
+	}
 }