feat: 添加异常日志功能并优化UI样式

refactor: 重构后端查询逻辑和API响应处理

fix: 修复用户角色更新和文件上传问题

test: 添加前端性能测试脚本和E2E测试用例

chore: 更新依赖版本和配置文件

docs: 添加环境检查脚本和测试文档

style: 统一表格标签样式和路由命名

perf: 优化前端页面加载速度和响应时间

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/config/SecurityConfig.java

@@ -3,7 +3,6 @@ package cn.novalon.manage.sys.config;
 import cn.novalon.manage.sys.security.JwtAuthenticationFilter;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.http.HttpMethod;
 import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
 import org.springframework.security.config.web.server.SecurityWebFiltersOrder;
 import org.springframework.security.config.web.server.ServerHttpSecurity;
@@ -43,9 +42,8 @@ public class SecurityConfig {
                         .pathMatchers("/api/auth/**").permitAll()
                         .pathMatchers("/api/public/**").permitAll()
                         .pathMatchers("/ws/**").permitAll()
-                        .pathMatchers(HttpMethod.GET, "/actuator/**").permitAll()
-                        .anyExchange().authenticated()
-                )
+                        .pathMatchers("/actuator/**").permitAll()
+                        .anyExchange().authenticated())
                 .build();
     }
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/command/CreateUserCommand.java

