ute2e/tests/auth-login-contract.spec.ts

import type { Locator, Page } from '@playwright/test'

import { captureScreenshot, expect, test } from './fixtures'

const loginContext = {
  defaultRoleCode: 'admin',
  roles: [
    {
      code: 'administrative',
      label: '行政',
      accountLabel: '教学系领导账号',
      organizationMode: 'SINGLE',
      organizationLabels: ['教学系'],
    },
    {
      code: 'teacher',
      label: '教员',
      accountLabel: '教员账号',
      organizationMode: 'CASCADE',
      organizationLabels: ['教学系', '教研室'],
    },
    {
      code: 'student',
      label: '学员',
      accountLabel: '学号或账号',
      organizationMode: 'NONE',
      organizationLabels: [],
    },
    {
      code: 'admin',
      label: '管理员',
      accountLabel: '管理员账号',
      organizationMode: 'NONE',
      organizationLabels: [],
    },
  ],
  departments: [
    {
      id: '100',
      code: 'EQUIPMENT',
      name: '工程装备系',
      parentId: null,
      children: [
        {
          id: '110',
          code: 'MAINTENANCE',
          name: '维修教研室',
          parentId: '100',
          children: [
            {
              id: '111',
              code: 'MAINTENANCE-GROUP-1',
              name: '维修一组',
              parentId: '110',
              children: [
                {
                  id: '112',
                  code: 'HYDROPOWER-A',
                  name: '水电组A',
                  parentId: '111',
                  children: [],
                },
              ],
            },
          ],
        },
        {
          id: '120',
          code: 'SUPPORT',
          name: '智能保障教研室',
          parentId: '100',
          children: [],
        },
      ],
    },
    {
      id: '200',
      code: 'COMMAND',
      name: '指挥系',
      parentId: null,
      children: [
        {
          id: '210',
          code: 'COMMAND-TEACHING',
          name: '指挥教研室',
          parentId: '200',
          children: [],
        },
      ],
    },
  ],
} as const

const loginIdentities = {
  administrative: [
    { id: '301', displayName: '秦主任', departmentId: '100', departmentName: '工程装备系' },
    { id: '302', displayName: '周主任', departmentId: '200', departmentName: '指挥系' },
  ],
  teacher: [
    { id: '401', displayName: '许教员', departmentId: '100', departmentName: '工程装备系' },
    { id: '402', displayName: '杜晴', departmentId: '110', departmentName: '维修教研室' },
    { id: '403', displayName: '马雅柔', departmentId: '112', departmentName: '水电组A' },
    { id: '404', displayName: '韩教员', departmentId: '120', departmentName: '智能保障教研室' },
  ],
  student: [
    { id: '501', displayName: '学生甲', departmentId: '112', departmentName: '水电组A' },
  ],
} as const

const descendantDepartmentIds: Record<string, ReadonlySet<string>> = {
  '100': new Set(['100', '110', '111', '112', '120']),
  '110': new Set(['110', '111', '112']),
  '120': new Set(['120']),
  '200': new Set(['200', '210']),
  '210': new Set(['210']),
}

const mockLoginContext = async (page: Page) => {
  await page.route('**/api/auth/v1/auth/login-context', async (route) => {
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({
        code: 200,
        message: '成功',
        data: loginContext,
        timestamp: '2026-08-11T00:00:00+08:00',
        requestId: 'ute2e-login-context-success',
      }),
    })
  })
  await page.route('**/api/auth/v1/auth/login-identities**', async (route) => {
    const url = new URL(route.request().url())
    const roleCode = url.searchParams.get('roleCode')
    const departmentId = url.searchParams.get('departmentId')
    const source = roleCode && roleCode in loginIdentities
      ? loginIdentities[roleCode as keyof typeof loginIdentities]
      : []
    const allowedDepartmentIds = departmentId ? descendantDepartmentIds[departmentId] : null
    const identities = source.filter((identity) => !allowedDepartmentIds || allowedDepartmentIds.has(identity.departmentId))
    await route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({
        code: 200,
        message: '成功',
        data: identities,
        timestamp: '2026-08-11T00:00:00+08:00',
        requestId: 'ute2e-login-identities-success',
      }),
    })
  })
}

const mockLoginContextFailure = async (page: Page) => {
  await page.route('**/api/auth/v1/auth/login-context', async (route) => {
    await route.fulfill({
      status: 503,
      contentType: 'application/json',
      body: JSON.stringify({
        code: 50300,
        message: '认证配置暂不可用',
        data: null,
        timestamp: '2026-08-11T00:00:00+08:00',
        requestId: 'ute2e-login-context-failure',
      }),
    })
  })
}

