tests: use TiDB-like keys in next-gen integration tests (tikv#2010) (tikv#2031)

 \n\nSigned-off-by: ti-chi-bot <ti-community-prow-bot@tidb.io>\nSigned-off-by: Chao Wang <cclcwangchao@hotmail.com>\n\nCo-authored-by: Ziqian Qin <eke@fastmail.com>\nCo-authored-by: Chao Wang <cclcwangchao@hotmail.com>

Author: ti-chi-bot

.github/workflows/integration.yml

@@ -133,63 +133,3 @@ jobs:
       - name: Test
         run: gotestsum --format short-verbose -- --with-tikv
         working-directory: integration_tests/raw
-
-  integration-next-gen-tikv:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip-integration-tests') && !startsWith(github.ref_name, 'release-') && !startsWith(github.base_ref, 'release-') }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: 1.25.8
-
-      - name: Install gotestsum
-        run: go install gotest.tools/gotestsum@latest
-
-      - name: Fetch PD
-        uses: shrink/actions-docker-extract@v1
-        id: extract-pd
-        with:
-          image: pingcap/pd:nightly
-          path: /pd-server
-
-      - name: Fetch Next-Gen TiKV
-        uses: shrink/actions-docker-extract@v1
-        id: extract-tikv
-        with:
-          image: gcr.io/pingcap-public/dbaas/tikv:dedicated-next-gen
-          path: /tikv-server
-
-      - name: Run MinIO, PD & Next-Gen TiKV
-        run: |
-          mkdir -p tikv-data
-          # Install and run minio for S3 backend
-          curl -Lo minio https://dl.min.io/server/minio/release/linux-amd64/minio
-          chmod +x minio
-          mkdir -p $HOME/serverless_s3/cse-test
-          MINIO_ROOT_USER=minioadmin MINIO_ROOT_PASSWORD=minioadmin ./minio server $HOME/serverless_s3 > minio.log 2>&1 &
-          sleep 5
-          # Move binaries and run servers
-          mv ../${{steps.extract-pd.outputs.destination}}/pd-server .
-          mv ../${{steps.extract-tikv.outputs.destination}}/tikv-server .
-          ./pd-server --config pd_next_gen.toml > pd.log 2>&1 &
-          sleep 5
-          ./tikv-server -C tikv_next_gen.toml --pd-endpoints="127.0.0.1:2379" --addr="127.0.0.1:20160" --data-dir=${{ github.workspace }}/integration_tests/tikv-data > tikv.log 2>&1 &
-          
-          echo "Waiting for servers to start..."
-          sleep 15
-
-          echo "--- MinIO Log ---"
-          tail minio.log || echo "minio.log not found"
-          echo "--- PD Log ---"
-          tail pd.log || echo "pd.log not found"
-          echo "--- TiKV Log ---"
-          tail tikv.log || echo "tikv.log not found"
-        working-directory: integration_tests
-
-      - name: Test
-        run: gotestsum --format short-verbose -- -parallel 1 -tags=nextgen --with-tikv --keyspace-name='keyspace1'
-        working-directory: integration_tests

AGENTS.md

@@ -25,14 +25,16 @@ Prefer existing error, retry, backoff, logging, metrics, and failpoint helpers i
 
 ## API v2 Codec Guidelines
 
-All API v2 commands that carry keys must have complete and consistent encode/decode handling in `internal/apicodec`. This includes keys, key ranges, lock information, region errors, and any request or response fields that carry encoded keys. When adding or modifying a key-bearing RPC, update both request and response paths, add table-driven coverage in `internal/apicodec`, and verify that encode/decode behavior is symmetric. Missing or one-sided handling can create key-format mismatches and correctness bugs, especially across TiKV and CSE paths.
+All API v2 commands that carry keys must have complete and consistent encode/decode handling in `internal/apicodec`. This includes keys, key ranges, lock information, region errors, and any request or response fields that carry encoded keys. When adding or modifying a key-bearing RPC, update both request and response paths, add table-driven coverage in `internal/apicodec`, and verify that encode/decode behavior is symmetric. Missing or one-sided handling can create key-format mismatches and correctness bugs, especially across TiKV and CSE paths. When adding or modifying a `tikvrpc.Cmd*` whose request has a context field, update `tikvrpc/gen.sh`, regenerate `tikvrpc/cmds_generated.go`, and add `AttachContext` coverage.
 
 ## Testing Guidelines
 
 Use Go's `testing` package with `testify/require`, `testify/assert`, and `testify/suite`, matching nearby tests. Name tests `TestXxx` and keep suite types in the existing lowercase style, such as `testRawkvSuite` or `testSnapshotSuite`.
 
 Add or update package-level tests for every behavior change. Use `integration_tests/` when behavior depends on TiKV, PD, transactions, lock resolution, failpoints, or API-version behavior that mocks cannot cover. For concurrency-sensitive changes, run the race command before opening a PR.
 
+CSE is only used behind TiDB. Transactional integration tests that run against next-gen/CSE should generate keys through a TiDB-like mem-comparable helper such as `encodeKey(...)`, not raw ad-hoc keys like `[]byte("k")`. For split/range/order-sensitive tests, update data keys, split keys, range bounds, and expected keys together.
+
 ## Commit & Pull Request Guidelines
 
 Recent commits use concise, imperative subjects scoped by package or area, for example `apicodec: cover remaining API v2 key-bearing commands` or `txnkv: enable TiKV-side async resolve region lock for read path`. Follow that pattern and reference issues or PRs when relevant. This repository has DCO checks enabled; create commits with `git commit -s` so the commit message includes the required `Signed-off-by` trailer.

integration_tests/1pc_test.go

@@ -64,8 +64,12 @@ func (s *testOnePCSuite) TearDownTest() {
 	s.testAsyncCommitCommon.tearDownTest()
 }
 
+func (s *testOnePCSuite) key(name string) []byte {
+	return encodeKey("~1pc", name)
+}
+
 func (s *testOnePCSuite) Test1PC() {
-	k1 := []byte("k1")
+	k1 := s.key("k1")
 	v1 := []byte("v1")
 
 	txn := s.begin1PC()
@@ -81,7 +85,7 @@ func (s *testOnePCSuite) Test1PC() {
 
 	// 1PC doesn't work if 1PC option is not set
 
-	k2 := []byte("k2")
+	k2 := s.key("k2")
 	v2 := []byte("v2")
 
 	txn = s.begin()
@@ -94,11 +98,11 @@ func (s *testOnePCSuite) Test1PC() {
 	s.Greater(txn.GetCommitter().GetCommitTS(), txn.StartTS())
 
 	// Test multiple keys
-	k3 := []byte("k3")
+	k3 := s.key("k3")
 	v3 := []byte("v3")
-	k4 := []byte("k4")
+	k4 := s.key("k4")
 	v4 := []byte("v4")
-	k5 := []byte("k5")
+	k5 := s.key("k5")
 	v5 := []byte("v5")
 
 	txn = s.begin1PC()
@@ -148,7 +152,7 @@ func (s *testOnePCSuite) Test1PC() {
 }
 
 func (s *testOnePCSuite) Test1PCIsolation() {
-	k := []byte("k")
+	k := s.key("isolation_k")
 	v1 := []byte("v1")
 
 	txn := s.begin1PC()
@@ -189,27 +193,28 @@ func (s *testOnePCSuite) Test1PCDisallowMultiRegion() {
 
 	txn := s.begin1PC()
 
-	keys := []string{"k0", "k1", "k2", "k3"}
+	keyNames := []string{"k0", "k1", "k2", "k3"}
+	keys := [][]byte{s.key(keyNames[0]), s.key(keyNames[1]), s.key(keyNames[2]), s.key(keyNames[3])}
 	values := []string{"v0", "v1", "v2", "v3"}
 
-	err := txn.Set([]byte(keys[0]), []byte(values[0]))
+	err := txn.Set(keys[0], []byte(values[0]))
 	s.Nil(err)
-	err = txn.Set([]byte(keys[3]), []byte(values[3]))
+	err = txn.Set(keys[3], []byte(values[3]))
 	s.Nil(err)
 	err = txn.Commit(context.Background())
 	s.Nil(err)
 
 	// 1PC doesn't work if it affects multiple regions.
-	loc, err := s.store.GetRegionCache().LocateKey(s.bo, []byte(keys[2]))
+	loc, err := s.store.GetRegionCache().LocateKey(s.bo, keys[2])
 	s.Nil(err)
 	newRegionID := s.cluster.AllocID()
 	newPeerID := s.cluster.AllocID()
-	s.cluster.Split(loc.Region.GetID(), newRegionID, []byte(keys[2]), []uint64{newPeerID}, newPeerID)
+	s.cluster.Split(loc.Region.GetID(), newRegionID, keys[2], []uint64{newPeerID}, newPeerID)
 
 	txn = s.begin1PC()
-	err = txn.Set([]byte(keys[1]), []byte(values[1]))
+	err = txn.Set(keys[1], []byte(values[1]))
 	s.Nil(err)
-	err = txn.Set([]byte(keys[2]), []byte(values[2]))
+	err = txn.Set(keys[2], []byte(values[2]))
 	s.Nil(err)
 	err = txn.Commit(context.Background())
 	s.Nil(err)
@@ -221,7 +226,7 @@ func (s *testOnePCSuite) Test1PCDisallowMultiRegion() {
 	s.Nil(err)
 	snap := s.store.GetSnapshot(ver)
 	for i, k := range keys {
-		v, err := snap.Get(context.Background(), []byte(k))
+		v, err := snap.Get(context.Background(), k)
 		s.Nil(err)
 		s.Equal(v.Value, []byte(values[i]))
 	}
@@ -232,9 +237,9 @@ func (s *testOnePCSuite) Test1PCDisallowMultiRegion() {
 func (s *testOnePCSuite) Test1PCLinearizability() {
 	t1 := s.begin()
 	t2 := s.begin()
-	err := t1.Set([]byte("a"), []byte("a1"))
+	err := t1.Set(s.key("linear_a"), []byte("a1"))
 	s.Nil(err)
-	err = t2.Set([]byte("b"), []byte("b1"))
+	err = t2.Set(s.key("linear_b"), []byte("b1"))
 	s.Nil(err)
 	// t2 commits earlier than t1
 	err = t2.Commit(context.Background())
@@ -253,15 +258,15 @@ func (s *testOnePCSuite) Test1PCWithMultiDC() {
 	}
 
 	localTxn := s.begin1PC()
-	err := localTxn.Set([]byte("a"), []byte("a1"))
+	err := localTxn.Set(s.key("multi_dc_a"), []byte("a1"))
 	localTxn.SetScope("bj")
 	s.Nil(err)
 	err = localTxn.Commit(context.Background())
 	s.Nil(err)
 	s.False(localTxn.GetCommitter().IsOnePC())
 
 	globalTxn := s.begin1PC()
-	err = globalTxn.Set([]byte("b"), []byte("b1"))
+	err = globalTxn.Set(s.key("multi_dc_b"), []byte("b1"))
 	globalTxn.SetScope(oracle.GlobalTxnScope)
 	s.Nil(err)
 	err = globalTxn.Commit(context.Background())
@@ -274,7 +279,7 @@ func (s *testOnePCSuite) TestTxnCommitCounter() {
 
 	// 2PC
 	txn := s.begin()
-	err := txn.Set([]byte("k"), []byte("v"))
+	err := txn.Set(s.key("counter_k"), []byte("v"))
 	s.Nil(err)
 	err = txn.Commit(context.Background())
 	s.Nil(err)
@@ -286,7 +291,7 @@ func (s *testOnePCSuite) TestTxnCommitCounter() {
 
 	// AsyncCommit
 	txn = s.beginAsyncCommit()
-	err = txn.Set([]byte("k1"), []byte("v1"))
+	err = txn.Set(s.key("counter_k1"), []byte("v1"))
 	s.Nil(err)
 	err = txn.Commit(context.Background())
 	s.Nil(err)
@@ -298,7 +303,7 @@ func (s *testOnePCSuite) TestTxnCommitCounter() {
 
 	// 1PC
 	txn = s.begin1PC()
-	err = txn.Set([]byte("k2"), []byte("v2"))
+	err = txn.Set(s.key("counter_k2"), []byte("v2"))
 	s.Nil(err)
 	err = txn.Commit(context.Background())
 	s.Nil(err)
@@ -314,7 +319,7 @@ func (s *testOnePCSuite) TestFailWithUndeterminedResult() {
 		s.T().Skip("not supported in real TiKV")
 	}
 	txn := s.begin1PC()
-	s.Nil(txn.Set([]byte("key"), []byte("value")))
+	s.Nil(txn.Set(s.key("undetermined_key"), []byte("value")))
 	s.Nil(failpoint.Enable(
 		"tikvclient/rpcPrewriteResult",
 		// it will make the prewrite in 1pc fail.