@@ -14,14 +14,18 @@ public record CreateUserCommand(
         Username username,
         Password password,
         Email email,
+        String nickname,
+        String phone,
         Long roleId,
         Integer status
 ) {
-    public static CreateUserCommand of(String username, String password, String email, Long roleId, Integer status) {
+    public static CreateUserCommand of(String username, String password, String email, String nickname, String phone, Long roleId, Integer status) {
         return new CreateUserCommand(
                 Username.of(username),
                 Password.of(password),
                 Email.of(email),
+                nickname,
+                phone,
                 roleId,
                 status
         );

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/command/UpdateUserCommand.java

@@ -12,9 +12,14 @@ public record UpdateUserCommand(
         String password,
         String email,
         Long roleId,
-        Integer status
+        Integer status,
+        boolean clearRole
 ) {
     public static UpdateUserCommand of(Long id, String username, String password, String email, Long roleId, Integer status) {
-        return new UpdateUserCommand(id, username, password, email, roleId, status);
+        return new UpdateUserCommand(id, username, password, email, roleId, status, false);
+    }
+    
+    public static UpdateUserCommand of(Long id, String username, String password, String email, Long roleId, Integer status, boolean clearRole) {
+        return new UpdateUserCommand(id, username, password, email, roleId, status, clearRole);
     }
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/domain/SysUser.java

@@ -14,7 +14,9 @@ public class SysUser extends BaseDomain {
 
     private String username;
     private String password;
+    private String nickname;
     private String email;
+    private String phone;
     private Long roleId;
     private Integer status;
 
@@ -34,6 +36,14 @@ public class SysUser extends BaseDomain {
         this.password = password;
     }
 
+    public String getNickname() {
+        return nickname;
+    }
+
+    public void setNickname(String nickname) {
+        this.nickname = nickname;
+    }
+
     public String getEmail() {
         return email;
     }
@@ -42,6 +52,14 @@ public class SysUser extends BaseDomain {
         this.email = email;
     }
 
+    public String getPhone() {
+        return phone;
+    }
+
+    public void setPhone(String phone) {
+        this.phone = phone;
+    }
+
     public Long getRoleId() {
         return roleId;
     }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/query/OperationLogQuery.java

@@ -0,0 +1,47 @@
+package cn.novalon.manage.sys.core.query;
+
+/**
+ * 操作日志查询对象
+ * 
+ * @author 张翔
+ * @date 2026-03-13
+ */
+public class OperationLogQuery {
+
+    private String username;
+    private String operation;
+    private String status;
+    private String keyword;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getOperation() {
+        return operation;
+    }
+
+    public void setOperation(String operation) {
+        this.operation = operation;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getKeyword() {
+        return keyword;
+    }
+
+    public void setKeyword(String keyword) {
+        this.keyword = keyword;
+    }
+}

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/query/SysExceptionLogQuery.java

@@ -0,0 +1,47 @@
+package cn.novalon.manage.sys.core.query;
+
+/**
+ * 异常日志查询对象
+ * 
+ * @author 张翔
+ * @date 2026-03-13
+ */
+public class SysExceptionLogQuery {
+
+    private String username;
+    private String title;
+    private String exceptionName;
+    private String keyword;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getExceptionName() {
+        return exceptionName;
+    }
+
+    public void setExceptionName(String exceptionName) {
+        this.exceptionName = exceptionName;
+    }
+
+    public String getKeyword() {
+        return keyword;
+    }
+
+    public void setKeyword(String keyword) {
+        this.keyword = keyword;
+    }
+}

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/query/SysLoginLogQuery.java

@@ -0,0 +1,47 @@
+package cn.novalon.manage.sys.core.query;
+
+/**
+ * 登录日志查询对象
+ * 
+ * @author 张翔
+ * @date 2026-03-13
+ */
+public class SysLoginLogQuery {
+
+    private String username;
+    private String ip;
+    private String status;
+    private String keyword;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public String getKeyword() {
+        return keyword;
+    }
+
+    public void setKeyword(String keyword) {
+        this.keyword = keyword;
+    }
+}

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/repository/IOperationLogRepository.java

@@ -3,6 +3,7 @@ package cn.novalon.manage.sys.core.repository;
 import cn.novalon.manage.common.dto.PageRequest;
 import cn.novalon.manage.common.dto.PageResponse;
 import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -26,7 +27,7 @@ public interface IOperationLogRepository {
 
     Flux<OperationLog> findByUsername(String username);
 
-    Mono<PageResponse<OperationLog>> findOperationLogsByPage(PageRequest pageRequest);
+    Mono<PageResponse<OperationLog>> findByQueryWithPagination(OperationLogQuery query, PageRequest pageRequest);
 
     Mono<Long> count();
 

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/service/IOperationLogService.java

@@ -3,6 +3,7 @@ package cn.novalon.manage.sys.core.service;
 import cn.novalon.manage.common.dto.PageRequest;
 import cn.novalon.manage.common.dto.PageResponse;
 import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -17,7 +18,7 @@ public interface IOperationLogService {
     Flux<OperationLog> findAll();
     Mono<OperationLog> findById(Long id);
     Flux<OperationLog> findByUsername(String username);
-    Mono<PageResponse<OperationLog>> findOperationLogsByPage(PageRequest pageRequest);
+    Mono<PageResponse<OperationLog>> findByQueryWithPagination(OperationLogQuery query, PageRequest pageRequest);
     Mono<Long> count();
     Mono<Long> countToday();
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/service/impl/OperationLogService.java

@@ -3,6 +3,7 @@ package cn.novalon.manage.sys.core.service.impl;
 import cn.novalon.manage.common.dto.PageRequest;
 import cn.novalon.manage.common.dto.PageResponse;
 import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
 import cn.novalon.manage.sys.core.repository.IOperationLogRepository;
 import cn.novalon.manage.sys.core.service.IOperationLogService;
 import org.springframework.stereotype.Service;
@@ -48,8 +49,8 @@ public class OperationLogService implements IOperationLogService {
     }
 
     @Override
-    public Mono<PageResponse<OperationLog>> findOperationLogsByPage(PageRequest pageRequest) {
-        return logRepository.findOperationLogsByPage(pageRequest);
+    public Mono<PageResponse<OperationLog>> findByQueryWithPagination(OperationLogQuery query, PageRequest pageRequest) {
+        return logRepository.findByQueryWithPagination(query, pageRequest);
     }
 
     @Override

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/service/impl/SysRoleService.java

@@ -48,8 +48,7 @@ public class SysRoleService implements ISysRoleService {
         SysRoleQuery query = new SysRoleQuery();
 
         if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
-            query.setRoleName(pageRequest.getKeyword());
-            query.setRoleKey(pageRequest.getKeyword());
+            query.setKeyword(pageRequest.getKeyword());
         }
 
         return roleRepository.findByQueryWithPagination(query, pageRequest);

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/core/service/impl/SysUserService.java

@@ -2,7 +2,6 @@ package cn.novalon.manage.sys.core.service.impl;
 
 import cn.novalon.manage.common.util.StatusConstants;
 import cn.novalon.manage.sys.core.domain.SysUser;
-import cn.novalon.manage.sys.core.query.SysUserQuery;
 import cn.novalon.manage.common.dto.PageRequest;
 import cn.novalon.manage.common.dto.PageResponse;
 import cn.novalon.manage.sys.core.repository.ISysUserRepository;
@@ -59,14 +58,7 @@ public class SysUserService implements ISysUserService {
 
     @Override
     public Mono<PageResponse<SysUser>> findUsersByPage(PageRequest pageRequest) {
-        SysUserQuery query = new SysUserQuery();
-
-        if (pageRequest.getKeyword() != null && !pageRequest.getKeyword().isEmpty()) {
-            query.setUsername(pageRequest.getKeyword());
-            query.setEmail(pageRequest.getKeyword());
-        }
-
-        return userRepository.findByQueryWithPagination(query, pageRequest);
+        return userRepository.findByQueryWithPagination(null, pageRequest);
     }
 
     @Override
@@ -95,6 +87,8 @@ public class SysUserService implements ISysUserService {
         user.setUsername(command.username().getValue());
         user.setPassword(passwordEncoder.encode(command.password().getValue()));
         user.setEmail(command.email().getValue());
+        user.setNickname(command.nickname());
+        user.setPhone(command.phone());
         user.setRoleId(command.roleId());
         user.setStatus(command.status() != null ? command.status() : StatusConstants.ENABLED);
         user.setCreatedAt(LocalDateTime.now());
@@ -121,7 +115,9 @@ public class SysUserService implements ISysUserService {
                     if (command.email() != null) {
                         user.setEmail(command.email());
                     }
-                    if (command.roleId() != null) {
+                    if (command.clearRole()) {
+                        user.setRoleId(null);
+                    } else if (command.roleId() != null) {
                         user.setRoleId(command.roleId());
                     }
                     if (command.status() != null) {

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/dto/request/MenuCreateRequest.java

@@ -1,7 +1,6 @@
 package cn.novalon.manage.sys.dto.request;
 
 import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
 
 /**
  * 菜单创建请求DTO

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/dto/request/RoleUpdateRequest.java

@@ -1,7 +1,5 @@
 package cn.novalon.manage.sys.dto.request;
 
-import jakarta.validation.constraints.NotBlank;
-
 /**
  * 角色更新请求DTO
  * 

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/dto/request/UserRegisterRequest.java

@@ -16,6 +16,9 @@ public class UserRegisterRequest {
     @Size(min = 3, max = 50, message = "用户名长度必须在3-50之间")
     private String username;
 
+    @Size(max = 100, message = "昵称长度不能超过100")
+    private String nickname;
+
     @NotBlank(message = "密码不能为空")
     @Size(min = 6, max = 100, message = "密码长度必须在6-100之间")
     private String password;
@@ -23,6 +26,9 @@ public class UserRegisterRequest {
     @Email(message = "邮箱格式不正确")
     private String email;
 
+    @Size(max = 20, message = "手机号长度不能超过20")
+    private String phone;
+
     public String getUsername() {
         return username;
     }
@@ -31,6 +37,14 @@ public class UserRegisterRequest {
         this.username = username;
     }
 
+    public String getNickname() {
+        return nickname;
+    }
+
+    public void setNickname(String nickname) {
+        this.nickname = nickname;
+    }
+
     public String getPassword() {
         return password;
     }
@@ -46,4 +60,12 @@ public class UserRegisterRequest {
     public void setEmail(String email) {
         this.email = email;
     }
+
+    public String getPhone() {
+        return phone;
+    }
+
+    public void setPhone(String phone) {
+        this.phone = phone;
+    }
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/dto/request/UserUpdateRequest.java

@@ -15,6 +15,8 @@ public class UserUpdateRequest {
     private Integer status;
 
     private Long roleId;
+    
+    private Boolean clearRole;
 
     @Email(message = "邮箱格式不正确")
     public String getEmail() {
@@ -40,4 +42,12 @@ public class UserUpdateRequest {
     public void setRoleId(Long roleId) {
         this.roleId = roleId;
     }
+    
+    public Boolean getClearRole() {
+        return clearRole;
+    }
+    
+    public void setClearRole(Boolean clearRole) {
+        this.clearRole = clearRole;
+    }
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/handler/auth/SysAuthHandler.java

@@ -6,7 +6,10 @@ import cn.novalon.manage.sys.dto.response.AuthResponse;
 import cn.novalon.manage.sys.security.JwtTokenProvider;
 import cn.novalon.manage.sys.core.domain.SysUser;
 import cn.novalon.manage.sys.core.service.ISysUserService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Component;
 import org.springframework.validation.FieldError;
@@ -32,66 +35,117 @@ import java.util.stream.Collectors;
 @Component
 public class SysAuthHandler {
 
-    private final ISysUserService userService;
-    private final PasswordEncoder passwordEncoder;
-    private final JwtTokenProvider jwtTokenProvider;
+        private static final Logger logger = LoggerFactory.getLogger(SysAuthHandler.class);
+        private final ISysUserService userService;
+        private final PasswordEncoder passwordEncoder;
+        private final JwtTokenProvider jwtTokenProvider;
 
-    public SysAuthHandler(ISysUserService userService, PasswordEncoder passwordEncoder,
-            JwtTokenProvider jwtTokenProvider) {
-        this.userService = userService;
-        this.passwordEncoder = passwordEncoder;
-        this.jwtTokenProvider = jwtTokenProvider;
-    }
+        public SysAuthHandler(ISysUserService userService, PasswordEncoder passwordEncoder,
+                        JwtTokenProvider jwtTokenProvider) {
+                this.userService = userService;
+                this.passwordEncoder = passwordEncoder;
+                this.jwtTokenProvider = jwtTokenProvider;
+        }
 
-    public Mono<ServerResponse> login(ServerRequest request) {
-        return request.bodyToMono(LoginRequest.class)
-                .filter(loginRequest -> loginRequest.getUsername() != null
-                        && !loginRequest.getUsername().trim().isEmpty())
-                .switchIfEmpty(Mono.error(new IllegalArgumentException("用户名不能为空")))
-                .filter(loginRequest -> loginRequest.getPassword() != null
-                        && !loginRequest.getPassword().trim().isEmpty())
-                .switchIfEmpty(Mono.error(new IllegalArgumentException("密码不能为空")))
-                .flatMap(loginRequest -> userService.findByUsername(loginRequest.getUsername())
-                        .filter(user -> passwordEncoder.matches(loginRequest.getPassword(), user.getPassword()))
-                        .filter(user -> 1 == user.getStatus())
-                        .flatMap(user -> {
-                            String token = jwtTokenProvider.generateToken(user.getUsername(), user.getId());
-                            AuthResponse response = new AuthResponse(token, user.getId(), user.getUsername());
-                            return ServerResponse.ok().bodyValue(response);
-                        })
-                        .switchIfEmpty(ServerResponse.status(HttpStatus.UNAUTHORIZED).build()))
-                .onErrorResume(WebExchangeBindException.class, ex -> {
-                    String errorMessage = ex.getBindingResult().getFieldErrors().stream()
-                            .map(FieldError::getDefaultMessage)
-                            .collect(Collectors.joining(", "));
-                    return ServerResponse.badRequest().bodyValue(Map.of(
-                            "code", HttpStatus.BAD_REQUEST.value(),
-                            "message", errorMessage,
-                            "timestamp", LocalDateTime.now()));
-                })
-                .onErrorResume(IllegalArgumentException.class, ex -> {
-                    return ServerResponse.badRequest().bodyValue(Map.of(
-                            "code", HttpStatus.BAD_REQUEST.value(),
-                            "message", ex.getMessage(),
-                            "timestamp", LocalDateTime.now()));
-                });
-    }
+        public Mono<ServerResponse> login(ServerRequest request) {
+                return request.bodyToMono(LoginRequest.class)
+                                .filter(loginRequest -> loginRequest.getUsername() != null
+                                                && !loginRequest.getUsername().trim().isEmpty())
+                                .switchIfEmpty(Mono.error(new IllegalArgumentException("用户名不能为空")))
+                                .filter(loginRequest -> loginRequest.getPassword() != null
+                                                && !loginRequest.getPassword().trim().isEmpty())
+                                .switchIfEmpty(Mono.error(new IllegalArgumentException("密码不能为空")))
+                                .flatMap(loginRequest -> {
+                                        logger.info("用户登录请求: username={}", loginRequest.getUsername());
+                                        return userService.findByUsername(loginRequest.getUsername())
+                                                        .flatMap(user -> {
+                                                                if (!passwordEncoder.matches(loginRequest.getPassword(),
+                                                                                user.getPassword())) {
+                                                                        logger.warn("用户登录失败: username={}, reason=密码错误",
+                                                                                        loginRequest.getUsername());
+                                                                        return Mono.error(new RuntimeException(
+                                                                                        "用户名或密码错误"));
+                                                                }
+                                                                if (user.getStatus() != 1) {
+                                                                        logger.warn("用户登录失败: username={}, reason=用户已禁用",
+                                                                                        loginRequest.getUsername());
+                                                                        return Mono.error(new RuntimeException(
+                                                                                        "用户名或密码错误"));
+                                                                }
+                                                                String token = jwtTokenProvider.generateToken(
+                                                                                user.getUsername(), user.getId());
+                                                                logger.info("用户登录成功: username={}, userId={}",
+                                                                                user.getUsername(), user.getId());
+                                                                AuthResponse response = new AuthResponse(token,
+                                                                                user.getId(), user.getUsername());
+                                                                return ServerResponse.ok().bodyValue(response);
+                                                        })
+                                                        .switchIfEmpty(Mono.defer(() -> {
+                                                                logger.warn("用户登录失败: username={}, reason=用户不存在",
+                                                                                loginRequest.getUsername());
+                                                                return Mono.error(new RuntimeException("用户名或密码错误"));
+                                                        }));
+                                })
+                                .onErrorResume(WebExchangeBindException.class, ex -> {
+                                        String errorMessage = ex.getBindingResult().getFieldErrors().stream()
+                                                        .map(FieldError::getDefaultMessage)
+                                                        .collect(Collectors.joining(", "));
+                                        logger.warn("用户登录请求参数验证失败: {}", errorMessage);
+                                        return ServerResponse.badRequest().bodyValue(Map.of(
+                                                        "code", HttpStatus.BAD_REQUEST.value(),
+                                                        "message", errorMessage,
+                                                        "timestamp", LocalDateTime.now()));
+                                })
+                                .onErrorResume(IllegalArgumentException.class, ex -> {
+                                        logger.warn("用户登录请求参数错误: {}", ex.getMessage());
+                                        return ServerResponse.badRequest().bodyValue(Map.of(
+                                                        "code", HttpStatus.BAD_REQUEST.value(),
+                                                        "message", ex.getMessage(),
+                                                        "timestamp", LocalDateTime.now()));
+                                })
+                                .onErrorResume(RuntimeException.class, ex -> {
+                                        if ("用户名或密码错误".equals(ex.getMessage())) {
+                                                return ServerResponse.status(HttpStatus.UNAUTHORIZED)
+                                                                .contentType(MediaType.APPLICATION_JSON)
+                                                                .bodyValue(Map.of(
+                                                                                "code", HttpStatus.UNAUTHORIZED.value(),
+                                                                                "message", "用户名或密码错误",
+                                                                                "timestamp", LocalDateTime.now()));
+                                        }
+                                        logger.error("用户登录发生未预期的错误", ex);
+                                        return Mono.error(ex);
+                                });
+        }
 
-    public Mono<ServerResponse> register(ServerRequest request) {
-        return request.bodyToMono(UserRegisterRequest.class)
-                .flatMap(registerRequest -> {
-                    SysUser user = new SysUser();
-                    user.setUsername(registerRequest.getUsername());
-                    user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
-                    user.setEmail(registerRequest.getEmail());
-                    return userService.findByUsername(registerRequest.getUsername())
-                            .flatMap(existing -> Mono.<ServerResponse>error(new RuntimeException("用户名已存在")))
-                            .switchIfEmpty(userService.createUser(user)
-                                    .flatMap(u -> ServerResponse.status(HttpStatus.CREATED).bodyValue(u)));
-                });
-    }
+        public Mono<ServerResponse> register(ServerRequest request) {
+                return request.bodyToMono(UserRegisterRequest.class)
+                                .flatMap(registerRequest -> {
+                                        logger.info("用户注册请求: username={}, email={}",
+                                                        registerRequest.getUsername(), registerRequest.getEmail());
+                                        SysUser user = new SysUser();
+                                        user.setUsername(registerRequest.getUsername());
+                                        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));
+                                        user.setEmail(registerRequest.getEmail());
+                                        return userService.findByUsername(registerRequest.getUsername())
+                                                        .flatMap(existing -> {
+                                                                logger.warn("用户注册失败: username={}, reason=用户名已存在",
+                                                                                registerRequest.getUsername());
+                                                                return Mono.<ServerResponse>error(
+                                                                                new RuntimeException("用户名已存在"));
+                                                        })
+                                                        .switchIfEmpty(userService.createUser(user)
+                                                                        .flatMap(u -> {
+                                                                                logger.info("用户注册成功: username={}, userId={}",
+                                                                                                u.getUsername(),
+                                                                                                u.getId());
+                                                                                return ServerResponse
+                                                                                                .status(HttpStatus.CREATED)
+                                                                                                .bodyValue(u);
+                                                                        }));
+                                });
+        }
 
-    public Mono<ServerResponse> logout(ServerRequest request) {
-        return ServerResponse.ok().build();
-    }
+        public Mono<ServerResponse> logout(ServerRequest request) {
+                return ServerResponse.ok().build();
+        }
 }

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/handler/log/OperationLogHandler.java

@@ -1,6 +1,7 @@
 package cn.novalon.manage.sys.handler.log;
 
 import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
 import cn.novalon.manage.sys.core.service.IOperationLogService;
 import cn.novalon.manage.common.dto.PageRequest;
 import io.swagger.v3.oas.annotations.Operation;
@@ -49,9 +50,12 @@ public class OperationLogHandler {
     public Mono<ServerResponse> getOperationLogsByPage(ServerRequest request) {
         int page = Integer.parseInt(request.queryParam("page").orElse("0"));
         int size = Integer.parseInt(request.queryParam("size").orElse("10"));
-        String sort = request.queryParam("sort").orElse("created_at");
+        String sort = request.queryParam("sort").orElse("createdAt");
         String order = request.queryParam("order").orElse("desc");
         String keyword = request.queryParam("keyword").orElse(null);
+        String username = request.queryParam("username").orElse(null);
+        String operation = request.queryParam("operation").orElse(null);
+        String status = request.queryParam("status").orElse(null);
 
         PageRequest pageRequest = new PageRequest();
         pageRequest.setPage(page);
@@ -60,7 +64,13 @@ public class OperationLogHandler {
         pageRequest.setOrder(order);
         pageRequest.setKeyword(keyword);
 
-        return logService.findOperationLogsByPage(pageRequest)
+        OperationLogQuery query = new OperationLogQuery();
+        query.setUsername(username);
+        query.setOperation(operation);
+        query.setStatus(status);
+        query.setKeyword(keyword);
+
+        return logService.findByQueryWithPagination(query, pageRequest)
                 .flatMap(response -> ServerResponse.ok().bodyValue(response));
     }
 

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/handler/user/SysUserHandler.java

@@ -93,6 +93,8 @@ public class SysUserHandler {
                         req.getUsername(),
                         req.getPassword(),
                         req.getEmail(),
+                        req.getNickname(),
+                        req.getPhone(),
                         null,
                         null
                 ))
@@ -104,14 +106,19 @@ public class SysUserHandler {
     public Mono<ServerResponse> updateUser(ServerRequest request) {
         Long id = Long.valueOf(request.pathVariable("id"));
         return request.bodyToMono(UserUpdateRequest.class)
-                .map(req -> UpdateUserCommand.of(
-                        id,
-                        null,
-                        null,
-                        req.getEmail(),
-                        req.getRoleId(),
-                        req.getStatus()
-                ))
+                .map(req -> {
+                    boolean clearRole = Boolean.TRUE.equals(req.getClearRole()) || 
+                                       (req.getRoleId() == null && req.getClearRole() != null);
+                    return UpdateUserCommand.of(
+                            id,
+                            null,
+                            null,
+                            req.getEmail(),
+                            req.getRoleId(),
+                            req.getStatus(),
+                            clearRole
+                    );
+                })
                 .flatMap(userService::updateUser)
                 .flatMap(user -> ServerResponse.ok().bodyValue(user))
                 .switchIfEmpty(ServerResponse.notFound().build());

novalon-manage-api/manage-sys/src/main/java/cn/novalon/manage/sys/interceptor/OperationLogFilter.java

@@ -13,8 +13,6 @@ import org.springframework.web.server.WebFilter;
 import org.springframework.web.server.WebFilterChain;
 import reactor.core.publisher.Mono;
 
-import java.time.Duration;
-
 /**
  * 操作日志过滤器
  * 
@@ -31,22 +29,23 @@ public class OperationLogFilter implements WebFilter {
     private static final Logger logger = LoggerFactory.getLogger(OperationLogFilter.class);
 
     private final IOperationLogService logService;
-    private final ObjectMapper objectMapper;
-
     public OperationLogFilter(IOperationLogService logService, ObjectMapper objectMapper) {
         this.logService = logService;
-        this.objectMapper = objectMapper;
     }
 
     @Override
     public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
         long startTime = System.currentTimeMillis();
         ServerHttpRequest request = exchange.getRequest();
-        
+
         String path = request.getPath().value();
         String method = request.getMethod().name();
         String ip = getClientIp(request);
-        
+
+        if (path.startsWith("/api/auth/")) {
+            return chain.filter(exchange);
+        }
+
         return chain.filter(exchange)
                 .doOnSuccess(v -> {
                     long duration = System.currentTimeMillis() - startTime;
@@ -58,14 +57,15 @@ public class OperationLogFilter implements WebFilter {
                 });
     }
 
-    private void recordLog(ServerWebExchange exchange, String path, String method, String ip, long duration, String errorMsg) {
+    private void recordLog(ServerWebExchange exchange, String path, String method, String ip, long duration,
+            String errorMsg) {
         try {
             OperationLog log = new OperationLog();
             log.setOperation(path);
             log.setMethod(method);
             log.setIp(ip);
             log.setDuration(duration);
-            
+
             if (errorMsg != null) {
                 log.setStatus("1");
                 log.setErrorMsg(errorMsg);
@@ -74,10 +74,10 @@ public class OperationLogFilter implements WebFilter {
                 log.setStatus("0");
                 log.setResult("Success");
             }
-            
+
             String queryParams = exchange.getRequest().getQueryParams().toSingleValueMap().toString();
             log.setParams(queryParams);
-            
+
             ReactiveSecurityContextHolder.getContext()
                     .flatMap(securityContext -> {
                         Object principal = securityContext.getAuthentication().getPrincipal();

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/config/SecurityConfigTest.java

@@ -6,10 +6,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpMethod;
-import org.springframework.security.config.web.server.ServerHttpSecurity;
 import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.security.web.server.SecurityWebFilterChain;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/command/CreateRoleCommandTest.java

@@ -0,0 +1,281 @@
+package cn.novalon.manage.sys.core.command;
+
+import cn.novalon.manage.common.util.StatusConstants;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CreateRoleCommandTest {
+
+    @Test
+    void testConstructor() {
+        CreateRoleCommand command = new CreateRoleCommand(
+                "Admin",
+                "admin",
+                1,
+                1
+        );
+
+        assertEquals("Admin", command.roleName());
+        assertEquals("admin", command.roleKey());
+        assertEquals(1, command.roleSort());
+        assertEquals(1, command.status());
+    }
+
+    @Test
+    void testOf_WithValidStatus() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin",
+                "admin",
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("Admin", command.roleName());
+        assertEquals("admin", command.roleKey());
+        assertEquals(1, command.roleSort());
+        assertEquals(StatusConstants.ENABLED, command.status());
+    }
+
+    @Test
+    void testOf_WithDisabledStatus() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin",
+                "admin",
+                1,
+                StatusConstants.DISABLED
+        );
+
+        assertEquals("Admin", command.roleName());
+        assertEquals("admin", command.roleKey());
+        assertEquals(1, command.roleSort());
+        assertEquals(StatusConstants.DISABLED, command.status());
+    }
+
+    @Test
+    void testOf_WithNullStatus() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin",
+                "admin",
+                1,
+                null
+        );
+
+        assertEquals("Admin", command.roleName());
+        assertEquals("admin", command.roleKey());
+        assertEquals(1, command.roleSort());
+        assertNull(command.status());
+    }
+
+    @Test
+    void testOf_WithInvalidStatus() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> CreateRoleCommand.of(
+                        "Admin",
+                        "admin",
+                        1,
+                        999
+                )
+        );
+
+        assertEquals("Invalid status value. Status must be 0 (disabled) or 1 (enabled)", exception.getMessage());
+    }
+
+    @Test
+    void testOf_WithInvalidStatus_Negative() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> CreateRoleCommand.of(
+                        "Admin",
+                        "admin",
+                        1,
+                        -1
+                )
+        );
+
+        assertEquals("Invalid status value. Status must be 0 (disabled) or 1 (enabled)", exception.getMessage());
+    }
+
+    @Test
+    void testOf_WithInvalidStatus_Two() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> CreateRoleCommand.of(
+                        "Admin",
+                        "admin",
+                        1,
+                        2
+                )
+        );
+
+        assertEquals("Invalid status value. Status must be 0 (disabled) or 1 (enabled)", exception.getMessage());
+    }
+
+    @Test
+    void testOf_WithNullValues() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                null,
+                null,
+                null,
+                null
+        );
+
+        assertNull(command.roleName());
+        assertNull(command.roleKey());
+        assertNull(command.roleSort());
+        assertNull(command.status());
+    }
+
+    @Test
+    void testOf_WithEmptyStrings() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "",
+                "",
+                null,
+                null
+        );
+
+        assertEquals("", command.roleName());
+        assertEquals("", command.roleKey());
+        assertNull(command.roleSort());
+        assertNull(command.status());
+    }
+
+    @Test
+    void testOf_WithBoundaryValues() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "a",
+                "a",
+                Integer.MAX_VALUE,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("a", command.roleName());
+        assertEquals("a", command.roleKey());
+        assertEquals(Integer.MAX_VALUE, command.roleSort());
+        assertEquals(StatusConstants.ENABLED, command.status());
+    }
+
+    @Test
+    void testOf_WithZeroValues() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin",
+                "admin",
+                0,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals(0, command.roleSort());
+    }
+
+    @Test
+    void testOf_WithNegativeSort() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin",
+                "admin",
+                -1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals(-1, command.roleSort());
+    }
+
+    @Test
+    void testOf_WithSpecialCharacters() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "Admin@#$%",
+                "admin@#$%",
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("Admin@#$%", command.roleName());
+        assertEquals("admin@#$%", command.roleKey());
+    }
+
+    @Test
+    void testOf_WithLongStrings() {
+        String longRoleName = "a".repeat(1000);
+        String longRoleKey = "b".repeat(1000);
+        
+        CreateRoleCommand command = CreateRoleCommand.of(
+                longRoleName,
+                longRoleKey,
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals(longRoleName, command.roleName());
+        assertEquals(longRoleKey, command.roleKey());
+    }
+
+    @Test
+    void testOf_WithUnicodeCharacters() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "管理员_测试",
+                "admin_测试",
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("管理员_测试", command.roleName());
+        assertEquals("admin_测试", command.roleKey());
+    }
+
+    @Test
+    void testOf_WithWhitespace() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "  Admin  ",
+                "  admin  ",
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("  Admin  ", command.roleName());
+        assertEquals("  admin  ", command.roleKey());
+    }
+
+    @Test
+    void testOf_WithNumericStrings() {
+        CreateRoleCommand command = CreateRoleCommand.of(
+                "12345",
+                "67890",
+                1,
+                StatusConstants.ENABLED
+        );
+
+        assertEquals("12345", command.roleName());
+        assertEquals("67890", command.roleKey());
+    }
+
+    @Test
+    void testValidateStatus_EdgeCase_MaxInt() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> CreateRoleCommand.of(
+                        "Admin",
+                        "admin",
+                        1,
+                        Integer.MAX_VALUE
+                )
+        );
+
+        assertEquals("Invalid status value. Status must be 0 (disabled) or 1 (enabled)", exception.getMessage());
+    }
+
+    @Test
+    void testValidateStatus_EdgeCase_MinInt() {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> CreateRoleCommand.of(
+                        "Admin",
+                        "admin",
+                        1,
+                        Integer.MIN_VALUE
+                )
+        );
+
+        assertEquals("Invalid status value. Status must be 0 (disabled) or 1 (enabled)", exception.getMessage());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/command/CreateUserCommandTest.java

@@ -0,0 +1,246 @@
+package cn.novalon.manage.sys.core.command;
+
+import cn.novalon.manage.sys.primitive.Email;
+import cn.novalon.manage.sys.primitive.Password;
+import cn.novalon.manage.sys.primitive.Username;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CreateUserCommandTest {
+
+    @Test
+    void testConstructor() {
+        Username username = Username.of("testuser");
+        Password password = Password.of("Password123!");
+        Email email = Email.of("test@example.com");
+        
+        CreateUserCommand command = new CreateUserCommand(
+                username,
+                password,
+                email,
+                "nickname",
+                "1234567890",
+                1L,
+                1
+        );
+
+        assertEquals(username, command.username());
+        assertEquals(password, command.password());
+        assertEquals(email, command.email());
+        assertEquals("nickname", command.nickname());
+        assertEquals("1234567890", command.phone());
+        assertEquals(1L, command.roleId());
+        assertEquals(1, command.status());
+    }
+
+    @Test
+    void testOf() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                "nickname",
+                "1234567890",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("nickname", command.nickname());
+        assertEquals("1234567890", command.phone());
+        assertEquals(1L, command.roleId());
+        assertEquals(1, command.status());
+    }
+
+    @Test
+    void testOf_WithNullValues() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                null,
+                null,
+                null,
+                null
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertNull(command.nickname());
+        assertNull(command.phone());
+        assertNull(command.roleId());
+        assertNull(command.status());
+    }
+
+    @Test
+    void testOf_WithEmptyStrings() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                "",
+                "",
+                null,
+                null
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("", command.nickname());
+        assertEquals("", command.phone());
+        assertNull(command.roleId());
+        assertNull(command.status());
+    }
+
+    @Test
+    void testOf_WithBoundaryValues() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "abc",
+                "Abc123!@",
+                "a@b.co",
+                "n",
+                "0",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("n", command.nickname());
+        assertEquals("0", command.phone());
+        assertEquals(1L, command.roleId());
+        assertEquals(1, command.status());
+    }
+
+    @Test
+    void testOf_WithZeroValues() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                "nickname",
+                "1234567890",
+                0L,
+                0
+        );
+
+        assertEquals(0L, command.roleId());
+        assertEquals(0, command.status());
+    }
+
+    @Test
+    void testOf_WithNegativeValues() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                "nickname",
+                "1234567890",
+                -1L,
+                -1
+        );
+
+        assertEquals(-1L, command.roleId());
+        assertEquals(-1, command.status());
+    }
+
+    @Test
+    void testOf_WithSpecialCharacters() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "test_user",
+                "Password123!",
+                "test@example.com",
+                "nick@#$%",
+                "123@#$%",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("nick@#$%", command.nickname());
+        assertEquals("123@#$%", command.phone());
+    }
+
+    @Test
+    void testOf_WithLongStrings() {
+        String longNickname = "a".repeat(1000);
+        String longPhone = "1".repeat(100);
+        
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                longNickname,
+                longPhone,
+                1L,
+                1
+        );
+
+        assertEquals(longNickname, command.nickname());
+        assertEquals(longPhone, command.phone());
+    }
+
+    @Test
+    void testOf_WithUnicodeCharacters() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "test_user",
+                "Password123!",
+                "test@example.com",
+                "昵称_测试",
+                "1234567890",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("昵称_测试", command.nickname());
+    }
+
+    @Test
+    void testOf_WithWhitespace() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "testuser",
+                "Password123!",
+                "test@example.com",
+                "  nickname  ",
+                "  1234567890  ",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("  nickname  ", command.nickname());
+        assertEquals("  1234567890  ", command.phone());
+    }
+
+    @Test
+    void testOf_WithNumericStrings() {
+        CreateUserCommand command = CreateUserCommand.of(
+                "test123",
+                "Password123!",
+                "test@example.com",
+                "12345",
+                "12345",
+                1L,
+                1
+        );
+
+        assertNotNull(command.username());
+        assertNotNull(command.password());
+        assertNotNull(command.email());
+        assertEquals("12345", command.nickname());
+        assertEquals("12345", command.phone());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/command/UpdateUserCommandTest.java

@@ -0,0 +1,312 @@
+package cn.novalon.manage.sys.core.command;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UpdateUserCommandTest {
+
+    @Test
+    void testConstructor() {
+        UpdateUserCommand command = new UpdateUserCommand(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1,
+                false
+        );
+
+        assertEquals(1L, command.id());
+        assertEquals("testuser", command.username());
+        assertEquals("password123", command.password());
+        assertEquals("test@example.com", command.email());
+        assertEquals(2L, command.roleId());
+        assertEquals(1, command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithoutClearRole() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1
+        );
+
+        assertEquals(1L, command.id());
+        assertEquals("testuser", command.username());
+        assertEquals("password123", command.password());
+        assertEquals("test@example.com", command.email());
+        assertEquals(2L, command.roleId());
+        assertEquals(1, command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithClearRoleFalse() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1,
+                false
+        );
+
+        assertEquals(1L, command.id());
+        assertEquals("testuser", command.username());
+        assertEquals("password123", command.password());
+        assertEquals("test@example.com", command.email());
+        assertEquals(2L, command.roleId());
+        assertEquals(1, command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithClearRoleTrue() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1,
+                true
+        );
+
+        assertEquals(1L, command.id());
+        assertEquals("testuser", command.username());
+        assertEquals("password123", command.password());
+        assertEquals("test@example.com", command.email());
+        assertEquals(2L, command.roleId());
+        assertEquals(1, command.status());
+        assertTrue(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithNullValues() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                null,
+                null,
+                null,
+                null,
+                null,
+                null
+        );
+
+        assertNull(command.id());
+        assertNull(command.username());
+        assertNull(command.password());
+        assertNull(command.email());
+        assertNull(command.roleId());
+        assertNull(command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithEmptyStrings() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "",
+                "",
+                "",
+                null,
+                null
+        );
+
+        assertEquals(1L, command.id());
+        assertEquals("", command.username());
+        assertEquals("", command.password());
+        assertEquals("", command.email());
+        assertNull(command.roleId());
+        assertNull(command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithBoundaryValues() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                Long.MAX_VALUE,
+                "a",
+                "1",
+                "a@b.c",
+                Long.MAX_VALUE,
+                Integer.MAX_VALUE,
+                true
+        );
+
+        assertEquals(Long.MAX_VALUE, command.id());
+        assertEquals("a", command.username());
+        assertEquals("1", command.password());
+        assertEquals("a@b.c", command.email());
+        assertEquals(Long.MAX_VALUE, command.roleId());
+        assertEquals(Integer.MAX_VALUE, command.status());
+        assertTrue(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithZeroValues() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                0L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                0L,
+                0,
+                false
+        );
+
+        assertEquals(0L, command.id());
+        assertEquals(0L, command.roleId());
+        assertEquals(0, command.status());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithNegativeValues() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                -1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                -1L,
+                -1,
+                true
+        );
+
+        assertEquals(-1L, command.id());
+        assertEquals(-1L, command.roleId());
+        assertEquals(-1, command.status());
+        assertTrue(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithSpecialCharacters() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "user@#$%",
+                "pass@#$%",
+                "test@#$%.com",
+                1L,
+                1,
+                false
+        );
+
+        assertEquals("user@#$%", command.username());
+        assertEquals("pass@#$%", command.password());
+        assertEquals("test@#$%.com", command.email());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithLongStrings() {
+        String longUsername = "a".repeat(1000);
+        String longPassword = "b".repeat(1000);
+        String longEmail = "c".repeat(1000) + "@example.com";
+        
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                longUsername,
+                longPassword,
+                longEmail,
+                1L,
+                1,
+                false
+        );
+
+        assertEquals(longUsername, command.username());
+        assertEquals(longPassword, command.password());
+        assertEquals(longEmail, command.email());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithUnicodeCharacters() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "用户_测试",
+                "密码_测试",
+                "测试@example.com",
+                1L,
+                1,
+                false
+        );
+
+        assertEquals("用户_测试", command.username());
+        assertEquals("密码_测试", command.password());
+        assertEquals("测试@example.com", command.email());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithWhitespace() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "  testuser  ",
+                "  password123  ",
+                "  test@example.com  ",
+                1L,
+                1,
+                false
+        );
+
+        assertEquals("  testuser  ", command.username());
+        assertEquals("  password123  ", command.password());
+        assertEquals("  test@example.com  ", command.email());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testOf_WithNumericStrings() {
+        UpdateUserCommand command = UpdateUserCommand.of(
+                1L,
+                "12345",
+                "12345",
+                "12345@example.com",
+                1L,
+                1,
+                false
+        );
+
+        assertEquals("12345", command.username());
+        assertEquals("12345", command.password());
+        assertEquals("12345@example.com", command.email());
+        assertFalse(command.clearRole());
+    }
+
+    @Test
+    void testClearRoleFlag_True() {
+        UpdateUserCommand command = new UpdateUserCommand(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1,
+                true
+        );
+
+        assertTrue(command.clearRole());
+    }
+
+    @Test
+    void testClearRoleFlag_False() {
+        UpdateUserCommand command = new UpdateUserCommand(
+                1L,
+                "testuser",
+                "password123",
+                "test@example.com",
+                2L,
+                1,
+                false
+        );
+
+        assertFalse(command.clearRole());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/domain/SysUserTest.java

@@ -0,0 +1,106 @@
+package cn.novalon.manage.sys.core.domain;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SysUserTest {
+
+    private SysUser user;
+
+    @BeforeEach
+    void setUp() {
+        user = new SysUser();
+    }
+
+    @Test
+    void testGenerateId() {
+        Long id = user.generateId();
+
+        assertNotNull(id);
+        assertTrue(id > 0);
+        assertEquals(id, user.getId());
+    }
+
+    @Test
+    void testGenerateId_GeneratesUniqueIds() {
+        SysUser user1 = new SysUser();
+        SysUser user2 = new SysUser();
+
+        Long id1 = user1.generateId();
+        Long id2 = user2.generateId();
+
+        assertNotNull(id1);
+        assertNotNull(id2);
+        assertNotEquals(id1, id2);
+    }
+
+    @Test
+    void testDelete() {
+        assertNull(user.getDeletedAt());
+
+        user.delete();
+
+        assertNotNull(user.getDeletedAt());
+        assertTrue(user.getDeletedAt().isBefore(LocalDateTime.now().plusSeconds(1)));
+        assertTrue(user.getDeletedAt().isAfter(LocalDateTime.now().minusSeconds(1)));
+    }
+
+    @Test
+    void testDelete_WhenAlreadyDeleted() {
+        user.delete();
+        LocalDateTime firstDeleteTime = user.getDeletedAt();
+
+        user.delete();
+        LocalDateTime secondDeleteTime = user.getDeletedAt();
+
+        assertNotNull(firstDeleteTime);
+        assertNotNull(secondDeleteTime);
+        assertNotEquals(firstDeleteTime, secondDeleteTime);
+    }
+
+    @Test
+    void testUsername() {
+        user.setUsername("testuser");
+        assertEquals("testuser", user.getUsername());
+    }
+
+    @Test
+    void testPassword() {
+        user.setPassword("password123");
+        assertEquals("password123", user.getPassword());
+    }
+
+    @Test
+    void testNickname() {
+        user.setNickname("测试用户");
+        assertEquals("测试用户", user.getNickname());
+    }
+
+    @Test
+    void testEmail() {
+        user.setEmail("test@example.com");
+        assertEquals("test@example.com", user.getEmail());
+    }
+
+    @Test
+    void testPhone() {
+        user.setPhone("13800138000");
+        assertEquals("13800138000", user.getPhone());
+    }
+
+    @Test
+    void testRoleId() {
+        user.setRoleId(1L);
+        assertEquals(1L, user.getRoleId());
+    }
+
+    @Test
+    void testStatus() {
+        user.setStatus(1);
+        assertEquals(1, user.getStatus());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/OperationLogServiceTest.java

@@ -1,7 +1,10 @@
 package cn.novalon.manage.sys.core.service.impl;
 
 import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
 import cn.novalon.manage.sys.core.repository.IOperationLogRepository;
+import cn.novalon.manage.common.dto.PageRequest;
+import cn.novalon.manage.common.dto.PageResponse;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -12,9 +15,9 @@ import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.LocalDateTime;
+import java.util.Collections;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -30,7 +33,7 @@ class OperationLogServiceTest {
     @BeforeEach
     void setUp() {
         operationLogService = new OperationLogService(logRepository);
-        
+
         testLog = new OperationLog();
         testLog.setId(1L);
         testLog.setUsername("testuser");
@@ -45,68 +48,121 @@ class OperationLogServiceTest {
     @Test
     void testSave() {
         when(logRepository.save(any(OperationLog.class))).thenReturn(Mono.just(testLog));
-        
+
         Mono<OperationLog> result = operationLogService.save(testLog);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(log -> 
-                    log.getId().equals(1L) && 
-                    log.getUsername().equals("testuser") &&
-                    log.getCreatedAt() != null)
+                .expectNextMatches(log -> log.getId().equals(1L) &&
+                        log.getUsername().equals("testuser") &&
+                        log.getCreatedAt() != null)
                 .verifyComplete();
-        
+
         verify(logRepository).save(any(OperationLog.class));
     }
 
     @Test
     void testFindAll() {
         when(logRepository.findAll()).thenReturn(Flux.just(testLog));
-        
+
         Flux<OperationLog> result = operationLogService.findAll();
-        
+
         StepVerifier.create(result)
                 .expectNext(testLog)
                 .verifyComplete();
-        
+
         verify(logRepository).findAll();
     }
 
     @Test
     void testFindByUsername() {
         when(logRepository.findByUsername("testuser")).thenReturn(Flux.just(testLog));
-        
+
         Flux<OperationLog> result = operationLogService.findByUsername("testuser");
-        
+
         StepVerifier.create(result)
                 .expectNext(testLog)
                 .verifyComplete();
-        
+
         verify(logRepository).findByUsername("testuser");
     }
 
     @Test
     void testCount() {
         when(logRepository.count()).thenReturn(Mono.just(100L));
-        
+
         Mono<Long> result = operationLogService.count();
-        
+
         StepVerifier.create(result)
                 .expectNext(100L)
                 .verifyComplete();
-        
+
         verify(logRepository).count();
     }
 
     @Test
     void testCountToday() {
         when(logRepository.countByCreatedAtAfter(any(LocalDateTime.class))).thenReturn(Mono.just(10L));
-        
+
         Mono<Long> result = operationLogService.countToday();
-        
+
         StepVerifier.create(result)
                 .expectNext(10L)
                 .verifyComplete();
-        
+
         verify(logRepository).countByCreatedAtAfter(any(LocalDateTime.class));
     }
+
+    @Test
+    void testFindById() {
+        when(logRepository.findById(1L)).thenReturn(Mono.just(testLog));
+
+        Mono<OperationLog> result = operationLogService.findById(1L);
+
+        StepVerifier.create(result)
+                .expectNext(testLog)
+                .verifyComplete();
+
+        verify(logRepository).findById(1L);
+    }
+
+    @Test
+    void testFindById_NotFound() {
+        when(logRepository.findById(999L)).thenReturn(Mono.empty());
+
+        Mono<OperationLog> result = operationLogService.findById(999L);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+
+        verify(logRepository).findById(999L);
+    }
+
+    @Test
+    void testFindByQueryWithPagination() {
+        PageResponse<OperationLog> pageResponse = new PageResponse<>();
+        pageResponse.setContent(Collections.singletonList(testLog));
+        pageResponse.setTotalElements(1L);
+        pageResponse.setTotalPages(1);
+        pageResponse.setCurrentPage(0);
+        pageResponse.setPageSize(10);
+
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+
+        OperationLogQuery query = new OperationLogQuery();
+
+        when(logRepository.findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class)))
+                .thenReturn(Mono.just(pageResponse));
+
+        Mono<PageResponse<OperationLog>> result = operationLogService.findByQueryWithPagination(query, pageRequest);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> response.getContent().size() == 1 &&
+                        response.getTotalElements() == 1L &&
+                        response.getTotalPages() == 1)
+                .verifyComplete();
+
+        verify(logRepository).findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class));
+    }
 }

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysConfigServiceTest.java

@@ -11,8 +11,8 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 /**
  * 系统配置服务单元测试类

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictDataServiceTest.java

@@ -14,8 +14,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictTypeServiceTest.java

@@ -14,8 +14,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysExceptionLogServiceTest.java

@@ -14,10 +14,8 @@ import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.LocalDateTime;
-import java.util.List;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysLoginLogServiceTest.java

@@ -14,10 +14,8 @@ import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.LocalDateTime;
-import java.util.List;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysMenuServiceTest.java

@@ -14,10 +14,8 @@ import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.LocalDateTime;
-import java.util.Arrays;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -33,7 +31,7 @@ class SysMenuServiceTest {
     @BeforeEach
     void setUp() {
         menuService = new SysMenuService(menuRepository);
-        
+
         testMenu = new SysMenu();
         testMenu.setId(1L);
         testMenu.setMenuName("系统管理");
@@ -49,64 +47,62 @@ class SysMenuServiceTest {
     @Test
     void testFindById() {
         when(menuRepository.findById(1L)).thenReturn(Mono.just(testMenu));
-        
+
         Mono<SysMenu> result = menuService.findById(1L);
-        
+
         StepVerifier.create(result)
                 .expectNext(testMenu)
                 .verifyComplete();
-        
+
         verify(menuRepository).findById(1L);
     }
 
     @Test
     void testFindAll() {
         when(menuRepository.findAll()).thenReturn(Flux.just(testMenu));
-        
+
         Flux<SysMenu> result = menuService.findAll();
-        
+
         StepVerifier.create(result)
                 .expectNext(testMenu)
                 .verifyComplete();
-        
+
         verify(menuRepository).findAll();
     }
 
     @Test
     void testFindByParentId() {
         when(menuRepository.findByParentId(0L)).thenReturn(Flux.just(testMenu));
-        
+
         Flux<SysMenu> result = menuService.findByParentId(0L);
-        
+
         StepVerifier.create(result)
                 .expectNext(testMenu)
                 .verifyComplete();
-        
+
         verify(menuRepository).findByParentId(0L);
     }
 
     @Test
     void testCreateMenu() {
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
-        
+
         Mono<SysMenu> result = menuService.createMenu(testMenu);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getId().equals(1L) && 
-                    menu.getMenuName().equals("系统管理") &&
-                    menu.getCreatedAt() != null)
+                .expectNextMatches(menu -> menu.getId().equals(1L) &&
+                        menu.getMenuName().equals("系统管理") &&
+                        menu.getCreatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).save(any(SysMenu.class));
     }
 
     @Test
     void testCreateMenuWithCommand() {
         CreateMenuCommand command = new CreateMenuCommand(
-            0L, "用户管理", "M", 2, "user", "user:manage", 1
-        );
-        
+                0L, "用户管理", "M", 2, "user", "user:manage", 1);
+
         SysMenu createdMenu = new SysMenu();
         createdMenu.setId(2L);
         createdMenu.setMenuName("用户管理");
@@ -117,53 +113,49 @@ class SysMenuServiceTest {
         createdMenu.setComponent("user");
         createdMenu.setStatus(1);
         createdMenu.setCreatedAt(LocalDateTime.now());
-        
+
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(createdMenu));
-        
+
         Mono<SysMenu> result = menuService.createMenu(command);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getMenuName().equals("用户管理") &&
-                    menu.getParentId().equals(0L) &&
-                    menu.getCreatedAt() != null)
+                .expectNextMatches(menu -> menu.getMenuName().equals("用户管理") &&
+                        menu.getParentId().equals(0L) &&
+                        menu.getCreatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).save(any(SysMenu.class));
     }
 
     @Test
     void testUpdateMenu() {
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
-        
+
         Mono<SysMenu> result = menuService.updateMenu(testMenu);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getId().equals(1L) && 
-                    menu.getUpdatedAt() != null)
+                .expectNextMatches(menu -> menu.getId().equals(1L) &&
+                        menu.getUpdatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).save(any(SysMenu.class));
     }
 
     @Test
     void testUpdateMenuWithCommand() {
         UpdateMenuCommand command = new UpdateMenuCommand(
-            1L, 0L, "系统管理（更新）", "M", 1, "system", "system:manage", 1
-        );
-        
+                1L, 0L, "系统管理（更新）", "M", 1, "system", "system:manage", 1);
+
         when(menuRepository.findById(1L)).thenReturn(Mono.just(testMenu));
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
-        
+
         Mono<SysMenu> result = menuService.updateMenu(command);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getMenuName().equals("系统管理（更新）") &&
-                    menu.getUpdatedAt() != null)
+                .expectNextMatches(menu -> menu.getMenuName().equals("系统管理（更新）") &&
+                        menu.getUpdatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).findById(1L);
         verify(menuRepository).save(any(SysMenu.class));
     }
@@ -171,17 +163,16 @@ class SysMenuServiceTest {
     @Test
     void testUpdateMenuWithCommand_NotFound() {
         UpdateMenuCommand command = new UpdateMenuCommand(
-            999L, 0L, "不存在的菜单", "M", 1, "system", "system:manage", 1
-        );
-        
+                999L, 0L, "不存在的菜单", "M", 1, "system", "system:manage", 1);
+
         when(menuRepository.findById(999L)).thenReturn(Mono.empty());
-        
+
         Mono<SysMenu> result = menuService.updateMenu(command);
-        
+
         StepVerifier.create(result)
                 .expectErrorMatches(ex -> ex.getMessage().contains("Menu not found"))
                 .verify();
-        
+
         verify(menuRepository).findById(999L);
     }
 
@@ -212,8 +203,7 @@ class SysMenuServiceTest {
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
 
         UpdateMenuCommand command = new UpdateMenuCommand(
-            1L, null, null, null, null, null, null, null
-        );
+                1L, null, null, null, null, null, null, null);
 
         StepVerifier.create(menuService.updateMenu(command))
                 .expectNextMatches(menu -> menu.getUpdatedAt() != null)
@@ -250,8 +240,7 @@ class SysMenuServiceTest {
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
 
         UpdateMenuCommand command = new UpdateMenuCommand(
-            1L, 2L, "系统管理（更新）", "C", 2, "system_updated", "system:manage_updated", 0
-        );
+                1L, 2L, "系统管理（更新）", "C", 2, "system_updated", "system:manage_updated", 0);
 
         StepVerifier.create(menuService.updateMenu(command))
                 .expectNextMatches(menu -> menu.getUpdatedAt() != null)
@@ -264,12 +253,12 @@ class SysMenuServiceTest {
     @Test
     void testDeleteMenu() {
         when(menuRepository.deleteById(1L)).thenReturn(Mono.empty());
-        
+
         Mono<Void> result = menuService.deleteMenu(1L);
-        
+
         StepVerifier.create(result)
                 .verifyComplete();
-        
+
         verify(menuRepository).deleteById(1L);
     }
 
@@ -279,60 +268,59 @@ class SysMenuServiceTest {
         parentMenu.setId(1L);
         parentMenu.setMenuName("系统管理");
         parentMenu.setParentId(0L);
-        
+
         SysMenu childMenu = new SysMenu();
         childMenu.setId(2L);
         childMenu.setMenuName("用户管理");
         childMenu.setParentId(1L);
-        
+
         when(menuRepository.findAll()).thenReturn(Flux.just(parentMenu, childMenu));
-        
+
         Flux<SysMenu> result = menuService.buildMenuTree(menuService.findAll());
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getId().equals(1L) && 
-                    menu.getChildren() != null &&
-                    menu.getChildren().size() == 1)
+                .expectNextMatches(menu -> menu.getId().equals(1L) &&
+                        menu.getChildren() != null &&
+                        menu.getChildren().size() == 1)
                 .verifyComplete();
     }
 
     @Test
     void testFindById_WhenMenuNotFound() {
         when(menuRepository.findById(999L)).thenReturn(Mono.empty());
-        
+
         Mono<SysMenu> result = menuService.findById(999L);
-        
+
         StepVerifier.create(result)
                 .expectNextCount(0)
                 .verifyComplete();
-        
+
         verify(menuRepository).findById(999L);
     }
 
     @Test
     void testFindAll_WhenNoMenusExist() {
         when(menuRepository.findAll()).thenReturn(Flux.empty());
-        
+
         Flux<SysMenu> result = menuService.findAll();
-        
+
         StepVerifier.create(result)
                 .expectNextCount(0)
                 .verifyComplete();
-        
+
         verify(menuRepository).findAll();
     }
 
     @Test
     void testFindByParentId_WhenNoChildrenExist() {
         when(menuRepository.findByParentId(999L)).thenReturn(Flux.empty());
-        
+
         Flux<SysMenu> result = menuService.findByParentId(999L);
-        
+
         StepVerifier.create(result)
                 .expectNextCount(0)
                 .verifyComplete();
-        
+
         verify(menuRepository).findByParentId(999L);
     }
 
@@ -359,24 +347,22 @@ class SysMenuServiceTest {
         savedMenu.setCreatedAt(LocalDateTime.now());
 
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(savedMenu));
-        
+
         Mono<SysMenu> result = menuService.createMenu(newMenu);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getStatus().equals(1) &&
-                    menu.getCreatedAt() != null)
+                .expectNextMatches(menu -> menu.getStatus().equals(1) &&
+                        menu.getCreatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).save(any(SysMenu.class));
     }
 
     @Test
     void testCreateMenuWithCommand_WithDefaultStatus() {
         CreateMenuCommand command = new CreateMenuCommand(
-            0L, "日志管理", "M", 3, "log", "log:manage", null
-        );
-        
+                0L, "日志管理", "M", 3, "log", "log:manage", null);
+
         SysMenu createdMenu = new SysMenu();
         createdMenu.setId(3L);
         createdMenu.setMenuName("日志管理");
@@ -387,31 +373,30 @@ class SysMenuServiceTest {
         createdMenu.setComponent("log");
         createdMenu.setStatus(1);
         createdMenu.setCreatedAt(LocalDateTime.now());
-        
+
         when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(createdMenu));
-        
+
         Mono<SysMenu> result = menuService.createMenu(command);
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getMenuName().equals("日志管理") &&
-                    menu.getStatus().equals(1) &&
-                    menu.getCreatedAt() != null)
+                .expectNextMatches(menu -> menu.getMenuName().equals("日志管理") &&
+                        menu.getStatus().equals(1) &&
+                        menu.getCreatedAt() != null)
                 .verifyComplete();
-        
+
         verify(menuRepository).save(any(SysMenu.class));
     }
 
     @Test
     void testBuildMenuTree_WithEmptyTree() {
         when(menuRepository.findAll()).thenReturn(Flux.empty());
-        
+
         Flux<SysMenu> result = menuService.buildMenuTree(menuService.findAll());
-        
+
         StepVerifier.create(result)
                 .expectNextCount(0)
                 .verifyComplete();
-        
+
         verify(menuRepository).findAll();
     }
 
@@ -421,30 +406,29 @@ class SysMenuServiceTest {
         rootMenu.setId(1L);
         rootMenu.setMenuName("系统管理");
         rootMenu.setParentId(0L);
-        
+
         SysMenu level1Menu = new SysMenu();
         level1Menu.setId(2L);
         level1Menu.setMenuName("用户管理");
         level1Menu.setParentId(1L);
-        
+
         SysMenu level2Menu = new SysMenu();
         level2Menu.setId(3L);
         level2Menu.setMenuName("用户列表");
         level2Menu.setParentId(2L);
-        
+
         when(menuRepository.findAll()).thenReturn(Flux.just(rootMenu, level1Menu, level2Menu));
-        
+
         Flux<SysMenu> result = menuService.buildMenuTree(menuService.findAll());
-        
+
         StepVerifier.create(result)
-                .expectNextMatches(menu -> 
-                    menu.getId().equals(1L) && 
-                    menu.getChildren() != null &&
-                    menu.getChildren().size() == 1 &&
-                    menu.getChildren().get(0).getChildren() != null &&
-                    menu.getChildren().get(0).getChildren().size() == 1)
+                .expectNextMatches(menu -> menu.getId().equals(1L) &&
+                        menu.getChildren() != null &&
+                        menu.getChildren().size() == 1 &&
+                        menu.getChildren().get(0).getChildren() != null &&
+                        menu.getChildren().get(0).getChildren().size() == 1)
                 .verifyComplete();
-        
+
         verify(menuRepository).findAll();
     }
 
@@ -454,30 +438,30 @@ class SysMenuServiceTest {
         root1.setId(1L);
         root1.setMenuName("系统管理");
         root1.setParentId(0L);
-        
+
         SysMenu root2 = new SysMenu();
         root2.setId(2L);
         root2.setMenuName("监控管理");
         root2.setParentId(0L);
-        
+
         SysMenu child1 = new SysMenu();
         child1.setId(3L);
         child1.setMenuName("用户管理");
         child1.setParentId(1L);
-        
+
         SysMenu child2 = new SysMenu();
         child2.setId(4L);
         child2.setMenuName("性能监控");
         child2.setParentId(2L);
-        
+
         when(menuRepository.findAll()).thenReturn(Flux.just(root1, root2, child1, child2));
-        
+
         Flux<SysMenu> result = menuService.buildMenuTree(menuService.findAll());
-        
+
         StepVerifier.create(result)
                 .expectNextCount(2)
                 .verifyComplete();
-        
+
         verify(menuRepository).findAll();
     }
 }

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysRoleServiceTest.java

@@ -12,7 +12,6 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.data.relational.core.query.Query;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/dto/response/AuthResponseTest.java

@@ -0,0 +1,184 @@
+package cn.novalon.manage.sys.dto.response;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AuthResponseTest {
+
+    @Test
+    void testConstructorWithParameters() {
+        AuthResponse response = new AuthResponse("test-token", 1L, "testuser");
+
+        assertEquals("test-token", response.getToken());
+        assertEquals(1L, response.getUserId());
+        assertEquals("testuser", response.getUsername());
+    }
+
+    @Test
+    void testDefaultConstructor() {
+        AuthResponse response = new AuthResponse();
+
+        assertNull(response.getToken());
+        assertNull(response.getUserId());
+        assertNull(response.getUsername());
+    }
+
+    @Test
+    void testGettersAndSetters() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken("new-token");
+        response.setUserId(2L);
+        response.setUsername("newuser");
+
+        assertEquals("new-token", response.getToken());
+        assertEquals(2L, response.getUserId());
+        assertEquals("newuser", response.getUsername());
+    }
+
+    @Test
+    void testSettersWithNullValues() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken(null);
+        response.setUserId(null);
+        response.setUsername(null);
+
+        assertNull(response.getToken());
+        assertNull(response.getUserId());
+        assertNull(response.getUsername());
+    }
+
+    @Test
+    void testSettersWithEmptyStrings() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken("");
+        response.setUsername("");
+
+        assertEquals("", response.getToken());
+        assertEquals("", response.getUsername());
+    }
+
+    @Test
+    void testConstructorWithNullValues() {
+        AuthResponse response = new AuthResponse(null, null, null);
+
+        assertNull(response.getToken());
+        assertNull(response.getUserId());
+        assertNull(response.getUsername());
+    }
+
+    @Test
+    void testConstructorWithEmptyStrings() {
+        AuthResponse response = new AuthResponse("", 1L, "");
+
+        assertEquals("", response.getToken());
+        assertEquals(1L, response.getUserId());
+        assertEquals("", response.getUsername());
+    }
+
+    @Test
+    void testSettersWithBoundaryValues() {
+        AuthResponse response = new AuthResponse();
+
+        response.setUserId(Long.MAX_VALUE);
+        response.setUserId(Long.MIN_VALUE);
+        response.setUserId(0L);
+
+        assertEquals(0L, response.getUserId());
+    }
+
+    @Test
+    void testSettersWithNegativeValues() {
+        AuthResponse response = new AuthResponse();
+
+        response.setUserId(-1L);
+
+        assertEquals(-1L, response.getUserId());
+    }
+
+    @Test
+    void testSettersWithSpecialCharacters() {
+        AuthResponse response = new AuthResponse();
+
+        String specialToken = "token@#$%^&*()";
+        String specialUsername = "user@#$%^&*()";
+
+        response.setToken(specialToken);
+        response.setUsername(specialUsername);
+
+        assertEquals(specialToken, response.getToken());
+        assertEquals(specialUsername, response.getUsername());
+    }
+
+    @Test
+    void testSettersWithLongStrings() {
+        AuthResponse response = new AuthResponse();
+
+        String longToken = "a".repeat(1000);
+        String longUsername = "b".repeat(500);
+
+        response.setToken(longToken);
+        response.setUsername(longUsername);
+
+        assertEquals(longToken, response.getToken());
+        assertEquals(longUsername, response.getUsername());
+    }
+
+    @Test
+    void testSettersWithUnicodeCharacters() {
+        AuthResponse response = new AuthResponse();
+
+        String unicodeToken = "token_测试_🔑";
+        String unicodeUsername = "user_测试_👤";
+
+        response.setToken(unicodeToken);
+        response.setUsername(unicodeUsername);
+
+        assertEquals(unicodeToken, response.getToken());
+        assertEquals(unicodeUsername, response.getUsername());
+    }
+
+    @Test
+    void testSettersWithWhitespace() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken("  token  ");
+        response.setUsername("  user  ");
+
+        assertEquals("  token  ", response.getToken());
+        assertEquals("  user  ", response.getUsername());
+    }
+
+    @Test
+    void testMultipleSetOperations() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken("token1");
+        response.setToken("token2");
+
+        assertEquals("token2", response.getToken());
+    }
+
+    @Test
+    void testConstructorWithZeroUserId() {
+        AuthResponse response = new AuthResponse("token", 0L, "user");
+
+        assertEquals("token", response.getToken());
+        assertEquals(0L, response.getUserId());
+        assertEquals("user", response.getUsername());
+    }
+
+    @Test
+    void testSettersWithNumericStrings() {
+        AuthResponse response = new AuthResponse();
+
+        response.setToken("12345");
+        response.setUsername("67890");
+
+        assertEquals("12345", response.getToken());
+        assertEquals("67890", response.getUsername());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/dto/response/FilePreviewResponseTest.java

@@ -0,0 +1,144 @@
+package cn.novalon.manage.sys.dto.response;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FilePreviewResponseTest {
+
+    @Test
+    void testGettersAndSetters() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName("test.pdf");
+        response.setFileType("application/pdf");
+        response.setFileSize(1024L);
+        response.setPreviewType("image");
+        response.setPreviewData("base64data");
+
+        assertEquals("test.pdf", response.getFileName());
+        assertEquals("application/pdf", response.getFileType());
+        assertEquals(1024L, response.getFileSize());
+        assertEquals("image", response.getPreviewType());
+        assertEquals("base64data", response.getPreviewData());
+    }
+
+    @Test
+    void testSettersWithNullValues() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName(null);
+        response.setFileType(null);
+        response.setFileSize(null);
+        response.setPreviewType(null);
+        response.setPreviewData(null);
+
+        assertNull(response.getFileName());
+        assertNull(response.getFileType());
+        assertNull(response.getFileSize());
+        assertNull(response.getPreviewType());
+        assertNull(response.getPreviewData());
+    }
+
+    @Test
+    void testSettersWithEmptyStrings() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName("");
+        response.setFileType("");
+        response.setPreviewType("");
+        response.setPreviewData("");
+
+        assertEquals("", response.getFileName());
+        assertEquals("", response.getFileType());
+        assertEquals("", response.getPreviewType());
+        assertEquals("", response.getPreviewData());
+    }
+
+    @Test
+    void testSettersWithBoundaryValues() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileSize(Long.MAX_VALUE);
+        response.setFileSize(Long.MIN_VALUE);
+        response.setFileSize(0L);
+
+        assertEquals(0L, response.getFileSize());
+    }
+
+    @Test
+    void testSettersWithSpecialCharacters() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        String specialFileName = "文件名@#$%^&*().pdf";
+        String specialFileType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        
+        response.setFileName(specialFileName);
+        response.setFileType(specialFileType);
+
+        assertEquals(specialFileName, response.getFileName());
+        assertEquals(specialFileType, response.getFileType());
+    }
+
+    @Test
+    void testSettersWithLongStrings() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        String longFileName = "a".repeat(1000) + ".pdf";
+        String longPreviewData = "x".repeat(10000);
+        
+        response.setFileName(longFileName);
+        response.setPreviewData(longPreviewData);
+
+        assertEquals(longFileName, response.getFileName());
+        assertEquals(longPreviewData, response.getPreviewData());
+    }
+
+    @Test
+    void testSettersWithUnicodeCharacters() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        String unicodeFileName = "文件名_测试_📄.pdf";
+        String unicodePreviewData = "数据_测试_🔍";
+        
+        response.setFileName(unicodeFileName);
+        response.setPreviewData(unicodePreviewData);
+
+        assertEquals(unicodeFileName, response.getFileName());
+        assertEquals(unicodePreviewData, response.getPreviewData());
+    }
+
+    @Test
+    void testSettersWithWhitespace() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName("  test.pdf  ");
+        response.setFileType("  application/pdf  ");
+        response.setPreviewType("  image  ");
+
+        assertEquals("  test.pdf  ", response.getFileName());
+        assertEquals("  application/pdf  ", response.getFileType());
+        assertEquals("  image  ", response.getPreviewType());
+    }
+
+    @Test
+    void testMultipleSetOperations() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName("file1.pdf");
+        response.setFileName("file2.pdf");
+        
+        assertEquals("file2.pdf", response.getFileName());
+    }
+
+    @Test
+    void testSettersWithNumericStrings() {
+        FilePreviewResponse response = new FilePreviewResponse();
+        
+        response.setFileName("12345.pdf");
+        response.setFileType("12345");
+        
+        assertEquals("12345.pdf", response.getFileName());
+        assertEquals("12345", response.getFileType());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/dto/response/UserResponseTest.java

@@ -0,0 +1,146 @@
+package cn.novalon.manage.sys.dto.response;
+
+import cn.novalon.manage.sys.core.domain.SysUser;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserResponseTest {
+
+    @Test
+    void testGettersAndSetters() {
+        UserResponse response = new UserResponse();
+        
+        response.setId(1L);
+        response.setUsername("testuser");
+        response.setEmail("test@example.com");
+        response.setRoleId(2L);
+        response.setStatus(1);
+        response.setCreatedAt(LocalDateTime.now());
+        response.setUpdatedAt(LocalDateTime.now());
+
+        assertEquals(1L, response.getId());
+        assertEquals("testuser", response.getUsername());
+        assertEquals("test@example.com", response.getEmail());
+        assertEquals(2L, response.getRoleId());
+        assertEquals(1, response.getStatus());
+        assertNotNull(response.getCreatedAt());
+        assertNotNull(response.getUpdatedAt());
+    }
+
+    @Test
+    void testFromDomain() {
+        SysUser user = new SysUser();
+        user.setId(1L);
+        user.setUsername("testuser");
+        user.setEmail("test@example.com");
+        user.setRoleId(2L);
+        user.setStatus(1);
+        user.setCreatedAt(LocalDateTime.now());
+        user.setUpdatedAt(LocalDateTime.now());
+
+        UserResponse response = UserResponse.fromDomain(user);
+
+        assertEquals(user.getId(), response.getId());
+        assertEquals(user.getUsername(), response.getUsername());
+        assertEquals(user.getEmail(), response.getEmail());
+        assertEquals(user.getRoleId(), response.getRoleId());
+        assertEquals(user.getStatus(), response.getStatus());
+        assertEquals(user.getCreatedAt(), response.getCreatedAt());
+        assertEquals(user.getUpdatedAt(), response.getUpdatedAt());
+    }
+
+    @Test
+    void testFromDomain_WithNullUser() {
+        assertThrows(NullPointerException.class, () -> UserResponse.fromDomain(null));
+    }
+
+    @Test
+    void testFromDomain_WithNullFields() {
+        SysUser user = new SysUser();
+        
+        UserResponse response = UserResponse.fromDomain(user);
+
+        assertNull(response.getId());
+        assertNull(response.getUsername());
+        assertNull(response.getEmail());
+        assertNull(response.getRoleId());
+        assertNull(response.getStatus());
+        assertNull(response.getCreatedAt());
+        assertNull(response.getUpdatedAt());
+    }
+
+    @Test
+    void testFromDomain_WithEmptyStrings() {
+        SysUser user = new SysUser();
+        user.setUsername("");
+        user.setEmail("");
+        
+        UserResponse response = UserResponse.fromDomain(user);
+
+        assertEquals("", response.getUsername());
+        assertEquals("", response.getEmail());
+    }
+
+    @Test
+    void testSettersWithNullValues() {
+        UserResponse response = new UserResponse();
+        
+        response.setId(null);
+        response.setUsername(null);
+        response.setEmail(null);
+        response.setRoleId(null);
+        response.setStatus(null);
+        response.setCreatedAt(null);
+        response.setUpdatedAt(null);
+
+        assertNull(response.getId());
+        assertNull(response.getUsername());
+        assertNull(response.getEmail());
+        assertNull(response.getRoleId());
+        assertNull(response.getStatus());
+        assertNull(response.getCreatedAt());
+        assertNull(response.getUpdatedAt());
+    }
+
+    @Test
+    void testSettersWithBoundaryValues() {
+        UserResponse response = new UserResponse();
+        
+        response.setId(Long.MAX_VALUE);
+        response.setRoleId(Long.MIN_VALUE);
+        response.setStatus(Integer.MAX_VALUE);
+        
+        assertEquals(Long.MAX_VALUE, response.getId());
+        assertEquals(Long.MIN_VALUE, response.getRoleId());
+        assertEquals(Integer.MAX_VALUE, response.getStatus());
+    }
+
+    @Test
+    void testSettersWithZeroValues() {
+        UserResponse response = new UserResponse();
+        
+        response.setId(0L);
+        response.setRoleId(0L);
+        response.setStatus(0);
+        
+        assertEquals(0L, response.getId());
+        assertEquals(0L, response.getRoleId());
+        assertEquals(0, response.getStatus());
+    }
+
+    @Test
+    void testSettersWithNegativeValues() {
+        UserResponse response = new UserResponse();
+        
+        response.setId(-1L);
+        response.setRoleId(-1L);
+        response.setStatus(-1);
+        
+        assertEquals(-1L, response.getId());
+        assertEquals(-1L, response.getRoleId());
+        assertEquals(-1, response.getStatus());
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/auth/SysAuthHandlerTest.java

@@ -2,7 +2,6 @@ package cn.novalon.manage.sys.handler.auth;
 
 import cn.novalon.manage.sys.dto.request.LoginRequest;
 import cn.novalon.manage.sys.dto.request.UserRegisterRequest;
-import cn.novalon.manage.sys.dto.response.AuthResponse;
 import cn.novalon.manage.sys.security.JwtTokenProvider;
 import cn.novalon.manage.sys.core.domain.SysUser;
 import cn.novalon.manage.sys.core.service.ISysUserService;
@@ -14,16 +13,12 @@ import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.http.HttpStatus;
 import org.springframework.mock.web.reactive.function.server.MockServerRequest;
 import org.springframework.security.crypto.password.PasswordEncoder;
-import org.springframework.web.bind.support.WebExchangeBindException;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
-import java.time.LocalDateTime;
-
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/config/SysConfigHandlerTest.java

@@ -18,7 +18,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/dict/SysDictHandlerTest.java

@@ -20,8 +20,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/log/OperationLogHandlerTest.java

@@ -0,0 +1,180 @@
+package cn.novalon.manage.sys.handler.log;
+
+import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.query.OperationLogQuery;
+import cn.novalon.manage.sys.core.service.IOperationLogService;
+import cn.novalon.manage.common.dto.PageRequest;
+import cn.novalon.manage.common.dto.PageResponse;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+import org.springframework.mock.web.reactive.function.server.MockServerRequest;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.LocalDateTime;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class OperationLogHandlerTest {
+
+    @Mock
+    private IOperationLogService logService;
+
+    private OperationLogHandler logHandler;
+    private OperationLog testOperationLog;
+
+    @BeforeEach
+    void setUp() {
+        logHandler = new OperationLogHandler(logService);
+
+        testOperationLog = new OperationLog();
+        testOperationLog.setId(1L);
+        testOperationLog.setUsername("testuser");
+        testOperationLog.setOperation("测试操作");
+        testOperationLog.setMethod("testMethod");
+        testOperationLog.setParams("test params");
+        testOperationLog.setDuration(100L);
+        testOperationLog.setIp("192.168.1.1");
+        testOperationLog.setCreatedAt(LocalDateTime.now());
+    }
+
+    @Test
+    void testGetAllOperationLogs() {
+        when(logService.findAll()).thenReturn(Flux.just(testOperationLog));
+
+        ServerRequest request = MockServerRequest.builder().build();
+        Mono<ServerResponse> response = logHandler.getAllOperationLogs(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+
+        verify(logService).findAll();
+    }
+
+    @Test
+    void testGetOperationLogById() {
+        when(logService.findById(1L)).thenReturn(Mono.just(testOperationLog));
+
+        ServerRequest request = MockServerRequest.builder()
+                .pathVariable("id", "1")
+                .build();
+        Mono<ServerResponse> response = logHandler.getOperationLogById(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+
+        verify(logService).findById(1L);
+    }
+
+    @Test
+    void testGetOperationLogById_NotFound() {
+        when(logService.findById(999L)).thenReturn(Mono.empty());
+
+        ServerRequest request = MockServerRequest.builder()
+                .pathVariable("id", "999")
+                .build();
+        Mono<ServerResponse> response = logHandler.getOperationLogById(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.NOT_FOUND)
+                .verifyComplete();
+
+        verify(logService).findById(999L);
+    }
+
+    @Test
+    void testGetOperationLogsByPage() {
+        PageResponse<OperationLog> pageResponse = new PageResponse<>();
+        pageResponse.setContent(java.util.Collections.singletonList(testOperationLog));
+        pageResponse.setTotalElements(1L);
+        pageResponse.setTotalPages(1);
+        pageResponse.setPageSize(10);
+        pageResponse.setCurrentPage(0);
+
+        when(logService.findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class)))
+                .thenReturn(Mono.just(pageResponse));
+
+        ServerRequest request = MockServerRequest.builder()
+                .queryParam("page", "0")
+                .queryParam("size", "10")
+                .queryParam("sort", "createdAt")
+                .queryParam("order", "desc")
+                .build();
+        Mono<ServerResponse> response = logHandler.getOperationLogsByPage(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+
+        verify(logService).findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class));
+    }
+
+    @Test
+    void testGetOperationLogsByPageWithKeyword() {
+        PageResponse<OperationLog> pageResponse = new PageResponse<>();
+        pageResponse.setContent(java.util.Collections.singletonList(testOperationLog));
+        pageResponse.setTotalElements(1L);
+        pageResponse.setTotalPages(1);
+        pageResponse.setPageSize(10);
+        pageResponse.setCurrentPage(0);
+
+        when(logService.findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class)))
+                .thenReturn(Mono.just(pageResponse));
+
+        ServerRequest request = MockServerRequest.builder()
+                .queryParam("page", "0")
+                .queryParam("size", "10")
+                .queryParam("sort", "createdAt")
+                .queryParam("order", "desc")
+                .queryParam("keyword", "test")
+                .build();
+        Mono<ServerResponse> response = logHandler.getOperationLogsByPage(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+
+        verify(logService).findByQueryWithPagination(any(OperationLogQuery.class), any(PageRequest.class));
+    }
+
+    @Test
+    void testGetOperationLogCount() {
+        when(logService.count()).thenReturn(Mono.just(100L));
+
+        ServerRequest request = MockServerRequest.builder().build();
+        Mono<ServerResponse> response = logHandler.getOperationLogCount(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+
+        verify(logService).count();
+    }
+
+    @Test
+    void testCreateOperationLog() {
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(testOperationLog));
+
+        ServerRequest request = MockServerRequest.builder()
+                .body(Mono.just(testOperationLog));
+        Mono<ServerResponse> response = logHandler.createOperationLog(request);
+
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> serverResponse.statusCode() == HttpStatus.CREATED)
+                .verifyComplete();
+
+        verify(logService).save(any(OperationLog.class));
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/log/SysLogHandlerTest.java

@@ -4,7 +4,6 @@ import cn.novalon.manage.sys.core.domain.SysLoginLog;
 import cn.novalon.manage.sys.core.domain.SysExceptionLog;
 import cn.novalon.manage.sys.core.service.ISysLoginLogService;
 import cn.novalon.manage.sys.core.service.ISysExceptionLogService;
-import cn.novalon.manage.common.dto.PageRequest;
 import cn.novalon.manage.common.dto.PageResponse;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -22,7 +21,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/menu/MenuHandlerTest.java

@@ -22,7 +22,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -153,7 +152,17 @@ class MenuHandlerTest {
 
     @Test
     void testGetMenusByType() {
-        when(menuService.findAll()).thenReturn(Flux.just(testMenu));
+        SysMenu menu1 = new SysMenu();
+        menu1.setId(1L);
+        menu1.setMenuName("系统管理");
+        menu1.setMenuType("M");
+        
+        SysMenu menu2 = new SysMenu();
+        menu2.setId(2L);
+        menu2.setMenuName("用户管理");
+        menu2.setMenuType("C");
+        
+        when(menuService.findAll()).thenReturn(Flux.just(menu1, menu2));
         
         ServerRequest request = MockServerRequest.builder()
                 .queryParam("menuType", "M")
@@ -170,7 +179,17 @@ class MenuHandlerTest {
 
     @Test
     void testGetMenusByType_Null() {
-        when(menuService.findAll()).thenReturn(Flux.just(testMenu));
+        SysMenu menu1 = new SysMenu();
+        menu1.setId(1L);
+        menu1.setMenuName("系统管理");
+        menu1.setMenuType("M");
+        
+        SysMenu menu2 = new SysMenu();
+        menu2.setId(2L);
+        menu2.setMenuName("用户管理");
+        menu2.setMenuType("C");
+        
+        when(menuService.findAll()).thenReturn(Flux.just(menu1, menu2));
         
         ServerRequest request = MockServerRequest.builder()
                 .build();
@@ -184,6 +203,33 @@ class MenuHandlerTest {
         verify(menuService).findAll();
     }
 
+    @Test
+    void testGetMenusByType_NoMatch() {
+        SysMenu menu1 = new SysMenu();
+        menu1.setId(1L);
+        menu1.setMenuName("系统管理");
+        menu1.setMenuType("M");
+        
+        SysMenu menu2 = new SysMenu();
+        menu2.setId(2L);
+        menu2.setMenuName("用户管理");
+        menu2.setMenuType("C");
+        
+        when(menuService.findAll()).thenReturn(Flux.just(menu1, menu2));
+        
+        ServerRequest request = MockServerRequest.builder()
+                .queryParam("menuType", "F")
+                .build();
+        Mono<ServerResponse> response = menuHandler.getMenusByType(request);
+        
+        StepVerifier.create(response)
+                .expectNextMatches(serverResponse -> 
+                    serverResponse.statusCode() == HttpStatus.OK)
+                .verifyComplete();
+        
+        verify(menuService).findAll();
+    }
+
     @Test
     void testCreateMenu() {
         MenuCreateRequest createRequest = new MenuCreateRequest();

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/handler/role/SysRoleHandlerTest.java

@@ -22,7 +22,6 @@ import reactor.test.StepVerifier;
 import java.time.LocalDateTime;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/interceptor/OperationLogFilterTest.java

@@ -0,0 +1,210 @@
+package cn.novalon.manage.sys.interceptor;
+
+import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.service.IOperationLogService;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpMethod;
+import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
+import org.springframework.mock.web.server.MockServerWebExchange;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.web.server.WebFilterChain;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.net.InetSocketAddress;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class OperationLogFilterTest {
+
+    @Mock
+    private IOperationLogService logService;
+
+    @Mock
+    private WebFilterChain chain;
+
+    @Mock
+    private ObjectMapper objectMapper;
+
+    private OperationLogFilter filter;
+
+    @BeforeEach
+    void setUp() {
+        filter = new OperationLogFilter(logService, objectMapper);
+    }
+
+    @Test
+    void testFilter_SkipAuthEndpoints() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/auth/login").build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(chain).filter(exchange);
+        verify(logService, never()).save(any(OperationLog.class));
+    }
+
+    @Test
+    void testFilter_RecordSuccessLog() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(chain).filter(exchange);
+        verify(logService).save(any(OperationLog.class));
+    }
+
+    @Test
+    void testFilter_RecordErrorLog() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        RuntimeException error = new RuntimeException("Test error");
+        when(chain.filter(exchange)).thenReturn(Mono.error(error));
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .expectError(RuntimeException.class)
+                .verify();
+
+        verify(chain).filter(exchange);
+        verify(logService).save(any(OperationLog.class));
+    }
+
+    @Test
+    void testFilter_WithXForwardedForHeader() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .header("X-Forwarded-For", "192.168.1.1")
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(logService).save(argThat(log -> "192.168.1.1".equals(log.getIp())));
+    }
+
+    @Test
+    void testFilter_WithXRealIPHeader() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .header("X-Real-IP", "10.0.0.1")
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(logService).save(argThat(log -> "10.0.0.1".equals(log.getIp())));
+    }
+
+    @Test
+    void testFilter_WithMultipleIPsInXForwardedFor() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .header("X-Forwarded-For", "192.168.1.1, 10.0.0.1")
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(logService).save(argThat(log -> "192.168.1.1".equals(log.getIp())));
+    }
+
+    @Test
+    void testFilter_WithUnknownHeader() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .header("X-Forwarded-For", "unknown")
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(logService).save(any(OperationLog.class));
+    }
+
+    @Test
+    void testFilter_DifferentHttpMethods() {
+        HttpMethod[] methods = {HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE, HttpMethod.PATCH};
+        
+        for (HttpMethod method : methods) {
+            MockServerHttpRequest request = MockServerHttpRequest.method(method, "/api/users")
+                    .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
+                    .build();
+            ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+            when(chain.filter(exchange)).thenReturn(Mono.empty());
+            when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+            StepVerifier.create(filter.filter(exchange, chain))
+                    .verifyComplete();
+
+            verify(logService).save(argThat(log -> method.name().equals(log.getMethod())));
+            reset(logService, chain);
+        }
+    }
+
+    @Test
+    void testFilter_WithQueryParams() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users?page=1&size=10")
+                .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.just(new OperationLog()));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(logService).save(argThat(log -> log.getParams() != null && !log.getParams().isEmpty()));
+    }
+
+    @Test
+    void testFilter_LogSaveError() {
+        MockServerHttpRequest request = MockServerHttpRequest.get("/api/users")
+                .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
+                .build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        when(logService.save(any(OperationLog.class))).thenReturn(Mono.error(new RuntimeException("Save failed")));
+
+        StepVerifier.create(filter.filter(exchange, chain))
+                .verifyComplete();
+
+        verify(chain).filter(exchange);
+        verify(logService).save(any(OperationLog.class));
+    }
+}

novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/security/JwtAuthenticationFilterTest.java

@@ -6,7 +6,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.http.HttpHeaders;
-import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
 import org.springframework.mock.web.server.MockServerWebExchange;
 import org.springframework.web.server.ServerWebExchange;