1.项目背景

这是一个基于 Spring Boot + Vue 前后端分离的论坛系统项目

本项目是一款集用户管理、帖子互动、站内通信、智能问答于一体的论坛类应用，由本人独立完成设计、开发、测试及云服务器部署的全流程工作

1.1项目介绍

模块设计

- 用户模块：实现用户登录、注册及个人信息维护功能，保障用户身份管理与信息安全。

- 帖子模块：支持帖子发布、管理、列表展示及点赞互动，满足用户内容创作与互动需求。

- 帖子回复功能：实现针对帖子的评论与互动回复，支持楼中楼回复，强化社区交流属性。

- 站内信功能：支持向指定用户发送消息，采用 SSE（Server-Sent Events）技术实现实时消息推送，提升用户沟通效率。

- 收藏功能：支持用户收藏感兴趣的帖子，方便后续查看和管理。

- 签到功能：实现用户每日签到功能，支持签到统计、日历展示和排行榜。

- 搜索功能：支持按关键词搜索帖子，采用全文检索技术提升搜索效率。

- AI助手功能：集成AI智能问答助手，支持基于文章内容提问和提取关键知识点。

- 管理员功能：支持用户管理（增删改查、状态管理）、文章管理（置顶、精选、公告设置）等后台管理操作。

技术栈

 - 后端：基于 Spring Boot 3.x + Spring MVC 构建服务端逻辑，以 MySQL 作为数据存储引擎，MyBatis 作为持久层框架，保障系统稳定性与数据可靠性。

- 前端：采用 Vue 3 + Element Plus 实现响应式页面布局，结合 Pinia 状态管理和 Vue Router 路由管理，确保前端交互体验流畅直观。

1.2应用技术

- 后端：Spring Boot 3.x, Spring MVC, MyBatis, Spring AI

- 数据库：MySQL

- 前端：Vue 3, Element Plus, Pinia, Vue Router, Axios

1.3技术亮点

1. 采用统一返回格式（AppResult）+ 全局错误信息定义（ResultCode），实现前后端交互结果的标准化、一致性处理，提升接口可读性与稳定性
2. 通过 @ControllerAdvice + @ExceptionHandler 注解组合，构建全局异常处理机制，统一拦截、规范化异常响应
3. 利用拦截器技术（LoginInterceptor）实现用户登录状态校验，精准拦截未授权请求，强化系统权限管理与操作安全性
4. 借助 MyBatis Generator 工具自动生成常规增删改查方法，大幅提升数据层开发效率，降低重复编码成本
5. 集成 Spring AI 实现智能问答助手功能，支持基于文章内容的智能问答和关键知识点提取
6. 采用 SSE（Server-Sent Events）技术实现站内信实时推送，替代传统轮询方式，降低服务器压力，提升实时性
7. 针对数据库高频查询字段建立索引，并通过查询计划工具分析索引生效情况，显著优化数据查询性能与系统响应速度
8. 实现文章搜索功能，支持按关键词全文检索，提升内容发现效率
9. 采用策略模式实现排行榜功能，支持多种排序策略（按访问量、按点赞数等），便于后续扩展
10. 实现用户签到功能，支持连续签到统计、签到日历展示和签到排行榜

2.项目模块及实现功能

 1.注册

2. 登录模块

3. 板块模块

•    获取首页板块列表
•    获取某一板块信息

4. 文章模块

•    发布新帖
•    获取帖子列表
•    帖子详情
•    修改帖子
•    点赞
•    删除帖子
•    获取用户的帖子列表

5. 回复模块

•    回复帖子
•    获取回复列表

6. 站内信模块

•    发送站内信
•    获取未读消息个数
•    查询用户的所有站内信
•    更新为已读
•    回复站内信
•    删除站内信
•    SSE实时消息订阅

7. 收藏模块

•    收藏帖子
•    取消收藏
•    获取收藏列表

8. 签到模块

•    每日签到
•    获取今日签到状态
•    获取签到统计
•    获取签到日历
•    获取签到排行榜

9. 搜索模块

•    搜索文章

10. AI助手模块

•     向AI提问
•     提取文章关键知识点

11. 管理员模块

    用户管理

•       获取用户列表
•       获取用户详情
•       创建用户
•       更新用户
•       删除用户
•       更新用户状态

    文章管理

•       更新文章标识（置顶、精选、公告）

3.测试用例

 4.自动化测试

4.1全接口测试报告

4.1.1. 测试环境

• 执行时间：2026-04-27 23:52:18（Asia/Shanghai）

• 项目路径：E:\forum论坛系统\forum

• 接口文档：E:\forum论坛系统\docs\API接口文档.md

• 操作系统：Windows 11 amd64

• JDK：17.0.9

• Maven：Apache Maven 3.6.3（Maven Wrapper）

• Spring Profile：test

• 数据库：MySQL 127.0.0.1:3306/forum_test

• 测试框架：JUnit5 + SpringBootTest + MockMvc + Mockito

4.1.2. 测试总数、成功数、失败数

• 全量测试总数：61

• 成功：61

• 失败：0

• 错误：0

• 跳过：0

• 接口测试（Controller）数量：59

• 非接口单元测试数量：2

4.1.3. 每个测试用例详细信息（按模块分组）

模块A：验证码与认证

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
CaptchaControllerApiTest	captchaShouldReturnIdAndBase64Image	/auth/captcha	GET	获取验证码返回 captchaId 与 imageBase64	通过

模块B：用户基础与资料

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
UserControllerApiTest	loginSuccessShouldReturnUser	/user/login	POST	正确凭据登录成功	通过
UserControllerApiTest	loginWrongPasswordShouldFail	/user/login	POST	错误密码登录失败	通过
UserControllerApiTest	infoWithoutLoginShouldReturnUnauthorizedCode	/user/info	GET	未登录访问被拦截（401）	通过
UserControllerApiTest	infoAfterLoginShouldReturnCurrentUser	/user/info	GET	登录后获取当前用户信息成功	通过
UserControllerProfileApiTest	registerShouldSuccessWithCaptcha	/user/register	POST	验证码注册成功	通过
UserControllerProfileApiTest	modifyInfoShouldSuccess	/user/modifyInfo	POST	用户资料修改成功	通过
UserControllerProfileApiTest	modifyPasswordShouldSuccessAndAllowRelogin	/user/modifyPassword	POST	密码修改成功且可用新密码重登	通过
UserControllerProfileApiTest	logoutShouldSuccess	/user/logout	GET	退出登录成功	通过
UserControllerProfileApiTest	uploadAvatarShouldSuccess	/user/uploadAvatar	POST	头像上传成功并返回地址	通过

模块C：板块

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
BoardControllerApiTest	topListShouldReturnActiveBoards	/board/topList	GET	板块列表查询成功	通过
BoardControllerApiTest	getByIdShouldReturnBoardWhenExists	/board/getById	GET	查询存在板块成功	通过
BoardControllerApiTest	getByIdShouldFailWhenBoardNotExists	/board/getById	GET	查询不存在板块返回失败	通过

模块D：文章

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
ArticleControllerApiTest	createArticleWithoutLoginShouldReturnUnauthorized	/article/create	POST	未登录发帖被拦截（401）	通过
ArticleControllerApiTest	createArticleSuccessShouldReturnCodeZero	/article/create	POST	登录后发帖成功	通过
ArticleControllerApiTest	createArticleWithInvalidBoardShouldFail	/article/create	POST	无效板块发帖失败	通过
ArticleControllerApiTest	getAllByBoardIdShouldReturnPagedData	/article/getAllByBoradId	GET	板块分页查询成功	通过
ArticleControllerApiTest	getDetailByIdShouldReturnArticle	/article/getDetailById	GET	文章详情查询成功	通过
ArticleControllerAdvancedApiTest	modifyShouldSuccessForOwner	/article/modify	POST	作者修改文章成功	通过
ArticleControllerAdvancedApiTest	thumbsUpShouldSuccessForAnotherUser	/article/thumbsUp	GET	非作者点赞成功	通过
ArticleControllerAdvancedApiTest	deleteShouldSuccessForOwner	/article/delete	POST	作者删除文章成功	通过
ArticleControllerAdvancedApiTest	getByUserIdShouldSuccess	/article/getByUserId	GET	按用户查询文章成功	通过
ArticleControllerTest	getAllByBoradIdShouldSuccess	/article/getAllByBoradId	GET	旧用例回归通过	通过

模块E：回复

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
ArticleReplyControllerApiTest	createReplyWithoutLoginShouldFail	/reply/create	POST	未登录回复被拦截（401）	通过
ArticleReplyControllerApiTest	createTopLevelReplyShouldSuccess	/reply/create	POST	一级回复成功	通过
ArticleReplyControllerApiTest	createReplyForMissingArticleShouldFail	/reply/create	POST	回复不存在文章失败	通过
ArticleReplyControllerApiTest	getRepliesShouldSuccess	/reply/getReplies	GET	回复列表查询成功	通过

模块F：站内信（发送与读取链路）

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
MessageControllerApiTest	createMessageWithoutLoginShouldFail	/message/create	POST	未登录发送站内信被拦截	通过
MessageControllerApiTest	createMessageSuccessShouldReturnCodeZero	/message/create	POST	发送站内信成功	通过
MessageControllerApiTest	createMessageToSelfShouldFail	/message/create	POST	发送给自己被拦截	通过
MessageControllerReadApiTest	getUnreadCountShouldSuccess	/message/getUnreadCount	GET	未读数查询成功	通过
MessageControllerReadApiTest	getAllShouldSuccess	/message/getAll	GET	消息列表查询成功	通过
MessageControllerReadApiTest	getByIdShouldSuccess	/message/getById	GET	消息详情查询成功	通过
MessageControllerReadApiTest	markReadShouldSuccess	/message/markRead	POST	标记已读成功	通过
MessageControllerReadApiTest	replyShouldSuccess	/message/reply	POST	站内信回复成功	通过
MessageControllerReadApiTest	deleteShouldSuccess	/message/delete	POST	站内信删除成功	通过
MessageControllerReadApiTest	subscribeShouldEstablishSseConnection	/message/subscribe	GET	SSE 订阅链路建立成功	通过

