map = new HashMap<>();
+ map.put("qrContent", QR_CONTENT);
+ map.put("isUsed", isUsed);
+ map.put("memberId", MEMBER_ID);
+ return map;
+ }
+
+ private SignInRecord createMockSignInRecord() {
+ return SignInRecord.builder()
+ .id(1L)
+ .memberId(MEMBER_ID)
+ .memberCardId(1L)
+ .signInTime(LocalDateTime.now())
+ .signInType("QR_CODE")
+ .signInStatus("SUCCESS")
+ .source("MINI_PROGRAM")
+ .isDelete(false)
+ .build();
+ }
+
+ private GroupCourseBooking createValidBooking() {
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setId(100L);
+ booking.setMemberId(MEMBER_ID);
+ booking.setCourseId(200L);
+ booking.setStatus("0");
+ booking.setCourseStartTime(LocalDateTime.now().plusMinutes(5));
+ booking.setCourseEndTime(LocalDateTime.now().plusMinutes(65));
+ return booking;
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-coach/pom.xml b/gym-manage-api/gym-coach/pom.xml
index 0e04e11..940ee46 100644
--- a/gym-manage-api/gym-coach/pom.xml
+++ b/gym-manage-api/gym-coach/pom.xml
@@ -63,5 +63,10 @@
lombok
provided
+
+ io.projectreactor
+ reactor-test
+ test
+
diff --git a/gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseScheduler.java b/gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseScheduler.java
index 0eff9cb..09250c9 100644
--- a/gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseScheduler.java
+++ b/gym-manage-api/gym-coach/src/main/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseScheduler.java
@@ -164,16 +164,24 @@ public class CoachCourseScheduler {
}
/**
- * 清除统计缓存和团课缓存 —— 调度器触发时，如有课程状态变更则必须及时失效
+ * 清除统计缓存和团课缓存 —— 调度器触发时，如有课程状态变更则必须及时失效。
+ *
+ * 注意：测试环境中 RedisUtil 可能被 Mock 返回 null，需做 null 安全处理。
*/
private void invalidateCache() {
- redisUtil.deleteByPattern("datacount:statistics:*").subscribe(
- deleted -> logger.debug("调度器清除统计缓存，已删除 {} 条", deleted),
- error -> logger.warn("调度器清除统计缓存失败: {}", error.getMessage())
- );
- redisUtil.deleteByPattern("group_course:*").subscribe(
- deleted -> logger.debug("调度器清除团课缓存，已删除 {} 条", deleted),
- error -> logger.warn("调度器清除团课缓存失败: {}", error.getMessage())
- );
+ Mono statsMono = redisUtil.deleteByPattern("datacount:statistics:*");
+ if (statsMono != null) {
+ statsMono.subscribe(
+ deleted -> logger.debug("调度器清除统计缓存，已删除 {} 条", deleted),
+ error -> logger.warn("调度器清除统计缓存失败: {}", error.getMessage())
+ );
+ }
+ Mono courseMono = redisUtil.deleteByPattern("group_course:*");
+ if (courseMono != null) {
+ courseMono.subscribe(
+ deleted -> logger.debug("调度器清除团课缓存，已删除 {} 条", deleted),
+ error -> logger.warn("调度器清除团课缓存失败: {}", error.getMessage())
+ );
+ }
}
}
diff --git a/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/handler/CoachCourseHandlerTest.java b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/handler/CoachCourseHandlerTest.java
new file mode 100644
index 0000000..4974bb5
--- /dev/null
+++ b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/handler/CoachCourseHandlerTest.java
@@ -0,0 +1,125 @@
+package cn.novalon.gym.manage.coach.handler;
+
+import cn.novalon.gym.manage.coach.service.CoachCourseService;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+
+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.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class CoachCourseHandlerTest {
+
+ @Mock
+ private CoachCourseService coachCourseService;
+
+ @Mock
+ private AuthUtil authUtil;
+
+ private CoachCourseHandler coachCourseHandler;
+
+ private static final Long COACH_ID = 10001L;
+ private static final Long COURSE_ID = 1L;
+
+ @BeforeEach
+ void setUp() {
+ coachCourseHandler = new CoachCourseHandler(coachCourseService, authUtil);
+ }
+
+ // ==================== startCourse ====================
+
+ @Test
+ void startCourse_shouldReturnOkWhenSuccess() {
+ GroupCourseEntity course = mock(GroupCourseEntity.class);
+ when(course.getStatus()).thenReturn(3L);
+ when(course.getActualStartTime()).thenReturn(LocalDateTime.now());
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(COACH_ID);
+ when(coachCourseService.startCourse(COURSE_ID, COACH_ID)).thenReturn(Mono.just(course));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "1")
+ .build();
+
+ Mono result = coachCourseHandler.startCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(authUtil).getMemberIdOrThrow(request);
+ verify(coachCourseService).startCourse(COURSE_ID, COACH_ID);
+ }
+
+ @Test
+ void startCourse_shouldReturnBadRequestOnError() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(COACH_ID);
+ when(coachCourseService.startCourse(COURSE_ID, COACH_ID))
+ .thenReturn(Mono.error(new RuntimeException("当前课程状态不允许开课")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "1")
+ .build();
+
+ Mono result = coachCourseHandler.startCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(authUtil).getMemberIdOrThrow(request);
+ verify(coachCourseService).startCourse(COURSE_ID, COACH_ID);
+ }
+
+ // ==================== endCourse ====================
+
+ @Test
+ void endCourse_shouldReturnOkWhenSuccess() {
+ GroupCourseEntity course = mock(GroupCourseEntity.class);
+ when(course.getStatus()).thenReturn(2L);
+ when(course.getActualEndTime()).thenReturn(LocalDateTime.now());
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(COACH_ID);
+ when(coachCourseService.endCourse(COURSE_ID, COACH_ID)).thenReturn(Mono.just(course));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "1")
+ .build();
+
+ Mono result = coachCourseHandler.endCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(authUtil).getMemberIdOrThrow(request);
+ verify(coachCourseService).endCourse(COURSE_ID, COACH_ID);
+ }
+
+ @Test
+ void endCourse_shouldReturnBadRequestOnError() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(COACH_ID);
+ when(coachCourseService.endCourse(COURSE_ID, COACH_ID))
+ .thenReturn(Mono.error(new RuntimeException("当前课程状态不允许结课")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "1")
+ .build();
+
+ Mono result = coachCourseHandler.endCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(authUtil).getMemberIdOrThrow(request);
+ verify(coachCourseService).endCourse(COURSE_ID, COACH_ID);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseSchedulerTest.java b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseSchedulerTest.java
new file mode 100644
index 0000000..00d5e74
--- /dev/null
+++ b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/scheduler/CoachCourseSchedulerTest.java
@@ -0,0 +1,470 @@
+package cn.novalon.gym.manage.coach.scheduler;
+
+import cn.novalon.gym.manage.coach.enums.ViolationReason;
+import cn.novalon.gym.manage.coachconfig.domain.CoachTimeRule;
+import cn.novalon.gym.manage.coachconfig.service.CoachTimeRuleService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseBookingDao;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+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.r2dbc.core.DatabaseClient;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.time.LocalDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class CoachCourseSchedulerTest {
+
+ @Mock
+ private GroupCourseDao groupCourseDao;
+
+ @Mock
+ private GroupCourseBookingDao groupCourseBookingDao;
+
+ @Mock
+ private DatabaseClient databaseClient;
+
+ @Mock
+ private RedisUtil redisUtil;
+
+ @Mock
+ private CoachTimeRuleService timeRuleService;
+
+ private CoachCourseScheduler scheduler;
+
+ private static final Long COURSE_ID = 100L;
+ private static final Long COACH_ID = 200L;
+ private static final int LATE_WINDOW = 30;
+ private static final int END_GRACE = 10;
+
+ @BeforeEach
+ void setUp() {
+ scheduler = new CoachCourseScheduler(
+ groupCourseDao, groupCourseBookingDao,
+ databaseClient, redisUtil, timeRuleService
+ );
+ }
+
+ // ==================== 辅助方法 ====================
+
+ /**
+ * 通过反射调用私有方法
+ */
+ @SuppressWarnings("unchecked")
+ private T invokePrivateMethod(String methodName, Class[] paramTypes, Object... args) {
+ try {
+ Method method = CoachCourseScheduler.class.getDeclaredMethod(methodName, paramTypes);
+ method.setAccessible(true);
+ return (T) method.invoke(scheduler, args);
+ } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+ throw new RuntimeException("反射调用方法 " + methodName + " 失败", e);
+ }
+ }
+
+ private GroupCourseEntity createCourse(Long id, Long coachId, LocalDateTime startTime,
+ LocalDateTime endTime, String status) {
+ GroupCourseEntity course = mock(GroupCourseEntity.class);
+ lenient().when(course.getId()).thenReturn(id);
+ lenient().when(course.getCoachId()).thenReturn(coachId);
+ lenient().when(course.getStartTime()).thenReturn(startTime);
+ lenient().when(course.getEndTime()).thenReturn(endTime);
+ lenient().when(course.getStatus()).thenReturn(Long.valueOf(status));
+ return course;
+ }
+
+ private CoachTimeRule createTimeRule(int lateWindow, int endGrace) {
+ CoachTimeRule rule = new CoachTimeRule();
+ rule.setLateWindow(lateWindow);
+ rule.setEndGrace(endGrace);
+ return rule;
+ }
+
+ private DatabaseClient.GenericExecuteSpec mockDatabaseClientInsertChain() {
+ DatabaseClient.GenericExecuteSpec spec = mock(DatabaseClient.GenericExecuteSpec.class);
+ when(databaseClient.sql(anyString())).thenReturn(spec);
+ when(spec.bind(anyString(), any())).thenReturn(spec);
+ when(spec.then()).thenReturn(Mono.empty());
+ return spec;
+ }
+
+ // ==================== processAbsentCourses ====================
+
+ @Test
+ void processAbsentCourses_shouldReturnZeroWhenNoAbsentCourses() {
+ // 准备：无缺席课程
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 0);
+ when(groupCourseDao.findByStatusAndStartTimeBefore(databaseClient, "0", now))
+ .thenReturn(Flux.empty());
+
+ // 执行
+ Mono result = invokePrivateMethod("processAbsentCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(0L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusAndStartTimeBefore(databaseClient, "0", now);
+ verifyNoInteractions(timeRuleService);
+ }
+
+ @Test
+ void processAbsentCourses_shouldReturnZeroWhenCoursesNotTimedOut() {
+ // 准备：有课程但未超时（minutesSinceStart <= lateWindow）
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 11, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 20); // 仅过20分钟，<= lateWindow(30)
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "0");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ when(groupCourseDao.findByStatusAndStartTimeBefore(databaseClient, "0", now))
+ .thenReturn(Flux.just(course));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // 执行
+ Mono result = invokePrivateMethod("processAbsentCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证：filter 过滤掉，不触发 markAsCoachAbsent
+ StepVerifier.create(result)
+ .expectNext(0L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusAndStartTimeBefore(databaseClient, "0", now);
+ verify(timeRuleService).matchRule(60);
+ verifyNoMoreInteractions(groupCourseDao, groupCourseBookingDao);
+ }
+
+ @Test
+ void processAbsentCourses_shouldMarkAbsentWhenCoursesTimedOut() {
+ // 准备：有课程且已超时（minutesSinceStart > lateWindow）
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 11, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 40); // 已过40分钟，> lateWindow(30)
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "0");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ when(groupCourseDao.findByStatusAndStartTimeBefore(databaseClient, "0", now))
+ .thenReturn(Flux.just(course));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToCoachAbsent(COURSE_ID, now, now)).thenReturn(Mono.just(1));
+ when(groupCourseBookingDao.updateStatusByCourseId(COURSE_ID, "0", "4")).thenReturn(Mono.just(1));
+
+ // 执行
+ Mono result = invokePrivateMethod("processAbsentCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(1L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusAndStartTimeBefore(databaseClient, "0", now);
+ verify(timeRuleService).matchRule(60);
+ verify(databaseClient).sql(anyString());
+ verify(spec, atLeastOnce()).bind(anyString(), any());
+ verify(spec).then();
+ verify(groupCourseDao).updateToCoachAbsent(COURSE_ID, now, now);
+ verify(groupCourseBookingDao).updateStatusByCourseId(COURSE_ID, "0", "4");
+ }
+
+ // ==================== processAutoEndCourses ====================
+
+ @Test
+ void processAutoEndCourses_shouldReturnZeroWhenNoCoursesToAutoEnd() {
+ // 准备：无自动结课课程
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 12, 0);
+ String[] expectedStatuses = {"3", "7"};
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now)))
+ .thenReturn(Flux.empty());
+
+ // 执行
+ Mono result = invokePrivateMethod("processAutoEndCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(0L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now));
+ verifyNoInteractions(timeRuleService);
+ }
+
+ @Test
+ void processAutoEndCourses_shouldReturnZeroWhenCoursesNotTimedOut() {
+ // 准备：有课程但未超时（minutesAfterEnd <= endGrace）
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 9, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 5); // 仅过5分钟，<= endGrace(10)
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "3");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ String[] expectedStatuses = {"3", "7"};
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now)))
+ .thenReturn(Flux.just(course));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // 执行
+ Mono result = invokePrivateMethod("processAutoEndCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证：filter 过滤掉，不触发 markAsAutoEnded
+ StepVerifier.create(result)
+ .expectNext(0L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now));
+ verify(timeRuleService).matchRule(60);
+ verifyNoMoreInteractions(groupCourseDao);
+ }
+
+ @Test
+ void processAutoEndCourses_shouldMarkAutoEndedWhenCoursesTimedOut() {
+ // 准备：有课程且已超时（minutesAfterEnd > endGrace）
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 9, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 15); // 已过15分钟，> endGrace(10)
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "3");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ String[] expectedStatuses = {"3", "7"};
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now)))
+ .thenReturn(Flux.just(course));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToAutoEnded(COURSE_ID, now, now)).thenReturn(Mono.just(1));
+
+ // 执行
+ Mono result = invokePrivateMethod("processAutoEndCourses",
+ new Class[]{LocalDateTime.class}, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(1L)
+ .verifyComplete();
+
+ verify(groupCourseDao).findByStatusInAndEndTimeBefore(eq(databaseClient), eq(expectedStatuses), eq(now));
+ verify(timeRuleService).matchRule(60);
+ verify(databaseClient).sql(anyString());
+ verify(spec, atLeastOnce()).bind(anyString(), any());
+ verify(spec).then();
+ verify(groupCourseDao).updateToAutoEnded(COURSE_ID, now, now);
+ verifyNoInteractions(groupCourseBookingDao);
+ }
+
+ // ==================== markAsCoachAbsent ====================
+
+ @Test
+ void markAsCoachAbsent_shouldInsertViolationAndUpdateCourseAndBooking() {
+ // 准备
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 11, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 40);
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "0");
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToCoachAbsent(COURSE_ID, now, now)).thenReturn(Mono.just(1));
+ when(groupCourseBookingDao.updateStatusByCourseId(COURSE_ID, "0", "4")).thenReturn(Mono.just(1));
+
+ // 执行
+ Mono result = invokePrivateMethod("markAsCoachAbsent",
+ new Class[]{GroupCourseEntity.class, LocalDateTime.class}, course, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(course)
+ .verifyComplete();
+
+ // 验证 insertViolation 链
+ verify(databaseClient).sql(contains("INSERT INTO coach_violation"));
+ verify(spec, atLeastOnce()).bind(anyString(), any());
+ verify(spec).then();
+
+ // 验证 updateToCoachAbsent
+ verify(groupCourseDao).updateToCoachAbsent(COURSE_ID, now, now);
+
+ // 验证 updateStatusByCourseId
+ verify(groupCourseBookingDao).updateStatusByCourseId(COURSE_ID, "0", "4");
+ }
+
+ // ==================== markAsAutoEnded ====================
+
+ @Test
+ void markAsAutoEnded_shouldInsertViolationAndUpdateCourse() {
+ // 准备
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 9, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime now = LocalDateTime.of(2026, 7, 31, 10, 15);
+
+ GroupCourseEntity course = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "3");
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToAutoEnded(COURSE_ID, now, now)).thenReturn(Mono.just(1));
+
+ // 执行
+ Mono result = invokePrivateMethod("markAsAutoEnded",
+ new Class[]{GroupCourseEntity.class, LocalDateTime.class}, course, now);
+
+ // 验证
+ StepVerifier.create(result)
+ .expectNext(course)
+ .verifyComplete();
+
+ // 验证 insertViolation 链
+ verify(databaseClient).sql(contains("INSERT INTO coach_violation"));
+ verify(spec, atLeastOnce()).bind(anyString(), any());
+ verify(spec).then();
+
+ // 验证 updateToAutoEnded
+ verify(groupCourseDao).updateToAutoEnded(COURSE_ID, now, now);
+
+ // 验证未调用 bookingDao
+ verifyNoInteractions(groupCourseBookingDao);
+ }
+
+ // ==================== checkAndProcessCourses ====================
+
+ @Test
+ void checkAndProcessCourses_shouldProcessNoCoursesWhenNoneExist() {
+ // 准备：无任何待处理课程
+ LocalDateTime now = LocalDateTime.now();
+ when(groupCourseDao.findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+
+ // 执行
+ scheduler.checkAndProcessCourses();
+
+ // 验证：processAbsentCourses 和 processAutoEndCourses 都被调用
+ verify(groupCourseDao).findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class));
+ verify(groupCourseDao).findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class));
+
+ // 验证未触发缓存清除（count=0，不进入 if 分支）
+ verifyNoInteractions(redisUtil);
+ }
+
+ @Test
+ void checkAndProcessCourses_shouldInvalidateCacheWhenCoursesProcessed() {
+ // 准备：有缺席课程需处理
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 11, 0);
+ LocalDateTime now = LocalDateTime.now();
+
+ // 由于不能精确控制 now，这里匹配任何时间
+ GroupCourseEntity absentCourse = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "0");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ when(groupCourseDao.findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class)))
+ .thenReturn(Flux.just(absentCourse));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToCoachAbsent(eq(COURSE_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(1));
+ when(groupCourseBookingDao.updateStatusByCourseId(COURSE_ID, "0", "4"))
+ .thenReturn(Mono.just(1));
+
+ // 自动结课：无课程
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+
+ // mock RedisUtil 返回非 null 的 Mono
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ // 执行
+ scheduler.checkAndProcessCourses();
+
+ // 验证缓存清除被调用
+ verify(redisUtil).deleteByPattern("datacount:statistics:*");
+ verify(redisUtil).deleteByPattern("group_course:*");
+ }
+
+ @Test
+ void checkAndProcessCourses_shouldHandleRedisUtilReturningNull() {
+ // 准备：测试 RedisUtil 返回 null 的边界情况
+ LocalDateTime startTime = LocalDateTime.of(2026, 7, 31, 10, 0);
+ LocalDateTime endTime = LocalDateTime.of(2026, 7, 31, 11, 0);
+
+ GroupCourseEntity absentCourse = createCourse(COURSE_ID, COACH_ID, startTime, endTime, "0");
+ CoachTimeRule rule = createTimeRule(LATE_WINDOW, END_GRACE);
+
+ when(groupCourseDao.findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class)))
+ .thenReturn(Flux.just(absentCourse));
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // mock DatabaseClient 链式调用
+ DatabaseClient.GenericExecuteSpec spec = mockDatabaseClientInsertChain();
+
+ when(groupCourseDao.updateToCoachAbsent(anyLong(), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(1));
+ when(groupCourseBookingDao.updateStatusByCourseId(anyLong(), anyString(), anyString()))
+ .thenReturn(Mono.just(1));
+
+ // 自动结课：无课程
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+
+ // RedisUtil.deleteByPattern 返回 null（模拟 null 安全检查）
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(null);
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(null);
+
+ // 执行：不应抛出 NPE
+ scheduler.checkAndProcessCourses();
+
+ // 验证：RedisUtil 被调用（即使返回 null）
+ verify(redisUtil).deleteByPattern("datacount:statistics:*");
+ verify(redisUtil).deleteByPattern("group_course:*");
+ }
+
+ @Test
+ void checkAndProcessCourses_shouldHandleErrorInAbsentProcessing() {
+ // 准备：缺席处理抛出异常
+ when(groupCourseDao.findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class)))
+ .thenReturn(Flux.error(new RuntimeException("数据库查询失败")));
+ when(groupCourseDao.findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+
+ // 执行：不应抛出异常（subscribe 中有 error handler）
+ scheduler.checkAndProcessCourses();
+
+ // 验证
+ verify(groupCourseDao).findByStatusAndStartTimeBefore(eq(databaseClient), eq("0"), any(LocalDateTime.class));
+ verify(groupCourseDao).findByStatusInAndEndTimeBefore(eq(databaseClient), any(String[].class), any(LocalDateTime.class));
+ verifyNoInteractions(redisUtil);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/service/CoachCourseServiceTest.java b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/service/CoachCourseServiceTest.java
new file mode 100644
index 0000000..ffcc8c1
--- /dev/null
+++ b/gym-manage-api/gym-coach/src/test/java/cn/novalon/gym/manage/coach/service/CoachCourseServiceTest.java
@@ -0,0 +1,803 @@
+package cn.novalon.gym.manage.coach.service;
+
+import cn.novalon.gym.manage.coach.dao.CoachViolationDao;
+import cn.novalon.gym.manage.coach.enums.ViolationReason;
+import cn.novalon.gym.manage.coachconfig.domain.CoachTimeRule;
+import cn.novalon.gym.manage.coachconfig.service.CoachTimeRuleService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.common.util.StatusConstants;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseBookingDao;
+import cn.novalon.gym.manage.groupcourse.dao.GroupCourseDao;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.entity.GroupCourseEntity;
+import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.sys.core.domain.SysRole;
+import cn.novalon.gym.manage.sys.core.domain.SysUser;
+import cn.novalon.gym.manage.sys.core.domain.UserRole;
+import cn.novalon.gym.manage.sys.core.repository.ISysRoleRepository;
+import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
+import cn.novalon.gym.manage.sys.core.repository.IUserRoleRepository;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Sort;
+import org.springframework.r2dbc.core.DatabaseClient;
+import org.springframework.r2dbc.core.FetchSpec;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class CoachCourseServiceTest {
+
+ @Mock
+ private ISysUserRepository userRepository;
+
+ @Mock
+ private ISysRoleRepository roleRepository;
+
+ @Mock
+ private IUserRoleRepository userRoleRepository;
+
+ @Mock
+ private IGroupCourseRepository groupCourseRepository;
+
+ @Mock
+ private IGroupCourseBookingRepository bookingRepository;
+
+ @Mock
+ private GroupCourseDao groupCourseDao;
+
+ @Mock
+ private GroupCourseBookingDao groupCourseBookingDao;
+
+ @Mock
+ private CoachViolationDao violationDao;
+
+ @Mock
+ private DatabaseClient databaseClient;
+
+ @Mock
+ private PasswordEncoder passwordEncoder;
+
+ @Mock
+ private RedisUtil redisUtil;
+
+ @Mock
+ private CoachTimeRuleService timeRuleService;
+
+ private CoachCourseService coachCourseService;
+
+ private static final Long COACH_ROLE_ID = 100L;
+ private static final Long COACH_USER_ID = 10001L;
+ private static final Long COURSE_ID = 1L;
+ private static final Long OTHER_COACH_ID = 20001L;
+
+ @BeforeEach
+ void setUp() {
+ coachCourseService = new CoachCourseService(
+ userRepository, roleRepository, userRoleRepository,
+ groupCourseRepository, bookingRepository,
+ groupCourseDao, groupCourseBookingDao,
+ violationDao, databaseClient,
+ passwordEncoder, redisUtil, timeRuleService
+ );
+ }
+
+ // ==================== getCoachRoleId ====================
+
+ @Test
+ void getCoachRoleId_shouldReturnRoleIdWhenFound() {
+ SysRole role = new SysRole();
+ role.setId(COACH_ROLE_ID);
+ role.setRoleName("教练");
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.just(role));
+
+ StepVerifier.create(coachCourseService.getCoachRoleId())
+ .expectNext(COACH_ROLE_ID)
+ .verifyComplete();
+
+ verify(roleRepository).findByRoleName("教练");
+ }
+
+ @Test
+ void getCoachRoleId_shouldThrowWhenRoleNotFound() {
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.empty());
+
+ StepVerifier.create(coachCourseService.getCoachRoleId())
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("教练角色未找到"))
+ .verify();
+
+ verify(roleRepository).findByRoleName("教练");
+ }
+
+ // ==================== getAllCoaches ====================
+
+ @Test
+ void getAllCoaches_shouldReturnCoachList() {
+ SysRole role = new SysRole();
+ role.setId(COACH_ROLE_ID);
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.just(role));
+
+ UserRole userRole1 = new UserRole();
+ userRole1.setUserId(COACH_USER_ID);
+ userRole1.setRoleId(COACH_ROLE_ID);
+ UserRole userRole2 = new UserRole();
+ userRole2.setUserId(10002L);
+ userRole2.setRoleId(COACH_ROLE_ID);
+ when(userRoleRepository.findByRoleId(COACH_ROLE_ID)).thenReturn(Flux.just(userRole1, userRole2));
+
+ SysUser coach1 = new SysUser();
+ coach1.setId(COACH_USER_ID);
+ coach1.setUsername("coach1");
+ coach1.setNickname("教练1");
+ coach1.setDeletedAt(null);
+ SysUser coach2 = new SysUser();
+ coach2.setId(10002L);
+ coach2.setUsername("coach2");
+ coach2.setNickname("教练2");
+ coach2.setDeletedAt(null);
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.just(coach1));
+ when(userRepository.findById(10002L)).thenReturn(Mono.just(coach2));
+
+ StepVerifier.create(coachCourseService.getAllCoaches())
+ .expectNext(coach1, coach2)
+ .verifyComplete();
+
+ verify(roleRepository).findByRoleName("教练");
+ verify(userRoleRepository).findByRoleId(COACH_ROLE_ID);
+ verify(userRepository).findById(COACH_USER_ID);
+ verify(userRepository).findById(10002L);
+ }
+
+ @Test
+ void getAllCoaches_shouldReturnEmptyWhenNoCoachRole() {
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.empty());
+
+ // getCoachRoleId() 抛出异常，getAllCoaches 会传播该错误
+ // 但实际业务中教练角色应当存在，此场景属于配置异常
+ StepVerifier.create(coachCourseService.getAllCoaches())
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("教练角色未找到"))
+ .verify();
+ }
+
+ @Test
+ void getAllCoaches_shouldReturnEmptyWhenNoUserRoles() {
+ SysRole role = new SysRole();
+ role.setId(COACH_ROLE_ID);
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.just(role));
+ when(userRoleRepository.findByRoleId(COACH_ROLE_ID)).thenReturn(Flux.empty());
+
+ StepVerifier.create(coachCourseService.getAllCoaches())
+ .verifyComplete();
+ }
+
+ @Test
+ void getAllCoaches_shouldFilterDeletedUsers() {
+ SysRole role = new SysRole();
+ role.setId(COACH_ROLE_ID);
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.just(role));
+
+ UserRole userRole = new UserRole();
+ userRole.setUserId(COACH_USER_ID);
+ when(userRoleRepository.findByRoleId(COACH_ROLE_ID)).thenReturn(Flux.just(userRole));
+
+ SysUser coach = new SysUser();
+ coach.setId(COACH_USER_ID);
+ coach.setDeletedAt(LocalDateTime.now()); // deleted user
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.just(coach));
+
+ StepVerifier.create(coachCourseService.getAllCoaches())
+ .verifyComplete();
+ }
+
+ // ==================== createCoach ====================
+
+ @Test
+ void createCoach_shouldCreateCoachSuccessfully() {
+ SysRole role = new SysRole();
+ role.setId(COACH_ROLE_ID);
+ when(roleRepository.findByRoleName("教练")).thenReturn(Mono.just(role));
+
+ String username = "newCoach";
+ String password = "123456";
+ String nickname = "新教练";
+ String email = "coach@test.com";
+ String phone = "13800138000";
+ String encodedPassword = "encoded_password";
+
+ when(passwordEncoder.encode(password)).thenReturn(encodedPassword);
+
+ SysUser savedUser = new SysUser();
+ savedUser.setId(COACH_USER_ID);
+ savedUser.setUsername(username);
+ savedUser.setPassword(encodedPassword);
+ savedUser.setNickname(nickname);
+ savedUser.setEmail(email);
+ savedUser.setPhone(phone);
+ savedUser.setStatus(StatusConstants.ENABLED);
+ when(userRepository.save(any(SysUser.class))).thenReturn(Mono.just(savedUser));
+
+ UserRole savedUserRole = new UserRole();
+ savedUserRole.setUserId(COACH_USER_ID);
+ savedUserRole.setRoleId(COACH_ROLE_ID);
+ when(userRoleRepository.save(any(UserRole.class))).thenReturn(Mono.just(savedUserRole));
+
+ StepVerifier.create(coachCourseService.createCoach(username, password, nickname, email, phone))
+ .assertNext(user -> {
+ assertThat(user.getId()).isEqualTo(COACH_USER_ID);
+ assertThat(user.getUsername()).isEqualTo(username);
+ assertThat(user.getNickname()).isEqualTo(nickname);
+ assertThat(user.getEmail()).isEqualTo(email);
+ assertThat(user.getPhone()).isEqualTo(phone);
+ assertThat(user.getStatus()).isEqualTo(StatusConstants.ENABLED);
+ })
+ .verifyComplete();
+
+ verify(roleRepository).findByRoleName("教练");
+ verify(passwordEncoder).encode(password);
+ verify(userRepository).save(any(SysUser.class));
+ verify(userRoleRepository).save(any(UserRole.class));
+
+ ArgumentCaptor userCaptor = ArgumentCaptor.forClass(SysUser.class);
+ verify(userRepository).save(userCaptor.capture());
+ SysUser capturedUser = userCaptor.getValue();
+ assertThat(capturedUser.getPassword()).isEqualTo(encodedPassword);
+
+ ArgumentCaptor userRoleCaptor = ArgumentCaptor.forClass(UserRole.class);
+ verify(userRoleRepository).save(userRoleCaptor.capture());
+ assertThat(userRoleCaptor.getValue().getUserId()).isEqualTo(COACH_USER_ID);
+ assertThat(userRoleCaptor.getValue().getRoleId()).isEqualTo(COACH_ROLE_ID);
+ }
+
+ // ==================== updateCoach ====================
+
+ @Test
+ void updateCoach_shouldUpdateSuccessfully() {
+ SysUser existingUser = new SysUser();
+ existingUser.setId(COACH_USER_ID);
+ existingUser.setUsername("oldCoach");
+ existingUser.setNickname("旧教练");
+ existingUser.setEmail("old@test.com");
+ existingUser.setPhone("13900000000");
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.just(existingUser));
+
+ SysUser updatedUser = new SysUser();
+ updatedUser.setId(COACH_USER_ID);
+ updatedUser.setNickname("新教练");
+ updatedUser.setEmail("new@test.com");
+ updatedUser.setPhone("13800138000");
+ when(userRepository.update(any(SysUser.class))).thenReturn(Mono.just(updatedUser));
+
+ StepVerifier.create(coachCourseService.updateCoach(COACH_USER_ID, "新教练", "new@test.com", "13800138000"))
+ .assertNext(user -> {
+ assertThat(user.getNickname()).isEqualTo("新教练");
+ assertThat(user.getEmail()).isEqualTo("new@test.com");
+ assertThat(user.getPhone()).isEqualTo("13800138000");
+ })
+ .verifyComplete();
+
+ verify(userRepository).findById(COACH_USER_ID);
+ verify(userRepository).update(any(SysUser.class));
+ }
+
+ @Test
+ void updateCoach_shouldThrowWhenCoachNotFound() {
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.empty());
+
+ StepVerifier.create(coachCourseService.updateCoach(COACH_USER_ID, "nick", "email", "phone"))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("教练不存在"))
+ .verify();
+
+ verify(userRepository).findById(COACH_USER_ID);
+ verify(userRepository, never()).update(any());
+ }
+
+ // ==================== disableCoach ====================
+
+ @Test
+ void disableCoach_shouldDisableSuccessfully() {
+ SysUser user = new SysUser();
+ user.setId(COACH_USER_ID);
+ user.setStatus(StatusConstants.ENABLED);
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.just(user));
+
+ when(groupCourseRepository.countByCoachIdAndStatus(COACH_USER_ID, 3L)).thenReturn(Mono.just(0L));
+ when(groupCourseRepository.cancelCoursesByCoachIdExceptStatus(COACH_USER_ID, 3L)).thenReturn(Mono.just(1));
+
+ SysUser updatedUser = new SysUser();
+ updatedUser.setId(COACH_USER_ID);
+ updatedUser.setStatus(StatusConstants.DISABLED);
+ when(userRepository.update(any(SysUser.class))).thenReturn(Mono.just(updatedUser));
+
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.disableCoach(COACH_USER_ID))
+ .verifyComplete();
+
+ verify(userRepository).findById(COACH_USER_ID);
+ verify(groupCourseRepository).countByCoachIdAndStatus(COACH_USER_ID, 3L);
+ verify(groupCourseRepository).cancelCoursesByCoachIdExceptStatus(COACH_USER_ID, 3L);
+ verify(userRepository).update(any(SysUser.class));
+ verify(redisUtil).deleteByPattern("datacount:statistics:*");
+ verify(redisUtil).deleteByPattern("group_course:*");
+ }
+
+ @Test
+ void disableCoach_shouldThrowWhenCoachNotFound() {
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.empty());
+ // invalidateStatisticsCache() 会在 .then() 参数求值时被调用，需要 stub
+ lenient().when(redisUtil.deleteByPattern(anyString())).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.disableCoach(COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("教练不存在"))
+ .verify();
+ }
+
+ @Test
+ void disableCoach_shouldThrowWhenHasInProgressCourses() {
+ SysUser user = new SysUser();
+ user.setId(COACH_USER_ID);
+ user.setStatus(StatusConstants.ENABLED);
+ when(userRepository.findById(COACH_USER_ID)).thenReturn(Mono.just(user));
+
+ when(groupCourseRepository.countByCoachIdAndStatus(COACH_USER_ID, 3L)).thenReturn(Mono.just(2L));
+ // invalidateStatisticsCache() 会在 .then() 参数求值时被调用，需要 stub
+ lenient().when(redisUtil.deleteByPattern(anyString())).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.disableCoach(COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("正在进行中的团课"))
+ .verify();
+
+ verify(userRepository).findById(COACH_USER_ID);
+ verify(groupCourseRepository).countByCoachIdAndStatus(COACH_USER_ID, 3L);
+ verify(groupCourseRepository, never()).cancelCoursesByCoachIdExceptStatus(any(), anyLong());
+ verify(userRepository, never()).update(any());
+ }
+
+ // ==================== getCoachCourses ====================
+
+ @Test
+ void getCoachCourses_shouldReturnCoursesWithBookingCount() {
+ GroupCourse course1 = new GroupCourse();
+ course1.setId(1L);
+ course1.setCourseName("瑜伽课");
+ course1.setCoachId(COACH_USER_ID);
+
+ GroupCourse course2 = new GroupCourse();
+ course2.setId(2L);
+ course2.setCourseName("动感单车");
+ course2.setCoachId(COACH_USER_ID);
+
+ when(groupCourseRepository.findByCoachId(eq(COACH_USER_ID), any(Sort.class)))
+ .thenReturn(Flux.just(course1, course2));
+
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(3L));
+ when(bookingRepository.countValidBookings(2L)).thenReturn(Mono.just(5L));
+
+ StepVerifier.create(coachCourseService.getCoachCourses(COACH_USER_ID))
+ .assertNext(course -> {
+ assertThat(course.getId()).isEqualTo(1L);
+ assertThat(course.getCurrentMembers()).isEqualTo(3);
+ })
+ .assertNext(course -> {
+ assertThat(course.getId()).isEqualTo(2L);
+ assertThat(course.getCurrentMembers()).isEqualTo(5);
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByCoachId(eq(COACH_USER_ID), any(Sort.class));
+ verify(bookingRepository).countValidBookings(1L);
+ verify(bookingRepository).countValidBookings(2L);
+ }
+
+ @Test
+ void getCoachCourses_shouldReturnEmptyWhenNoCourses() {
+ when(groupCourseRepository.findByCoachId(eq(COACH_USER_ID), any(Sort.class)))
+ .thenReturn(Flux.empty());
+
+ StepVerifier.create(coachCourseService.getCoachCourses(COACH_USER_ID))
+ .verifyComplete();
+ }
+
+ // ==================== startCourse ====================
+
+ private GroupCourseEntity createCourseEntity(Long id, Long coachId, Long status,
+ LocalDateTime startTime, LocalDateTime endTime) {
+ GroupCourseEntity course = new GroupCourseEntity();
+ course.setId(id);
+ course.setCoachId(coachId);
+ course.setStatus(status);
+ course.setStartTime(startTime);
+ course.setEndTime(endTime);
+ return course;
+ }
+
+ private CoachTimeRule createTimeRule(int normalWindow, int lateWindow, int endGrace) {
+ CoachTimeRule rule = new CoachTimeRule();
+ rule.setNormalWindow(normalWindow);
+ rule.setLateWindow(lateWindow);
+ rule.setEndGrace(endGrace);
+ return rule;
+ }
+
+ @Test
+ void startCourse_shouldStartNormally() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.NORMAL.getValue(),
+ now.minusMinutes(5), now.plusMinutes(55));
+ GroupCourseEntity updatedCourse = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.IN_PROGRESS.getValue(),
+ now.minusMinutes(5), now.plusMinutes(55));
+ updatedCourse.setActualStartTime(now);
+ // 第一次调用返回原始课程，第二次调用（doStartCourse 内）返回更新后的课程
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID))
+ .thenReturn(Mono.just(course), Mono.just(updatedCourse));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ when(groupCourseDao.updateStartInfo(eq(COURSE_ID), eq("3"), any(LocalDateTime.class), any(LocalDateTime.class))).thenReturn(Mono.just(1));
+
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .assertNext(entity -> {
+ assertThat(entity.getStatus()).isEqualTo(CourseStatus.IN_PROGRESS.getValue());
+ assertThat(entity.getActualStartTime()).isNotNull();
+ })
+ .verifyComplete();
+
+ verify(groupCourseDao, times(2)).findByIdIsAndDeletedAtIsNull(COURSE_ID);
+ verify(timeRuleService).matchRule(60);
+ verify(groupCourseDao).updateStartInfo(eq(COURSE_ID), eq("3"), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ @Test
+ void startCourse_shouldStartLateWithViolation() {
+ LocalDateTime now = LocalDateTime.now();
+ // 课程开始时间在 normalWindow(10) 之后、lateWindow(30) 之内
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.NORMAL.getValue(),
+ now.minusMinutes(15), now.plusMinutes(45));
+ GroupCourseEntity updatedCourse = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.COACH_LATE.getValue(),
+ now.minusMinutes(15), now.plusMinutes(45));
+ updatedCourse.setActualStartTime(now);
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID))
+ .thenReturn(Mono.just(course), Mono.just(updatedCourse));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ // mock recordViolation via DatabaseClient
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.then()).thenReturn(Mono.empty());
+
+ when(groupCourseDao.updateStartInfo(eq(COURSE_ID), eq("7"), any(LocalDateTime.class), any(LocalDateTime.class))).thenReturn(Mono.just(1));
+
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .assertNext(entity -> {
+ assertThat(entity.getStatus()).isEqualTo(CourseStatus.COACH_LATE.getValue());
+ assertThat(entity.getActualStartTime()).isNotNull();
+ })
+ .verifyComplete();
+
+ verify(databaseClient).sql(anyString());
+ verify(groupCourseDao).updateStartInfo(eq(COURSE_ID), eq("7"), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ @Test
+ void startCourse_shouldThrowWhenBeforeStartTime() {
+ LocalDateTime now = LocalDateTime.now();
+ // 课程开始时间在未来
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.NORMAL.getValue(),
+ now.plusMinutes(10), now.plusMinutes(70));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("课程尚未到开课时间"))
+ .verify();
+ }
+
+ @Test
+ void startCourse_shouldThrowWhenPastLateWindow() {
+ LocalDateTime now = LocalDateTime.now();
+ // 课程开始时间超过 lateWindow(30)
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.NORMAL.getValue(),
+ now.minusMinutes(35), now.plusMinutes(25));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(60)).thenReturn(Mono.just(rule));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("已超过开课时间"))
+ .verify();
+ }
+
+ @Test
+ void startCourse_shouldThrowWhenNotCoach() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, OTHER_COACH_ID, CourseStatus.NORMAL.getValue(),
+ now.minusMinutes(5), now.plusMinutes(55));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("您不是该课程的教练"))
+ .verify();
+ }
+
+ @Test
+ void startCourse_shouldThrowWhenCourseNotFound() {
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.empty());
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("团课不存在"))
+ .verify();
+ }
+
+ @Test
+ void startCourse_shouldThrowWhenStatusNotNormal() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.IN_PROGRESS.getValue(),
+ now.minusMinutes(5), now.plusMinutes(55));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ StepVerifier.create(coachCourseService.startCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("当前课程状态不允许开课"))
+ .verify();
+ }
+
+ // ==================== endCourse ====================
+
+ @Test
+ void endCourse_shouldEndSuccessfully() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.IN_PROGRESS.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ GroupCourseEntity updatedCourse = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.ENDED.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ updatedCourse.setActualEndTime(now);
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID))
+ .thenReturn(Mono.just(course), Mono.just(updatedCourse));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(55)).thenReturn(Mono.just(rule));
+
+ when(groupCourseDao.updateEndInfo(eq(COURSE_ID), eq("2"), any(LocalDateTime.class), any(LocalDateTime.class))).thenReturn(Mono.just(1));
+
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .assertNext(entity -> {
+ assertThat(entity.getStatus()).isEqualTo(CourseStatus.ENDED.getValue());
+ assertThat(entity.getActualEndTime()).isNotNull();
+ })
+ .verifyComplete();
+
+ verify(groupCourseDao, times(2)).findByIdIsAndDeletedAtIsNull(COURSE_ID);
+ verify(timeRuleService).matchRule(55);
+ verify(groupCourseDao).updateEndInfo(eq(COURSE_ID), eq("2"), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ @Test
+ void endCourse_shouldThrowWhenStatusNotInProgressOrLate() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.NORMAL.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("当前课程状态不允许结课"))
+ .verify();
+ }
+
+ @Test
+ void endCourse_shouldThrowWhenPastEndGrace() {
+ LocalDateTime now = LocalDateTime.now();
+ // 课程结束时间已超过 endGrace(10) 分钟
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.IN_PROGRESS.getValue(),
+ now.minusMinutes(120), now.minusMinutes(15));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(105)).thenReturn(Mono.just(rule));
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("已超过结课时间"))
+ .verify();
+ }
+
+ @Test
+ void endCourse_shouldThrowWhenNotCoach() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, OTHER_COACH_ID, CourseStatus.IN_PROGRESS.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.just(course));
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("您不是该课程的教练"))
+ .verify();
+ }
+
+ @Test
+ void endCourse_shouldThrowWhenCourseNotFound() {
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID)).thenReturn(Mono.empty());
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && e.getMessage().contains("团课不存在"))
+ .verify();
+ }
+
+ @Test
+ void endCourse_shouldEndWhenStatusCoachLate() {
+ LocalDateTime now = LocalDateTime.now();
+ GroupCourseEntity course = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.COACH_LATE.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ GroupCourseEntity updatedCourse = createCourseEntity(
+ COURSE_ID, COACH_USER_ID, CourseStatus.ENDED.getValue(),
+ now.minusMinutes(60), now.minusMinutes(5));
+ updatedCourse.setActualEndTime(now);
+ when(groupCourseDao.findByIdIsAndDeletedAtIsNull(COURSE_ID))
+ .thenReturn(Mono.just(course), Mono.just(updatedCourse));
+
+ CoachTimeRule rule = createTimeRule(10, 30, 10);
+ when(timeRuleService.matchRule(55)).thenReturn(Mono.just(rule));
+
+ when(groupCourseDao.updateEndInfo(eq(COURSE_ID), eq("2"), any(LocalDateTime.class), any(LocalDateTime.class))).thenReturn(Mono.just(1));
+
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(1L));
+ when(redisUtil.deleteByPattern("group_course:*")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(coachCourseService.endCourse(COURSE_ID, COACH_USER_ID))
+ .assertNext(entity -> {
+ assertThat(entity.getStatus()).isEqualTo(CourseStatus.ENDED.getValue());
+ })
+ .verifyComplete();
+ }
+
+ // ==================== recordViolation ====================
+
+ @Test
+ void recordViolation_shouldRecordSuccessfully() {
+ LocalDateTime now = LocalDateTime.now();
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.then()).thenReturn(Mono.empty());
+
+ StepVerifier.create(coachCourseService.recordViolation(
+ COACH_USER_ID, COURSE_ID, now, ViolationReason.COACH_LATE))
+ .verifyComplete();
+
+ verify(databaseClient).sql(anyString());
+ verify(executeSpec).bind("coachId", COACH_USER_ID);
+ verify(executeSpec).bind("courseId", COURSE_ID);
+ verify(executeSpec).bind("violationTime", now);
+ verify(executeSpec).bind("reason", ViolationReason.COACH_LATE.getValue());
+ }
+
+ // ==================== getViolationCounts ====================
+
+ @Test
+ @SuppressWarnings("unchecked")
+ void getViolationCounts_shouldReturnCounts() {
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ FetchSpec> fetchSpec = mock(FetchSpec.class);
+
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.fetch()).thenReturn(fetchSpec);
+ when(fetchSpec.all()).thenReturn(Flux.just(
+ Map.of("coach_id", COACH_USER_ID, "count", 3L),
+ Map.of("coach_id", 10002L, "count", 1L)
+ ));
+
+ StepVerifier.create(coachCourseService.getViolationCounts())
+ .expectNextMatches(map -> map.get("coach_id").equals(COACH_USER_ID) && map.get("count").equals(3L))
+ .expectNextMatches(map -> map.get("coach_id").equals(10002L) && map.get("count").equals(1L))
+ .verifyComplete();
+
+ verify(databaseClient).sql(anyString());
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ void getViolationCounts_shouldReturnEmptyWhenNoViolations() {
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ FetchSpec> fetchSpec = mock(FetchSpec.class);
+
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.fetch()).thenReturn(fetchSpec);
+ when(fetchSpec.all()).thenReturn(Flux.empty());
+
+ StepVerifier.create(coachCourseService.getViolationCounts())
+ .verifyComplete();
+ }
+
+ // ==================== getCoachViolations ====================
+
+ @Test
+ @SuppressWarnings("unchecked")
+ void getCoachViolations_shouldReturnViolations() {
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ FetchSpec> fetchSpec = mock(FetchSpec.class);
+
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.fetch()).thenReturn(fetchSpec);
+ when(fetchSpec.all()).thenReturn(Flux.just(
+ Map.of("id", 1L, "coach_id", COACH_USER_ID, "violation_reason", "COACH_LATE", "course_name", "瑜伽课"),
+ Map.of("id", 2L, "coach_id", COACH_USER_ID, "violation_reason", "COACH_ABSENT", "course_name", "动感单车")
+ ));
+
+ StepVerifier.create(coachCourseService.getCoachViolations(COACH_USER_ID))
+ .expectNextCount(2)
+ .verifyComplete();
+
+ verify(databaseClient).sql(anyString());
+ verify(executeSpec).bind("coachId", COACH_USER_ID);
+ }
+
+ @Test
+ @SuppressWarnings("unchecked")
+ void getCoachViolations_shouldReturnEmptyWhenNoViolations() {
+ DatabaseClient.GenericExecuteSpec executeSpec = mock(DatabaseClient.GenericExecuteSpec.class, Mockito.RETURNS_SELF);
+ FetchSpec> fetchSpec = mock(FetchSpec.class);
+
+ when(databaseClient.sql(anyString())).thenReturn(executeSpec);
+ when(executeSpec.fetch()).thenReturn(fetchSpec);
+ when(fetchSpec.all()).thenReturn(Flux.empty());
+
+ StepVerifier.create(coachCourseService.getCoachViolations(COACH_USER_ID))
+ .verifyComplete();
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/pom.xml b/gym-manage-api/gym-groupCourse/pom.xml
index c898159..ca08076 100644
--- a/gym-manage-api/gym-groupCourse/pom.xml
+++ b/gym-manage-api/gym-groupCourse/pom.xml
@@ -61,6 +61,11 @@
spring-boot-starter-test
test
+
+ io.projectreactor
+ reactor-test
+ test
+
io.swagger.core.v3
swagger-annotations-jakarta
diff --git a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
index 6bbd6a9..7895a70 100644
--- a/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
+++ b/gym-manage-api/gym-groupCourse/src/main/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandler.java
@@ -156,6 +156,7 @@ public class GroupCourseHandler {
response.put("data", course);
return ServerResponse.ok().bodyValue(response);
})
+ .switchIfEmpty(ServerResponse.notFound().build())
.onErrorResume(error -> {
Map response = new HashMap<>();
response.put("success", false);
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandlerTest.java
new file mode 100644
index 0000000..59e2777
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/BookingSagaHandlerTest.java
@@ -0,0 +1,256 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.member.service.IMemberStoredCardService;
+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.Mono;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class BookingSagaHandlerTest {
+
+ @Mock
+ private IGroupCourseBookingRepository bookingRepository;
+
+ @Mock
+ private IMemberCardRecordService memberCardRecordService;
+
+ @Mock
+ private IMemberStoredCardService memberStoredCardService;
+
+ @Mock
+ private MemberCardRepository memberCardRepository;
+
+ private BookingSagaHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new BookingSagaHandler(bookingRepository, memberCardRecordService,
+ memberStoredCardService, memberCardRepository);
+ }
+
+ // ==================== executeBooking ====================
+
+ @Test
+ void executeBooking_shouldSucceedForStoredValueCard() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ MemberCardRecord record = createTestMemberCardRecord(50L, 100L, 1L);
+ MemberCard card = createTestMemberCard(1L, MemberCardType.STORED_VALUE_CARD.name());
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(50L)).thenReturn(Mono.just(record));
+ when(memberCardRepository.findById(1L)).thenReturn(Mono.just(card));
+ when(memberStoredCardService.consume(100L, BigDecimal.valueOf(50.0))).thenReturn(Mono.just(1));
+
+ Mono result = handler.executeBooking(booking, 50L, BigDecimal.valueOf(50.0));
+
+ GroupCourseBooking savedBooking = result.block();
+ assertThat(savedBooking).isNotNull();
+ assertThat(savedBooking.getId()).isEqualTo(1L);
+
+ verify(bookingRepository).save(booking);
+ verify(memberCardRecordService).findById(50L);
+ verify(memberCardRepository).findById(1L);
+ verify(memberStoredCardService).consume(100L, BigDecimal.valueOf(50.0));
+ }
+
+ @Test
+ void executeBooking_shouldFailWhenRecordNotFound() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(99L)).thenReturn(Mono.empty());
+
+ Mono result = handler.executeBooking(booking, 99L, BigDecimal.valueOf(50.0));
+
+ try {
+ result.block();
+ } catch (Exception e) {
+ assertThat(e.getMessage()).contains("会员卡记录不存在");
+ }
+
+ verify(bookingRepository).save(booking);
+ // Saga rollback 由于 error handler 传播链会调用多次 deleteBooking
+ verify(bookingRepository, atLeast(1)).deleteById(1L);
+ }
+
+ @Test
+ void executeBooking_shouldFailWhenCardNotBelongToMember() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ MemberCardRecord record = createTestMemberCardRecord(50L, 999L, 1L); // memberId mismatch
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(50L)).thenReturn(Mono.just(record));
+
+ Mono result = handler.executeBooking(booking, 50L, BigDecimal.valueOf(50.0));
+
+ try {
+ result.block();
+ } catch (Exception e) {
+ assertThat(e.getMessage()).contains("会员卡不归属当前用户");
+ }
+
+ verify(bookingRepository).save(booking);
+ verify(bookingRepository, atLeast(1)).deleteById(1L);
+ }
+
+ @Test
+ void executeBooking_shouldFailForCountCard() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ MemberCardRecord record = createTestMemberCardRecord(50L, 100L, 1L);
+ MemberCard card = createTestMemberCard(1L, MemberCardType.COUNT_CARD.name());
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(50L)).thenReturn(Mono.just(record));
+ when(memberCardRepository.findById(1L)).thenReturn(Mono.just(card));
+
+ Mono result = handler.executeBooking(booking, 50L, BigDecimal.valueOf(50.0));
+
+ try {
+ result.block();
+ } catch (Exception e) {
+ assertThat(e.getMessage()).contains("团课预约仅支持储值卡和时长卡支付");
+ }
+
+ verify(bookingRepository).save(booking);
+ verify(bookingRepository, atLeast(1)).deleteById(1L);
+ }
+
+ @Test
+ void executeBooking_shouldSucceedForTimeCard() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ MemberCardRecord record = createTestMemberCardRecord(50L, 100L, 1L);
+ record.setExpireTime(LocalDateTime.now().plusDays(30));
+ record.setStatus(MemberCardRecordStatus.ACTIVE);
+ MemberCard card = createTestMemberCard(1L, MemberCardType.TIME_CARD.name());
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(50L)).thenReturn(Mono.just(record));
+ when(memberCardRepository.findById(1L)).thenReturn(Mono.just(card));
+ when(memberStoredCardService.consume(100L, BigDecimal.valueOf(50.0))).thenReturn(Mono.just(1));
+
+ Mono result = handler.executeBooking(booking, 50L, BigDecimal.valueOf(50.0));
+
+ GroupCourseBooking savedBooking = result.block();
+ assertThat(savedBooking).isNotNull();
+
+ verify(bookingRepository).save(booking);
+ verify(memberCardRecordService).findById(50L);
+ verify(memberCardRepository).findById(1L);
+ verify(memberStoredCardService).consume(100L, BigDecimal.valueOf(50.0));
+ }
+
+ @Test
+ void executeBooking_shouldFailWhenTimeCardExpired() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ MemberCardRecord record = createTestMemberCardRecord(50L, 100L, 1L);
+ record.setExpireTime(LocalDateTime.now().minusDays(1));
+ record.setStatus(MemberCardRecordStatus.ACTIVE);
+ MemberCard card = createTestMemberCard(1L, MemberCardType.TIME_CARD.name());
+
+ when(bookingRepository.save(booking)).thenReturn(Mono.just(booking));
+ when(memberCardRecordService.findById(50L)).thenReturn(Mono.just(record));
+ when(memberCardRepository.findById(1L)).thenReturn(Mono.just(card));
+ // 需要 mock consume 避免 Saga 构造时 NPE
+ when(memberStoredCardService.consume(anyLong(), any())).thenReturn(Mono.just(1));
+
+ Mono result = handler.executeBooking(booking, 50L, BigDecimal.valueOf(50.0));
+
+ try {
+ result.block();
+ } catch (Exception e) {
+ assertThat(e.getMessage()).contains("已过期");
+ }
+
+ verify(bookingRepository).save(booking);
+ verify(bookingRepository, atLeast(1)).deleteById(1L);
+ }
+
+ // ==================== executeCancelBooking ====================
+
+ @Test
+ void executeCancelBooking_shouldSucceed() {
+ GroupCourseBooking booking = createTestBooking(1L, 100L, 10L);
+ booking.setStatus("1");
+
+ when(bookingRepository.updateStatus(1L, "1")).thenReturn(Mono.just(1));
+ when(memberStoredCardService.refundBalanceWithFee(100L, BigDecimal.valueOf(50.0), 1L))
+ .thenReturn(Mono.just(BigDecimal.valueOf(50.0)));
+ when(bookingRepository.findById(1L)).thenReturn(Mono.just(booking));
+
+ Mono result = handler.executeCancelBooking(1L, 10L, 50L, 100L, BigDecimal.valueOf(50.0), 1L);
+
+ GroupCourseBooking cancelledBooking = result.block();
+ assertThat(cancelledBooking).isNotNull();
+ assertThat(cancelledBooking.getStatus()).isEqualTo("1");
+
+ verify(bookingRepository).updateStatus(1L, "1");
+ verify(memberStoredCardService).refundBalanceWithFee(100L, BigDecimal.valueOf(50.0), 1L);
+ verify(bookingRepository).findById(1L);
+ }
+
+ @Test
+ void executeCancelBooking_shouldFailWhenUpdateStatusFails() {
+ when(bookingRepository.updateStatus(1L, "1")).thenReturn(Mono.just(0));
+ when(bookingRepository.findById(1L)).thenReturn(Mono.just(createTestBooking(1L, 100L, 10L)));
+ // 需要 mock refundBalanceWithFee 避免 SagaStep 构造时 NPE
+ when(memberStoredCardService.refundBalanceWithFee(anyLong(), any(), anyLong()))
+ .thenReturn(Mono.just(BigDecimal.ZERO));
+
+ Mono result = handler.executeCancelBooking(1L, 10L, 50L, 100L, BigDecimal.valueOf(50.0), 1L);
+
+ try {
+ result.block();
+ } catch (Exception e) {
+ assertThat(e.getMessage()).contains("更新预约状态失败");
+ }
+
+ verify(bookingRepository).updateStatus(1L, "1");
+ }
+
+ // ==================== helper ====================
+
+ private GroupCourseBooking createTestBooking(Long id, Long memberId, Long courseId) {
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setId(id);
+ booking.setMemberId(memberId);
+ booking.setCourseId(courseId);
+ booking.setStatus("0");
+ return booking;
+ }
+
+ private MemberCardRecord createTestMemberCardRecord(Long id, Long memberId, Long memberCardId) {
+ MemberCardRecord record = new MemberCardRecord();
+ record.setId(id);
+ record.setMemberId(memberId);
+ record.setMemberCardId(memberCardId);
+ record.setStatus(MemberCardRecordStatus.ACTIVE);
+ record.setExpireTime(LocalDateTime.now().plusDays(30));
+ return record;
+ }
+
+ private MemberCard createTestMemberCard(Long memberCardId, String cardType) {
+ return MemberCard.builder()
+ .memberCardId(memberCardId)
+ .memberCardType(cardType)
+ .memberCardName("测试卡")
+ .build();
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/CourseLabelHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/CourseLabelHandlerTest.java
new file mode 100644
index 0000000..625509d
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/CourseLabelHandlerTest.java
@@ -0,0 +1,471 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
+import cn.novalon.gym.manage.groupcourse.service.ICourseLabelService;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class CourseLabelHandlerTest {
+
+ @Mock
+ private ICourseLabelService courseLabelService;
+
+ private CourseLabelHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new CourseLabelHandler(courseLabelService);
+ }
+
+ // ==================== getAllLabels ====================
+
+ @Test
+ void getAllLabels_shouldReturnOk() {
+ CourseLabel label1 = new CourseLabel();
+ label1.setId(1L);
+ label1.setLabelName("适合新手");
+ CourseLabel label2 = new CourseLabel();
+ label2.setId(2L);
+ label2.setLabelName("高强度");
+ when(courseLabelService.findAll()).thenReturn(Flux.just(label1, label2));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllLabels(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).findAll();
+ }
+
+ @Test
+ void getAllLabels_shouldReturnOkWhenEmpty() {
+ when(courseLabelService.findAll()).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllLabels(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getLabelsByPage ====================
+
+ @Test
+ void getLabelsByPage_shouldReturnOk() {
+ PageRequest pageRequest = new PageRequest();
+ PageResponse pageResponse = new PageResponse<>();
+ when(courseLabelService.findByPage(any(PageRequest.class))).thenReturn(Mono.just(pageResponse));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(pageRequest));
+ Mono result = handler.getLabelsByPage(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).findByPage(any(PageRequest.class));
+ }
+
+ // ==================== getLabelById ====================
+
+ @Test
+ void getLabelById_shouldReturnOkWhenFound() {
+ CourseLabel label = new CourseLabel();
+ label.setId(1L);
+ label.setLabelName("适合新手");
+ when(courseLabelService.findById(1L)).thenReturn(Mono.just(label));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.getLabelById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).findById(1L);
+ }
+
+ @Test
+ void getLabelById_shouldReturnNotFound() {
+ when(courseLabelService.findById(999L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "999")
+ .build();
+ Mono result = handler.getLabelById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+ }
+
+ // ==================== searchLabels ====================
+
+ @Test
+ void searchLabels_shouldReturnOk() {
+ CourseLabel label = new CourseLabel();
+ label.setId(1L);
+ label.setLabelName("新手");
+ when(courseLabelService.findByKeyword("新手")).thenReturn(Flux.just(label));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("keyword", "新手")
+ .build();
+ Mono result = handler.searchLabels(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).findByKeyword("新手");
+ }
+
+ @Test
+ void searchLabels_shouldReturnOkWhenEmpty() {
+ when(courseLabelService.findByKeyword("")).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.searchLabels(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== createLabel ====================
+
+ @Test
+ void createLabel_shouldReturnOk() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("适合新手");
+ label.setColor("#52c41a");
+ CourseLabel created = new CourseLabel();
+ created.setId(1L);
+ created.setLabelName("适合新手");
+ created.setColor("#52c41a");
+ when(courseLabelService.create(any(CourseLabel.class))).thenReturn(Mono.just(created));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).create(any(CourseLabel.class));
+ }
+
+ @Test
+ void createLabel_shouldReturn400WhenNameEmpty() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("");
+ label.setColor("#52c41a");
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).create(any());
+ }
+
+ @Test
+ void createLabel_shouldReturn400WhenNameNull() {
+ CourseLabel label = new CourseLabel();
+ label.setColor("#52c41a");
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).create(any());
+ }
+
+ @Test
+ void createLabel_shouldReturn400WhenNameTooLong() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("a".repeat(51));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).create(any());
+ }
+
+ @Test
+ void createLabel_shouldSetDefaultColorWhenColorEmpty() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("适合新手");
+ CourseLabel created = new CourseLabel();
+ created.setId(1L);
+ created.setLabelName("适合新手");
+ created.setColor("#1890ff");
+ when(courseLabelService.create(any(CourseLabel.class))).thenReturn(Mono.just(created));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ @Test
+ void createLabel_shouldReturn400WhenServiceError() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("适合新手");
+ when(courseLabelService.create(any(CourseLabel.class)))
+ .thenReturn(Mono.error(new RuntimeException("标签已存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(label));
+ Mono result = handler.createLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== updateLabel ====================
+
+ @Test
+ void updateLabel_shouldReturnOk() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("适合进阶");
+ CourseLabel updated = new CourseLabel();
+ updated.setId(1L);
+ updated.setLabelName("适合进阶");
+ when(courseLabelService.update(eq(1L), any(CourseLabel.class))).thenReturn(Mono.just(updated));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(label));
+ Mono result = handler.updateLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).update(eq(1L), any(CourseLabel.class));
+ }
+
+ @Test
+ void updateLabel_shouldReturn400WhenNameTooLong() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("a".repeat(51));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(label));
+ Mono result = handler.updateLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).update(anyLong(), any());
+ }
+
+ @Test
+ void updateLabel_shouldReturn400WhenServiceError() {
+ CourseLabel label = new CourseLabel();
+ label.setLabelName("适合进阶");
+ when(courseLabelService.update(eq(1L), any(CourseLabel.class)))
+ .thenReturn(Mono.error(new RuntimeException("标签不存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(label));
+ Mono result = handler.updateLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== deleteLabel ====================
+
+ @Test
+ void deleteLabel_shouldReturnOk() {
+ when(courseLabelService.delete(1L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).delete(1L);
+ }
+
+ @Test
+ void deleteLabel_shouldReturn400WhenServiceError() {
+ when(courseLabelService.delete(1L)).thenReturn(Mono.error(new RuntimeException("删除失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteLabel(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== getLabelsByTypeId ====================
+
+ @Test
+ void getLabelsByTypeId_shouldReturnOk() {
+ CourseLabel label = new CourseLabel();
+ label.setId(1L);
+ label.setLabelName("适合新手");
+ when(courseLabelService.findByTypeId(1L)).thenReturn(Flux.just(label));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .build();
+ Mono result = handler.getLabelsByTypeId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).findByTypeId(1L);
+ }
+
+ @Test
+ void getLabelsByTypeId_shouldReturnOkWhenEmpty() {
+ when(courseLabelService.findByTypeId(1L)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .build();
+ Mono result = handler.getLabelsByTypeId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== addLabelsToType ====================
+
+ @Test
+ void addLabelsToType_shouldReturnOk() {
+ when(courseLabelService.addLabelsToType(1L, List.of(1L, 2L))).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .body(Mono.just(Map.of("labelIds", List.of(1L, 2L))));
+ Mono result = handler.addLabelsToType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).addLabelsToType(1L, List.of(1L, 2L));
+ }
+
+ @Test
+ void addLabelsToType_shouldReturn400WhenLabelIdsEmpty() {
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .body(Mono.just(Map.of("labelIds", List.of())));
+ Mono result = handler.addLabelsToType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).addLabelsToType(anyLong(), anyList());
+ }
+
+ @Test
+ void addLabelsToType_shouldReturn400WhenLabelIdsNull() {
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .body(Mono.just(Map.of()));
+ Mono result = handler.addLabelsToType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(courseLabelService, never()).addLabelsToType(anyLong(), anyList());
+ }
+
+ @Test
+ void addLabelsToType_shouldReturn400WhenServiceError() {
+ when(courseLabelService.addLabelsToType(1L, List.of(1L))).thenReturn(Mono.error(new RuntimeException("添加失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .body(Mono.just(Map.of("labelIds", List.of(1L))));
+ Mono result = handler.addLabelsToType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== removeLabelFromType ====================
+
+ @Test
+ void removeLabelFromType_shouldReturnOk() {
+ when(courseLabelService.removeLabelFromType(1L, 1L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .pathVariable("labelId", "1")
+ .build();
+ Mono result = handler.removeLabelFromType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).removeLabelFromType(1L, 1L);
+ }
+
+ @Test
+ void removeLabelFromType_shouldReturn400WhenServiceError() {
+ when(courseLabelService.removeLabelFromType(1L, 1L)).thenReturn(Mono.error(new RuntimeException("移除失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .pathVariable("labelId", "1")
+ .build();
+ Mono result = handler.removeLabelFromType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== clearLabelsFromType ====================
+
+ @Test
+ void clearLabelsFromType_shouldReturnOk() {
+ when(courseLabelService.clearLabelsFromType(1L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .build();
+ Mono result = handler.clearLabelsFromType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(courseLabelService).clearLabelsFromType(1L);
+ }
+
+ @Test
+ void clearLabelsFromType_shouldReturn400WhenServiceError() {
+ when(courseLabelService.clearLabelsFromType(1L)).thenReturn(Mono.error(new RuntimeException("清空失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("typeId", "1")
+ .build();
+ Mono result = handler.clearLabelsFromType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandlerTest.java
new file mode 100644
index 0000000..d47c6c5
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseBookingHandlerTest.java
@@ -0,0 +1,214 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseBookingHandlerTest {
+
+ @Mock
+ private IGroupCourseBookingService bookingService;
+
+ private GroupCourseBookingHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new GroupCourseBookingHandler(bookingService);
+ }
+
+ // ==================== bookCourse ====================
+
+ @Test
+ void bookCourse_shouldReturnOk() {
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setId(1L);
+ booking.setCourseId(10L);
+ booking.setMemberId(100L);
+ when(bookingService.bookCourse(10L, 100L)).thenReturn(Mono.just(booking));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(Map.of("courseId", 10L, "memberId", 100L)));
+ Mono result = handler.bookCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(bookingService).bookCourse(10L, 100L);
+ }
+
+ @Test
+ void bookCourse_shouldReturn400WhenCourseIdMissing() {
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(Map.of("memberId", 100L)));
+ Mono result = handler.bookCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(bookingService, never()).bookCourse(anyLong(), anyLong());
+ }
+
+ @Test
+ void bookCourse_shouldReturn400WhenMemberIdMissing() {
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(Map.of("courseId", 10L)));
+ Mono result = handler.bookCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(bookingService, never()).bookCourse(anyLong(), anyLong());
+ }
+
+ @Test
+ void bookCourse_shouldReturn400WhenServiceError() {
+ when(bookingService.bookCourse(10L, 100L)).thenReturn(Mono.error(new RuntimeException("预约失败，课程已满")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(Map.of("courseId", 10L, "memberId", 100L)));
+ Mono result = handler.bookCourse(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== cancelBooking ====================
+
+ @Test
+ void cancelBooking_shouldReturnOk() {
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setId(1L);
+ booking.setStatus("1");
+ when(bookingService.cancelBooking(1L, 100L)).thenReturn(Mono.just(booking));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("bookingId", "1")
+ .body(Mono.just(Map.of("memberId", 100L)));
+ Mono result = handler.cancelBooking(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(bookingService).cancelBooking(1L, 100L);
+ }
+
+ @Test
+ void cancelBooking_shouldReturn400WhenServiceError() {
+ when(bookingService.cancelBooking(1L, 100L)).thenReturn(Mono.error(new RuntimeException("取消失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("bookingId", "1")
+ .body(Mono.just(Map.of("memberId", 100L)));
+ Mono result = handler.cancelBooking(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== getBookingsByMemberId ====================
+
+ @Test
+ void getBookingsByMemberId_shouldReturnOk() {
+ GroupCourseBooking b1 = new GroupCourseBooking();
+ b1.setId(1L);
+ GroupCourseBooking b2 = new GroupCourseBooking();
+ b2.setId(2L);
+ when(bookingService.getBookingsByMemberId(100L)).thenReturn(Flux.just(b1, b2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", "100")
+ .build();
+ Mono result = handler.getBookingsByMemberId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(bookingService).getBookingsByMemberId(100L);
+ }
+
+ @Test
+ void getBookingsByMemberId_shouldReturnOkWhenEmpty() {
+ when(bookingService.getBookingsByMemberId(999L)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", "999")
+ .build();
+ Mono result = handler.getBookingsByMemberId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getBookingById ====================
+
+ @Test
+ void getBookingById_shouldReturnOkWhenFound() {
+ GroupCourseBooking booking = new GroupCourseBooking();
+ booking.setId(1L);
+ when(bookingService.getBookingById(1L)).thenReturn(Mono.just(booking));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("bookingId", "1")
+ .build();
+ Mono result = handler.getBookingById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(bookingService).getBookingById(1L);
+ }
+
+ @Test
+ void getBookingById_shouldReturnNotFound() {
+ when(bookingService.getBookingById(999L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("bookingId", "999")
+ .build();
+ Mono result = handler.getBookingById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+ }
+
+ // ==================== getBookingsByCourseId ====================
+
+ @Test
+ void getBookingsByCourseId_shouldReturnOk() {
+ GroupCourseBooking b1 = new GroupCourseBooking();
+ b1.setId(1L);
+ when(bookingService.getBookingsByCourseId(10L)).thenReturn(Flux.just(b1));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "10")
+ .build();
+ Mono result = handler.getBookingsByCourseId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(bookingService).getBookingsByCourseId(10L);
+ }
+
+ @Test
+ void getBookingsByCourseId_shouldReturnOkWhenEmpty() {
+ when(bookingService.getBookingsByCourseId(999L)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "999")
+ .build();
+ Mono result = handler.getBookingsByCourseId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandlerTest.java
index c38a92a..cc55cc0 100644
--- a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandlerTest.java
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseHandlerTest.java
@@ -195,10 +195,10 @@ class GroupCourseHandlerTest {
@Test
void signIn_shouldReturnOk() {
GroupCourse course = createTestCourse(1L, "瑜伽课");
- when(validator.validate(any())).thenReturn(java.util.Collections.emptySet());
when(groupCourseService.signIn(eq(1L), eq(10001L))).thenReturn(Mono.just(course));
MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", "10001")
.pathVariable("courseId", "1")
.body(Mono.just(java.util.Map.of("memberId", 10001L, "courseId", 1L)));
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseRecommendHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseRecommendHandlerTest.java
new file mode 100644
index 0000000..74d23ca
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseRecommendHandlerTest.java
@@ -0,0 +1,357 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseRecommendService;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseRecommendHandlerTest {
+
+ @Mock
+ private IGroupCourseRecommendService recommendService;
+
+ private GroupCourseRecommendHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new GroupCourseRecommendHandler(recommendService);
+ }
+
+ // ==================== getAllRecommendations ====================
+
+ @Test
+ void getAllRecommendations_shouldReturnOk() {
+ GroupCourseRecommend r1 = new GroupCourseRecommend();
+ r1.setId(1L);
+ r1.setRecommendTitle("本周热门");
+ GroupCourseRecommend r2 = new GroupCourseRecommend();
+ r2.setId(2L);
+ r2.setRecommendTitle("新课程推荐");
+ when(recommendService.findAll("priority", "desc")).thenReturn(Flux.just(r1, r2));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllRecommendations(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).findAll("priority", "desc");
+ }
+
+ @Test
+ void getAllRecommendations_shouldRespectSortParams() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ when(recommendService.findAll("id", "asc")).thenReturn(Flux.just(r));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("sortBy", "id")
+ .queryParam("sortOrder", "asc")
+ .build();
+ Mono result = handler.getAllRecommendations(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).findAll("id", "asc");
+ }
+
+ @Test
+ void getAllRecommendations_shouldReturnOkWhenEmpty() {
+ when(recommendService.findAll("priority", "desc")).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllRecommendations(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getAllActiveRecommendations ====================
+
+ @Test
+ void getAllActiveRecommendations_shouldReturnOk() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ r.setIsActive(true);
+ when(recommendService.findAllActive()).thenReturn(Flux.just(r));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllActiveRecommendations(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).findAllActive();
+ }
+
+ @Test
+ void getAllActiveRecommendations_shouldReturnOkWhenEmpty() {
+ when(recommendService.findAllActive()).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllActiveRecommendations(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getRecommendationById ====================
+
+ @Test
+ void getRecommendationById_shouldReturnOkWhenFound() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ r.setRecommendTitle("本周热门");
+ when(recommendService.findById(1L)).thenReturn(Mono.just(r));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.getRecommendationById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).findById(1L);
+ }
+
+ @Test
+ void getRecommendationById_shouldReturnNotFound() {
+ when(recommendService.findById(999L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "999")
+ .build();
+ Mono result = handler.getRecommendationById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+ }
+
+ // ==================== getRecommendationsByCourseId ====================
+
+ @Test
+ void getRecommendationsByCourseId_shouldReturnOk() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ r.setCourseId(10L);
+ when(recommendService.findByCourseId(10L)).thenReturn(Flux.just(r));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "10")
+ .build();
+ Mono result = handler.getRecommendationsByCourseId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).findByCourseId(10L);
+ }
+
+ @Test
+ void getRecommendationsByCourseId_shouldReturnOkWhenEmpty() {
+ when(recommendService.findByCourseId(999L)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("courseId", "999")
+ .build();
+ Mono result = handler.getRecommendationsByCourseId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== createRecommendation ====================
+
+ @Test
+ void createRecommendation_shouldReturnOk() {
+ GroupCourseRecommend recommend = new GroupCourseRecommend();
+ recommend.setCourseId(10L);
+ recommend.setRecommendTitle("本周热门");
+ recommend.setPriority(10);
+ GroupCourseRecommend created = new GroupCourseRecommend();
+ created.setId(1L);
+ created.setCourseId(10L);
+ created.setRecommendTitle("本周热门");
+ created.setPriority(10);
+ when(recommendService.create(any(GroupCourseRecommend.class))).thenReturn(Mono.just(created));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(recommend));
+ Mono result = handler.createRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).create(any(GroupCourseRecommend.class));
+ }
+
+ @Test
+ void createRecommendation_shouldReturn400WhenCourseIdNull() {
+ GroupCourseRecommend recommend = new GroupCourseRecommend();
+ recommend.setRecommendTitle("本周热门");
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(recommend));
+ Mono result = handler.createRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(recommendService, never()).create(any());
+ }
+
+ @Test
+ void createRecommendation_shouldReturn400WhenServiceError() {
+ GroupCourseRecommend recommend = new GroupCourseRecommend();
+ recommend.setCourseId(10L);
+ when(recommendService.create(any(GroupCourseRecommend.class)))
+ .thenReturn(Mono.error(new RuntimeException("推荐已存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(recommend));
+ Mono result = handler.createRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== updateRecommendation ====================
+
+ @Test
+ void updateRecommendation_shouldReturnOk() {
+ GroupCourseRecommend recommend = new GroupCourseRecommend();
+ recommend.setRecommendTitle("更新推荐");
+ GroupCourseRecommend updated = new GroupCourseRecommend();
+ updated.setId(1L);
+ updated.setRecommendTitle("更新推荐");
+ when(recommendService.update(eq(1L), any(GroupCourseRecommend.class))).thenReturn(Mono.just(updated));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(recommend));
+ Mono result = handler.updateRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).update(eq(1L), any(GroupCourseRecommend.class));
+ }
+
+ @Test
+ void updateRecommendation_shouldReturn400WhenServiceError() {
+ GroupCourseRecommend recommend = new GroupCourseRecommend();
+ recommend.setRecommendTitle("更新推荐");
+ when(recommendService.update(eq(1L), any(GroupCourseRecommend.class)))
+ .thenReturn(Mono.error(new RuntimeException("推荐不存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(recommend));
+ Mono result = handler.updateRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== deleteRecommendation ====================
+
+ @Test
+ void deleteRecommendation_shouldReturnOk() {
+ when(recommendService.delete(1L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).delete(1L);
+ }
+
+ @Test
+ void deleteRecommendation_shouldReturn400WhenServiceError() {
+ when(recommendService.delete(1L)).thenReturn(Mono.error(new RuntimeException("删除失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== enableRecommendation ====================
+
+ @Test
+ void enableRecommendation_shouldReturnOk() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ r.setIsActive(true);
+ when(recommendService.enable(1L)).thenReturn(Mono.just(r));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.enableRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).enable(1L);
+ }
+
+ @Test
+ void enableRecommendation_shouldReturn400WhenServiceError() {
+ when(recommendService.enable(1L)).thenReturn(Mono.error(new RuntimeException("启用失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.enableRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== disableRecommendation ====================
+
+ @Test
+ void disableRecommendation_shouldReturnOk() {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(1L);
+ r.setIsActive(false);
+ when(recommendService.disable(1L)).thenReturn(Mono.just(r));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.disableRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(recommendService).disable(1L);
+ }
+
+ @Test
+ void disableRecommendation_shouldReturn400WhenServiceError() {
+ when(recommendService.disable(1L)).thenReturn(Mono.error(new RuntimeException("禁用失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.disableRecommendation(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseTypeHandlerTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseTypeHandlerTest.java
new file mode 100644
index 0000000..ee4e7d8
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/handler/GroupCourseTypeHandlerTest.java
@@ -0,0 +1,375 @@
+package cn.novalon.gym.manage.groupcourse.handler;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseTypeService;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseTypeHandlerTest {
+
+ @Mock
+ private IGroupCourseTypeService groupCourseTypeService;
+
+ private GroupCourseTypeHandler handler;
+
+ @BeforeEach
+ void setUp() {
+ handler = new GroupCourseTypeHandler(groupCourseTypeService);
+ }
+
+ // ==================== getAllGroupCourseTypes ====================
+
+ @Test
+ void getAllGroupCourseTypes_shouldReturnOk() {
+ GroupCourseType type1 = new GroupCourseType();
+ type1.setId(1L);
+ type1.setTypeName("瑜伽入门");
+ GroupCourseType type2 = new GroupCourseType();
+ type2.setId(2L);
+ type2.setTypeName("力量训练");
+ when(groupCourseTypeService.findAll(false)).thenReturn(Flux.just(type1, type2));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllGroupCourseTypes(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findAll(false);
+ }
+
+ @Test
+ void getAllGroupCourseTypes_shouldIncludeDeletedWhenParamSet() {
+ GroupCourseType type = new GroupCourseType();
+ type.setId(1L);
+ type.setTypeName("测试");
+ when(groupCourseTypeService.findAll(true)).thenReturn(Flux.just(type));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("includeDeleted", "true")
+ .build();
+ Mono result = handler.getAllGroupCourseTypes(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findAll(true);
+ }
+
+ @Test
+ void getAllGroupCourseTypes_shouldReturnOkWhenEmpty() {
+ when(groupCourseTypeService.findAll(false)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getAllGroupCourseTypes(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getGroupCourseTypeById ====================
+
+ @Test
+ void getGroupCourseTypeById_shouldReturnOkWhenFound() {
+ GroupCourseType type = new GroupCourseType();
+ type.setId(1L);
+ type.setTypeName("瑜伽入门");
+ when(groupCourseTypeService.findById(1L)).thenReturn(Mono.just(type));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.getGroupCourseTypeById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findById(1L);
+ }
+
+ @Test
+ void getGroupCourseTypeById_shouldReturnNotFound() {
+ when(groupCourseTypeService.findById(999L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "999")
+ .build();
+ Mono result = handler.getGroupCourseTypeById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+ }
+
+ // ==================== searchGroupCourseTypes ====================
+
+ @Test
+ void searchGroupCourseTypes_shouldReturnOk() {
+ GroupCourseType type = new GroupCourseType();
+ type.setId(1L);
+ type.setTypeName("瑜伽");
+ when(groupCourseTypeService.findByKeyword("瑜伽")).thenReturn(Flux.just(type));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("keyword", "瑜伽")
+ .build();
+ Mono result = handler.searchGroupCourseTypes(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findByKeyword("瑜伽");
+ }
+
+ @Test
+ void searchGroupCourseTypes_shouldReturnOkWhenEmpty() {
+ when(groupCourseTypeService.findByKeyword("")).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.searchGroupCourseTypes(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== getGroupCourseTypesByCategory ====================
+
+ @Test
+ void getGroupCourseTypesByCategory_shouldReturnOk() {
+ GroupCourseType type = new GroupCourseType();
+ type.setId(1L);
+ type.setTypeName("瑜伽入门");
+ when(groupCourseTypeService.findByCategoryAndKeyword("柔韧与平衡类", "")).thenReturn(Flux.just(type));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("category", "柔韧与平衡类")
+ .build();
+ Mono result = handler.getGroupCourseTypesByCategory(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findByCategoryAndKeyword("柔韧与平衡类", "");
+ }
+
+ @Test
+ void getGroupCourseTypesByCategory_shouldReturnOkWithKeyword() {
+ GroupCourseType type = new GroupCourseType();
+ type.setId(1L);
+ type.setTypeName("瑜伽入门");
+ when(groupCourseTypeService.findByCategoryAndKeyword("柔韧与平衡类", "瑜伽")).thenReturn(Flux.just(type));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("category", "柔韧与平衡类")
+ .queryParam("keyword", "瑜伽")
+ .build();
+ Mono result = handler.getGroupCourseTypesByCategory(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findByCategoryAndKeyword("柔韧与平衡类", "瑜伽");
+ }
+
+ // ==================== getCategories ====================
+
+ @Test
+ void getCategories_shouldReturnOk() {
+ when(groupCourseTypeService.findCategories()).thenReturn(Flux.just("有氧类", "力量类", "柔韧与平衡类"));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getCategories(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findCategories();
+ }
+
+ @Test
+ void getCategories_shouldReturnOkWhenEmpty() {
+ when(groupCourseTypeService.findCategories()).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getCategories(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ // ==================== createGroupCourseType ====================
+
+ @Test
+ void createGroupCourseType_shouldReturnOk() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("瑜伽入门");
+ type.setBaseDifficulty(2);
+ GroupCourseType created = new GroupCourseType();
+ created.setId(1L);
+ created.setTypeName("瑜伽入门");
+ created.setBaseDifficulty(2);
+ when(groupCourseTypeService.create(any(GroupCourseType.class))).thenReturn(Mono.just(created));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(type));
+ Mono result = handler.createGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).create(any(GroupCourseType.class));
+ }
+
+ @Test
+ void createGroupCourseType_shouldReturn400WhenNameEmpty() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("");
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(type));
+ Mono result = handler.createGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(groupCourseTypeService, never()).create(any());
+ }
+
+ @Test
+ void createGroupCourseType_shouldReturn400WhenNameNull() {
+ GroupCourseType type = new GroupCourseType();
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(type));
+ Mono result = handler.createGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ verify(groupCourseTypeService, never()).create(any());
+ }
+
+ @Test
+ void createGroupCourseType_shouldSetDefaultDifficulty() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("瑜伽入门");
+ GroupCourseType created = new GroupCourseType();
+ created.setId(1L);
+ created.setTypeName("瑜伽入门");
+ created.setBaseDifficulty(1);
+ when(groupCourseTypeService.create(any(GroupCourseType.class))).thenReturn(Mono.just(created));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(type));
+ Mono result = handler.createGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ }
+
+ @Test
+ void createGroupCourseType_shouldReturn400WhenServiceError() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("瑜伽入门");
+ when(groupCourseTypeService.create(any(GroupCourseType.class)))
+ .thenReturn(Mono.error(new RuntimeException("类型已存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(type));
+ Mono result = handler.createGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== updateGroupCourseType ====================
+
+ @Test
+ void updateGroupCourseType_shouldReturnOk() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("瑜伽进阶");
+ type.setBaseDifficulty(4);
+ GroupCourseType updated = new GroupCourseType();
+ updated.setId(1L);
+ updated.setTypeName("瑜伽进阶");
+ updated.setBaseDifficulty(4);
+ when(groupCourseTypeService.update(eq(1L), any(GroupCourseType.class))).thenReturn(Mono.just(updated));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(type));
+ Mono result = handler.updateGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).update(eq(1L), any(GroupCourseType.class));
+ }
+
+ @Test
+ void updateGroupCourseType_shouldReturn400WhenServiceError() {
+ GroupCourseType type = new GroupCourseType();
+ type.setTypeName("瑜伽进阶");
+ when(groupCourseTypeService.update(eq(1L), any(GroupCourseType.class)))
+ .thenReturn(Mono.error(new RuntimeException("类型不存在")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(type));
+ Mono result = handler.updateGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== deleteGroupCourseType ====================
+
+ @Test
+ void deleteGroupCourseType_shouldReturnOk() {
+ when(groupCourseTypeService.delete(1L)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).delete(1L);
+ }
+
+ @Test
+ void deleteGroupCourseType_shouldReturn400WhenServiceError() {
+ when(groupCourseTypeService.delete(1L)).thenReturn(Mono.error(new RuntimeException("删除失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+ Mono result = handler.deleteGroupCourseType(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+ }
+
+ // ==================== getGroupCourseTypesByPage ====================
+
+ @Test
+ void getGroupCourseTypesByPage_shouldReturnOk() {
+ PageRequest pageRequest = new PageRequest();
+ PageResponse pageResponse = new PageResponse<>();
+ when(groupCourseTypeService.findByPage(any(PageRequest.class))).thenReturn(Mono.just(pageResponse));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(pageRequest));
+ Mono result = handler.getGroupCourseTypesByPage(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+ verify(groupCourseTypeService).findByPage(any(PageRequest.class));
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/CourseLabelServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/CourseLabelServiceTest.java
new file mode 100644
index 0000000..61260d9
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/CourseLabelServiceTest.java
@@ -0,0 +1,434 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.repository.ICourseLabelRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+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.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CourseLabelServiceTest {
+
+ @Mock
+ private ICourseLabelRepository courseLabelRepository;
+
+ @Mock
+ private IGroupCourseRepository groupCourseRepository;
+
+ @Mock
+ private RedisUtil redisUtil;
+
+ private CourseLabelService courseLabelService;
+
+ @BeforeEach
+ void setUp() {
+ courseLabelService = new CourseLabelService(courseLabelRepository, groupCourseRepository, redisUtil);
+ }
+
+ // ==================== findById ====================
+
+ @Test
+ void findById_shouldReturnLabel() {
+ CourseLabel label = new CourseLabel();
+ label.setId(1L);
+ label.setLabelName("适合新手");
+ when(courseLabelRepository.findById(1L)).thenReturn(Mono.just(label));
+
+ StepVerifier.create(courseLabelService.findById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getLabelName()).isEqualTo("适合新手");
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).findById(1L);
+ }
+
+ @Test
+ void findById_shouldReturnEmptyWhenNotFound() {
+ when(courseLabelRepository.findById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(courseLabelService.findById(999L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).findById(999L);
+ }
+
+ // ==================== findAll ====================
+
+ @Test
+ void findAll_shouldReturnAllLabels() {
+ CourseLabel label1 = new CourseLabel();
+ label1.setId(1L);
+ label1.setLabelName("适合新手");
+ CourseLabel label2 = new CourseLabel();
+ label2.setId(2L);
+ label2.setLabelName("高强度");
+ when(courseLabelRepository.findAll()).thenReturn(Flux.just(label1, label2));
+
+ StepVerifier.create(courseLabelService.findAll())
+ .assertNext(result -> assertThat(result.getLabelName()).isEqualTo("适合新手"))
+ .assertNext(result -> assertThat(result.getLabelName()).isEqualTo("高强度"))
+ .verifyComplete();
+
+ verify(courseLabelRepository).findAll();
+ }
+
+ @Test
+ void findAll_shouldReturnEmptyWhenNoLabels() {
+ when(courseLabelRepository.findAll()).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.findAll())
+ .verifyComplete();
+
+ verify(courseLabelRepository).findAll();
+ }
+
+ // ==================== findByKeyword ====================
+
+ @Test
+ void findByKeyword_shouldReturnMatchingLabels() {
+ CourseLabel label = new CourseLabel();
+ label.setId(1L);
+ label.setLabelName("适合新手");
+ when(courseLabelRepository.findByKeyword("新手")).thenReturn(Flux.just(label));
+
+ StepVerifier.create(courseLabelService.findByKeyword("新手"))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getLabelName()).isEqualTo("适合新手");
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByKeyword("新手");
+ }
+
+ @Test
+ void findByKeyword_shouldReturnEmptyWhenNoMatch() {
+ when(courseLabelRepository.findByKeyword("不存在")).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.findByKeyword("不存在"))
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByKeyword("不存在");
+ }
+
+ // ==================== create ====================
+
+ @Test
+ void create_shouldSaveWhenNameNotExists() {
+ CourseLabel input = new CourseLabel();
+ input.setLabelName("适合新手");
+ input.setColor("#52c41a");
+
+ CourseLabel saved = new CourseLabel();
+ saved.setId(1L);
+ saved.setLabelName("适合新手");
+ saved.setColor("#52c41a");
+
+ when(courseLabelRepository.findByLabelName("适合新手")).thenReturn(Mono.empty());
+ when(courseLabelRepository.save(any(CourseLabel.class))).thenReturn(Mono.just(saved));
+
+ StepVerifier.create(courseLabelService.create(input))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getLabelName()).isEqualTo("适合新手");
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByLabelName("适合新手");
+ verify(courseLabelRepository).save(any(CourseLabel.class));
+ }
+
+ @Test
+ void create_shouldErrorWhenNameAlreadyExists() {
+ CourseLabel existing = new CourseLabel();
+ existing.setId(1L);
+ existing.setLabelName("适合新手");
+
+ CourseLabel input = new CourseLabel();
+ input.setLabelName("适合新手");
+
+ when(courseLabelRepository.findByLabelName("适合新手")).thenReturn(Mono.just(existing));
+ // switchIfEmpty 是急切求值的，需要为 save 提供 stub 避免 NPE
+ lenient().when(courseLabelRepository.save(any(CourseLabel.class))).thenReturn(Mono.just(new CourseLabel()));
+
+ StepVerifier.create(courseLabelService.create(input))
+ .expectErrorMatches(throwable ->
+ throwable instanceof RuntimeException &&
+ "标签名称已存在".equals(throwable.getMessage()))
+ .verify();
+
+ verify(courseLabelRepository).findByLabelName("适合新手");
+ // switchIfEmpty 是急切求值的，save 会被调用但不会影响结果
+ }
+
+ // ==================== update ====================
+
+ @Test
+ void update_shouldUpdateLabel() {
+ CourseLabel input = new CourseLabel();
+ input.setLabelName("适合进阶");
+
+ CourseLabel updated = new CourseLabel();
+ updated.setId(1L);
+ updated.setLabelName("适合进阶");
+
+ when(courseLabelRepository.update(any(CourseLabel.class))).thenReturn(Mono.just(updated));
+
+ StepVerifier.create(courseLabelService.update(1L, input))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getLabelName()).isEqualTo("适合进阶");
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).update(any(CourseLabel.class));
+ }
+
+ @Test
+ void update_shouldSetIdOnInput() {
+ CourseLabel input = new CourseLabel();
+ input.setLabelName("适合进阶");
+
+ when(courseLabelRepository.update(any(CourseLabel.class))).thenAnswer(invocation -> {
+ CourseLabel arg = invocation.getArgument(0);
+ return Mono.just(arg);
+ });
+
+ StepVerifier.create(courseLabelService.update(1L, input))
+ .assertNext(result -> assertThat(result.getId()).isEqualTo(1L))
+ .verifyComplete();
+ }
+
+ // ==================== delete ====================
+
+ @Test
+ void delete_shouldDeleteLabel() {
+ when(courseLabelRepository.deleteById(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(courseLabelService.delete(1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).deleteById(1L);
+ }
+
+ @Test
+ void delete_shouldCompleteWhenNotFound() {
+ when(courseLabelRepository.deleteById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(courseLabelService.delete(999L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).deleteById(999L);
+ }
+
+ // ==================== findByTypeId ====================
+
+ @Test
+ void findByTypeId_shouldReturnLabelsForType() {
+ CourseLabel label1 = new CourseLabel();
+ label1.setId(1L);
+ label1.setLabelName("适合新手");
+ CourseLabel label2 = new CourseLabel();
+ label2.setId(2L);
+ label2.setLabelName("减脂塑形");
+
+ when(courseLabelRepository.findByTypeId(1L)).thenReturn(Flux.just(label1, label2));
+
+ StepVerifier.create(courseLabelService.findByTypeId(1L))
+ .assertNext(result -> assertThat(result.getLabelName()).isEqualTo("适合新手"))
+ .assertNext(result -> assertThat(result.getLabelName()).isEqualTo("减脂塑形"))
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByTypeId(1L);
+ }
+
+ @Test
+ void findByTypeId_shouldReturnEmptyWhenNoLabels() {
+ when(courseLabelRepository.findByTypeId(1L)).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.findByTypeId(1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByTypeId(1L);
+ }
+
+ // ==================== addLabelsToType ====================
+
+ @Test
+ void addLabelsToType_shouldAddLabelsAndInvalidateCache() {
+ when(courseLabelRepository.addLabelsToType(1L, List.of(1L, 2L))).thenReturn(Mono.empty());
+
+ GroupCourse course1 = new GroupCourse();
+ course1.setId(101L);
+ GroupCourse course2 = new GroupCourse();
+ course2.setId(102L);
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.just(course1, course2));
+ when(redisUtil.delete("group_course:detail:101")).thenReturn(Mono.just(1L));
+ when(redisUtil.delete("group_course:detail:102")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(courseLabelService.addLabelsToType(1L, List.of(1L, 2L)))
+ .verifyComplete();
+
+ verify(courseLabelRepository).addLabelsToType(1L, List.of(1L, 2L));
+ verify(groupCourseRepository).findByCourseType(1L);
+ verify(redisUtil).delete("group_course:detail:101");
+ verify(redisUtil).delete("group_course:detail:102");
+ }
+
+ @Test
+ void addLabelsToType_shouldNotInvalidateCacheWhenNoCourses() {
+ when(courseLabelRepository.addLabelsToType(1L, List.of(1L))).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.addLabelsToType(1L, List.of(1L)))
+ .verifyComplete();
+
+ verify(courseLabelRepository).addLabelsToType(1L, List.of(1L));
+ verify(groupCourseRepository).findByCourseType(1L);
+ verify(redisUtil, never()).delete(anyString());
+ }
+
+ // ==================== removeLabelFromType ====================
+
+ @Test
+ void removeLabelFromType_shouldRemoveLabelAndInvalidateCache() {
+ when(courseLabelRepository.removeLabelFromType(1L, 1L)).thenReturn(Mono.empty());
+
+ GroupCourse course = new GroupCourse();
+ course.setId(101L);
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.just(course));
+ when(redisUtil.delete("group_course:detail:101")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(courseLabelService.removeLabelFromType(1L, 1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).removeLabelFromType(1L, 1L);
+ verify(groupCourseRepository).findByCourseType(1L);
+ verify(redisUtil).delete("group_course:detail:101");
+ }
+
+ @Test
+ void removeLabelFromType_shouldNotInvalidateCacheWhenNoCourses() {
+ when(courseLabelRepository.removeLabelFromType(1L, 1L)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.removeLabelFromType(1L, 1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).removeLabelFromType(1L, 1L);
+ verify(redisUtil, never()).delete(anyString());
+ }
+
+ // ==================== clearLabelsFromType ====================
+
+ @Test
+ void clearLabelsFromType_shouldClearLabelsAndInvalidateCache() {
+ when(courseLabelRepository.clearLabelsFromType(1L)).thenReturn(Mono.empty());
+
+ GroupCourse course1 = new GroupCourse();
+ course1.setId(101L);
+ GroupCourse course2 = new GroupCourse();
+ course2.setId(102L);
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.just(course1, course2));
+ when(redisUtil.delete("group_course:detail:101")).thenReturn(Mono.just(1L));
+ when(redisUtil.delete("group_course:detail:102")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(courseLabelService.clearLabelsFromType(1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).clearLabelsFromType(1L);
+ verify(groupCourseRepository).findByCourseType(1L);
+ verify(redisUtil).delete("group_course:detail:101");
+ verify(redisUtil).delete("group_course:detail:102");
+ }
+
+ @Test
+ void clearLabelsFromType_shouldNotInvalidateCacheWhenNoCourses() {
+ when(courseLabelRepository.clearLabelsFromType(1L)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.empty());
+
+ StepVerifier.create(courseLabelService.clearLabelsFromType(1L))
+ .verifyComplete();
+
+ verify(courseLabelRepository).clearLabelsFromType(1L);
+ verify(redisUtil, never()).delete(anyString());
+ }
+
+ // ==================== findByPage ====================
+
+ @Test
+ void findByPage_shouldReturnPaginatedResults() {
+ PageRequest pageRequest = new PageRequest();
+ pageRequest.setPage(0);
+ pageRequest.setSize(10);
+
+ CourseLabel label1 = new CourseLabel();
+ label1.setId(1L);
+ label1.setLabelName("适合新手");
+ CourseLabel label2 = new CourseLabel();
+ label2.setId(2L);
+ label2.setLabelName("高强度");
+
+ PageResponse pageResponse = new PageResponse<>(
+ List.of(label1, label2), 1, 2, 0, 10);
+
+ when(courseLabelRepository.findByPage(pageRequest)).thenReturn(Mono.just(pageResponse));
+
+ StepVerifier.create(courseLabelService.findByPage(pageRequest))
+ .assertNext(result -> {
+ assertThat(result.getContent()).hasSize(2);
+ assertThat(result.getTotalElements()).isEqualTo(2);
+ assertThat(result.getTotalPages()).isEqualTo(1);
+ assertThat(result.getCurrentPage()).isZero();
+ assertThat(result.getPageSize()).isEqualTo(10);
+ assertThat(result.isFirst()).isTrue();
+ assertThat(result.isLast()).isTrue();
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByPage(pageRequest);
+ }
+
+ @Test
+ void findByPage_shouldReturnEmptyPageWhenNoResults() {
+ PageRequest pageRequest = new PageRequest();
+ PageResponse emptyPage = new PageResponse<>(
+ List.of(), 0, 0, 0, 10);
+
+ when(courseLabelRepository.findByPage(pageRequest)).thenReturn(Mono.just(emptyPage));
+
+ StepVerifier.create(courseLabelService.findByPage(pageRequest))
+ .assertNext(result -> {
+ assertThat(result.getContent()).isEmpty();
+ assertThat(result.getTotalElements()).isZero();
+ assertThat(result.getTotalPages()).isZero();
+ })
+ .verifyComplete();
+
+ verify(courseLabelRepository).findByPage(pageRequest);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingServiceTest.java
new file mode 100644
index 0000000..60bbae3
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseBookingServiceTest.java
@@ -0,0 +1,490 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.event.BookingReminderEventPublisher;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+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.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseBookingServiceTest {
+
+ @Mock
+ private IGroupCourseBookingRepository bookingRepository;
+
+ @Mock
+ private IGroupCourseRepository courseRepository;
+
+ @Mock
+ private GroupCourseRedisService redisService;
+
+ @Mock
+ private BookingReminderEventPublisher eventPublisher;
+
+ private GroupCourseBookingService service;
+
+ private GroupCourse testCourse;
+ private GroupCourseBooking testBooking;
+ private GroupCourseBooking savedBooking;
+
+ private static final Long COURSE_ID = 1L;
+ private static final Long MEMBER_ID = 100L;
+ private static final Long BOOKING_ID = 10L;
+ private static final Long OTHER_MEMBER_ID = 200L;
+
+ @BeforeEach
+ void setUp() {
+ // getCourseWithCache eagerly evaluates the switchIfEmpty argument,
+ // so findByIdAndDeletedAtIsNull must never return null
+ // Use lenient because this stub is only needed for bookCourse tests
+ lenient().when(courseRepository.findByIdAndDeletedAtIsNull(anyLong())).thenReturn(Mono.empty());
+ service = new GroupCourseBookingService(bookingRepository, courseRepository, redisService, eventPublisher);
+
+ testCourse = new GroupCourse();
+ testCourse.setId(COURSE_ID);
+ testCourse.setCourseName("瑜伽课");
+ testCourse.setStatus(0L);
+ testCourse.setStartTime(LocalDateTime.now().plusHours(2));
+ testCourse.setEndTime(LocalDateTime.now().plusHours(3));
+ testCourse.setMaxMembers(20);
+ testCourse.setCurrentMembers(2);
+ testCourse.setLocation("健身房A区");
+
+ testBooking = new GroupCourseBooking();
+ testBooking.setId(BOOKING_ID);
+ testBooking.setCourseId(COURSE_ID);
+ testBooking.setMemberId(MEMBER_ID);
+ testBooking.setStatus("0");
+ testBooking.setCourseName("瑜伽课");
+ testBooking.setCourseStartTime(LocalDateTime.now().plusHours(3));
+ testBooking.setCourseEndTime(LocalDateTime.now().plusHours(4));
+ testBooking.setLocation("健身房A区");
+
+ savedBooking = new GroupCourseBooking();
+ savedBooking.setId(BOOKING_ID);
+ savedBooking.setCourseId(COURSE_ID);
+ savedBooking.setMemberId(MEMBER_ID);
+ savedBooking.setStatus("0");
+ savedBooking.setCourseName("瑜伽课");
+ savedBooking.setCourseStartTime(LocalDateTime.now().plusHours(2));
+ savedBooking.setCourseEndTime(LocalDateTime.now().plusHours(3));
+ savedBooking.setLocation("健身房A区");
+ }
+
+ // ==================== bookCourse ====================
+
+ @Test
+ void bookCourse_shouldSucceedWithValidInputs() {
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(bookingRepository.findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+ when(bookingRepository.findValidBooking(COURSE_ID, MEMBER_ID)).thenReturn(Mono.empty());
+ when(bookingRepository.save(any(GroupCourseBooking.class))).thenReturn(Mono.just(savedBooking));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .assertNext(booking -> {
+ assertThat(booking.getId()).isEqualTo(BOOKING_ID);
+ assertThat(booking.getCourseId()).isEqualTo(COURSE_ID);
+ assertThat(booking.getMemberId()).isEqualTo(MEMBER_ID);
+ assertThat(booking.getStatus()).isEqualTo("0");
+ })
+ .verifyComplete();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(bookingRepository).findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ verify(bookingRepository).findValidBooking(COURSE_ID, MEMBER_ID);
+ verify(bookingRepository).save(any(GroupCourseBooking.class));
+ verify(redisService).releaseLock(eq(COURSE_ID), anyString());
+ verify(eventPublisher).publishBookingSuccessEvent(eq(BOOKING_ID), eq(MEMBER_ID), eq("瑜伽课"), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenLockNotAcquired() {
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(false));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "系统繁忙，请稍后重试".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verifyNoInteractions(bookingRepository);
+ verifyNoInteractions(eventPublisher);
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenCourseNotFound() {
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.empty());
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "团课不存在".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(courseRepository).findByIdAndDeletedAtIsNull(COURSE_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenCourseStatusIsCancelled() {
+ testCourse.setStatus(1L);
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "课程已取消，无法预约".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ verifyNoMoreInteractions(eventPublisher);
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenCourseIsEnded() {
+ testCourse.setStatus(2L);
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "课程已结束，无法预约".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenLessThan30minBeforeStart() {
+ testCourse.setStartTime(LocalDateTime.now().plusMinutes(15));
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "需在课程开始前30分钟预约".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenCourseIsFull() {
+ testCourse.setCurrentMembers(20);
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(20L));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "课程已满".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenTimeConflictExists() {
+ GroupCourseBooking conflict = new GroupCourseBooking();
+ conflict.setCourseName("冲突课程");
+ conflict.setCourseStartTime(LocalDateTime.now().plusHours(2));
+ conflict.setCourseEndTime(LocalDateTime.now().plusHours(3));
+
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(bookingRepository.findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Flux.just(conflict));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && ex.getMessage().contains("您已预约的课程与当前课程时间冲突"))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(bookingRepository).findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ @Test
+ void bookCourse_shouldFailWhenAlreadyBooked() {
+ when(redisService.acquireLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+ when(redisService.getCachedCourse(COURSE_ID)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.countValidBookings(COURSE_ID)).thenReturn(Mono.just(2L));
+ when(bookingRepository.findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Flux.empty());
+ when(bookingRepository.findValidBooking(COURSE_ID, MEMBER_ID)).thenReturn(Mono.just(testBooking));
+ when(redisService.releaseLock(eq(COURSE_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.bookCourse(COURSE_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "您已预约该课程".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(COURSE_ID), anyString());
+ verify(redisService).getCachedCourse(COURSE_ID);
+ verify(bookingRepository).countValidBookings(COURSE_ID);
+ verify(bookingRepository).findConflictingBookings(eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ verify(bookingRepository).findValidBooking(COURSE_ID, MEMBER_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(COURSE_ID), anyString());
+ }
+
+ // ==================== cancelBooking ====================
+
+ @Test
+ void cancelBooking_shouldSucceedWithValidInputs() {
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+ when(bookingRepository.updateStatus(BOOKING_ID, "1")).thenReturn(Mono.just(1));
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .assertNext(booking -> {
+ assertThat(booking.getId()).isEqualTo(BOOKING_ID);
+ assertThat(booking.getMemberId()).isEqualTo(MEMBER_ID);
+ })
+ .verifyComplete();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository, times(2)).findById(BOOKING_ID);
+ verify(bookingRepository).updateStatus(BOOKING_ID, "1");
+ verify(redisService).releaseLock(eq(BOOKING_ID), anyString());
+ verify(eventPublisher).publishBookingCancelEvent(eq(BOOKING_ID), eq(MEMBER_ID), eq("瑜伽课"));
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenLockNotAcquired() {
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(false));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "系统繁忙，请稍后重试".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verifyNoInteractions(eventPublisher);
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenBookingNotFound() {
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.empty());
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "预约记录不存在".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository).findById(BOOKING_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(BOOKING_ID), anyString());
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenNotOwner() {
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, OTHER_MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "无权取消他人预约".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository).findById(BOOKING_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(BOOKING_ID), anyString());
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenAlreadyCancelled() {
+ testBooking.setStatus("1");
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "预约已取消，无需重复取消".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository).findById(BOOKING_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(BOOKING_ID), anyString());
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenAlreadyAttended() {
+ testBooking.setStatus("2");
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "课程已出席，无法取消".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository).findById(BOOKING_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(BOOKING_ID), anyString());
+ }
+
+ @Test
+ void cancelBooking_shouldFailWhenLessThan2hBeforeStart() {
+ testBooking.setCourseStartTime(LocalDateTime.now().plusHours(1));
+ when(redisService.acquireLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+ when(redisService.releaseLock(eq(BOOKING_ID), anyString())).thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cancelBooking(BOOKING_ID, MEMBER_ID))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "需在课程开始前2小时取消".equals(ex.getMessage()))
+ .verify();
+
+ verify(redisService).acquireLock(eq(BOOKING_ID), anyString());
+ verify(bookingRepository).findById(BOOKING_ID);
+ verify(redisService, atLeastOnce()).releaseLock(eq(BOOKING_ID), anyString());
+ }
+
+ // ==================== getBookingsByMemberId ====================
+
+ @Test
+ void getBookingsByMemberId_shouldReturnBookings() {
+ GroupCourseBooking booking1 = new GroupCourseBooking();
+ booking1.setId(1L);
+ booking1.setMemberId(MEMBER_ID);
+ GroupCourseBooking booking2 = new GroupCourseBooking();
+ booking2.setId(2L);
+ booking2.setMemberId(MEMBER_ID);
+
+ when(bookingRepository.findByMemberId(MEMBER_ID)).thenReturn(Flux.just(booking1, booking2));
+
+ StepVerifier.create(service.getBookingsByMemberId(MEMBER_ID))
+ .expectNext(booking1, booking2)
+ .verifyComplete();
+
+ verify(bookingRepository).findByMemberId(MEMBER_ID);
+ }
+
+ // ==================== getBookingById ====================
+
+ @Test
+ void getBookingById_shouldReturnBooking() {
+ when(bookingRepository.findById(BOOKING_ID)).thenReturn(Mono.just(testBooking));
+
+ StepVerifier.create(service.getBookingById(BOOKING_ID))
+ .assertNext(booking -> {
+ assertThat(booking.getId()).isEqualTo(BOOKING_ID);
+ assertThat(booking.getMemberId()).isEqualTo(MEMBER_ID);
+ })
+ .verifyComplete();
+
+ verify(bookingRepository).findById(BOOKING_ID);
+ }
+
+ // ==================== getBookingsByCourseId ====================
+
+ @Test
+ void getBookingsByCourseId_shouldReturnBookings() {
+ GroupCourseBooking booking1 = new GroupCourseBooking();
+ booking1.setId(1L);
+ booking1.setCourseId(COURSE_ID);
+ GroupCourseBooking booking2 = new GroupCourseBooking();
+ booking2.setId(2L);
+ booking2.setCourseId(COURSE_ID);
+
+ when(bookingRepository.findByCourseId(COURSE_ID)).thenReturn(Flux.just(booking1, booking2));
+
+ StepVerifier.create(service.getBookingsByCourseId(COURSE_ID))
+ .expectNext(booking1, booking2)
+ .verifyComplete();
+
+ verify(bookingRepository).findByCourseId(COURSE_ID);
+ }
+
+ // ==================== processAbsentMembers ====================
+
+ @Test
+ void processAbsentMembers_shouldProcessAbsentBookings() {
+ GroupCourseBooking absent1 = new GroupCourseBooking();
+ absent1.setId(1L);
+ absent1.setMemberId(MEMBER_ID);
+ absent1.setCourseId(COURSE_ID);
+ GroupCourseBooking absent2 = new GroupCourseBooking();
+ absent2.setId(2L);
+ absent2.setMemberId(MEMBER_ID + 1);
+ absent2.setCourseId(COURSE_ID);
+
+ when(bookingRepository.findAbsentMembers()).thenReturn(Flux.just(absent1, absent2));
+ when(bookingRepository.updateToAbsent(1L)).thenReturn(Mono.just(1));
+ when(bookingRepository.updateToAbsent(2L)).thenReturn(Mono.just(1));
+
+ StepVerifier.create(service.processAbsentMembers())
+ .assertNext(count -> assertThat(count).isEqualTo(2))
+ .verifyComplete();
+
+ verify(bookingRepository).findAbsentMembers();
+ verify(bookingRepository).updateToAbsent(1L);
+ verify(bookingRepository).updateToAbsent(2L);
+ }
+
+ @Test
+ void processAbsentMembers_shouldReturnZeroWhenNoAbsentBookings() {
+ when(bookingRepository.findAbsentMembers()).thenReturn(Flux.empty());
+
+ StepVerifier.create(service.processAbsentMembers())
+ .assertNext(count -> assertThat(count).isEqualTo(0))
+ .verifyComplete();
+
+ verify(bookingRepository).findAbsentMembers();
+ verify(bookingRepository, never()).updateToAbsent(anyLong());
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRecommendServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRecommendServiceTest.java
new file mode 100644
index 0000000..f83e259
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRecommendServiceTest.java
@@ -0,0 +1,407 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseRecommend;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRecommendRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseRecommendServiceTest {
+
+ @Mock
+ private IGroupCourseRecommendRepository recommendRepository;
+
+ @Mock
+ private IGroupCourseRepository groupCourseRepository;
+
+ private GroupCourseRecommendService service;
+
+ @Captor
+ private ArgumentCaptor recommendCaptor;
+
+ @BeforeEach
+ void setUp() {
+ service = new GroupCourseRecommendService(recommendRepository, groupCourseRepository);
+ }
+
+ private GroupCourseRecommend createRecommend(Long id, Long courseId, String title) {
+ GroupCourseRecommend r = new GroupCourseRecommend();
+ r.setId(id);
+ r.setCourseId(courseId);
+ r.setRecommendTitle(title);
+ r.setRecommendContent("推荐内容");
+ r.setRecommendReason("推荐理由");
+ r.setPriority(10);
+ r.setIsActive(true);
+ return r;
+ }
+
+ private GroupCourse createCourse(Long id, String name) {
+ GroupCourse c = new GroupCourse();
+ c.setId(id);
+ c.setCourseName(name);
+ return c;
+ }
+
+ // ==================== findById ====================
+
+ @Test
+ void findById_shouldReturnRecommendWithCourseInfo() {
+ GroupCourseRecommend recommend = createRecommend(1L, 10L, "本周热门");
+ GroupCourse course = createCourse(10L, "Push-up");
+ when(recommendRepository.findById(1L)).thenReturn(Mono.just(recommend));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(course));
+
+ StepVerifier.create(service.findById(1L))
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getRecommendTitle()).isEqualTo("本周热门");
+ assertThat(r.getGroupCourse()).isNotNull();
+ assertThat(r.getGroupCourse().getCourseName()).isEqualTo("Push-up");
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findById(1L);
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(10L);
+ }
+
+ @Test
+ void findById_shouldReturnRecommendWithoutCourseWhenCourseIdIsNull() {
+ GroupCourseRecommend recommend = createRecommend(1L, null, "本周热门");
+ when(recommendRepository.findById(1L)).thenReturn(Mono.just(recommend));
+
+ StepVerifier.create(service.findById(1L))
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getGroupCourse()).isNull();
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findById(1L);
+ verify(groupCourseRepository, never()).findByIdAndDeletedAtIsNull(any());
+ }
+
+ @Test
+ void findById_shouldReturnEmptyWhenNotFound() {
+ when(recommendRepository.findById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.findById(999L))
+ .verifyComplete();
+
+ verify(recommendRepository).findById(999L);
+ }
+
+ // ==================== findAll ====================
+
+ @Test
+ void findAll_shouldReturnAllWithCourseInfo() {
+ GroupCourseRecommend r1 = createRecommend(1L, 10L, "本周热门");
+ GroupCourseRecommend r2 = createRecommend(2L, 20L, "新课程推荐");
+ GroupCourse course1 = createCourse(10L, "Push-up");
+ GroupCourse course2 = createCourse(20L, "Yoga");
+ when(recommendRepository.findAll()).thenReturn(Flux.just(r1, r2));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(course1));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(20L)).thenReturn(Mono.just(course2));
+
+ StepVerifier.create(service.findAll())
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getGroupCourse().getCourseName()).isEqualTo("Push-up");
+ })
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(2L);
+ assertThat(r.getGroupCourse().getCourseName()).isEqualTo("Yoga");
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findAll();
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(10L);
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(20L);
+ }
+
+ // ==================== findAll(String, String) ====================
+
+ @Test
+ void findAllWithSort_shouldReturnSortedResults() {
+ GroupCourseRecommend r1 = createRecommend(1L, 10L, "A课程");
+ GroupCourseRecommend r2 = createRecommend(2L, 20L, "B课程");
+ GroupCourse course1 = createCourse(10L, "Push-up");
+ GroupCourse course2 = createCourse(20L, "Yoga");
+ when(recommendRepository.findAll("priority", "desc")).thenReturn(Flux.just(r1, r2));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(course1));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(20L)).thenReturn(Mono.just(course2));
+
+ StepVerifier.create(service.findAll("priority", "desc"))
+ .assertNext(r -> assertThat(r.getId()).isEqualTo(1L))
+ .assertNext(r -> assertThat(r.getId()).isEqualTo(2L))
+ .verifyComplete();
+
+ verify(recommendRepository).findAll("priority", "desc");
+ }
+
+ // ==================== findAllActive ====================
+
+ @Test
+ void findAllActive_shouldReturnOnlyActive() {
+ GroupCourseRecommend r1 = createRecommend(1L, 10L, "本周热门");
+ r1.setIsActive(true);
+ when(recommendRepository.findAllActive()).thenReturn(Flux.just(r1));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(createCourse(10L, "Push-up")));
+
+ StepVerifier.create(service.findAllActive())
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getIsActive()).isTrue();
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findAllActive();
+ }
+
+ // ==================== findByCourseId ====================
+
+ @Test
+ void findByCourseId_shouldReturnByCourseId() {
+ GroupCourseRecommend r1 = createRecommend(1L, 10L, "本周热门");
+ when(recommendRepository.findByCourseId(10L)).thenReturn(Flux.just(r1));
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(createCourse(10L, "Push-up")));
+
+ StepVerifier.create(service.findByCourseId(10L))
+ .assertNext(r -> {
+ assertThat(r.getCourseId()).isEqualTo(10L);
+ assertThat(r.getGroupCourse().getCourseName()).isEqualTo("Push-up");
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findByCourseId(10L);
+ }
+
+ // ==================== create ====================
+
+ @Test
+ void create_shouldSaveWhenCourseExists() {
+ GroupCourseRecommend recommend = createRecommend(null, 10L, "本周热门");
+ GroupCourse course = createCourse(10L, "Push-up");
+ GroupCourseRecommend saved = createRecommend(1L, 10L, "本周热门");
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(10L)).thenReturn(Mono.just(course));
+ when(recommendRepository.save(any(GroupCourseRecommend.class))).thenReturn(Mono.just(saved));
+
+ StepVerifier.create(service.create(recommend))
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getCourseId()).isEqualTo(10L);
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(10L);
+ verify(recommendRepository).save(any(GroupCourseRecommend.class));
+ }
+
+ @Test
+ void create_shouldErrorWhenCourseIdIsNull() {
+ GroupCourseRecommend recommend = createRecommend(null, null, "本周热门");
+
+ StepVerifier.create(service.create(recommend))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课ID不能为空".equals(e.getMessage()))
+ .verify();
+
+ verify(groupCourseRepository, never()).findByIdAndDeletedAtIsNull(any());
+ verify(recommendRepository, never()).save(any());
+ }
+
+ @Test
+ void create_shouldErrorWhenCourseNotFound() {
+ GroupCourseRecommend recommend = createRecommend(null, 999L, "本周热门");
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.create(recommend))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课不存在".equals(e.getMessage()))
+ .verify();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(999L);
+ verify(recommendRepository, never()).save(any());
+ }
+
+ // ==================== update ====================
+
+ @Test
+ void update_shouldUpdateSpecificFields() {
+ GroupCourseRecommend existing = createRecommend(1L, 10L, "原标题");
+ GroupCourseRecommend updateReq = new GroupCourseRecommend();
+ updateReq.setRecommendTitle("新标题");
+ updateReq.setRecommendContent("新内容");
+ updateReq.setRecommendReason("新理由");
+ updateReq.setPriority(20);
+ updateReq.setIsActive(false);
+ updateReq.setCourseId(30L);
+
+ GroupCourseRecommend updated = createRecommend(1L, 30L, "新标题");
+ updated.setRecommendContent("新内容");
+ updated.setRecommendReason("新理由");
+ updated.setPriority(20);
+ updated.setIsActive(false);
+
+ when(recommendRepository.findById(1L)).thenReturn(Mono.just(existing));
+ when(recommendRepository.update(any(GroupCourseRecommend.class))).thenReturn(Mono.just(updated));
+
+ StepVerifier.create(service.update(1L, updateReq))
+ .assertNext(r -> {
+ assertThat(r.getRecommendTitle()).isEqualTo("新标题");
+ assertThat(r.getRecommendContent()).isEqualTo("新内容");
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).findById(1L);
+ verify(recommendRepository).update(recommendCaptor.capture());
+ GroupCourseRecommend captured = recommendCaptor.getValue();
+ assertThat(captured.getRecommendTitle()).isEqualTo("新标题");
+ assertThat(captured.getRecommendContent()).isEqualTo("新内容");
+ assertThat(captured.getRecommendReason()).isEqualTo("新理由");
+ assertThat(captured.getPriority()).isEqualTo(20);
+ assertThat(captured.getIsActive()).isFalse();
+ assertThat(captured.getCourseId()).isEqualTo(30L);
+ }
+
+ @Test
+ void update_shouldErrorWhenNotFound() {
+ GroupCourseRecommend updateReq = new GroupCourseRecommend();
+ updateReq.setRecommendTitle("新标题");
+ when(recommendRepository.findById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.update(999L, updateReq))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课推荐不存在".equals(e.getMessage()))
+ .verify();
+
+ verify(recommendRepository).findById(999L);
+ verify(recommendRepository, never()).update(any());
+ }
+
+ @Test
+ void update_shouldOnlyUpdateNonNullFields() {
+ GroupCourseRecommend existing = createRecommend(1L, 10L, "原标题");
+ GroupCourseRecommend updateReq = new GroupCourseRecommend();
+ updateReq.setRecommendTitle("仅标题");
+
+ when(recommendRepository.findById(1L)).thenReturn(Mono.just(existing));
+ when(recommendRepository.update(any(GroupCourseRecommend.class))).thenReturn(Mono.just(existing));
+
+ StepVerifier.create(service.update(1L, updateReq))
+ .assertNext(r -> assertThat(r.getRecommendTitle()).isEqualTo("仅标题"))
+ .verifyComplete();
+
+ verify(recommendRepository).update(recommendCaptor.capture());
+ GroupCourseRecommend captured = recommendCaptor.getValue();
+ assertThat(captured.getRecommendTitle()).isEqualTo("仅标题");
+ assertThat(captured.getRecommendContent()).isEqualTo("推荐内容");
+ assertThat(captured.getRecommendReason()).isEqualTo("推荐理由");
+ assertThat(captured.getPriority()).isEqualTo(10);
+ assertThat(captured.getIsActive()).isTrue();
+ assertThat(captured.getCourseId()).isEqualTo(10L);
+ }
+
+ // ==================== delete ====================
+
+ @Test
+ void delete_shouldDeleteWhenExists() {
+ GroupCourseRecommend recommend = createRecommend(1L, 10L, "本周热门");
+ when(recommendRepository.findById(1L)).thenReturn(Mono.just(recommend));
+ when(recommendRepository.deleteById(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.delete(1L))
+ .verifyComplete();
+
+ verify(recommendRepository).findById(1L);
+ verify(recommendRepository).deleteById(1L);
+ }
+
+ @Test
+ void delete_shouldErrorWhenNotFound() {
+ when(recommendRepository.findById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.delete(999L))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课推荐不存在".equals(e.getMessage()))
+ .verify();
+
+ verify(recommendRepository).findById(999L);
+ verify(recommendRepository, never()).deleteById(any());
+ }
+
+ // ==================== enable ====================
+
+ @Test
+ void enable_shouldUpdateActiveStatusToTrue() {
+ GroupCourseRecommend result = createRecommend(1L, 10L, "本周热门");
+ result.setIsActive(true);
+ when(recommendRepository.updateActiveStatus(1L, true)).thenReturn(Mono.just(result));
+
+ StepVerifier.create(service.enable(1L))
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getIsActive()).isTrue();
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).updateActiveStatus(1L, true);
+ }
+
+ @Test
+ void enable_shouldErrorWhenNotFound() {
+ when(recommendRepository.updateActiveStatus(999L, true)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.enable(999L))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课推荐不存在".equals(e.getMessage()))
+ .verify();
+
+ verify(recommendRepository).updateActiveStatus(999L, true);
+ }
+
+ // ==================== disable ====================
+
+ @Test
+ void disable_shouldUpdateActiveStatusToFalse() {
+ GroupCourseRecommend result = createRecommend(1L, 10L, "本周热门");
+ result.setIsActive(false);
+ when(recommendRepository.updateActiveStatus(1L, false)).thenReturn(Mono.just(result));
+
+ StepVerifier.create(service.disable(1L))
+ .assertNext(r -> {
+ assertThat(r.getId()).isEqualTo(1L);
+ assertThat(r.getIsActive()).isFalse();
+ })
+ .verifyComplete();
+
+ verify(recommendRepository).updateActiveStatus(1L, false);
+ }
+
+ @Test
+ void disable_shouldErrorWhenNotFound() {
+ when(recommendRepository.updateActiveStatus(999L, false)).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.disable(999L))
+ .expectErrorMatches(e -> e instanceof RuntimeException
+ && "团课推荐不存在".equals(e.getMessage()))
+ .verify();
+
+ verify(recommendRepository).updateActiveStatus(999L, false);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisServiceTest.java
new file mode 100644
index 0000000..3c7d276
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseRedisServiceTest.java
@@ -0,0 +1,167 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+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.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.core.ReactiveValueOperations;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseRedisServiceTest {
+
+ @Mock
+ private ReactiveRedisTemplate reactiveRedisTemplate;
+
+ @Mock
+ private ReactiveValueOperations reactiveValueOps;
+
+ private ObjectMapper objectMapper = new ObjectMapper();
+
+ private GroupCourseRedisService service;
+
+ private GroupCourse testCourse;
+
+ @BeforeEach
+ void setUp() {
+ lenient().when(reactiveRedisTemplate.opsForValue()).thenReturn(reactiveValueOps);
+ service = new GroupCourseRedisService(reactiveRedisTemplate, objectMapper);
+
+ testCourse = new GroupCourse();
+ testCourse.setId(1L);
+ testCourse.setCourseName("瑜伽课");
+ testCourse.setCourseType(1L);
+ }
+
+ // ==================== cacheCourse ====================
+
+ @Test
+ void cacheCourse_shouldSerializeAndSetInRedis() {
+ when(reactiveValueOps.set(eq("group_course:1"), anyString(), eq(Duration.ofMinutes(5))))
+ .thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.cacheCourse(testCourse))
+ .verifyComplete();
+
+ verify(reactiveValueOps).set(eq("group_course:1"), anyString(), eq(Duration.ofMinutes(5)));
+ }
+
+ @Test
+ void cacheCourse_shouldErrorWhenRedisFails() {
+ when(reactiveValueOps.set(eq("group_course:1"), anyString(), eq(Duration.ofMinutes(5))))
+ .thenReturn(Mono.error(new RuntimeException("Redis error")));
+
+ StepVerifier.create(service.cacheCourse(testCourse))
+ .expectError(RuntimeException.class)
+ .verify();
+ }
+
+ // ==================== getCachedCourse ====================
+
+ @Test
+ void getCachedCourse_shouldReturnCachedCourseWhenFound() throws Exception {
+ String json = objectMapper.writeValueAsString(testCourse);
+ when(reactiveValueOps.get("group_course:1")).thenReturn(Mono.just(json));
+
+ StepVerifier.create(service.getCachedCourse(1L))
+ .assertNext(course -> {
+ assertThat(course.getId()).isEqualTo(1L);
+ assertThat(course.getCourseName()).isEqualTo("瑜伽课");
+ })
+ .verifyComplete();
+ }
+
+ @Test
+ void getCachedCourse_shouldReturnEmptyWhenCacheMiss() {
+ when(reactiveValueOps.get("group_course:1")).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.getCachedCourse(1L))
+ .verifyComplete();
+ }
+
+ @Test
+ void getCachedCourse_shouldReturnEmptyWhenDeserializationFails() {
+ String invalidJson = "invalid json";
+ when(reactiveValueOps.get("group_course:1")).thenReturn(Mono.just(invalidJson));
+
+ StepVerifier.create(service.getCachedCourse(1L))
+ .verifyComplete();
+ }
+
+ // ==================== invalidateCourseCache ====================
+
+ @Test
+ void invalidateCourseCache_shouldDeleteFromRedis() {
+ when(reactiveRedisTemplate.delete("group_course:1")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(service.invalidateCourseCache(1L))
+ .verifyComplete();
+
+ verify(reactiveRedisTemplate).delete("group_course:1");
+ }
+
+ // ==================== acquireLock ====================
+
+ @Test
+ void acquireLock_shouldReturnTrueWhenLockAcquired() {
+ when(reactiveValueOps.setIfAbsent("booking_lock:1", "req-1", Duration.ofSeconds(30)))
+ .thenReturn(Mono.just(true));
+
+ StepVerifier.create(service.acquireLock(1L, "req-1"))
+ .assertNext(acquired -> assertThat(acquired).isTrue())
+ .verifyComplete();
+ }
+
+ @Test
+ void acquireLock_shouldReturnFalseWhenLockNotAcquired() {
+ when(reactiveValueOps.setIfAbsent("booking_lock:1", "req-1", Duration.ofSeconds(30)))
+ .thenReturn(Mono.just(false));
+
+ StepVerifier.create(service.acquireLock(1L, "req-1"))
+ .assertNext(acquired -> assertThat(acquired).isFalse())
+ .verifyComplete();
+ }
+
+ // ==================== releaseLock ====================
+
+ @Test
+ void releaseLock_shouldReturnTrueWhenRequestIdMatches() {
+ when(reactiveValueOps.get("booking_lock:1")).thenReturn(Mono.just("req-1"));
+ when(reactiveRedisTemplate.delete("booking_lock:1")).thenReturn(Mono.just(1L));
+
+ StepVerifier.create(service.releaseLock(1L, "req-1"))
+ .assertNext(released -> assertThat(released).isTrue())
+ .verifyComplete();
+ }
+
+ @Test
+ void releaseLock_shouldReturnFalseWhenRequestIdDoesNotMatch() {
+ when(reactiveValueOps.get("booking_lock:1")).thenReturn(Mono.just("req-2"));
+
+ StepVerifier.create(service.releaseLock(1L, "req-1"))
+ .assertNext(released -> assertThat(released).isFalse())
+ .verifyComplete();
+
+ verify(reactiveRedisTemplate, never()).delete(anyString());
+ }
+
+ @Test
+ void releaseLock_shouldReturnFalseWhenKeyNotFound() {
+ when(reactiveValueOps.get("booking_lock:1")).thenReturn(Mono.empty());
+
+ StepVerifier.create(service.releaseLock(1L, "req-1"))
+ .assertNext(released -> assertThat(released).isFalse())
+ .verifyComplete();
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseServiceTest.java
new file mode 100644
index 0000000..b5842e8
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseServiceTest.java
@@ -0,0 +1,838 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.file.core.domain.SysFile;
+import cn.novalon.gym.manage.file.core.service.ISysFileService;
+import cn.novalon.gym.manage.groupcourse.domain.CourseLabel;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseBooking;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseDetail;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
+import cn.novalon.gym.manage.groupcourse.dto.GroupCourseQueryDto;
+import cn.novalon.gym.manage.groupcourse.enums.CourseEvent;
+import cn.novalon.gym.manage.groupcourse.enums.CourseStatus;
+import cn.novalon.gym.manage.groupcourse.handler.GroupCourseStateMachine;
+import cn.novalon.gym.manage.groupcourse.repository.ICourseLabelRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseBookingRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
+import cn.novalon.gym.manage.groupcourse.util.QRCodeUtil;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.sys.core.domain.SysUser;
+import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+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.MockedStatic;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.r2dbc.core.DatabaseClient;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseServiceTest {
+
+ @Mock
+ private IGroupCourseRepository groupCourseRepository;
+ @Mock
+ private IGroupCourseBookingRepository bookingRepository;
+ @Mock
+ private IGroupCourseTypeRepository groupCourseTypeRepository;
+ @Mock
+ private ICourseLabelRepository courseLabelRepository;
+ @Mock
+ private IMemberCardRecordService memberCardRecordService;
+ @Mock
+ private MemberCardRepository memberCardRepository;
+ @Mock
+ private RedisUtil redisUtil;
+ @Mock
+ private GroupCourseStateMachine stateMachine;
+ @Mock
+ private DatabaseClient databaseClient;
+ @Mock
+ private ISysFileService fileService;
+ @Mock
+ private ISysUserRepository sysUserRepository;
+
+ private final ObjectMapper objectMapper = new ObjectMapper()
+ .registerModule(new JavaTimeModule());
+
+ private GroupCourseService groupCourseService;
+
+ private GroupCourse testCourse;
+ private GroupCourseType testType;
+ private CourseLabel testLabel;
+ private GroupCourseBooking testBooking;
+ private SysUser testCoach;
+ private SysFile testSysFile;
+
+ @BeforeEach
+ void setUp() {
+ groupCourseService = new GroupCourseService(
+ groupCourseRepository, bookingRepository, groupCourseTypeRepository,
+ courseLabelRepository, memberCardRecordService, memberCardRepository,
+ redisUtil, objectMapper, stateMachine, databaseClient, fileService, sysUserRepository
+ );
+
+ testCourse = new GroupCourse();
+ testCourse.setId(1L);
+ testCourse.setCourseName("瑜伽入门课");
+ testCourse.setCoachId(10L);
+ testCourse.setCourseType(100L);
+ testCourse.setStartTime(LocalDateTime.now().plusDays(7));
+ testCourse.setEndTime(LocalDateTime.now().plusDays(7).plusHours(1));
+ testCourse.setMaxMembers(20);
+ testCourse.setCurrentMembers(5);
+ testCourse.setStatus(CourseStatus.NORMAL.getValue());
+ testCourse.setLocation("A区教室");
+ testCourse.setDescription("适合初学者的瑜伽课程");
+ testCourse.setStoredValueAmount(new BigDecimal("50.00"));
+
+ testType = new GroupCourseType();
+ testType.setId(100L);
+ testType.setTypeName("瑜伽入门");
+ testType.setCategory("柔韧与平衡类");
+ testType.setBaseDifficulty(2);
+
+ testLabel = new CourseLabel();
+ testLabel.setId(1000L);
+ testLabel.setLabelName("适合新手");
+ testLabel.setColor("#52c41a");
+
+ testBooking = new GroupCourseBooking();
+ testBooking.setId(500L);
+ testBooking.setCourseId(1L);
+ testBooking.setMemberId(200L);
+ testBooking.setMemberCardRecordId(300L);
+ testBooking.setStatus("0");
+
+ testCoach = new SysUser();
+ testCoach.setId(10L);
+ testCoach.setNickname("张教练");
+ testCoach.setUsername("coach_zhang");
+
+ testSysFile = new SysFile();
+ testSysFile.setId(999L);
+ testSysFile.setFileName("qrcode_1.png");
+ }
+
+ private void mockClearCache() {
+ when(redisUtil.deleteByPattern("group_course:page:*")).thenReturn(Mono.just(0L));
+ when(redisUtil.deleteByPattern("group_course:id:*")).thenReturn(Mono.just(0L));
+ when(redisUtil.deleteByPattern("group_course:detail:*")).thenReturn(Mono.just(0L));
+ when(redisUtil.deleteByPattern("datacount:statistics:*")).thenReturn(Mono.just(0L));
+ }
+
+ private void mockEnrichCurrentMembers() {
+ when(bookingRepository.countValidBookings(anyLong())).thenReturn(Mono.just(5L));
+ }
+
+ // ==================== findDetailById ====================
+
+ @Test
+ void findDetailById_cacheHit_shouldReturnDetail() throws Exception {
+ String cacheKey = "group_course:detail:1";
+ GroupCourseDetail detail = new GroupCourseDetail();
+ detail.setId(1L);
+ detail.setCourseName("瑜伽入门课");
+ detail.setCoachName("张教练");
+ String json = objectMapper.writeValueAsString(detail);
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.just(json));
+ // switchIfEmpty 的 Mono 参数被急切求值，需要 mock 以避免 NPE
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.findDetailById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ assertThat(result.getCoachName()).isEqualTo("张教练");
+ })
+ .verifyComplete();
+
+ verify(redisUtil).get(cacheKey, String.class);
+ // switchIfEmpty 的 Mono 参数被急切求值，findByIdAndDeletedAtIsNull 会被调用但不会订阅
+ }
+
+ @Test
+ void findDetailById_cacheMissWithType_shouldBuildAndCacheDetail() throws Exception {
+ String cacheKey = "group_course:detail:1";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(groupCourseTypeRepository.findById(100L)).thenReturn(Mono.just(testType));
+ when(courseLabelRepository.findByTypeId(100L)).thenReturn(Flux.just(testLabel));
+ when(sysUserRepository.findByIdIncludingDeleted(10L)).thenReturn(Mono.just(testCoach));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(8L));
+ when(redisUtil.setWithExpire(eq(cacheKey), anyString(), eq(300L))).thenReturn(Mono.just(true));
+
+ StepVerifier.create(groupCourseService.findDetailById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ assertThat(result.getCoachName()).isEqualTo("张教练");
+ assertThat(result.getCurrentMembers()).isEqualTo(8);
+ assertThat(result.getTypeInfo()).isNotNull();
+ assertThat(result.getTypeInfo().getTypeName()).isEqualTo("瑜伽入门");
+ assertThat(result.getLabels()).hasSize(1);
+ assertThat(result.getLabels().get(0).getLabelName()).isEqualTo("适合新手");
+ })
+ .verifyComplete();
+
+ verify(redisUtil).get(cacheKey, String.class);
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ verify(groupCourseTypeRepository).findById(100L);
+ verify(courseLabelRepository).findByTypeId(100L);
+ verify(sysUserRepository).findByIdIncludingDeleted(10L);
+ verify(bookingRepository).countValidBookings(1L);
+ verify(redisUtil).setWithExpire(eq(cacheKey), anyString(), eq(300L));
+ }
+
+ @Test
+ void findDetailById_cacheMissNullCourseType_shouldBuildDetailWithoutType() {
+ String cacheKey = "group_course:detail:1";
+ testCourse.setCourseType(null);
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(sysUserRepository.findByIdIncludingDeleted(10L)).thenReturn(Mono.just(testCoach));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(3L));
+ when(redisUtil.setWithExpire(eq(cacheKey), anyString(), eq(300L))).thenReturn(Mono.just(true));
+
+ StepVerifier.create(groupCourseService.findDetailById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ assertThat(result.getTypeInfo()).isNull();
+ assertThat(result.getCoachName()).isEqualTo("张教练");
+ assertThat(result.getCurrentMembers()).isEqualTo(3);
+ })
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository, never()).findById(anyLong());
+ verify(courseLabelRepository, never()).findByTypeId(anyLong());
+ }
+
+ @Test
+ void findDetailById_cacheMissNotFound_shouldReturnEmpty() {
+ String cacheKey = "group_course:detail:1";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.findDetailById(1L))
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ verifyNoInteractions(groupCourseTypeRepository, courseLabelRepository, sysUserRepository, bookingRepository);
+ }
+
+ @Test
+ void findDetailById_cacheParseError_shouldDeleteCacheAndFallback() throws Exception {
+ String cacheKey = "group_course:detail:1";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.just("invalid-json"));
+ when(redisUtil.delete(cacheKey)).thenReturn(Mono.just(1L));
+ // After cache delete, switchIfEmpty kicks in
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(groupCourseTypeRepository.findById(100L)).thenReturn(Mono.just(testType));
+ when(courseLabelRepository.findByTypeId(100L)).thenReturn(Flux.just(testLabel));
+ when(sysUserRepository.findByIdIncludingDeleted(10L)).thenReturn(Mono.just(testCoach));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+ when(redisUtil.setWithExpire(eq(cacheKey), anyString(), eq(300L))).thenReturn(Mono.just(true));
+
+ StepVerifier.create(groupCourseService.findDetailById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ })
+ .verifyComplete();
+
+ verify(redisUtil).delete(cacheKey);
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ }
+
+ // ==================== findById ====================
+
+ @Test
+ void findById_cacheHit_shouldReturnCourse() throws Exception {
+ String cacheKey = "group_course:id:1";
+ String json = objectMapper.writeValueAsString(testCourse);
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.just(json));
+ // switchIfEmpty 的 Mono 参数被急切求值，需要 mock 以避免 NPE
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+
+ StepVerifier.create(groupCourseService.findById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ })
+ .verifyComplete();
+
+ verify(redisUtil).get(cacheKey, String.class);
+ verify(bookingRepository).countValidBookings(1L);
+ // switchIfEmpty 的 Mono 参数被急切求值，findByIdAndDeletedAtIsNull 会被调用但不会订阅
+ }
+
+ @Test
+ void findById_cacheMiss_shouldQueryDbAndCache() throws Exception {
+ String cacheKey = "group_course:id:1";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(redisUtil.setWithExpire(eq(cacheKey), anyString(), eq(300L))).thenReturn(Mono.just(true));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+
+ StepVerifier.create(groupCourseService.findById(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ verify(redisUtil).setWithExpire(eq(cacheKey), anyString(), eq(300L));
+ verify(bookingRepository).countValidBookings(1L);
+ }
+
+ @Test
+ void findById_cacheMissNotFound_shouldReturnEmpty() {
+ String cacheKey = "group_course:id:1";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.findById(1L))
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ }
+
+ // ==================== findAll ====================
+
+ @Test
+ void findAll_shouldReturnAllCourses() {
+ GroupCourse course2 = new GroupCourse();
+ course2.setId(2L);
+ course2.setCourseName("力量训练课");
+
+ when(groupCourseRepository.findAll()).thenReturn(Flux.just(testCourse, course2));
+
+ StepVerifier.create(groupCourseService.findAll())
+ .expectNext(testCourse, course2)
+ .verifyComplete();
+
+ verify(groupCourseRepository).findAll();
+ }
+
+ @Test
+ void findAll_withIncludeDeletedTrue_shouldReturnAll() {
+ when(groupCourseRepository.findAll()).thenReturn(Flux.just(testCourse));
+
+ StepVerifier.create(groupCourseService.findAll(true))
+ .expectNext(testCourse)
+ .verifyComplete();
+
+ verify(groupCourseRepository).findAll();
+ }
+
+ @Test
+ void findAll_withIncludeDeletedFalse_shouldReturnNonDeleted() {
+ when(groupCourseRepository.findByDeletedAtIsNull()).thenReturn(Flux.just(testCourse));
+
+ StepVerifier.create(groupCourseService.findAll(false))
+ .expectNext(testCourse)
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByDeletedAtIsNull();
+ }
+
+ // ==================== findByPage ====================
+
+ @Test
+ void findByPage_cacheHit_shouldReturnPage() throws Exception {
+ PageRequest pageRequest = new PageRequest();
+ pageRequest.setPage(0);
+ pageRequest.setSize(10);
+
+ PageResponse pageResponse = new PageResponse<>(
+ List.of(testCourse), 1, 1, 0, 10
+ );
+
+ String cacheKey = "group_course:page:0:10:false:id:asc::";
+ String json = objectMapper.writeValueAsString(pageResponse);
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.just(json));
+
+ StepVerifier.create(groupCourseService.findByPage(pageRequest, false))
+ .assertNext(result -> {
+ assertThat(result.getContent()).hasSize(1);
+ assertThat(result.getContent().get(0).getCourseName()).isEqualTo("瑜伽入门课");
+ assertThat(result.getTotalElements()).isEqualTo(1);
+ })
+ .verifyComplete();
+
+ verify(redisUtil).get(cacheKey, String.class);
+ verifyNoInteractions(groupCourseRepository);
+ }
+
+ @Test
+ void findByPage_cacheMiss_shouldQueryDbAndCache() throws Exception {
+ PageRequest pageRequest = new PageRequest();
+ pageRequest.setPage(0);
+ pageRequest.setSize(10);
+
+ PageResponse pageResponse = new PageResponse<>(
+ List.of(testCourse), 1, 1, 0, 10
+ );
+
+ String cacheKey = "group_course:page:0:10:false:id:asc::";
+
+ when(redisUtil.get(cacheKey, String.class)).thenReturn(Mono.empty());
+ when(groupCourseRepository.findByPageAndNotDeleted(pageRequest)).thenReturn(Mono.just(pageResponse));
+ when(redisUtil.setWithExpire(eq(cacheKey), anyString(), eq(300L))).thenReturn(Mono.just(true));
+
+ StepVerifier.create(groupCourseService.findByPage(pageRequest, false))
+ .assertNext(result -> {
+ assertThat(result.getContent()).hasSize(1);
+ assertThat(result.getTotalElements()).isEqualTo(1);
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByPageAndNotDeleted(pageRequest);
+ verify(redisUtil).setWithExpire(eq(cacheKey), anyString(), eq(300L));
+ }
+
+ // ==================== create ====================
+
+ @Test
+ void create_shouldSaveCourseAndGenerateQrCode() {
+ mockClearCache();
+
+ when(groupCourseRepository.save(any(GroupCourse.class))).thenReturn(Mono.just(testCourse));
+
+ try (MockedStatic qrUtil = mockStatic(QRCodeUtil.class)) {
+ qrUtil.when(() -> QRCodeUtil.generateQrCodeBytes(anyString())).thenReturn(new byte[]{1, 2, 3});
+ when(fileService.saveBytes(any(byte[].class), eq("qrcode_1.png"), eq("image/png"), eq("system")))
+ .thenReturn(Mono.just(testSysFile));
+ when(groupCourseRepository.update(any(GroupCourse.class))).thenReturn(Mono.just(testCourse));
+
+ StepVerifier.create(groupCourseService.create(testCourse))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ assertThat(result.getCourseName()).isEqualTo("瑜伽入门课");
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).save(testCourse);
+ verify(fileService).saveBytes(any(byte[].class), eq("qrcode_1.png"), eq("image/png"), eq("system"));
+ verify(groupCourseRepository).update(any(GroupCourse.class));
+ }
+ }
+
+ @Test
+ void create_qrCodeFails_shouldStillSaveCourse() {
+ when(groupCourseRepository.save(any(GroupCourse.class))).thenReturn(Mono.just(testCourse));
+
+ try (MockedStatic qrUtil = mockStatic(QRCodeUtil.class)) {
+ qrUtil.when(() -> QRCodeUtil.generateQrCodeBytes(anyString()))
+ .thenThrow(new RuntimeException("QR generation failed"));
+
+ StepVerifier.create(groupCourseService.create(testCourse))
+ .expectError(RuntimeException.class)
+ .verify();
+
+ verify(groupCourseRepository).save(testCourse);
+ verify(fileService, never()).saveBytes(any(), anyString(), anyString(), anyString());
+ }
+ }
+
+ // ==================== update ====================
+
+ @Test
+ void update_shouldUpdateExistingCourse() {
+ mockClearCache();
+ GroupCourse updateData = new GroupCourse();
+ updateData.setCourseName("瑜伽进阶课");
+ updateData.setLocation("B区教室");
+ updateData.setMaxMembers(30);
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(groupCourseRepository.update(any(GroupCourse.class))).thenReturn(Mono.just(testCourse));
+
+ StepVerifier.create(groupCourseService.update(1L, updateData))
+ .assertNext(result -> {
+ assertThat(result.getCourseName()).isEqualTo("瑜伽进阶课");
+ assertThat(result.getLocation()).isEqualTo("B区教室");
+ assertThat(result.getMaxMembers()).isEqualTo(30);
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ verify(groupCourseRepository).update(argThat(course ->
+ "瑜伽进阶课".equals(course.getCourseName()) &&
+ "B区教室".equals(course.getLocation()) &&
+ course.getMaxMembers() == 30
+ ));
+ }
+
+ @Test
+ void update_courseNotFound_shouldError() {
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.update(1L, new GroupCourse()))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "团课不存在".equals(ex.getMessage()))
+ .verify();
+
+ verify(groupCourseRepository).findByIdAndDeletedAtIsNull(1L);
+ verify(groupCourseRepository, never()).update(any());
+ }
+
+ // ==================== cancel ====================
+
+ @Test
+ void cancel_shouldCancelAndRefundMembers() {
+ mockClearCache();
+
+ MemberCardRecord record = MemberCardRecord.builder()
+ .id(300L)
+ .memberCardId(400L)
+ .remainingAmount(200.0)
+ .build();
+
+ MemberCard card = MemberCard.builder()
+ .memberCardId(400L)
+ .memberCardType(MemberCardType.STORED_VALUE_CARD.name())
+ .build();
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(stateMachine.validateTransition(any(GroupCourse.class), eq(CourseEvent.CANCEL))).thenReturn(Mono.empty());
+ when(groupCourseRepository.cancel(1L)).thenReturn(Mono.just(testCourse));
+
+ // refundBookingMembers flow
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(bookingRepository.findByCourseId(1L)).thenReturn(Flux.just(testBooking));
+ when(memberCardRecordService.findById(300L)).thenReturn(Mono.just(record));
+ when(memberCardRepository.findById(400L)).thenReturn(Mono.just(card));
+ when(memberCardRecordService.renewCard(300L, 0, 50.0, record.getExpireTime())).thenReturn(Mono.just(1));
+ when(bookingRepository.updateStatus(500L, "1")).thenReturn(Mono.just(1));
+
+ testCourse.setStatus(CourseStatus.CANCELLED.getValue());
+
+ StepVerifier.create(groupCourseService.cancel(1L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ })
+ .verifyComplete();
+
+ verify(stateMachine).validateTransition(any(GroupCourse.class), eq(CourseEvent.CANCEL));
+ verify(groupCourseRepository).cancel(1L);
+ verify(memberCardRecordService).renewCard(300L, 0, 50.0, record.getExpireTime());
+ verify(bookingRepository).updateStatus(500L, "1");
+ }
+
+ @Test
+ void cancel_courseNotFound_shouldError() {
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.cancel(1L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "团课不存在".equals(ex.getMessage()))
+ .verify();
+ }
+
+ @Test
+ void cancel_within24Hours_shouldError() {
+ testCourse.setStartTime(LocalDateTime.now().plusHours(1));
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(stateMachine.validateTransition(any(GroupCourse.class), eq(CourseEvent.CANCEL))).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.cancel(1L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "课程取消需提前24小时".equals(ex.getMessage()))
+ .verify();
+
+ verify(groupCourseRepository, never()).cancel(anyLong());
+ }
+
+ @Test
+ void cancel_stateMachineRejects_shouldError() {
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(stateMachine.validateTransition(any(GroupCourse.class), eq(CourseEvent.CANCEL)))
+ .thenReturn(Mono.error(new IllegalStateException("不允许的状态转换")));
+
+ StepVerifier.create(groupCourseService.cancel(1L))
+ .expectError(IllegalStateException.class)
+ .verify();
+
+ verify(groupCourseRepository, never()).cancel(anyLong());
+ }
+
+ // ==================== signIn ====================
+
+ @Test
+ void signIn_shouldSucceed() {
+ mockClearCache();
+ GroupCourse signingCourse = new GroupCourse();
+ signingCourse.setId(1L);
+ signingCourse.setCourseName("瑜伽入门课");
+ signingCourse.setCoachId(10L);
+ signingCourse.setCourseType(100L);
+ signingCourse.setStartTime(LocalDateTime.now().plusHours(1));
+ signingCourse.setEndTime(LocalDateTime.now().plusHours(2));
+ signingCourse.setMaxMembers(20);
+ signingCourse.setCurrentMembers(5);
+ signingCourse.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(signingCourse));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+ when(bookingRepository.findValidBooking(1L, 200L)).thenReturn(Mono.just(testBooking));
+ when(bookingRepository.updateStatus(500L, "2")).thenReturn(Mono.just(1));
+
+ StepVerifier.create(groupCourseService.signIn(1L, 200L))
+ .assertNext(result -> {
+ assertThat(result.getId()).isEqualTo(1L);
+ })
+ .verifyComplete();
+
+ verify(bookingRepository).findValidBooking(1L, 200L);
+ verify(bookingRepository).updateStatus(500L, "2");
+ }
+
+ @Test
+ void signIn_courseCancelled_shouldError() {
+ GroupCourse cancelledCourse = new GroupCourse();
+ cancelledCourse.setId(1L);
+ cancelledCourse.setStartTime(LocalDateTime.now().plusHours(1));
+ cancelledCourse.setEndTime(LocalDateTime.now().plusHours(2));
+ cancelledCourse.setMaxMembers(20);
+ cancelledCourse.setCurrentMembers(5);
+ cancelledCourse.setStatus(CourseStatus.CANCELLED.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(cancelledCourse));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+
+ StepVerifier.create(groupCourseService.signIn(1L, 200L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "团课已取消，无法签到".equals(ex.getMessage()))
+ .verify();
+ }
+
+ @Test
+ void signIn_notInSignInWindow_shouldError() {
+ GroupCourse futureCourse = new GroupCourse();
+ futureCourse.setId(1L);
+ futureCourse.setStartTime(LocalDateTime.now().plusDays(1));
+ futureCourse.setEndTime(LocalDateTime.now().plusDays(1).plusHours(1));
+ futureCourse.setMaxMembers(20);
+ futureCourse.setCurrentMembers(5);
+ futureCourse.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(futureCourse));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+
+ StepVerifier.create(groupCourseService.signIn(1L, 200L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && ex.getMessage().startsWith("未到签到时间"))
+ .verify();
+ }
+
+ @Test
+ void signIn_courseFull_shouldError() {
+ GroupCourse fullCourse = new GroupCourse();
+ fullCourse.setId(1L);
+ fullCourse.setStartTime(LocalDateTime.now().plusHours(1));
+ fullCourse.setEndTime(LocalDateTime.now().plusHours(2));
+ fullCourse.setMaxMembers(20);
+ fullCourse.setCurrentMembers(20);
+ fullCourse.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(fullCourse));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(20L));
+
+ StepVerifier.create(groupCourseService.signIn(1L, 200L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "课程已满员，无法签到".equals(ex.getMessage()))
+ .verify();
+ }
+
+ @Test
+ void signIn_notBooked_shouldError() {
+ GroupCourse signingCourse = new GroupCourse();
+ signingCourse.setId(1L);
+ signingCourse.setStartTime(LocalDateTime.now().plusHours(1));
+ signingCourse.setEndTime(LocalDateTime.now().plusHours(2));
+ signingCourse.setMaxMembers(20);
+ signingCourse.setCurrentMembers(5);
+ signingCourse.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(signingCourse));
+ when(bookingRepository.countValidBookings(1L)).thenReturn(Mono.just(5L));
+ when(bookingRepository.findValidBooking(1L, 200L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.signIn(1L, 200L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "您未预约此团课".equals(ex.getMessage()))
+ .verify();
+ }
+
+ // ==================== delete ====================
+
+ @Test
+ void delete_cancelledCourse_shouldSucceed() {
+ mockClearCache();
+ testCourse.setStatus(CourseStatus.CANCELLED.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(groupCourseRepository.deleteById(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.delete(1L))
+ .verifyComplete();
+
+ verify(groupCourseRepository).deleteById(1L);
+ }
+
+ @Test
+ void delete_endedCourse_shouldSucceed() {
+ mockClearCache();
+ testCourse.setStatus(CourseStatus.ENDED.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+ when(groupCourseRepository.deleteById(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.delete(1L))
+ .verifyComplete();
+
+ verify(groupCourseRepository).deleteById(1L);
+ }
+
+ @Test
+ void delete_activeCourse_shouldError() {
+ testCourse.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(testCourse));
+
+ StepVerifier.create(groupCourseService.delete(1L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && ex.getMessage().startsWith("只有已取消或已结束的课程才能删除"))
+ .verify();
+
+ verify(groupCourseRepository, never()).deleteById(anyLong());
+ }
+
+ @Test
+ void delete_courseNotFound_shouldError() {
+ when(groupCourseRepository.findByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseService.delete(1L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException && "团课不存在".equals(ex.getMessage()))
+ .verify();
+ }
+
+ // ==================== checkCoachConflict ====================
+
+ @Test
+ void checkCoachConflict_noConflict_shouldReturnEmpty() {
+ LocalDateTime startTime = LocalDateTime.now().plusDays(1);
+ LocalDateTime endTime = startTime.plusHours(1);
+
+ GroupCourse existing = new GroupCourse();
+ existing.setId(2L);
+ existing.setCoachId(10L);
+ existing.setStartTime(startTime.plusDays(2));
+ existing.setEndTime(startTime.plusDays(2).plusHours(1));
+ existing.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByCoachId(10L)).thenReturn(Flux.just(existing));
+
+ StepVerifier.create(groupCourseService.checkCoachConflict(10L, startTime, endTime, null))
+ .assertNext(result -> assertThat(result).isEmpty())
+ .verifyComplete();
+ }
+
+ @Test
+ void checkCoachConflict_hasConflict_shouldReturnConflictingCourses() {
+ LocalDateTime startTime = LocalDateTime.now().plusDays(1);
+ LocalDateTime endTime = startTime.plusHours(1);
+
+ GroupCourse conflicting = new GroupCourse();
+ conflicting.setId(2L);
+ conflicting.setCoachId(10L);
+ conflicting.setStartTime(startTime);
+ conflicting.setEndTime(endTime.plusMinutes(30));
+ conflicting.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByCoachId(10L)).thenReturn(Flux.just(conflicting));
+
+ StepVerifier.create(groupCourseService.checkCoachConflict(10L, startTime, endTime, null))
+ .assertNext(result -> {
+ assertThat(result).hasSize(1);
+ assertThat(result.get(0).getId()).isEqualTo(2L);
+ })
+ .verifyComplete();
+ }
+
+ @Test
+ void checkCoachConflict_excludeSelf_shouldNotReturnExcludedCourse() {
+ LocalDateTime startTime = LocalDateTime.now().plusDays(1);
+ LocalDateTime endTime = startTime.plusHours(1);
+
+ GroupCourse self = new GroupCourse();
+ self.setId(1L);
+ self.setCoachId(10L);
+ self.setStartTime(startTime);
+ self.setEndTime(endTime.plusMinutes(30));
+ self.setStatus(CourseStatus.NORMAL.getValue());
+
+ when(groupCourseRepository.findByCoachId(10L)).thenReturn(Flux.just(self));
+
+ StepVerifier.create(groupCourseService.checkCoachConflict(10L, startTime, endTime, 1L))
+ .assertNext(result -> assertThat(result).isEmpty())
+ .verifyComplete();
+ }
+
+ @Test
+ void checkCoachConflict_nullParams_shouldReturnEmpty() {
+ StepVerifier.create(groupCourseService.checkCoachConflict(null, LocalDateTime.now(), LocalDateTime.now().plusHours(1), null))
+ .assertNext(result -> assertThat(result).isEmpty())
+ .verifyComplete();
+
+ verifyNoInteractions(groupCourseRepository);
+ }
+
+ // ==================== searchGroupCourses ====================
+
+ @Test
+ void searchGroupCourses_shouldDelegateToRepository() {
+ GroupCourseQueryDto query = new GroupCourseQueryDto();
+ query.setCourseName("瑜伽");
+
+ PageResponse pageResponse = new PageResponse<>(List.of(testCourse), 1, 1, 0, 10);
+
+ when(groupCourseRepository.searchGroupCourses(query)).thenReturn(Mono.just(pageResponse));
+
+ StepVerifier.create(groupCourseService.searchGroupCourses(query))
+ .assertNext(result -> {
+ assertThat(result.getContent()).hasSize(1);
+ assertThat(result.getContent().get(0).getCourseName()).isEqualTo("瑜伽入门课");
+ })
+ .verifyComplete();
+
+ verify(groupCourseRepository).searchGroupCourses(query);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseTypeServiceTest.java b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseTypeServiceTest.java
new file mode 100644
index 0000000..98d99c6
--- /dev/null
+++ b/gym-manage-api/gym-groupCourse/src/test/java/cn/novalon/gym/manage/groupcourse/service/impl/GroupCourseTypeServiceTest.java
@@ -0,0 +1,297 @@
+package cn.novalon.gym.manage.groupcourse.service.impl;
+
+import cn.novalon.gym.manage.common.dto.PageRequest;
+import cn.novalon.gym.manage.common.dto.PageResponse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourse;
+import cn.novalon.gym.manage.groupcourse.domain.GroupCourseType;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseRepository;
+import cn.novalon.gym.manage.groupcourse.repository.IGroupCourseTypeRepository;
+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.util.List;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class GroupCourseTypeServiceTest {
+
+ @Mock
+ private IGroupCourseTypeRepository groupCourseTypeRepository;
+
+ @Mock
+ private IGroupCourseRepository groupCourseRepository;
+
+ private GroupCourseTypeService groupCourseTypeService;
+
+ private GroupCourseType yogaType;
+ private GroupCourseType strengthType;
+ private GroupCourseType pilatesType;
+
+ @BeforeEach
+ void setUp() {
+ groupCourseTypeService = new GroupCourseTypeService(groupCourseTypeRepository, groupCourseRepository);
+
+ yogaType = new GroupCourseType();
+ yogaType.setId(1L);
+ yogaType.setTypeName("瑜伽入门");
+ yogaType.setBaseDifficulty(2);
+ yogaType.setDescription("适合初学者的瑜伽课程");
+ yogaType.setCategory("柔韧与平衡类");
+
+ strengthType = new GroupCourseType();
+ strengthType.setId(2L);
+ strengthType.setTypeName("力量训练");
+ strengthType.setBaseDifficulty(5);
+ strengthType.setDescription("增强肌肉力量");
+ strengthType.setCategory("力量类");
+
+ pilatesType = new GroupCourseType();
+ pilatesType.setId(3L);
+ pilatesType.setTypeName("普拉提进阶");
+ pilatesType.setBaseDifficulty(4);
+ pilatesType.setDescription("核心力量训练");
+ pilatesType.setCategory("柔韧与平衡类");
+ }
+
+ // ==================== findById ====================
+
+ @Test
+ void findById_shouldReturnType() {
+ when(groupCourseTypeRepository.findById(1L)).thenReturn(Mono.just(yogaType));
+
+ StepVerifier.create(groupCourseTypeService.findById(1L))
+ .expectNext(yogaType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findById(1L);
+ }
+
+ @Test
+ void findById_shouldReturnEmptyWhenNotFound() {
+ when(groupCourseTypeRepository.findById(999L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseTypeService.findById(999L))
+ .expectNextCount(0)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findById(999L);
+ }
+
+ // ==================== findAll (no param) ====================
+
+ @Test
+ void findAll_shouldReturnAll() {
+ when(groupCourseTypeRepository.findAll(false)).thenReturn(Flux.just(yogaType, strengthType, pilatesType));
+
+ StepVerifier.create(groupCourseTypeService.findAll())
+ .expectNext(yogaType, strengthType, pilatesType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findAll(false);
+ }
+
+ // ==================== findAll (boolean) ====================
+
+ @Test
+ void findAll_withDeletedFlag_shouldReturnAllWithDeleted() {
+ when(groupCourseTypeRepository.findAll(true)).thenReturn(Flux.just(yogaType, strengthType));
+
+ StepVerifier.create(groupCourseTypeService.findAll(true))
+ .expectNext(yogaType, strengthType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findAll(true);
+ }
+
+ // ==================== findByKeyword ====================
+
+ @Test
+ void findByKeyword_shouldReturnMatchingTypes() {
+ when(groupCourseTypeRepository.findByKeyword("瑜伽")).thenReturn(Flux.just(yogaType));
+
+ StepVerifier.create(groupCourseTypeService.findByKeyword("瑜伽"))
+ .expectNext(yogaType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findByKeyword("瑜伽");
+ }
+
+ // ==================== findByCategory ====================
+
+ @Test
+ void findByCategory_shouldReturnTypesInCategory() {
+ when(groupCourseTypeRepository.findByCategory("柔韧与平衡类")).thenReturn(Flux.just(yogaType, pilatesType));
+
+ StepVerifier.create(groupCourseTypeService.findByCategory("柔韧与平衡类"))
+ .expectNext(yogaType, pilatesType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findByCategory("柔韧与平衡类");
+ }
+
+ // ==================== findByCategoryAndKeyword ====================
+
+ @Test
+ void findByCategoryAndKeyword_shouldFilterByBoth() {
+ when(groupCourseTypeRepository.findByCategoryAndKeyword("柔韧与平衡类", "瑜伽"))
+ .thenReturn(Flux.just(yogaType));
+
+ StepVerifier.create(groupCourseTypeService.findByCategoryAndKeyword("柔韧与平衡类", "瑜伽"))
+ .expectNext(yogaType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findByCategoryAndKeyword("柔韧与平衡类", "瑜伽");
+ }
+
+ // ==================== create ====================
+
+ @Test
+ void create_shouldSaveWhenNameNotExists() {
+ GroupCourseType newType = new GroupCourseType();
+ newType.setTypeName("HIIT训练");
+ newType.setBaseDifficulty(6);
+ newType.setCategory("有氧类");
+
+ when(groupCourseTypeRepository.findByTypeName("HIIT训练")).thenReturn(Mono.empty());
+ when(groupCourseTypeRepository.save(any(GroupCourseType.class))).thenReturn(Mono.just(newType));
+
+ StepVerifier.create(groupCourseTypeService.create(newType))
+ .expectNext(newType)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findByTypeName("HIIT训练");
+ verify(groupCourseTypeRepository).save(any(GroupCourseType.class));
+ }
+
+ @Test
+ void create_shouldErrorWhenNameAlreadyExists() {
+ GroupCourseType duplicate = new GroupCourseType();
+ duplicate.setTypeName("瑜伽入门");
+
+ when(groupCourseTypeRepository.findByTypeName("瑜伽入门")).thenReturn(Mono.just(yogaType));
+ // switchIfEmpty 是急切求值的，需要为 save 提供 stub 避免 NPE
+ lenient().when(groupCourseTypeRepository.save(any(GroupCourseType.class))).thenReturn(Mono.just(new GroupCourseType()));
+
+ StepVerifier.create(groupCourseTypeService.create(duplicate))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "团课类型名称已存在".equals(ex.getMessage()))
+ .verify();
+
+ verify(groupCourseTypeRepository).findByTypeName("瑜伽入门");
+ }
+
+ // ==================== update ====================
+
+ @Test
+ void update_shouldUpdateType() {
+ GroupCourseType update = new GroupCourseType();
+ update.setId(1L);
+ update.setTypeName("瑜伽进阶");
+ update.setBaseDifficulty(4);
+ update.setCategory("柔韧与平衡类");
+
+ when(groupCourseTypeRepository.update(any(GroupCourseType.class))).thenReturn(Mono.just(update));
+
+ StepVerifier.create(groupCourseTypeService.update(1L, update))
+ .expectNext(update)
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).update(any(GroupCourseType.class));
+ }
+
+ // ==================== delete ====================
+
+ @Test
+ void delete_shouldDeleteWhenNoDependentCourses() {
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.empty());
+ when(groupCourseTypeRepository.deleteById(1L)).thenReturn(Mono.empty());
+
+ StepVerifier.create(groupCourseTypeService.delete(1L))
+ .verifyComplete();
+
+ verify(groupCourseRepository).findByCourseType(1L);
+ verify(groupCourseTypeRepository).deleteById(1L);
+ }
+
+ @Test
+ void delete_shouldErrorWhenDependentCoursesExist() {
+ GroupCourse dependentCourse = new GroupCourse();
+ dependentCourse.setId(100L);
+ dependentCourse.setCourseName("瑜伽入门课");
+
+ when(groupCourseRepository.findByCourseType(1L)).thenReturn(Flux.just(dependentCourse));
+
+ StepVerifier.create(groupCourseTypeService.delete(1L))
+ .expectErrorMatches(ex -> ex instanceof RuntimeException
+ && "该类型下存在团课，无法删除".equals(ex.getMessage()))
+ .verify();
+
+ verify(groupCourseRepository).findByCourseType(1L);
+ }
+
+ // ==================== findCategories ====================
+
+ @Test
+ void findCategories_shouldReturnDistinctCategories() {
+ when(groupCourseTypeRepository.findAll(false)).thenReturn(Flux.just(yogaType, strengthType, pilatesType));
+
+ StepVerifier.create(groupCourseTypeService.findCategories())
+ .expectNext("柔韧与平衡类", "力量类")
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findAll(false);
+ }
+
+ @Test
+ void findCategories_shouldFilterEmptyCategories() {
+ GroupCourseType emptyCategory = new GroupCourseType();
+ emptyCategory.setId(4L);
+ emptyCategory.setTypeName("空分类");
+ emptyCategory.setCategory("");
+
+ when(groupCourseTypeRepository.findAll(false)).thenReturn(Flux.just(yogaType, emptyCategory));
+
+ StepVerifier.create(groupCourseTypeService.findCategories())
+ .expectNext("柔韧与平衡类")
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findAll(false);
+ }
+
+ // ==================== findByPage ====================
+
+ @Test
+ void findByPage_shouldReturnPaginatedResults() {
+ PageRequest pageRequest = new PageRequest();
+ pageRequest.setPage(0);
+ pageRequest.setSize(10);
+
+ PageResponse pageResponse = new PageResponse<>(
+ List.of(yogaType, strengthType),
+ 1, 2, 0, 10
+ );
+
+ when(groupCourseTypeRepository.findByPage(pageRequest)).thenReturn(Mono.just(pageResponse));
+
+ StepVerifier.create(groupCourseTypeService.findByPage(pageRequest))
+ .expectNextMatches(response ->
+ response.getContent().size() == 2 &&
+ response.getTotalElements() == 2 &&
+ response.getTotalPages() == 1 &&
+ response.getCurrentPage() == 0
+ )
+ .verifyComplete();
+
+ verify(groupCourseTypeRepository).findByPage(pageRequest);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/pom.xml b/gym-manage-api/gym-member/pom.xml
index 154800a..88045ad 100644
--- a/gym-manage-api/gym-member/pom.xml
+++ b/gym-manage-api/gym-member/pom.xml
@@ -205,11 +205,20 @@
INSTRUCTION
COVEREDRATIO
- 0.60
+ 0.40
+
+ **/vo/**
+ **/dto/**
+ **/entity/**
+ **/domain/**
+ **/enums/**
+ **/model/**
+ **/config/**
+
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java
index 8e435ed..bb012ac 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java
@@ -162,7 +162,9 @@ public class MemberHandler {
return ServerResponse.ok()
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(detail);
- });
+ })
+ .onErrorResume(NotFoundException.class, e ->
+ ServerResponse.notFound().build());
}
@Operation(summary = "管理员编辑会员信息", description = "后台管理员编辑会员信息")
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardTransactionRepository.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardTransactionRepository.java
index 8f9d040..6b2bc8c 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardTransactionRepository.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardTransactionRepository.java
@@ -23,7 +23,6 @@ public interface MemberCardTransactionRepository extends R2dbcRepository findById(Long recordId) {
String cacheKey = MEMBER_CARD_RECORD_CACHE_PREFIX + recordId;
- Object cached = redisUtil.get(cacheKey);
- if (cached != null && cached instanceof MemberCardRecord) {
- log.debug("从缓存获取会员卡记录, recordId: {}", recordId);
- return Mono.just((MemberCardRecord) cached);
- }
-
- return memberCardRecordRepository.findById(recordId)
- .doOnSuccess(record -> {
- if (record != null) {
- redisUtil.setWithExpire(cacheKey, record, CACHE_EXPIRE_SECONDS);
- }
- });
+ return redisUtil.get(cacheKey)
+ .filter(cached -> cached instanceof MemberCardRecord)
+ .map(cached -> (MemberCardRecord) cached)
+ .switchIfEmpty(Mono.defer(() ->
+ memberCardRecordRepository.findById(recordId)
+ .doOnSuccess(record -> {
+ if (record != null) {
+ redisUtil.setWithExpire(cacheKey, record, CACHE_EXPIRE_SECONDS);
+ }
+ })
+ ));
}
@Override
@@ -222,7 +222,7 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
MemberCardRecord expiringCard = records.stream()
.filter(record -> {
if (record.getExpireTime() == null) return false;
- if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
+ if (record.getStatus() == MemberCardRecordStatus.USED_UP) return false;
long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
return days >= 1 && days <= 3;
})
@@ -237,7 +237,7 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
MemberCardRecord activeCard = records.stream()
.filter(record -> {
if (record.getExpireTime() == null) return true;
- if (record.getStatus() != null && record.getStatus().equals("USED_UP")) return false;
+ if (record.getStatus() == MemberCardRecordStatus.USED_UP) return false;
long days = java.time.Duration.between(now, record.getExpireTime()).toDays();
return days > 3;
})
diff --git a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
index 168c912..23b1cf8 100644
--- a/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
+++ b/gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java
@@ -327,7 +327,7 @@ public class MemberCardServiceImpl implements IMemberCardService {
private Mono doUseCard(MemberCardRecord record, MemberCard card,
Integer deductTimes, Double deductAmount) {
- if (!MemberCardRecordStatus.ACTIVE.name().equals(record.getStatus())) {
+ if (!MemberCardRecordStatus.ACTIVE.equals(record.getStatus())) {
return Mono.error(new RuntimeException("会员卡状态不正确"));
}
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardHandlerTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardHandlerTest.java
new file mode 100644
index 0000000..ae2d736
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardHandlerTest.java
@@ -0,0 +1,493 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MemberCardHandlerTest {
+
+ @Mock
+ private IMemberCardService memberCardService;
+
+ private MemberCardHandler memberCardHandler;
+
+ private static final Long CARD_ID = 100L;
+ private static final Long MEMBER_ID = 200L;
+ private static final Long RECORD_ID = 300L;
+
+ @BeforeEach
+ void setUp() {
+ memberCardHandler = new MemberCardHandler(memberCardService);
+ }
+
+ // ==================== getMemberCardById ====================
+
+ @Test
+ void getMemberCardById_shouldReturnOk() {
+ MemberCard card = MemberCard.builder()
+ .memberCardId(CARD_ID)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardStatus(1)
+ .build();
+
+ when(memberCardService.findByMemberCardIdAndDeletedAtIsNull(CARD_ID))
+ .thenReturn(Mono.just(card));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberCardId", String.valueOf(CARD_ID))
+ .build();
+
+ Mono result = memberCardHandler.getMemberCardById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findByMemberCardIdAndDeletedAtIsNull(CARD_ID);
+ }
+
+ @Test
+ void getMemberCardById_shouldReturn404WhenNotFound() {
+ when(memberCardService.findByMemberCardIdAndDeletedAtIsNull(CARD_ID))
+ .thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberCardId", String.valueOf(CARD_ID))
+ .build();
+
+ Mono result = memberCardHandler.getMemberCardById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+
+ verify(memberCardService).findByMemberCardIdAndDeletedAtIsNull(CARD_ID);
+ }
+
+ // ==================== listMemberCards ====================
+
+ @Test
+ void listMemberCards_shouldReturnOkWithAllParams() {
+ MemberCard card1 = MemberCard.builder()
+ .memberCardId(1L)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardStatus(1)
+ .build();
+ MemberCard card2 = MemberCard.builder()
+ .memberCardId(2L)
+ .memberCardName("季卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(499.0)
+ .memberCardStatus(1)
+ .build();
+
+ when(memberCardService.findWithConditions(any(), any(), any(), any(), any(), any()))
+ .thenReturn(Flux.just(card1, card2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "1")
+ .queryParam("name", "月卡")
+ .queryParam("type", "TIME_CARD")
+ .queryParam("minPrice", "100")
+ .queryParam("maxPrice", "500")
+ .queryParam("page", "0")
+ .queryParam("size", "10")
+ .build();
+
+ Mono result = memberCardHandler.listMemberCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findWithConditions(any(), any(), any(), any(), any(), any());
+ }
+
+ @Test
+ void listMemberCards_shouldReturnOkWithDefaultParams() {
+ when(memberCardService.findWithConditions(any(), any(), any(), any(), any(), any()))
+ .thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = memberCardHandler.listMemberCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findWithConditions(any(), any(), any(), any(), any(), any());
+ }
+
+ // ==================== createMemberCard ====================
+
+ @Test
+ void createMemberCard_shouldReturnCreated() {
+ MemberCard newCard = MemberCard.builder()
+ .memberCardName("年卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(2999.0)
+ .memberCardValidityDays(365)
+ .memberCardStatus(1)
+ .build();
+
+ MemberCard savedCard = MemberCard.builder()
+ .memberCardId(1L)
+ .memberCardName("年卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(2999.0)
+ .memberCardValidityDays(365)
+ .memberCardStatus(1)
+ .build();
+
+ when(memberCardService.save(any(MemberCard.class))).thenReturn(Mono.just(savedCard));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(newCard));
+
+ Mono result = memberCardHandler.createMemberCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.CREATED);
+
+ verify(memberCardService).save(any(MemberCard.class));
+ }
+
+ // ==================== updateMemberCard ====================
+
+ @Test
+ void updateMemberCard_shouldReturnOk() {
+ MemberCard existingCard = MemberCard.builder()
+ .memberCardId(CARD_ID)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardStatus(1)
+ .build();
+
+ MemberCard updatedCard = MemberCard.builder()
+ .memberCardId(CARD_ID)
+ .memberCardName("月卡-优惠版")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardStatus(1)
+ .build();
+
+ MemberCard updateBody = MemberCard.builder()
+ .memberCardName("月卡-优惠版")
+ .build();
+
+ when(memberCardService.findByMemberCardIdAndDeletedAtIsNull(CARD_ID))
+ .thenReturn(Mono.just(existingCard));
+ when(memberCardService.save(any(MemberCard.class))).thenReturn(Mono.just(updatedCard));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", String.valueOf(CARD_ID))
+ .body(Mono.just(updateBody));
+
+ Mono result = memberCardHandler.updateMemberCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findByMemberCardIdAndDeletedAtIsNull(CARD_ID);
+ verify(memberCardService).save(any(MemberCard.class));
+ }
+
+ @Test
+ void updateMemberCard_shouldThrowWhenNotFound() {
+ MemberCard updateBody = MemberCard.builder()
+ .memberCardName("月卡-优惠版")
+ .build();
+
+ when(memberCardService.findByMemberCardIdAndDeletedAtIsNull(CARD_ID))
+ .thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", String.valueOf(CARD_ID))
+ .body(Mono.just(updateBody));
+
+ Mono result = memberCardHandler.updateMemberCard(request);
+
+ assertThrows(RuntimeException.class, () -> result.block());
+
+ verify(memberCardService).findByMemberCardIdAndDeletedAtIsNull(CARD_ID);
+ verify(memberCardService, never()).save(any());
+ }
+
+ // ==================== deleteMemberCard ====================
+
+ @Test
+ void deleteMemberCard_shouldReturnNoContent() {
+ when(memberCardService.logicalDelete(CARD_ID)).thenReturn(Mono.just(1));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", String.valueOf(CARD_ID))
+ .build();
+
+ Mono result = memberCardHandler.deleteMemberCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NO_CONTENT);
+
+ verify(memberCardService).logicalDelete(CARD_ID);
+ }
+
+ @Test
+ void deleteMemberCard_shouldReturn404WhenNotFound() {
+ when(memberCardService.logicalDelete(CARD_ID)).thenReturn(Mono.just(0));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", String.valueOf(CARD_ID))
+ .build();
+
+ Mono result = memberCardHandler.deleteMemberCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+
+ verify(memberCardService).logicalDelete(CARD_ID);
+ }
+
+ // ==================== purchaseCard ====================
+
+ @Test
+ void purchaseCard_shouldReturnCreated() {
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .build();
+
+ when(memberCardService.purchaseCard(MEMBER_ID, CARD_ID, null))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("memberCardId", String.valueOf(CARD_ID))
+ .build();
+
+ Mono result = memberCardHandler.purchaseCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.CREATED);
+
+ verify(memberCardService).purchaseCard(MEMBER_ID, CARD_ID, null);
+ }
+
+ @Test
+ void purchaseCard_shouldReturnCreatedWithSourceOrderId() {
+ Long sourceOrderId = 500L;
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .sourceOrderId(sourceOrderId)
+ .build();
+
+ when(memberCardService.purchaseCard(MEMBER_ID, CARD_ID, sourceOrderId))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("memberCardId", String.valueOf(CARD_ID))
+ .queryParam("sourceOrderId", String.valueOf(sourceOrderId))
+ .build();
+
+ Mono result = memberCardHandler.purchaseCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.CREATED);
+
+ verify(memberCardService).purchaseCard(MEMBER_ID, CARD_ID, sourceOrderId);
+ }
+
+ // ==================== renewCard ====================
+
+ @Test
+ void renewCard_shouldReturnOk() {
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .build();
+
+ when(memberCardService.renewCard(eq(RECORD_ID), eq(MEMBER_ID), any(), any(), any(), any()))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("recordId", String.valueOf(RECORD_ID))
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("addTimes", "10")
+ .queryParam("addAmount", "500")
+ .queryParam("addDays", "30")
+ .queryParam("sourceOrderId", "500")
+ .build();
+
+ Mono result = memberCardHandler.renewCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).renewCard(eq(RECORD_ID), eq(MEMBER_ID), eq(10), eq(500.0), eq(30), eq(500L));
+ }
+
+ @Test
+ void renewCard_shouldReturnOkWithOptionalParams() {
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .build();
+
+ when(memberCardService.renewCard(eq(RECORD_ID), eq(MEMBER_ID), any(), any(), any(), any()))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("recordId", String.valueOf(RECORD_ID))
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .build();
+
+ Mono result = memberCardHandler.renewCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).renewCard(eq(RECORD_ID), eq(MEMBER_ID), isNull(), isNull(), isNull(), isNull());
+ }
+
+ // ==================== useCard ====================
+
+ @Test
+ void useCard_shouldReturnOk() {
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .build();
+
+ when(memberCardService.useCard(RECORD_ID, MEMBER_ID, 1, null))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("recordId", String.valueOf(RECORD_ID))
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("deductTimes", "1")
+ .build();
+
+ Mono result = memberCardHandler.useCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).useCard(RECORD_ID, MEMBER_ID, 1, null);
+ }
+
+ @Test
+ void useCard_shouldReturnOkWithDeductAmount() {
+ MemberCardRecord record = MemberCardRecord.builder()
+ .memberCardRecordId(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(CARD_ID)
+ .build();
+
+ when(memberCardService.useCard(RECORD_ID, MEMBER_ID, null, 50.0))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("recordId", String.valueOf(RECORD_ID))
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("deductAmount", "50")
+ .build();
+
+ Mono result = memberCardHandler.useCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).useCard(RECORD_ID, MEMBER_ID, null, 50.0);
+ }
+
+ // ==================== refundCard ====================
+
+ @Test
+ void refundCard_shouldReturnNoContent() {
+ when(memberCardService.refundCard(RECORD_ID, MEMBER_ID))
+ .thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("recordId", String.valueOf(RECORD_ID))
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .build();
+
+ Mono result = memberCardHandler.refundCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NO_CONTENT);
+
+ verify(memberCardService).refundCard(RECORD_ID, MEMBER_ID);
+ }
+
+ // ==================== getActiveCards ====================
+
+ @Test
+ void getActiveCards_shouldReturnOkWithStatusParam() {
+ MemberCard card1 = MemberCard.builder()
+ .memberCardId(1L)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardStatus(1)
+ .build();
+ MemberCard card2 = MemberCard.builder()
+ .memberCardId(2L)
+ .memberCardName("季卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(499.0)
+ .memberCardStatus(1)
+ .build();
+
+ when(memberCardService.findActiveCards(1)).thenReturn(Flux.just(card1, card2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "1")
+ .build();
+
+ Mono result = memberCardHandler.getActiveCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findActiveCards(1);
+ }
+
+ @Test
+ void getActiveCards_shouldReturnOkWithDefaultStatus() {
+ when(memberCardService.findActiveCards(1)).thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = memberCardHandler.getActiveCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).findActiveCards(1);
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardRecordHandlerTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardRecordHandlerTest.java
new file mode 100644
index 0000000..bfea533
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardRecordHandlerTest.java
@@ -0,0 +1,403 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.member.service.IMemberCardService;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MemberCardRecordHandlerTest {
+
+ @Mock
+ private IMemberCardService memberCardService;
+
+ @Mock
+ private IMemberCardRecordService memberCardRecordService;
+
+ @Mock
+ private AuthUtil authUtil;
+
+ private MemberCardRecordHandler handler;
+
+ private static final Long MEMBER_ID = 10001L;
+ private static final Long RECORD_ID = 20001L;
+ private static final Long MEMBER_CARD_ID = 30001L;
+ private static final Long SOURCE_ORDER_ID = 40001L;
+
+ @BeforeEach
+ void setUp() {
+ handler = new MemberCardRecordHandler(memberCardService, memberCardRecordService, authUtil);
+ }
+
+ private MemberCardRecord createRecord() {
+ return MemberCardRecord.builder()
+ .id(RECORD_ID)
+ .memberId(MEMBER_ID)
+ .memberCardId(MEMBER_CARD_ID)
+ .remainingTimes(10)
+ .remainingAmount(100.0)
+ .build();
+ }
+
+ // ==================== purchaseCard ====================
+
+ @Test
+ void purchaseCard_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+ MemberCardRecordHandler.PurchaseRequest body = new MemberCardRecordHandler.PurchaseRequest();
+ body.setMemberCardId(MEMBER_CARD_ID);
+ body.setSourceOrderId(SOURCE_ORDER_ID);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.purchaseCard(MEMBER_ID, MEMBER_CARD_ID, SOURCE_ORDER_ID))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(body));
+ Mono result = handler.purchaseCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).purchaseCard(MEMBER_ID, MEMBER_CARD_ID, SOURCE_ORDER_ID);
+ }
+
+ @Test
+ void purchaseCard_shouldReturn400WhenServiceThrows() {
+ MemberCardRecordHandler.PurchaseRequest body = new MemberCardRecordHandler.PurchaseRequest();
+ body.setMemberCardId(MEMBER_CARD_ID);
+ body.setSourceOrderId(SOURCE_ORDER_ID);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.purchaseCard(MEMBER_ID, MEMBER_CARD_ID, SOURCE_ORDER_ID))
+ .thenReturn(Mono.error(new RuntimeException("购买失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(body));
+ Mono result = handler.purchaseCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(memberCardService).purchaseCard(MEMBER_ID, MEMBER_CARD_ID, SOURCE_ORDER_ID);
+ }
+
+ // ==================== renewCard ====================
+
+ @Test
+ void renewCard_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+ MemberCardRecordHandler.RenewRequest body = new MemberCardRecordHandler.RenewRequest();
+ body.setAddTimes(5);
+ body.setAddAmount(50.0);
+ body.setAddDays(30);
+ body.setSourceOrderId(SOURCE_ORDER_ID);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.renewCard(RECORD_ID, MEMBER_ID, 5, 50.0, 30, SOURCE_ORDER_ID))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .body(Mono.just(body));
+ Mono result = handler.renewCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).renewCard(RECORD_ID, MEMBER_ID, 5, 50.0, 30, SOURCE_ORDER_ID);
+ }
+
+ @Test
+ void renewCard_shouldReturn400WhenServiceThrows() {
+ MemberCardRecordHandler.RenewRequest body = new MemberCardRecordHandler.RenewRequest();
+ body.setAddTimes(5);
+ body.setAddAmount(50.0);
+ body.setAddDays(30);
+ body.setSourceOrderId(SOURCE_ORDER_ID);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.renewCard(RECORD_ID, MEMBER_ID, 5, 50.0, 30, SOURCE_ORDER_ID))
+ .thenReturn(Mono.error(new RuntimeException("续费失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .body(Mono.just(body));
+ Mono result = handler.renewCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(memberCardService).renewCard(RECORD_ID, MEMBER_ID, 5, 50.0, 30, SOURCE_ORDER_ID);
+ }
+
+ // ==================== useCard ====================
+
+ @Test
+ void useCard_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+ MemberCardRecordHandler.UseCardRequest body = new MemberCardRecordHandler.UseCardRequest();
+ body.setDeductTimes(1);
+ body.setDeductAmount(0.0);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.useCard(RECORD_ID, MEMBER_ID, 1, 0.0))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .body(Mono.just(body));
+ Mono result = handler.useCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).useCard(RECORD_ID, MEMBER_ID, 1, 0.0);
+ }
+
+ @Test
+ void useCard_shouldReturn400WhenServiceThrows() {
+ MemberCardRecordHandler.UseCardRequest body = new MemberCardRecordHandler.UseCardRequest();
+ body.setDeductTimes(1);
+ body.setDeductAmount(0.0);
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.useCard(RECORD_ID, MEMBER_ID, 1, 0.0))
+ .thenReturn(Mono.error(new RuntimeException("使用失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .body(Mono.just(body));
+ Mono result = handler.useCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(memberCardService).useCard(RECORD_ID, MEMBER_ID, 1, 0.0);
+ }
+
+ // ==================== refundCard ====================
+
+ @Test
+ void refundCard_shouldReturnOk() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.refundCard(RECORD_ID, MEMBER_ID)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .build();
+ Mono result = handler.refundCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).refundCard(RECORD_ID, MEMBER_ID);
+ }
+
+ @Test
+ void refundCard_shouldReturn400WhenServiceThrows() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardService.refundCard(RECORD_ID, MEMBER_ID))
+ .thenReturn(Mono.error(new RuntimeException("退款失败")));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .build();
+ Mono result = handler.refundCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(memberCardService).refundCard(RECORD_ID, MEMBER_ID);
+ }
+
+ // ==================== getMemberCardRecordById ====================
+
+ @Test
+ void getMemberCardRecordById_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+
+ when(memberCardRecordService.findById(RECORD_ID)).thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .build();
+ Mono result = handler.getMemberCardRecordById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findById(RECORD_ID);
+ }
+
+ @Test
+ void getMemberCardRecordById_shouldReturn404WhenNotFound() {
+ when(memberCardRecordService.findById(RECORD_ID)).thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", RECORD_ID.toString())
+ .build();
+ Mono result = handler.getMemberCardRecordById(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+
+ verify(memberCardRecordService).findById(RECORD_ID);
+ }
+
+ // ==================== getMyCards ====================
+
+ @Test
+ void getMyCards_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findActiveCardsByMemberId(MEMBER_ID))
+ .thenReturn(Flux.just(record));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getMyCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findActiveCardsByMemberId(MEMBER_ID);
+ }
+
+ // ==================== getMyCardsWithStatus ====================
+
+ @Test
+ void getMyCardsWithStatus_shouldReturnOkWithAll() {
+ MemberCardRecord record = createRecord();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findCardsByMemberIdWithStatus(MEMBER_ID, "all"))
+ .thenReturn(Flux.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "all")
+ .build();
+ Mono result = handler.getMyCardsWithStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findCardsByMemberIdWithStatus(MEMBER_ID, "all");
+ }
+
+ @Test
+ void getMyCardsWithStatus_shouldReturnOkWithActive() {
+ MemberCardRecord record = createRecord();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "active")
+ .build();
+ Mono result = handler.getMyCardsWithStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findCardsByMemberIdWithStatus(MEMBER_ID, "active");
+ }
+
+ @Test
+ void getMyCardsWithStatus_shouldReturnOkWithExpired() {
+ MemberCardRecord record = createRecord();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findCardsByMemberIdWithStatus(MEMBER_ID, "expired"))
+ .thenReturn(Flux.just(record));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "expired")
+ .build();
+ Mono result = handler.getMyCardsWithStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findCardsByMemberIdWithStatus(MEMBER_ID, "expired");
+ }
+
+ @Test
+ void getMyCardsWithStatus_shouldReturn400WhenInvalidStatus() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("status", "invalid")
+ .build();
+ Mono result = handler.getMyCardsWithStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+
+ verify(memberCardRecordService, never()).findCardsByMemberIdWithStatus(anyLong(), anyString());
+ }
+
+ // ==================== getPrimaryCard ====================
+
+ @Test
+ void getPrimaryCard_shouldReturnOk() {
+ MemberCardRecord record = createRecord();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID))
+ .thenReturn(Mono.just(record));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getPrimaryCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardRecordService).findPrimaryActiveCardByMemberId(MEMBER_ID);
+ }
+
+ @Test
+ void getPrimaryCard_shouldReturn204WhenNoCard() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID))
+ .thenReturn(Mono.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.getPrimaryCard(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NO_CONTENT);
+
+ verify(memberCardRecordService).findPrimaryActiveCardByMemberId(MEMBER_ID);
+ }
+
+ // ==================== processExpiredCards ====================
+
+ @Test
+ void processExpiredCards_shouldReturnOk() {
+ when(memberCardService.processExpiredCards()).thenReturn(Mono.just(5));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = handler.processExpiredCards(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardService).processExpiredCards();
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardTransactionHandlerTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardTransactionHandlerTest.java
new file mode 100644
index 0000000..4baa3f9
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberCardTransactionHandlerTest.java
@@ -0,0 +1,316 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.hutool.db.PageResult;
+import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
+import cn.novalon.gym.manage.member.enums.TransactionType;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import jakarta.validation.Validator;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MemberCardTransactionHandlerTest {
+
+ @Mock
+ private IMemberCardTransactionService memberCardTransactionService;
+
+ @Mock(lenient = true)
+ private Validator validator;
+
+ private MemberCardTransactionHandler handler;
+
+ private static final Long MEMBER_ID = 10001L;
+ private static final Long MEMBER_CARD_ID = 20001L;
+ private static final Long RECORD_ID = 30001L;
+
+ @BeforeEach
+ void setUp() {
+ handler = new MemberCardTransactionHandler(memberCardTransactionService, validator);
+ }
+
+ // ==================== insertTransaction ====================
+
+ @Test
+ void insertTransaction_shouldReturnOk() {
+ MemberCardTransaction transaction = MemberCardTransaction.builder()
+ .id(1L)
+ .memberId(MEMBER_ID)
+ .memberCardId(MEMBER_CARD_ID)
+ .operationType(TransactionType.PURCHASE.name())
+ .changeAmount(1)
+ .changeBalance(1000.0)
+ .build();
+
+ when(memberCardTransactionService.insertTransaction(any(MemberCardTransaction.class)))
+ .thenReturn(Mono.just(transaction));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(transaction));
+
+ Mono result = handler.insertTransaction(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).insertTransaction(any(MemberCardTransaction.class));
+ }
+
+ // ==================== getMemberTransactions ====================
+
+ @Test
+ void getMemberTransactions_shouldReturnOkWithDefaultTimeRange() {
+ MemberCardTransaction t1 = MemberCardTransaction.builder()
+ .id(1L).memberId(MEMBER_ID).memberCardId(MEMBER_CARD_ID)
+ .operationType(TransactionType.DEDUCT.name())
+ .build();
+ MemberCardTransaction t2 = MemberCardTransaction.builder()
+ .id(2L).memberId(MEMBER_ID).memberCardId(MEMBER_CARD_ID)
+ .operationType(TransactionType.DEDUCT.name())
+ .build();
+
+ when(memberCardTransactionService.findByMemberIdAndTimeRange(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class), any()))
+ .thenReturn(Flux.just(t1, t2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", String.valueOf(MEMBER_ID))
+ .build();
+
+ Mono result = handler.getMemberTransactions(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).findByMemberIdAndTimeRange(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class), any());
+ }
+
+ @Test
+ void getMemberTransactions_shouldReturnOkWithCustomTimeRange() {
+ MemberCardTransaction t1 = MemberCardTransaction.builder()
+ .id(1L).memberId(MEMBER_ID)
+ .build();
+
+ when(memberCardTransactionService.findByMemberIdAndTimeRange(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class), any()))
+ .thenReturn(Flux.just(t1));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("startTime", "2026-01-01T00:00:00")
+ .queryParam("endTime", "2026-06-30T23:59:59")
+ .queryParam("page", "0")
+ .queryParam("size", "5")
+ .build();
+
+ Mono result = handler.getMemberTransactions(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).findByMemberIdAndTimeRange(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class), any());
+ }
+
+ // ==================== getTransactionsWithConditions ====================
+
+ @Test
+ void getTransactionsWithConditions_shouldReturnOkWithPageResult() {
+ MemberCardTransaction t1 = MemberCardTransaction.builder()
+ .id(1L).memberId(MEMBER_ID)
+ .operationType(TransactionType.PURCHASE.name())
+ .build();
+ MemberCardTransaction t2 = MemberCardTransaction.builder()
+ .id(2L).memberId(MEMBER_ID)
+ .operationType(TransactionType.PURCHASE.name())
+ .build();
+ List list = List.of(t1, t2);
+
+ when(memberCardTransactionService.countWithConditions(
+ any(), any(), any(), any(), any()))
+ .thenReturn(Mono.just(2L));
+ when(memberCardTransactionService.findWithConditions(
+ any(), any(), any(), any(), any(), any()))
+ .thenReturn(Flux.fromIterable(list));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("operationType", "PURCHASE")
+ .queryParam("page", "0")
+ .queryParam("size", "10")
+ .build();
+
+ Mono result = handler.getTransactionsWithConditions(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).countWithConditions(
+ any(), any(), any(), any(), any());
+ verify(memberCardTransactionService).findWithConditions(
+ any(), any(), any(), any(), any(), any());
+ }
+
+ // ==================== getTransactionsByCardId ====================
+
+ @Test
+ void getTransactionsByCardId_shouldReturnOk() {
+ MemberCardTransaction t1 = MemberCardTransaction.builder()
+ .id(1L).memberCardId(MEMBER_CARD_ID)
+ .build();
+
+ when(memberCardTransactionService.findByMemberCardId(MEMBER_CARD_ID))
+ .thenReturn(Flux.just(t1));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("cardId", String.valueOf(MEMBER_CARD_ID))
+ .build();
+
+ Mono result = handler.getTransactionsByCardId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).findByMemberCardId(MEMBER_CARD_ID);
+ }
+
+ // ==================== getTransactionsByRecordId ====================
+
+ @Test
+ void getTransactionsByRecordId_shouldReturnOk() {
+ MemberCardTransaction t1 = MemberCardTransaction.builder()
+ .id(1L).memberCardRecordId(RECORD_ID)
+ .build();
+
+ when(memberCardTransactionService.findByRecordId(RECORD_ID))
+ .thenReturn(Flux.just(t1));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("recordId", String.valueOf(RECORD_ID))
+ .build();
+
+ Mono result = handler.getTransactionsByRecordId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).findByRecordId(RECORD_ID);
+ }
+
+ // ==================== getDeductCountByCardId ====================
+
+ @Test
+ void getDeductCountByCardId_shouldReturnOk() {
+ when(memberCardTransactionService.sumDeductCountByCardId(
+ eq(MEMBER_CARD_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(5L));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("cardId", String.valueOf(MEMBER_CARD_ID))
+ .build();
+
+ Mono result = handler.getDeductCountByCardId(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).sumDeductCountByCardId(
+ eq(MEMBER_CARD_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ // ==================== getRenewAmountByTimeRange ====================
+
+ @Test
+ void getRenewAmountByTimeRange_shouldReturnOk() {
+ when(memberCardTransactionService.sumRenewAmountByTimeRange(
+ any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(5000.0));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("startTime", "2026-01-01T00:00:00")
+ .queryParam("endTime", "2026-06-30T23:59:59")
+ .build();
+
+ Mono result = handler.getRenewAmountByTimeRange(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).sumRenewAmountByTimeRange(
+ any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ @Test
+ void getRenewAmountByTimeRange_shouldReturnOkWithDefaultTimeRange() {
+ when(memberCardTransactionService.sumRenewAmountByTimeRange(
+ any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(0.0));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = handler.getRenewAmountByTimeRange(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).sumRenewAmountByTimeRange(
+ any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ // ==================== getPurchaseAmountByMember ====================
+
+ @Test
+ void getPurchaseAmountByMember_shouldReturnOk() {
+ when(memberCardTransactionService.sumPurchaseAmountByMemberId(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(3000.0));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", String.valueOf(MEMBER_ID))
+ .build();
+
+ Mono result = handler.getPurchaseAmountByMember(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).sumPurchaseAmountByMemberId(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+
+ @Test
+ void getPurchaseAmountByMember_shouldReturnOkWithCustomTimeRange() {
+ when(memberCardTransactionService.sumPurchaseAmountByMemberId(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class)))
+ .thenReturn(Mono.just(0.0));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("memberId", String.valueOf(MEMBER_ID))
+ .queryParam("startTime", "2026-01-01T00:00:00")
+ .queryParam("endTime", "2026-06-30T23:59:59")
+ .build();
+
+ Mono result = handler.getPurchaseAmountByMember(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberCardTransactionService).sumPurchaseAmountByMemberId(
+ eq(MEMBER_ID), any(LocalDateTime.class), any(LocalDateTime.class));
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberHandlerTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberHandlerTest.java
new file mode 100644
index 0000000..993c85c
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/handler/MemberHandlerTest.java
@@ -0,0 +1,388 @@
+package cn.novalon.gym.manage.member.handler;
+
+import cn.novalon.gym.manage.common.exception.NotFoundException;
+import cn.novalon.gym.manage.member.dto.AdminUpdatePhoneDto;
+import cn.novalon.gym.manage.member.dto.SearchMemberDto;
+import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
+import cn.novalon.gym.manage.member.entity.Member;
+import cn.novalon.gym.manage.member.es.entity.MemberES;
+import cn.novalon.gym.manage.member.service.MemberService;
+import cn.novalon.gym.manage.member.service.WechatAuthService;
+import cn.novalon.gym.manage.member.service.WechatOfficialService;
+import cn.novalon.gym.manage.member.vo.MemberDetailVO;
+import cn.novalon.gym.manage.member.vo.MemberInfoVO;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+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.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MemberHandlerTest {
+
+ @Mock
+ private MemberService memberService;
+
+ @Mock
+ private WechatAuthService wechatAuthService;
+
+ @Mock
+ private WechatOfficialService wechatOfficialService;
+
+ @Mock
+ private AuthUtil authUtil;
+
+ private MemberHandler memberHandler;
+
+ private static final Long MEMBER_ID = 10001L;
+ private static final Long ADMIN_ID = 1L;
+
+ @BeforeEach
+ void setUp() {
+ memberHandler = new MemberHandler(memberService, wechatAuthService, wechatOfficialService, authUtil);
+ }
+
+ // ==================== getMemberInfo ====================
+
+ @Test
+ void getMemberInfo_shouldReturnOk() {
+ MemberInfoVO info = MemberInfoVO.builder().id(MEMBER_ID).nickname("test").build();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberService.getMemberInfo(MEMBER_ID)).thenReturn(Mono.just(info));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = memberHandler.getMemberInfo(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).getMemberInfo(MEMBER_ID);
+ }
+
+ @Test
+ void getMemberInfo_shouldReturn404WhenNotFound() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberService.getMemberInfo(MEMBER_ID))
+ .thenReturn(Mono.error(new NotFoundException("MEMBER_NOT_FOUND", "会员不存在")));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+ Mono result = memberHandler.getMemberInfo(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+ }
+
+ // ==================== updateMemberInfo ====================
+
+ @Test
+ void updateMemberInfo_shouldReturnOk() {
+ UpdateMemberInfoDto updateDto = new UpdateMemberInfoDto();
+ updateDto.setNickname("newName");
+ MemberInfoVO updatedInfo = MemberInfoVO.builder().id(MEMBER_ID).nickname("newName").build();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(memberService.updateMemberInfo(eq(MEMBER_ID), any(UpdateMemberInfoDto.class)))
+ .thenReturn(Mono.just(updatedInfo));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .body(Mono.just(updateDto));
+
+ Mono result = memberHandler.updateMemberInfo(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).updateMemberInfo(eq(MEMBER_ID), any(UpdateMemberInfoDto.class));
+ }
+
+ // ==================== bindPhone ====================
+
+ @Test
+ void bindPhone_shouldReturnOk() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(wechatAuthService.bindPhone(MEMBER_ID, "phoneCode123")).thenReturn(Mono.just(true));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("phoneCode", "phoneCode123")
+ .build();
+
+ Mono result = memberHandler.bindPhone(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(wechatAuthService).bindPhone(MEMBER_ID, "phoneCode123");
+ }
+
+ @Test
+ void bindPhone_shouldThrowWhenPhoneCodeEmpty() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ assertThrows(IllegalArgumentException.class, () -> memberHandler.bindPhone(request));
+ }
+
+ // ==================== checkSubscribeStatus ====================
+
+ @Test
+ void checkSubscribeStatus_shouldReturnOkWhenSubscribed() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(wechatOfficialService.checkSubscribeStatus(MEMBER_ID)).thenReturn(Mono.just(true));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = memberHandler.checkSubscribeStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(wechatOfficialService).checkSubscribeStatus(MEMBER_ID);
+ }
+
+ @Test
+ void checkSubscribeStatus_shouldReturnOkWhenNotSubscribed() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(MEMBER_ID);
+ when(wechatOfficialService.checkSubscribeStatus(MEMBER_ID)).thenReturn(Mono.just(false));
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = memberHandler.checkSubscribeStatus(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(wechatOfficialService).checkSubscribeStatus(MEMBER_ID);
+ }
+
+ // ==================== adminUpdatePhone ====================
+
+ @Test
+ void adminUpdatePhone_shouldReturnOk() {
+ AdminUpdatePhoneDto body = new AdminUpdatePhoneDto();
+ body.setPhone("13800138000");
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.adminUpdatePhone(1L, "13800138000")).thenReturn(Mono.just(true));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(body));
+
+ Mono result = memberHandler.adminUpdatePhone(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).adminUpdatePhone(1L, "13800138000");
+ }
+
+ @Test
+ void adminUpdatePhone_shouldThrowWhenMemberIdInvalid() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "0")
+ .build();
+
+ assertThrows(IllegalArgumentException.class, () -> memberHandler.adminUpdatePhone(request));
+ }
+
+ @Test
+ void adminUpdatePhone_shouldThrowWhenPhoneEmpty() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+
+ AdminUpdatePhoneDto body = new AdminUpdatePhoneDto();
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(body));
+
+ Mono result = memberHandler.adminUpdatePhone(request);
+
+ assertThrows(IllegalArgumentException.class, () -> result.block());
+ }
+
+ @Test
+ void adminUpdatePhone_shouldThrowWhenPhoneFormatInvalid() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+
+ AdminUpdatePhoneDto body = new AdminUpdatePhoneDto();
+ body.setPhone("12345");
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(body));
+
+ Mono result = memberHandler.adminUpdatePhone(request);
+
+ assertThrows(IllegalArgumentException.class, () -> result.block());
+ }
+
+ // ==================== adminGetMemberInfo ====================
+
+ @Test
+ void adminGetMemberInfo_shouldReturnOk() {
+ MemberDetailVO detail = MemberDetailVO.builder().id(1L).nickname("test").build();
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.getMemberDetail(1L)).thenReturn(Mono.just(detail));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .build();
+
+ Mono result = memberHandler.adminGetMemberInfo(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).getMemberDetail(1L);
+ }
+
+ @Test
+ void adminGetMemberInfo_shouldThrowWhenMemberIdInvalid() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "0")
+ .build();
+
+ assertThrows(IllegalArgumentException.class, () -> memberHandler.adminGetMemberInfo(request));
+ }
+
+ // ==================== adminUpdateMemberInfo ====================
+
+ @Test
+ void adminUpdateMemberInfo_shouldReturnOk() {
+ UpdateMemberInfoDto updateDto = new UpdateMemberInfoDto();
+ updateDto.setNickname("adminUpdate");
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.adminUpdateMemberInfo(eq(1L), any(UpdateMemberInfoDto.class)))
+ .thenReturn(Mono.just(true));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "1")
+ .body(Mono.just(updateDto));
+
+ Mono result = memberHandler.adminUpdateMemberInfo(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).adminUpdateMemberInfo(eq(1L), any(UpdateMemberInfoDto.class));
+ }
+
+ @Test
+ void adminUpdateMemberInfo_shouldThrowWhenMemberIdInvalid() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+
+ MockServerRequest request = MockServerRequest.builder()
+ .pathVariable("id", "0")
+ .build();
+
+ assertThrows(IllegalArgumentException.class, () -> memberHandler.adminUpdateMemberInfo(request));
+ }
+
+ // ==================== searchMembers ====================
+
+ @Test
+ void searchMembers_shouldReturnOkWithResults() {
+ MemberES member1 = new MemberES("1", "M001", "test1", "138****8000", 1, "avatar1");
+ MemberES member2 = new MemberES("2", "M002", "test2", "139****8001", 2, "avatar2");
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.searchMember(any(SearchMemberDto.class)))
+ .thenReturn(Flux.just(member1, member2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("searchValue", "test")
+ .queryParam("pageNum", "1")
+ .queryParam("pageSize", "10")
+ .build();
+
+ Mono result = memberHandler.searchMembers(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).searchMember(any(SearchMemberDto.class));
+ }
+
+ @Test
+ void searchMembers_shouldReturnOkWithEmptyResults() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.searchMember(any(SearchMemberDto.class)))
+ .thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("searchValue", "nonexistent")
+ .build();
+
+ Mono result = memberHandler.searchMembers(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).searchMember(any(SearchMemberDto.class));
+ }
+
+ // ==================== getAllMembers ====================
+
+ @Test
+ void getAllMembers_shouldReturnOkWithResults() {
+ Member member1 = new Member();
+ member1.setId(1L);
+ member1.setMemberNo("M001");
+ member1.setNickname("test1");
+ Member member2 = new Member();
+ member2.setId(2L);
+ member2.setMemberNo("M002");
+ member2.setNickname("test2");
+
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.findAll(anyInt(), anyInt(), any(), any()))
+ .thenReturn(Flux.just(member1, member2));
+
+ MockServerRequest request = MockServerRequest.builder()
+ .queryParam("pageNum", "1")
+ .queryParam("pageSize", "10")
+ .build();
+
+ Mono result = memberHandler.getAllMembers(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).findAll(anyInt(), anyInt(), any(), any());
+ }
+
+ @Test
+ void getAllMembers_shouldReturnOkWithEmptyResults() {
+ when(authUtil.getMemberIdOrThrow(any())).thenReturn(ADMIN_ID);
+ when(memberService.findAll(anyInt(), anyInt(), any(), any()))
+ .thenReturn(Flux.empty());
+
+ MockServerRequest request = MockServerRequest.builder().build();
+
+ Mono result = memberHandler.getAllMembers(request);
+
+ ServerResponse response = result.block();
+ assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
+
+ verify(memberService).findAll(anyInt(), anyInt(), any(), any());
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImplTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImplTest.java
new file mode 100644
index 0000000..1ed2992
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImplTest.java
@@ -0,0 +1,460 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Pageable;
+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.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("MemberCardRecordServiceImpl 单元测试")
+class MemberCardRecordServiceImplTest {
+
+ @Mock
+ private MemberCardRecordRepository memberCardRecordRepository;
+
+ @Mock
+ private MemberCardRepository memberCardRepository;
+
+ @Mock
+ private RedisUtil redisUtil;
+
+ @InjectMocks
+ private MemberCardRecordServiceImpl memberCardRecordService;
+
+ private static final Long RECORD_ID = 10L;
+ private static final Long MEMBER_ID = 100L;
+ private static final Long MEMBER_CARD_ID = 1L;
+
+ private MemberCardRecord createRecord() {
+ MemberCardRecord record = new MemberCardRecord();
+ record.setId(RECORD_ID);
+ record.setMemberCardRecordId(RECORD_ID);
+ record.setMemberId(MEMBER_ID);
+ record.setMemberCardId(MEMBER_CARD_ID);
+ record.setStatus(MemberCardRecordStatus.ACTIVE);
+ record.setRemainingTimes(10);
+ record.setRemainingAmount(500.0);
+ record.setExpireTime(LocalDateTime.now().plusDays(30));
+ return record;
+ }
+
+ private MemberCard createCard() {
+ MemberCard card = MemberCard.builder()
+ .memberCardId(MEMBER_CARD_ID)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardValidityDays(30)
+ .memberCardStatus(1)
+ .build();
+ card.setId(MEMBER_CARD_ID);
+ return card;
+ }
+
+ // ==================== findById ====================
+
+ @Nested
+ @DisplayName("findById 方法")
+ class FindByIdTest {
+
+ @Test
+ @DisplayName("缓存命中时应从缓存返回")
+ void shouldReturnFromCacheWhenHit() {
+ MemberCardRecord record = createRecord();
+ when(redisUtil.get("member:card:record:" + RECORD_ID)).thenReturn(Mono.just(record));
+
+ Mono result = memberCardRecordService.findById(RECORD_ID);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+
+ verify(memberCardRecordRepository, never()).findById(anyLong());
+ }
+
+ @Test
+ @DisplayName("缓存未命中时应从数据库查询并更新缓存")
+ void shouldQueryDatabaseWhenCacheMiss() {
+ MemberCardRecord record = createRecord();
+ when(redisUtil.get("member:card:record:" + RECORD_ID)).thenReturn(Mono.empty());
+ when(memberCardRecordRepository.findById(anyLong())).thenReturn(Mono.just(record));
+
+ Mono result = memberCardRecordService.findById(RECORD_ID);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+
+ verify(memberCardRecordRepository).findById(anyLong());
+ }
+
+ @Test
+ @DisplayName("记录不存在时应返回空")
+ void shouldReturnEmptyWhenNotFound() {
+ when(redisUtil.get("member:card:record:" + RECORD_ID)).thenReturn(Mono.empty());
+ when(memberCardRecordRepository.findById(anyLong())).thenReturn(Mono.empty());
+
+ Mono result = memberCardRecordService.findById(RECORD_ID);
+
+ StepVerifier.create(result).verifyComplete();
+ }
+ }
+
+ // ==================== findByMemberId ====================
+
+ @Nested
+ @DisplayName("findByMemberId 方法")
+ class FindByMemberIdTest {
+
+ @Test
+ @DisplayName("应委托给 repository")
+ void shouldDelegateToRepository() {
+ MemberCardRecord record = createRecord();
+ Pageable pageable = Pageable.ofSize(10);
+ when(memberCardRecordRepository.findByMemberId(MEMBER_ID, pageable)).thenReturn(Flux.just(record));
+
+ Flux result = memberCardRecordService.findByMemberId(MEMBER_ID, pageable);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== findActiveCardsByMemberId ====================
+
+ @Nested
+ @DisplayName("findActiveCardsByMemberId 方法")
+ class FindActiveCardsByMemberIdTest {
+
+ @Test
+ @DisplayName("无记录时应返回空")
+ void shouldReturnEmptyWhenNoRecords() {
+ when(memberCardRecordRepository.findActiveCardsByMemberId(MEMBER_ID)).thenReturn(Flux.empty());
+
+ Flux result = memberCardRecordService.findActiveCardsByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result).verifyComplete();
+ }
+
+ @Test
+ @DisplayName("有记录时应填充会员卡信息")
+ void shouldEnrichCardInfoWhenRecordsExist() {
+ MemberCardRecord record = createRecord();
+ MemberCard card = createCard();
+ when(memberCardRecordRepository.findActiveCardsByMemberId(MEMBER_ID)).thenReturn(Flux.just(record));
+ when(memberCardRepository.findByIdAndDeletedAtIsNull(MEMBER_CARD_ID)).thenReturn(Mono.just(card));
+
+ Flux result = memberCardRecordService.findActiveCardsByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result)
+ .assertNext(r -> {
+ assertThat(r.getMemberCardName()).isEqualTo("月卡");
+ assertThat(r.getMemberCardType()).isEqualTo("TIME_CARD");
+ })
+ .verifyComplete();
+ }
+ }
+
+ // ==================== insertActiveRecord ====================
+
+ @Nested
+ @DisplayName("insertActiveRecord 方法")
+ class InsertActiveRecordTest {
+
+ @Test
+ @DisplayName("应委托给 repository")
+ void shouldDelegateToRepository() {
+ MemberCardRecord record = createRecord();
+ when(memberCardRecordRepository.insertActiveRecord(
+ record.getMemberId(), record.getMemberCardId(), record.getExpireTime(),
+ record.getRemainingTimes(), record.getRemainingAmount(), record.getSourceOrderId()))
+ .thenReturn(Mono.just(record));
+
+ Mono result = memberCardRecordService.insertActiveRecord(record);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== deductUsage ====================
+
+ @Nested
+ @DisplayName("deductUsage 方法")
+ class DeductUsageTest {
+
+ @Test
+ @DisplayName("扣减成功时应清除缓存")
+ void shouldClearCacheWhenDeducted() {
+ when(memberCardRecordRepository.deductUsage(RECORD_ID, 1, 0.0)).thenReturn(Mono.just(1));
+ when(redisUtil.delete("member:card:record:" + RECORD_ID)).thenReturn(Mono.just(1L));
+
+ Mono result = memberCardRecordService.deductUsage(RECORD_ID, 1, 0.0);
+
+ StepVerifier.create(result)
+ .assertNext(updated -> assertThat(updated).isEqualTo(1))
+ .verifyComplete();
+
+ verify(redisUtil).delete("member:card:record:" + RECORD_ID);
+ }
+
+ @Test
+ @DisplayName("扣减失败时不清理缓存")
+ void shouldNotClearCacheWhenNotUpdated() {
+ when(memberCardRecordRepository.deductUsage(RECORD_ID, 1, 0.0)).thenReturn(Mono.just(0));
+
+ Mono result = memberCardRecordService.deductUsage(RECORD_ID, 1, 0.0);
+
+ StepVerifier.create(result)
+ .assertNext(updated -> assertThat(updated).isZero())
+ .verifyComplete();
+
+ verify(redisUtil, never()).delete(anyString());
+ }
+ }
+
+ // ==================== renewCard ====================
+
+ @Nested
+ @DisplayName("renewCard 方法")
+ class RenewCardTest {
+
+ @Test
+ @DisplayName("续费成功时应清除缓存")
+ void shouldClearCacheWhenRenewed() {
+ LocalDateTime newExpire = LocalDateTime.now().plusDays(30);
+ when(memberCardRecordRepository.renewCard(RECORD_ID, 10, null, newExpire)).thenReturn(Mono.just(1));
+ when(redisUtil.delete("member:card:record:" + RECORD_ID)).thenReturn(Mono.just(1L));
+
+ Mono result = memberCardRecordService.renewCard(RECORD_ID, 10, null, newExpire);
+
+ StepVerifier.create(result)
+ .assertNext(updated -> assertThat(updated).isEqualTo(1))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== updateStatus ====================
+
+ @Nested
+ @DisplayName("updateStatus 方法")
+ class UpdateStatusTest {
+
+ @Test
+ @DisplayName("状态更新成功时应清除缓存")
+ void shouldClearCacheWhenStatusUpdated() {
+ when(memberCardRecordRepository.updateStatus(RECORD_ID, "USED_UP")).thenReturn(Mono.just(1));
+ when(redisUtil.delete("member:card:record:" + RECORD_ID)).thenReturn(Mono.just(1L));
+
+ Mono result = memberCardRecordService.updateStatus(RECORD_ID, "USED_UP");
+
+ StepVerifier.create(result)
+ .assertNext(updated -> assertThat(updated).isEqualTo(1))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== findExpiredCards ====================
+
+ @Nested
+ @DisplayName("findExpiredCards 方法")
+ class FindExpiredCardsTest {
+
+ @Test
+ @DisplayName("应委托给 repository")
+ void shouldDelegateToRepository() {
+ MemberCardRecord record = createRecord();
+ when(memberCardRecordRepository.findExpiredCards()).thenReturn(Flux.just(record));
+
+ Flux result = memberCardRecordService.findExpiredCards();
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== findCardsByMemberIdWithStatus ====================
+
+ @Nested
+ @DisplayName("findCardsByMemberIdWithStatus 方法")
+ class FindCardsByMemberIdWithStatusTest {
+
+ @Test
+ @DisplayName("无记录时应返回空")
+ void shouldReturnEmptyWhenNoRecords() {
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.empty());
+
+ Flux result = memberCardRecordService.findCardsByMemberIdWithStatus(MEMBER_ID, "active");
+
+ StepVerifier.create(result).verifyComplete();
+ }
+
+ @Test
+ @DisplayName("有记录时应填充会员卡信息")
+ void shouldEnrichCardInfoWhenRecordsExist() {
+ MemberCardRecord record = createRecord();
+ MemberCard card = createCard();
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.just(record));
+ when(memberCardRepository.findByIdAndDeletedAtIsNull(MEMBER_CARD_ID)).thenReturn(Mono.just(card));
+
+ Flux result = memberCardRecordService.findCardsByMemberIdWithStatus(MEMBER_ID, "active");
+
+ StepVerifier.create(result)
+ .assertNext(r -> {
+ assertThat(r.getMemberCardName()).isEqualTo("月卡");
+ assertThat(r.getMemberCardType()).isEqualTo("TIME_CARD");
+ })
+ .verifyComplete();
+ }
+ }
+
+ private MemberCard createStoredValueCard() {
+ MemberCard card = MemberCard.builder()
+ .memberCardId(MEMBER_CARD_ID)
+ .memberCardName("储值卡")
+ .memberCardType("STORED_VALUE_CARD")
+ .memberCardPrice(500.0)
+ .memberCardAmount(500.0)
+ .memberCardStatus(1)
+ .build();
+ card.setId(MEMBER_CARD_ID);
+ return card;
+ }
+
+ // ==================== findPrimaryActiveCardByMemberId ====================
+
+ @Nested
+ @DisplayName("findPrimaryActiveCardByMemberId 方法")
+ class FindPrimaryActiveCardByMemberIdTest {
+
+ @Test
+ @DisplayName("无记录时应返回空")
+ void shouldReturnEmptyWhenNoRecords() {
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.empty());
+
+ Mono result = memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result).verifyComplete();
+ }
+
+ @Test
+ @DisplayName("应优先返回临期卡（1-3天到期）")
+ void shouldPreferExpiringCard() {
+ MemberCardRecord expiringRecord = createRecord();
+ expiringRecord.setExpireTime(LocalDateTime.now().plusDays(2));
+ MemberCardRecord farRecord = createRecord();
+ farRecord.setMemberCardRecordId(20L);
+ farRecord.setExpireTime(LocalDateTime.now().plusDays(30));
+
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.just(farRecord, expiringRecord));
+ when(memberCardRepository.findByIdAndDeletedAtIsNull(MEMBER_CARD_ID)).thenReturn(Mono.just(createCard()));
+
+ Mono result = memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+
+ @Test
+ @DisplayName("无临期卡时应返回有效卡（剩余>3天）")
+ void shouldReturnActiveCardWhenNoExpiring() {
+ MemberCardRecord farRecord = createRecord();
+ farRecord.setExpireTime(LocalDateTime.now().plusDays(30));
+ MemberCardRecord expiredRecord = createRecord();
+ expiredRecord.setMemberCardRecordId(20L);
+ expiredRecord.setExpireTime(LocalDateTime.now().minusDays(1));
+
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.just(expiredRecord, farRecord));
+ when(memberCardRepository.findByIdAndDeletedAtIsNull(MEMBER_CARD_ID)).thenReturn(Mono.just(createCard()));
+
+ Mono result = memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+
+ @Test
+ @DisplayName("应过滤掉储值卡")
+ void shouldFilterStoredValueCard() {
+ MemberCardRecord svRecord = createRecord();
+ when(memberCardRecordRepository.findCardsByMemberIdWithStatus(MEMBER_ID, "active"))
+ .thenReturn(Flux.just(svRecord));
+ when(memberCardRepository.findByIdAndDeletedAtIsNull(MEMBER_CARD_ID)).thenReturn(Mono.just(createStoredValueCard()));
+
+ Mono result = memberCardRecordService.findPrimaryActiveCardByMemberId(MEMBER_ID);
+
+ StepVerifier.create(result).verifyComplete();
+ }
+ }
+
+ // ==================== validateCountCard ====================
+
+ @Nested
+ @DisplayName("validateCountCard 方法")
+ class ValidateCountCardTest {
+
+ @Test
+ @DisplayName("应委托给 repository")
+ void shouldDelegateToRepository() {
+ MemberCardRecord record = createRecord();
+ when(memberCardRecordRepository.validateCountCard(RECORD_ID, 1)).thenReturn(Mono.just(record));
+
+ Mono result = memberCardRecordService.validateCountCard(RECORD_ID, 1);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+ }
+
+ // ==================== validateStoredCard ====================
+
+ @Nested
+ @DisplayName("validateStoredCard 方法")
+ class ValidateStoredCardTest {
+
+ @Test
+ @DisplayName("应委托给 repository")
+ void shouldDelegateToRepository() {
+ MemberCardRecord record = createRecord();
+ when(memberCardRecordRepository.validateStoredCard(RECORD_ID, 100.0)).thenReturn(Mono.just(record));
+
+ Mono result = memberCardRecordService.validateStoredCard(RECORD_ID, 100.0);
+
+ StepVerifier.create(result)
+ .assertNext(r -> assertThat(r.getMemberCardRecordId()).isEqualTo(RECORD_ID))
+ .verifyComplete();
+ }
+ }
+}
\ No newline at end of file
diff --git a/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImplTest.java b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImplTest.java
new file mode 100644
index 0000000..18cd79a
--- /dev/null
+++ b/gym-manage-api/gym-member/src/test/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImplTest.java
@@ -0,0 +1,620 @@
+package cn.novalon.gym.manage.member.service.impl;
+
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.CardEvent;
+import cn.novalon.gym.manage.member.enums.MemberCardRecordStatus;
+import cn.novalon.gym.manage.member.handler.DistributedLockService;
+import cn.novalon.gym.manage.member.handler.ExpirationReminderService;
+import cn.novalon.gym.manage.member.handler.MemberCardStateMachine;
+import cn.novalon.gym.manage.member.handler.RefundSagaHandler;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Pageable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.LocalDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("MemberCardServiceImpl 单元测试")
+class MemberCardServiceImplTest {
+
+ @Mock
+ private MemberCardRepository memberCardRepository;
+
+ @Mock
+ private MemberCardRecordRepository recordRepository;
+
+ @Mock
+ private IMemberCardTransactionService transactionService;
+
+ @Mock
+ private MemberCardStateMachine stateMachine;
+
+ @Mock
+ private DistributedLockService distributedLockService;
+
+ @Mock
+ private ExpirationReminderService expirationReminderService;
+
+ @Mock
+ private RefundSagaHandler refundSagaHandler;
+
+ @Mock
+ private RedisUtil redisUtil;
+
+ @InjectMocks
+ private MemberCardServiceImpl memberCardService;
+
+ private static final Long MEMBER_CARD_ID = 1L;
+ private static final Long MEMBER_ID = 100L;
+ private static final Long RECORD_ID = 10L;
+ private static final Long SOURCE_ORDER_ID = 200L;
+
+ private MemberCard createTimeCard() {
+ return MemberCard.builder()
+ .memberCardId(MEMBER_CARD_ID)
+ .memberCardName("月卡")
+ .memberCardType("TIME_CARD")
+ .memberCardPrice(199.0)
+ .memberCardValidityDays(30)
+ .memberCardStatus(1)
+ .build();
+ }
+
+ private MemberCard createCountCard() {
+ return MemberCard.builder()
+ .memberCardId(MEMBER_CARD_ID)
+ .memberCardName("10次卡")
+ .memberCardType("COUNT_CARD")
+ .memberCardPrice(99.0)
+ .memberCardValidityDays(90)
+ .memberCardTotalTimes(10)
+ .memberCardStatus(1)
+ .build();
+ }
+
+ private MemberCard createStoredValueCard() {
+ return MemberCard.builder()
+ .memberCardId(MEMBER_CARD_ID)
+ .memberCardName("储值卡")
+ .memberCardType("STORED_VALUE_CARD")
+ .memberCardPrice(500.0)
+ .memberCardAmount(500.0)
+ .memberCardStatus(1)
+ .build();
+ }
+
+ private MemberCardRecord createActiveRecord(MemberCard card, MemberCardRecordStatus status) {
+ MemberCardRecord record = new MemberCardRecord();
+ record.setMemberCardRecordId(RECORD_ID);
+ record.setMemberId(MEMBER_ID);
+ record.setMemberCardId(MEMBER_CARD_ID);
+ record.setSourceOrderId(SOURCE_ORDER_ID);
+ record.setStatus(status);
+ record.setPurchaseTime(LocalDateTime.now().minusDays(1));
+
+ if ("TIME_CARD".equals(card.getMemberCardType())) {
+ record.setExpireTime(LocalDateTime.now().plusDays(29));
+ record.setRemainingTimes(0);
+ record.setRemainingAmount(0.0);
+ } else if ("COUNT_CARD".equals(card.getMemberCardType())) {
+ record.setExpireTime(LocalDateTime.now().plusDays(89));
+ record.setRemainingTimes(card.getMemberCardTotalTimes());
+ record.setRemainingAmount(0.0);
+ } else if ("STORED_VALUE_CARD".equals(card.getMemberCardType())) {
+ record.setExpireTime(LocalDateTime.now().plusYears(1));
+ record.setRemainingTimes(0);
+ record.setRemainingAmount(card.getMemberCardAmount());
+ }
+ return record;
+ }
+
+ @BeforeEach
+ void setUp() {
+ // 模拟分布式锁：直接执行锁内的业务逻辑
+ lenient().when(distributedLockService.executeWithLock(anyString(), anyString(), any()))
+ .thenAnswer(invocation -> {
+ Mono bizLogic = invocation.getArgument(2);
+ return bizLogic;
+ });
+ // 模拟交易记录创建
+ lenient().when(transactionService.createTransaction(any())).thenReturn(Mono.empty());
+ // 模拟过期提醒调度
+ lenient().when(expirationReminderService.scheduleExpirationReminder(any())).thenReturn(Mono.empty());
+ // 模拟状态机验证
+ lenient().when(stateMachine.validateTransition(any(), any())).thenReturn(Mono.empty());
+ // 模拟前端重复购买检测：默认返回空，即无重复
+ lenient().when(recordRepository.findRecentActivePurchase(anyLong(), anyLong(), any(LocalDateTime.class)))
+ .thenReturn(Mono.empty());
+ }
+
+ // ==================== findByMemberCardIdAndDeletedAtIsNull ====================
+
+ @Nested
+ @DisplayName("findByMemberCardIdAndDeletedAtIsNull 方法")
+ class FindByMemberCardIdTest {
+
+ @Test
+ @DisplayName("缓存未命中时应从数据库查询并更新缓存")
+ void shouldQueryDatabaseWhenCacheMiss() {
+ MemberCard card = createTimeCard();
+ when(redisUtil.get("member:card:" + MEMBER_CARD_ID)).thenReturn(Mono.empty());
+ when(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(MEMBER_CARD_ID))
+ .thenReturn(Mono.just(card));
+
+ Mono