Spring Boot测试报告 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

--- name: SpringBoot-MyBatis-UnitTesting version: 1.0.0 description: | 专业的Spring Boot + MyBatis + MySQL项目单元测试技能，提供全面的测试覆盖策略。当用户需要为Spring Boot项目编写单元测试时使用此技能，特别是包含： - 完整的正常流程测试 - 充分的异常场景测试 - 全面的边界值测试 - MyBatis Mapper层测试 - Service层业务逻辑测试 - Controller层API测试 - 集成测试和端到端测试适用于：JUnit 5、Mockito、AssertJ、Hamcrest、H2数据库、Testcontainers等技术栈。 author: WorkBuddy User license: MIT repository: https://github.com/your-repo/springboot-unit-testing tags: [spring-boot, mybatis, unit-testing, java, junit, mockito, mysql, testing] --- # Spring Boot + MyBatis 单元测试专家 ## 技能概述本技能提供Spring Boot + MyBatis + MySQL项目的专业单元测试解决方案，确保： 1. **正常流程全面覆盖** - 所有业务逻辑都有对应的成功测试 2. **异常场景充分测试** - 各种错误情况和异常处理都有测试验证 3. **边界值完整验证** - 数据边界、参数边界、状态边界都有测试 4. **分层测试策略** - Mapper、Service、Controller各层都有专业测试方法 ## 快速开始 ### 1. Maven依赖配置查看 [references/dependencies.md](references/dependencies.md) 获取完整的测试依赖配置。 ### 2. 测试结构 - **Mapper层**: 使用 `@MybatisTest` + H2内存数据库 - **Service层**: 使用 `@ExtendWith(MockitoExtension.class)` + Mock依赖 - **Controller层**: 使用 `@WebMvcTest` + MockMvc - **集成测试**: 使用 `@SpringBootTest` + Testcontainers ### 3. 测试覆盖率目标 - Mapper层: 90%+ (覆盖所有SQL语句) - Service层: 95%+ (覆盖所有业务逻辑分支) - Controller层: 85%+ (覆盖所有API端点) - 异常测试: 100% (所有异常处理逻辑) - 边界测试: 100% (所有边界条件) ## 核心测试策略 ### 正常流程测试 (Normal Flow Testing) 每个业务方法都需要以下测试： - **成功场景测试**: 验证方法在理想条件下的行为 - **多数据测试**: 测试不同数据组合下的表现 - **状态转换测试**: 验证状态机的正确转换 - **并发安全测试**: 确保线程安全（如果适用） ### 异常流程测试 (Exception Flow Testing) 每个可能抛出的异常都需要： - **参数验证异常**: 测试无效参数的异常处理 - **业务逻辑异常**: 测试业务规则违反的异常 - **数据不存在异常**: 测试查询不到数据的异常 - **并发异常**: 测试并发冲突的异常处理 - **外部依赖异常**: 测试外部服务失败的异常 ### 边界值测试 (Boundary Value Testing) 所有输入参数都需要边界测试： - **数值边界**: 最小/最大/临界值测试 - **字符串边界**: 空/null/最大长度/特殊字符测试 - **集合边界**: 空集合/单元素/最大容量测试 - **时间边界**: 最小/最大时间/时区边界测试 - **状态边界**: 初始/中间/最终状态测试 ## 测试模板 ### Mapper层测试模板 ```java // 查看完整模板: references/mapper-test-template.java @MybatisTest @AutoConfigureTestDatabase(replace = Replace.NONE) @Sql("/test-data.sql") class [Entity]MapperTest { // CRUD操作测试 // 复杂查询测试 // 事务边界测试 // 性能边界测试 } ``` ### Service层测试模板 ```java // 查看完整模板: references/service-test-template.java @ExtendWith(MockitoExtension.class) class [Entity]ServiceTest { // 业务逻辑测试 // 异常处理测试 // 事务管理测试 // 并发安全测试 } ``` ### Controller层测试模板 ```java // 查看完整模板: references/controller-test-template.java @WebMvcTest([Entity]Controller.class) class [Entity]ControllerTest { // HTTP方法测试 // 请求参数测试 // 响应格式测试 // 错误处理测试 } ``` ### 集成测试模板 ```java // 查看完整模板: references/integration-test-template.java @SpringBootTest @AutoConfigureMockMvc @Transactional class [Feature]IntegrationTest { // 端到端流程测试 // 数据一致性测试 // 性能基准测试 // 安全边界测试 } ``` ## 测试数据管理 ### 测试数据策略 1. **静态测试数据**: 使用 `@Sql` 注解导入SQL文件 2. **动态测试数据**: 使用Builder模式创建测试对象 3. **随机测试数据**: 使用Faker库生成随机数据 4. **边界测试数据**: 专门测试边界条件的数据 ### 测试数据工厂查看 [references/test-data-factory.java](references/test-data-factory.java) 获取测试数据工厂实现。 ### SQL测试数据文件查看 [references/test-data-examples.sql](references/test-data-examples.sql) 获取测试SQL示例。 ## 特殊场景测试 ### 1. 事务测试 ```java @Test @Transactional(propagation = Propagation.NEVER) void testTransactionRollback() { // 测试事务回滚 } @Test void testTransactionPropagation() { // 测试事务传播 } ``` ### 2. 并发测试 ```java @Test void testConcurrentAccess() throws InterruptedException { // 使用CountDownLatch或CompletableFuture测试并发 } ``` ### 3. 性能测试 ```java @Test @Timeout(5) // 5秒超时 void testPerformanceBoundary() { // 性能边界测试 } ``` ### 4. 安全测试 ```java @Test void testSecurityConstraints() { // 权限验证测试 // 数据隔离测试 } ``` ## 测试工具和最佳实践 ### 断言选择指南 - **基本断言**: 使用JUnit 5的 `assertEquals()`、`assertThrows()` - **流式断言**: 使用AssertJ的 `assertThat()` 链式调用 - **匹配器断言**: 使用Hamcrest的 `assertThat()` + Matcher - **自定义断言**: 创建领域特定的断言方法 ### Mock使用指南 - **最小化Mock**: 只Mock外部依赖 - **验证调用**: 使用 `verify()` 验证方法调用 - **参数匹配**: 使用 `any()`, `eq()`, `argThat()` 等 - **异常模拟**: 使用 `when().thenThrow()` 模拟异常 ### 测试生命周期 - **@BeforeEach**: 准备测试数据 - **@AfterEach**: 清理测试数据 - **@BeforeAll**: 初始化测试环境 - **@AfterAll**: 清理测试环境 ## 质量保证 ### 代码覆盖率检查 ```bash # 生成覆盖率报告 mvn clean test jacoco:report # 检查覆盖率阈值 mvn jacoco:check ``` ### 测试代码质量 - **可读性**: 测试代码应该像文档一样清晰 - **可维护性**: 避免重复代码，使用工厂模式 - **可执行性**: 测试应该快速执行，独立运行 - **可调试性**: 提供清晰的失败信息 ### 测试命名规范 - **方法名**: `test[场景]_[条件]_[期望结果]` - **测试类**: `[Entity][Layer]Test` - **数据工厂**: `TestDataFactory` - **测试文件**: `test-[feature].sql` ## 故障排除 ### 常见问题 1. **事务不回滚**: 检查 `@Transactional` 注解位置 2. **Mock不生效**: 检查 `@MockBean` 和 `@Mock` 的区别 3. **数据库连接失败**: 检查H2数据库配置 4. **测试数据污染**: 使用 `@Transactional` 或清理方法 ### 调试技巧 - 启用详细日志: `logging.level.root=DEBUG` - 使用 `@DirtiesContext` 重置Spring上下文 - 使用 `@TestPropertySource` 覆盖配置 - 使用 `MockMvc` 的 `andDo(print())` 打印请求详情 ## 扩展和定制 ### 自定义测试注解 ```java // 创建组合注解简化测试配置 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @MybatisTest @AutoConfigureTestDatabase @Sql("/test-data.sql") public @interface MybatisIntegrationTest { } ``` ### 测试工具扩展 - **自定义Matcher**: 创建领域特定的Matcher - **测试监听器**: 实现TestExecutionListener - **自定义Runner**: 扩展SpringJUnit4ClassRunner - **测试扩展**: 实现Extension接口 ### 性能优化 - **测试分组**: 使用 `@Tag` 分组测试 - **并行执行**: 配置Maven Surefire并行执行 - **数据库优化**: 使用H2内存数据库模式 - **Mock优化**: 避免不必要的Mock初始化 ## 参考资源 ### 核心文档 - [测试依赖配置](references/dependencies.md) - Maven依赖和配置 - [测试模板代码](references/) - 各层测试模板 - [测试数据示例](references/test-data-examples.sql) - SQL测试数据 - [测试工厂模式](references/test-data-factory.java) - 数据工厂实现 ### 最佳实践 - [测试策略指南](references/testing-strategies.md) - 详细测试策略 - [异常测试模式](references/exception-patterns.md) - 异常测试模式 - [边界测试方法](references/boundary-testing.md) - 边界测试方法 - [性能测试指南](references/performance-testing.md) - 性能测试指南 ### 工具脚本 - [测试覆盖率脚本](scripts/check-coverage.sh) - 检查覆盖率脚本 - [测试数据生成器](scripts/generate-test-data.py) - 生成测试数据 - [测试报告生成器](scripts/generate-test-report.py) - 生成测试报告 ## 使用示例当用户请求"为我的Spring Boot项目编写单元测试"时： 1. **分析项目结构** - 识别Entity、Mapper、Service、Controller 2. **选择测试策略** - 根据需求选择正常/异常/边界测试 3. **生成测试代码** - 使用模板生成对应层的测试 4. **配置测试环境** - 设置依赖、数据、配置 5. **验证测试覆盖** - 检查覆盖率，补充缺失测试本技能确保为每个Spring Boot项目提供专业、全面、可维护的单元测试解决方案。 --- ## 📦 发布信息 ### ClawHub发布配置此Skill已配置为可发布到ClawHub的技能市场。包含以下发布文件： 1. **clawhub.yml** - 发布配置文件 2. **package.json** - 标准化包描述 3. **LICENSE** - MIT许可证 4. **README.md** - 完整使用说明 ### 发布准备检查清单 ✅ **完整性检查** - [x] SKILL.md - 主技能文件 - [x] README.md - 使用文档 - [x] scripts/ - 3个实用脚本 - [x] references/ - 4个参考文档 - [x] examples/ - 2个示例测试代码 - [x] assets/ - 资源文件夹 ✅ **配置检查** - [x] clawhub.yml - 发布配置 - [x] package.json - 包管理 - [x] LICENSE - 许可证文件 ✅ **质量检查** - [x] 测试策略文档齐全 - [x] 代码示例完整可运行 - [x] 工具脚本可用 - [x] 依赖配置正确 ### 发布到ClawHub的步骤 1. **创建GitHub仓库**（推荐） ```bash git init git add . git commit -m "feat: Spring Boot单元测试Skill v1.0.0" git remote add origin https://github.com/your-repo/springboot-unit-testing.git git push -u origin main ``` 2. **准备发布包** ```bash # 打包Skill tar -czf springboot-unit-testing-skill-v1.0.0.tar.gz test-skill/ # 或使用zip zip -r springboot-unit-testing-skill-v1.0.0.zip test-skill/ ``` 3. **发布到ClawHub** - 访问ClawHub网站 (https://clawhub.com) - 注册/登录开发者账户 - 创建新Skill发布 - 填写Skill信息（参考clawhub.yml） - 上传打包文件 - 设置分类标签：spring-boot, testing, java - 提交审核 4. **维护和更新** - 定期更新测试策略 - 收集用户反馈 - 发布新版本 - 更新文档 ### Skill分类信息 - **类别**: 开发工具 / 测试框架 - **技术栈**: Spring Boot, MyBatis, MySQL, JUnit 5 - **适用场景**: 企业级Java项目单元测试 - **难度级别**: 中级（需要Java和Spring Boot基础） - **预估时间**: 使用此Skill可减少50%的测试开发时间 ### 用户支持 - **文档**: 完整的README和示例代码 - **问题反馈**: 通过GitHub Issues - **社区**: 分享测试经验和最佳实践 - **贡献**: 欢迎提交PR改进Skill ### 版本历史 - **v1.0.0** (2026-03-20) - 初始发布 - 完整的Spring Boot单元测试策略 - 正常流程、异常测试、边界值测试全面覆盖 - 3个实用工具脚本 - 4个详细参考文档 - 2个完整代码示例 --- **让Spring Boot项目的单元测试更专业、更全面、更高效！** FILE:clawhub.yml name: springboot-unit-testing version: 1.0.0 description: | 专业的Spring Boot + MyBatis + MySQL项目单元测试Skill 提供全面的测试覆盖策略，确保正常流程、异常场景、边界值的完整测试覆盖核心特点： - 分层测试架构：Mapper层、Service层、Controller层、集成测试 - 全面测试覆盖：正常流程、异常测试、边界值测试 - 专业工具脚本：覆盖率检查、测试报告生成、测试数据生成 - 详细参考文档：测试策略、异常模式、边界测试方法 tags: - spring-boot - mybatis - unit-testing - java - junit - mockito - mysql - testing author: name: WorkBuddy User email: user@example.com url: https://github.com/your-profile license: MIT dependencies: - name: java version: ">= 11" - name: maven version: ">= 3.6" - name: python version: ">= 3.8" files: - SKILL.md - README.md - scripts/ - references/ - assets/ installation: commands: - git clone https://github.com/your-repo/springboot-unit-testing.git - cd springboot-unit-testing - # 或者通过ClawHub安装 usage: - 加载Skill后，会获得Spring Boot单元测试的专业指导 - 可以使用脚本生成测试数据、检查覆盖率、生成测试报告 - 参考文档提供完整的测试策略和最佳实践 changelog: - version: 1.0.0 date: 2026-03-20 changes: - 初始版本发布 - 包含完整的测试策略文档 - 提供三个实用工具脚本 - 包含四个详细参考文档 repository: type: git url: https://github.com/your-repo/springboot-unit-testing.git bugs: url: https://github.com/your-repo/springboot-unit-testing/issues homepage: https://github.com/your-repo/springboot-unit-testing keywords: - "spring boot" - "unit test" - "mybatis" - "java testing" - "junit 5" - "mockito" - "test coverage" - "exception testing" - "boundary testing" FILE:package.json { "name": "springboot-unit-testing-skill", "version": "1.0.0", "description": "专业的Spring Boot + MyBatis + MySQL项目单元测试Skill，提供全面的测试覆盖策略", "main": "SKILL.md", "scripts": { "check-coverage": "./scripts/check-coverage.sh", "generate-data": "python scripts/generate-test-data.py .", "generate-report": "python scripts/generate-test-report.py .", "test": "echo \"Skill安装成功！请加载Skill获得专业测试指导\"" }, "keywords": [ "spring-boot", "unit-testing", "mybatis", "junit", "mockito", "testing", "java", "test-coverage", "exception-testing", "boundary-testing" ], "author": "WorkBuddy User ", "license": "MIT", "repository": { "type": "git", "url": "https://github.com/your-repo/springboot-unit-testing.git" }, "bugs": { "url": "https://github.com/your-repo/springboot-unit-testing/issues" }, "homepage": "https://github.com/your-repo/springboot-unit-testing#readme", "dependencies": {}, "devDependencies": {}, "engines": { "node": ">= 14.0.0", "python": ">= 3.8", "java": ">= 11", "maven": ">= 3.6" }, "files": [ "SKILL.md", "README.md", "scripts/", "references/", "assets/", "clawhub.yml", "LICENSE" ] } FILE:README.md # Spring Boot单元测试专家Skill [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Spring Boot](https://img.shields.io/badge/Spring%20Boot-2.7%2B-green.svg)](https://spring.io/projects/spring-boot) [![Java](https://img.shields.io/badge/Java-11%2B-blue.svg)](https://www.java.com) [![ClawHub](https://img.shields.io/badge/ClawHub-Skill-orange.svg)](https://clawhub.com) ## 🎯 概述这是一个专门用于Spring Boot + MyBatis + MySQL项目的专业单元测试Skill。提供全面的测试覆盖策略，确保： 1. **正常流程全面覆盖** - 所有业务逻辑都有对应的成功测试 2. **异常场景充分测试** - 各种错误情况和异常处理都有测试验证 3. **边界值完整验证** - 数据边界、参数边界、状态边界都有测试 4. **分层测试策略** - Mapper、Service、Controller各层都有专业测试方法 ## 📦 快速安装 ### 从ClawHub安装（推荐） ```bash # 待发布到ClawHub后可用 clawhub install springboot-unit-testing ``` ### 手动安装 ```bash # 克隆仓库 git clone https://github.com/your-repo/springboot-unit-testing.git # 或下载Release包 wget https://github.com/your-repo/springboot-unit-testing/releases/download/v1.0.0/springboot-unit-testing-skill-v1.0.0.zip unzip springboot-unit-testing-skill-v1.0.0.zip ``` ## 📁 目录结构 ``` test-skill/ ├── SKILL.md # Skill主文件 ├── README.md # 说明文档 ├── scripts/ # 工具脚本 │ ├── check-coverage.sh # 覆盖率检查脚本 │ ├── generate-test-data.py # 测试数据生成脚本 │ └── generate-test-report.py # 测试报告生成脚本 ├── references/ # 参考文档 │ ├── dependencies.md # 依赖配置 │ ├── testing-strategies.md # 测试策略 │ ├── exception-patterns.md # 异常测试模式 │ └── boundary-testing.md # 边界值测试 └── assets/ # 资源文件 ``` ## 🚀 快速开始 ### 1. 安装依赖查看 [references/dependencies.md](references/dependencies.md) 获取完整的Maven依赖配置。 ### 2. 运行测试检查 ```bash # 运行测试 mvn clean test # 检查覆盖率 ./scripts/check-coverage.sh # 生成测试报告 python scripts/generate-test-report.py . ``` ### 3. 生成测试数据 ```bash python scripts/generate-test-data.py /path/to/your/project ``` ## 🎯 核心功能 ### 1. 分层测试策略 - **Mapper层**: `@MybatisTest` + H2内存数据库 - **Service层**: `@ExtendWith(MockitoExtension.class)` + Mock依赖 - **Controller层**: `@WebMvcTest` + MockMvc - **集成测试**: `@SpringBootTest` + Testcontainers ### 2. 全面测试覆盖 - **正常流程测试**: 成功场景、数据组合、状态转换 - **异常流程测试**: 参数验证、业务规则、数据访问、外部依赖异常 - **边界值测试**: 数值边界、字符串边界、集合边界、时间边界、状态边界 ### 3. 测试数据管理 - **静态数据**: SQL文件导入 - **动态数据**: TestDataFactory模式 - **随机数据**: Faker库生成 - **边界数据**: 专门测试边界条件 ## 📊 覆盖率目标 | 测试类型 | 覆盖率目标 | 说明 | |---------|-----------|------| | Mapper层 | 90%+ | 覆盖所有SQL语句 | | Service层 | 95%+ | 覆盖所有业务逻辑分支 | | Controller层 | 85%+ | 覆盖所有API端点 | | 异常测试 | 100% | 所有异常处理逻辑 | | 边界测试 | 100% | 所有边界条件 | ## 🔧 工具脚本 ### 1. 覆盖率检查 (`check-coverage.sh`) ```bash # 运行测试并检查覆盖率 ./scripts/check-coverage.sh # 输出包括： # - 测试执行结果 # - 覆盖率百分比 # - 阈值检查 # - 测试类别分析 # - 质量建议 ``` ### 2. 测试报告生成 (`generate-test-report.py`) ```python # 生成详细测试报告 python scripts/generate-test-report.py /path/to/project # 生成文件： # - test-report.json (JSON格式) # - test-report.html (HTML可视化) ``` ### 3. 测试数据生成 (`generate-test-data.py`) ```python # 生成完整测试数据 python scripts/generate-test-data.py /path/to/project # 生成文件： # - test-data.sql (SQL数据) # - test-data.json (JSON数据) # - test-data.yml (YAML配置) # - TestDataFactory.java (Java工厂类) ``` ## 📚 参考文档 ### 1. 依赖配置 (`references/dependencies.md`) - Maven依赖完整配置 - 测试环境配置 - 版本兼容性说明 ### 2. 测试策略 (`references/testing-strategies.md`) - 测试分层架构 - 测试设计原则 - 执行策略优化 ### 3. 异常测试 (`references/exception-patterns.md`) - 异常分类体系 - 异常测试模式 - 最佳实践指南 ### 4. 边界测试 (`references/boundary-testing.md`) - 边界值概念 - 测试方法 - 各种边界类型详解 ## 🎨 最佳实践 ### 1. 测试命名规范 ```java // Given-When-Then格式 test[方法名]_[条件]_[期望结果] // 示例 testGetUserById_Success() testCreateUser_InvalidEmail_ThrowsException() testUpdateUser_NotFound_Returns404() ``` ### 2. 测试结构 ```java @Test void testMethod() { // 1. Given - 准备测试数据 when(mock.method()).thenReturn(result); // 2. When - 执行测试方法 Object actual = service.method(); // 3. Then - 验证结果 assertThat(actual).isEqualTo(expected); verify(mock, times(1)).method(); } ``` ### 3. 测试数据管理 ```java // 使用TestDataFactory User user = TestDataFactory.createNormalUser(); User boundaryUser = TestDataFactory.createBoundaryUser(); User invalidUser = TestDataFactory.createInvalidUser(); // 使用@Sql导入 @Sql("/test-data.sql") @Test void testWithData() { // 测试方法 } ``` ## 🔍 故障排除 ### 常见问题 1. **事务不回滚** ```java // 确保使用@Transactional @Test @Transactional void testWithTransaction() { // 测试代码 } ``` 2. **Mock不生效** ```java // Service测试使用@Mock @Mock private UserMapper userMapper; // Controller测试使用@MockBean @MockBean private UserService userService; ``` 3. **测试数据污染** ```java // 使用@Transactional自动回滚 // 或使用@AfterEach清理 @AfterEach void tearDown() { cleanupTestData(); } ``` ### 调试技巧 1. **启用详细日志** ```yaml logging: level: com.example.demo: DEBUG org.springframework: DEBUG ``` 2. **打印请求详情** ```java mockMvc.perform(get("/api/users/1")) .andDo(print()); // 打印请求响应详情 ``` ## 📈 质量保证 ### 1. 持续集成 ```yaml # GitHub Actions示例 name: Test Coverage on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Run tests with coverage run: | mvn clean test jacoco:report ./scripts/check-coverage.sh ``` ### 2. 质量门禁 ```xml BUNDLE LINE COVEREDRATIO 0.85 ``` ## 🚀 扩展定制 ### 1. 自定义测试注解 ```java // 创建组合注解 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @MybatisTest @AutoConfigureTestDatabase @Sql("/test-data.sql") public @interface MybatisIntegrationTest { } ``` ### 2. 测试工具扩展 ```java // 自定义断言 public class CustomAssertions { public static void assertUserEquals(User expected, User actual) { assertThat(actual.getUsername()).isEqualTo(expected.getUsername()); assertThat(actual.getEmail()).isEqualTo(expected.getEmail()); } } ``` ### 3. 性能优化 ```java // 测试分组 @Tag("fast") @Test void testFastOperation() { ... } @Tag("slow") @Test void testSlowOperation() { ... } ``` ## 📋 使用示例当需要为Spring Boot项目编写单元测试时： 1. **分析项目结构** - 识别Entity、Mapper、Service、Controller 2. **选择测试策略** - 根据需求选择正常/异常/边界测试 3. **生成测试代码** - 使用模板生成对应层的测试 4. **配置测试环境** - 设置依赖、数据、配置 5. **验证测试覆盖** - 检查覆盖率，补充缺失测试 ## 📞 支持 ### 问题反馈 1. 检查参考文档中的解决方案 2. 运行诊断脚本检查配置 3. 查看生成的测试报告 ### 功能建议 1. 扩展测试覆盖类型 2. 添加新的测试工具 3. 优化测试执行性能 ## 📄 许可证本Skill遵循MIT许可证，可自由使用、修改和分发。 ## 🙏 致谢感谢所有为Spring Boot测试生态系统做出贡献的开发者。 --- **记住**: 好的测试是高质量代码的基石。通过本Skill，您可以确保您的Spring Boot项目具有专业级的测试覆盖！ --- ## 📤 发布到ClawHub ### 发布准备本Skill已配置完整的发布文件： 1. **clawhub.yml** - ClawHub发布配置文件 2. **package.json** - 标准化包描述文件 3. **LICENSE** - MIT许可证 4. **完整的目录结构** - 包含脚本、参考文档、示例 ### 发布步骤 #### 步骤1：创建GitHub仓库（推荐） ```bash # 初始化Git仓库 git init git add . git commit -m "feat: Spring Boot单元测试Skill v1.0.0" git branch -M main # 在GitHub创建新仓库，然后： git remote add origin https://github.com/your-username/springboot-unit-testing.git git push -u origin main ``` #### 步骤2：创建发布包 ```bash # 打包整个Skill目录 tar -czf springboot-unit-testing-skill-v1.0.0.tar.gz test-skill/ # 或使用zip zip -r springboot-unit-testing-skill-v1.0.0.zip test-skill/ ``` #### 步骤3：在ClawHub发布 1. 访问 [ClawHub网站](https://clawhub.com) 2. 注册/登录开发者账户 3. 进入"发布Skill"页面 4. 填写Skill信息： - **名称**: springboot-unit-testing - **版本**: 1.0.0 - **描述**: 专业的Spring Boot + MyBatis + MySQL项目单元测试Skill - **分类**: 开发工具 / 测试框架 - **标签**: spring-boot, mybatis, unit-testing, java, junit, mockito - **许可证**: MIT 5. 上传打包文件 6. 提交审核 #### 步骤4：维护和更新 - 定期收集用户反馈 - 更新测试策略和最佳实践 - 发布新版本时更新changelog - 保持文档的最新性 ### 发布检查清单 ✅ **文件完整性** - [x] SKILL.md (主技能文件) - [x] README.md (使用文档) - [x] scripts/ (3个实用脚本) - [x] references/ (4个参考文档) - [x] examples/ (示例代码) - [x] assets/ (资源文件夹) ✅ **配置完整** - [x] clawhub.yml (发布配置) - [x] package.json (包管理) - [x] LICENSE (许可证) - [x] 测试数据文件 ✅ **质量保证** - [x] 测试策略文档齐全 - [x] 代码示例完整可运行 - [x] 工具脚本可用 - [x] 依赖配置正确 ### 发布后推广 1. **文档推广**: 确保README清晰易懂 2. **社区分享**: 在相关技术社区分享 3. **用户反馈**: 积极收集用户建议 4. **版本迭代**: 根据反馈持续改进 ### 联系方式 - **GitHub**: https://github.com/your-username/springboot-unit-testing - **Issue跟踪**: 使用GitHub Issues - **Pull Request**: 欢迎贡献改进 --- **🚀 现在您的Skill已经准备好发布到ClawHub，与全球的Spring Boot开发者分享专业的单元测试解决方案！** FILE:scripts/check-coverage.sh #!/bin/bash # Spring Boot测试覆盖率检查脚本 set -e # 遇到错误退出 # 颜色定义 RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' NC='\033[0m' # No Color # 覆盖率阈值 LINE_COVERAGE_THRESHOLD=85 BRANCH_COVERAGE_THRESHOLD=80 METHOD_COVERAGE_THRESHOLD=90 CLASS_COVERAGE_THRESHOLD=95 print_header() { echo -e "\n${BLUE}=========================================${NC}" echo -e "${BLUE} $1${NC}" echo -e "${BLUE}=========================================${NC}" } print_success() { echo -e "${GREEN}✅ $1${NC}" } print_warning() { echo -e "${YELLOW}⚠️ $1${NC}" } print_error() { echo -e "${RED}❌ $1${NC}" } check_prerequisites() { print_header "检查环境依赖" # 检查Maven if ! command -v mvn &> /dev/null; then print_error "Maven未安装" exit 1 fi print_success "Maven已安装: $(mvn --version | head -1)" # 检查Java if ! command -v java &> /dev/null; then print_error "Java未安装" exit 1 fi print_success "Java已安装: $(java -version 2>&1 | head -1)" # 检查项目根目录 if [ ! -f "pom.xml" ]; then print_error "当前目录不是Maven项目根目录" exit 1 fi print_success "Maven项目检测成功" } run_tests() { print_header "运行测试" echo "清理并运行测试..." mvn clean test if [ $? -eq 0 ]; then print_success "测试运行成功" else print_error "测试运行失败" exit 1 fi } generate_coverage_report() { print_header "生成覆盖率报告" echo "生成JaCoCo覆盖率报告..." mvn jacoco:report if [ $? -eq 0 ]; then print_success "覆盖率报告生成成功" else print_error "覆盖率报告生成失败" exit 1 fi } check_coverage_thresholds() { print_header "检查覆盖率阈值" local jacoco_xml="target/site/jacoco/jacoco.xml" if [ ! -f "$jacoco_xml" ]; then print_error "覆盖率报告文件不存在: $jacoco_xml" exit 1 fi # 解析JaCoCo XML文件 echo "解析覆盖率数据..." # 提取覆盖率数据 local line_coverage=$(xmlstarlet sel -t -v "//counter[@type='LINE']/@covered" -o "/" -v "//counter[@type='LINE']/@missed" "$jacoco_xml" 2>/dev/null | bc -l 2>/dev/null || echo "0") local branch_coverage=$(xmlstarlet sel -t -v "//counter[@type='BRANCH']/@covered" -o "/" -v "//counter[@type='BRANCH']/@missed" "$jacoco_xml" 2>/dev/null | bc -l 2>/dev/null || echo "0") local method_coverage=$(xmlstarlet sel -t -v "//counter[@type='METHOD']/@covered" -o "/" -v "//counter[@type='METHOD']/@missed" "$jacoco_xml" 2>/dev/null | bc -l 2>/dev/null || echo "0") local class_coverage=$(xmlstarlet sel -t -v "//counter[@type='CLASS']/@covered" -o "/" -v "//counter[@type='CLASS']/@missed" "$jacoco_xml" 2>/dev/null | bc -l 2>/dev/null || echo "0") # 计算百分比 line_coverage=$(echo "scale=2; $line_coverage * 100" | bc) branch_coverage=$(echo "scale=2; $branch_coverage * 100" | bc) method_coverage=$(echo "scale=2; $method_coverage * 100" | bc) class_coverage=$(echo "scale=2; $class_coverage * 100" | bc) # 显示覆盖率 echo -e "\n${BLUE}📊 当前覆盖率:${NC}" echo " 行覆盖率: $line_coverage%" echo " 分支覆盖率: $branch_coverage%" echo " 方法覆盖率: $method_coverage%" echo " 类覆盖率: $class_coverage%" # 检查阈值 local passed=true if (( $(echo "$line_coverage < $LINE_COVERAGE_THRESHOLD" | bc -l) )); then print_warning "行覆盖率低于阈值: $line_coverage% < ${LINE_COVERAGE_THRESHOLD}%" passed=false else print_success "行覆盖率达标: $line_coverage% >= ${LINE_COVERAGE_THRESHOLD}%" fi if (( $(echo "$branch_coverage < $BRANCH_COVERAGE_THRESHOLD" | bc -l) )); then print_warning "分支覆盖率低于阈值: $branch_coverage% < ${BRANCH_COVERAGE_THRESHOLD}%" passed=false else print_success "分支覆盖率达标: $branch_coverage% >= ${BRANCH_COVERAGE_THRESHOLD}%" fi if (( $(echo "$method_coverage < $METHOD_COVERAGE_THRESHOLD" | bc -l) )); then print_warning "方法覆盖率低于阈值: $method_coverage% < ${METHOD_COVERAGE_THRESHOLD}%" passed=false else print_success "方法覆盖率达标: $method_coverage% >= ${METHOD_COVERAGE_THRESHOLD}%" fi if (( $(echo "$class_coverage < $CLASS_COVERAGE_THRESHOLD" | bc -l) )); then print_warning "类覆盖率低于阈值: $class_coverage% < ${CLASS_COVERAGE_THRESHOLD}%" passed=false else print_success "类覆盖率达标: $class_coverage% >= ${CLASS_COVERAGE_THRESHOLD}%" fi if [ "$passed" = true ]; then print_success "所有覆盖率指标均达标！" return 0 else print_error "部分覆盖率指标未达标" return 1 fi } analyze_test_categories() { print_header "分析测试类别" local test_dir="src/test/java" if [ ! -d "$test_dir" ]; then print_warning "测试目录不存在: $test_dir" return fi # 统计各种测试类型 local unit_tests=0 local integration_tests=0 local controller_tests=0 local service_tests=0 local repository_tests=0 local exception_tests=0 local boundary_tests=0 # 查找Java测试文件 while IFS= read -r file; do local filename=$(basename "$file") local content=$(cat "$file" 2>/dev/null || echo "") # 分类统计 if [[ "$filename" == *IntegrationTest* ]] || [[ "$filename" == *IT.java ]]; then ((integration_tests++)) elif [[ "$filename" == *ControllerTest* ]]; then ((controller_tests++)) elif [[ "$filename" == *ServiceTest* ]]; then ((service_tests++)) elif [[ "$filename" == *RepositoryTest* ]] || [[ "$filename" == *MapperTest* ]]; then ((repository_tests++)) else ((unit_tests++)) fi # 内容分析 if [[ "$content" == *assertThrows* ]] || [[ "$content" == *Exception* ]]; then ((exception_tests++)) fi if [[ "$content" == *boundary* ]] || [[ "$content" == *Boundary* ]]; then ((boundary_tests++)) fi done < <(find "$test_dir" -name "*.java" -type f) # 显示统计结果 echo -e "\n${BLUE}📋 测试类别统计:${NC}" echo " 单元测试: $unit_tests" echo " 集成测试: $integration_tests" echo " Controller测试: $controller_tests" echo " Service测试: $service_tests" echo " Repository测试: $repository_tests" echo " 异常测试: $exception_tests" echo " 边界测试: $boundary_tests" # 检查是否缺少重要测试类型 if [ $controller_tests -eq 0 ]; then print_warning "缺少Controller层测试" fi if [ $service_tests -eq 0 ]; then print_warning "缺少Service层测试" fi if [ $repository_tests -eq 0 ]; then print_warning "缺少Repository/Mapper层测试" fi if [ $exception_tests -eq 0 ]; then print_warning "缺少异常处理测试" fi if [ $boundary_tests -eq 0 ]; then print_warning "缺少边界值测试" fi } check_test_quality() { print_header "检查测试质量" local issues=0 # 检查测试命名规范 echo "检查测试命名规范..." local bad_names=$(find src/test/java -name "*.java" -type f -exec grep -l "test[^A-Z]" {} \; 2>/dev/null || true) if [ -n "$bad_names" ]; then print_warning "发现不符合命名规范的测试文件:" echo "$bad_names" | while read -r file; do echo " - $file" done ((issues++)) else print_success "测试命名规范良好" fi # 检查测试方法长度 echo "检查测试方法长度..." local long_methods=$(find src/test/java -name "*.java" -type f -exec awk ' BEGIN { in_method=0; line_count=0; method_name="" } /@Test/ { in_method=1; line_count=0; method_name=""; next } /public void test/ && in_method==0 { in_method=1; line_count=0; method_name=$0; next } in_method && /^\s*}[[:space:]]*$/ { if (line_count > 50) { print FILENAME ":" method_name " - " line_count "行" } in_method=0; line_count=0; method_name=""; next } in_method { line_count++ } ' {} \; 2>/dev/null || true) if [ -n "$long_methods" ]; then print_warning "发现过长的测试方法:" echo "$long_methods" | head -5 | while read -r line; do echo " - $line" done ((issues++)) else print_success "测试方法长度合适" fi # 检查断言使用 echo "检查断言使用..." local no_assertions=$(find src/test/java -name "*.java" -type f -exec grep -l "@Test" {} \; | xargs grep -L "assert\|verify\|expect" 2>/dev/null || true) if [ -n "$no_assertions" ]; then print_warning "发现没有断言的测试方法:" echo "$no_assertions" | while read -r file; do echo " - $file" done ((issues++)) else print_success "所有测试都有断言" fi if [ $issues -eq 0 ]; then print_success "测试质量检查通过" else print_warning "发现 $issues 个测试质量问题" fi } generate_summary() { print_header "测试覆盖率检查总结" echo -e "${BLUE}🏁 检查完成!${NC}" echo "" echo "📁 覆盖率报告位置:" echo " - HTML报告: target/site/jacoco/index.html" echo " - XML报告: target/site/jacoco/jacoco.xml" echo "" echo "📈 覆盖率阈值:" echo " - 行覆盖率: ${LINE_COVERAGE_THRESHOLD}%" echo " - 分支覆盖率: ${BRANCH_COVERAGE_THRESHOLD}%" echo " - 方法覆盖率: ${METHOD_COVERAGE_THRESHOLD}%" echo " - 类覆盖率: ${CLASS_COVERAGE_THRESHOLD}%" echo "" echo "💡 建议:" echo " 1. 定期运行覆盖率检查" echo " 2. 添加缺失的测试类别" echo " 3. 优化测试代码质量" echo " 4. 集成到CI/CD流程" } main() { print_header "Spring Boot测试覆盖率检查" echo "项目: $(basename $(pwd))" echo "时间: $(date)" echo "" # 执行检查步骤 check_prerequisites run_tests generate_coverage_report check_coverage_thresholds analyze_test_categories check_test_quality generate_summary print_header "✅ 检查完成" } # 执行主函数 main "$@" FILE:scripts/generate-test-data.py #!/usr/bin/env python3 """ 测试数据生成脚本生成Spring Boot项目的测试数据 """ import os import sys import json import random from datetime import datetime, timedelta from pathlib import Path from typing import Dict, List, Any, Optional import yaml class TestDataGenerator: """测试数据生成器""" def __init__(self, project_root: str): self.project_root = Path(project_root).resolve() self.test_data_dir = self.project_root / "src" / "test" / "resources" self.test_data_dir.mkdir(parents=True, exist_ok=True) def generate_all_test_data(self) -> Dict[str, str]: """生成所有测试数据""" generated_files = {} # 生成SQL测试数据 sql_file = self.test_data_dir / "test-data.sql" sql_content = self._generate_sql_test_data() sql_file.write_text(sql_content, encoding="utf-8") generated_files["sql"] = str(sql_file) # 生成JSON测试数据 json_file = self.test_data_dir / "test-data.json" json_content = self._generate_json_test_data() json_file.write_text(json.dumps(json_content, indent=2, ensure_ascii=False), encoding="utf-8") generated_files["json"] = str(json_file) # 生成YAML测试数据 yaml_file = self.test_data_dir / "test-data.yml" yaml_content = self._generate_yaml_test_data() yaml_file.write_text(yaml.dump(yaml_content, allow_unicode=True, default_flow_style=False), encoding="utf-8") generated_files["yaml"] = str(yaml_file) # 生成边界值测试数据 boundary_file = self.test_data_dir / "boundary-test-data.sql" boundary_content = self._generate_boundary_test_data() boundary_file.write_text(boundary_content, encoding="utf-8") generated_files["boundary"] = str(boundary_file) # 生成异常测试数据 exception_file = self.project_root / "src" / "test" / "java" / "com" / "example" / "demo" / "TestDataFactory.java" exception_content = self._generate_test_data_factory() exception_file.parent.mkdir(parents=True, exist_ok=True) exception_file.write_text(exception_content, encoding="utf-8") generated_files["factory"] = str(exception_file) return generated_files def _generate_sql_test_data(self) -> str: """生成SQL测试数据""" now = datetime.now() sql = """-- 测试数据SQL文件 -- 自动生成于: {timestamp} -- 用于单元测试和集成测试 -- 清空表（测试前） DELETE FROM user; DELETE FROM order; DELETE FROM product; DELETE FROM category; -- 用户表测试数据 INSERT INTO user (id, username, email, phone, status, create_time, update_time) VALUES -- 正常用户数据 (1, 'normal_user', 'normal@example.com', '13800138000', 1, '{date1}', '{date2}'), (2, 'active_user', 'active@example.com', '13900139000', 1, '{date3}', '{date4}'), (3, 'inactive_user', 'inactive@example.com', '13700137000', 0, '{date5}', '{date6}'), -- 边界用户数据 (4, 'min_user', 'min@example.com', '13000000000', 0, '{date7}', '{date8}'), -- 最小状态 (5, 'max_user', 'max@example.com', '13999999999', 255, '{date9}', '{date10}'), -- 最大状态 (6, 'long_username', 'longusername@example.com', '13888888888', 1, '{date11}', '{date12}'), -- 特殊字符用户数据 (7, 'user_with_space', 'space@example.com', '13666666666', 1, '{date13}', '{date14}'), (8, 'user-with-dash', 'dash@example.com', '13555555555', 1, '{date15}', '{date16}'), (9, 'user.period', 'period@example.com', '13444444444', 1, '{date17}', '{date18}'), -- Unicode用户数据 (10, '中文用户', 'chinese@example.com', '13333333333', 1, '{date19}', '{date20}'), (11, '🎉emoji_user', 'emoji@example.com', '13222222222', 1, '{date21}', '{date22}'), -- 大量用户数据（性能测试） {bulk_users} -- 产品表测试数据 INSERT INTO product (id, name, price, stock, status, category_id, create_time) VALUES (1, '测试产品1', 99.99, 100, 1, 1, '{date1}'), (2, '测试产品2', 199.99, 50, 1, 1, '{date2}'), (3, '测试产品3', 299.99, 0, 0, 2, '{date3}'), -- 缺货产品 (4, '免费产品', 0.00, 999, 1, 2, '{date4}'), -- 免费产品 (5, '高价产品', 9999.99, 10, 1, 3, '{date5}'), -- 高价产品 -- 边界产品数据 (6, '最小价格产品', 0.01, 1, 1, 1, '{date6}'), (7, '最大价格产品', 999999.99, 1, 1, 1, '{date7}'), (8, '零库存产品', 100.00, 0, 1, 1, '{date8}'), (9, '大库存产品', 50.00, 10000, 1, 1, '{date9}'), -- 长名称产品 (10, '{long_product_name}', 150.00, 500, 1, 2, '{date10}'), -- 订单表测试数据 INSERT INTO `order` (id, order_no, user_id, total_amount, status, create_time, update_time) VALUES -- 正常订单 (1, 'ORD2024000001', 1, 299.97, 1, '{date1}', '{date2}'), (2, 'ORD2024000002', 2, 99.99, 2, '{date3}', '{date4}'), (3, 'ORD2024000003', 1, 199.99, 3, '{date5}', '{date6}'), -- 边界订单 (4, 'ORD2024000004', 3, 0.01, 1, '{date7}', '{date8}'), -- 最小金额 (5, 'ORD2024000005', 4, 999999.99, 1, '{date9}', '{date10}'), -- 最大金额 (6, 'ORD2024000006', 5, 0.00, 4, '{date11}', '{date12}'), -- 零金额订单 -- 不同状态订单 (7, 'ORD2024000007', 1, 150.00, 1, '{date13}', '{date14}'), -- 待支付 (8, 'ORD2024000008', 2, 250.00, 2, '{date15}', '{date16}'), -- 已支付 (9, 'ORD2024000009', 3, 350.00, 3, '{date17}', '{date18}'), -- 已发货 (10, 'ORD2024000010', 4, 450.00, 4, '{date19}', '{date20}'), -- 已完成 (11, 'ORD2024000011', 5, 550.00, 5, '{date21}', '{date22}'), -- 已取消 -- 分类表测试数据 INSERT INTO category (id, name, parent_id, level, sort, status, create_time) VALUES (1, '电子产品', NULL, 1, 1, 1, '{date1}'), (2, '服装鞋帽', NULL, 1, 2, 1, '{date2}'), (3, '食品饮料', NULL, 1, 3, 1, '{date3}'), (4, '手机', 1, 2, 1, 1, '{date4}'), (5, '电脑', 1, 2, 2, 1, '{date5}'), (6, '男装', 2, 2, 1, 1, '{date6}'), (7, '女装', 2, 2, 2, 1, '{date7}'), -- 边界分类数据 (8, '停用分类', NULL, 1, 99, 0, '{date8}'), (9, '长名称分类啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊', NULL, 1, 100, 1, '{date9}'); -- 订单详情表测试数据 INSERT INTO order_item (id, order_id, product_id, quantity, price, total_price, create_time) VALUES (1, 1, 1, 3, 99.99, 299.97, '{date1}'), (2, 2, 2, 1, 99.99, 99.99, '{date2}'), (3, 3, 3, 2, 99.99, 199.98, '{date3}'), -- 边界订单详情 (4, 4, 4, 1, 0.01, 0.01, '{date4}'), -- 最小数量 (5, 5, 5, 999, 1000.00, 999000.00, '{date5}'), -- 最大数量 (6, 6, 6, 0, 100.00, 0.00, '{date6}'); -- 零数量 -- 验证数据插入 SELECT '用户表记录数:' as table_name, COUNT(*) as record_count FROM user UNION ALL SELECT '产品表记录数:', COUNT(*) FROM product UNION ALL SELECT '订单表记录数:', COUNT(*) FROM `order` UNION ALL SELECT '分类表记录数:', COUNT(*) FROM category UNION ALL SELECT '订单详情记录数:', COUNT(*) FROM order_item; """.format( timestamp=now.strftime("%Y-%m-%d %H:%M:%S"), date1=(now - timedelta(days=10)).strftime("%Y-%m-%d %H:%M:%S"), date2=(now - timedelta(days=9)).strftime("%Y-%m-%d %H:%M:%S"), date3=(now - timedelta(days=8)).strftime("%Y-%m-%d %H:%M:%S"), date4=(now - timedelta(days=7)).strftime("%Y-%m-%d %H:%M:%S"), date5=(now - timedelta(days=6)).strftime("%Y-%m-%d %H:%M:%S"), date6=(now - timedelta(days=5)).strftime("%Y-%m-%d %H:%M:%S"), date7=(now - timedelta(days=4)).strftime("%Y-%m-%d %H:%M:%S"), date8=(now - timedelta(days=3)).strftime("%Y-%m-%d %H:%M:%S"), date9=(now - timedelta(days=2)).strftime("%Y-%m-%d %H:%M:%S"), date10=(now - timedelta(days=1)).strftime("%Y-%m-%d %H:%M:%S"), date11=(now - timedelta(days=10, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date12=(now - timedelta(days=10, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), date13=(now - timedelta(days=9, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date14=(now - timedelta(days=9, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), date15=(now - timedelta(days=8, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date16=(now - timedelta(days=8, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), date17=(now - timedelta(days=7, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date18=(now - timedelta(days=7, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), date19=(now - timedelta(days=6, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date20=(now - timedelta(days=6, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), date21=(now - timedelta(days=5, hours=2)).strftime("%Y-%m-%d %H:%M:%S"), date22=(now - timedelta(days=5, hours=1)).strftime("%Y-%m-%d %H:%M:%S"), bulk_users=self._generate_bulk_users(100, 200), # 生成100-200之间的随机用户 long_product_name="超长产品名称" + "非常" * 20 + "长的产品名称用于测试边界情况" ) return sql def _generate_bulk_users(self, min_count: int, max_count: int) -> str: """生成大量用户数据（用于性能测试）""" count = random.randint(min_count, max_count) users = [] base_date = datetime.now() - timedelta(days=365) for i in range(12, 12 + count): # 从12开始，避免ID冲突 username = f"bulk_user_{i}" email = f"bulk{i}@example.com" phone = f"13{random.randint(100000000, 999999999):09d}" status = random.choice([0, 1]) # 随机创建时间（过去一年内） random_days = random.randint(0, 365) random_hours = random.randint(0, 23) create_time = base_date + timedelta(days=random_days, hours=random_hours) update_time = create_time + timedelta(hours=random.randint(1, 24)) users.append( f"({i}, '{username}', '{email}', '{phone}', {status}, " f"'{create_time.strftime('%Y-%m-%d %H:%M:%S')}', " f"'{update_time.strftime('%Y-%m-%d %H:%M:%S')}')" ) return ",\n".join(users) def _generate_json_test_data(self) -> Dict[str, Any]: """生成JSON测试数据""" now = datetime.now() return { "metadata": { "generated_at": now.isoformat(), "purpose": "Spring Boot单元测试数据", "version": "1.0.0" }, "test_users": [ { "id": 1, "username": "test_user_1", "email": "test1@example.com", "phone": "13800138001", "status": 1, "create_time": (now - timedelta(days=7)).isoformat(), "update_time": (now - timedelta(days=1)).isoformat() }, { "id": 2, "username": "test_user_2", "email": "test2@example.com", "phone": "13800138002", "status": 0, "create_time": (now - timedelta(days=14)).isoformat(), "update_time": (now - timedelta(days=7)).isoformat() } ], "test_products": [ { "id": 1, "name": "测试产品A", "price": 99.99, "stock": 100, "category": "电子产品" }, { "id": 2, "name": "测试产品B", "price": 199.99, "stock": 50, "category": "服装" } ], "test_orders": [ { "id": 1, "order_no": "TEST001", "user_id": 1, "total_amount": 299.97, "status": "pending", "items": [ {"product_id": 1, "quantity": 3, "price": 99.99}, {"product_id": 2, "quantity": 1, "price": 199.99} ] } ], "boundary_values": { "strings": { "empty": "", "whitespace": " ", "single_char": "a", "max_length": "a" * 255, "unicode": "🎉测试中文", "special_chars": "test@#$%^&*()" }, "numbers": { "zero": 0, "negative": -1, "positive": 1, "max_int": 2147483647, "min_int": -2147483648, "float": 99.99, "large_float": 999999.99 }, "dates": { "min_date": "0001-01-01", "max_date": "9999-12-31", "current": now.date().isoformat(), "past": (now - timedelta(days=365)).date().isoformat(), "future": (now + timedelta(days=365)).date().isoformat() } }, "error_cases": { "invalid_emails": [ "", "invalid", "@example.com", "test@", "test@example", "test@.com" ], "invalid_phones": [ "", "123", "abcdefg", "1380013800a", "+8613800138000" ], "invalid_usernames": [ "", " ", "a", "a" * 256, "test@user", "user\nname" ] } } def _generate_yaml_test_data(self) -> Dict[str, Any]: """生成YAML测试数据""" return { "application": { "name": "Spring Boot Test Application", "version": "1.0.0" }, "test": { "profiles": ["test", "integration"], "database": { "type": "h2", "url": "jdbc:h2:mem:testdb", "username": "sa", "password": "" } }, "data": { "users": { "default": { "count": 10, "status_distribution": { "active": 0.7, "inactive": 0.2, "suspended": 0.1 } }, "boundary": { "min_age": 18, "max_age": 100, "min_salary": 0, "max_salary": 1000000 } }, "products": { "categories": ["电子产品", "服装", "食品", "图书", "家居"], "price_range": { "min": 0.01, "max": 9999.99 }, "stock_range": { "min": 0, "max": 10000 } } }, "coverage": { "targets": { "line": 85, "branch": 80, "method": 90, "class": 95 }, "categories": { "unit": 60, "integration": 20, "controller": 10, "service": 10 } } } def _generate_boundary_test_data(self) -> str: """生成边界测试数据""" sql = """-- 边界值测试数据 -- 专门用于边界条件测试 -- 用户表边界测试数据 INSERT INTO user (id, username, email, phone, status, create_time) VALUES -- 空值测试 (1001, '', 'empty_username@example.com', '13800000001', 1, NOW()), (1002, 'empty_email', '', '13800000002', 1, NOW()), (1003, 'empty_phone', 'empty_phone@example.com', '', 1, NOW()), -- 最大长度测试 (1004, 'a', 'maxlength@example.com', '13800000004', 1, NOW()), -- 最小长度用户名 (1005, REPEAT('a', 255), 'longusername@example.com', '13800000005', 1, NOW()), -- 最大长度用户名 (1006, 'max_email', REPEAT('a', 100) || '@example.com', '13800000006', 1, NOW()), -- 长邮箱 -- 特殊字符测试 (1007, 'user with space', 'space@example.com', '13800000007', 1, NOW()), (1008, 'user-with-dash', 'dash@example.com', '13800000008', 1, NOW()), (1009, 'user.period', 'period@example.com', '13800000009', 1, NOW()), (1010, 'user_underscore', 'underscore@example.com', '13800000010', 1, NOW()), (1011, 'user@symbol', 'symbol@example.com', '13800000011', 1, NOW()), -- @符号在用户名中 -- Unicode测试 (1012, '中文用户', 'chinese@example.com', '13800000012', 1, NOW()), (1013, '🎉emoji_user', 'emoji@example.com', '13800000013', 1, NOW()), (1014, 'user_with_😀', 'smile@example.com', '13800000014', 1, NOW()), -- 数值边界测试 (1015, 'status_min', 'min@example.com', '13800000015', 0, NOW()), -- 最小状态 (1016, 'status_max', 'max@example.com', '13800000016', 255, NOW()), -- 最大状态 (1017, 'status_negative', 'negative@example.com', '13800000017', -1, NOW()), -- 负状态 -- 时间边界测试 (1018, 'min_time', 'mintime@example.com', '13800000018', 1, '1970-01-01 00:00:01'), (1019, 'max_time', 'maxtime@example.com', '13800000019', 1, '2038-01-19 03:14:07'), (1020, 'leap_year', 'leap@example.com', '13800000020', 1, '2024-02-29 12:00:00'), -- NULL值测试（在某些字段允许NULL的情况下） (1021, NULL, 'null_username@example.com', '13800000021', 1, NOW()), (1022, 'null_email', NULL, '13800000022', 1, NOW()), (1023, 'null_status', 'nullstatus@example.com', '13800000023', NULL, NOW()); -- 产品表边界测试数据 INSERT INTO product (id, name, price, stock, status) VALUES -- 价格边界 (2001, '免费产品', 0.00, 100, 1), -- 零价格 (2002, '最小价格产品', 0.01, 100, 1), -- 最小正价格 (2003, '高价产品', 999999.99, 100, 1), -- 最大价格 (2004, '负价产品', -1.00, 100, 1), -- 负价格 -- 库存边界 (2005, '零库存产品', 100.00, 0, 1), -- 零库存 (2006, '单库存产品', 100.00, 1, 1), -- 最小正库存 (2007, '大库存产品', 100.00, 99999, 1), -- 大库存 (2008, '负库存产品', 100.00, -1, 1), -- 负库存 -- 状态边界 (2009, '最小状态产品', 100.00, 100, 0), -- 最小状态 (2010, '最大状态产品', 100.00, 100, 255), -- 最大状态 -- 名称边界 (2011, '', 100.00, 100, 1), -- 空名称 (2012, ' ', 100.00, 100, 1), -- 空格名称 (2013, 'a', 100.00, 100, 1), -- 单字符名称 (2014, REPEAT('a', 500), 100.00, 100, 1), -- 超长名称 -- 浮点数精度测试 (2015, '精度测试1', 0.3333333333, 100, 1), (2016, '精度测试2', 99.9999999999, 100, 1), (2017, '精度测试3', 0.0000000001, 100, 1); -- 订单表边界测试数据 INSERT INTO `order` (id, order_no, user_id, total_amount, status) VALUES -- 金额边界 (3001, 'BOUNDARY001', 1001, 0.00, 1), -- 零金额 (3002, 'BOUNDARY002', 1002, 0.01, 1), -- 最小正金额 (3003, 'BOUNDARY003', 1003, 999999.99, 1), -- 最大金额 (3004, 'BOUNDARY004', 1004, -1.00, 1), -- 负金额 -- 状态边界 (3005, 'BOUNDARY005', 1005, 100.00, 0), -- 最小状态 (3006, 'BOUNDARY006', 1006, 100.00, 255), -- 最大状态 (3007, 'BOUNDARY007', 1007, 100.00, -1), -- 负状态 -- 订单号边界 (3008, '', 1008, 100.00, 1), -- 空订单号 (3009, ' ', 1009, 100.00, 1), -- 空格订单号 (3010, 'A', 1010, 100.00, 1), -- 单字符订单号 (3011, REPEAT('A', 100), 1011, 100.00, 1), -- 长订单号 -- 用户ID边界 (3012, 'BOUNDARY012', 0, 100.00, 1), -- 零用户ID (3013, 'BOUNDARY013', -1, 100.00, 1), -- 负用户ID (3014, 'BOUNDARY014', 999999, 100.00, 1); -- 大用户ID -- 验证边界数据插入 SELECT '边界用户记录数:' as table_name, COUNT(*) as record_count FROM user WHERE id >= 1000 AND id < 2000 UNION ALL SELECT '边界产品记录数:', COUNT(*) FROM product WHERE id >= 2000 AND id < 3000 UNION ALL SELECT '边界订单记录数:', COUNT(*) FROM `order` WHERE id >= 3000 AND id < 4000; """ return sql def _generate_test_data_factory(self) -> str: """生成测试数据工厂类""" return """package com.example.demo; import java.time.LocalDateTime; import java.util.Arrays; import java.util.List; import java.util.UUID; /** * 测试数据工厂类 * 生成各种测试场景的数据 */ public class TestDataFactory { // 私有构造函数，防止实例化 private TestDataFactory() {} /** * 创建正常用户 */ public static User createNormalUser() { User user = new User(); user.setId(1L); user.setUsername("testuser"); user.setEmail("test@example.com"); user.setPhone("13800138000"); user.setStatus(1); user.setCreateTime(LocalDateTime.now().minusDays(1)); user.setUpdateTime(LocalDateTime.now()); return user; } /** * 创建边界用户 */ public static User createBoundaryUser() { User user = createNormalUser(); user.setUsername("a".repeat(255)); // 最大长度用户名 user.setEmail("a".repeat(100) + "@example.com"); // 长邮箱 user.setPhone("1".repeat(11)); // 11位手机号 user.setStatus(255); // 最大状态值 return user; } /** * 创建无效用户（用于异常测试） */ public static User createInvalidUser() { User user = new User(); user.setUsername(""); // 空用户名 user.setEmail("invalid-email"); // 无效邮箱 user.setPhone("123"); // 无效手机号 user.setStatus(-1); // 无效状态 return user; } /** * 创建空值用户 */ public static User createNullUser() { User user = new User(); user.setUsername(null); // null用户名 user.setEmail(null); // null邮箱 user.setPhone(null); // null手机号 user.setStatus(null); // null状态 return user; } /** * 创建包含特殊字符的用户 */ public static User createSpecialCharacterUser() { User user = createNormalUser(); user.setUsername("test user"); // 包含空格 user.setEmail("test.user@example.com"); // 包含点号 user.setPhone("+86-138-0013-8000"); // 包含特殊字符 return user; } /** * 创建包含Unicode字符的用户 */ public static User createUnicodeUser() { User user = createNormalUser(); user.setUsername("中文用户🎉"); user.setEmail("中文@例子.中国"); return user; } /** * 创建重复用户名用户（用于冲突测试） */ public static User createDuplicateUsernameUser() { User user = createNormalUser(); user.setUsername("existinguser"); // 已存在的用户名 return user; } /** * 创建重复邮箱用户（用于冲突测试） */ public static User createDuplicateEmailUser() { User user = createNormalUser(); user.setEmail("existing@example.com"); // 已存在的邮箱 return user; } /** * 创建不同状态的用户列表 */ public static List createUsersWithDifferentStatuses() { User activeUser = createNormalUser(); activeUser.setStatus(1); // 活跃 User inactiveUser = createNormalUser(); inactiveUser.setId(2L); inactiveUser.setUsername("inactiveuser"); inactiveUser.setStatus(0); // 非活跃 User suspendedUser = createNormalUser(); suspendedUser.setId(3L); suspendedUser.setUsername("suspendeduser"); suspendedUser.setStatus(2); // 暂停 User deletedUser = createNormalUser(); deletedUser.setId(4L); deletedUser.setUsername("deleteduser"); deletedUser.setStatus(-1); // 删除 return Arrays.asList(activeUser, inactiveUser, suspendedUser, deletedUser); } /** * 创建大量用户（用于性能测试） */ public static List createBulkUsers(int count) { List users = new java.util.ArrayList<>(); for (int i = 0; i < count; i++) { User user = new User(); user.setId(1000L + i); user.setUsername("bulkuser" + i); user.setEmail("bulk" + i + "@example.com"); user.setPhone("138" + String.format("%08d", i)); user.setStatus(i % 2); // 交替状态 user.setCreateTime(LocalDateTime.now().minusDays(i)); users.add(user); } return users; } /** * 创建随机用户 */ public static User createRandomUser() { User user = new User(); user.setId(System.currentTimeMillis()); user.setUsername("user_" + UUID.randomUUID().toString().substring(0, 8)); user.setEmail("user_" + System.currentTimeMillis() + "@example.com"); user.setPhone("13" + (100000000 + (int)(Math.random() * 900000000))); user.setStatus((int)(Math.random() * 5)); // 0-4随机状态 user.setCreateTime(LocalDateTime.now().minusDays((int)(Math.random() * 365))); return user; } /** * 创建边界值测试数据 */ public static class BoundaryValues { // 字符串边界值 public static final String EMPTY_STRING = ""; public static final String WHITESPACE_STRING = " "; public static final String SINGLE_CHAR = "a"; public static final String MAX_LENGTH_STRING = "a".repeat(255); public static final String UNICODE_STRING = "🎉测试中文"; public static final String SPECIAL_CHARS = "test@#$%^&*()"; // 数值边界值 public static final int MIN_INT = Integer.MIN_VALUE; public static final int MAX_INT = Integer.MAX_VALUE; public static final long MIN_LONG = Long.MIN_VALUE; public static final long MAX_LONG = Long.MAX_VALUE; public static final double MIN_DOUBLE = Double.MIN_VALUE; public static final double MAX_DOUBLE = Double.MAX_VALUE; public static final double NEGATIVE_INFINITY = Double.NEGATIVE_INFINITY; public static final double POSITIVE_INFINITY = Double.POSITIVE_INFINITY; public static final double NAN = Double.NaN; // 时间边界值 public static final LocalDateTime MIN_DATE_TIME = LocalDateTime.MIN; public static final LocalDateTime MAX_DATE_TIME = LocalDateTime.MAX; public static final LocalDateTime UNIX_EPOCH = LocalDateTime.of(1970, 1, 1, 0, 0, 0); public static final LocalDateTime YEAR_2038 = LocalDateTime.of(2038, 1, 19, 3, 14, 7); private BoundaryValues() {} } /** * 创建异常测试数据 */ public static class ExceptionTestData { // 无效邮箱列表 public static final List INVALID_EMAILS = Arrays.asList( "", // 空字符串 " ", // 空格 "invalid", // 没有@符号 "@example.com", // 没有本地部分 "test@", // 没有域名 "test@example", // 没有顶级域名 "test@.com", // 没有二级域名 "test@com", // 没有点号 "test@example..com", // 连续点号 "test@-example.com", // 域名以连字符开头 "test@example-.com", // 域名以连字符结尾 "test@exa mple.com", // 包含空格 "test@exa\tmple.com", // 包含制表符 "test@exa\\nmple.com", // 包含换行符 "test@\"example\".com", // 包含引号 "test@example.c", // 过短的顶级域名 "test@" + "a".repeat(256) + ".com" // 超长域名 ); // 无效手机号列表 public static final List INVALID_PHONES = Arrays.asList( "", // 空字符串 " ", // 空格 "123", // 过短 "123456789012", // 过长 "abcdefg", // 包含字母 "1380013800a", // 包含字母 "+8613800138000", // 包含加号（如果不支持） "013800138000", // 以0开头 "138-0013-8000", // 包含连字符 "138 0013 8000", // 包含空格 "138.0013.8000" // 包含点号 ); // 无效用户名列表 public static final List INVALID_USERNAMES = Arrays.asList( "", // 空字符串 " ", // 空格 "a", // 过短（如果最小长度>1） "a".repeat(256), // 过长（如果最大长度255） "test@user", // 包含@符号 "user\nname", // 包含换行符 "user\tname", // 包含制表符 "user name", // 包含空格 "user/name", // 包含斜杠 "user\\\\name", // 包含反斜杠 "user:name", // 包含冒号 "user;name", // 包含分号 "user,name", // 包含逗号 "username", // 包含大于号 "user|name", // 包含竖线 "user?name", // 包含问号 "user*name", // 包含星号 "null", // 保留字 "admin", // 保留字 "root" // 保留字 ); private ExceptionTestData() {} } }""" def print_summary(self, generated_files: Dict[str, str]) -> None: """打印生成摘要""" print("=" * 60) print("测试数据生成完成") print("=" * 60) print(f"\n📁 生成文件:") for file_type, file_path in generated_files.items(): print(f" {file_type.upper():10} -> {file_path}") print(f"\n📊 包含数据:") print(" - 正常流程测试数据") print(" - 边界值测试数据") print(" - 异常场景测试数据") print(" - 性能测试数据") print(" - Unicode和特殊字符测试数据") print(f"\n💡 使用建议:") print(" 1. SQL文件用于@Sql注解导入测试数据") print(" 2. JSON/YAML文件用于配置测试") print(" 3. TestDataFactory用于动态创建测试对象") print(" 4. 边界数据专门测试边界条件") print(f"\n🚀 下一步:") print(" 1. 运行测试: mvn test") print(" 2. 检查覆盖率: ./scripts/check-coverage.sh") print(" 3. 生成报告: ./scripts/generate-test-report.py") def main(): """主函数""" if len(sys.argv) < 2: print("用法: python generate-test-data.py <项目根目录>") print("示例: python generate-test-data.py /path/to/spring-boot-project") sys.exit(1) project_root = sys.argv[1] if not os.path.exists(project_root): print(f"错误: 项目目录不存在: {project_root}") sys.exit(1) print(f"🔧 开始生成测试数据: {project_root}") try: generator = TestDataGenerator(project_root) generated_files = generator.generate_all_test_data() generator.print_summary(generated_files) except Exception as e: print(f"❌ 生成测试数据时出错: {e}") import traceback traceback.print_exc() sys.exit(1) if __name__ == "__main__": main() FILE:scripts/generate-test-report.py #!/usr/bin/env python3 """ 测试报告生成脚本生成Spring Boot项目的测试覆盖率和质量报告 """ import os import sys import json import xml.etree.ElementTree as ET from datetime import datetime from pathlib import Path import subprocess from typing import Dict, List, Tuple, Any class TestReportGenerator: """测试报告生成器""" def __init__(self, project_root: str): self.project_root = Path(project_root).resolve() self.report_dir = self.project_root / "test-reports" self.report_dir.mkdir(exist_ok=True) def generate_comprehensive_report(self) -> Dict[str, Any]: """生成综合测试报告""" report = { "timestamp": datetime.now().isoformat(), "project_root": str(self.project_root), "summary": {}, "coverage": {}, "test_categories": {}, "issues": [], "recommendations": [] } # 收集测试信息 report["summary"] = self.collect_test_summary() report["coverage"] = self.collect_coverage_data() report["test_categories"] = self.analyze_test_categories() report["issues"] = self.identify_issues() report["recommendations"] = self.generate_recommendations() # 生成报告文件 self.save_report(report) self.generate_html_report(report) return report def collect_test_summary(self) -> Dict[str, Any]: """收集测试摘要信息""" summary = { "total_tests": 0, "passed_tests": 0, "failed_tests": 0, "skipped_tests": 0, "test_classes": 0, "test_methods": 0, "execution_time": 0.0 } # 查找Surefire测试报告 surefire_dir = self.project_root / "target" / "surefire-reports" if surefire_dir.exists(): for xml_file in surefire_dir.glob("*.xml"): try: tree = ET.parse(xml_file) root = tree.getroot() summary["total_tests"] += int(root.get("tests", 0)) summary["failed_tests"] += int(root.get("failures", 0)) summary["skipped_tests"] += int(root.get("skipped", 0)) summary["passed_tests"] = summary["total_tests"] - summary["failed_tests"] - summary["skipped_tests"] # 计算执行时间 time_attr = root.get("time") if time_attr: summary["execution_time"] += float(time_attr) # 统计测试类和方法 for testcase in root.findall(".//testcase"): summary["test_methods"] += 1 class_name = testcase.get("classname", "") if class_name and class_name not in self._test_classes: self._test_classes.add(class_name) summary["test_classes"] += 1 except ET.ParseError: print(f"警告: 无法解析XML文件: {xml_file}") return summary def collect_coverage_data(self) -> Dict[str, Any]: """收集覆盖率数据""" coverage = { "line_coverage": 0.0, "branch_coverage": 0.0, "method_coverage": 0.0, "class_coverage": 0.0, "instructions_coverage": 0.0, "complexity_coverage": 0.0, "by_package": {}, "by_class": {} } # 查找JaCoCo覆盖率报告 jacoco_xml = self.project_root / "target" / "site" / "jacoco" / "jacoco.xml" if jacoco_xml.exists(): try: tree = ET.parse(jacoco_xml) root = tree.getroot() # 收集整体覆盖率 counter_types = { "LINE": "line_coverage", "BRANCH": "branch_coverage", "METHOD": "method_coverage", "CLASS": "class_coverage", "INSTRUCTION": "instructions_coverage", "COMPLEXITY": "complexity_coverage" } for counter in root.findall(".//counter"): counter_type = counter.get("type") if counter_type in counter_types: missed = int(counter.get("missed", 0)) covered = int(counter.get("covered", 0)) total = missed + covered if total > 0: coverage_rate = (covered / total) * 100 coverage[counter_types[counter_type]] = round(coverage_rate, 2) # 按包收集覆盖率 for package in root.findall(".//package"): package_name = package.get("name", "unknown") package_coverage = {} for counter in package.findall("counter"): counter_type = counter.get("type") missed = int(counter.get("missed", 0)) covered = int(counter.get("covered", 0)) total = missed + covered if total > 0: coverage_rate = (covered / total) * 100 package_coverage[counter_type.lower()] = round(coverage_rate, 2) coverage["by_package"][package_name] = package_coverage # 按类收集覆盖率（仅限主要业务类） for package in root.findall(".//package"): for class_elem in package.findall("class"): class_name = class_elem.get("name", "unknown") if "Test" not in class_name: # 排除测试类 class_coverage = {} for counter in class_elem.findall("counter"): counter_type = counter.get("type") missed = int(counter.get("missed", 0)) covered = int(counter.get("covered", 0)) total = missed + covered if total > 0: coverage_rate = (covered / total) * 100 class_coverage[counter_type.lower()] = round(coverage_rate, 2) if class_coverage: coverage["by_class"][class_name] = class_coverage except ET.ParseError: print(f"警告: 无法解析JaCoCo XML文件: {jacoco_xml}") return coverage def analyze_test_categories(self) -> Dict[str, Any]: """分析测试类别分布""" categories = { "unit_tests": {"count": 0, "coverage": 0.0}, "integration_tests": {"count": 0, "coverage": 0.0}, "controller_tests": {"count": 0, "coverage": 0.0}, "service_tests": {"count": 0, "coverage": 0.0}, "repository_tests": {"count": 0, "coverage": 0.0}, "exception_tests": {"count": 0, "coverage": 0.0}, "boundary_tests": {"count": 0, "coverage": 0.0} } # 分析测试文件 test_dir = self.project_root / "src" / "test" if test_dir.exists(): for test_file in test_dir.rglob("*.java"): content = test_file.read_text(encoding="utf-8", errors="ignore") # 根据文件名和内容分类 file_name = test_file.name if "IntegrationTest" in file_name or "IT.java" in file_name: categories["integration_tests"]["count"] += 1 elif "ControllerTest" in file_name: categories["controller_tests"]["count"] += 1 elif "ServiceTest" in file_name: categories["service_tests"]["count"] += 1 elif "RepositoryTest" in file_name or "MapperTest" in file_name: categories["repository_tests"]["count"] += 1 else: categories["unit_tests"]["count"] += 1 # 根据内容进一步分类 if "assertThrows" in content or "Exception" in content: categories["exception_tests"]["count"] += 1 if "boundary" in content.lower() or "Boundary" in content: categories["boundary_tests"]["count"] += 1 return categories def identify_issues(self) -> List[Dict[str, Any]]: """识别测试问题""" issues = [] # 检查覆盖率阈值 coverage = self.collect_coverage_data() thresholds = { "line_coverage": 85.0, "branch_coverage": 80.0, "method_coverage": 90.0, "class_coverage": 95.0 } for metric, threshold in thresholds.items(): actual = coverage.get(metric, 0.0) if actual < threshold: issues.append({ "type": "COVERAGE_LOW", "severity": "MEDIUM", "metric": metric, "expected": threshold, "actual": actual, "message": f"{metric.replace('_', ' ').title()} 低于阈值: {actual}% < {threshold}%" }) # 检查缺少的测试类别 categories = self.analyze_test_categories() required_categories = ["controller_tests", "service_tests", "repository_tests"] for category in required_categories: if categories[category]["count"] == 0: issues.append({ "type": "MISSING_TEST_CATEGORY", "severity": "HIGH", "category": category, "message": f"缺少{category.replace('_', ' ').title()}" }) # 检查异常和边界测试 if categories["exception_tests"]["count"] == 0: issues.append({ "type": "MISSING_EXCEPTION_TESTS", "severity": "MEDIUM", "message": "缺少异常处理测试" }) if categories["boundary_tests"]["count"] == 0: issues.append({ "type": "MISSING_BOUNDARY_TESTS", "severity": "MEDIUM", "message": "缺少边界值测试" }) return issues def generate_recommendations(self) -> List[Dict[str, Any]]: """生成改进建议""" recommendations = [] # 基于问题生成建议 issues = self.identify_issues() for issue in issues: if issue["type"] == "COVERAGE_LOW": metric = issue["metric"] recommendations.append({ "type": "IMPROVE_COVERAGE", "priority": "HIGH" if issue["severity"] == "HIGH" else "MEDIUM", "action": f"提高{metric.replace('_', ' ').title()}", "details": f"当前覆盖率: {issue['actual']}%, 目标: {issue['expected']}%" }) elif issue["type"] == "MISSING_TEST_CATEGORY": category = issue["category"] recommendations.append({ "type": "ADD_TEST_CATEGORY", "priority": "HIGH", "action": f"添加{category.replace('_', ' ').title()}", "details": "参考测试模板创建对应的测试类" }) elif issue["type"] == "MISSING_EXCEPTION_TESTS": recommendations.append({ "type": "ADD_EXCEPTION_TESTS", "priority": "MEDIUM", "action": "添加异常处理测试", "details": "为每个可能抛出异常的方法添加异常测试" }) elif issue["type"] == "MISSING_BOUNDARY_TESTS": recommendations.append({ "type": "ADD_BOUNDARY_TESTS", "priority": "MEDIUM", "action": "添加边界值测试", "details": "为输入参数、状态转换、数据边界添加测试" }) # 通用建议 recommendations.extend([ { "type": "REVIEW_TEST_NAMING", "priority": "LOW", "action": "检查测试命名规范", "details": "确保测试方法名遵循 Given-When-Then 格式" }, { "type": "OPTIMIZE_TEST_SPEED", "priority": "MEDIUM", "action": "优化测试执行速度", "details": "考虑使用@MockBean代替真实依赖，使用内存数据库" }, { "type": "ADD_INTEGRATION_TESTS", "priority": "MEDIUM", "action": "添加集成测试", "details": "使用@Testcontainers测试端到端流程" } ]) return recommendations def save_report(self, report: Dict[str, Any]) -> None: """保存JSON格式报告""" report_file = self.report_dir / "test-report.json" with open(report_file, 'w', encoding='utf-8') as f: json.dump(report, f, indent=2, ensure_ascii=False) print(f"✅ 测试报告已保存: {report_file}") def generate_html_report(self, report: Dict[str, Any]) -> None: """生成HTML格式报告""" html_file = self.report_dir / "test-report.html" html_content = self._generate_html_content(report) with open(html_file, 'w', encoding='utf-8') as f: f.write(html_content) print(f"✅ HTML报告已生成: {html_file}") def _generate_html_content(self, report: Dict[str, Any]) -> str: """生成HTML内容""" summary = report["summary"] coverage = report["coverage"] categories = report["test_categories"] issues = report["issues"] recommendations = report["recommendations"] return f""" Spring Boot测试报告 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