模块G：收藏

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
FavoriteControllerApiTest	createFavoriteShouldSuccess	/favorite/create	POST	收藏创建成功	通过
FavoriteControllerApiTest	listFavoriteShouldSuccess	/favorite/list	GET	收藏列表查询成功	通过
FavoriteControllerApiTest	deleteFavoriteShouldSuccess	/favorite/delete	POST	收藏删除成功	通过

模块H：签到与排行

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
CheckinControllerApiTest	doCheckinShouldSuccess	/checkin/do	POST	当日签到成功	通过
CheckinControllerApiTest	getTodayShouldSuccess	/checkin/today	GET	今日签到状态查询成功	通过
CheckinControllerApiTest	getStatShouldSuccess	/checkin/stat	GET	签到统计查询成功	通过
CheckinControllerApiTest	getCalendarShouldSuccess	/checkin/calendar	GET	签到日历查询成功	通过
CheckinControllerApiTest	getRankingShouldSuccess	/checkin/ranking	GET	签到排行查询成功	通过
RankingControllerApiTest	listCheckinRankingShouldSuccess	/ranking/list	GET	排行维度=checkin 查询成功	通过
RankingControllerApiTest	listContributionRankingShouldSuccess	/ranking/list	GET	排行维度=contribution 查询成功	通过

模块I：标签与搜索

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
TagControllerApiTest	listShouldSuccess	/tag/list	GET	标签列表查询成功	通过
SearchControllerApiTest	searchArticleShouldSuccess	/search/article	GET	文章关键字搜索成功	通过

模块J：AI 助手

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
AiAssistantControllerApiTest	askShouldReturnAnswer	/ai/ask	POST	AI 问答接口返回回答（Mock）	通过
AiAssistantControllerApiTest	keypointsShouldReturnList	/ai/keypoints	POST	AI 提取要点接口返回列表（Mock）	通过

模块K：管理员接口

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
AdminUserControllerApiTest	listShouldSuccessForAdmin	/admin/user/list	GET	管理员分页查询用户成功	通过
AdminUserControllerApiTest	detailShouldSuccessForAdmin	/admin/user/detail	GET	管理员查询用户详情成功	通过
AdminUserControllerApiTest	createShouldSuccessForAdmin	/admin/user/create	POST	管理员创建用户成功	通过
AdminUserControllerApiTest	updateShouldSuccessForAdmin	/admin/user/update	POST	管理员更新用户信息成功	通过
AdminUserControllerApiTest	deleteShouldSuccessForAdmin	/admin/user/delete	POST	管理员删除用户成功	通过
AdminUserControllerApiTest	updateStatusShouldSuccessForAdmin	/admin/user/updateStatus	POST	管理员更新用户状态成功	通过
AdminArticleControllerApiTest	updateFlagsShouldSuccessForAdmin	/admin/article/updateFlags	POST	管理员更新文章标记成功	通过

模块L：文件上传（项目扩展接口）

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
UploadControllerApiTest	uploadImageShouldSuccess	/upload/image	POST	通用图片上传成功	通过

模块M：非接口单元测试

测试类名	测试方法名	接口路径	请求类型	测试点	测试结果
ArticleReplyServiceImplUnitTest	createShouldFillReplyUserIdForTopLevelReply	N/A	N/A	一级回复时回填 replyUserId 逻辑正确	通过
ArticleReplyServiceImplUnitTest	createShouldFillReplyUserIdFromParentReplyWhenMissing	N/A	N/A	楼中楼回复时继承父回复对象逻辑正确	通过

4.1.4. 按模块分组汇总

• 认证模块：1 通过 / 0 失败

• 用户模块：9 通过 / 0 失败

• 板块模块：3 通过 / 0 失败

• 文章模块：10 通过 / 0 失败

• 回复模块：4 通过 / 0 失败

• 站内信模块：10 通过 / 0 失败

• 收藏模块：3 通过 / 0 失败

• 签到排行模块：7 通过 / 0 失败

• 标签搜索模块：2 通过 / 0 失败

• AI 助手模块：2 通过 / 0 失败

• 管理员模块：7 通过 / 0 失败

• 文件上传模块：1 通过 / 0 失败

• 单元测试模块：2 通过 / 0 失败

4.1.5接口文档覆盖检查

• 文档接口总数：47

• 已覆盖：47

• 未覆盖：0

• 结论：文档内所有接口均已有自动化测试覆盖

4.2界面自动化测试

4.2.1 公共类 SeleniumConfig

1. 创建驱动 setUp()
2. 释放驱动 tearDown()
3. 登录封装 login() / login(String username, String password)
4. 屏幕截图 takeScreenshot(String fileName)
5. 页面跳转 navigateTo(String path)

package com.bit.forum.selenium.config;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;

/**
 * Selenium 测试基类
 * 使用 Selenium 4 内置的 Selenium Manager 自动管理 ChromeDriver（无需 WebDriverManager）
 */
public class SeleniumConfig {

    protected static final String BASE_URL = "https://szym.site";
    protected static final String TEST_USERNAME = "haha";
    protected static final String TEST_PASSWORD = "123456";

    protected WebDriver driver;
    protected WebDriverWait wait;

    /**
     * ChromeDriver 路径配置。
     * 如果 Selenium 内置的 Selenium Manager 无法自动下载，请手动指定 chromedriver.exe 路径。
     */
    private static final String CHROMEDRIVER_PATH = System.getProperty("user.home")
            + "/chromedriver/chromedriver-win64/chromedriver.exe";

    static {
        // 检查手动下载的 ChromeDriver 是否存在，有则优先使用
        if (java.nio.file.Files.exists(java.nio.file.Paths.get(CHROMEDRIVER_PATH))) {
            System.setProperty("webdriver.chrome.driver", CHROMEDRIVER_PATH);
            System.out.println("Using local ChromeDriver: " + CHROMEDRIVER_PATH);
        }
    }

    @BeforeEach
    void setUp() {
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--remote-allow-origins=*");
        options.addArguments("--disable-blink-features=AutomationControlled");
        // 无头模式运行，取消下面注释：
        // options.addArguments("--headless");

        try {
            // Selenium 4.11+ 内置 Selenium Manager，自动下载匹配的 ChromeDriver
            driver = new ChromeDriver(options);
        } catch (Exception e) {
            System.err.println("无法自动下载 ChromeDriver: " + e.getMessage());
            System.err.println("请手动下载 ChromeDriver 并放置到系统 PATH，或设置 webdriver.chrome.driver 属性");
            throw new RuntimeException("ChromeDriver 初始化失败", e);
        }

        driver.manage().window().maximize();
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    @AfterEach
    void tearDown() {
        if (driver != null) {
            try {
                driver.quit();
            } catch (Exception ignored) {
            }
        }
    }

    /**
     * 登录辅助方法：导航到登录页 → 输入账号密码 → 登录 → 等待跳转
     */
    protected void login() {
        login(TEST_USERNAME, TEST_PASSWORD);
    }

    protected void login(String username, String password) {
        driver.get(BASE_URL + "/sign-in");
        waitForPageLoad();

        fillVueInput(By.cssSelector("input[placeholder='用户名']"), username);
        fillVueInput(By.cssSelector("input[placeholder='密码']"), password);

        clickButtonByText("登录");

        wait.until(ExpectedConditions.or(
                ExpectedConditions.urlContains("/home"),
                ExpectedConditions.urlContains("/sign-in")
        ));
    }

    /**
     * 填充 Vue 3 / Element Plus 输入框，触发 v-model 更新
     */
    protected void fillVueInput(By by, String value) {
        WebElement input = findVisible(by);
        input.clear();
        // 使用 JavaScript 直接设置值并触发 input 事件，确保 Vue 3 v-model 生效
        JavascriptExecutor js = (JavascriptExecutor) driver;
        js.executeScript(
                "var el = arguments[0];"
                        + "var nativeInputValueSetter = Object.getOwnPropertyDescriptor("
                        + "  window.HTMLInputElement.prototype, 'value').set;"
                        + "nativeInputValueSetter.call(el, arguments[1]);"
                        + "el.dispatchEvent(new Event('input', { bubbles: true }));",
                input, value
        );
        sleep(200);
    }

    protected void clickButtonByText(String text) {
        By buttonBy = By.xpath("//button[contains(.,'" + text + "')]");
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(buttonBy));
        btn.click();
    }

    protected WebElement findVisible(By by) {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(by));
    }

    protected void waitForPageLoad() {
        wait.until(driver -> ((JavascriptExecutor) driver)
                .executeScript("return document.readyState").equals("complete"));
        sleep(500);
    }

    protected void waitForElMessage(String expectedText) {
        try {
            By messageBy = By.xpath(
                    "//*[contains(@class,'el-message')]//*[contains(@class,'el-message__content')]");
            wait.until(ExpectedConditions.textToBePresentInElementLocated(messageBy, expectedText));
        } catch (TimeoutException ignored) {
        }
        sleep(800);
    }

    protected boolean isElementPresent(By by) {
        try {
            driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(1));
            return driver.findElements(by).size() > 0;
        } finally {
            driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        }
    }

    protected void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException ignored) {
        }
    }

    protected void takeScreenshot(String fileName) {
        try {
            TakesScreenshot ts = (TakesScreenshot) driver;
            File src = ts.getScreenshotAs(OutputType.FILE);
            Path dir = Paths.get("target", "selenium-screenshots");
            Files.createDirectories(dir);
            Files.copy(src.toPath(), dir.resolve(fileName + ".png"),
                    java.nio.file.StandardCopyOption.REPLACE_EXISTING);
            System.out.println("Screenshot saved: " + dir.resolve(fileName + ".png"));
        } catch (IOException e) {
            System.err.println("Failed to save screenshot: " + e.getMessage());
        }
    }

    protected void navigateTo(String path) {
        driver.get(BASE_URL + path);
        waitForPageLoad();
    }

    protected void openUserDropdown() {
        By avatarBy = By.cssSelector(".el-avatar, [class*='user-avatar'], [class*='avatar']");
        try {
            WebElement avatar = findVisible(avatarBy);
            avatar.click();
            sleep(500);
        } catch (Exception e) {
            takeScreenshot("error-openUserDropdown");
        }
    }
}

