feat(看板): 删净在跑店铺看板,进度文案对齐客户端,加国家列,默认筛「在跑」

- 店铺看板整条移除(面板/`/shops`/`shops()`/`TaskCenterShopVo`),汇总卡「在跑店铺」保留;
- 采集数据行进度改成客户端那句「关键词进度:第 N/总 个」(只改文字,数字口径与夹取不变),
  其余无进度条的模块仍显示「—」;
- 列表加「国家」列:值来自 request_json 的 7 条路径(线上实测顺序与覆盖 315/451=69.8%),
  按页内主键点查、不进列表 UNION,以免把大 JSON 列拉回已知慢查询;品牌行不发查询;
  只展示不筛选,无迁移;
- 状态默认「在跑」= PENDING∪RUNNING∪SCHEDULED,前端下发 ACTIVE 哨兵、只在服务层 statusFilter
  一处展开,成员与 ACTIVE_STATUS_SET/ACTIVE_STATUSES 同源钉死;
- 护栏:后端 task-center 77 例(新增状态 IN 渲染、7 路径顺序、归一两形态、品牌不查国家等)、
  前端 21 例;4 个变异点(路径顺序/哨兵不展开/归一截断/文案分支)全部被抓到并字节级还原。
This commit is contained in:
2026-10-04 12:48:18 +08:00
parent ea15cc58bf
commit 48aad3f2fd
14 changed files with 550 additions and 460 deletions
@@ -10,6 +10,7 @@ import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -54,9 +55,9 @@ class TaskCenterQueryMapperSqlTest {
.replaceAll("\\s*,\\s*", ",");
}
/** 任务列表分页的查询参数(店铺口径下已不再有设备号)。 */
/** 任务列表分页的查询参数(状态已改为「一组大写状态」,「在跑」由服务层展开)。 */
private static Map<String, Object> taskPageParams(Object shop, long limit, long offset) {
return params("userIds", null, "moduleType", null, "status", null, "shop", shop,
return params("userIds", null, "moduleType", null, "statuses", null, "shop", shop,
"startTime", null, "endTime", null, "limit", limit, "offset", offset);
}
@@ -207,8 +208,8 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskListFiltersReachBothBranchesAndBrandDropsShopFilter() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH", "status", "RUNNING",
"shop", "旗舰店",
params("userIds", List.of(5L, 11L), "moduleType", "PUBLISH",
"statuses", List.of("RUNNING"), "shop", "旗舰店",
"startTime", LocalDateTime.of(2026, 9, 1, 0, 0),
"endTime", LocalDateTime.of(2026, 9, 28, 0, 0),
"limit", 20L, "offset", 20L));
@@ -260,17 +261,55 @@ class TaskCenterQueryMapperSqlTest {
@Test
void taskCountSharesTheUnionBody() {
BoundSql boundSql = render("countTaskPage",
params("userIds", null, "moduleType", "BRAND", "status", "RUNNING",
params("userIds", null, "moduleType", "BRAND", "statuses", List.of("RUNNING"),
"shop", null, "startTime", null, "endTime", null));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("SELECT COUNT(*) FROM(SELECT t.id AS id"));
assertTrue(sql.contains("brand_crawl_tasks"));
assertTrue(sql.contains("AND 'BRAND' = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END = ?"));
assertTrue(sql.contains("AND CASE WHEN UPPER(b.status) = 'CANCELED' THEN 'CANCELLED' ELSE UPPER(b.status) END"
+ " IN(?)"));
assertEquals(4, boundSql.getParameterMappings().size(), "业务 + 状态在两张表各绑一次");
}
/**
* 状态筛选必须是 IN:前端默认项「在跑」= PENDING∪RUNNING∪SCHEDULED 三个状态的合并,
* 留旧的单值等号会让默认视图恒空(选了「在跑」却拿 ACTIVE 去比表里的状态)。
*/
@Test
void statusFilterIsAnInListSoTheMergedActiveSentinelWorks() {
BoundSql boundSql = render("selectTaskPage",
params("userIds", null, "moduleType", null,
"statuses", TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED,
"shop", null, "startTime", null, "endTime", null,
"limit", 20L, "offset", 0L));
String sql = sqlOf(boundSql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?,?,?)"),
"biz 分支按展开后的三个状态过滤:" + sql);
assertTrue(sql.contains("AND " + TaskCenterQueryMapper.STATUS_B + " IN(?,?,?)"),
"品牌分支同口径(小写状态已由 STATUS_B 归一为大写)");
assertEquals(8, boundSql.getParameterMappings().size(), "两张表各绑三个状态 + 分页两个");
assertEquals("PENDING", boundSql.getAdditionalParameter("__frch_st_0"));
assertEquals("RUNNING", boundSql.getAdditionalParameter("__frch_st_1"));
assertEquals("SCHEDULED", boundSql.getAdditionalParameter("__frch_st_2"));
}
/** 选了具体状态时就是单元素 IN,行为与旧的等号一致;不选则整段不渲染。 */
@Test
void singleStatusStillRendersAsOneElementInList() {
String one = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", List.of("SUCCESS"),
"shop", null, "startTime", null, "endTime", null)));
String none = sqlOf(render("countTaskPage",
params("userIds", null, "moduleType", null, "statuses", null,
"shop", null, "startTime", null, "endTime", null)));
assertTrue(one.contains("AND " + TaskCenterQueryMapper.STATUS_T + " IN(?)"), "单状态 = IN 一个值:" + one);
assertFalse(none.contains(TaskCenterQueryMapper.STATUS_T + " IN"), "未选状态不加状态条件");
}
@Test
void usernameLookupIsFuzzyAndBounded() {
BoundSql boundSql = render("selectUserIdsByUsername", params("keyword", "ali"));
@@ -311,6 +350,32 @@ class TaskCenterQueryMapperSqlTest {
assertEquals(2L, boundSql.getAdditionalParameter("__frch_tid_1"));
}
/**
* 国家列的取数:七条 JSON 路径与先后顺序 = 2026-10-04 生产实测(近 30 天 20 行页采样 16 行有值、
* 全量 70.7%),少一条或换序就是另一套覆盖率,所以按「出现顺序」断言而不是只看包含。
* 形状钉死:只回 taskId + country 两列、按主键点查,不进列表主查询(那条不许碰 request_json)。
*/
@Test
void countryLookupReadsTheMeasuredSevenPathsInOrderByPrimaryKey() {
List<String> measuredOrder = List.of("$.filters.countryCode", "$.countryCode", "$.country",
"$.publish_country", "$.countryCodes", "$.country_codes", "$.filters.countryCodes");
BoundSql boundSql = render("selectTaskCountries", params("taskIds", List.of(1L, 2L)));
String sql = sqlOf(boundSql);
int previous = -1;
for (String path : measuredOrder) {
int at = sql.indexOf("JSON_UNQUOTE(JSON_EXTRACT(t.request_json,'" + path + "'))");
assertTrue(at > previous, "路径缺失或顺序变了(顺序就是优先级):" + path + " at=" + at);
previous = at;
}
assertEquals(7, sql.split("JSON_UNQUOTE\\(JSON_EXTRACT\\(t\\.request_json,", -1).length - 1,
"七条路径一条不多一条不少");
assertTrue(sql.startsWith("SELECT t.id AS taskId,COALESCE("), "只出两列,大 JSON 不回服务层");
assertTrue(sql.endsWith("WHERE t.id IN(?,?)"), "按页内任务号点查");
assertFalse(sql.contains("result_json"), "国家不碰进度那个 JSON 列");
assertEquals(2, boundSql.getParameterMappings().size());
}
/** 店铺只有两个真来源:上架结果文件的 shop_name、逐店落行的模块的 source_filename。 */
@Test
void shopSourcesAreBatchedByTaskId() {
@@ -369,6 +434,11 @@ class TaskCenterQueryMapperSqlTest {
TaskCenterQueryMapper.BRAND_ACTIVE_STATUSES);
assertEquals(TaskCenterQueryMapper.sqlList(TaskCenterQueryMapper.BRAND_TERMINAL_STATUS_SET),
TaskCenterQueryMapper.BRAND_TERMINAL_STATUSES);
// 「在跑」筛选项走有序版本(IN 列表要可断言),成员必须与判在跑/判卡住用的那个 Set 完全一致
assertEquals(TaskCenterQueryMapper.ACTIVE_STATUS_SET,
Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), "展开成 IN 的那组 = 进行中状态集合");
assertEquals(List.of("PENDING", "RUNNING", "SCHEDULED"),
TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED, "顺序固定,SQL 文本与日志才可断言");
}
/**
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.taskcenter.service;
import com.nanri.aiimage.modules.taskcenter.mapper.TaskCenterQueryMapper;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCollectStatsRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterCountryRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterDeviceRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterShopStatRow;
@@ -10,7 +11,6 @@ import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskQuery;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterTaskRow;
import com.nanri.aiimage.modules.taskcenter.model.dto.TaskCenterUserRow;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterOverviewVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterShopVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskDetailVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskPageVo;
import com.nanri.aiimage.modules.taskcenter.model.vo.TaskCenterTaskRowVo;
@@ -150,16 +150,18 @@ class TaskCenterQueryServiceTest {
return row;
}
private static TaskCenterCountryRow countryRow(long taskId, String country) {
TaskCenterCountryRow row = new TaskCenterCountryRow();
row.setTaskId(taskId);
row.setCountry(country);
return row;
}
private static TaskCenterTaskRowVo item(TaskCenterTaskPageVo page, long id) {
return page.getItems().stream().filter(row -> Long.valueOf(id).equals(row.getId()))
.findFirst().orElseThrow(() -> new AssertionError("任务缺失: " + id));
}
private static TaskCenterShopVo shop(List<TaskCenterShopVo> rows, String name) {
return rows.stream().filter(row -> name.equals(row.getShop()))
.findFirst().orElseThrow(() -> new AssertionError("店铺行缺失: " + name));
}
private void stubPage(List<TaskCenterTaskRow> rows) {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any()))
.thenReturn((long) rows.size());
@@ -181,6 +183,15 @@ class TaskCenterQueryServiceTest {
when(queryMapper.selectFileResultShops(any())).thenReturn(rows);
}
/** 「在跑店铺」只从汇总卡这个真实出口读,不给私有方法开后门。 */
private long shopRunning() {
when(queryMapper.countShops(isNull())).thenReturn(86L);
when(queryMapper.countRunningTasks(isNull())).thenReturn(0L);
when(queryMapper.countStuckTasks(isNull(), any())).thenReturn(0L);
when(queryMapper.countFinishedTasksSince(isNull(), any())).thenReturn(0L);
return service.overview(superScope()).getShopRunning();
}
// ── 汇总卡 ──────────────────────────────────────────────────────────
@Test
@@ -210,80 +221,29 @@ class TaskCenterQueryServiceTest {
}
@Test
void overviewRunningShopsEqualsPanelRowsExcludingTheBucket() {
void runningShopsCountsRealShopsOnly() {
LocalDateTime now = LocalDateTime.now();
when(queryMapper.countShops(isNull())).thenReturn(86L);
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
TaskCenterOverviewVo vo = service.overview(superScope());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1L, vo.getShopRunning(), "2 个在跑任务里只有 1 家真店铺,另一行是不挂店铺桶");
assertEquals(2, panel.size(), "卡片与面板共用同一份聚合:面板 1 家店铺 + 1 行桶");
assertEquals(1L, panel.stream().filter(row -> !row.isNoShop()).count());
assertEquals(1L, shopRunning(), "2 个在跑任务里只有 1 家真店铺,采集数据不落店铺");
}
@Test
void scopedOperatorPassesVisibleUsersToEveryQuery() {
service.overview(scoped(5L, 11L));
service.shops(scoped(5L, 11L));
service.shopOptions(scoped(5L, 11L));
// 可见集合由 Set 转来、顺序不定,断言必须与顺序无关。
verify(queryMapper).countShops(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper).countRunningTasks(argThat(TaskCenterQueryServiceTest::visiblePair));
verify(queryMapper, times(2))
.selectActiveTasks(argThat(TaskCenterQueryServiceTest::visiblePair), anyLong());
verify(queryMapper).selectShopNames(argThat(TaskCenterQueryServiceTest::visiblePair));
}
@Test
void shopOptionsAreTheRegistryNamesAsReturned() {
when(queryMapper.selectShopNames(isNull())).thenReturn(List.of("林芳旗舰店", "美国店"));
assertEquals(List.of("林芳旗舰店", "美国店"), service.shopOptions(superScope()));
}
// ── 店铺面板 ────────────────────────────────────────────────────────
@Test
void everyActiveTaskLandsInExactlyOnePanelBucket() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "COLLECT_DATA", "RUNNING", now, now),
brandTaskRow(3L, "running", now, now)));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size(), "1 家店铺 + 1 行不挂店铺桶");
assertEquals(3L, panel.stream().mapToLong(TaskCenterShopVo::getRunningTasks).sum(),
"每个进行中任务恰好落进一个桶,采集数据与品牌任务不许在看板里消失");
assertEquals(2L, shop(panel, TaskCenterQueryService.NO_SHOP_LABEL).getRunningTasks());
}
@Test
void multiShopTaskIsCountedUnderEachOfItsShops() {
void multiShopTaskMakesEveryShopCount() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(1L, "乙店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(2, panel.size());
assertEquals(1L, shop(panel, "甲店").getRunningTasks());
assertEquals(1L, shop(panel, "乙店").getRunningTasks(), "一个任务挂两家店 → 两家店各算 1 个在跑任务");
assertEquals(2L, shopRunning(), "一个任务挂两家店 → 两家店各算一家在跑");
}
@Test
void sameShopWrittenTwoWaysStaysOneRow() {
void sameShopWrittenTwoWaysCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
@@ -291,81 +251,34 @@ class TaskCenterQueryServiceTest {
stubPublishShops(List.of(shopRow(1L, "Amazon 美国店"), shopRow(2L, "amazon 美国店 ")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size(), "大小写与首尾空格差异不拆成两行(与 SQL 的 LOWER(TRIM) 同口径)");
assertEquals("Amazon 美国店", panel.get(0).getShop(), "展示名沿用首次出现的写法");
assertEquals(2L, panel.get(0).getRunningTasks());
assertEquals(1L, shopRunning(), "大小写与首尾空格差异不拆成两家(与 SQL 的 LOWER(TRIM) 同口径)");
}
@Test
void panelRowFlagsStuckTasksAndCarriesFreshestReport() {
void sameShopFromBothSourcesCountsOnce() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now.minusHours(2), now.minusMinutes(30)),
taskRow(2L, "SHOP_MATCH", "RUNNING", now.minusHours(1), now.minusSeconds(40))));
stubPublishShops(List.of(shopRow(1L, "林芳旗舰店"), shopRow(2L, "林芳旗舰店")));
stubFileResultShops(List.of());
stubActiveTasks(List.of(taskRow(1L, "PRICE_TRACK", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店")));
stubFileResultShops(List.of(shopRow(1L, "甲店")));
TaskCenterShopVo row = shop(service.shops(superScope()), "林芳旗舰店");
assertEquals(2L, row.getRunningTasks());
assertEquals(1L, row.getStuckTasks(), "只有 30 分钟没上报的那个算卡住");
assertTrue(within(row.getLastReportAt(), now.minusSeconds(40), 5), "最近上报取该店所有在跑任务里最新的一次");
assertEquals("定时匹配×1 / 跟价×1", row.getModuleSummary(), "按任务数倒序、同数按业务名稳定排列");
assertEquals(1L, shopRunning(), "上架文件与逐店结果行指向同一家店时不重复计数");
}
@Test
void moduleSummaryAggregatesCountsPerBusiness() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now)));
stubPublishShops(List.of(shopRow(1L, "甲店"), shopRow(2L, "甲店"), shopRow(3L, "甲店")));
stubFileResultShops(List.of());
assertEquals("跟价×2 / 定时匹配×1", shop(service.shops(superScope()), "甲店").getModuleSummary());
}
@Test
void panelSortsStuckFirstThenStalestReportWithBucketLast() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(1)),
taskRow(2L, "PRICE_TRACK", "RUNNING", now, now.minusMinutes(30)),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now.minusMinutes(5)),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now.minusHours(3))));
stubPublishShops(List.of(shopRow(1L, "A店"), shopRow(2L, "B店"), shopRow(3L, "C店")));
stubFileResultShops(List.of());
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(List.of("B店", "C店", "A店", TaskCenterQueryService.NO_SHOP_LABEL),
panel.stream().map(TaskCenterShopVo::getShop).toList(),
"有卡住的排最前,其次最久没上报的,桶永远垫底(哪怕它最久没动)");
}
@Test
void brandTasksNeverQueryShopSourcesAndLandInTheBucket() {
void brandTasksNeverQueryShopSources() {
LocalDateTime now = LocalDateTime.now();
stubActiveTasks(List.of(brandTaskRow(7L, "running", now, now)));
List<TaskCenterShopVo> panel = service.shops(superScope());
assertEquals(1, panel.size());
assertTrue(panel.get(0).isNoShop(), "品牌任务按关键字执行,不落店铺,只能进桶");
assertEquals(1L, panel.get(0).getRunningTasks());
assertEquals(0L, shopRunning(), "品牌任务按关键字执行,没有店铺维度");
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@Test
void emptyPanelDoesNotQueryShopSources() {
void noActiveTaskMeansNoShopSourceQuery() {
stubActiveTasks(List.of());
assertEquals(List.of(), service.shops(superScope()));
assertEquals(0L, shopRunning());
verify(queryMapper, never()).selectPublishShops(any());
verify(queryMapper, never()).selectFileResultShops(any());
}
@@ -432,12 +345,71 @@ class TaskCenterQueryServiceTest {
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).countTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end));
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq("RUNNING"),
verify(queryMapper).selectTaskPage(isNull(), eq("PUBLISH"), eq(List.of("RUNNING")),
eq("旗舰店"), eq(start), eq(end), eq(100L), eq(200L));
}
/** 前端默认项「在跑」= 三个进行中状态的合并:下传的是状态序列,不是字面量 ACTIVE。 */
@Test
void activeSentinelExpandsIntoTheThreeRunningStates() {
when(queryMapper.countTaskPage(any(), any(), any(), any(), any(), any())).thenReturn(0L);
TaskCenterTaskQuery query = new TaskCenterTaskQuery();
query.setStatus("ACTIVE");
service.tasks(superScope(), query);
verify(queryMapper).countTaskPage(isNull(), isNull(),
eq(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED), isNull(), isNull(), isNull());
assertEquals(Set.copyOf(TaskCenterQueryMapper.ACTIVE_STATUSES_ORDERED),
TaskCenterQueryMapper.ACTIVE_STATUS_SET, "「在跑」的合并口径必须与判卡住用的那组同源");
}
@Test
void statusFilterKeepsSingleStatesAndIgnoresBlank() {
assertEquals(List.of("RUNNING"), TaskCenterQueryService.statusFilter("running"), "大小写不敏感");
assertEquals(List.of("CANCELLED"), TaskCenterQueryService.statusFilter(" CANCELLED "));
assertNull(TaskCenterQueryService.statusFilter(""), "空 = 不裁剪");
assertNull(TaskCenterQueryService.statusFilter(null));
}
/** 国家列:原文两种形状都要归一,取不到留空(前端画「—」),不许把 null 当国家名。 */
@Test
void countryColumnIsNormalizedFromBothJsonShapes() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(
taskRow(1L, "PRICE_TRACK", "RUNNING", now, now),
taskRow(2L, "PUBLISH", "RUNNING", now, now),
taskRow(3L, "SHOP_MATCH", "RUNNING", now, now),
taskRow(4L, "COLLECT_DATA", "RUNNING", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
stubPublishShops(List.of());
stubFileResultShops(List.of());
when(queryMapper.selectTaskCountries(List.of(1L, 2L, 3L, 4L))).thenReturn(List.of(
countryRow(1L, "[\"UK\"]"),
countryRow(2L, "[\"UK\", \"DE\"]"),
countryRow(3L, "DE")));
TaskCenterTaskPageVo page = service.tasks(superScope(), new TaskCenterTaskQuery());
assertEquals("UK", item(page, 1L).getCountry(), "单元素数组去掉括号,与裸串 UK 同值");
assertEquals("UK/DE", item(page, 2L).getCountry(), "多国家任务不能只显示第一个");
assertEquals("DE", item(page, 3L).getCountry());
assertNull(item(page, 4L).getCountry(), "该模块不写国家 → 无值,不是空串");
}
/** 品牌任务按关键字执行、没有国家维度;它的 id 还会与 biz 表撞号,所以连点查都不发。 */
@Test
void brandRowsAreNotAskedForCountries() {
LocalDateTime now = LocalDateTime.now();
stubPage(List.of(brandTaskRow(7L, "running", now, now)));
when(queryMapper.selectSnapshots(any())).thenReturn(List.of());
assertNull(item(service.tasks(superScope(), new TaskCenterTaskQuery()), 7L).getCountry());
verify(queryMapper, never()).selectTaskCountries(any());
}
@Test
void stuckFlagBoundary() {
LocalDateTime now = LocalDateTime.now();