📊 测试摘要

{summary.get('total_tests', 0)}

总测试数

{summary.get('passed_tests', 0)}

通过测试

{summary.get('failed_tests', 0)}

失败测试

{summary.get('skipped_tests', 0)}

跳过测试

{summary.get('test_classes', 0)}

测试类

{summary.get('execution_time', 0):.2f}s

执行时间

📈 代码覆盖率

{coverage.get('line_coverage', 0)}%

行覆盖率

{coverage.get('branch_coverage', 0)}%

分支覆盖率

{coverage.get('method_coverage', 0)}%

方法覆盖率

{coverage.get('class_coverage', 0)}%

类覆盖率

测试类别分布

{categories.get('unit_tests', {{}}).get('count', 0)}

单元测试

{categories.get('integration_tests', {{}}).get('count', 0)}

集成测试

{categories.get('controller_tests', {{}}).get('count', 0)}

Controller测试

{categories.get('service_tests', {{}}).get('count', 0)}

Service测试

{categories.get('repository_tests', {{}}).get('count', 0)}

Repository测试

{categories.get('exception_tests', {{}}).get('count', 0)}

异常测试

{categories.get('boundary_tests', {{}}).get('count', 0)}

边界测试

⚠️ 发现问题

{self._generate_issues_html(issues)}