4.2.2 注册界面 SignUpPage

1. testSignUpPageElements() ：测试注册页面元素是否完整显示（用户名、昵称、密码、确认密码、验证码、注册按钮、登录链接）
2. testSignUpEmptyUsername() ：测试用户名为空时注册失败，提示“请输入用户名”
3. testSignUpEmptyNickname() ：测试昵称为空时注册失败，提示“请输入昵称”
4. testSignUpPasswordMismatch() ：测试两次密码不一致时注册失败，提示“两次输入的密码不一致”
5. testSignUpEmptyCaptcha() ：测试验证码为空时注册失败，提示“请输入验证码”
6. testNavigateToSignIn() ：测试点击登录链接后可跳转到登录页（ /sign-in ）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

/**
 * 注册页面 Page Object
 */
public class SignUpPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By usernameInput = By.cssSelector("input[placeholder='用户名']");
    private final By nicknameInput = By.cssSelector("input[placeholder='昵称']");
    private final By passwordInput = By.cssSelector("input[placeholder='密码']");
    private final By passwordRepeatInput = By.cssSelector("input[placeholder='确认密码']");
    private final By captchaInput = By.cssSelector("input[placeholder='验证码']");
    private final By captchaImage = By.cssSelector("img[alt='captcha']");
    private final By registerButton = By.xpath("//button[contains(.,'注册')]");
    private final By loginLink = By.xpath("//a[contains(@href,'/sign-in')]");
    private final By submitBtn = By.cssSelector(".submit-btn");

    public SignUpPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/sign-up");
        waitForLoad();
    }

    public boolean isUsernameInputPresent() {
        return driver.findElements(usernameInput).size() > 0;
    }

    public boolean isNicknameInputPresent() {
        return driver.findElements(nicknameInput).size() > 0;
    }

    public boolean isPasswordInputPresent() {
        return driver.findElements(passwordInput).size() > 0;
    }

    public boolean isPasswordRepeatInputPresent() {
        return driver.findElements(passwordRepeatInput).size() > 0;
    }

    public boolean isCaptchaInputPresent() {
        return driver.findElements(captchaInput).size() > 0;
    }

    public boolean isCaptchaImagePresent() {
        return driver.findElements(captchaImage).size() > 0;
    }

    public boolean isRegisterButtonPresent() {
        return driver.findElements(submitBtn).size() > 0;
    }

    public boolean isLoginLinkPresent() {
        return driver.findElements(loginLink).size() > 0;
    }

    public void fillUsername(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(usernameInput));
        fillVueInput(el, value);
    }

    public void fillNickname(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(nicknameInput));
        fillVueInput(el, value);
    }

    public void fillPassword(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(passwordInput));
        fillVueInput(el, value);
    }

    public void fillPasswordRepeat(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(passwordRepeatInput));
        fillVueInput(el, value);
    }

    public void fillCaptcha(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(captchaInput));
        fillVueInput(el, value);
    }

    private void fillVueInput(WebElement input, String value) {
        input.clear();
        org.openqa.selenium.JavascriptExecutor js =
                (org.openqa.selenium.JavascriptExecutor) driver;
        js.executeScript(
                "var nativeInputValueSetter = Object.getOwnPropertyDescriptor("
                        + "window.HTMLInputElement.prototype, 'value').set;"
                        + "nativeInputValueSetter.call(arguments[0], arguments[1]);"
                        + "arguments[0].dispatchEvent(new Event('input', { bubbles: true }));",
                input, value
        );
        try { Thread.sleep(200); } catch (InterruptedException ignored) {}
    }

    public void clickRegister() {
        clickButtonByText("注册");
    }

    public void clickLoginLink() {
        wait.until(ExpectedConditions.elementToBeClickable(loginLink)).click();
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    public void fillAllFields(String username, String nickname, String password, String passwordRepeat) {
        fillUsername(username);
        fillNickname(nickname);
        fillPassword(password);
        fillPasswordRepeat(passwordRepeat);
        fillCaptcha("1234"); // 填入一个假的验证码值
    }

    public boolean isOnSignUpPage() {
        return driver.getCurrentUrl().contains("/sign-up");
    }

    private void clickButtonByText(String text) {
        By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
        btn.click();
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.SignUpPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 注册页面测试
 */
public class SignUpTest extends SeleniumConfig {

    private SignUpPage signUpPage;

    @BeforeEach
    void initPage() {
        signUpPage = new SignUpPage(driver);
        signUpPage.open();
    }

    @Test
    @DisplayName("验证注册页面所有元素存在")
    void testSignUpPageElements() {
        assertTrue(signUpPage.isUsernameInputPresent(), "用户名输入框应存在");
        assertTrue(signUpPage.isNicknameInputPresent(), "昵称输入框应存在");
        assertTrue(signUpPage.isPasswordInputPresent(), "密码输入框应存在");
        assertTrue(signUpPage.isPasswordRepeatInputPresent(), "确认密码输入框应存在");
        assertTrue(signUpPage.isCaptchaInputPresent(), "验证码输入框应存在");
        assertTrue(signUpPage.isCaptchaImagePresent(), "验证码图片应存在");
        assertTrue(signUpPage.isRegisterButtonPresent(), "注册按钮应存在");
        assertTrue(signUpPage.isLoginLinkPresent(), "登录链接应存在");
    }

    @Test
    @DisplayName("用户名为空时注册校验")
    void testSignUpEmptyUsername() {
        signUpPage.fillNickname("test");
        signUpPage.fillPassword("123456");
        signUpPage.fillPasswordRepeat("123456");
        signUpPage.fillCaptcha("1234");
        signUpPage.clickRegister();
        sleep(1000);
        // 应出现提示"请输入用户名"
        waitForElMessage("请输入用户名");
        assertTrue(signUpPage.isOnSignUpPage(), "应留在注册页面");
    }

    @Test
    @DisplayName("昵称为空时注册校验")
    void testSignUpEmptyNickname() {
        signUpPage.fillUsername("testuser123_" + System.currentTimeMillis());
        signUpPage.fillPassword("123456");
        signUpPage.fillPasswordRepeat("123456");
        signUpPage.fillCaptcha("1234");
        signUpPage.clickRegister();
        sleep(1000);
        waitForElMessage("请输入昵称");
        assertTrue(signUpPage.isOnSignUpPage(), "应留在注册页面");
    }

    @Test
    @DisplayName("两次密码不一致校验")
    void testSignUpPasswordMismatch() {
        signUpPage.fillAllFields("testuser_" + System.currentTimeMillis(), "testuser",
                "password123", "password456");
        signUpPage.clickRegister();
        sleep(1000);
        waitForElMessage("两次输入的密码不一致");
        assertTrue(signUpPage.isOnSignUpPage(), "应留在注册页面");
    }

    @Test
    @DisplayName("验证码为空校验")
    void testSignUpEmptyCaptcha() {
        signUpPage.fillUsername("testuser_" + System.currentTimeMillis());
        signUpPage.fillNickname("testuser");
        signUpPage.fillPassword("123456");
        signUpPage.fillPasswordRepeat("123456");
        // 不填验证码
        signUpPage.clickRegister();
        sleep(1000);
        waitForElMessage("请输入验证码");
        assertTrue(signUpPage.isOnSignUpPage(), "应留在注册页面");
    }

    @Test
    @DisplayName("点击登录链接跳转到登录页")
    void testNavigateToSignIn() {
        signUpPage.clickLoginLink();
        sleep(1000);
        String url = signUpPage.getCurrentUrl();
        assertTrue(url.contains("/sign-in"), "应跳转到登录页面，当前URL: " + url);
    }
}

4.2.3 登录界面 SignInPage

1. testSignInPageElements() ：测试页面是否正常显示（用户名、密码、登录按钮、注册链接、密码显隐图标）
2. testSignInSuccess() ：测试登录功能成功（正确账号密码，跳转 /home ）
3. testSignInEmptyUsername()/testSignInEmptyPassword()/testSignInWrongPassword() ：测试登录失败（用户名为空、密码为空、密码错误，页面停留或提示校验信息）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

/**
 * 登录页面 Page Object
 */
public class SignInPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By usernameInput = By.cssSelector("input[placeholder='用户名']");
    private final By passwordInput = By.cssSelector("input[placeholder='密码']");
    private final By loginButton = By.xpath("//button[contains(.,'登录')]");
    private final By registerLink = By.xpath("//a[contains(@href,'/sign-up')]");
    private final By createAccountButton = By.xpath("//button[contains(.,'创建新账户')]");
    private final By passwordToggleIcon = By.cssSelector("[class*='el-input__suffix']");

    public SignInPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/sign-in");
        waitForLoad();
    }

    public boolean isUsernameInputPresent() {
        return driver.findElements(usernameInput).size() > 0;
    }

    public boolean isPasswordInputPresent() {
        return driver.findElements(passwordInput).size() > 0;
    }

    public boolean isLoginButtonPresent() {
        return driver.findElements(loginButton).size() > 0;
    }

    public boolean isRegisterLinkPresent() {
        return driver.findElements(createAccountButton).size() > 0
                || driver.findElements(registerLink).size() > 0;
    }

    public boolean isPasswordTogglePresent() {
        return driver.findElements(passwordToggleIcon).size() > 0;
    }

    public void fillUsername(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(usernameInput));
        fillVueInput(el, value);
    }

    public void fillPassword(String value) {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(passwordInput));
        fillVueInput(el, value);
    }

    private void fillVueInput(WebElement input, String value) {
        input.clear();
        org.openqa.selenium.JavascriptExecutor js =
                (org.openqa.selenium.JavascriptExecutor) driver;
        js.executeScript(
                "var nativeInputValueSetter = Object.getOwnPropertyDescriptor("
                        + "window.HTMLInputElement.prototype, 'value').set;"
                        + "nativeInputValueSetter.call(arguments[0], arguments[1]);"
                        + "arguments[0].dispatchEvent(new Event('input', { bubbles: true }));",
                input, value
        );
        try { Thread.sleep(200); } catch (InterruptedException ignored) {}
    }

    public void clickLogin() {
        clickButtonByText("登录");
    }

    public void clickRegisterLink() {
        By link = createAccountButton;
        wait.until(ExpectedConditions.elementToBeClickable(link)).click();
    }

    public void togglePasswordVisibility() {
        WebElement toggle = wait.until(ExpectedConditions.elementToBeClickable(passwordToggleIcon));
        toggle.click();
        try { Thread.sleep(300); } catch (InterruptedException ignored) {}
    }

    public String getPasswordFieldType() {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(passwordInput))
                .getDomAttribute("type");
    }

    public void loginAs(String username, String password) {
        fillUsername(username);
        fillPassword(password);
        clickLogin();
    }

    public boolean isOnSignInPage() {
        return driver.getCurrentUrl().contains("/sign-in");
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    private void clickButtonByText(String text) {
        By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
        btn.click();
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 登录页面测试
 */
public class SignInTest extends SeleniumConfig {

    private SignInPage signInPage;

    @BeforeEach
    void initPage() {
        signInPage = new SignInPage(driver);
        signInPage.open();
    }

    @Test
    @DisplayName("验证登录页面所有元素存在")
    void testSignInPageElements() {
        assertTrue(signInPage.isUsernameInputPresent(), "用户名输入框应存在");
        assertTrue(signInPage.isPasswordInputPresent(), "密码输入框应存在");
        assertTrue(signInPage.isLoginButtonPresent(), "登录按钮应存在");
        assertTrue(signInPage.isRegisterLinkPresent(), "注册链接应存在");
        assertTrue(signInPage.isPasswordTogglePresent(), "密码显隐切换图标应存在");
    }

    @Test
    @DisplayName("正确账号密码登录成功")
    void testSignInSuccess() {
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        String url = signInPage.getCurrentUrl();
        assertTrue(url.contains("/home"), "登录成功应跳转到首页，当前URL: " + url);
    }

    @Test
    @DisplayName("用户名为空时登录校验")
    void testSignInEmptyUsername() {
        signInPage.fillPassword(TEST_PASSWORD);
        signInPage.clickLogin();
        sleep(1000);
        waitForElMessage("请输入用户名");
        assertTrue(signInPage.isOnSignInPage(), "应留在登录页面");
    }

    @Test
    @DisplayName("密码为空时登录校验")
    void testSignInEmptyPassword() {
        signInPage.fillUsername(TEST_USERNAME);
        signInPage.clickLogin();
        sleep(1000);
        waitForElMessage("请输入密码");
        assertTrue(signInPage.isOnSignInPage(), "应留在登录页面");
    }

    @Test
    @DisplayName("错误密码登录失败")
    void testSignInWrongPassword() {
        signInPage.loginAs(TEST_USERNAME, "wrongpassword123");
        sleep(2000);
        // 错误密码应停留在登录页
        String url = signInPage.getCurrentUrl();
        assertTrue(url.contains("/sign-in"), "错误密码应留在登录页，当前URL: " + url);
    }

    @Test
    @DisplayName("密码显隐切换功能")
    void testPasswordVisibilityToggle() {
        signInPage.fillPassword(TEST_PASSWORD);
        String initType = signInPage.getPasswordFieldType();

        signInPage.togglePasswordVisibility();
        String afterToggleType = signInPage.getPasswordFieldType();

        assertNotEquals(initType, afterToggleType, "切换后密码状态应改变");
    }
}

4.2.4 个人中心界面 SettingsPage

1. testSettingsPageElements() ：测试设置页是否正常显示（标题、头像区、昵称/邮箱输入框、保存按钮、修改密码标签）
2. testModifyNickname() ：测试修改昵称功能（输入新昵称并保存，校验成功提示）
3. testModifyPasswordMismatch()/testModifyEmptyOldPassword() ：测试修改密码失败场景（新旧密码校验不通过、原密码为空）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

/**
 * 个人中心/设置页面 Page Object (/settings)
 */
public class SettingsPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By pageTitle = By.cssSelector(".card-header h1, .settings-card h1");
    private final By infoTab = By.xpath("//div[contains(@class,'el-tabs__item') and contains(.,'基本信息')]");
    private final By passwordTab = By.xpath("//div[contains(@class,'el-tabs__item') and contains(.,'修改密码')]");
    private final By avatarUpload = By.cssSelector(".avatar-uploader");
    private final By nicknameInput = By.cssSelector("input[placeholder='请输入昵称']");
    private final By emailInput = By.cssSelector("input[placeholder='请输入邮箱']");
    private final By phoneInput = By.cssSelector("input[placeholder='请输入手机号']");
    private final By remarkInput = By.cssSelector("textarea[placeholder='请输入自我介绍']");
    private final By saveInfoButton = By.xpath("//button[contains(.,'保存修改')]");

    // 修改密码区域
    private final By oldPasswordInput = By.cssSelector("input[placeholder='请输入原密码']");
    private final By newPasswordInput = By.cssSelector("input[placeholder='请输入新密码']");
    private final By passwordRepeatInput = By.cssSelector("input[placeholder='请再次输入新密码']");
    private final By changePasswordButton = By.xpath("//button[contains(.,'修改密码')]");

    public SettingsPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/settings");
        waitForLoad();
    }

    public boolean isPageTitlePresent() {
        return driver.findElements(pageTitle).size() > 0;
    }

    public boolean isAvatarSectionPresent() {
        return driver.findElements(avatarUpload).size() > 0;
    }

    public boolean isNicknameInputPresent() {
        return driver.findElements(nicknameInput).size() > 0;
    }

    public boolean isEmailInputPresent() {
        return driver.findElements(emailInput).size() > 0;
    }

    public boolean isSaveInfoButtonPresent() {
        return driver.findElements(saveInfoButton).size() > 0;
    }

    public boolean isPasswordTabPresent() {
        return driver.findElements(passwordTab).size() > 0
                || driver.findElements(By.xpath("//div[contains(@class,'el-tabs__item')]")).size() >= 2;
    }

    public void switchToPasswordTab() {
        try {
            WebElement tab = wait.until(ExpectedConditions.elementToBeClickable(passwordTab));
            tab.click();
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        } catch (Exception ignored) {}
    }

    public void switchToInfoTab() {
        try {
            WebElement tab = wait.until(ExpectedConditions.elementToBeClickable(infoTab));
            tab.click();
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        } catch (Exception ignored) {}
    }

    public void fillNickname(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(nicknameInput));
        input.clear();
        input.sendKeys(value);
    }

    public void fillEmail(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(emailInput));
        input.clear();
        input.sendKeys(value);
    }

    public void fillRemark(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(remarkInput));
        input.clear();
        input.sendKeys(value);
    }

    public void clickSaveInfo() {
        clickButtonByText("保存修改");
    }

    public void fillOldPassword(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(oldPasswordInput));
        input.clear();
        input.sendKeys(value);
    }

    public void fillNewPassword(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(newPasswordInput));
        input.clear();
        input.sendKeys(value);
    }

    public void fillPasswordRepeat(String value) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(passwordRepeatInput));
        input.clear();
        input.sendKeys(value);
    }

    public void clickChangePassword() {
        clickButtonByText("修改密码");
    }

    public boolean isOnSettingsPage() {
        return driver.getCurrentUrl().contains("/settings");
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    private void clickButtonByText(String text) {
        By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
        btn.click();
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.SettingsPage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 个人中心/设置页面测试 (/settings)
 */
public class SettingsTest extends SeleniumConfig {

    private SettingsPage settingsPage;

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        settingsPage = new SettingsPage(driver);
        settingsPage.open();
    }

    @Test
    @DisplayName("验证个人中心页面元素存在")
    void testSettingsPageElements() {
        assertTrue(settingsPage.isOnSettingsPage(), "应在个人中心页面");
        assertTrue(settingsPage.isPageTitlePresent(), "页面标题应存在");
        assertTrue(settingsPage.isAvatarSectionPresent(), "头像区域应存在");
        assertTrue(settingsPage.isNicknameInputPresent(), "昵称输入框应存在");
        assertTrue(settingsPage.isEmailInputPresent(), "邮箱输入框应存在");
        assertTrue(settingsPage.isSaveInfoButtonPresent(), "保存修改按钮应存在");
        assertTrue(settingsPage.isPasswordTabPresent(), "修改密码标签应存在");
    }

    @Test
    @DisplayName("修改昵称功能")
    void testModifyNickname() {
        String newNickname = "haha_" + (System.currentTimeMillis() % 100000);
        settingsPage.fillNickname(newNickname);
        settingsPage.clickSaveInfo();
        sleep(1500);
        waitForElMessage("success");
    }

    @Test
    @DisplayName("修改密码-新密码与确认密码不一致")
    void testModifyPasswordMismatch() {
        settingsPage.switchToPasswordTab();
        sleep(500);

        settingsPage.fillOldPassword(TEST_PASSWORD);
        settingsPage.fillNewPassword("newpass123");
        settingsPage.fillPasswordRepeat("different456");
        settingsPage.clickChangePassword();
        sleep(1000);

        waitForElMessage("两次输入的密码不一致");
    }

    @Test
    @DisplayName("修改密码-原密码为空校验")
    void testModifyEmptyOldPassword() {
        settingsPage.switchToPasswordTab();
        sleep(500);

        settingsPage.fillNewPassword("newpass123");
        settingsPage.fillPasswordRepeat("newpass123");
        settingsPage.clickChangePassword();
        sleep(1000);

        waitForElMessage("请输入原密码");
    }
}

4.2.5 我的帖子页面 ProfilePage

1. testProfilePageElements() ：测试“我的帖子”页面是否正常显示（页面标题、基础结构）
2. testProfileDisplaysUserPosts() ：测试当前用户帖子列表展示能力（有帖子则展示列表，无帖子也应正常显示空状态）
3. testClickMyPostNavigatesToDetail() ：测试点击我的帖子后跳转详情页（URL 包含 /article/ ）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;
import java.util.List;

/**
 * 我的帖子/个人主页 Page Object (/profile)
 */
public class ProfilePage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By pageTitle = By.cssSelector(".card-header h1, .page-title");
    private final By articleItems = By.cssSelector(".article-item");
    private final By articleTitles = By.cssSelector(".article-item .article-title");
    private final By articleCards = By.cssSelector(".article-card");
    private final By emptyState = By.cssSelector(".empty-state");

    public ProfilePage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/profile");
        waitForLoad();
    }

    public boolean isPageTitlePresent() {
        return driver.findElements(pageTitle).size() > 0;
    }

    public boolean hasArticles() {
        try {
            wait.until(ExpectedConditions.or(
                    ExpectedConditions.presenceOfElementLocated(articleItems),
                    ExpectedConditions.presenceOfElementLocated(articleCards),
                    ExpectedConditions.presenceOfElementLocated(emptyState),
                    ExpectedConditions.presenceOfElementLocated(By.cssSelector(".articles-list"))
            ));
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        } catch (Exception ignored) {}
        return driver.findElements(articleItems).size() > 0
                || driver.findElements(articleCards).size() > 0;
    }

    public void clickFirstArticle() {
        List<WebElement> articles = driver.findElements(articleTitles);
        if (articles.isEmpty()) {
            articles = driver.findElements(articleItems);
        }
        if (!articles.isEmpty()) {
            articles.get(0).click();
            try { Thread.sleep(800); } catch (InterruptedException ignored) {}
        }
    }

    public String getPageTitle() {
        try {
            return wait.until(ExpectedConditions.visibilityOfElementLocated(pageTitle)).getText();
        } catch (Exception e) {
            return "";
        }
    }

    public int getArticleCount() {
        return driver.findElements(articleItems).size() + driver.findElements(articleCards).size();
    }

    public boolean isOnProfilePage() {
        return driver.getCurrentUrl().contains("/profile");
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.ProfilePage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 我的帖子页面测试 (/profile)
 */
public class ProfileTest extends SeleniumConfig {

    private ProfilePage profilePage;

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        profilePage = new ProfilePage(driver);
        profilePage.open();
    }

    @Test
    @DisplayName("验证我的帖子页面元素存在")
    void testProfilePageElements() {
        assertTrue(profilePage.isOnProfilePage(), "应在我的帖子页面");
        assertTrue(profilePage.isPageTitlePresent(), "页面标题应存在");
    }

    @Test
    @DisplayName("显示当前用户发布的帖子列表")
    void testProfileDisplaysUserPosts() {
        profilePage.open();
        sleep(1000);
        // 检查是否有帖子列表或空状态
        boolean hasContent = profilePage.hasArticles();
        // 即使没有帖子，页面也应正常显示（有空状态提示）
        assertTrue(profilePage.isOnProfilePage(), "应在我的帖子页面");
    }

    @Test
    @DisplayName("点击自己的帖子跳转到详情页")
    void testClickMyPostNavigatesToDetail() {
        if (!profilePage.hasArticles()) {
            System.out.println("用户没有帖子，跳过此测试");
            return;
        }

        profilePage.clickFirstArticle();
        sleep(1500);
        String url = profilePage.getCurrentUrl();
        assertTrue(url.contains("/article/"),
                "点击帖子应跳转到详情页，当前URL: " + url);
    }
}