const openLoginWithContext = async (page: Page) => {
  await mockLoginContext(page)
  await page.goto('/login')
  const contextState = page.getByText('身份认证服务正常', { exact: true })
  await expect(contextState).toBeAttached()
  await expect(contextState).toHaveAttribute('aria-live', 'polite')
  await expect(contextState).toHaveCSS('position', 'absolute')
  await expect(contextState).toHaveCSS('clip-path', 'inset(50%)')
}

const adminUsernameInput = (page: Page) => page.locator('input[name="username"]')
const passwordInput = (page: Page) => page.locator('input[name="password"]')
const submitButton = (page: Page) => page.getByRole('button', { name: '登录系统' })
const identitySelect = (page: Page) => page.getByTestId('login-identity')

const openElementSelect = async (page: Page, select: Locator) => {
  const combobox = select.getByRole('combobox')
  await select.locator('.el-select__wrapper').click()
  await expect(combobox).toHaveAttribute('aria-expanded', 'true')
  const listboxId = await combobox.getAttribute('aria-controls')
  expect(listboxId).toBeTruthy()
  const listbox = page.locator(`[id="${listboxId}"]`)
  await expect(listbox).toBeVisible()
  return listbox
}

const selectElementOption = async (page: Page, select: Locator, name: string | RegExp) => {
  const listbox = await openElementSelect(page, select)
  await listbox.getByRole('option', { name, exact: typeof name === 'string' }).click()
}

const expectElementSelectOptions = async (page: Page, select: Locator, expected: string[]) => {
  const listbox = await openElementSelect(page, select)
  const labels = (await listbox.getByRole('option').allTextContents())
    .map((label) => label.replace(/\s+/g, ' ').trim())
  expect(labels).toEqual(expected)
  await page.keyboard.press('Escape')
}

const expectElementSelectPlaceholder = async (select: Locator, placeholder: string) => {
  await expect(select.locator('.el-select__placeholder').first()).toContainText(placeholder)
}

