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.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()
|
);
|
}
|
|
/**
|
* 同课程时间线已推进到后续场次时，应将历史残留的直播中场次收敛为已结束。
|
*/
|
@Test
|
void reconcileCourseLivingSessionsShouldCloseHistoricalLivingSession() {
|
LiveSession staleLivingSession = new LiveSession();
|
staleLivingSession.setId(90001L);
|
staleLivingSession.setLiveCourseId(9000L);
|
staleLivingSession.setLiveStatus(1);
|
staleLivingSession.setStartTime(LocalDateTime.of(2026, 4, 8, 10, 0));
|
|
LiveSession latestEndedSession = new LiveSession();
|
latestEndedSession.setId(90002L);
|
latestEndedSession.setLiveCourseId(9000L);
|
latestEndedSession.setLiveStatus(2);
|
latestEndedSession.setStartTime(LocalDateTime.of(2026, 4, 9, 10, 0));
|
latestEndedSession.setActualEndTime(LocalDateTime.of(2026, 4, 9, 10, 30));
|
|
when(liveSessionMapper.selectList(any())).thenReturn(Arrays.asList(staleLivingSession, latestEndedSession));
|
|
assertEquals(1, liveSessionAppService.reconcileCourseLivingSessions(9000L, LocalDateTime.of(2026, 4, 9, 10, 35)));
|
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())));
|
}
|
|
/**
|
* 构造题目请求。
|
*/
|
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;
|
}
|
}
|