4.2.6 站内信页面 MessageDrawerPage

1. testMessageDrawerOpens() ：测试点击铃铛后站内信抽屉正常打开
2. testMessageListDisplay()/testClickUnreadMessage() ：测试消息列表展示与未读消息点击查看流程
3. testSendNewMessage() ：测试发送新站内信功能（以给自己发消息为负例，校验“不能给自己发送站内信”提示）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;
import java.util.List;

/**
 * 站内信抽屉 Page Object
 */
public class MessageDrawerPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By messageDrawer = By.cssSelector(".message-drawer, .el-drawer");
    private final By messageItems = By.cssSelector(".message-item");
    private final By messageContent = By.cssSelector(".message-content");
    private final By sendMessageButton = By.xpath("//button[contains(.,'发送新消息')]");
    private final By sendDialog = By.cssSelector(".send-message-dialog, .el-dialog");
    private final By sendDialogReceiver = By.cssSelector(".send-message-dialog input, .el-dialog input[placeholder*='用户']");
    private final By sendDialogContent = By.cssSelector(".send-message-dialog textarea, .el-dialog textarea");
    private final By sendDialogSubmit = By.xpath("//button[contains(.,'发送') and contains(@class,'el-button--primary')]");
    private final By drawerClose = By.cssSelector(".el-drawer__close-btn");
    private final By unreadMessages = By.cssSelector(".message-item.unread");
    private final By deleteSelectedButton = By.xpath("//button[contains(.,'删除选中')]");

    public MessageDrawerPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public boolean isDrawerOpen() {
        try {
            return driver.findElements(By.cssSelector(".el-drawer:not(.is-hidden), .message-drawer")).size() > 0;
        } catch (Exception e) {
            return false;
        }
    }

    public boolean hasMessageItems() {
        try {
            wait.until(ExpectedConditions.presenceOfElementLocated(messageItems));
            return driver.findElements(messageItems).size() > 0;
        } catch (Exception e) {
            return false;
        }
    }

    public boolean hasUnreadMessages() {
        return driver.findElements(unreadMessages).size() > 0;
    }

    public boolean isSendMessageButtonPresent() {
        return driver.findElements(sendMessageButton).size() > 0;
    }

    public void clickFirstMessage() {
        List<WebElement> items = driver.findElements(messageContent);
        if (!items.isEmpty()) {
            items.get(0).click();
            try { Thread.sleep(800); } catch (InterruptedException ignored) {}
        }
    }

    public void clickSendNewMessage() {
        try {
            // 尝试滚动抽屉底部（按钮在底部）
            org.openqa.selenium.JavascriptExecutor js =
                    (org.openqa.selenium.JavascriptExecutor) driver;
            js.executeScript(
                    "var drawer = document.querySelector('.el-drawer__body');"
                            + "if(drawer) drawer.scrollTop = drawer.scrollHeight;"
            );
            Thread.sleep(300);
        } catch (Exception ignored) {}

        try {
            WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(sendMessageButton));
            btn.click();
        } catch (Exception e) {
            // Fallback: try to find by partial text or class
            try {
                WebElement btn = driver.findElement(
                        By.cssSelector(".send-message-btn"));
                btn.click();
            } catch (Exception e2) {
                throw e;
            }
        }
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }

    public boolean isSendDialogOpen() {
        try {
            return driver.findElements(By.cssSelector(".el-dialog:not([style*='display: none'])")).size() > 0;
        } catch (Exception e) {
            return false;
        }
    }

    public void fillMessageReceiver(String username) {
        try {
            WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(
                    By.cssSelector(".el-dialog input[placeholder*='用户'], .el-dialog input[placeholder*='昵称']")
            ));
            input.clear();
            input.sendKeys(username);
        } catch (Exception e) {
            // Try any input in the dialog
            WebElement input = driver.findElement(By.cssSelector(".el-dialog:not([style*='none']) input"));
            input.clear();
            input.sendKeys(username);
        }
    }

    public void fillMessageContent(String content) {
        WebElement textarea = wait.until(ExpectedConditions.visibilityOfElementLocated(
                By.cssSelector(".el-dialog textarea, .el-dialog [class*='textarea'] textarea")
        ));
        textarea.clear();
        textarea.sendKeys(content);
    }

    public void clickSendInDialog() {
        clickButtonByText("发送");
    }

    public void closeDrawer() {
        try {
            WebElement closeBtn = driver.findElement(drawerClose);
            closeBtn.click();
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        } catch (Exception ignored) {}
    }

    private void clickButtonByText(String text) {
        By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
        btn.click();
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.HomePage;
import com.bit.forum.selenium.pages.MessageDrawerPage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 站内信测试
 */
public class MessageTest extends SeleniumConfig {

    private MessageDrawerPage messagePage;

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        messagePage = new MessageDrawerPage(driver);

        // 打开站内信抽屉
        HomePage homePage = new HomePage(driver);
        homePage.clickNotificationBell();
        sleep(1000);
    }

    @Test
    @DisplayName("点击铃铛打开站内信抽屉")
    void testMessageDrawerOpens() {
        assertTrue(messagePage.isDrawerOpen(), "站内信抽屉应打开");
    }

    @Test
    @DisplayName("消息列表显示")
    void testMessageListDisplay() {
        if (!messagePage.isDrawerOpen()) {
            System.out.println("站内信抽屉未打开，跳过测试");
            return;
        }
        if (!messagePage.hasMessageItems()) {
            System.out.println("没有站内信消息，跳过列表显示测试");
            return;
        }
        assertTrue(messagePage.hasMessageItems(), "应有站内信消息");
        assertTrue(messagePage.isSendMessageButtonPresent(), "发送新消息按钮应存在");
    }

    @Test
    @DisplayName("点击未读消息查看详情")
    void testClickUnreadMessage() {
        if (!messagePage.isDrawerOpen()) {
            System.out.println("站内信抽屉未打开，跳过测试");
            return;
        }
        if (!messagePage.hasMessageItems()) {
            System.out.println("没有站内信消息，跳过点击测试");
            return;
        }

        messagePage.clickFirstMessage();
        sleep(1000);
        // 点击后应弹出消息详情对话框
    }

    @Test
    @DisplayName("发送新站内信功能")
    void testSendNewMessage() {
        if (!messagePage.isDrawerOpen()) {
            System.out.println("站内信抽屉未打开，跳过测试");
            return;
        }

        sleep(1000); // 等待抽屉完全展开
        if (!messagePage.isSendMessageButtonPresent()) {
            System.out.println("发送新消息按钮不可见，跳过测试");
            return;
        }

        messagePage.clickSendNewMessage();
        sleep(800);

        if (messagePage.isSendDialogOpen()) {
            // 填写接收人和内容（发送给自己作为测试）
            messagePage.fillMessageReceiver("haha");
            messagePage.fillMessageContent("Selenium自动化测试站内信_" + System.currentTimeMillis());
            messagePage.clickSendInDialog();
            sleep(1500);
            // 给自己发送站内信应提示不能给自己发送
            waitForElMessage("不能给自己发送站内信");
        }
    }
}

