diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/OperationLogServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/OperationLogServiceTest.java
new file mode 100644
index 0000000..7c845cd
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/OperationLogServiceTest.java
@@ -0,0 +1,112 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.OperationLog;
+import cn.novalon.manage.sys.core.repository.IOperationLogRepository;
+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 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.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class OperationLogServiceTest {
+
+    @Mock
+    private IOperationLogRepository logRepository;
+
+    private OperationLogService operationLogService;
+    private OperationLog testLog;
+
+    @BeforeEach
+    void setUp() {
+        operationLogService = new OperationLogService(logRepository);
+        
+        testLog = new OperationLog();
+        testLog.setId(1L);
+        testLog.setUsername("testuser");
+        testLog.setOperation("test operation");
+        testLog.setMethod("testMethod");
+        testLog.setParams("{}");
+        testLog.setDuration(100L);
+        testLog.setIp("192.168.1.1");
+        testLog.setStatus("1");
+    }
+
+    @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)
+                .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));
+    }
+}
\ No newline at end of file
diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictDataServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictDataServiceTest.java
new file mode 100644
index 0000000..467ed6e
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictDataServiceTest.java
@@ -0,0 +1,122 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.SysDictData;
+import cn.novalon.manage.sys.core.repository.ISysDictDataRepository;
+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 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.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class SysDictDataServiceTest {
+
+    @Mock
+    private ISysDictDataRepository repository;
+
+    private SysDictDataService dictDataService;
+    private SysDictData testDictData;
+
+    @BeforeEach
+    void setUp() {
+        dictDataService = new SysDictDataService(repository);
+        
+        testDictData = new SysDictData();
+        testDictData.setId(1L);
+        testDictData.setDictTypeId(1L);
+        testDictData.setDictLabel("正常");
+        testDictData.setDictValue("1");
+        testDictData.setDictSort(1);
+        testDictData.setDictType("sys_status");
+        testDictData.setStatus("0");
+        testDictData.setCreatedAt(LocalDateTime.now());
+    }
+
+    @Test
+    void testFindAll() {
+        when(repository.findByDeletedAtIsNull()).thenReturn(Flux.just(testDictData));
+        
+        Flux<SysDictData> result = dictDataService.findAll();
+        
+        StepVerifier.create(result)
+                .expectNext(testDictData)
+                .verifyComplete();
+        
+        verify(repository).findByDeletedAtIsNull();
+    }
+
+    @Test
+    void testFindByDictType() {
+        when(repository.findByDictTypeAndDeletedAtIsNull("sys_status")).thenReturn(Flux.just(testDictData));
+        
+        Flux<SysDictData> result = dictDataService.findByDictType("sys_status");
+        
+        StepVerifier.create(result)
+                .expectNext(testDictData)
+                .verifyComplete();
+        
+        verify(repository).findByDictTypeAndDeletedAtIsNull("sys_status");
+    }
+
+    @Test
+    void testFindByDictTypeAndStatus() {
+        when(repository.findByDictTypeAndStatusAndDeletedAtIsNull("sys_status", "0")).thenReturn(Flux.just(testDictData));
+        
+        Flux<SysDictData> result = dictDataService.findByDictTypeAndStatus("sys_status", "0");
+        
+        StepVerifier.create(result)
+                .expectNext(testDictData)
+                .verifyComplete();
+        
+        verify(repository).findByDictTypeAndStatusAndDeletedAtIsNull("sys_status", "0");
+    }
+
+    @Test
+    void testFindById() {
+        when(repository.findById(1L)).thenReturn(Mono.just(testDictData));
+        
+        Mono<SysDictData> result = dictDataService.findById(1L);
+        
+        StepVerifier.create(result)
+                .expectNext(testDictData)
+                .verifyComplete();
+        
+        verify(repository).findById(1L);
+    }
+
+    @Test
+    void testSave() {
+        when(repository.save(any(SysDictData.class))).thenReturn(Mono.just(testDictData));
+        
+        Mono<SysDictData> result = dictDataService.save(testDictData);
+        
+        StepVerifier.create(result)
+                .expectNext(testDictData)
+                .verifyComplete();
+        
+        verify(repository).save(any(SysDictData.class));
+    }
+
+    @Test
+    void testDeleteById() {
+        when(repository.deleteByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+        
+        Mono<Void> result = dictDataService.deleteById(1L);
+        
+        StepVerifier.create(result)
+                .verifyComplete();
+        
+        verify(repository).deleteByIdAndDeletedAtIsNull(1L);
+    }
+}
\ No newline at end of file
diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictTypeServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictTypeServiceTest.java
new file mode 100644
index 0000000..00d2cad
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysDictTypeServiceTest.java
@@ -0,0 +1,107 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.SysDictType;
+import cn.novalon.manage.sys.core.repository.ISysDictTypeRepository;
+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 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.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class SysDictTypeServiceTest {
+
+    @Mock
+    private ISysDictTypeRepository repository;
+
+    private SysDictTypeService dictTypeService;
+    private SysDictType testDictType;
+
+    @BeforeEach
+    void setUp() {
+        dictTypeService = new SysDictTypeService(repository);
+        
+        testDictType = new SysDictType();
+        testDictType.setId(1L);
+        testDictType.setDictName("系统状态");
+        testDictType.setDictType("sys_status");
+        testDictType.setStatus("0");
+        testDictType.setRemark("系统状态字典");
+        testDictType.setCreatedAt(LocalDateTime.now());
+    }
+
+    @Test
+    void testFindAll() {
+        when(repository.findByDeletedAtIsNull()).thenReturn(Flux.just(testDictType));
+        
+        Flux<SysDictType> result = dictTypeService.findAll();
+        
+        StepVerifier.create(result)
+                .expectNext(testDictType)
+                .verifyComplete();
+        
+        verify(repository).findByDeletedAtIsNull();
+    }
+
+    @Test
+    void testFindById() {
+        when(repository.findById(1L)).thenReturn(Mono.just(testDictType));
+        
+        Mono<SysDictType> result = dictTypeService.findById(1L);
+        
+        StepVerifier.create(result)
+                .expectNext(testDictType)
+                .verifyComplete();
+        
+        verify(repository).findById(1L);
+    }
+
+    @Test
+    void testFindByDictType() {
+        when(repository.findByDictTypeAndDeletedAtIsNull("sys_status")).thenReturn(Mono.just(testDictType));
+        
+        Mono<SysDictType> result = dictTypeService.findByDictType("sys_status");
+        
+        StepVerifier.create(result)
+                .expectNext(testDictType)
+                .verifyComplete();
+        
+        verify(repository).findByDictTypeAndDeletedAtIsNull("sys_status");
+    }
+
+    @Test
+    void testSave() {
+        when(repository.save(any(SysDictType.class))).thenReturn(Mono.just(testDictType));
+        
+        Mono<SysDictType> result = dictTypeService.save(testDictType);
+        
+        StepVerifier.create(result)
+                .expectNext(testDictType)
+                .verifyComplete();
+        
+        verify(repository).save(any(SysDictType.class));
+    }
+
+    @Test
+    void testDeleteById() {
+        when(repository.deleteByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+        
+        Mono<Void> result = dictTypeService.deleteById(1L);
+        
+        StepVerifier.create(result)
+                .verifyComplete();
+        
+        verify(repository).deleteByIdAndDeletedAtIsNull(1L);
+    }
+}
\ No newline at end of file
diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysExceptionLogServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysExceptionLogServiceTest.java
new file mode 100644
index 0000000..179e3ec
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysExceptionLogServiceTest.java
@@ -0,0 +1,194 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.SysExceptionLog;
+import cn.novalon.manage.sys.core.repository.ISysExceptionLogRepository;
+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 reactor.core.publisher.Flux;
+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;
+
+@ExtendWith(MockitoExtension.class)
+class SysExceptionLogServiceTest {
+
+    @Mock
+    private ISysExceptionLogRepository repository;
+
+    private SysExceptionLogService exceptionLogService;
+    private SysExceptionLog testExceptionLog;
+
+    @BeforeEach
+    void setUp() {
+        exceptionLogService = new SysExceptionLogService(repository);
+        
+        testExceptionLog = new SysExceptionLog();
+        testExceptionLog.setId(1L);
+        testExceptionLog.setUsername("testuser");
+        testExceptionLog.setTitle("test operation");
+        testExceptionLog.setExceptionName("NullPointerException");
+        testExceptionLog.setExceptionMsg("Test exception");
+        testExceptionLog.setCreateTime(LocalDateTime.now());
+    }
+
+    @Test
+    void testFindAll() {
+        when(repository.findAllByOrderByCreateTimeDesc()).thenReturn(Flux.just(testExceptionLog));
+        
+        Flux<SysExceptionLog> result = exceptionLogService.findAll();
+        
+        StepVerifier.create(result)
+                .expectNext(testExceptionLog)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByCreateTimeDesc();
+    }
+
+    @Test
+    void testFindByUsername() {
+        when(repository.findByUsernameOrderByCreateTimeDesc("testuser")).thenReturn(Flux.just(testExceptionLog));
+        
+        Flux<SysExceptionLog> result = exceptionLogService.findByUsername("testuser");
+        
+        StepVerifier.create(result)
+                .expectNext(testExceptionLog)
+                .verifyComplete();
+        
+        verify(repository).findByUsernameOrderByCreateTimeDesc("testuser");
+    }
+
+    @Test
+    void testFindByCreateTimeBetween() {
+        LocalDateTime startTime = LocalDateTime.now().minusDays(1);
+        LocalDateTime endTime = LocalDateTime.now();
+        
+        when(repository.findByCreateTimeBetweenOrderByCreateTimeDesc(startTime, endTime))
+                .thenReturn(Flux.just(testExceptionLog));
+        
+        Flux<SysExceptionLog> result = exceptionLogService.findByCreateTimeBetween(startTime, endTime);
+        
+        StepVerifier.create(result)
+                .expectNext(testExceptionLog)
+                .verifyComplete();
+        
+        verify(repository).findByCreateTimeBetweenOrderByCreateTimeDesc(startTime, endTime);
+    }
+
+    @Test
+    void testSave() {
+        when(repository.save(any(SysExceptionLog.class))).thenReturn(Mono.just(testExceptionLog));
+        
+        Mono<SysExceptionLog> result = exceptionLogService.save(testExceptionLog);
+        
+        StepVerifier.create(result)
+                .expectNext(testExceptionLog)
+                .verifyComplete();
+        
+        verify(repository).save(any(SysExceptionLog.class));
+    }
+
+    @Test
+    void testFindById() {
+        when(repository.findById(1L)).thenReturn(Mono.just(testExceptionLog));
+        
+        Mono<SysExceptionLog> result = exceptionLogService.findById(1L);
+        
+        StepVerifier.create(result)
+                .expectNext(testExceptionLog)
+                .verifyComplete();
+        
+        verify(repository).findById(1L);
+    }
+
+    @Test
+    void testFindExceptionLogsByPage() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        
+        when(repository.findAllByOrderByCreateTimeDesc()).thenReturn(Flux.just(testExceptionLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysExceptionLog>> result = exceptionLogService.findExceptionLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getTotalPages() == 1 &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByCreateTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testFindExceptionLogsByPage_WithKeyword() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        pageRequest.setKeyword("test");
+        
+        when(repository.findAllByOrderByCreateTimeDesc()).thenReturn(Flux.just(testExceptionLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysExceptionLog>> result = exceptionLogService.findExceptionLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByCreateTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testFindExceptionLogsByPage_WithSort() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        pageRequest.setSort("username");
+        pageRequest.setOrder("desc");
+        
+        when(repository.findAllByOrderByCreateTimeDesc()).thenReturn(Flux.just(testExceptionLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysExceptionLog>> result = exceptionLogService.findExceptionLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByCreateTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testCount() {
+        when(repository.count()).thenReturn(Mono.just(50L));
+        
+        Mono<Long> result = exceptionLogService.count();
+        
+        StepVerifier.create(result)
+                .expectNext(50L)
+                .verifyComplete();
+        
+        verify(repository).count();
+    }
+}
\ No newline at end of file
diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysLoginLogServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysLoginLogServiceTest.java
new file mode 100644
index 0000000..21e6473
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysLoginLogServiceTest.java
@@ -0,0 +1,197 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.SysLoginLog;
+import cn.novalon.manage.sys.core.repository.ISysLoginLogRepository;
+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 reactor.core.publisher.Flux;
+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;
+
+@ExtendWith(MockitoExtension.class)
+class SysLoginLogServiceTest {
+
+    @Mock
+    private ISysLoginLogRepository repository;
+
+    private SysLoginLogService loginLogService;
+    private SysLoginLog testLoginLog;
+
+    @BeforeEach
+    void setUp() {
+        loginLogService = new SysLoginLogService(repository);
+        
+        testLoginLog = new SysLoginLog();
+        testLoginLog.setId(1L);
+        testLoginLog.setUsername("testuser");
+        testLoginLog.setIp("192.168.1.1");
+        testLoginLog.setLocation("北京");
+        testLoginLog.setBrowser("Chrome");
+        testLoginLog.setOs("Windows");
+        testLoginLog.setStatus("1");
+        testLoginLog.setMessage("登录成功");
+        testLoginLog.setLoginTime(LocalDateTime.now());
+    }
+
+    @Test
+    void testFindAll() {
+        when(repository.findAllByOrderByLoginTimeDesc()).thenReturn(Flux.just(testLoginLog));
+        
+        Flux<SysLoginLog> result = loginLogService.findAll();
+        
+        StepVerifier.create(result)
+                .expectNext(testLoginLog)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByLoginTimeDesc();
+    }
+
+    @Test
+    void testFindByUsername() {
+        when(repository.findByUsernameOrderByLoginTimeDesc("testuser")).thenReturn(Flux.just(testLoginLog));
+        
+        Flux<SysLoginLog> result = loginLogService.findByUsername("testuser");
+        
+        StepVerifier.create(result)
+                .expectNext(testLoginLog)
+                .verifyComplete();
+        
+        verify(repository).findByUsernameOrderByLoginTimeDesc("testuser");
+    }
+
+    @Test
+    void testFindByLoginTimeBetween() {
+        LocalDateTime startTime = LocalDateTime.now().minusDays(1);
+        LocalDateTime endTime = LocalDateTime.now();
+        
+        when(repository.findByLoginTimeBetweenOrderByLoginTimeDesc(startTime, endTime))
+                .thenReturn(Flux.just(testLoginLog));
+        
+        Flux<SysLoginLog> result = loginLogService.findByLoginTimeBetween(startTime, endTime);
+        
+        StepVerifier.create(result)
+                .expectNext(testLoginLog)
+                .verifyComplete();
+        
+        verify(repository).findByLoginTimeBetweenOrderByLoginTimeDesc(startTime, endTime);
+    }
+
+    @Test
+    void testSave() {
+        when(repository.save(any(SysLoginLog.class))).thenReturn(Mono.just(testLoginLog));
+        
+        Mono<SysLoginLog> result = loginLogService.save(testLoginLog);
+        
+        StepVerifier.create(result)
+                .expectNext(testLoginLog)
+                .verifyComplete();
+        
+        verify(repository).save(any(SysLoginLog.class));
+    }
+
+    @Test
+    void testFindById() {
+        when(repository.findById(1L)).thenReturn(Mono.just(testLoginLog));
+        
+        Mono<SysLoginLog> result = loginLogService.findById(1L);
+        
+        StepVerifier.create(result)
+                .expectNext(testLoginLog)
+                .verifyComplete();
+        
+        verify(repository).findById(1L);
+    }
+
+    @Test
+    void testFindLoginLogsByPage() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        
+        when(repository.findAllByOrderByLoginTimeDesc()).thenReturn(Flux.just(testLoginLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysLoginLog>> result = loginLogService.findLoginLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getTotalPages() == 1 &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByLoginTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testFindLoginLogsByPage_WithKeyword() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        pageRequest.setKeyword("test");
+        
+        when(repository.findAllByOrderByLoginTimeDesc()).thenReturn(Flux.just(testLoginLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysLoginLog>> result = loginLogService.findLoginLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByLoginTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testFindLoginLogsByPage_WithSort() {
+        PageRequest pageRequest = new PageRequest();
+        pageRequest.setPage(0);
+        pageRequest.setSize(10);
+        pageRequest.setSort("username");
+        pageRequest.setOrder("desc");
+        
+        when(repository.findAllByOrderByLoginTimeDesc()).thenReturn(Flux.just(testLoginLog));
+        when(repository.count()).thenReturn(Mono.just(1L));
+        
+        Mono<PageResponse<SysLoginLog>> result = loginLogService.findLoginLogsByPage(pageRequest);
+        
+        StepVerifier.create(result)
+                .expectNextMatches(response -> 
+                    response.getTotalElements() == 1L &&
+                    response.getContent().size() == 1)
+                .verifyComplete();
+        
+        verify(repository).findAllByOrderByLoginTimeDesc();
+        verify(repository).count();
+    }
+
+    @Test
+    void testCount() {
+        when(repository.count()).thenReturn(Mono.just(100L));
+        
+        Mono<Long> result = loginLogService.count();
+        
+        StepVerifier.create(result)
+                .expectNext(100L)
+                .verifyComplete();
+        
+        verify(repository).count();
+    }
+}
\ No newline at end of file
diff --git a/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysMenuServiceTest.java b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysMenuServiceTest.java
new file mode 100644
index 0000000..2f0d81b
--- /dev/null
+++ b/novalon-manage-api/manage-sys/src/test/java/cn/novalon/manage/sys/core/service/impl/SysMenuServiceTest.java
@@ -0,0 +1,223 @@
+package cn.novalon.manage.sys.core.service.impl;
+
+import cn.novalon.manage.sys.core.domain.SysMenu;
+import cn.novalon.manage.sys.core.repository.ISysMenuRepository;
+import cn.novalon.manage.sys.core.command.CreateMenuCommand;
+import cn.novalon.manage.sys.core.command.UpdateMenuCommand;
+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 reactor.core.publisher.Flux;
+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;
+
+@ExtendWith(MockitoExtension.class)
+class SysMenuServiceTest {
+
+    @Mock
+    private ISysMenuRepository menuRepository;
+
+    private SysMenuService menuService;
+    private SysMenu testMenu;
+
+    @BeforeEach
+    void setUp() {
+        menuService = new SysMenuService(menuRepository);
+        
+        testMenu = new SysMenu();
+        testMenu.setId(1L);
+        testMenu.setMenuName("系统管理");
+        testMenu.setParentId(0L);
+        testMenu.setOrderNum(1);
+        testMenu.setMenuType("M");
+        testMenu.setPerms("system");
+        testMenu.setComponent("system");
+        testMenu.setStatus(1);
+        testMenu.setCreatedAt(LocalDateTime.now());
+    }
+
+    @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)
+                .verifyComplete();
+        
+        verify(menuRepository).save(any(SysMenu.class));
+    }
+
+    @Test
+    void testCreateMenuWithCommand() {
+        CreateMenuCommand command = new CreateMenuCommand(
+            0L, "用户管理", "M", 2, "user", "user:manage", 1
+        );
+        
+        SysMenu createdMenu = new SysMenu();
+        createdMenu.setId(2L);
+        createdMenu.setMenuName("用户管理");
+        createdMenu.setParentId(0L);
+        createdMenu.setOrderNum(2);
+        createdMenu.setMenuType("M");
+        createdMenu.setPerms("user:manage");
+        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)
+                .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)
+                .verifyComplete();
+        
+        verify(menuRepository).save(any(SysMenu.class));
+    }
+
+    @Test
+    void testUpdateMenuWithCommand() {
+        UpdateMenuCommand command = new UpdateMenuCommand(
+            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)
+                .verifyComplete();
+        
+        verify(menuRepository).findById(1L);
+        verify(menuRepository).save(any(SysMenu.class));
+    }
+
+    @Test
+    void testUpdateMenuWithCommand_NotFound() {
+        UpdateMenuCommand command = new UpdateMenuCommand(
+            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);
+    }
+
+    @Test
+    void testDeleteMenu() {
+        when(menuRepository.deleteById(1L)).thenReturn(Mono.empty());
+        
+        Mono<Void> result = menuService.deleteMenu(1L);
+        
+        StepVerifier.create(result)
+                .verifyComplete();
+        
+        verify(menuRepository).deleteById(1L);
+    }
+
+    @Test
+    void testBuildMenuTree() {
+        SysMenu parentMenu = new SysMenu();
+        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)
+                .verifyComplete();
+    }
+}
\ No newline at end of file