Files
lpt-be/src/test/java/com/guo/learningprogresstracker/service/impl/ReviewStatsAggregationIntegrationTest.java
T

317 lines
15 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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)。
*
* <p>核心验收:聚合返回的行数与「任务数」同阶,不随历史会话数线性增长;
* 同时守住自定义 SQL 的两个隐式条件(租户隔离与逻辑删除)。</p>
*/
@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<TaskSessionStats> 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<TaskContentCount> reports = studyReportsMapper.countReportsByTask(Set.of(taskNum));
List<TaskContentCount> 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<TaskContentCount> reports = studyReportsMapper.countReportsByTask(Set.of(taskNum));
List<TaskContentCount> 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。
*
* <p>裸表 count 会把「待归类」碎片也算进「学习残片」,而列表的碎片数按内容归属聚合,
* 两者对不上(待归类在总览里另有独立区块展示)。这里额外造一条待归类碎片,
* 一旦汇总退回裸表计数,断言就会失败。</p>
*/
@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<ReviewTaskStats> 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 查询算出,且子查询也受租户隔离约束。
*
* <p>「同一 task_num 上存在别人打的同名标签」这种编号碰撞下,若子查询没带 created_by,
* 就会把别人标记的任务算成自己的命中——这里用直插 marker 的方式构造该场景守住它。</p>
*/
@Test
void markerFilterIsPushedIntoSqlAndStaysTenantScoped() throws Exception {
String untaggedTask = saveTask();
String taggedTask = saveTask();
markerService.addUserTag(MarkerObjectTypeEnum.TASK, taggedTask, "筛选标签");
// 本用户:只命中自己打过标签的那一个
Page<ReviewTaskStats> page = reviewService.getReviewTaskStats(1, 20, "筛选标签");
assertEquals(1, page.getTotal());
assertEquals(taggedTask, page.getRecords().get(0).getTaskNum());
// 没有命中时返回空页,不能退化成「不过滤」
Page<ReviewTaskStats> 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<ReviewTaskStats> 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;
}
}