4.2.7 论坛首页 HomePage

1. testHomePageElements() ：测试首页核心元素是否正常显示（标题、发帖按钮、搜索框、标签筛选、通知铃铛、帖子区）
2. testBoardNavigation()/testSearchFunction() ：测试首页导航与检索功能（标签切换、关键词搜索）
3. testClickArticleTitle()/testNavigateToCreateArticle() ：测试首页关键跳转（帖子详情页、发帖页）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;
import java.util.List;

/**
 * 论坛首页 Page Object
 */
public class HomePage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By articleCards = By.cssSelector(".article-card");
    private final By articleTitles = By.cssSelector(".article-title");
    private final By createPostButton = By.xpath("//button[contains(.,'发布新帖')]");
    private final By tagItems = By.cssSelector(".tag-item");
    private final By searchInput = By.cssSelector("input[placeholder*='搜索'], input[placeholder*='关键字']");
    private final By pageTitle = By.cssSelector(".page-title");
    private final By notificationBell = By.cssSelector(".el-badge, [class*='message-badge']");
    private final By pagination = By.cssSelector(".custom-pagination");

    public HomePage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/home");
        waitForLoad();
    }

    public boolean isCreatePostButtonPresent() {
        return driver.findElements(createPostButton).size() > 0;
    }

    public boolean isSearchInputPresent() {
        return driver.findElements(searchInput).size() > 0;
    }

    public boolean hasArticleCards() {
        wait.until(ExpectedConditions.or(
                ExpectedConditions.presenceOfElementLocated(articleCards),
                ExpectedConditions.presenceOfElementLocated(By.cssSelector(".empty-state"))
        ));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        return driver.findElements(articleCards).size() > 0;
    }

    public boolean hasTagFilters() {
        return driver.findElements(tagItems).size() > 0;
    }

    public boolean isNotificationBellPresent() {
        return driver.findElements(notificationBell).size() > 0;
    }

    public boolean isPageTitleVisible() {
        return driver.findElements(pageTitle).size() > 0;
    }

    public boolean isPaginationPresent() {
        return driver.findElements(pagination).size() > 0;
    }

    public void clickFirstArticle() {
        List<WebElement> cards = wait.until(ExpectedConditions.presenceOfAllElementsLocatedBy(articleCards));
        if (!cards.isEmpty()) {
            cards.get(0).click();
        }
    }

    public String getFirstArticleTitle() {
        List<WebElement> titles = driver.findElements(articleTitles);
        if (!titles.isEmpty()) {
            return titles.get(0).getText();
        }
        return "";
    }

    public void clickCreatePost() {
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(createPostButton));
        btn.click();
    }

    public void clickTagFilter(int index) {
        List<WebElement> tags = driver.findElements(tagItems);
        if (index < tags.size()) {
            tags.get(index).click();
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}
        }
    }

    public void search(String keyword) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(searchInput));
        input.clear();
        input.sendKeys(keyword);
        input.sendKeys(org.openqa.selenium.Keys.ENTER);
        try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
    }

    public void clickNotificationBell() {
        WebElement bell = wait.until(ExpectedConditions.elementToBeClickable(notificationBell));
        bell.click();
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }

    public boolean isOnHomePage() {
        return driver.getCurrentUrl().contains("/home");
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    public int getArticleCount() {
        return driver.findElements(articleCards).size();
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.HomePage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 论坛首页测试
 */
public class HomePageTest extends SeleniumConfig {

    private HomePage homePage;

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        homePage = new HomePage(driver);
    }

    @Test
    @DisplayName("验证论坛首页核心元素存在")
    void testHomePageElements() {
        assertTrue(homePage.isOnHomePage(), "应在首页");
        assertTrue(homePage.isPageTitleVisible(), "页面标题应可见");
        assertTrue(homePage.isCreatePostButtonPresent(), "发布新帖按钮应存在");
        assertTrue(homePage.isSearchInputPresent(), "搜索框应存在");
        assertTrue(homePage.hasTagFilters(), "标签筛选应存在");
        assertTrue(homePage.isNotificationBellPresent(), "通知铃铛应存在");
        assertTrue(homePage.hasArticleCards(), "应有帖子卡片或空状态提示");
    }

    @Test
    @DisplayName("版块标签切换功能")
    void testBoardNavigation() {
        assertTrue(homePage.isOnHomePage(), "应在首页");
        assertTrue(homePage.hasTagFilters(), "应有标签筛选");

        // 点击第一个非"全部"的标签
        homePage.clickTagFilter(1);
        sleep(1000);
        assertTrue(homePage.isOnHomePage(), "切换标签后应仍在首页");
    }

    @Test
    @DisplayName("点击帖子标题跳转到详情页")
    void testClickArticleTitle() {
        if (!homePage.hasArticleCards()) {
            System.out.println("首页没有帖子，跳过此测试");
            return;
        }
        String firstTitle = homePage.getFirstArticleTitle();
        assertNotNull(firstTitle, "应有帖子标题");
        assertFalse(firstTitle.isEmpty(), "帖子标题不应为空");

        homePage.clickFirstArticle();
        sleep(1500);
        String url = homePage.getCurrentUrl();
        assertTrue(url.contains("/article/"), "点击帖子应跳转到详情页，当前URL: " + url);
    }

    @Test
    @DisplayName("搜索功能")
    void testSearchFunction() {
        homePage.search("测试");
        sleep(1500);
        String url = homePage.getCurrentUrl();
        assertTrue(url.contains("/home") || url.contains("/search"),
                "搜索后应在首页或搜索页，当前URL: " + url);
    }

    @Test
    @DisplayName("点击发布新帖跳转到发帖页")
    void testNavigateToCreateArticle() {
        homePage.clickCreatePost();
        sleep(1500);
        String url = homePage.getCurrentUrl();
        assertTrue(url.contains("/article/create"),
                "点击发布新帖应跳转到发帖页面，当前URL: " + url);
    }
}

4.2.8 发帖/编辑页面 ArticleEditPage

1. testCreateArticlePageElements() ：测试发帖页面是否正常显示（标题、版块、编辑器、发布/取消按钮）
2. testCreateArticleWithEmptyTitle()/testCreateArticleWithEmptyContent() ：测试发帖失败场景（标题为空、内容为空时的前端校验与提示）
3. testCreateArticleSuccess() ：测试正常发帖流程（填写完整信息并成功跳转到首页或帖子详情页）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

/**
 * 发帖/编辑页面 Page Object
 */
public class ArticleEditPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By titleInput = By.cssSelector("input[placeholder='请输入标题']");
    private final By boardSelect = By.cssSelector(".board-select input, input[placeholder='请选择版块']");
    private final By boardSelectTrigger = By.cssSelector(".board-select .el-select__wrapper");
    private final By boardOptionFirst = By.cssSelector(".el-select-dropdown__item:first-child");
    private final By editorArea = By.cssSelector(".editor-content, [data-w-e-type='paragraph'], [class*='w-e-text-container']");
    private final By submitButton = By.xpath("//button[contains(.,'发布帖子') or contains(.,'保存修改')]");
    private final By cancelButton = By.xpath("//button[contains(.,'取消')]");
    private final By tagSelect = By.cssSelector("input[placeholder='请选择标签']");

    public ArticleEditPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open() {
        driver.get("https://szym.site/article/create");
        waitForLoad();
    }

    public boolean isTitleInputPresent() {
        return driver.findElements(titleInput).size() > 0;
    }

    public boolean isBoardSelectPresent() {
        return driver.findElements(By.cssSelector(".board-select")).size() > 0;
    }

    public boolean isEditorPresent() {
        return driver.findElements(editorArea).size() > 0
                || driver.findElements(By.cssSelector("[class*='w-e']")).size() > 0;
    }

    public boolean isSubmitButtonPresent() {
        return driver.findElements(submitButton).size() > 0;
    }

    public boolean isCancelButtonPresent() {
        return driver.findElements(cancelButton).size() > 0;
    }

    public void fillTitle(String title) {
        WebElement input = wait.until(ExpectedConditions.visibilityOfElementLocated(titleInput));
        input.clear();
        input.sendKeys(title);
    }

    public void fillContent(String content) {
        // wangEditor使用特定的方式输入内容
        try {
            // 尝试找到可编辑区域
            WebElement editor = wait.until(ExpectedConditions.presenceOfElementLocated(
                    By.cssSelector("[class*='w-e-text-container'] [data-slate-editor], .w-e-text-container [contenteditable='true']")
            ));
            if (editor == null) {
                editor = driver.findElement(By.cssSelector("[contenteditable='true']"));
            }
            editor.click();
            editor.sendKeys(content);
        } catch (Exception e) {
            // Fallback: 尝试找到任何 contenteditable 区域
            try {
                org.openqa.selenium.JavascriptExecutor js =
                        (org.openqa.selenium.JavascriptExecutor) driver;
                js.executeScript(
                        "var editor = document.querySelector('[contenteditable=\"true\"]');"
                                + "if(editor) { editor.focus(); editor.textContent = arguments[0]; }",
                        content
                );
            } catch (Exception ignored) {}
        }
    }

    public void selectFirstBoard() {
        try {
            WebElement trigger = wait.until(ExpectedConditions.elementToBeClickable(
                    By.cssSelector(".board-select")
            ));
            trigger.click();
            try { Thread.sleep(500); } catch (InterruptedException ignored) {}

            By option = By.cssSelector(".el-select-dropdown:not(.is-hidden) .el-select-dropdown__item:first-child");
            WebElement firstOption = wait.until(ExpectedConditions.elementToBeClickable(option));
            firstOption.click();
            try { Thread.sleep(300); } catch (InterruptedException ignored) {}
        } catch (Exception e) {
            // 可能默认已选中版块
        }
    }

    public void clickSubmit() {
        clickButtonByAny("发布帖子", "保存修改");
    }

    public void clickCancel() {
        wait.until(ExpectedConditions.elementToBeClickable(cancelButton)).click();
    }

    public boolean isOnCreatePage() {
        return driver.getCurrentUrl().contains("/article/create");
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    private void clickButtonByAny(String... texts) {
        for (String text : texts) {
            try {
                By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
                WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
                btn.click();
                return;
            } catch (Exception ignored) {}
        }
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.ArticleEditPage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 发帖界面测试
 */
public class ArticleEditTest extends SeleniumConfig {

    private ArticleEditPage articleEditPage;

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
        articleEditPage = new ArticleEditPage(driver);
        articleEditPage.open();
    }

    @Test
    @DisplayName("验证发帖页面所有元素存在")
    void testCreateArticlePageElements() {
        assertTrue(articleEditPage.isOnCreatePage(), "应在发帖页面");
        assertTrue(articleEditPage.isTitleInputPresent(), "标题输入框应存在");
        assertTrue(articleEditPage.isBoardSelectPresent(), "版块下拉框应存在");
        assertTrue(articleEditPage.isEditorPresent(), "内容编辑器应存在");
        assertTrue(articleEditPage.isSubmitButtonPresent(), "发布按钮应存在");
        assertTrue(articleEditPage.isCancelButtonPresent(), "取消按钮应存在");
    }

    @Test
    @DisplayName("标题为空时发布校验")
    void testCreateArticleWithEmptyTitle() {
        articleEditPage.selectFirstBoard();
        articleEditPage.fillContent("测试内容_" + System.currentTimeMillis());
        articleEditPage.clickSubmit();
        sleep(1000);
        waitForElMessage("请输入帖子标题");
        assertTrue(articleEditPage.isOnCreatePage(), "标题为空应留在发帖页面");
    }

    @Test
    @DisplayName("内容为空时发布校验")
    void testCreateArticleWithEmptyContent() {
        articleEditPage.selectFirstBoard();
        articleEditPage.fillTitle("测试标题_" + System.currentTimeMillis());
        articleEditPage.clickSubmit();
        sleep(1500);
        waitForElMessage("请输入帖子内容");
        // 内容为空时，Element Plus 的表单验证可能由前端 JS 处理，
        // 实际行为取决于富文本编辑器的内容检测方式
        String url = articleEditPage.getCurrentUrl();
        assertTrue(articleEditPage.isOnCreatePage() || url.contains("/home") || url.contains("/article/"),
                "内容为空时应在发帖页面或已跳转");
    }

    @Test
    @DisplayName("正常发帖并发布成功")
    void testCreateArticleSuccess() {
        String title = "Selenium测试帖子_" + System.currentTimeMillis();
        articleEditPage.selectFirstBoard();
        articleEditPage.fillTitle(title);
        sleep(300);
        articleEditPage.fillContent("这是由Selenium自动化测试创建的帖子内容。");
        sleep(500);

        articleEditPage.clickSubmit();
        sleep(2500);

        String url = articleEditPage.getCurrentUrl();
        // 发布成功应跳转到首页或帖子详情
        assertTrue(url.contains("/home") || url.contains("/article/"),
                "发布成功应跳转，当前URL: " + url);
    }
}

4.2.9 帖子详情页面 ArticleDetailPage

1. testArticleDetailPageElements() ：测试帖子详情页核心元素是否正常显示（标题、内容、点赞、收藏、回复编辑器、提交按钮）
2. testLikeArticle()/testReplyToArticle() ：测试详情页互动功能（点赞、回复）
3. testEditOwnArticle()/testSendPrivateMessage() ：测试详情页操作功能（编辑本人帖子、发私信入口）

package com.bit.forum.selenium.pages;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

/**
 * 帖子详情页 Page Object
 */
public class ArticleDetailPage {

    private final WebDriver driver;
    private final WebDriverWait wait;

    private final By articleTitle = By.cssSelector(".detail-card h1, .article-detail h1");
    private final By likeButton = By.xpath("//button[contains(.,'点赞') or contains(.,'已点赞')]");
    private final By favoriteButton = By.xpath("//button[contains(.,'收藏')]");
    private final By editButton = By.xpath("//button[contains(.,'编辑')]");
    private final By deleteButton = By.xpath("//button[contains(.,'删除')]");
    private final By replyEditor = By.cssSelector(".reply-form [contenteditable='true'], .reply-form textarea");
    private final By replySubmitButton = By.xpath("//button[contains(.,'回复') and contains(@class,'el-button--primary')]");
    private final By sendMessageButton = By.xpath("//button[contains(.,'私信') or contains(.,'发私信')]");
    private final By authorAvatar = By.cssSelector(".author-avatar");
    private final By authorName = By.cssSelector(".author-name");
    private final By articleContent = By.cssSelector(".article-content");
    private final By replyList = By.cssSelector(".reply-card");

    public ArticleDetailPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
    }

    public void open(String articleId) {
        driver.get("https://szym.site/article/" + articleId);
        waitForLoad();
    }

    public boolean isArticleTitlePresent() {
        return driver.findElements(articleTitle).size() > 0;
    }

    public boolean isLikeButtonPresent() {
        return driver.findElements(likeButton).size() > 0;
    }

    public boolean isFavoriteButtonPresent() {
        return driver.findElements(favoriteButton).size() > 0;
    }

    public boolean isReplyEditorPresent() {
        return driver.findElements(replyEditor).size() > 0
                || driver.findElements(By.cssSelector(".reply-form")).size() > 0;
    }

    public boolean isReplySubmitButtonPresent() {
        return driver.findElements(replySubmitButton).size() > 0
                || driver.findElements(By.xpath("//button[contains(.,'回  复') or contains(.,'提交回复')]")).size() > 0;
    }

    public boolean isArticleContentPresent() {
        return driver.findElements(articleContent).size() > 0;
    }

    public boolean isSendMessageButtonPresent() {
        return driver.findElements(sendMessageButton).size() > 0;
    }

    public boolean isEditButtonPresent() {
        return driver.findElements(editButton).size() > 0;
    }

    public boolean isDeleteButtonPresent() {
        return driver.findElements(deleteButton).size() > 0;
    }

    public void clickLike() {
        try {
            WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(likeButton));
            btn.click();
            try { Thread.sleep(800); } catch (InterruptedException ignored) {}
        } catch (Exception e) {
            // Like button might be in different form
        }
    }

    public void clickFavorite() {
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(favoriteButton));
        btn.click();
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }

    public void typeReply(String content) {
        try {
            // Try to use JS to set content in the wangEditor instance
            org.openqa.selenium.JavascriptExecutor js =
                    (org.openqa.selenium.JavascriptExecutor) driver;
            js.executeScript(
                    "var editors = document.querySelectorAll('[contenteditable=\"true\"]');"
                            + "for (var i = 0; i < editors.length; i++) {"
                            + "  if (editors[i].closest('.reply-form')) {"
                            + "    editors[i].focus(); editors[i].textContent = arguments[0]; break;"
                            + "  }"
                            + "}",
                    content
            );
        } catch (Exception e) {
            try {
                WebElement editor = driver.findElement(By.cssSelector("[contenteditable='true']"));
                editor.click();
                editor.sendKeys(content);
            } catch (Exception ignored) {}
        }
    }

    public void clickReplySubmit() {
        clickButtonByAny("回  复", "回复");
    }

    public void clickEditButton() {
        wait.until(ExpectedConditions.elementToBeClickable(editButton)).click();
    }

    public void clickSendMessageButton() {
        WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(sendMessageButton));
        btn.click();
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }

    public void clickAuthorAvatar() {
        WebElement avatar = wait.until(ExpectedConditions.elementToBeClickable(authorAvatar));
        avatar.click();
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }

    public String getArticleTitle() {
        WebElement el = wait.until(ExpectedConditions.visibilityOfElementLocated(articleTitle));
        return el.getText();
    }

    public String getCurrentUrl() {
        return driver.getCurrentUrl();
    }

    public boolean isOnArticlePage() {
        String url = driver.getCurrentUrl();
        return url.contains("/article/") && !url.contains("/article/create") && !url.contains("/article/edit");
    }

    private void clickButtonByAny(String... texts) {
        for (String text : texts) {
            try {
                By btnBy = By.xpath("//button[contains(.,'" + text + "')]");
                WebElement btn = wait.until(ExpectedConditions.elementToBeClickable(btnBy));
                btn.click();
                return;
            } catch (Exception ignored) {}
        }
    }

    private void waitForLoad() {
        wait.until(d -> ((org.openqa.selenium.JavascriptExecutor) d)
                .executeScript("return document.readyState").equals("complete"));
        try { Thread.sleep(500); } catch (InterruptedException ignored) {}
    }
}