test.describe('登录上下文 UI 契约', () => {
  test('默认管理员且四个身份展示各自约定字段', async ({ page }, testInfo) => {
    await openLoginWithContext(page)

    const roleButtons = page.locator('[data-role-code]')
    await expect(roleButtons).toHaveCount(4)
    expect(await roleButtons.evaluateAll((buttons) => buttons.map((button) => ({
      code: button.getAttribute('data-role-code'),
      label: button.textContent?.trim(),
    })))).toEqual([
      { code: 'administrative', label: '行政' },
      { code: 'teacher', label: '教员' },
      { code: 'student', label: '学员' },
      { code: 'admin', label: '管理员' },
    ])

    await expect(page.locator('[data-role-code="admin"]')).toHaveAttribute('aria-pressed', 'true')
    await expect(adminUsernameInput(page)).toHaveAttribute('placeholder', '请输入管理员账号')
    await expect(identitySelect(page)).toHaveCount(0)
    await expect(page.getByTestId('login-organization')).toHaveCount(0)
    await expect(page.getByTestId('login-department')).toHaveCount(0)

    await page.locator('[data-role-code="administrative"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeVisible()
    await expectElementSelectPlaceholder(identitySelect(page), '请选择行政账号')
    await expect(identitySelect(page)).toBeDisabled()
    await expect(page.getByTestId('login-organization')).toHaveCount(0)
    await expect(page.getByTestId('login-department')).toBeVisible()

    await page.locator('[data-role-code="teacher"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeVisible()
    await expectElementSelectPlaceholder(identitySelect(page), '请选择教员账号')
    await expect(identitySelect(page)).toBeDisabled()
    await expect(page.getByTestId('login-organization')).toBeVisible()
    await expect(page.getByTestId('login-department')).toBeVisible()

    await page.locator('[data-role-code="student"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeVisible()
    await expectElementSelectPlaceholder(identitySelect(page), '请选择学员账号')
    await expect(identitySelect(page)).toBeEnabled()
    await expect(page.getByTestId('login-organization')).toHaveCount(0)
    await expect(page.getByTestId('login-department')).toHaveCount(0)
    await captureScreenshot(page, testInfo, 'four-role-fields')
  })

  test('行政身份按 SINGLE 模式只选择一个教学系', async ({ page }, testInfo) => {
    await openLoginWithContext(page)
    await page.locator('[data-role-code="administrative"]').click()

    const department = page.getByTestId('login-department')
    await expect(department).toBeEnabled()
    await expectElementSelectPlaceholder(department, '请选择教学系')
    await expectElementSelectOptions(page, department, [
      '工程装备系',
      '指挥系',
    ])
    await expect(submitButton(page)).toBeDisabled()
    await selectElementOption(page, department, '工程装备系')
    await expect(identitySelect(page)).toBeEnabled()
    await expectElementSelectPlaceholder(identitySelect(page), '请选择行政账号')
    await selectElementOption(page, identitySelect(page), /秦主任.*工程装备系/)
    await passwordInput(page).fill('ContractOnly-NotSubmitted')
    await expect(submitButton(page)).toBeEnabled()
    await captureScreenshot(page, testInfo, 'administrative-single')
  })

  test('教员身份按 CASCADE 模式支持教学系本级和直属教研室', async ({ page }, testInfo) => {
    await openLoginWithContext(page)
    await page.locator('[data-role-code="teacher"]').click()

    const organization = page.getByTestId('login-organization')
    const department = page.getByTestId('login-department')
    await expect(organization).toBeEnabled()
    await expect(department).toBeDisabled()
    await expect(identitySelect(page)).toBeDisabled()
    await expect(submitButton(page)).toBeDisabled()

    await selectElementOption(page, organization, '工程装备系')
    await expect(department).toBeEnabled()
    await expectElementSelectPlaceholder(department, '请选择教研室')
    await expectElementSelectOptions(page, department, [
      '工程装备系（本级）',
      '维修教研室',
      '智能保障教研室',
    ])

    await selectElementOption(page, department, '工程装备系（本级）')
    await expect(department).toContainText('工程装备系（本级）')
    await expect(identitySelect(page)).toBeEnabled()
    await selectElementOption(page, identitySelect(page), /许教员.*工程装备系/)
    await passwordInput(page).fill('ContractOnly-NotSubmitted')
    await expect(submitButton(page)).toBeEnabled()

    await selectElementOption(page, department, '维修教研室')
    await expect(department).toContainText('维修教研室')
    await expect(passwordInput(page)).toHaveValue('')
    await expect(identitySelect(page)).toBeEnabled()
    const identityListbox = await openElementSelect(page, identitySelect(page))
    await expect(identityListbox.getByRole('option', { name: /马雅柔.*水电组A/ })).toBeVisible()
    await identityListbox.getByRole('option', { name: /马雅柔.*水电组A/ }).click()
    await passwordInput(page).fill('ContractOnly-NotSubmitted')
    await expect(submitButton(page)).toBeEnabled()
    await captureScreenshot(page, testInfo, 'teacher-cascade-current-and-child')
  })

  test('切换身份会清空账号密码和已选组织', async ({ page }, testInfo) => {
    await openLoginWithContext(page)
    await page.locator('[data-role-code="teacher"]').click()
    await selectElementOption(page, page.getByTestId('login-organization'), '工程装备系')
    await selectElementOption(page, page.getByTestId('login-department'), '维修教研室')
    await selectElementOption(page, identitySelect(page), /马雅柔.*水电组A/)
    await passwordInput(page).fill('ContractOnly-NotSubmitted')

    await page.locator('[data-role-code="administrative"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expectElementSelectPlaceholder(identitySelect(page), '请选择行政账号')
    await expect(passwordInput(page)).toHaveValue('')
    await expect(page.getByTestId('login-organization')).toHaveCount(0)
    await expectElementSelectPlaceholder(page.getByTestId('login-department'), '请选择教学系')

    await selectElementOption(page, page.getByTestId('login-department'), '指挥系')
    await selectElementOption(page, identitySelect(page), /周主任.*指挥系/)
    await passwordInput(page).fill('ContractOnly-NotSubmitted')
    await page.locator('[data-role-code="teacher"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expectElementSelectPlaceholder(identitySelect(page), '请选择教员账号')
    await expect(passwordInput(page)).toHaveValue('')
    await expectElementSelectPlaceholder(page.getByTestId('login-organization'), '请选择教学系')
    await expectElementSelectPlaceholder(page.getByTestId('login-department'), '请选择教研室')
    await expect(page.getByTestId('login-department')).toBeDisabled()
    await captureScreenshot(page, testInfo, 'role-switch-clears-sensitive-fields')
  })

  test('登录页只按当前身份和组织加载安全账号候选且不会预填密码', async ({ page }) => {
    await openLoginWithContext(page)

    await expect(adminUsernameInput(page)).toHaveValue('')
    await expect(passwordInput(page)).toHaveValue('')
    await expect(adminUsernameInput(page)).toHaveAttribute('autocomplete', 'username')
    await expect(passwordInput(page)).toHaveAttribute('autocomplete', 'current-password')
    await expect(page.locator('.login-password-toggle')).toBeVisible()
    await expect(page.locator('.login-password-toggle svg')).toHaveCount(1)
    await expect(page.locator('.login-password-toggle')).toHaveAttribute('aria-label', '显示密码')
    await page.locator('.login-password-toggle').click()
    await expect(passwordInput(page)).toHaveAttribute('type', 'text')
    await expect(page.locator('.login-password-toggle')).toHaveAttribute('aria-label', '隐藏密码')
    await page.locator('.login-password-toggle').click()
    await expect(passwordInput(page)).toHaveAttribute('type', 'password')
    expect(await adminUsernameInput(page).getAttribute('list')).toBeNull()
    await expect(page.locator('datalist')).toHaveCount(0)
    await expect(page.locator('select[name*="user" i], select[name*="account" i]')).toHaveCount(0)

    await page.locator('[data-role-code="administrative"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeDisabled()
    await expect(passwordInput(page)).toHaveValue('')

    await page.locator('[data-role-code="teacher"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeDisabled()
    await expect(passwordInput(page)).toHaveValue('')

    await page.locator('[data-role-code="student"]').click()
    await expect(adminUsernameInput(page)).toHaveCount(0)
    await expect(identitySelect(page)).toBeEnabled()
    const studentListbox = await openElementSelect(page, identitySelect(page))
    await expect(studentListbox.getByRole('option', { name: /学生甲.*水电组A/ })).toBeVisible()
    await page.keyboard.press('Escape')
    await expect(passwordInput(page)).toHaveValue('')

    await page.locator('[data-role-code="admin"]').click()
    await expect(identitySelect(page)).toHaveCount(0)
    await expect(adminUsernameInput(page)).toHaveValue('')
    await expect(passwordInput(page)).toHaveValue('')
  })

  test('登录上下文失败时管理员账号密码入口仍可使用', async ({ page }, testInfo) => {
    await mockLoginContextFailure(page)
    await page.goto('/login')
    const contextState = page.getByText('认证配置连接失败', { exact: true })
    await expect(contextState).toBeAttached()
    await expect(contextState).toHaveAttribute('aria-live', 'polite')
    await expect(contextState).toBeVisible()

    await expect(page.locator('[data-role-code="admin"]')).toHaveAttribute('aria-pressed', 'true')
    await expect(page.getByTestId('login-organization')).toHaveCount(0)
    await expect(page.getByTestId('login-department')).toHaveCount(0)
    await adminUsernameInput(page).fill('admin.contract')
    await passwordInput(page).fill('ContractOnly-NotSubmitted')
    await expect(submitButton(page)).toBeEnabled()
    await captureScreenshot(page, testInfo, 'context-failure-admin-available')
  })
})

for (const viewport of [
  { width: 375, height: 812 },
  { width: 1024, height: 768 },
  { width: 1440, height: 900 },
]) {
  test(`登录页在 ${viewport.width}px 宽度无横向滚动`, async ({ page }, testInfo) => {
    await page.setViewportSize(viewport)
    await openLoginWithContext(page)

    const geometry = await page.evaluate(() => {
      const card = document.querySelector<HTMLElement>('.login-card')?.getBoundingClientRect()
      return {
        documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
        bodyOverflow: document.body.scrollWidth - document.body.clientWidth,
        cardLeft: card?.left ?? -1,
        cardRight: card?.right ?? Number.POSITIVE_INFINITY,
        viewportWidth: window.innerWidth,
      }
    })
    expect(geometry.documentOverflow).toBeLessThanOrEqual(1)
    expect(geometry.bodyOverflow).toBeLessThanOrEqual(1)
    expect(geometry.cardLeft).toBeGreaterThanOrEqual(0)
    expect(geometry.cardRight).toBeLessThanOrEqual(geometry.viewportWidth + 1)
    await captureScreenshot(page, testInfo, `login-responsive-${viewport.width}`)
  })
}