package com.guo.learningprogresstracker.service.impl;
import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.guo.learningprogresstracker.dto.ReviewSummary;
import com.guo.learningprogresstracker.dto.ReviewTaskStats;
import com.guo.learningprogresstracker.dto.TaskContentCount;
import com.guo.learningprogresstracker.dto.TaskSessionStats;
import com.guo.learningprogresstracker.entity.MarkerEntity;
import com.guo.learningprogresstracker.entity.StudyReportFragmentsEntity;
import com.guo.learningprogresstracker.entity.StudyReportsEntity;
import com.guo.learningprogresstracker.entity.StudySessionsEntity;
import com.guo.learningprogresstracker.entity.TaskEntity;
import com.guo.learningprogresstracker.enums.MarkerKindEnum;
import com.guo.learningprogresstracker.enums.MarkerObjectTypeEnum;
import com.guo.learningprogresstracker.enums.StudySessionStateEnum;
import com.guo.learningprogresstracker.mapper.MarkerMapper;
import com.guo.learningprogresstracker.mapper.StudyReportFragmentsMapper;
import com.guo.learningprogresstracker.mapper.StudyReportsMapper;
import com.guo.learningprogresstracker.mapper.StudySessionsMapper;
import com.guo.learningprogresstracker.mapper.TasksMapper;
import com.guo.learningprogresstracker.service.MarkerService;
import com.guo.learningprogresstracker.service.ReviewService;
import com.guo.learningprogresstracker.utils.GenerateNumTool;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* 复习统计聚合的落库集成测试(数据-02)。
*
*
核心验收:聚合返回的行数与「任务数」同阶,不随历史会话数线性增长;
* 同时守住自定义 SQL 的两个隐式条件(租户隔离与逻辑删除)。
*/
@SpringBootTest
class ReviewStatsAggregationIntegrationTest {
private static final String USER = "统计聚合集成测试用户";
private static final AtomicInteger SEQ = new AtomicInteger();
@Autowired
private ReviewService reviewService;
@Autowired
private StudySessionsMapper studySessionsMapper;
@Autowired
private StudyReportsMapper studyReportsMapper;
@Autowired
private StudyReportFragmentsMapper studyReportFragmentsMapper;
@Autowired
private TasksMapper tasksMapper;
@Autowired
private MarkerService markerService;
@Autowired
private MarkerMapper markerMapper;
@BeforeEach
void setUp() {
StpUtil.login(USER, "test_device");
}
private static String uniqueTaskNum() {
return "TASKAGG-IT-" + System.nanoTime() + "-" + SEQ.incrementAndGet();
}
@Test
void aggregation_rowCountIsBoundedByTaskCountNotSessionCount() {
String taskNum = uniqueTaskNum();
// 同一个任务下堆很多会话:聚合查询只应返回 1 行
for (int i = 0; i < 30; i++) {
saveSession(taskNum, 60, LocalDateTime.now().minusDays(i));
}
List rows = studySessionsMapper.sumStudyStatsByTask(
Set.of(taskNum), LocalDate.now().atStartOfDay(),
LocalDate.now().with(DayOfWeek.MONDAY).atStartOfDay());
assertEquals(1, rows.size(), "同一任务下 30 个会话应聚合成 1 行");
assertEquals(30L, rows.get(0).getSessionCount());
assertEquals(30 * 60D, rows.get(0).getEffectiveTime(), 0.001);
}
@Test
void statsAggregateTimeWindowsAndAveragesInSql() {
String taskNum = uniqueTaskNum();
saveSession(taskNum, 600, LocalDateTime.now()); // 今日 / 本周
saveSession(taskNum, 300, LocalDateTime.now().minusDays(1)); // 本周(若今天是周一则属上周)
saveSession(taskNum, 120, LocalDateTime.now().minusDays(20)); // 本月早些时候,肯定不在本周
ReviewTaskStats stats = reviewService.getReviewTaskStats(taskNum);
assertEquals(3, stats.getSessionCount());
assertEquals(1020D, stats.getEffectiveTime(), 0.001);
assertEquals(340D, stats.getAvgEffectiveTime(), 0.001, "平均有效时间 = 累计 / 会话数");
assertEquals(600D, stats.getTodayEffectiveTime(), 0.001, "今日窗口只应包含今天的会话");
assertTrue(stats.getWeekEffectiveTime() >= 600D, "本周窗口至少包含今天的会话");
assertTrue(stats.getWeekEffectiveTime() <= 1020D);
}
@Test
void contentCountsAreGroupedByOwnershipNotBySession() {
String taskNum = uniqueTaskNum();
StudySessionsEntity first = saveSession(taskNum, 60, LocalDateTime.now());
StudySessionsEntity second = saveSession(taskNum, 60, LocalDateTime.now());
insertReport(first.getSessionNum());
insertReport(first.getSessionNum());
insertFragment(second.getSessionNum(), taskNum);
List reports = studyReportsMapper.countReportsByTask(Set.of(taskNum));
List fragments = studyReportFragmentsMapper.countFragmentsByTask(Set.of(taskNum));
assertEquals(1, reports.size(), "报告计数也应按任务聚合成 1 行");
assertEquals(1, fragments.size(), "碎片计数也应按任务聚合成 1 行");
assertEquals(2L, reports.get(0).getContentCount(), "两个会话下的报告都应归属到同一任务");
assertEquals(1L, fragments.get(0).getContentCount());
}
@Test
void contentCountsExcludeLogicallyDeletedRows() {
String taskNum = uniqueTaskNum();
StudySessionsEntity session = saveSession(taskNum, 60, LocalDateTime.now());
StudyReportsEntity kept = insertReport(session.getSessionNum());
StudyReportsEntity deleted = insertReport(session.getSessionNum());
studyReportsMapper.deleteById(deleted.getId());
StudyReportFragmentsEntity deletedFragment = insertFragment(session.getSessionNum(), taskNum);
studyReportFragmentsMapper.deleteById(deletedFragment.getId());
List reports = studyReportsMapper.countReportsByTask(Set.of(taskNum));
List fragments = studyReportFragmentsMapper.countFragmentsByTask(Set.of(taskNum));
assertEquals(1L, reports.get(0).getContentCount(), "逻辑删除的报告不应计入");
assertTrue(fragments.isEmpty() || fragments.get(0).getContentCount() == 0L,
"逻辑删除的碎片不应计入");
assertNotNull(kept.getId(), "保留的报告应正常落库");
}
@Test
void statsOnlyCountCurrentTenant() {
String taskNum = uniqueTaskNum();
saveSession(taskNum, 600, LocalDateTime.now());
StpUtil.login("统计聚合集成测试另一个用户", "test_device");
ReviewTaskStats otherStats = reviewService.getReviewTaskStats(taskNum);
assertEquals(0, otherStats.getSessionCount(), "统计聚合必须受租户隔离约束");
assertEquals(0D, otherStats.getEffectiveTime(), 0.001);
// 汇总同样不能跨租户:join 出来的 tasks 也会被拦截器追加 created_by,
// 否则会把别人的报告/碎片算进自己的总览
ReviewSummary otherSummary = reviewService.summary();
assertEquals(0L, otherSummary.taskTotal(), "汇总必须受租户隔离约束");
assertEquals(0L, otherSummary.reportTotal(), "汇总必须受租户隔离约束");
assertEquals(0L, otherSummary.fragmentTotal(), "汇总必须受租户隔离约束");
StpUtil.login(USER, "test_device");
assertEquals(1, reviewService.getReviewTaskStats(taskNum).getSessionCount());
}
/**
* 总览汇总必须与按任务列表同口径:列表逐页相加 == summary。
*
* 裸表 count 会把「待归类」碎片也算进「学习残片」,而列表的碎片数按内容归属聚合,
* 两者对不上(待归类在总览里另有独立区块展示)。这里额外造一条待归类碎片,
* 一旦汇总退回裸表计数,断言就会失败。
*/
@Test
void summaryMatchesListTotalsAcrossAllPagesAndExcludesPendingFragments() {
String taskNum = saveTask();
StudySessionsEntity session = saveSession(taskNum, 60, LocalDateTime.now());
insertReport(session.getSessionNum());
insertFragment(session.getSessionNum(), taskNum);
// 待归类碎片:不属于任何任务,因此不进列表,也不该进汇总的「学习残片」
insertFragment(session.getSessionNum(), null);
ReviewSummary summary = reviewService.summary();
long listReports = 0L;
long listFragments = 0L;
int pageSize = 100;
long total = reviewService.getReviewTaskStats(1, pageSize, null).getTotal();
long pages = (total + pageSize - 1) / pageSize;
for (int page = 1; page <= pages; page++) {
Page pageResult = reviewService.getReviewTaskStats(page, pageSize, null);
for (ReviewTaskStats stats : pageResult.getRecords()) {
listReports += stats.getReportCount();
listFragments += stats.getFragmentCount();
}
}
assertEquals(listReports, summary.reportTotal(), "汇总报告数必须等于列表逐页相加");
assertEquals(listFragments, summary.fragmentTotal(), "汇总碎片数必须等于列表逐页相加(不含待归类)");
}
/** 真实的任务行:列表按 tasks 表分页,因此汇总的 join 必须能匹配到它 */
private String saveTask() {
String taskNum = uniqueTaskNum();
TaskEntity task = new TaskEntity();
task.setTaskNum(taskNum);
task.setTaskName("统计聚合集成测试任务");
tasksMapper.insert(task);
return taskNum;
}
/**
* 标签筛选下推到 SQL:命中任务由一次 EXISTS 查询算出,且子查询也受租户隔离约束。
*
* 「同一 task_num 上存在别人打的同名标签」这种编号碰撞下,若子查询没带 created_by,
* 就会把别人标记的任务算成自己的命中——这里用直插 marker 的方式构造该场景守住它。
*/
@Test
void markerFilterIsPushedIntoSqlAndStaysTenantScoped() throws Exception {
String untaggedTask = saveTask();
String taggedTask = saveTask();
markerService.addUserTag(MarkerObjectTypeEnum.TASK, taggedTask, "筛选标签");
// 本用户:只命中自己打过标签的那一个
Page page = reviewService.getReviewTaskStats(1, 20, "筛选标签");
assertEquals(1, page.getTotal());
assertEquals(taggedTask, page.getRecords().get(0).getTaskNum());
// 没有命中时返回空页,不能退化成「不过滤」
Page none = reviewService.getReviewTaskStats(1, 20, "不存在的标签");
assertEquals(0, none.getTotal());
assertTrue(none.getRecords().isEmpty());
// 另一用户在同一个 task_num 上插同名标签(模拟编号碰撞)
StpUtil.login("统计聚合集成测试标记用户", "test_device");
MarkerEntity foreign = new MarkerEntity();
foreign.setObjectType(MarkerObjectTypeEnum.TASK.name());
foreign.setObjectNum(untaggedTask);
foreign.setKind(MarkerKindEnum.USER.name());
foreign.setMarkerName("筛选标签");
markerMapper.insert(foreign);
// 本用户仍只看到自己标记的任务:别人的标记不能让他未打标签的任务命中
StpUtil.login(USER, "test_device");
Page after = reviewService.getReviewTaskStats(1, 20, "筛选标签");
assertEquals(1, after.getTotal(), "标签筛选必须受租户隔离约束");
assertEquals(taggedTask, after.getRecords().get(0).getTaskNum());
}
/**
* 分页总数必须受租户隔离:分页拦截器要注册在多租户之后,
* 否则 count 语句是从「还没追加租户条件」的原句派生的,records 正确但 total 会跨租户。
*/
@Test
void pagedTaskListTotalIsTenantScoped() {
StpUtil.login(USER, "test_device");
long mineBefore = reviewService.getReviewTaskStats(1, 20, null).getTotal();
// 另一用户新建任务:若 count 没带租户条件,本用户看到的 total 会被抬高
StpUtil.login("统计聚合集成测试分页用户", "test_device");
long theirsBefore = reviewService.getReviewTaskStats(1, 20, null).getTotal();
saveTask();
saveTask();
assertEquals(theirsBefore + 2, reviewService.getReviewTaskStats(1, 20, null).getTotal(),
"分页 count 必须只算自己的任务");
StpUtil.login(USER, "test_device");
assertEquals(mineBefore, reviewService.getReviewTaskStats(1, 20, null).getTotal(),
"分页 count 必须带租户条件,别人的任务不能算进我的总数");
}
private StudySessionsEntity saveSession(String taskNum, long effectiveSeconds, LocalDateTime startTime) {
StudySessionsEntity session = new StudySessionsEntity();
session.setSessionNum(GenerateNumTool.generateNum("SESSIONAGG"));
session.setTaskNum(taskNum);
session.setStartTime(startTime);
session.setLastStartTime(startTime);
session.setEndTime(startTime.plusSeconds(effectiveSeconds));
session.setActualTime(effectiveSeconds);
session.setEffectiveTime(effectiveSeconds);
session.setEffectivenessRatio(1.0);
session.setSessionState(StudySessionStateEnum.ENDED.name());
studySessionsMapper.insert(session);
return session;
}
private StudyReportsEntity insertReport(String sessionNum) {
StudyReportsEntity report = new StudyReportsEntity();
report.setSessionNum(sessionNum);
report.setFreeSummary("集成测试报告");
studyReportsMapper.insert(report);
return report;
}
private StudyReportFragmentsEntity insertFragment(String sessionNum, String ownerTaskNum) {
StudyReportFragmentsEntity fragment = new StudyReportFragmentsEntity();
fragment.setContextNum(sessionNum);
fragment.setContextType("SESSION");
// 归属-01:碎片计数按内容归属聚合,因此必须带上归属任务
fragment.setOwnerTaskNum(ownerTaskNum);
fragment.setContent("集成测试碎片");
studyReportFragmentsMapper.insert(fragment);
return fragment;
}
}