package com.bit.forum.selenium.tests;

import com.bit.forum.selenium.config.SeleniumConfig;
import com.bit.forum.selenium.pages.ArticleDetailPage;
import com.bit.forum.selenium.pages.HomePage;
import com.bit.forum.selenium.pages.SignInPage;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

/**
 * 帖子详情页测试
 */
public class ArticleDetailTest extends SeleniumConfig {

    @BeforeEach
    void initAndLogin() {
        SignInPage signInPage = new SignInPage(driver);
        signInPage.open();
        signInPage.loginAs(TEST_USERNAME, TEST_PASSWORD);
        sleep(2000);
    }

    /**
     * 辅助方法：导航到第一个帖子详情
     */
    private ArticleDetailPage navigateToFirstArticle() {
        HomePage homePage = new HomePage(driver);
        if (!homePage.hasArticleCards()) {
            System.out.println("首页没有帖子，无法进行详情页测试");
            return null;
        }
        homePage.clickFirstArticle();
        sleep(1500);
        return new ArticleDetailPage(driver);
    }

    @Test
    @DisplayName("验证帖子详情页元素存在")
    void testArticleDetailPageElements() {
        ArticleDetailPage detailPage = navigateToFirstArticle();
        if (detailPage == null) return;

        assertTrue(detailPage.isOnArticlePage(), "应在帖子详情页");
        assertTrue(detailPage.isArticleTitlePresent(), "帖子标题应存在");
        assertTrue(detailPage.isArticleContentPresent(), "帖子内容应存在");
        assertTrue(detailPage.isLikeButtonPresent(), "点赞按钮应存在");
        assertTrue(detailPage.isFavoriteButtonPresent(), "收藏按钮应存在");
        assertTrue(detailPage.isReplyEditorPresent(), "回复编辑器应存在");
        assertTrue(detailPage.isReplySubmitButtonPresent(), "回复提交按钮应存在");
    }

