fix(jpa): 优化测试用例

spring-boot-service-template-database/spring-boot-service-template-database-jpa/src/test/java/com/lanyuanxiaoyao/service/template/database/jpa/TestApplication.java

@@ -266,11 +266,12 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result3_jpa.size() == 1, "字符串操作符查询失败 （%d）".formatted(result3_jpa.size()));
 
     formatLog("3. 字符串操作符查询 Fenix");
-    log.info("Fenix框架当前版本不支持以下字符串操作符:");
+    log.info("""
-    log.info("  - cb.length() - 字符串长度函数");
+        Fenix框架当前版本不支持以下字符串操作符:
-    log.info("  - cb.substring() - 子字符串提取函数");
+          - cb.length() - 字符串长度函数
-    log.info("  - cb.lower() / cb.upper() - 大小写转换函数 (不支持直接在条件中使用)");
+          - cb.substring() - 子字符串提取函数
-    log.info("Fenix支持的部分实现:");
+          - cb.lower() / cb.upper() - 大小写转换函数 (不支持直接在条件中使用)
+        Fenix支持的部分实现:""");
     var result3_fenix = employeeRepository.findAll(
         builder -> builder.andStartsWith(Employee.Fields.name, "A")
             .andNotStartsWith(Employee.Fields.name, "C")
@@ -357,11 +358,12 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result5_jpa.size() == 2, "集合操作符查询失败 （%d）".formatted(result5_jpa.size()));
 
     formatLog("5. 集合操作符查询 Fenix");
-    log.info("Fenix框架当前版本不支持以下集合操作符:");
+    log.info("""
-    log.info("  - cb.isNotEmpty() / cb.isEmpty() - 集合非空/空判断");
+        Fenix框架当前版本不支持以下集合操作符:
-    log.info("  - cb.isMember() / cb.isNotMember() - 集合成员判断");
+          - cb.isNotEmpty() / cb.isEmpty() - 集合非空/空判断
-    log.info("  - cb.size() - 集合大小函数");
+          - cb.isMember() / cb.isNotMember() - 集合成员判断
-    log.info("这些集合操作在JPA Criteria中需要复杂的join处理，Fenix当前不支持");
+          - cb.size() - 集合大小函数
+        这些集合操作在JPA Criteria中需要复杂的join处理，Fenix当前不支持""");
 
     formatLog("5. 集合操作符查询 QueryDSL");
     var result5_querydsl = employeeRepository.findAll(
@@ -406,8 +408,9 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result6_jpa.size() == 2, "逻辑操作符查询失败 （%d）".formatted(result6_jpa.size()));
 
     formatLog("6. 逻辑操作符查询 Fenix");
-    log.info("Fenix框架当前版本不支持复杂的嵌套OR和NOT组合逻辑");
+    log.info("""
-    log.info("Fenix支持简单的orEquals，但不支持嵌套的or + not组合");
+        Fenix框架当前版本不支持复杂的嵌套OR和NOT组合逻辑
+        Fenix支持简单的orEquals，但不支持嵌套的or + not组合""");
     var result6_fenix = employeeRepository.findAll(
         builder -> builder.orEquals(Employee.Fields.name, "Alice")
             .orEquals(Employee.Fields.name, "Bob")
@@ -498,14 +501,15 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result8_jpa.size() == 1, "Join 操作查询失败 （%d）".formatted(result8_jpa.size()));
 
     formatLog("8. Join 操作查询 Fenix");
