diff --git a/executor/distsql_test.go b/executor/distsql_test.go index a832b8913f66c..0d1e3a2df5bf2 100644 --- a/executor/distsql_test.go +++ b/executor/distsql_test.go @@ -21,23 +21,26 @@ import ( "math/rand" "runtime/pprof" "strings" + "testing" "time" - . "github.com/pingcap/check" "github.com/pingcap/tidb/domain" "github.com/pingcap/tidb/executor" "github.com/pingcap/tidb/kv" "github.com/pingcap/tidb/parser/model" + "github.com/pingcap/tidb/session" "github.com/pingcap/tidb/store/copr" + "github.com/pingcap/tidb/store/mockstore" "github.com/pingcap/tidb/table/tables" "github.com/pingcap/tidb/tablecodec" + "github.com/pingcap/tidb/testkit" "github.com/pingcap/tidb/types" "github.com/pingcap/tidb/util/israce" "github.com/pingcap/tidb/util/mock" - "github.com/pingcap/tidb/util/testkit" + "github.com/stretchr/testify/require" + "github.com/tikv/client-go/v2/testutils" ) -// nolint:unused func checkGoroutineExists(keyword string) bool { buf := new(bytes.Buffer) profile := pprof.Lookup("goroutine") @@ -49,13 +52,21 @@ func checkGoroutineExists(keyword string) bool { return strings.Contains(str, keyword) } -func (s *testSuite3) TestCopClientSend(c *C) { - c.Skip("not stable") - if _, ok := s.store.GetClient().(*copr.CopClient); !ok { +func TestCopClientSend(t *testing.T) { + t.Parallel() + t.Skip("not stable") + var cluster testutils.Cluster + store, clean := testkit.CreateMockStore(t, mockstore.WithClusterInspector(func(c testutils.Cluster) { + mockstore.BootstrapWithSingleStore(c) + cluster = c + })) + defer clean() + if _, ok := store.GetClient().(*copr.CopClient); !ok { // Make sure the store is tikv store. return } - tk := testkit.NewTestKit(c, s.store) + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("create table copclient (id int primary key)") @@ -67,53 +78,53 @@ func (s *testSuite3) TestCopClientSend(c *C) { tk.MustExec("insert copclient values " + strings.Join(values, ",")) // Get table ID for split. - dom := domain.GetDomain(tk.Se) + dom := domain.GetDomain(tk.Session()) is := dom.InfoSchema() tbl, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("copclient")) - c.Assert(err, IsNil) + require.NoError(t, err) tblID := tbl.Meta().ID // Split the table. tableStart := tablecodec.GenTableRecordPrefix(tblID) - s.cluster.SplitKeys(tableStart, tableStart.PrefixNext(), 100) + cluster.SplitKeys(tableStart, tableStart.PrefixNext(), 100) ctx := context.Background() // Send coprocessor request when the table split. rs, err := tk.Exec("select sum(id) from copclient") - c.Assert(err, IsNil) + require.NoError(t, err) req := rs.NewChunk(nil) err = rs.Next(ctx, req) - c.Assert(err, IsNil) - c.Assert(req.GetRow(0).GetMyDecimal(0).String(), Equals, "499500") - c.Assert(rs.Close(), IsNil) + require.NoError(t, err) + require.Equal(t, "499500", req.GetRow(0).GetMyDecimal(0).String()) + require.NoError(t, rs.Close()) // Split one region. key := tablecodec.EncodeRowKeyWithHandle(tblID, kv.IntHandle(500)) - region, _ := s.cluster.GetRegionByKey(key) - peerID := s.cluster.AllocID() - s.cluster.Split(region.GetId(), s.cluster.AllocID(), key, []uint64{peerID}, peerID) + region, _ := cluster.GetRegionByKey(key) + peerID := cluster.AllocID() + cluster.Split(region.GetId(), cluster.AllocID(), key, []uint64{peerID}, peerID) // Check again. rs, err = tk.Exec("select sum(id) from copclient") - c.Assert(err, IsNil) + require.NoError(t, err) req = rs.NewChunk(nil) err = rs.Next(ctx, req) - c.Assert(err, IsNil) - c.Assert(req.GetRow(0).GetMyDecimal(0).String(), Equals, "499500") - c.Assert(rs.Close(), IsNil) + require.NoError(t, err) + require.Equal(t, "499500", req.GetRow(0).GetMyDecimal(0).String()) + require.NoError(t, rs.Close()) // Check there is no goroutine leak. rs, err = tk.Exec("select * from copclient order by id") - c.Assert(err, IsNil) + require.NoError(t, err) req = rs.NewChunk(nil) err = rs.Next(ctx, req) - c.Assert(err, IsNil) - c.Assert(rs.Close(), IsNil) + require.NoError(t, err) + require.NoError(t, rs.Close()) keyword := "(*copIterator).work" - c.Check(checkGoroutineExists(keyword), IsFalse) + require.False(t, checkGoroutineExists(keyword)) } -func (s *testSuite3) TestGetLackHandles(c *C) { +func TestGetLackHandles(t *testing.T) { expectedHandles := []kv.Handle{kv.IntHandle(1), kv.IntHandle(2), kv.IntHandle(3), kv.IntHandle(4), kv.IntHandle(5), kv.IntHandle(6), kv.IntHandle(7), kv.IntHandle(8), kv.IntHandle(9), kv.IntHandle(10)} handlesMap := kv.NewHandleMap() @@ -124,8 +135,8 @@ func (s *testSuite3) TestGetLackHandles(c *C) { // expected handles 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 // obtained handles 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 diffHandles := executor.GetLackHandles(expectedHandles, handlesMap) - c.Assert(diffHandles, HasLen, 0) - c.Assert(handlesMap.Len(), Equals, 0) + require.Len(t, diffHandles, 0) + require.Equal(t, 0, handlesMap.Len()) // expected handles 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 // obtained handles 2, 3, 4, 6, 7, 8, 9 @@ -136,19 +147,27 @@ func (s *testSuite3) TestGetLackHandles(c *C) { handlesMap.Set(kv.IntHandle(5), true) handlesMap.Set(kv.IntHandle(10), true) diffHandles = executor.GetLackHandles(expectedHandles, handlesMap) - c.Assert(retHandles, DeepEquals, diffHandles) + require.Equal(t, diffHandles, retHandles) // deep equal } -func (s *testSuite3) TestBigIntPK(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestBigIntPK(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("create table t(a bigint unsigned primary key, b int, c int, index idx(a, b))") tk.MustExec("insert into t values(1, 1, 1), (9223372036854775807, 2, 2)") tk.MustQuery("select * from t use index(idx) order by a").Check(testkit.Rows("1 1 1", "9223372036854775807 2 2")) } -func (s *testSuite3) TestCorColToRanges(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestCorColToRanges(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("set sql_mode='STRICT_TRANS_TABLES'") // disable only-full-group-by tk.MustExec("drop table if exists t") @@ -163,8 +182,12 @@ func (s *testSuite3) TestCorColToRanges(c *C) { tk.MustQuery("select t.c in (select count(*) from t s use index(idx), t t1 where s.b = t.a and s.c = t1.a) from t order by 1 desc").Check(testkit.Rows("1", "0", "0", "0", "0", "0", "0", "0", "0")) } -func (s *testSuiteP1) TestUniqueKeyNullValueSelect(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestUniqueKeyNullValueSelect(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists t") // test null in unique-key @@ -189,8 +212,12 @@ func (s *testSuiteP1) TestUniqueKeyNullValueSelect(c *C) { } // TestIssue10178 contains tests for https://github.com/pingcap/tidb/issues/10178 . -func (s *testSuite3) TestIssue10178(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestIssue10178(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists t") tk.MustExec("create table t(a bigint unsigned primary key)") @@ -200,58 +227,67 @@ func (s *testSuite3) TestIssue10178(c *C) { tk.MustQuery("select * from t where a < 9223372036854775808").Check(testkit.Rows("9223372036854775807")) } -func (s *testSuite3) TestInconsistentIndex(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestInconsistentIndex(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + dom, err := session.BootstrapSession(store) + require.NoError(t, err) + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists t") tk.MustExec("create table t(a int, b int, index idx_a(a))") - is := s.domain.InfoSchema() + is := dom.InfoSchema() tbl, err := is.TableByName(model.NewCIStr("test"), model.NewCIStr("t")) - c.Assert(err, IsNil) + require.NoError(t, err) idx := tbl.Meta().FindIndexByName("idx_a") idxOp := tables.NewIndex(tbl.Meta().ID, tbl.Meta(), idx) ctx := mock.NewContext() - ctx.Store = s.store + ctx.Store = store for i := 0; i < 10; i++ { tk.MustExec(fmt.Sprintf("insert into t values (%d, %d)", i+10, i)) - c.Assert(tk.QueryToErr("select * from t where a>=0"), IsNil) + require.NoError(t, tk.QueryToErr("select * from t where a>=0")) } for i := 0; i < 10; i++ { tk.MustExec(fmt.Sprintf("update t set a=%d where a=%d", i, i+10)) - c.Assert(tk.QueryToErr("select * from t where a>=0"), IsNil) + require.NoError(t, tk.QueryToErr("select * from t where a>=0")) } for i := 0; i < 10; i++ { - txn, err := s.store.Begin() - c.Assert(err, IsNil) + txn, err := store.Begin() + require.NoError(t, err) _, err = idxOp.Create(ctx, txn, types.MakeDatums(i+10), kv.IntHandle(100+i), nil) - c.Assert(err, IsNil) + require.NoError(t, err) err = txn.Commit(context.Background()) - c.Assert(err, IsNil) + require.NoError(t, err) err = tk.QueryToErr("select * from t use index(idx_a) where a >= 0") - c.Assert(err.Error(), Equals, fmt.Sprintf("inconsistent index idx_a handle count %d isn't equal to value count 10", i+11)) - + require.Equal(t, fmt.Sprintf("inconsistent index idx_a handle count %d isn't equal to value count 10", i+11), err.Error()) // if has other conditions, the inconsistent index check doesn't work. err = tk.QueryToErr("select * from t where a>=0 and b<10") - c.Assert(err, IsNil) + require.NoError(t, err) } // fix inconsistent problem to pass CI for i := 0; i < 10; i++ { - txn, err := s.store.Begin() - c.Assert(err, IsNil) + txn, err := store.Begin() + require.NoError(t, err) err = idxOp.Delete(ctx.GetSessionVars().StmtCtx, txn, types.MakeDatums(i+10), kv.IntHandle(100+i)) - c.Assert(err, IsNil) + require.NoError(t, err) err = txn.Commit(context.Background()) - c.Assert(err, IsNil) + require.NoError(t, err) } } -func (s *testSuite3) TestPushLimitDownIndexLookUpReader(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestPushLimitDownIndexLookUpReader(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists tbl") tk.MustExec("create table tbl(a int, b int, c int, key idx_b_c(b,c))") @@ -265,8 +301,12 @@ func (s *testSuite3) TestPushLimitDownIndexLookUpReader(c *C) { tk.MustQuery("select * from tbl use index(idx_b_c) where b > 1 and c > 1 limit 2,1").Check(testkit.Rows("4 4 4")) } -func (s *testSuite3) TestPartitionTableIndexLookUpReader(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestPartitionTableIndexLookUpReader(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists t") tk.MustExec(`create table t (a int, b int, key(a)) @@ -289,11 +329,15 @@ func (s *testSuite3) TestPartitionTableIndexLookUpReader(c *C) { tk.MustQuery("select * from t where a>=1 and a<15 order by a limit 3").Check(testkit.Rows("1 1", "2 2", "11 11")) } -func (s *testSuite3) TestPartitionTableRandomlyIndexLookUpReader(c *C) { +func TestPartitionTableRandomlyIndexLookUpReader(t *testing.T) { if israce.RaceEnabled { - c.Skip("exhaustive types test, skip race test") + t.Skip("exhaustive types test, skip race test") } - tk := testkit.NewTestKit(c, s.store) + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists t") tk.MustExec(`create table t (a int, b int, key(a)) @@ -326,7 +370,7 @@ func (s *testSuite3) TestPartitionTableRandomlyIndexLookUpReader(c *C) { } } -func (s *testSuite3) TestIndexLookUpStats(c *C) { +func TestIndexLookUpStats(t *testing.T) { stats := &executor.IndexLookUpRunTimeStats{ FetchHandleTotal: int64(5 * time.Second), FetchHandle: int64(2 * time.Second), @@ -335,14 +379,18 @@ func (s *testSuite3) TestIndexLookUpStats(c *C) { TableTaskNum: 2, Concurrency: 1, } - c.Assert(stats.String(), Equals, "index_task: {total_time: 5s, fetch_handle: 2s, build: 1s, wait: 2s}, table_task: {total_time: 2s, num: 2, concurrency: 1}") - c.Assert(stats.String(), Equals, stats.Clone().String()) + require.Equal(t, "index_task: {total_time: 5s, fetch_handle: 2s, build: 1s, wait: 2s}, table_task: {total_time: 2s, num: 2, concurrency: 1}", stats.String()) + require.Equal(t, stats.Clone().String(), stats.String()) stats.Merge(stats.Clone()) - c.Assert(stats.String(), Equals, "index_task: {total_time: 10s, fetch_handle: 4s, build: 2s, wait: 4s}, table_task: {total_time: 4s, num: 4, concurrency: 2}") + require.Equal(t, "index_task: {total_time: 10s, fetch_handle: 4s, build: 2s, wait: 4s}, table_task: {total_time: 4s, num: 4, concurrency: 2}", stats.String()) } -func (s *testSuite3) TestIndexLookUpGetResultChunk(c *C) { - tk := testkit.NewTestKit(c, s.store) +func TestIndexLookUpGetResultChunk(t *testing.T) { + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("drop table if exists tbl") tk.MustExec("create table tbl(a int, b int, c int, key idx_a(a))") @@ -353,11 +401,15 @@ func (s *testSuite3) TestIndexLookUpGetResultChunk(c *C) { tk.MustQuery("select * from tbl use index(idx_a) where a > 10 order by a asc limit 4,1").Check(testkit.Rows("15 15 15")) } -func (s *testSuite3) TestPartitionTableIndexJoinIndexLookUp(c *C) { +func TestPartitionTableIndexJoinIndexLookUp(t *testing.T) { if israce.RaceEnabled { - c.Skip("exhaustive types test, skip race test") + t.Skip("exhaustive types test, skip race test") } - tk := testkit.NewTestKit(c, s.store) + t.Parallel() + store, clean := testkit.CreateMockStore(t) + defer clean() + tk := testkit.NewTestKit(t, store) + tk.MustExec("use test") tk.MustExec("set @@tidb_partition_prune_mode='dynamic'") tk.MustExec(`create table t (a int, b int, key(a)) partition by hash(a) partitions 4`)