tests: fix the rest failed nextgen tests (#9819)

close #9806

Signed-off-by: Ryan Leung <rleungx@gmail.com>

Author: rleungx

pkg/gc/gc_state_manager_test.go

@@ -139,14 +139,22 @@ func newGCStateManagerForTest(t testing.TB, opt newGCStateManagerForTestOptions)
 	err = keyspaceManager.Bootstrap()
 	re.NoError(err)
 
-	// keyspaceID 0 exists automatically after bootstrapping.
+	// The bootstrap keyspace (DefaultKeyspaceID or SystemKeyspaceID) exists automatically after bootstrapping.
 	if opt.specifyInitialKeyspaces == nil {
+		// In NextGen, all keyspaces should use keyspace_level GC
+		// In Classic, we can have different GC management types
+		var ks1Config map[string]string
+		if kerneltype.IsNextGen() {
+			ks1Config = map[string]string{"gc_management_type": "keyspace_level"}
+		} else {
+			ks1Config = map[string]string{"gc_management_type": "unified"}
+		}
 		id := new(uint32)
 		*id = 1
 		ks1, err := keyspaceManager.CreateKeyspaceByID(&keyspace.CreateKeyspaceByIDRequest{
 			ID:         id,
 			Name:       "ks1",
-			Config:     map[string]string{"gc_management_type": "unified"},
+			Config:     ks1Config,
 			CreateTime: time.Now().Unix(),
 		})
 		re.NoError(err)
@@ -196,10 +204,21 @@ func newGCStateManagerForTest(t testing.TB, opt newGCStateManagerForTestOptions)
 func (s *gcStateManagerTestSuite) SetupTest() {
 	s.storage, s.provider, s.manager, s.clean, s.cancel = newGCStateManagerForTest(s.T(), newGCStateManagerForTestOptions{})
 
-	s.keyspacePresets.all = []uint32{constant.NullKeyspaceID, 0, 1, 2, 3}
-	s.keyspacePresets.manageable = []uint32{constant.NullKeyspaceID, 2}
-	s.keyspacePresets.unmanageable = []uint32{0, 1, 3}
-	s.keyspacePresets.unifiedGC = []uint32{constant.NullKeyspaceID, 0, 1, 3}
+	bootstrapKeyspaceID := keyspace.GetBootstrapKeyspaceID()
+	s.keyspacePresets.all = []uint32{constant.NullKeyspaceID, bootstrapKeyspaceID, 1, 2, 3}
+
+	// In NextGen builds, bootstrapKeyspaceID is SystemKeyspaceID (0xFFFFFE) with KeyspaceLevelGC config, so it's manageable.
+	// In Classic builds, bootstrapKeyspaceID is DefaultKeyspaceID (0) without KeyspaceLevelGC config, so it's unmanageable.
+	if kerneltype.IsNextGen() {
+		// NextGen: all keyspaces default to KeyspaceLevelGC
+		s.keyspacePresets.manageable = []uint32{constant.NullKeyspaceID, bootstrapKeyspaceID, 1, 2, 3}
+		s.keyspacePresets.unmanageable = []uint32{}
+		s.keyspacePresets.unifiedGC = []uint32{} // NextGen has no unified GC
+	} else {
+		s.keyspacePresets.manageable = []uint32{constant.NullKeyspaceID, 2}
+		s.keyspacePresets.unmanageable = []uint32{bootstrapKeyspaceID, 1, 3}
+		s.keyspacePresets.unifiedGC = []uint32{constant.NullKeyspaceID, bootstrapKeyspaceID, 1, 3}
+	}
 	s.keyspacePresets.notExisting = []uint32{5, 0xffffff}
 	s.keyspacePresets.nullSynonyms = []uint32{constant.NullKeyspaceID, 0x1000000, 0xfffffffe}
 }
@@ -1883,8 +1902,16 @@ func (s *gcStateManagerTestSuite) TestGetAllKeyspacesMaxTxnSafePoint() {
 	})
 	re.NoError(err)
 	re.Equal(uint64(len(s.keyspacePresets.manageable)), txnSafePoint)
-	re.Equal("ks2", keyspaceName)
-	re.Equal(uint32(2), keyspaceID)
+
+	// In NextGen, all keyspaces are manageable, so the max should be ks3
+	// In Classic, only certain keyspaces are manageable, so the max should be ks2
+	if kerneltype.IsNextGen() {
+		re.Equal("ks3", keyspaceName)
+		re.Equal(uint32(3), keyspaceID)
+	} else {
+		re.Equal("ks2", keyspaceName)
+		re.Equal(uint32(2), keyspaceID)
+	}
 }
 
 func (s *gcStateManagerTestSuite) TestWeakenedConstraints() {

pkg/keyspace/keyspace.go

@@ -250,6 +250,9 @@ func (manager *Manager) CreateKeyspace(request *CreateKeyspaceRequest) (*keyspac
 	}
 	// Set default value of GCManagementType to KeyspaceLevelGC for NextGen
 	if kerneltype.IsNextGen() {
+		if request.Config == nil {
+			request.Config = make(map[string]string)
+		}
 		if v, ok := request.Config[GCManagementType]; !ok || len(v) == 0 {
 			request.Config[GCManagementType] = KeyspaceLevelGC
 		}
@@ -341,6 +344,15 @@ func (manager *Manager) CreateKeyspaceByID(request *CreateKeyspaceByIDRequest) (
 			request.Config[UserKindKey] = config[UserKindKey]
 		}
 	}
+	// Set default value of GCManagementType to KeyspaceLevelGC for NextGen
+	if kerneltype.IsNextGen() {
+		if request.Config == nil {
+			request.Config = make(map[string]string)
+		}
+		if v, ok := request.Config[GCManagementType]; !ok || len(v) == 0 {
+			request.Config[GCManagementType] = KeyspaceLevelGC
+		}
+	}
 	// Create a disabled keyspace meta for tikv-server to get the config on keyspace split.
 	keyspace := &keyspacepb.KeyspaceMeta{
 		Id:             id,

pkg/keyspace/keyspace_test.go

@@ -384,7 +384,7 @@ func (suite *keyspaceTestSuite) TestLoadRangeKeyspace() {
 			}
 		}
 	} else {
-		// For legacy: expect keyspaces [0, 1, 2, ..., 100]
+		// For classic: expect keyspaces [0, 1, 2, ..., 100]
 		for i := range keyspaces {
 			re.Equal(uint32(i), keyspaces[i].Id)
 			if i != 0 {

pkg/keyspace/util.go

@@ -294,7 +294,7 @@ func (hp *indexedHeap) Remove(id uint32) *endpoint.KeyspaceGroup {
 }
 
 // GetBootstrapKeyspaceID returns the Keyspace ID used for bootstrapping.
-// Legacy: constant.DefaultKeyspaceID
+// Classic: constant.DefaultKeyspaceID
 // NextGen: constant.SystemKeyspaceID
 func GetBootstrapKeyspaceID() uint32 {
 	if kerneltype.IsNextGen() {
@@ -304,7 +304,7 @@ func GetBootstrapKeyspaceID() uint32 {
 }
 
 // GetBootstrapKeyspaceName returns the Keyspace Name used for bootstrapping.
-// Legacy: constant.DefaultKeyspaceName
+// Classic: constant.DefaultKeyspaceName
 // NextGen: constant.SystemKeyspaceName
 func GetBootstrapKeyspaceName() string {
 	if kerneltype.IsNextGen() {

pkg/schedule/schedulers/base_scheduler.go

@@ -141,8 +141,12 @@ func (s *BaseScheduler) SetDisable(disable bool) error {
 
 // IsDefault returns if the scheduler is a default scheduler.
 func (s *BaseScheduler) IsDefault() bool {
-	if _, ok := s.conf.(defaultSchedulerConfig); ok {
-		return true
+	// Check if the scheduler is in the current DefaultSchedulers list
+	// which dynamically adjusts based on NextGen vs Classic
+	for _, schedulerType := range types.DefaultSchedulers {
+		if s.tp == schedulerType {
+			return true
+		}
 	}
 	return false
 }

pkg/schedule/schedulers/scheduler_controller.go

@@ -299,7 +299,13 @@ func (c *Controller) ReloadSchedulerConfig(name string) error {
 	if exist, _ := c.IsSchedulerExisted(name); !exist {
 		return errs.ErrSchedulerNotFound.FastGenByArgs()
 	}
-	return c.GetScheduler(name).ReloadConfig()
+	scheduler := c.GetScheduler(name)
+	if scheduler == nil {
+		// Scheduler exists in handlers but not in schedulers map, which means it's a handler-only scheduler
+		// Handler-only schedulers don't have config reloading capability
+		return errs.ErrSchedulerNotFound.FastGenByArgs()
+	}
+	return scheduler.ReloadConfig()
 }
 
 // IsSchedulerAllowed returns whether a scheduler is allowed to schedule, a scheduler is not allowed to schedule if it is paused or blocked by unsafe recovery.

pkg/schedule/schedulers/scheduler_test.go

@@ -525,15 +525,15 @@ func TestIsDefault(t *testing.T) {
 	defer cancel()
 
 	for schedulerType := range types.SchedulerTypeCompatibleMap {
-		bs, err := CreateScheduler(schedulerType, oc,
+		s, err := CreateScheduler(schedulerType, oc,
 			storage.NewStorageWithMemoryBackend(),
 			testDecoder,
 			func(string) error { return nil })
 		re.NoError(err)
 		if slices.Contains(types.DefaultSchedulers, schedulerType) {
-			re.True(bs.IsDefault())
+			re.True(s.IsDefault())
 		} else {
-			re.False(bs.IsDefault())
+			re.False(s.IsDefault())
 		}
 	}
 }

server/cluster/cluster_test.go

@@ -3175,11 +3175,11 @@ func TestAddScheduler(t *testing.T) {
 	defer cleanup()
 	controller := co.GetSchedulersController()
 	re.Len(controller.GetSchedulerNames(), len(sc.DefaultSchedulers))
-	re.NoError(controller.RemoveScheduler(types.BalanceLeaderScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceRegionScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceHotRegionScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictSlowStoreScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictStoppingStoreScheduler.String()))
+	// Remove all default schedulers (dynamically adjusts for NextGen vs Classic)
+	for _, schedulerConfig := range sc.DefaultSchedulers {
+		schedulerType := types.ConvertOldStrToType[schedulerConfig.Type]
+		re.NoError(controller.RemoveScheduler(schedulerType.String()))
+	}
 	re.Empty(controller.GetSchedulerNames())
 
 	stream := mockhbstream.NewHeartbeatStream()
@@ -3287,11 +3287,10 @@ func TestPersistScheduler(t *testing.T) {
 	re.Len(sches, defaultCount+2)
 
 	// remove all default schedulers
-	re.NoError(controller.RemoveScheduler(types.BalanceLeaderScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceRegionScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceHotRegionScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictSlowStoreScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictStoppingStoreScheduler.String()))
+	for _, schedulerConfig := range sc.DefaultSchedulers {
+		schedulerType := types.ConvertOldStrToType[schedulerConfig.Type]
+		re.NoError(controller.RemoveScheduler(schedulerType.String()))
+	}
 	// only remains 2 items with independent config.
 	re.Len(controller.GetSchedulerNames(), 2)
 	re.NoError(co.GetCluster().GetSchedulerConfig().Persist(storage))
@@ -3401,12 +3400,10 @@ func TestRemoveScheduler(t *testing.T) {
 	re.Len(sches, defaultCount+1)
 
 	// remove all schedulers
-	re.NoError(controller.RemoveScheduler(types.BalanceLeaderScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceRegionScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.BalanceHotRegionScheduler.String()))
 	re.NoError(controller.RemoveScheduler(types.GrantLeaderScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictSlowStoreScheduler.String()))
-	re.NoError(controller.RemoveScheduler(types.EvictStoppingStoreScheduler.String()))
+	for _, schedulerType := range types.DefaultSchedulers {
+		re.NoError(controller.RemoveScheduler(schedulerType.String()))
+	}
 	// all removed
 	sches, _, err = storage.LoadAllSchedulerConfigs()
 	re.NoError(err)

tests/integrations/client/http_client_test.go

@@ -47,6 +47,7 @@ import (
 	"github.com/tikv/pd/pkg/utils/testutil"
 	"github.com/tikv/pd/pkg/utils/tsoutil"
 	"github.com/tikv/pd/pkg/versioninfo"
+	"github.com/tikv/pd/pkg/versioninfo/kerneltype"
 	"github.com/tikv/pd/server/api"
 	"github.com/tikv/pd/tests"
 )
@@ -467,7 +468,13 @@ func (suite *httpClientTestSuite) TestRegionLabel() {
 	labelRules, err := client.GetAllRegionLabelRules(ctx)
 	re.NoError(err)
 	re.Len(labelRules, 1)
-	re.Equal("keyspaces/0", labelRules[0].ID)
+
+	// In NextGen, the bootstrap keyspace is SYSTEM with ID 16777214, not DEFAULT with ID 0
+	expectedKeyspaceID := "keyspaces/0"
+	if kerneltype.IsNextGen() {
+		expectedKeyspaceID = "keyspaces/16777214"
+	}
+	re.Equal(expectedKeyspaceID, labelRules[0].ID)
 	// Set a new region label rule.
 	labelRule := &pd.LabelRule{
 		ID:       "rule1",
@@ -512,7 +519,7 @@ func (suite *httpClientTestSuite) TestRegionLabel() {
 	re.NoError(err)
 	re.Len(labelRules, 1)
 	re.Equal(labelRule, labelRules[0])
-	labelRules, err = client.GetRegionLabelRulesByIDs(ctx, []string{"keyspaces/0", "rule2"})
+	labelRules, err = client.GetRegionLabelRulesByIDs(ctx, []string{expectedKeyspaceID, "rule2"})
 	re.NoError(err)
 	sort.Slice(labelRules, func(i, j int) bool {
 		return labelRules[i].ID < labelRules[j].ID
@@ -965,7 +972,13 @@ func (suite *httpClientTestSuite) TestUpdateKeyspaceGCManagementType() {
 	ctx, cancel := context.WithCancel(suite.ctx)
 	defer cancel()
 
-	keyspaceName := constant.DefaultKeyspaceName
+	// Use the correct bootstrap keyspace name based on build type
+	var keyspaceName string
+	if kerneltype.IsNextGen() {
+		keyspaceName = constant.SystemKeyspaceName
+	} else {
+		keyspaceName = constant.DefaultKeyspaceName
+	}
 	expectGCManagementType := "test-type"
 
 	keyspaceSafePointVersionConfig := pd.KeyspaceGCManagementTypeConfig{
@@ -1000,8 +1013,16 @@ func (suite *httpClientTestSuite) TestGetKeyspaceMetaByID() {
 	ctx, cancel := context.WithCancel(suite.ctx)
 	defer cancel()
 
-	// Fetch DEFAULT keyspace by name first to get its ID.
-	metaByName, err := client.GetKeyspaceMetaByName(ctx, constant.DefaultKeyspaceName)
+	// Fetch the bootstrap keyspace by name first to get its ID.
+	// In NextGen, it's SYSTEM keyspace; in Classic, it's DEFAULT keyspace.
+	var bootstrapKeyspaceName string
+	if kerneltype.IsNextGen() {
+		bootstrapKeyspaceName = constant.SystemKeyspaceName
+	} else {
+		bootstrapKeyspaceName = constant.DefaultKeyspaceName
+	}
+
+	metaByName, err := client.GetKeyspaceMetaByName(ctx, bootstrapKeyspaceName)
 	re.NoError(err)
 	re.NotNil(metaByName)
 

tests/integrations/client/keyspace_test.go

@@ -73,11 +73,13 @@ func (suite *clientStatelessTestSuite) TestLoadKeyspace() {
 	// Loading non-existing keyspace should result in error.
 	_, err := suite.client.LoadKeyspace(suite.ctx, "non-existing keyspace")
 	re.Error(err)
-	// Loading default keyspace should be successful.
-	keyspaceDefault, err := suite.client.LoadKeyspace(suite.ctx, constant.DefaultKeyspaceName)
+	// Loading bootstrap keyspace should be successful.
+	bootstrapKeyspaceName := keyspace.GetBootstrapKeyspaceName()
+	bootstrapKeyspaceID := keyspace.GetBootstrapKeyspaceID()
+	keyspaceDefault, err := suite.client.LoadKeyspace(suite.ctx, bootstrapKeyspaceName)
 	re.NoError(err)
-	re.Equal(constant.DefaultKeyspaceID, keyspaceDefault.GetId())
-	re.Equal(constant.DefaultKeyspaceName, keyspaceDefault.GetName())
+	re.Equal(bootstrapKeyspaceID, keyspaceDefault.GetId())
+	re.Equal(bootstrapKeyspaceName, keyspaceDefault.GetName())
 }
 
 func (suite *clientStatelessTestSuite) TestGetAllKeyspaces() {
@@ -91,7 +93,15 @@ func (suite *clientStatelessTestSuite) TestGetAllKeyspaces() {
 	// Get all keyspaces.
 	resKeyspaces, err := suite.client.GetAllKeyspaces(suite.ctx, 1, math.MaxUint32)
 	re.NoError(err)
-	re.Len(metas, len(resKeyspaces))
+	if kerneltype.IsNextGen() {
+		// In NextGen, the bootstrap keyspace is SYSTEM, not DEFAULT.
+		// Should have test keyspaces + bootstrap keyspace
+		re.Len(resKeyspaces, len(metas)+1)
+	} else {
+		// In Classic, the bootstrap keyspace is DEFAULT.
+		// Should have test keyspaces
+		re.Len(resKeyspaces, len(metas))
+	}
 	// Check expected keyspaces all in resKeyspaces.
 	for _, expected := range metas {
 		var isExists bool
@@ -219,7 +229,9 @@ func (s *clientStatefulTestSuite) TestIsKeyspaceUsingKeyspaceLevelGC() {
 		CreateTime: time.Now().Unix(),
 	})
 	re.NoError(err)
-	re.False(pd.IsKeyspaceUsingKeyspaceLevelGC(meta))
+	// In NextGen build, empty gc_management_type is automatically set to "keyspace_level"
+	// In Classic build, empty gc_management_type remains empty and returns false
+	re.Equal(kerneltype.IsNextGen(), pd.IsKeyspaceUsingKeyspaceLevelGC(meta))
 }
 
 func TestProtectedKeyspace(t *testing.T) {