create-react-admin-template 0.0.0-stage → 0.1.0

package/template/src/tenantWorkspace/switch.ts

@@ -0,0 +1,206 @@
+import { useAuthStore } from '@/stores/authStore'
+import {
+  fnCommitTenantWorkspace,
+  fnGetTenantWorkspaceCurrent,
+  fnSetTenantWorkspaceTransition,
+} from './store'
+import {
+  TenantWorkspaceError,
+  type ITenantWorkspaceCurrent,
+  type ITenantWorkspaceSwitchOptions,
+  type ITenantWorkspaceTarget,
+} from './types'
+
+let objActiveSwitchController: AbortController | undefined
+let nActiveSwitchSequence = 0
+
+function fnNormalizeRequiredId(strValue: string, strField: string) {
+  const strNormalizedValue = strValue.trim()
+  if (!strNormalizedValue) {
+    throw new TenantWorkspaceError(
+      'invalid_target',
+      `${strField} 必须是非空稳定标识。`
+    )
+  }
+  return strNormalizedValue
+}
+
+function fnNormalizeOptionalId(strValue: string | undefined) {
+  const strNormalizedValue = strValue?.trim()
+  return strNormalizedValue || undefined
+}
+
+function fnNormalizeTarget(
+  objTarget: ITenantWorkspaceTarget
+): ITenantWorkspaceTarget {
+  const strTenantId = fnNormalizeRequiredId(
+    objTarget.strTenantId,
+    'strTenantId'
+  )
+  const strWorkspaceId = fnNormalizeOptionalId(objTarget.strWorkspaceId)
+  return Object.freeze({
+    strTenantId,
+    ...(strWorkspaceId ? { strWorkspaceId } : {}),
+  })
+}
+
+function fnIsSameContext(
+  objCurrent: ITenantWorkspaceCurrent,
+  objTarget: ITenantWorkspaceTarget
+) {
+  return (
+    objCurrent.strTenantId === objTarget.strTenantId &&
+    objCurrent.strWorkspaceId === objTarget.strWorkspaceId
+  )
+}
+
+function fnIsAbortError(objError: Error) {
+  return objError instanceof DOMException && objError.name === 'AbortError'
+}
+
+function fnNormalizeSwitchError(objError: Error) {
+  if (objError instanceof TenantWorkspaceError) return objError
+  return new TenantWorkspaceError(
+    'switch_failed',
+    '租户或工作空间切换失败，当前上下文未改变。',
+    { cause: objError }
+  )
+}
+
+/** 取消当前切换；旧上下文始终保持生效。 */
+export function fnCancelTenantWorkspaceSwitch() {
+  objActiveSwitchController?.abort()
+}
+
+/**
+ * 通过项目 Adapter 原子切换上下文。后端结果确认前不会改变当前上下文，跨租户
+ * 切换必须提交一份与目标租户绑定的新认证会话。
+ */
+export async function fnSwitchTenantWorkspace(
+  objTargetInput: ITenantWorkspaceTarget,
+  {
+    fnAfterCommit,
+    fnBeforeCommit,
+    objAdapter,
+  }: ITenantWorkspaceSwitchOptions = {}
+) {
+  const objTarget = fnNormalizeTarget(objTargetInput)
+  const objCurrent = fnGetTenantWorkspaceCurrent()
+  if (!objCurrent.bIsAuthenticated || !objCurrent.strUserId) {
+    throw new TenantWorkspaceError(
+      'authentication_required',
+      '建立认证会话后才能切换租户或工作空间。'
+    )
+  }
+  if (fnIsSameContext(objCurrent, objTarget)) {
+    objActiveSwitchController?.abort()
+    return objCurrent
+  }
+
+  objActiveSwitchController?.abort()
+  const objController = new AbortController()
+  const nSwitchSequence = ++nActiveSwitchSequence
+  objActiveSwitchController = objController
+  fnSetTenantWorkspaceTransition({ strStatus: 'switching', objTarget })
+
+  try {
+    if (!objAdapter) {
+      throw new TenantWorkspaceError(
+        'adapter_missing',
+        '项目尚未配置租户/工作空间切换 Adapter。'
+      )
+    }
+    const objResult = await objAdapter.fnSwitch({
+      objCurrent,
+      objSignal: objController.signal,
+      objTarget,
+    })
+    if (
+      objController.signal.aborted ||
+      nSwitchSequence !== nActiveSwitchSequence
+    ) {
+      throw new DOMException('切换请求已被更新的操作取代。', 'AbortError')
+    }
+
+    const strResultTenantId = fnNormalizeRequiredId(
+      objResult.strTenantId,
+      'result.strTenantId'
+    )
+    const strResultWorkspaceId = fnNormalizeOptionalId(objResult.strWorkspaceId)
+    if (
+      strResultTenantId !== objTarget.strTenantId ||
+      strResultWorkspaceId !== objTarget.strWorkspaceId
+    ) {
+      throw new TenantWorkspaceError(
+        'result_mismatch',
+        '后端确认的租户/工作空间与切换目标不一致。'
+      )
+    }
+    if (
+      objCurrent.strTenantId !== objTarget.strTenantId &&
+      !objResult.objSession
+    ) {
+      throw new TenantWorkspaceError(
+        'session_required',
+        '跨租户切换必须由后端返回新的完整认证会话。'
+      )
+    }
+    if (
+      objResult.objSession &&
+      objResult.objSession.objUser.strTenantId !== objTarget.strTenantId
+    ) {
+      throw new TenantWorkspaceError(
+        'result_mismatch',
+        '新认证会话所属租户与切换目标不一致。'
+      )
+    }
+
+    await fnBeforeCommit?.()
+    if (
+      objController.signal.aborted ||
+      nSwitchSequence !== nActiveSwitchSequence
+    ) {
+      throw new DOMException('切换请求已取消。', 'AbortError')
+    }
+    if (objResult.objSession) {
+      useAuthStore.getState().fnEstablishSession(objResult.objSession)
+    }
+    const objUser = useAuthStore.getState().objUser
+    if (!objUser || objUser.strTenantId !== objTarget.strTenantId) {
+      throw new TenantWorkspaceError(
+        'result_mismatch',
+        '认证会话未进入后端确认的目标租户。'
+      )
+    }
+    fnCommitTenantWorkspace(objUser, objTarget)
+    const objNextCurrent = fnGetTenantWorkspaceCurrent()
+    fnAfterCommit?.(objNextCurrent, objCurrent)
+    return objNextCurrent
+  } catch (objCaughtError) {
+    const objError =
+      objCaughtError instanceof Error
+        ? objCaughtError
+        : new Error('切换 Adapter 抛出了非标准错误。', {
+            cause: objCaughtError,
+          })
+    if (fnIsAbortError(objError) && nSwitchSequence !== nActiveSwitchSequence) {
+      throw objError
+    }
+    if (nSwitchSequence === nActiveSwitchSequence) {
+      if (fnIsAbortError(objError)) {
+        fnSetTenantWorkspaceTransition({ strStatus: 'idle' })
+      } else {
+        fnSetTenantWorkspaceTransition({
+          strStatus: 'error',
+          objError: fnNormalizeSwitchError(objError),
+          objTarget,
+        })
+      }
+    }
+    throw fnIsAbortError(objError) ? objError : fnNormalizeSwitchError(objError)
+  } finally {
+    if (nSwitchSequence === nActiveSwitchSequence) {
+      objActiveSwitchController = undefined
+    }
+  }
+}