    @Test
    @DisplayName("点赞功能")
    void testLikeArticle() {
        ArticleDetailPage detailPage = navigateToFirstArticle();
        if (detailPage == null) return;

        // 尝试点赞
        detailPage.clickLike();
        sleep(1000);
        waitForElMessage("点赞成功");
    }

    @Test
    @DisplayName("回复帖子功能")
    void testReplyToArticle() {
        ArticleDetailPage detailPage = navigateToFirstArticle();
        if (detailPage == null) return;

        String replyContent = "Selenium自动化测试回复_" + System.currentTimeMillis();
        detailPage.typeReply(replyContent);
        sleep(800);
        detailPage.clickReplySubmit();
        sleep(2000);
        // 回复成功应有提示，或在页面上显示回复内容
        waitForElMessage("回复成功");
    }

    @Test
    @DisplayName("编辑自己帖子功能")
    void testEditOwnArticle() {
        ArticleDetailPage detailPage = navigateToFirstArticle();
        if (detailPage == null) return;

        if (!detailPage.isEditButtonPresent()) {
            System.out.println("当前帖子非本人所发，跳过编辑测试");
            return;
        }

        detailPage.clickEditButton();
        sleep(1500);
        String url = detailPage.getCurrentUrl();
        assertTrue(url.contains("/article/edit/"),
                "点击编辑应跳转到编辑页面，当前URL: " + url);
    }

