package com.tcm.training.admin.live.service;
|
|
import com.baomidou.mybatisplus.core.MybatisConfiguration;
|
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
|
import com.tcm.training.admin.live.dto.LiveSessionQuestionRequest;
|
import com.tcm.training.admin.live.dto.LiveSessionUpsertRequest;
|
import com.tcm.training.admin.live.entity.LiveCourse;
|
import com.tcm.training.admin.live.entity.LiveSession;
|
import com.tcm.training.admin.live.entity.LiveSessionQuestion;
|
import com.tcm.training.admin.live.mapper.LiveCourseMapper;
|
import com.tcm.training.admin.live.mapper.LiveReserveMapper;
|
import com.tcm.training.admin.live.mapper.LiveSessionMapper;
|
import com.tcm.training.admin.live.mapper.LiveSessionQuestionMapper;
|
import com.tcm.training.admin.live.vo.LiveSessionVO;
|
import com.tcm.training.admin.live.vo.LiveSessionStatusVO;
|
import org.apache.ibatis.builder.MapperBuilderAssistant;
|
import org.junit.jupiter.api.BeforeAll;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.extension.ExtendWith;
|
import org.junit.jupiter.params.ParameterizedTest;
|
import org.junit.jupiter.params.provider.ValueSource;
|
import org.mockito.ArgumentCaptor;
|
import org.mockito.Captor;
|
import org.mockito.Mock;
|
import org.mockito.junit.jupiter.MockitoExtension;
|
|
import java.time.LocalDateTime;
|
import java.util.Arrays;
|
import java.util.Collections;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
/**
|
* 直播场次服务测试。
|
*/
|
@ExtendWith(MockitoExtension.class)
|
class LiveSessionAppServiceTest {
|
|
@BeforeAll
|
static void initLambdaCache() {
|
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
|
TableInfoHelper.initTableInfo(assistant, LiveCourse.class);
|
TableInfoHelper.initTableInfo(assistant, LiveSession.class);
|
TableInfoHelper.initTableInfo(assistant, LiveSessionQuestion.class);
|
}
|
|
@Mock
|
private LiveCourseMapper liveCourseMapper;
|
|
@Mock
|
private LiveSessionMapper liveSessionMapper;
|
|
@Mock
|
private LiveSessionQuestionMapper liveSessionQuestionMapper;
|
|
@Mock
|
private LiveReserveMapper liveReserveMapper;
|
|
private LiveSessionAppService liveSessionAppService;
|
|
@Captor
|
private ArgumentCaptor<LiveSessionQuestion> questionCaptor;
|
@Mock
|
private LiveRemindDispatchService liveRemindDispatchService;
|
|
/**
|
* 每个用例前重建被测服务。
|
*/
|
@BeforeEach
|
void setUp() {
|
liveSessionAppService = new LiveSessionAppService(
|
liveCourseMapper,
|
liveSessionMapper,
|
liveSessionQuestionMapper,
|
liveReserveMapper,
|
liveRemindDispatchService
|
);
|
}
|
|
/**
|
* 编辑场次题目时应先物理删除旧题，避免逻辑删除记录触发唯一索引冲突。
|
*/
|
@Test
|
void updateSessionShouldHardDeleteQuestionsBeforeReinsert() {
|
LiveCourse course = new LiveCourse();
|
course.setId(9000L);
|
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setLiveStatus(0);
|
session.setStartTime(LocalDateTime.now().plusDays(1));
|
|
when(liveCourseMapper.selectById(9000L)).thenReturn(course);
|
when(liveSessionMapper.selectById(90008L)).thenReturn(session);
|
when(liveSessionQuestionMapper.selectList(any())).thenReturn(Collections.<LiveSessionQuestion>emptyList());
|
|
LiveSessionUpsertRequest request = new LiveSessionUpsertRequest();
|
request.setStartTime(LocalDateTime.now().plusDays(2));
|
request.setVideoUrl("https://cdn.example/live.m3u8");
|
request.setDurationSeconds(1800);
|
request.setBaseReserveCount(12);
|
request.setBaseWatchCount(8);
|
request.setQuestions(Arrays.asList(
|
buildQuestion(1, "题目一"),
|
buildQuestion(2, "题目二"),
|
buildQuestion(3, "题目三")
|
));
|
|
liveSessionAppService.updateSession(9000L, 90008L, request);
|
|
verify(liveSessionQuestionMapper).hardDeleteBySessionId(90008L);
|
verify(liveSessionQuestionMapper, never()).delete(any());
|
verify(liveSessionMapper).updateById(org.mockito.ArgumentMatchers.argThat(updatedSession ->
|
updatedSession != null
|
&& Long.valueOf(90008L).equals(updatedSession.getId())
|
&& Integer.valueOf(1800).equals(updatedSession.getDurationSeconds())));
|
verify(liveSessionQuestionMapper, org.mockito.Mockito.times(3)).insert(questionCaptor.capture());
|
assertEquals(3, questionCaptor.getAllValues().size());
|
assertEquals(Long.valueOf(90008L), questionCaptor.getAllValues().get(0).getSessionId());
|
assertEquals(Integer.valueOf(1), questionCaptor.getAllValues().get(0).getSort());
|
assertTrue(questionCaptor.getAllValues().stream().allMatch(item -> Long.valueOf(90008L).equals(item.getSessionId())));
|
}
|
|
/**
|
* 查询场次列表时应回传视频时长，供管理后台回显。
|
*/
|
@Test
|
void pageSessionsShouldIncludeDurationSeconds() {
|
LiveCourse course = new LiveCourse();
|
course.setId(9000L);
|
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setStartTime(LocalDateTime.of(2026, 4, 9, 19, 30));
|
session.setVideoUrl("https://cdn.example/live.mp4");
|
session.setDurationSeconds(2400);
|
session.setLiveStatus(0);
|
session.setBaseReserveCount(10);
|
session.setBaseWatchCount(5);
|
|
com.baomidou.mybatisplus.extension.plugins.pagination.Page<LiveSession> page =
|
new com.baomidou.mybatisplus.extension.plugins.pagination.Page<LiveSession>(1, 10);
|
page.setRecords(Collections.singletonList(session));
|
page.setTotal(1);
|
|
when(liveCourseMapper.selectById(9000L)).thenReturn(course);
|
when(liveSessionMapper.selectPage(any(), any())).thenReturn(page);
|
when(liveSessionQuestionMapper.selectList(any())).thenReturn(Collections.<LiveSessionQuestion>emptyList());
|
|
LiveSessionVO sessionVO = liveSessionAppService.pageSessions(9000L, 1, 10, null, null, null).getList().get(0);
|
|
assertEquals(Integer.valueOf(2400), sessionVO.getDurationSeconds());
|
}
|
|
/**
|
* 手动开播时应复用公共状态迁移逻辑，并返回数据库中的最新开播时间。
|
*/
|
@Test
|
void startShouldMarkPendingSessionAsLiving() {
|
LiveCourse course = new LiveCourse();
|
course.setId(9000L);
|
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setLiveStatus(0);
|
|
LiveSession startedSession = new LiveSession();
|
startedSession.setId(90008L);
|
startedSession.setLiveCourseId(9000L);
|
startedSession.setLiveStatus(1);
|
startedSession.setActualStartTime(LocalDateTime.of(2026, 4, 9, 10, 0));
|
|
when(liveCourseMapper.selectById(9000L)).thenReturn(course);
|
when(liveSessionMapper.selectById(90008L)).thenReturn(session, startedSession);
|
when(liveSessionMapper.markLivingIfPending(org.mockito.ArgumentMatchers.eq(90008L), any(LocalDateTime.class))).thenReturn(1);
|
|
LiveSessionStatusVO statusVO = liveSessionAppService.start(9000L, 90008L);
|
|
assertEquals(Integer.valueOf(1), statusVO.getLiveStatus());
|
assertEquals(LocalDateTime.of(2026, 4, 9, 10, 0), statusVO.getActualStartTime());
|
}
|
|
/**
|
* 自动开播在状态已变化时应静默跳过，避免定时任务重复报错。
|
*/
|
@Test
|
void autoStartShouldReturnNullWhenStateTransitionFails() {
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setLiveStatus(1);
|
|
when(liveSessionMapper.selectById(90008L)).thenReturn(session);
|
when(liveSessionMapper.markLivingIfPending(org.mockito.ArgumentMatchers.eq(90008L), any(LocalDateTime.class))).thenReturn(0);
|
|
assertNull(liveSessionAppService.autoStart(90008L, LocalDateTime.of(2026, 4, 9, 10, 5)));
|
}
|
|
/**
|
* 自动开播后应以后置查询结果为准，避免覆盖数据库中已有的实际开播时间。
|
*/
|
@Test
|
void autoStartShouldUsePersistedActualStartTime() {
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setLiveStatus(0);
|
|
LiveSession startedSession = new LiveSession();
|
startedSession.setId(90008L);
|
startedSession.setLiveCourseId(9000L);
|
startedSession.setLiveStatus(1);
|
startedSession.setActualStartTime(LocalDateTime.of(2026, 4, 9, 9, 55));
|
|
when(liveSessionMapper.selectById(90008L)).thenReturn(session, startedSession);
|
when(liveSessionMapper.markLivingIfPending(org.mockito.ArgumentMatchers.eq(90008L), any(LocalDateTime.class))).thenReturn(1);
|
|
assertEquals(
|
LocalDateTime.of(2026, 4, 9, 9, 55),
|
liveSessionAppService.autoStart(90008L, LocalDateTime.of(2026, 4, 9, 10, 0)).getActualStartTime()
|
);
|
}
|
|
/**
|
* 仅后续直播中场次能替换当前直播，已结束的历史记录不能挤掉它。
|
*/
|
@ParameterizedTest
|
@ValueSource(ints = {1, 2})
|
void reconcileCourseLivingSessionsShouldOnlyCloseForNewerLivingSession(int latestStatus) {
|
LiveSession staleLivingSession = new LiveSession();
|
staleLivingSession.setId(90001L);
|
staleLivingSession.setLiveCourseId(9000L);
|
staleLivingSession.setLiveStatus(1);
|
staleLivingSession.setStartTime(LocalDateTime.of(2026, 4, 8, 10, 0));
|
|
LiveSession latestSession = new LiveSession();
|
latestSession.setId(90002L);
|
latestSession.setLiveCourseId(9000L);
|
latestSession.setLiveStatus(latestStatus);
|
latestSession.setStartTime(LocalDateTime.of(2026, 4, 9, 10, 0));
|
if (latestStatus == 2) {
|
latestSession.setActualEndTime(LocalDateTime.of(2026, 4, 9, 10, 30));
|
}
|
|
when(liveSessionMapper.selectList(any())).thenReturn(Arrays.asList(staleLivingSession, latestSession));
|
|
int repairedCount = liveSessionAppService.reconcileCourseLivingSessions(
|
9000L, LocalDateTime.of(2026, 4, 9, 10, 35));
|
if (latestStatus == 2) {
|
assertEquals(0, repairedCount);
|
verify(liveSessionMapper, never()).updateById(any(LiveSession.class));
|
return;
|
}
|
assertEquals(1, repairedCount);
|
verify(liveSessionMapper).updateById(org.mockito.ArgumentMatchers.argThat(session ->
|
session != null
|
&& Long.valueOf(90001L).equals(session.getId())
|
&& Integer.valueOf(2).equals(session.getLiveStatus())
|
&& LocalDateTime.of(2026, 4, 9, 10, 35).equals(session.getActualEndTime())));
|
}
|
|
/**
|
* 模拟 DATETIME 按秒四舍五入，覆盖半秒边界及跨秒、跨日进位。
|
*/
|
@ParameterizedTest
|
@ValueSource(ints = {0, 100000000, 499999999, 500000000, 800000000, 999999999})
|
void autoStartShouldRemainLivingWhenDatabaseRoundsTime(int nanos) {
|
LiveSession session = mockPendingSessionWithDatabaseRounding();
|
LocalDateTime startTime = LocalDateTime.of(2026, 9, 22, 23, 59, 59, nanos);
|
session.setStartTime(startTime.withNano(0));
|
|
LiveSessionStatusVO result = liveSessionAppService.autoStart(session.getId(), startTime);
|
|
assertEquals(Integer.valueOf(1), result.getLiveStatus());
|
assertEquals(startTime.withNano(0), result.getActualStartTime());
|
assertNull(result.getActualEndTime());
|
verify(liveSessionMapper, never()).updateById(any(LiveSession.class));
|
verify(liveSessionMapper).markLivingIfPending(session.getId(), startTime.withNano(0));
|
}
|
|
/**
|
* 人工提前开播也应经过相同的秒级归一化，而不是被未来的计划时间误结束。
|
*/
|
@Test
|
void manualStartShouldUseSecondPrecisionBeforePlannedTime() {
|
LiveSession session = mockPendingSessionWithDatabaseRounding();
|
session.setStartTime(LocalDateTime.now().plusHours(1));
|
LiveCourse course = new LiveCourse();
|
course.setId(session.getLiveCourseId());
|
when(liveCourseMapper.selectById(course.getId())).thenReturn(course);
|
|
LiveSessionStatusVO result = liveSessionAppService.start(course.getId(), session.getId());
|
|
ArgumentCaptor<LocalDateTime> timeCaptor = ArgumentCaptor.forClass(LocalDateTime.class);
|
verify(liveSessionMapper).markLivingIfPending(
|
org.mockito.ArgumentMatchers.eq(session.getId()), timeCaptor.capture());
|
assertEquals(0, timeCaptor.getValue().getNano());
|
assertEquals(Integer.valueOf(1), result.getLiveStatus());
|
assertNull(result.getActualEndTime());
|
verify(liveSessionMapper, never()).updateById(any(LiveSession.class));
|
}
|
|
private LiveSession mockPendingSessionWithDatabaseRounding() {
|
LiveSession session = new LiveSession();
|
session.setId(90008L);
|
session.setLiveCourseId(9000L);
|
session.setLiveStatus(0);
|
session.setDurationSeconds(385);
|
when(liveSessionMapper.selectById(session.getId())).thenReturn(session);
|
when(liveSessionMapper.selectList(any())).thenReturn(Collections.singletonList(session));
|
when(liveSessionMapper.markLivingIfPending(
|
org.mockito.ArgumentMatchers.eq(session.getId()), any(LocalDateTime.class)))
|
.thenAnswer(invocation -> {
|
LocalDateTime input = invocation.getArgument(1);
|
// 保留与 MySQL 秒精度写入一致的进位模型，不依赖真实数据库。
|
LocalDateTime persisted = input.withNano(0);
|
if (input.getNano() >= 500000000) {
|
persisted = persisted.plusSeconds(1);
|
}
|
session.setActualStartTime(persisted);
|
session.setLiveStatus(1);
|
return 1;
|
});
|
return session;
|
}
|
|
/**
|
* 构造题目请求。
|
*/
|
private LiveSessionQuestionRequest buildQuestion(int sort, String stem) {
|
LiveSessionQuestionRequest questionRequest = new LiveSessionQuestionRequest();
|
questionRequest.setSort(sort);
|
questionRequest.setStem(stem);
|
questionRequest.setOptionA("A");
|
questionRequest.setOptionB("B");
|
questionRequest.setOptionC("C");
|
questionRequest.setCorrectOption("A");
|
return questionRequest;
|
}
|
}
|