package/template/src/tenantWorkspace/types.ts

@@ -0,0 +1,155 @@
+import type { ReactNode } from 'react'
+import type { IAuthSession } from '@/stores/authStore'
+
+/** 当前认证身份实际生效的租户/工作空间作用域。 */
+export interface ITenantWorkspaceCurrent {
+  /** 当前是否已经建立可用的认证会话。 */
+  readonly bIsAuthenticated: boolean
+  /** 当前认证用户的稳定唯一标识；未登录时不存在。 */
+  readonly strUserId?: string
+  /** 认证会话授予的租户标识；它是租户唯一真相来源。 */
+  readonly strTenantId?: string
+  /** 当前用户在当前租户内选择的工作空间标识。 */
+  readonly strWorkspaceId?: string
+}
+
+/** 用户请求切换到的稳定租户/工作空间标识。 */
+export interface ITenantWorkspaceTarget {
+  /** 目标租户的稳定后端标识，不得使用展示名称。 */
+  readonly strTenantId: string
+  /** 目标工作空间的稳定后端标识；租户级页面可以省略。 */
+  readonly strWorkspaceId?: string
+}
+
+/** 交给后端切换 Adapter 的完整请求上下文。 */
+export interface ITenantWorkspaceSwitchRequest {
+  /** 发起切换时仍然生效的旧上下文。 */
+  readonly objCurrent: ITenantWorkspaceCurrent
+  /** 已标准化且准备切换到的目标上下文。 */
+  readonly objTarget: ITenantWorkspaceTarget
+  /** 新切换或用户取消时触发的请求取消信号。 */
+  readonly objSignal: AbortSignal
+}
+
+/** 后端确认用户有权进入目标上下文后的结果。 */
+export interface ITenantWorkspaceSwitchResult {
+  /** 后端实际确认的租户 ID，必须与请求目标完全一致。 */
+  readonly strTenantId: string
+  /** 后端实际确认的工作空间 ID，必须与请求目标完全一致。 */
+  readonly strWorkspaceId?: string
+  /**
+   * 后端重新签发的完整认证会话。跨租户切换必须返回；同租户工作空间
+   * 切换仅在令牌或权限随工作空间变化时返回。
+   */
+  readonly objSession?: IAuthSession
+}
+
+/** 项目使用 Swagger 生成客户端实现的租户/工作空间切换边界。 */
+export interface ITenantWorkspaceAdapter {
+  /** 校验成员关系并让后端确认目标上下文。 */
+  readonly fnSwitch: (
+    objRequest: ITenantWorkspaceSwitchRequest
+  ) => Promise<ITenantWorkspaceSwitchResult>
+}
+
+/** 当前没有切换事务。 */
+export interface ITenantWorkspaceIdleTransition {
+  /** 可判别的空闲状态。 */
+  readonly strStatus: 'idle'
+}
+
+/** 一个目标上下文正在由后端校验。 */
+export interface ITenantWorkspaceSwitchingTransition {
+  /** 可判别的切换中状态。 */
+  readonly strStatus: 'switching'
+  /** 当前正在校验的目标上下文。 */
+  readonly objTarget: ITenantWorkspaceTarget
+}
+
+/** 最近一次切换失败，旧上下文仍然有效。 */
+export interface ITenantWorkspaceErrorTransition {
+  /** 可判别的失败状态。 */
+  readonly strStatus: 'error'
+  /** 失败后可安全用于重试的目标上下文。 */
+  readonly objTarget: ITenantWorkspaceTarget
+  /** 已归一化的切换错误。 */
+  readonly objError: TenantWorkspaceError
+}
+
+/** 切换事务的完整可判别状态。 */
+export type TTenantWorkspaceTransition =
+  | ITenantWorkspaceIdleTransition
+  | ITenantWorkspaceSwitchingTransition
+  | ITenantWorkspaceErrorTransition
+
+/** React 和非 React 消费者读取的统一上下文快照。 */
+export interface ITenantWorkspaceSnapshot {
+  /** 当前仍然生效的租户/工作空间。 */
+  readonly objCurrent: ITenantWorkspaceCurrent
+  /** 最近一次切换事务状态。 */
+  readonly objTransition: TTenantWorkspaceTransition
+  /** 工作空间成功提交或清除后递增的本地版本。 */
+  readonly nWorkspaceGeneration: number
+}
+
+/** 上下文提交前后由应用壳层执行的缓存和路由生命周期。 */
+export interface ITenantWorkspaceLifecycle {
+  /** 提交前取消仍在旧作用域运行的服务端请求。 */
+  readonly fnBeforeCommit?: () => Promise<void> | void
+  /** 提交后通知路由重新执行 Loader 和权限判断。 */
+  readonly fnAfterCommit?: (
+    objCurrent: ITenantWorkspaceCurrent,
+    objPrevious: ITenantWorkspaceCurrent
+  ) => void
+}
+
+/** 非 React 切换入口的依赖。 */
+export interface ITenantWorkspaceSwitchOptions extends ITenantWorkspaceLifecycle {
+  /** 项目提供的后端切换 Adapter；未配置时切换会稳定失败。 */
+  readonly objAdapter?: ITenantWorkspaceAdapter
+}
+
+/** 应用根 Provider 的配置。 */
+export interface ITenantWorkspaceProviderProps extends ITenantWorkspaceSwitchOptions {
+  /** 使用统一租户/工作空间上下文的应用子树。 */
+  readonly children: ReactNode
+}
+
+/** React 消费者获得的上下文与切换命令。 */
+export interface ITenantWorkspaceContextValue extends ITenantWorkspaceSnapshot {
+  /** 请求切换到一个后端确认的目标上下文。 */
+  readonly fnSwitch: (
+    objTarget: ITenantWorkspaceTarget
+  ) => Promise<ITenantWorkspaceCurrent>
+  /** 重新执行最近一次失败的目标；没有失败时保持当前上下文。 */
+  readonly fnRetry: () => Promise<ITenantWorkspaceCurrent>
+  /** 取消当前仍在运行的切换请求。 */
+  readonly fnCancel: () => void
+  /** 清除失败提示但不改变当前上下文。 */
+  readonly fnClearError: () => void
+}
+
+/** 租户/工作空间切换的稳定错误码。 */
+export type TTenantWorkspaceErrorCode =
+  | 'adapter_missing'
+  | 'authentication_required'
+  | 'invalid_target'
+  | 'result_mismatch'
+  | 'session_required'
+  | 'switch_failed'
+
+/** 可由 UI 稳定分类并允许重试的上下文切换错误。 */
+export class TenantWorkspaceError extends Error {
+  /** 供 UI、日志和测试分类的稳定错误码。 */
+  readonly strCode: TTenantWorkspaceErrorCode
+
+  constructor(
+    strCode: TTenantWorkspaceErrorCode,
+    strMessage: string,
+    objOptions?: ErrorOptions
+  ) {
+    super(strMessage, objOptions)
+    this.name = 'TenantWorkspaceError'
+    this.strCode = strCode
+  }
+}