-    log.info("Fenix框架当前版本不支持显式的join操作:");
+    log.info("""
-    log.info("  - root.join() - 显式关联查询");
+        Fenix框架当前版本不支持显式的join操作:
-    log.info("  - root.fetch() - 显式抓取查询");
+          - root.join() - 显式关联查询
-    log.info("  - Map join (cb.equal(root.join().value(), ...))");
+          - root.fetch() - 显式抓取查询
-    log.info("Fenix主要用于单表条件查询，复杂join操作建议使用JPA Specification原生方式或QueryDSL");
+          - Map join (cb.equal(root.join().value(), ...))
-    log.info("可以通过doAny使用原生CriteriaBuilder实现join操作");
+        Fenix主要用于单表条件查询，复杂join操作建议使用JPA Specification原生方式或QueryDSL
-    log.info("注意：由于类型系统的限制，doAny中使用join可能会有类型推断问题");
+        可以通过doAny使用原生CriteriaBuilder实现join操作
-    log.info("建议：对于join等复杂查询，直接使用JPA Specification原生方式");
+        注意：由于类型系统的限制，doAny中使用join可能会有类型推断问题
+        建议：对于join等复杂查询，直接使用JPA Specification原生方式""");
 
     formatLog("8. Join 操作查询 QueryDSL");
     var result8_querydsl = employeeRepository.findAll(
@@ -565,13 +569,14 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result9_jpa.isEmpty(), "子查询（聚合函数）+ 数学运算失败 （%d）".formatted(result9_jpa.size()));
 
     formatLog("9. 子查询和聚合函数查询 Fenix");
-    log.info("Fenix框架当前版本不支持以下高级查询特性:");
+    log.info("""
-    log.info("  - query.subquery() - 子查询");
+        Fenix框架当前版本不支持以下高级查询特性:
-    log.info("  - cb.avg(), cb.count(), cb.sum() - 聚合函数");
+          - query.subquery() - 子查询
-    log.info("  - cb.coalesce() - 空值替换函数");
+          - cb.avg(), cb.count(), cb.sum() - 聚合函数
-    log.info("  - cb.sum() - 数值加法运算");
+          - cb.coalesce() - 空值替换函数
-    log.info("这些是SQL级别的复杂查询，Fenix主要用于动态条件构建");
+          - cb.sum() - 数值加法运算
-    log.info("可以通过doAny使用原生CriteriaBuilder实现部分聚合操作");
+        这些是SQL级别的复杂查询，Fenix主要用于动态条件构建
+        可以通过doAny使用原生CriteriaBuilder实现部分聚合操作""");
 
     formatLog("9. 子查询和聚合函数查询 QueryDSL");
     var avgQuery = factory.select(QEmployee.employee.salary.avg());
@@ -622,8 +627,9 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result10_jpa.size() == 3, "排序查询失败 （%d）".formatted(result10_jpa.size()));
 
     formatLog("10. 排序查询 Fenix");