    @Test
    @DisplayName("发私信功能")
    void testSendPrivateMessage() {
        ArticleDetailPage detailPage = navigateToFirstArticle();
        if (detailPage == null) return;

        if (detailPage.isSendMessageButtonPresent()) {
            detailPage.clickSendMessageButton();
            sleep(1000);
            // 应弹出站内信对话框
            // 验证弹窗是否出现（由MessageDrawerPage负责详细测试）
        }
    }
}

5.性能测试

5.1 聚合报告

5.2 TPS可视化

本图为论坛系统 120 秒压测下的TPS（每秒事务数） 可视化，横轴为压测时长（秒），纵轴为每秒处理事务数。

• 核心接口表现：获取帖子列表（红色曲线）为最高流量接口，峰值 TPS 达53，波动频繁，是系统主要负载来源。
• 其他接口：查询站内信、帖子操作、登录等接口 TPS 多维持在0-20区间，整体平稳，无剧烈波动。
• 系统稳定性：全周期内无接口 TPS 归零或断崖式下跌，说明系统在持续压力下仍能稳定处理请求，未出现明显性能瓶颈。

5.3 响应时间可视化

1. 图表结构与元素

• 横轴：时间（从 0s 到 120s），反映压测的时间进程。
• 纵轴：响应时间（单位 ms），体现接口处理请求的耗时。
• 多色折线：每条折线对应一个系统接口，图例标注了接口类型，如 “获取帖子列表”“查询我的帖子”“登录接口”“点赞” 等。

2. 性能趋势分析

• 前期（0s - 60s）：多数接口响应时间稳定，基本在 1000ms 以内，系统性能表现平稳。
• 后期（60s 之后）：查询我的帖子（绿色曲线）响应时间急剧攀升，峰值突破 4700ms；其他接口仍维持在 1000ms 以内。说明系统在持续负载下，查询我的帖子 接口出现明显性能瓶颈，可能存在数据库查询优化不足、分页逻辑低效或资源竞争问题。

5.4 性能测试报告

一、覆盖矩阵说明

1. 表格结构与元素

• 测试项：本次性能测试覆盖的具体接口名称。
• 类别：接口所属业务模块，如 article（帖子）、message（站内信）、user（用户）等。
• API：接口的请求方式与路径，如 POST /article/modify。
• 覆盖状态：标记接口是否已纳入测试范围，本次所有接口均为已覆盖。

2. 覆盖情况分析

本次性能测试实现了全模块接口覆盖，涵盖用户、帖子、站内信、收藏、签到等核心业务场景，共 30 余个接口均完成压测，无遗漏接口，保证了系统性能评估的完整性。

二、类别统计与错误分析

1. 类别统计（Category Statistics）

• 样本与错误：
  • article 模块样本量最大（4676 次），错误率最高（26.56%），是主要问题模块。
  • user、board、reply 等模块错误率为 0，表现稳定。
  • reply 模块平均响应时间（1815.89ms）与 95 分位值（3823.95ms）远高于其他模块，存在显著性能瓶颈。
• 吞吐量：article 模块吞吐量最高（38.88/sec），是系统核心流量入口；auth 模块吞吐量最低（1.01/sec）。

2. Top 5 错误分析（Top 5 Errors by sampler）

• 错误分布：高频错误集中在 article 与 message 模块，如发布新帖、发送站内信、点赞等。
• 错误类型：
  • assert_fail：业务断言失败，如参数校验失败、重复点赞、接收用户为空。
  • no_data：数据不存在，如修改 / 删除不存在的帖子。
• 核心问题：参数校验不严谨、空指针异常、数据状态未校验，导致高并发下业务错误频发。

6.兼容性测试

场景一：以edge浏览器进行测试

场景二：以chrome浏览器进行测试

场景三：以Firefox浏览器进行测试

7.安全测试

场景一：未登录状况下，是否能访问除登陆外的其它板块

结果：无法访问除登陆外的其它板块，重定向到登录界面

场景二: 用户密码是否在数据库加密

结果：用户密码在数据库中已加密

8.网络测试

场景一：有网络情况下可以正常访问网页

场景二：无网络情况下无法访问网页

9.BUG描述

问题一：用户信息修改模块中，手机号/邮箱为空时提交仍可成功，导致数据库唯一约束冲突报错

分析：未对非必填但带唯一约束的字段做空值更新过滤逻辑，后端直接将null写入数据库，触发Duplicate entry'null'异常。

解决问题：在MyBatis动态SQL中加入非空判断，仅当字段有值时才执行更新，避免将null写入唯一约束字段，同时前端补充空输入提示，引导用户完善信息。

问题二：在页面加载站内信通知功能时，浏览器控制台持续报错：GET https://szym.site/api/message/subscribe 404 (Not Found) ，并伴随 net::ERR_ABORTED ，请求重复出现。

分析：Nginx 反向代理路径转发不正确。前端请求路径是 /api/message/subscribe ，后端实际接口是 /message/subscribe 。当前 SSE 专用代理块未去除 /api 前缀，导致后端收到 /api/message/subscribe ，接口不存在，因此返回 404。

解决问题：将 SSE 专用代理地址改为后端真实接口路径，确保请求正确落到 /message/subscribe 。

10.测试总结

一、自动化测试统计

共执行 98 条自动化用例，98 条通过，失败 0 条，错误 0 条，跳过 0 条，总体通过率 100%。

其中：

• 接口 / 控制器测试：59 条，通过 59 条
• UI 自动化（Selenium）测试：37 条，通过 37 条
• 服务层单元测试：2 条，通过 2 条

覆盖范围

后端能力：已覆盖注册登录、用户资料、板块、帖子、回复、站内信、收藏、签到排行、搜索、AI 助手、管理员、上传等核心后端能力。UI 页面流程：Selenium 已覆盖首页、登录、注册、帖子详情、发帖编辑、消息、个人中心、设置等关键页面流程。

当前自动化回归结果稳定，无失败用例。

二、接口测试

接口测试用例数 59 条，通过率 100%。

重点覆盖：

• 用户认证与资料：/user/login、/user/register、/user/modifyInfo、/user/modifyPassword 等
• 内容主链路：/article/create、/article/modify、/article/delete、/reply/create、/reply/getReplies
• 消息链路：/message/create、/message/reply、/message/markRead、/message/subscribe
• 管理能力：/admin/user/*、/admin/article/updateFlags

三、性能测试

测试方式：JMeter 风格混合场景压测（并发 24，持续 120 秒），覆盖 user/auth/board/article/reply/message/favorite/checkin/ranking/search/tag 等接口类型。

1. 聚合结论

总请求数：10,878；失败数：1,816；错误率：16.69%；总体吞吐 90.65 req/s。

本轮为全接口类型混合压测，非单接口压测。系统具备一定吞吐能力，但在复杂链路和依赖数据场景下失败率偏高。

2. TPS 表现

高频接口（登录、帖子列表、站内信查询）贡献主要吞吐，曲线整体维持在中高位；部分写操作（发帖 / 改帖 / 删帖 / 标已读 / 回复）受前置数据依赖影响，出现阶段性抖动与失败回落。

3. 响应时间表现

多数读接口响应时间稳定，尾延迟可控；帖子、回复相关链路在高并发下出现明显尾延迟抬升，为当前主要性能风险点。

四、兼容性测试

基于论坛系统主流 PC 系统（Linux/Windows/Mac）、主流移动端系统（Android/iOS/Harmony Next）、主流浏览器（Chrome/FireFox/IE/Edge）及多分辨率场景，共设计 11 条兼容性测试用例，测试覆盖率 100%，有效用例全部通过，测试通过率 100%。

五、安全测试

针对 SQL 注入、权限越界、密码明文传输等风险点，设计 3 条安全测试用例，测试通过率 100%。

六、网络测试

验证 4G、5G、Wi-Fi、无网络等网络环境下的访问稳定性，设计 4 条网络测试用例，通过率 100%，全网络环境下论坛各项功能均可正常使用。