package/template/src/vite-env.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_API_BASE_URL: string
+  readonly VITE_API_PROXY?: string
+  readonly VITE_DEV_API_INSECURE_TLS?: string
+  readonly VITE_PORT: string
+  readonly VITE_PUBLIC_PATH: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+/** 由 Vite 在构建时注入的公开应用版本。 */
+declare const strBuildAppVersion: string
+/** 由 Vite 在构建时注入的 Git Commit。 */
+declare const strBuildCommit: string
+/** 由 Vite 在构建时注入的 ISO 构建时间。 */
+declare const strBuildTime: string

package/template/stylelint.config.js

@@ -0,0 +1,28 @@
+/** @type {import('stylelint').Config} */
+export default {
+  extends: ['stylelint-config-standard', 'stylelint-config-recess-order'],
+  plugins: ['stylelint-order'],
+  ignoreFiles: ['dist/**', 'src/api/generated/**'],
+  rules: {
+    'at-rule-no-unknown': [
+      true,
+      {
+        ignoreAtRules: [
+          'apply',
+          'custom-variant',
+          'layer',
+          'plugin',
+          'source',
+          'theme',
+          'utility',
+          'variant',
+        ],
+      },
+    ],
+    'custom-property-empty-line-before': null,
+    'import-notation': null,
+    'nesting-selector-no-missing-scoping-root': null,
+    'no-descending-specificity': null,
+    'selector-class-pattern': null,
+  },
+}