-    log.info("Fenix框架使用Spring Data JPA原生的Sort对象进行排序");
+    log.info("""
-    log.info("Fenix构建查询条件，Sort对象通过repository.findAll()的第二个参数传入");
+        Fenix框架使用Spring Data JPA原生的Sort对象进行排序
+        Fenix构建查询条件，Sort对象通过repository.findAll()的第二个参数传入""");
     var result10_fenix = employeeRepository.findAll(
         builder -> builder.andEquals(Employee.Fields.active, true)
             .andNotEquals(Employee.Fields.role, Employee.Role.ADMIN)
@@ -677,8 +683,9 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(page11_jpa.getTotalElements() == 3, "总元素数不正确 （%d）".formatted(page11_jpa.getTotalElements()));
 
     formatLog("11. 分页查询 Fenix");
-    log.info("Fenix框架使用Spring Data JPA原生的Pageable对象进行分页");
+    log.info("""
-    log.info("Fenix构建查询条件，Pageable对象通过repository.findAll()的第二个参数传入");
+        Fenix框架使用Spring Data JPA原生的Pageable对象进行分页
+        Fenix构建查询条件，Pageable对象通过repository.findAll()的第二个参数传入""");
     var page11_fenix = employeeRepository.findAll(
         builder -> builder.andEquals(Employee.Fields.active, true)
             .andNotEquals(Employee.Fields.role, Employee.Role.ADMIN)
@@ -691,10 +698,11 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(page11_fenix.getTotalElements() == 3, "总元素数不正确 （%d）".formatted(page11_fenix.getTotalElements()));
 
     formatLog("11. 分页查询 QueryDSL");
-    log.info("QueryDSL支持分页查询:");
+    log.info("""
-    log.info("  - offset() - 跳过记录数");
+        QueryDSL支持分页查询:
-    log.info("  - limit() - 限制记录数");
+          - offset() - 跳过记录数
-    log.info("  - 也可以结合Spring Data JPA的Pageable对象");
+          - limit() - 限制记录数
+          - 也可以结合Spring Data JPA的Pageable对象""");
     var page11_querydsl = employeeRepository.findAll(
         QEmployee.employee.active.isTrue()
             .and(QEmployee.employee.role.ne(Employee.Role.ADMIN))
@@ -751,14 +759,15 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result12_jpa.size() == 2, "CASE WHEN 查询失败 （%d）".formatted(result12_jpa.size()));
 
     formatLog("12. CASE WHEN 条件表达式查询 Fenix");
-    log.info("Fenix框架当前版本不支持CASE WHEN条件表达式:");
+    log.info("""
-    log.info("  - cb.selectCase() - SQL CASE WHEN表达式");
+        Fenix框架当前版本不支持CASE WHEN条件表达式:
-    log.info("  - .when() - CASE WHEN条件分支");
+          - cb.selectCase() - SQL CASE WHEN表达式
-    log.info("  - .otherwise() - CASE ELSE分支");
+          - .when() - CASE WHEN条件分支
-    log.info("CASE WHEN是SQL级别的条件表达式，Fenix主要用于动态条件构建");
+          - .otherwise() - CASE ELSE分支
-    log.info("可以通过doAny使用原生CriteriaBuilder实现CASE WHEN操作");
+        CASE WHEN是SQL级别的条件表达式，Fenix主要用于动态条件构建
-    log.info("注意：由于类型系统的限制，doAny中使用CriteriaBuilder的复杂表达式可能会有类型推断问题");
+        可以通过doAny使用原生CriteriaBuilder实现CASE WHEN操作
-    log.info("建议：对于CASE WHEN等复杂查询，直接使用JPA Specification原生方式");
+        注意：由于类型系统的限制，doAny中使用CriteriaBuilder的复杂表达式可能会有类型推断问题
+        建议：对于CASE WHEN等复杂查询，直接使用JPA Specification原生方式""");
     var result12_fenix = employeeRepository.findAll(builder -> {
       return builder.doAny(null, null, (cb, root, fieldName, value) -> {
         // 使用原生JPA Criteria实现CASE WHEN（简化版本）
@@ -833,13 +842,14 @@ public class TestApplication extends AbstractTestApplication {
     Assert.isTrue(result13_jpa.size() == 1 && result13_jpa.get(0).getName().equals("Alice"), "综合多条件查询失败 （%d）".formatted(result13_jpa.size()));
 
     formatLog("13. 综合多条件查询 Fenix");
-    log.info("Fenix框架不支持综合多条件查询中的复杂join和集合操作:");
+    log.info("""
-    log.info("  - 显式join操作（company, skills, properties）");
+        Fenix框架不支持综合多条件查询中的复杂join和集合操作:
-    log.info("  - 集合isEmpty/isNotEmpty/isMember操作");
+          - 显式join操作（company, skills, properties）
-    log.info("  - Map join操作");
+          - 集合isEmpty/isNotEmpty/isMember操作
-    log.info("  - 嵌入式对象查询（address.city）");
+          - Map join操作
-    log.info("Fenix主要支持简单的单表字段查询");
+          - 嵌入式对象查询（address.city）
-    log.info("可以通过doAny使用原生CriteriaBuilder实现复杂综合查询");
+        Fenix主要支持简单的单表字段查询
+        可以通过doAny使用原生CriteriaBuilder实现复杂综合查询""");
 
     formatLog("13. 综合多条件查询 QueryDSL");
     var result13_querydsl = employeeRepository.findAll(