💡 改进建议

{self._generate_recommendations_html(recommendations)}

""" def _generate_issues_html(self, issues: List[Dict[str, Any]]) -> str: """生成问题HTML""" if not issues: return '

🎉 未发现问题！测试覆盖良好。

' html_parts = [] for issue in issues: severity_class = f"severity-{issue['severity'].lower()}" html_parts.append(f"""

{issue['severity']} {issue['message']}

""") return "\n".join(html_parts) def _generate_recommendations_html(self, recommendations: List[Dict[str, Any]]) -> str: """生成建议HTML""" if not recommendations: return '

✅ 无需改进建议。

' html_parts = [] for rec in recommendations: priority_class = f"priority-{rec['priority'].lower()}" html_parts.append(f"""

{rec['priority']} {rec['action']}
{rec['details']}

""") return "\n".join(html_parts) def main(): """主函数""" if len(sys.argv) < 2: print("用法: python generate-test-report.py <项目根目录>") print("示例: python generate-test-report.py /path/to/spring-boot-project") sys.exit(1) project_root = sys.argv[1] if not os.path.exists(project_root): print(f"错误: 项目目录不存在: {project_root}") sys.exit(1) print(f"🔍 开始分析项目: {project_root}") try: generator = TestReportGenerator(project_root) report = generator.generate_comprehensive_report() print("\n" + "="*60) print("📋 测试报告摘要") print("="*60) summary = report["summary"] print(f"总测试数: {summary['total_tests']}") print(f"通过测试: {summary['passed_tests']}") print(f"失败测试: {summary['failed_tests']}") print(f"跳过测试: {summary['skipped_tests']}") print(f"执行时间: {summary['execution_time']:.2f}秒") coverage = report["coverage"] print(f"\n📊 代码覆盖率:") print(f" 行覆盖率: {coverage.get('line_coverage', 0)}%") print(f" 分支覆盖率: {coverage.get('branch_coverage', 0)}%") print(f" 方法覆盖率: {coverage.get('method_coverage', 0)}%") print(f" 类覆盖率: {coverage.get('class_coverage', 0)}%") issues = report["issues"] print(f"\n⚠️ 发现 {len(issues)} 个问题:") for issue in issues: print(f" - {issue['message']}") recommendations = report["recommendations"] print(f"\n💡 生成 {len(recommendations)} 条改进建议") print(f"\n✅ 报告已生成:") print(f" JSON报告: {os.path.join(generator.report_dir, 'test-report.json')}") print(f" HTML报告: {os.path.join(generator.report_dir, 'test-report.html')}") except Exception as e: print(f"❌ 生成报告时出错: {e}") import traceback traceback.print_exc() sys.exit(1) if __name__ == "__main__": main() FILE:references/boundary-testing.md # Spring Boot边界值测试指南 ## 边界值测试核心概念 ### 什么是边界值？边界值是输入域、输出域或状态域的边缘值，这些值附近通常最容易出现错误。 ### 边界值类型 1. **输入边界** - 参数的取值范围边界 2. **输出边界** - 返回值的取值范围边界 3. **状态边界** - 系统状态的转换边界 4. **容量边界** - 系统容量的极限边界 5. **时间边界** - 时间相关的边界条件 ## 边界值测试策略 ### 三值边界测试法对于每个边界，测试三个值： - **边界值本身** - **刚好小于边界值** (边界值-1) - **刚好大于边界值** (边界值+1) ### 七值边界测试法（推荐）对于有范围的参数，测试七个值： 1. **最小值** (min) 2. **最小值+1** (min+1) 3. **正常值** (nominal) 4. **最大值-1** (max-1) 5. **最大值** (max) 6. **小于最小值** (min-1) 7. **大于最大值** (max+1) ## 数值边界测试 ### 整数边界测试 ```java public class IntegerBoundaryTest { @ParameterizedTest @ValueSource(ints = { Integer.MIN_VALUE, // 最小边界 Integer.MIN_VALUE + 1, // 最小边界+1 -1, // 负边界 0, // 零边界 1, // 正边界 Integer.MAX_VALUE - 1, // 最大边界-1 Integer.MAX_VALUE // 最大边界 }) void testIntegerBoundaryValues(int value) { // 测试整数边界值 assertDoesNotThrow(() -> service.processInteger(value)); } @Test void testIntegerOverflow() { // 测试整数溢出 int maxValue = Integer.MAX_VALUE; assertThrows(ArithmeticException.class, () -> service.add(maxValue, 1)); } @Test void testIntegerUnderflow() { // 测试整数下溢 int minValue = Integer.MIN_VALUE; assertThrows(ArithmeticException.class, () -> service.subtract(minValue, 1)); } } ``` ### 浮点数边界测试 ```java public class FloatBoundaryTest { @ParameterizedTest @ValueSource(doubles = { Double.NEGATIVE_INFINITY, // 负无穷 -Double.MAX_VALUE, // 最小负值 -Double.MIN_VALUE, // 最小负非零值 -0.0, // 负零 0.0, // 零 Double.MIN_VALUE, // 最小正非零值 Double.MAX_VALUE, // 最大正值 Double.POSITIVE_INFINITY, // 正无穷 Double.NaN // 非数字 }) void testFloatBoundaryValues(double value) { // 测试浮点数边界值 assertDoesNotThrow(() -> service.processDouble(value)); } @Test void testFloatingPointPrecision() { // 测试浮点数精度问题 double result = 0.1 + 0.2; assertThat(result).isNotEqualTo(0.3); // 浮点数精度问题 assertThat(result).isCloseTo(0.3, within(0.0000001)); } @Test void testDivisionByZero() { // 测试除以零 assertThrows(ArithmeticException.class, () -> service.divide(1.0, 0.0)); // 测试除以负零 assertThrows(ArithmeticException.class, () -> service.divide(1.0, -0.0)); } } ``` ## 字符串边界测试 ### 长度边界测试 ```java public class StringLengthBoundaryTest { // 测试各种长度的字符串 @ParameterizedTest @ValueSource(strings = { "", // 空字符串 "a", // 单字符 "ab", // 双字符 "abc", // 三字符 "a".repeat(255), // 最大长度（假设255） "a".repeat(256), // 超过最大长度 "a".repeat(1000), // 远超过最大长度 "test\0null", // 包含空字符 "test\\escape", // 转义字符 "🎉emoji", // Emoji字符（多字节） "测试中文", // 中文字符 "a".repeat(1024 * 1024) // 1MB大字符串 }) void testStringLengthBoundaries(String input) { // 测试字符串长度边界 if (input.length() > 255) { assertThrows(ValidationException.class, () -> service.validateString(input)); } else { assertDoesNotThrow(() -> service.validateString(input)); } } @Test void testEmptyAndBlankStrings() { // 测试空字符串和空白字符串 assertThrows(IllegalArgumentException.class, () -> service.processString("")); assertThrows(IllegalArgumentException.class, () -> service.processString(" ")); assertThrows(IllegalArgumentException.class, () -> service.processString("\t\n\r")); // 包含不可见字符 assertThrows(IllegalArgumentException.class, () -> service.processString("test\u0000")); } @Test void testUnicodeBoundaries() { // 测试Unicode边界 String[] unicodeTests = { "\u0000", // 最小Unicode "\u0020", // 空格 "\u007F", // DELETE "\u0080", // 扩展ASCII开始 "\u00FF", // 拉丁文补充 "\u0100", // 拉丁文扩展 "\u07FF", // 西里尔文等 "\u0800", // 梵文等 "\uFFFF", // 基本多文种平面结束 "\uD800\uDC00", // 代理对开始 "\uDBFF\uDFFF", // 代理对结束 "🎉", // Emoji "𝄞", // 音乐符号 "\uFFFD" // 替换字符 }; for (String unicode : unicodeTests) { assertDoesNotThrow(() -> service.processUnicode(unicode)); } } } ``` ### 内容边界测试 ```java public class StringContentBoundaryTest { @Test void testSpecialCharacters() { // 测试特殊字符 String[] specialChars = { "test's", // 单引号 "test\"s", // 双引号 "test`s", // 反引号 "test\\s", // 反斜杠 "test/s", // 斜杠 "test|s", // 竖线 "test&s", // 与符号 "test%s", // 百分号 "test@s", // @符号 "test#s", // 井号 "test$s", // 美元符号 "test*s", // 星号 "test(s)", // 括号 "test[s]", // 方括号 "test{s}", // 花括号 "test", // 尖括号 "test;s", // 分号 "test:s", // 冒号 "test,s", // 逗号 "test.s", // 点号 "test?s", // 问号 "test!s", // 感叹号 "test~s", // 波浪号 "test^s", // 插入符 "test`s", // 重音符 }; for (String str : specialChars) { assertDoesNotThrow(() -> service.processSpecialChars(str)); } } @Test void testWhitespaceVariations() { // 测试各种空白字符 String[] whitespaceTests = { " ", // 空格 "\t", // 水平制表符 "\n", // 换行符 "\r", // 回车符 "\f", // 换页符 "\b", // 退格符 "\u00A0", // 不换行空格 "\u2000", // 半角空格 "\u2001", // 全角空格 "\u2002", // EN空格 "\u2003", // EM空格 "\u2004", // 三分之一EM空格 "\u2005", // 四分之一EM空格 "\u2006", // 六分之一EM空格 "\u2007", // 数字空格 "\u2008", // 标点空格 "\u2009", // 薄空格 "\u200A", // 头发空格 "\u2028", // 行分隔符 "\u2029", // 段分隔符 "\u3000", // 表意文字空格 }; for (String whitespace : whitespaceTests) { String testStr = "test" + whitespace + "string"; service.processWhitespace(testStr); } } @Test void testControlCharacters() { // 测试控制字符 for (int i = 0; i <= 31; i++) { String controlChar = String.valueOf((char) i); String testStr = "test" + controlChar + "string"; if (i == 9 || i == 10 || i == 13) { // 制表符、换行、回车 assertDoesNotThrow(() -> service.processControlChars(testStr)); } else { assertThrows(ValidationException.class, () -> service.processControlChars(testStr)); } } // DEL字符 (127) String delChar = String.valueOf((char) 127); String testStr = "test" + delChar + "string"; assertThrows(ValidationException.class, () -> service.processControlChars(testStr)); } } ``` ## 集合边界测试 ### 列表边界测试 ```java public class ListBoundaryTest { @Test void testListSizeBoundaries() { // 测试各种大小的列表 List[] sizeTests = new List[]{ Collections.emptyList(), // 空列表 Collections.singletonList("single"), // 单元素列表 Arrays.asList("a", "b"), // 双元素列表 createList(10), // 小列表 createList(100), // 中等列表 createList(1000), // 大列表 createList(10000), // 超大列表 createList(100000), // 极限列表 }; for (List list : sizeTests) { assertDoesNotThrow(() -> service.processList(list)); } // 测试列表容量限制 List hugeList = createList(1000000); // 百万元素 assertThrows(OutOfMemoryError.class, () -> service.processList(hugeList)); } @Test void testListContentBoundaries() { // 测试包含边界值的列表 List

springboot-unit-testing

Comments (0)