func InitSentinel() {
	cfg := config.NewDefaultConfig()
	cfg.Sentinel.Log.Dir = "./tmp/sentinel/api"
	err := sentinel.InitWithConfig(cfg)
	if err != nil {
		hlog.Fatal("init sentinel failed", err)
	}
	_, err = flow.LoadRules([]*flow.Rule{
		{
			Resource:               serverConfig.GlobalServerConfig.FlowRule.Resource,
			Threshold:              float64(serverConfig.GlobalServerConfig.FlowRule.Threshold),
			TokenCalculateStrategy: flow.TokenCalculateStrategy(serverConfig.GlobalServerConfig.FlowRule.TokenCalculateStrategy),
			ControlBehavior:        flow.ControlBehavior(serverConfig.GlobalServerConfig.FlowRule.TokenCalculateStrategy),
			StatIntervalInMs:       serverConfig.GlobalServerConfig.FlowRule.StatIntervalInMs,
		},
	})
	if err != nil {
		hlog.Fatal("load sentinel failed", err)
	}
}

func main(){
    ...
    h.Use(hertzSentinel.SentinelServerMiddleware(
   hertzSentinel.WithServerResourceExtractor(func(ctx context.Context, requestContext *app.RequestContext) string {
      return config.GlobalServerConfig.FlowRule.Resource
   }),
   // abort with status 429 by default
   hertzSentinel.WithServerBlockFallback(func(c context.Context, ctx *app.RequestContext) {
      ctx.JSON(http.StatusTooManyRequests, nil)
      ctx.Abort()
   }),
))
    ...
}

func Sentinel() {
	conf := SentinelConfig.NewDefaultConfig()
	conf.Sentinel.Log.Dir = consts.UserSentinelFilePath
	err := sentinel.InitWithConfig(conf)
	if err != nil {
		klog.Fatal(err)
	}
	// 注册状态变化监听器，用于观察内部断路器的状态变化
	circuitbreaker.RegisterStateChangeListeners(&stateChangeTestListener{})
	c := config.GlobalServerConfig.CbRule
	// 加载断路器规则
	_, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
		// 统计时间窗口=5秒，恢复时间=3秒，慢请求上限=50毫秒，最大慢请求比例=50%
		{
			Resource:                     c.Resource,
			Strategy:                     circuitbreaker.Strategy(c.Strategy),
			RetryTimeoutMs:               c.RetryTimeoutMs,
			MinRequestAmount:             c.MinRequestAmount,
			StatIntervalMs:               c.StatIntervalMs,
			StatSlidingWindowBucketCount: c.StatSlidingWindowBucketCount,
			MaxAllowedRtMs:               c.MaxAllowedRtMs,
			Threshold:                    c.Threshold,
		},
	})
	if err != nil {
		klog.Fatal(err)
	}
}

func main() {
	srv := user.NewServer(impl,
        ...                  
		// QPS限流
		server.WithLimit(&limit.Option{MaxConnections: 2000, MaxQPS: 500}),
		// 熔断
		server.WithMiddleware(kitexSentinel.SentinelServerMiddleware(
			kitexSentinel.WithResourceExtract(func(ctx context.Context, req, resp interface{}) string {
				return config.GlobalServerConfig.CbRule.Resource
			}),
			kitexSentinel.WithBlockFallback(func(ctx context.Context, req, resp interface{}, blockErr error) error {
				return errors.New("service block")
			}),
		)),
	)
    ...
}

func RunMysqlInDocker(t *testing.T) (cleanUpFunc func(), db *gorm.DB, err error) {
	c, err := client.NewClientWithOpts(client.WithVersion(api.DefaultVersion))
    
	if err != nil {
		return func() {}, nil, err
	}

	ctx := context.Background()

	resp, err := c.ContainerCreate(ctx, &container.Config{
		// ...
		},
		Env: []string{ // ...},
	}, &container.HostConfig{
		PortBindings: nat.PortMap{
			// ...
		},
	}, nil, nil, "")

	if err != nil {
		return func() {}, nil, err
	}

	containerID := resp.ID

	cleanUpFunc = func() {
		err = c.ContainerRemove(ctx, containerID, types.ContainerRemoveOptions{
			Force: true,
		})
		if err != nil {
			t.Error("remove test docker failed", err)
		}
	}

	err = c.ContainerStart(ctx, containerID, types.ContainerStartOptions{})
	if err != nil {
		return cleanUpFunc, nil, err
	}

	inspRes, err := c.ContainerInspect(ctx, containerID)
	if err != nil {
		return cleanUpFunc, nil, err
	}

	hostPort := inspRes.NetworkSettings.Ports[consts.MySQLContainerPort][0]
	port, _ := strconv.Atoi(hostPort.HostPort)
	mysqlDSN := fmt.Sprintf(consts.MySqlDSN, consts.MySQLAdmin, consts.DockerTestMySQLPwd, hostPort.HostIP, port, consts.DockerTestMySQLDb)
	// Init mysql
	time.Sleep(20 * time.Second)
    
	db, err = gorm.Open(mysql.Open(mysqlDSN), &gorm.Config{
		// ...
		},
		// ...
			},
		),
	})

	// ...
}

func TestUserLifecycleInMySQL(t *testing.T) {
	cleanUpFunc, db, err := test.RunMysqlInDocker(t)

	defer cleanUpFunc()

	if err != nil {
		t.Fatal(err)
	}

	dao := NewUser(db)

	ctx := context.Background()
    
    // ...

	cases := []struct {
		name       string
		op         func() (string, error)
		wantErr    bool
		wantResult string
	}{
        // ...
	}

	for _, cc := range cases {
		result, err := cc.op()
		if cc.wantErr {
			if err == nil {
				t.Errorf("%s:want error;got none", cc.name)
			} else {
				continue
			}
		}
		if err != nil {
			t.Errorf("%s:operation failed: %v", cc.name, err)
		}
		if result != cc.wantResult {
			t.Errorf("%s:result err: want %s,got %s", cc.name, cc.wantResult, result)
		}
	}
}