package/template/tests/integration/Application.test.tsx

@@ -0,0 +1,269 @@
+import { Application } from '@/Application'
+import { objAppConfig } from '@/config/appConfig'
+import {
+  fnStartAuthLifecycle,
+  objQueryClient,
+  objRouter,
+} from '@/router/router'
+import '@/styles/index.css'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { render } from 'vitest-browser-react'
+import { userEvent } from 'vitest/browser'
+import { objDemoCredentials } from '@/api/demoAuthClient'
+import {
+  fnCreateEnumCatalogSource,
+  type IEnumCatalogPayload,
+  type IEnumCatalogRequestContext,
+} from '@/api/enums'
+import {
+  fnCreateGlobalParameterSource,
+  type IGlobalParameterRequestContext,
+} from '@/api/parameters'
+import { useAuthStore } from '@/stores/authStore'
+import { fnExpectNoAccessibilityViolations } from '../setup/accessibility'
+
+beforeEach(() => {
+  localStorage.setItem(objAppConfig.storage.strThemeKey, 'light')
+  useAuthStore.getState().fnClearSession()
+  objQueryClient.clear()
+})
+
+describe('Application', () => {
+  it('renders the authentication entry without a business bootstrap request', async () => {
+    const objScreen = await render(<Application />)
+
+    await expect
+      .element(objScreen.getByText('请使用已获授权的组织账号继续访问。'))
+      .toBeVisible()
+    expect(document.body.textContent).not.toContain('正在初始化系统数据…')
+  })
+
+  it.each(['light', 'dark'] as const)(
+    'has no automated accessibility violations on the %s sign-in shell',
+    async (strTheme) => {
+      localStorage.setItem(objAppConfig.storage.strThemeKey, strTheme)
+      const objScreen = await render(<Application />)
+
+      await expect
+        .element(objScreen.getByRole('heading', { level: 1 }))
+        .toBeVisible()
+      await expect
+        .poll(() => document.documentElement.classList.contains('dark'))
+        .toBe(strTheme === 'dark')
+      await fnExpectNoAccessibilityViolations(objScreen.container)
+    }
+  )
+
+  it('supports a keyboard-only sign-in and sign-out journey', async () => {
+    const fnStopAuthLifecycle = fnStartAuthLifecycle()
+
+    try {
+      const objScreen = await render(<Application />)
+      const objPhoneInput = objScreen.getByRole('textbox', {
+        name: /^手机号$/,
+      })
+      const objPasswordInput = objScreen.getByLabelText(/^密码$/)
+
+      await expect.element(objPhoneInput).toBeVisible()
+      await userEvent.keyboard('{Tab}')
+      await expect.element(objPhoneInput).toHaveFocus()
+      await userEvent.keyboard('{Tab}')
+      await expect.element(objPasswordInput).toHaveFocus()
+
+      await userEvent.fill(objPhoneInput, objDemoCredentials.strPhone)
+      await userEvent.fill(objPasswordInput, objDemoCredentials.strPassword)
+      await userEvent.keyboard('{Enter}')
+
+      await expect
+        .element(objScreen.getByText('Enterprise Scaffold'))
+        .toBeVisible()
+      await expect
+        .element(objScreen.getByRole('link', { name: /表格业务场景/ }))
+        .toBeVisible()
+      await userEvent.click(
+        objScreen.getByRole('link', { name: /表格业务场景/ })
+      )
+      await expect
+        .element(objScreen.getByRole('heading', { name: '表格业务场景' }))
+        .toBeVisible()
+      await expect
+        .element(objScreen.getByRole('table', { name: '核心 CRUD 页面' }))
+        .toBeVisible()
+      await userEvent.click(objScreen.getByRole('button', { name: '新增记录' }))
+      await expect
+        .element(objScreen.getByRole('dialog').getByRole('textbox').first())
+        .toBeVisible()
+      await userEvent.keyboard('{Escape}')
+      await expect
+        .element(objScreen.getByRole('button', { name: '用户菜单' }))
+        .toBeVisible()
+      expect(objRouter.state.location.pathname).toBe('/showcase/table')
+      await userEvent.click(objScreen.getByRole('link', { name: '首页' }))
+      await expect
+        .element(objScreen.getByRole('link', { name: /PageForm 场景/ }))
+        .toBeVisible()
+      expect(objRouter.state.location.pathname).toBe('/dashboard')
+      await fnExpectNoAccessibilityViolations(objScreen.container)
+
+      await userEvent.click(
+        objScreen.getByRole('link', { name: /身份、会话与权限/ })
+      )
+      await expect
+        .element(objScreen.getByRole('heading', { name: '身份、会话与权限' }))
+        .toBeVisible()
+      await userEvent.click(objScreen.getByRole('button', { name: '只读用户' }))
+      await expect
+        .element(objScreen.getByRole('button', { name: '编辑记录' }))
+        .toBeDisabled()
+      await expect
+        .element(objScreen.getByText('受保护操作已被 Can 隐藏。'))
+        .toBeVisible()
+      await userEvent.click(objScreen.getByRole('button', { name: '运营人员' }))
+      await expect
+        .element(objScreen.getByRole('button', { name: '编辑记录' }))
+        .toBeEnabled()
+      await userEvent.click(objScreen.getByRole('link', { name: '首页' }))
+      await expect
+        .poll(() => useAuthStore.getState().objUser?.arrPermissions)
+        .toEqual(['*'])
+
+      await userEvent.click(objScreen.getByRole('button', { name: '用户菜单' }))
+      await userEvent.click(
+        objScreen.getByRole('menuitem', { name: '退出登录' })
+      )
+
+      await expect
+        .element(objScreen.getByRole('button', { name: /^登录$/ }))
+        .toBeVisible()
+      expect(objRouter.state.location.pathname).toBe('/sign-in')
+    } finally {
+      fnStopAuthLifecycle()
+    }
+  })
+
+  it('does not load an authenticated enum source before sign-in', async () => {
+    const fnRequest = vi.fn().mockResolvedValue({
+      enums: {},
+      locale: 'zh-CN',
+      version: 'v1',
+    })
+    const objSource = fnCreateEnumCatalogSource(fnRequest)
+    const objScreen = await render(
+      <Application objMetadata={{ objEnumCatalog: { objSource } }} />
+    )
+
+    await expect
+      .element(objScreen.getByText('请使用已获授权的组织账号继续访问。'))
+      .toBeVisible()
+    expect(fnRequest).not.toHaveBeenCalled()
+  })
+
+  it('preloads an explicitly enabled public enum catalog', async () => {
+    const fnRequest = vi.fn(
+      async (
+        _objContext: IEnumCatalogRequestContext
+      ): Promise<IEnumCatalogPayload> => ({
+        enums: {},
+        locale: 'en-US',
+        version: '2026.08.26',
+      })
+    )
+    const objSource = fnCreateEnumCatalogSource(fnRequest)
+
+    await render(
+      <Application
+        objLocale={{ strLocale: 'en-US' }}
+        objMetadata={{
+          objEnumCatalog: {
+            bIsEnabled: true,
+            objScope: { strNamespace: 'public' },
+            objSource,
+          },
+        }}
+      />
+    )
+
+    await expect.poll(() => fnRequest).toHaveBeenCalledTimes(1)
+    const objRequestContext = fnRequest.mock.calls[0]?.[0]
+    expect(objRequestContext?.objScope).toMatchObject({
+      strLocale: 'en-US',
+      strNamespace: 'public',
+    })
+    expect(objRequestContext?.strLocale).toBe('en-US')
+  })
+
+  it('loads scoped metadata after sign-in and reloads it for a new tenant', async () => {
+    const fnEnumRequest = vi.fn(
+      async (
+        objContext: IEnumCatalogRequestContext
+      ): Promise<IEnumCatalogPayload> => ({
+        enums: {},
+        locale: objContext.strLocale,
+        version: objContext.objScope.strTenantId ?? 'public',
+      })
+    )
+    const fnParameterRequest = vi.fn(
+      async (objContext: IGlobalParameterRequestContext) => ({
+        locale: objContext.strLocale,
+        parameters: {},
+        version: objContext.objScope.strTenantId ?? 'public',
+      })
+    )
+    await render(
+      <Application
+        objMetadata={{
+          objEnumCatalog: {
+            objSource: fnCreateEnumCatalogSource(fnEnumRequest),
+          },
+          objGlobalParameters: {
+            objSource: fnCreateGlobalParameterSource(fnParameterRequest),
+          },
+        }}
+      />
+    )
+
+    expect(fnEnumRequest).not.toHaveBeenCalled()
+    expect(fnParameterRequest).not.toHaveBeenCalled()
+
+    useAuthStore.getState().fnEstablishSession({
+      objUser: {
+        arrPermissions: ['metadata:read'],
+        arrRoleCodes: ['admin'],
+        strId: 'user-1',
+        strAccount: '138****0000',
+        strDisplayName: '管理员',
+        strRole: 'admin',
+        strTenantId: 'tenant-a',
+      },
+      strAccessToken: 'access-token',
+      strRefreshToken: 'refresh-token',
+      nAccessTokenExpiresAt: Date.now() + 60_000,
+      nRefreshTokenExpiresAt: Date.now() + 60_000,
+    })
+
+    await expect.poll(() => fnEnumRequest).toHaveBeenCalledTimes(1)
+    await expect.poll(() => fnParameterRequest).toHaveBeenCalledTimes(1)
+    expect(fnEnumRequest.mock.calls[0]?.[0].objScope.strTenantId).toBe(
+      'tenant-a'
+    )
+    expect(fnParameterRequest.mock.calls[0]?.[0].objScope.strTenantId).toBe(
+      'tenant-a'
+    )
+
+    const objCurrentUser = useAuthStore.getState().objUser
+    if (!objCurrentUser) throw new Error('测试会话未建立。')
+    useAuthStore.getState().fnUpdateUser({
+      ...objCurrentUser,
+      strTenantId: 'tenant-b',
+    })
+
+    await expect.poll(() => fnEnumRequest).toHaveBeenCalledTimes(2)
+    await expect.poll(() => fnParameterRequest).toHaveBeenCalledTimes(2)
+    expect(fnEnumRequest.mock.calls[1]?.[0].objScope.strTenantId).toBe(
+      'tenant-b'
+    )
+    expect(fnParameterRequest.mock.calls[1]?.[0].objScope.strTenantId).toBe(
+      'tenant-b'
+    )
+  })
+})