486 lines
21 KiB
Java
486 lines
21 KiB
Java
package com.guo.learningprogresstracker.service.impl;
|
||
|
||
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
||
import com.guo.learningprogresstracker.common.StudyTimePolicy;
|
||
import com.guo.learningprogresstracker.dto.ReportSections;
|
||
import com.guo.learningprogresstracker.entity.StudyReportsEntity;
|
||
import com.guo.learningprogresstracker.entity.StudySessionsEntity;
|
||
import com.guo.learningprogresstracker.entity.TaskEntity;
|
||
import com.guo.learningprogresstracker.enums.StudySessionStateEnum;
|
||
import com.guo.learningprogresstracker.exception.ErrorParameterException;
|
||
import com.guo.learningprogresstracker.mapper.StudyReportFragmentsMapper;
|
||
import com.guo.learningprogresstracker.mapper.StudyReportsMapper;
|
||
import com.guo.learningprogresstracker.mapper.StudySessionsMapper;
|
||
import com.guo.learningprogresstracker.service.StudyExpectationsService;
|
||
import org.junit.jupiter.api.BeforeEach;
|
||
import org.junit.jupiter.api.Test;
|
||
import org.junit.jupiter.api.extension.ExtendWith;
|
||
import org.mockito.InjectMocks;
|
||
import org.mockito.Mock;
|
||
import org.mockito.Spy;
|
||
import org.mockito.junit.jupiter.MockitoSettings;
|
||
import org.mockito.quality.Strictness;
|
||
import org.mockito.junit.jupiter.MockitoExtension;
|
||
import org.springframework.test.util.ReflectionTestUtils;
|
||
|
||
import java.io.Serializable;
|
||
import java.time.LocalDateTime;
|
||
import java.util.List;
|
||
import java.util.Optional;
|
||
|
||
import static org.junit.jupiter.api.Assertions.*;
|
||
import static org.mockito.ArgumentMatchers.any;
|
||
import static org.mockito.ArgumentMatchers.eq;
|
||
import static org.mockito.Mockito.*;
|
||
|
||
@ExtendWith(MockitoExtension.class)
|
||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||
class StudySessionsServiceImplTest {
|
||
|
||
@Spy
|
||
@InjectMocks
|
||
private StudySessionsServiceImpl studySessionsService;
|
||
|
||
@Mock
|
||
private StudyReportsMapper studyReportsMapper;
|
||
|
||
@Mock
|
||
private StudyReportFragmentsMapper studyReportFragmentsMapper;
|
||
|
||
@Mock
|
||
private StudySessionsMapper studySessionsMapper;
|
||
|
||
@Mock
|
||
private StudyExpectationsService studyExpectationsService;
|
||
|
||
@Mock
|
||
private TasksServiceImpl tasksServiceImpl;
|
||
|
||
@Mock
|
||
private AiServiceClient aiServiceClient;
|
||
|
||
/** 时间口径用真实默认值,避免测试里出现 null 策略;需要改口径时换成自建实例即可 */
|
||
@Spy
|
||
private StudyTimePolicy studyTimePolicy = StudyTimePolicy.DEFAULT;
|
||
|
||
@BeforeEach
|
||
void setUp() {
|
||
// stub updateById,避免调用真实的 getBaseMapper()
|
||
doReturn(true).when(studySessionsService).updateById(any());
|
||
// stub 条件更新(结束会话抢占),默认视为抢占成功
|
||
doReturn(true).when(studySessionsService).update(any(StudySessionsEntity.class), any(Wrapper.class));
|
||
// stub removeById,避免调用真实的 getBaseMapper()
|
||
doReturn(true).when(studySessionsService).removeById(any(Serializable.class));
|
||
// 收敛路径直接使用 ServiceImpl 的 baseMapper 字段,必须显式注入(Mockito 不会填父类字段)
|
||
ReflectionTestUtils.setField(studySessionsService, "baseMapper", studySessionsMapper);
|
||
}
|
||
|
||
private StudySessionsEntity createSession(String state, int minutesAgo) {
|
||
StudySessionsEntity session = new StudySessionsEntity();
|
||
session.setSessionNum("SESSION_TEST");
|
||
session.setSessionState(state);
|
||
session.setStartTime(LocalDateTime.now().minusMinutes(minutesAgo));
|
||
session.setLastStartTime(LocalDateTime.now().minusMinutes(minutesAgo));
|
||
session.setEffectiveTime(0);
|
||
session.setActualTime(0);
|
||
return session;
|
||
}
|
||
|
||
private void mockGetOneOpt(StudySessionsEntity session) {
|
||
doReturn(Optional.of(session)).when(studySessionsService).getOneOpt(any(Wrapper.class));
|
||
}
|
||
|
||
/**
|
||
* 场景1:ONGOING 状态,有效时间 < 10分钟 → 返回提示消息
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoing_lessThan10Min_shouldReturnMessage() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 5);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertEquals("本次有效学习时间不足10分钟,不计入总学习时间", message);
|
||
assertEquals(0, session.getEffectiveTime(), "effectiveTime 应被清零");
|
||
assertEquals(StudySessionStateEnum.ENDED.name(), session.getSessionState());
|
||
verify(studyReportsMapper).insert(any(StudyReportsEntity.class));
|
||
}
|
||
|
||
/**
|
||
* 场景2:ONGOING 状态,有效时间 > 10分钟 → 返回 null(正常结束)
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoing_moreThan10Min_shouldReturnNull() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 15);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertNull(message, "有效时间超过10分钟不应返回提示");
|
||
assertTrue(session.getEffectiveTime() > 0, "effectiveTime 应保留");
|
||
assertEquals(StudySessionStateEnum.ENDED.name(), session.getSessionState());
|
||
}
|
||
|
||
/**
|
||
* 场景3:PAUSED 状态,有效时间 < 10分钟 → 返回 null(PAUSED 不触发提示)
|
||
*/
|
||
@Test
|
||
void endedStudySession_paused_lessThan10Min_shouldReturnNull() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.PAUSED.name(), 5);
|
||
session.setEffectiveTime(5 * 60);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertNull(message, "PAUSED 状态结束不返回提示(用户已主动暂停)");
|
||
assertEquals(0, session.getEffectiveTime(), "effectiveTime 仍应被实体层清零");
|
||
}
|
||
|
||
/**
|
||
* 场景4:PAUSED 状态,有效时间 > 10分钟 → 返回 null,effectiveTime 保留
|
||
*/
|
||
@Test
|
||
void endedStudySession_paused_moreThan10Min_shouldReturnNull() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.PAUSED.name(), 15);
|
||
session.setEffectiveTime(15 * 60);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertNull(message);
|
||
assertTrue(session.getEffectiveTime() > 0, "effectiveTime 应保留");
|
||
}
|
||
|
||
/**
|
||
* 场景5:无论是否触发清零,学习报告都应正常创建
|
||
*/
|
||
@Test
|
||
void endedStudySession_shouldAlwaysCreateReport() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 3);
|
||
mockGetOneOpt(session);
|
||
|
||
studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "测试报告内容"));
|
||
|
||
verify(studyReportsMapper).insert(argThat(report ->
|
||
"SESSION_TEST".equals(((StudyReportsEntity) report).getSessionNum())
|
||
&& "测试报告内容".equals(((StudyReportsEntity) report).getFreeSummary())
|
||
));
|
||
}
|
||
|
||
/**
|
||
* 场景6:ONGOING 状态,有效时间恰好 = 10分钟 → 有效时间保留(600 不 < 600)
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoing_exactly10Min_shouldReturnNull() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 10);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertNull(message, "有效时间等于10分钟应保留(阈值为 < 600)");
|
||
assertTrue(session.getEffectiveTime() >= 10 * 60, "effectiveTime 应保留");
|
||
}
|
||
|
||
/**
|
||
* 场景7:会话不存在 → 抛出异常
|
||
*/
|
||
@Test
|
||
void endedStudySession_sessionNotFound_shouldThrowException() {
|
||
doReturn(Optional.empty()).when(studySessionsService).getOneOpt(any(Wrapper.class));
|
||
|
||
assertThrows(Exception.class, () ->
|
||
studySessionsService.endedStudySession("NOT_EXIST", new ReportSections(null, null, "内容")));
|
||
}
|
||
|
||
/**
|
||
* 场景8:ONGOING 状态,有效时间极短(1分钟) → 返回提示消息
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoing_veryShortTime_shouldReturnMessage() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 1);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "学习内容"));
|
||
|
||
assertEquals("本次有效学习时间不足10分钟,不计入总学习时间", message);
|
||
assertEquals(0, session.getEffectiveTime());
|
||
}
|
||
|
||
/**
|
||
* 场景9:ONGOING 状态,刚开始就结束(effectiveTime ≈ 0) → 返回提示消息
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoing_immediatelyEnded_shouldReturnMessage() throws Exception {
|
||
StudySessionsEntity session = new StudySessionsEntity();
|
||
session.setSessionNum("SESSION_INSTANT");
|
||
session.setSessionState(StudySessionStateEnum.ONGOING.name());
|
||
session.setStartTime(LocalDateTime.now());
|
||
session.setLastStartTime(LocalDateTime.now());
|
||
session.setEffectiveTime(0);
|
||
session.setActualTime(0);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_INSTANT", new ReportSections(null, null, "内容"));
|
||
|
||
assertEquals("本次有效学习时间不足10分钟,不计入总学习时间", message);
|
||
assertEquals(0, session.getEffectiveTime());
|
||
}
|
||
|
||
/**
|
||
* 场景10:确认会话状态被持久化(条件更新:仅当仍未结束时写入)
|
||
*/
|
||
@Test
|
||
void endedStudySession_shouldCallUpdateWithNotEndedCondition() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 5);
|
||
session.setId(10);
|
||
mockGetOneOpt(session);
|
||
|
||
studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "内容"));
|
||
|
||
verify(studySessionsService).update(eq(session), any(Wrapper.class));
|
||
}
|
||
|
||
// ============ 误操作结束(零数据关闭) ============
|
||
|
||
/**
|
||
* 场景11:确认语正确且未产生残片 → 删除预期与会话,零数据关闭
|
||
*/
|
||
@Test
|
||
void abortStudySession_success_shouldDeleteEverything() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 5);
|
||
session.setId(1);
|
||
mockGetOneOpt(session);
|
||
doReturn(0L).when(studyReportFragmentsMapper).selectCount(any());
|
||
|
||
studySessionsService.abortStudySession("SESSION_TEST", StudySessionsServiceImpl.MISOPERATION_CONFIRMATION);
|
||
|
||
verify(studyExpectationsService).deleteBySessionNum("SESSION_TEST");
|
||
verify(studySessionsService).removeById(1);
|
||
}
|
||
|
||
/**
|
||
* 场景12:确认语不正确 → 抛异常,不删除任何数据
|
||
*/
|
||
@Test
|
||
void abortStudySession_wrongConfirmation_shouldThrow() {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 5);
|
||
mockGetOneOpt(session);
|
||
|
||
ErrorParameterException ex = assertThrows(ErrorParameterException.class, () ->
|
||
studySessionsService.abortStudySession("SESSION_TEST", "我不是确认语"));
|
||
|
||
assertEquals("确认语输入不正确,请核对后重新输入", ex.getMessage());
|
||
verify(studyExpectationsService, never()).deleteBySessionNum(any());
|
||
verify(studySessionsService, never()).removeById(any());
|
||
}
|
||
|
||
/**
|
||
* 场景13:确认语首尾空白应被忽略,仍视为正确
|
||
*/
|
||
@Test
|
||
void abortStudySession_confirmationWithSpaces_shouldSucceed() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.PAUSED.name(), 5);
|
||
session.setId(2);
|
||
mockGetOneOpt(session);
|
||
doReturn(0L).when(studyReportFragmentsMapper).selectCount(any());
|
||
|
||
studySessionsService.abortStudySession("SESSION_TEST",
|
||
" " + StudySessionsServiceImpl.MISOPERATION_CONFIRMATION + " ");
|
||
|
||
verify(studyExpectationsService).deleteBySessionNum("SESSION_TEST");
|
||
verify(studySessionsService).removeById(2);
|
||
}
|
||
|
||
/**
|
||
* 场景14:已产生学习残片 → 抛异常,不能误操作结束
|
||
*/
|
||
@Test
|
||
void abortStudySession_hasFragments_shouldThrow() {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 5);
|
||
mockGetOneOpt(session);
|
||
doReturn(1L).when(studyReportFragmentsMapper).selectCount(any());
|
||
|
||
ErrorParameterException ex = assertThrows(ErrorParameterException.class, () ->
|
||
studySessionsService.abortStudySession("SESSION_TEST", StudySessionsServiceImpl.MISOPERATION_CONFIRMATION));
|
||
|
||
assertEquals("这次学习已经产生了学习残片,不能按误操作结束了哦", ex.getMessage());
|
||
verify(studyExpectationsService, never()).deleteBySessionNum(any());
|
||
verify(studySessionsService, never()).removeById(any());
|
||
}
|
||
|
||
/**
|
||
* 场景15:会话已结束 → 抛异常
|
||
*/
|
||
@Test
|
||
void abortStudySession_endedSession_shouldThrow() {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ENDED.name(), 5);
|
||
mockGetOneOpt(session);
|
||
|
||
ErrorParameterException ex = assertThrows(ErrorParameterException.class, () ->
|
||
studySessionsService.abortStudySession("SESSION_TEST", StudySessionsServiceImpl.MISOPERATION_CONFIRMATION));
|
||
|
||
assertEquals("这次学习会话已经结束,不能再误操作结束了", ex.getMessage());
|
||
verify(studySessionsService, never()).removeById(any());
|
||
}
|
||
|
||
/**
|
||
* 场景16:会话不存在 → 抛异常
|
||
*/
|
||
@Test
|
||
void abortStudySession_sessionNotFound_shouldThrow() {
|
||
doReturn(Optional.empty()).when(studySessionsService).getOneOpt(any(Wrapper.class));
|
||
|
||
assertThrows(ErrorParameterException.class, () ->
|
||
studySessionsService.abortStudySession("NOT_EXIST", StudySessionsServiceImpl.MISOPERATION_CONFIRMATION));
|
||
}
|
||
|
||
// ============ 会话-01:结算路径统一 ============
|
||
|
||
/**
|
||
* 场景17:ONGOING 且上一段开始于 3 小时前 → 结束时应截断为 25 分钟
|
||
*/
|
||
@Test
|
||
void endedStudySession_ongoingThreeHoursGap_shouldTruncateToOnePomodoro() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 180);
|
||
session.setId(20);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "内容"));
|
||
|
||
assertNull(message, "截断后 25 分钟 ≥ 10 分钟,不应提示时间不足");
|
||
assertEquals(25 * 60, session.getEffectiveTime(), "3 小时无人操作只应计入 25 分钟");
|
||
verify(studyReportsMapper).insert(any(StudyReportsEntity.class));
|
||
}
|
||
|
||
/**
|
||
* 场景18:ONGOING 且上一段开始于 3 小时前 → 暂停时同样应截断为 25 分钟
|
||
*/
|
||
@Test
|
||
void pauseStudySession_ongoingThreeHoursGap_shouldTruncateToOnePomodoro() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 180);
|
||
mockGetOneOpt(session);
|
||
|
||
studySessionsService.pauseStudySession("SESSION_TEST", null);
|
||
|
||
assertEquals(StudySessionStateEnum.PAUSED.name(), session.getSessionState());
|
||
assertEquals(25 * 60, session.getEffectiveTime(), "暂停路径也应按遗忘规则截断");
|
||
}
|
||
|
||
// ============ 会话-02:暂停会话不再弹出超时提示 ============
|
||
|
||
/**
|
||
* 场景19:PAUSED 且 end_time 已存在、last_start_time 很旧 → 不返回 systemMessage
|
||
*/
|
||
@Test
|
||
void startOrContinueStudySession_pausedStaleSession_shouldNotReturnSystemMessage() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.PAUSED.name(), 180);
|
||
session.setEndTime(session.getLastStartTime().plusMinutes(25));
|
||
session.setEffectiveTime(25 * 60);
|
||
mockGetOneOpt(session);
|
||
|
||
TaskEntity task = new TaskEntity();
|
||
task.setTaskNum("TASK_TEST");
|
||
task.setTaskName("测试任务");
|
||
doReturn(Optional.of(task)).when(tasksServiceImpl).getOneOpt(any(Wrapper.class));
|
||
|
||
var response = studySessionsService.startOrContinueStudySession("TASK_TEST");
|
||
|
||
assertNull(response.getSystemMessage(), "已暂停的会话不应再提示超时");
|
||
}
|
||
|
||
// ============ 会话-03:结束会话幂等 ============
|
||
|
||
/**
|
||
* 场景20:重复结束已 ENDED 的会话 → 不重复生成学习报告
|
||
*/
|
||
@Test
|
||
void endedStudySession_alreadyEnded_shouldNotInsertReport() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ENDED.name(), 5);
|
||
session.setEffectiveTime(5 * 60);
|
||
mockGetOneOpt(session);
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "内容"));
|
||
|
||
assertNull(message);
|
||
verify(studyReportsMapper, never()).insert(any(StudyReportsEntity.class));
|
||
verify(studySessionsService, never()).update(any(StudySessionsEntity.class), any(Wrapper.class));
|
||
}
|
||
|
||
/**
|
||
* 场景21:并发结束抢占失败(其他请求已先结束)→ 不重复生成学习报告
|
||
*/
|
||
@Test
|
||
void endedStudySession_concurrentClaimLost_shouldNotInsertReport() throws Exception {
|
||
StudySessionsEntity session = createSession(StudySessionStateEnum.ONGOING.name(), 15);
|
||
session.setId(30);
|
||
mockGetOneOpt(session);
|
||
doReturn(false).when(studySessionsService).update(any(StudySessionsEntity.class), any(Wrapper.class));
|
||
|
||
String message = studySessionsService.endedStudySession("SESSION_TEST", new ReportSections(null, null, "内容"));
|
||
|
||
assertNull(message);
|
||
verify(studyReportsMapper, never()).insert(any(StudyReportsEntity.class));
|
||
}
|
||
|
||
// ============ 会话-04:悬挂会话收敛 ============
|
||
|
||
@Test
|
||
void convergeStaleSessionsOfCurrentUser_staleOngoing_shouldPauseTruncateAndMark() {
|
||
StudySessionsEntity stale = createSession(StudySessionStateEnum.ONGOING.name(), 180);
|
||
doReturn(List.of(stale)).when(studySessionsService).list(any(Wrapper.class));
|
||
when(studySessionsMapper.convergeStaleSession(any())).thenReturn(1);
|
||
|
||
int converged = studySessionsService.convergeStaleSessionsOfCurrentUser();
|
||
|
||
assertEquals(1, converged);
|
||
assertEquals(StudySessionStateEnum.PAUSED.name(), stale.getSessionState());
|
||
assertEquals(25 * 60, stale.getEffectiveTime(), "悬挂 3 小时只应计入一个番茄钟");
|
||
assertEquals(Boolean.TRUE, stale.getAutoConverged());
|
||
}
|
||
|
||
@Test
|
||
void convergeStaleSessionsOfCurrentUser_freshOngoing_shouldNotWrite() {
|
||
StudySessionsEntity fresh = createSession(StudySessionStateEnum.ONGOING.name(), 10);
|
||
doReturn(List.of(fresh)).when(studySessionsService).list(any(Wrapper.class));
|
||
|
||
int converged = studySessionsService.convergeStaleSessionsOfCurrentUser();
|
||
|
||
assertEquals(0, converged, "未超过硬兜底阈值不应收敛");
|
||
assertEquals(StudySessionStateEnum.ONGOING.name(), fresh.getSessionState());
|
||
verify(studySessionsMapper, never()).convergeStaleSession(any());
|
||
}
|
||
|
||
@Test
|
||
void convergeStaleSessionsOfCurrentUser_concurrentClaimLost_shouldCountZero() {
|
||
StudySessionsEntity stale = createSession(StudySessionStateEnum.ONGOING.name(), 180);
|
||
doReturn(List.of(stale)).when(studySessionsService).list(any(Wrapper.class));
|
||
// 条件更新未命中:说明已被其他请求收敛
|
||
when(studySessionsMapper.convergeStaleSession(any())).thenReturn(0);
|
||
|
||
assertEquals(0, studySessionsService.convergeStaleSessionsOfCurrentUser());
|
||
}
|
||
|
||
@Test
|
||
void scanAndConvergeStaleSessions_shouldUseCrossTenantScan() {
|
||
StudySessionsEntity stale = createSession(StudySessionStateEnum.ONGOING.name(), 200);
|
||
when(studySessionsMapper.selectForcePausableSessions(any(), anyInt())).thenReturn(List.of(stale));
|
||
when(studySessionsMapper.convergeStaleSession(any())).thenReturn(1);
|
||
|
||
int converged = studySessionsService.scanAndConvergeStaleSessions();
|
||
|
||
assertEquals(1, converged);
|
||
assertEquals(Boolean.TRUE, stale.getAutoConverged());
|
||
verify(studySessionsMapper).selectForcePausableSessions(any(), anyInt());
|
||
}
|
||
|
||
@Test
|
||
void getActiveSession_shouldRunLazyConvergenceFirst() {
|
||
when(studySessionsMapper.selectList(any())).thenReturn(List.of());
|
||
|
||
assertNull(studySessionsService.getActiveSession(null));
|
||
|
||
// 惰性收敛先按状态 + last_start_time 查一次悬挂会话
|
||
verify(studySessionsMapper, atLeastOnce()).selectList(any());
|
||
}
|
||
}
|