feat(公司tab): 批次 2/3/4 再接 8 页,注册表收到 16 页——用户页回流 company_id 按新边界改写反向钉

「切 tab 数据还一样」的根因一直是分母小于现实:批次 1 只登记 8 页,本轮按控制方
三次点名扩到 16 页(company-scope.ts 是唯一清单,routes.ts 的 companyScoped 逐页对平)。

批次 2(五页 ASIN 中心):去重总数据 / 不符合ASIN / 查询ASIN / 最低价ASIN / 商品类目。
批次 3(两页店铺中心):撞款监控、店铺数据记录。这两页没有归属列可筛,归属口径是
「本公司账号名下的店铺」——后端由 DataReadScope 推公司 → 成员账号 → biz_shop_manage.
created_by_id,前端只把 activeId 当 company_id 送下去。空成员集必须交空集合,绝不能
退化成 null(null 在这里=全量,那样第二家会看到全部数据)。
批次 4(用户管理):后端早就认 company_id(只对站点超管生效,公司超管恒锁本公司),
断的是前端——UserListQuery 里连这个字段都没有,三家 tab 看的是同一份全量列表。

三处口径改动,逐条说明:
1)company-user-list.test.ts 的反向钉被改写。2026-10-04 定案把公司维度从用户页整体摘掉,
   那条钉的原文是「列表查询/筛选/行渲染不允许出现公司维度」。控制方 2026-10-05 明确要
   用户管理区分公司 tab,所以钉的边界收窄成两半:渲染层(行级公司列、「所属公司」标签、
   筛选状态、顶栏公司名)仍不得回流;请求层的 company_id 是这次加回来的,尺子换成
   「取值口唯一」——页面每处 companyId 都必须等于 companyTab.requestCompanyId,且
   normalizeUserPageParams/toUserListQuery 两只白名单构造器体内不许出现公司值。
   新增一支行为钉:往归一化里传 companyId 必须被丢掉,这是 users.ts 读原始入参的全部理由
   (写成 normalized.companyId 时 TS 照样绿、运行时恒 undefined)。
2)align-dup-console 那条 watch 看守的 token 扩到含 reload。变异自证里「删掉 void
   loadConsole()」当场全绿:体里的清筛选项守住了,重新取数那半没人守。批次 3/4 三对
   token 一起写到 reload 为止(批次 1/2 的老条目不动)。
3)公司管理页补正/反向两把尺子:company-config-entry-super-only 新增「吃公司 tab 的页面
   集合恰好等于 COMPANY_SCOPED_PAGES 的 pageFiles」——按代码真值比,不按清单比,所以
   清单不改一字而往 CompaniesPage.vue 里塞 store 也会红。谓词带括号,否则 import 行也算消费者。

菜单权限(admin_columns)本轮不动:MenusPage 只消费 /api/admin/permission-menus 这一份全局
菜单字典,切 tab 一样是数据本身全局,不是筛选坏了。真问题在写侧——PermissionMenuService
create/update/delete 只有 ensureAdminOperatorIfPresent(isAdmin 即放行),公司管理员改的是
全平台的菜单行。收窄为仅站点超管 vs 给 permission_menu 加归属列,两种改法代价差一个量级,
留给控制方定档。

护栏:G1 发送口 22 个 / 页面分组 17、watch 体看守 10 对、operation-guide 的 tab 文案 15 页
(撞款监控是显式豁免,另有一条自检盯「豁免落空」)。
变异自证 12/12 全杀(前端 10 + 公司管理反向钉 2),分母钉死在 27 例。
门禁:后端全量 3823 例 / 0 失败 / 0 错误 / 7 skipped,BUILD SUCCESS;admin-frontend-vue
1741 例 / 0 红;vue-tsc rc=0。首轮后端 4 红是另一路 task_partial 改动与本轮编译抢跑,
单跑 13 例已绿,本笔不含他们的任何文件。

未上线:jar 与 admin-vue 都没出包,V147 未在生产执行。
This commit is contained in:
2026-10-06 02:32:59 +08:00
parent e5e36aa713
commit 16583f578d
87 changed files with 3519 additions and 459 deletions
@@ -142,7 +142,7 @@ class CollectDataBrandRecheckInjectorTest {
List.of(chunk(1, "s1", "hash1", "ptr1")));
when(transientPayloadStorageService.resolvePayload(eq("ptr1"), anyString())).thenReturn(
"[{\"asin\":\"B01\",\"brand\":\"Zara\"},{\"asin\":\"B02\",\"brand\":\"Zara\"}]");
when(invalidAsinBatchWriter.writeBatch(anyList())).thenReturn(2);
when(invalidAsinBatchWriter.writeBatch(anyList(), eq(961L))).thenReturn(2);
GroupOutcome outcome = injector.apply(task(100L), Map.of("zara", RecheckVerdict.REJECTED));
@@ -208,7 +208,7 @@ class CollectDataServiceTxBoundaryTest {
service.submitResult(TASK_ID, submitRequest());
verify(invalidAsinBatchWriter).writeBatch(any());
verify(invalidAsinBatchWriter).writeBatch(any(), eq(USER_ID));
}
@Test
@@ -220,7 +220,7 @@ class CollectDataServiceTxBoundaryTest {
service.submitResult(TASK_ID, submitRequest());
verify(invalidAsinBatchWriter, never()).writeBatch(any());
verify(invalidAsinBatchWriter, never()).writeBatch(any(), any());
}
@Test
@@ -232,7 +232,7 @@ class CollectDataServiceTxBoundaryTest {
service.submitResult(TASK_ID, submitRequest());
verify(invalidAsinBatchWriter, never()).writeBatch(any());
verify(invalidAsinBatchWriter, never()).writeBatch(any(), any());
}
@Test
@@ -1,5 +1,6 @@
package com.nanri.aiimage.modules.collectdata.util;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.entity.InvalidAsinDataEntity;
@@ -26,16 +27,29 @@ import static org.mockito.Mockito.when;
* biz_invalid_asin_data(INSERT IGNORE,按唯一键幂等),空批次/无合法
* data_value 的批次不发起任何 insertBatchIgnore 调用;远程失败降级记录
* 计数(跳过写入),可恢复后继续,不抛出中断整个提交流程的异常。
*
* <p>归属那一笔(10-05 批次 3):实体与 INSERT 列清单此前都不带 company_id/uploader_user_id,
* V145 补的列全靠 DEFAULT 1 盖 ⇒ 第 2 家公司跑货源产生的行被记成第 1 家。写入器现在按
* 调用方给的任务发起账号推公司,<b>推不出公司就整批不写</b>(宁可少一条黑名单,也不把行盖成
* 别家公司 —— 那会让另一家的正常品牌被静默过滤)。</p>
*/
class CollectDataInvalidAsinBatchWriterTest {
/** 任务发起账号(biz_file_task.user_id)。 */
private static final Long UPLOADER = 7L;
/** 该账号归属的公司 —— 必须与 UPLOADER 不同值,否则断言分不清写进去的是哪个。 */
private static final Long UPLOADER_COMPANY = 2L;
private InvalidAsinDataMapper invalidAsinDataMapper;
private CompanyScopeSupport companyScopeSupport;
private CollectDataInvalidAsinBatchWriter writer;
@BeforeEach
void setUp() {
invalidAsinDataMapper = mock(InvalidAsinDataMapper.class);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 10);
companyScopeSupport = mock(CompanyScopeSupport.class);
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 10);
}
@Test
@@ -46,7 +60,7 @@ class CollectDataInvalidAsinBatchWriterTest {
int written = writer.writeBatch(List.of(
row("B000000001", "Zara"),
row("B000000002", "nike")
));
), UPLOADER);
assertEquals(2, written, "两行都写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
@@ -68,7 +82,7 @@ class CollectDataInvalidAsinBatchWriterTest {
rows.add(row("B" + String.format("%09d", i + 1), "brand-" + (i % 7)));
}
int written = writer.writeBatch(rows);
int written = writer.writeBatch(rows, UPLOADER);
assertEquals(100, written, "全部写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
@@ -95,8 +109,8 @@ class CollectDataInvalidAsinBatchWriterTest {
row("B000000003", "")
);
int first = writer.writeBatch(rows);
int second = writer.writeBatch(rows);
int first = writer.writeBatch(rows, UPLOADER);
int second = writer.writeBatch(rows, UPLOADER);
assertEquals(2, first, "首轮 2 个合法行写入");
assertEquals(2, second, "重复执行同样只写合法行(幂等键由 SQL 保证)");
@@ -108,11 +122,11 @@ class CollectDataInvalidAsinBatchWriterTest {
@Test
void test_task_048_asin_boundary_empty_input() {
// 空输入:空列表与全空行均不发起任何批量写入调用,返回 0。
int written = writer.writeBatch(null);
int written = writer.writeBatch(null, UPLOADER);
assertEquals(0, written, "null 输入返回 0");
verify(invalidAsinDataMapper, never()).insertBatchIgnore(anyList());
int blankWritten = writer.writeBatch(List.of(row("", "nike"), row("B000000001", "")));
int blankWritten = writer.writeBatch(List.of(row("", "nike"), row("B000000001", "")), UPLOADER);
assertEquals(0, blankWritten, "无合法行返回 0");
verify(invalidAsinDataMapper, never()).insertBatchIgnore(anyList());
}
@@ -122,7 +136,7 @@ class CollectDataInvalidAsinBatchWriterTest {
// 单元素:单行单品牌正常批量写入;批次大小 1 的边界也正常。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenReturn(1);
int written = writer.writeBatch(List.of(row("B000000001", "solo")));
int written = writer.writeBatch(List.of(row("B000000001", "solo")), UPLOADER);
assertEquals(1, written, "单行写入成功");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
@@ -137,13 +151,13 @@ class CollectDataInvalidAsinBatchWriterTest {
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
CollectDataInvalidAsinBatchWriter smallWriter =
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 3);
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 3);
List<CollectDataResultRowVo> rows = new ArrayList<>();
for (int i = 0; i < 10; i++) {
rows.add(row("B" + String.format("%09d", i + 1), "brand"));
}
int written = smallWriter.writeBatch(rows);
int written = smallWriter.writeBatch(rows, UPLOADER);
assertEquals(10, written, "全部写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
@@ -164,7 +178,7 @@ class CollectDataInvalidAsinBatchWriterTest {
rows.add(row("B000000001", null));
rows.add(row(" B000000002 ", " nike "));
int written = writer.writeBatch(rows);
int written = writer.writeBatch(rows, UPLOADER);
assertEquals(1, written, "仅完全合法的 1 行写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
@@ -187,7 +201,7 @@ class CollectDataInvalidAsinBatchWriterTest {
rows.add(row("B" + String.format("%09d", i + 1), "brand"));
}
int written = writer.writeBatch(rows);
int written = writer.writeBatch(rows, UPLOADER);
assertEquals(2, written, "首批失败跳过,第二批 2 行写入");
verify(invalidAsinDataMapper, times(2)).insertBatchIgnore(anyList());
@@ -196,6 +210,38 @@ class CollectDataInvalidAsinBatchWriterTest {
assertTrue(captor.getAllValues().get(1).size() > 0, "恢复后批次非空");
}
@Test
void test_batch_3_asin_normal_ownership_is_stamped_on_every_row() {
// 归属由任务发起账号推:每一行都带 company_id + uploader_user_id,
// 而不是留空让 DEFAULT 1 去盖(那会把第 2 家的行记成第 1 家,事后分不开)。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(invalidAsinDataMapper).insertBatchIgnore(captor.capture());
List<InvalidAsinDataEntity> entities = captor.getValue();
assertEquals(2, entities.size());
for (InvalidAsinDataEntity entity : entities) {
assertEquals(UPLOADER_COMPANY, entity.getCompanyId(), "company_id 来自发起账号,不是 DEFAULT");
assertEquals(UPLOADER, entity.getUploaderUserId(), "uploader_user_id 一并落,处置可回溯到人");
}
}
@Test
void test_batch_3_asin_invalid_owner_unresolved_skips_whole_batch() {
// 推不出公司(账号已删/没有公司):整批不写、返回 0、一次 insertBatchIgnore 都不发。
// 这一族的替代方案是"照常写、让 DEFAULT 盖一家",那是静默串数据,必须判红。
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(null);
int written = writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
assertEquals(0, written, "归属推不出 ⇒ 一行都不写");
verify(invalidAsinDataMapper, never()).insertBatchIgnore(anyList());
}
private static CollectDataResultRowVo row(String asin, String brand) {
CollectDataResultRowVo row = new CollectDataResultRowVo();
row.setAsin(asin);
@@ -19,6 +19,8 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
@@ -34,8 +36,10 @@ import static org.mockito.Mockito.when;
* 还没摘,此后每个没显式传公司的写入都会被静默塞进默认那家——不报错、不丢数据,只在后台列表里
* 表现成"这条数据怎么在别家公司"。所以必须用代码在启动期喊出来,而不是写在注释里等人记得。</p>
*
* <p>V145 之后盯的是【三张表】(users + 两张规则库),不是一列:漏登记的那张表等于没人盯,
* 所以"探不到列"也要出声(见 {@link #unwatchedTableIsAnnouncedInsteadOfLookingClean})。</p>
* <p>V145 之后盯的是【一张清单】(users + 两张规则库 + V147 的 biz_product_category),不是一列:
* 漏登记的那张表等于没人盯,所以"探不到列"也要出声(见
* {@link #unwatchedTableIsAnnouncedInsteadOfLookingClean})。清单与探针 SQL 的 IN 列表双向同源由
* {@link #watchedTablesMatchTheProbeSql} 钉住。</p>
*/
class CompanyDefaultGuardTest {
@@ -66,20 +70,49 @@ class CompanyDefaultGuardTest {
when(companyMapper.selectCount(null)).thenReturn(count);
}
/** 一条探针结果都没有=这些表在 information_schema 里查不到 company_id。 */
/**
* 一条探针结果都没有=这些表在 information_schema 里查不到 company_id。
*
* <p>未被点名的表按"已摘掉"自动补齐:清单哪天加第五条,本文件那几支"一声不响"的用例不会
* 因为漏了一张而红在 {@link #unwatchedTableIsAnnouncedInsteadOfLookingClean} 的同一条 WARN 上——
* 那种红会把人引去改哨兵,而哨兵是对的。要演"探不到"那一族,用 {@link #probeReturnsOnly}。</p>
*/
private void probeReturns(String... tableAndDefault) {
Map<String, String> given = new LinkedHashMap<>();
for (String entry : tableAndDefault) {
int split = entry.indexOf('=');
given.put(entry.substring(0, split), split + 1 >= entry.length() ? null : entry.substring(split + 1));
}
List<Map<String, Object>> rows = new ArrayList<>();
for (String table : CompanyDefaultGuard.WATCHED_TABLES) {
if (!given.containsKey(table)) {
rows.add(row(table, null));
} else {
rows.add(row(table, given.get(table)));
}
}
when(jdbcTemplate.queryForList(anyString())).thenReturn(rows);
}
/** 只给这几条结果,不补清单:用来演"某一列在 information_schema 里查不到"。 */
private void probeReturnsOnly(String... tableAndDefault) {
List<Map<String, Object>> rows = new ArrayList<>();
for (String entry : tableAndDefault) {
int split = entry.indexOf('=');
Map<String, Object> row = new LinkedHashMap<>();
row.put("TABLE_NAME", entry.substring(0, split));
row.put("COLUMN_DEFAULT", split + 1 >= entry.length() || "null".equals(entry.substring(split + 1))
? null : entry.substring(split + 1));
rows.add(row);
rows.add(row(entry.substring(0, split),
split + 1 >= entry.length() || "null".equals(entry.substring(split + 1))
? null : entry.substring(split + 1)));
}
when(jdbcTemplate.queryForList(anyString())).thenReturn(rows);
}
private static Map<String, Object> row(String table, String columnDefault) {
Map<String, Object> row = new LinkedHashMap<>();
row.put("TABLE_NAME", table);
row.put("COLUMN_DEFAULT", "null".equals(columnDefault) ? null : columnDefault);
return row;
}
private String messageAt(Level level) {
return appender.list.stream()
.filter(e -> e.getLevel() == level)
@@ -194,19 +227,39 @@ class CompanyDefaultGuardTest {
@DisplayName("盯不到的那张表要出声,不能装作检查过了")
void unwatchedTableIsAnnouncedInsteadOfLookingClean() {
companies(2);
probeReturns("users=null");
probeReturnsOnly("users=null");
guard.check();
assertThat(messageAt(Level.ERROR)).isEmpty();
assertThat(messageAt(Level.WARN))
.contains(CompanyDefaultGuard.PROBE_FAILED)
.contains("biz_invalid_asin_data")
.contains("biz_dedupe_total_data");
String warn = messageAt(Level.WARN);
assertThat(warn).contains(CompanyDefaultGuard.PROBE_FAILED);
// 逐条点名而不是挑两条写死:清单里每一条都必须出现在"探不到"的名单里,
// 新登记表漏进 SQL 之外的任何一侧都会在这一支红。
for (String table : CompanyDefaultGuard.WATCHED_TABLES) {
if (!"users".equals(table)) {
assertThat(warn).contains(table);
}
}
}
@Test
@DisplayName("探的是这三张表的 company_id 列,表名列名写错就等于没探")
@DisplayName("V147 的 biz_product_category 也在盯的清单里:摘 DEFAULT 那一步不许把它落下")
void productCategoryTableIsWatchedToo() {
companies(2);
probeReturns("biz_product_category=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_product_category.company_id DEFAULT=1")
.contains("ALTER TABLE biz_product_category ALTER COLUMN company_id DROP DEFAULT")
.doesNotContain("MODIFY");
}
@Test
@DisplayName("探的是清单里这几张表的 company_id 列,表名列名写错就等于没探")
void probeReadsTheRightColumns() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
@@ -218,19 +271,38 @@ class CompanyDefaultGuardTest {
assertThat(sql.getValue())
.contains("information_schema.COLUMNS")
.contains("DATABASE()")
.contains("'company_id'")
.contains("'users'")
.contains("'biz_invalid_asin_data'")
.contains("'biz_dedupe_total_data'");
.contains("'company_id'");
for (String table : CompanyDefaultGuard.WATCHED_TABLES) {
assertThat(sql.getValue()).contains("'" + table + "'");
}
}
/**
* 双向钉同源。只钉"清单里的都在 SQL 里"会漏掉另一侧:有人往 SQL 的 IN 列表加了一张表、
* 却没加进 {@code WATCHED_TABLES},那么 {@link #check} 的逐表循环根本不会走到它——
* 探针查得到、判定查不到,Outcome 是"这张表没人盯"而一声不响,正是本哨兵要消灭的那个形状。
*/
@Test
@DisplayName("清单与探针 SQL 的 IN 列表必须同源:漏一条就是那张表没人盯")
@DisplayName("清单与探针 SQL 的 IN 列表必须同源:两个方向都钉,漏一条就是那张表没人盯")
void watchedTablesMatchTheProbeSql() {
String probeSql = probeSqlText();
for (String table : CompanyDefaultGuard.WATCHED_TABLES) {
assertThat(probeSql).contains("'" + table + "'");
}
assertThat(inListTables(probeSql)).containsExactlyInAnyOrder(
CompanyDefaultGuard.WATCHED_TABLES.toArray(new String[0]));
}
/** 取 {@code TABLE_NAME IN ('a', 'b')} 里那批单引号表名(只认 IN 那一段,别把 'company_id' 也算进来)。 */
private static List<String> inListTables(String probeSql) {
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(probeSql);
assertThat(inList.find()).as("探针 SQL 里没有 TABLE_NAME IN (…) 这一段,取不到清单").isTrue();
List<String> tables = new ArrayList<>();
Matcher quoted = Pattern.compile("'([^']+)'").matcher(inList.group(1));
while (quoted.find()) {
tables.add(quoted.group(1));
}
return tables;
}
private String probeSqlText() {
@@ -2,9 +2,12 @@ package com.nanri.aiimage.modules.dedupe.controller;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.service.ReadScope;
import com.nanri.aiimage.modules.dedupe.service.DedupeTotalDataService;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
@@ -15,6 +18,7 @@ import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBo
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.time.LocalDate;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -38,9 +42,11 @@ class DedupeTotalDataControllerTest {
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService);
service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L);
operator.setRole("super_admin");
@@ -57,7 +63,8 @@ class DedupeTotalDataControllerTest {
eq(LocalDate.of(2026, 7, 31)),
eq(3L),
isNull(),
eq(8L));
eq(8L),
isNull());
ResponseEntity<StreamingResponseBody> response = controller.export(
"member",
@@ -65,6 +72,7 @@ class DedupeTotalDataControllerTest {
LocalDate.of(2026, 7, 31),
3L,
null,
null,
request);
assertNotNull(response.getBody());
@@ -87,9 +95,10 @@ class DedupeTotalDataControllerTest {
eq(LocalDate.of(2026, 7, 31)),
eq(3L),
isNull(),
eq(8L));
eq(8L),
isNull());
verify(service, never()).writeMonthlyZipExport(
any(OutputStream.class), any(), any(), any(), any(), any(), any());
any(OutputStream.class), any(), any(), any(), any(), any(), any(), any());
verifyNoInteractions(permissionMenuService);
}
@@ -98,9 +107,11 @@ class DedupeTotalDataControllerTest {
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService);
service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L);
operator.setRole("super_admin");
@@ -113,6 +124,7 @@ class DedupeTotalDataControllerTest {
LocalDate.of(2026, 8, 2),
3L,
null,
null,
request);
assertEquals(MediaType.parseMediaType(
@@ -130,9 +142,10 @@ class DedupeTotalDataControllerTest {
eq(LocalDate.of(2026, 8, 2)),
eq(3L),
isNull(),
eq(8L));
eq(8L),
isNull());
verify(service, never()).writeMonthlyZipExport(
any(OutputStream.class), any(), any(), any(), any(), any(), any());
any(OutputStream.class), any(), any(), any(), any(), any(), any(), any());
}
@Test
@@ -140,9 +153,11 @@ class DedupeTotalDataControllerTest {
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService);
service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L);
operator.setRole("super_admin");
@@ -159,7 +174,8 @@ class DedupeTotalDataControllerTest {
eq(LocalDate.of(2026, 8, 2)),
eq(3L),
isNull(),
eq(8L));
eq(8L),
isNull());
ResponseEntity<StreamingResponseBody> response = controller.export(
"member",
@@ -167,6 +183,7 @@ class DedupeTotalDataControllerTest {
LocalDate.of(2026, 8, 2),
3L,
null,
null,
request);
assertEquals(MediaType.parseMediaType("application/zip"), response.getHeaders().getContentType());
@@ -184,8 +201,9 @@ class DedupeTotalDataControllerTest {
eq(LocalDate.of(2026, 8, 2)),
eq(3L),
isNull(),
eq(8L));
verify(service, never()).writeExport(any(OutputStream.class), any(), any(), any(), any(), any(), any());
eq(8L),
isNull());
verify(service, never()).writeExport(any(OutputStream.class), any(), any(), any(), any(), any(), any(), any());
}
@Test
@@ -193,9 +211,11 @@ class DedupeTotalDataControllerTest {
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService);
service, authSupport, permissionMenuService, dataReadScope);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
BusinessException exception = assertThrows(BusinessException.class, () -> controller.export(
"member",
@@ -203,9 +223,62 @@ class DedupeTotalDataControllerTest {
LocalDate.of(2026, 7, 15),
3L,
null,
null,
request));
assertEquals(400, exception.getCode());
verifyNoInteractions(service, authSupport, permissionMenuService);
}
@Test
void companyTabNarrowsSuperAdminToListOfMemberAccounts() {
// 超管点公司 tab ⇒ 成员集必须一路传到 service 的最后一个实参。
// 这一记盯的是"参数收了、readScope 也调了、结果却喂了 null"那种假接线(tab 恒不动的现网形状)。
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(8L);
operator.setRole("super_admin");
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readScope(operator, 2L)).thenReturn(ReadScope.users(List.of(11L, 12L)));
controller.page(1L, 15L, null, "member", null, null, null, null, null, 2L, request);
verify(service).page(eq(1L), eq(15L), isNull(), eq("member"),
isNull(), isNull(), isNull(), isNull(), isNull(), eq(8L), eq(List.of(11L, 12L)));
}
@Test
void nonSuperAdminStaysUnfilteredEvenWhenCompanyTabIsSent() {
// 非超管:刻意<b>不</b>按公司收窄。他的可见集里含"靠分组权限可见"的行,
// 叠一层账号 IN 会把那批行静默删掉(口径同 ShopManageController)。
// 这条是反向钉:哪天有人给非超管也加上成员集,这里必须红。
DedupeTotalDataService service = mock(DedupeTotalDataService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
HttpServletRequest request = mock(HttpServletRequest.class);
DedupeTotalDataController controller = new DedupeTotalDataController(
service, authSupport, permissionMenuService, dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(9L);
operator.setRole("admin");
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("admin");
PermissionMenuItemVo granted = new PermissionMenuItemVo();
granted.setColumnKey("admin_dedupe_total_data");
when(permissionMenuService.getUserColumnPermissions(9L, "admin")).thenReturn(List.of(granted));
controller.page(1L, 15L, null, null, null, null, null, null, null, 2L, request);
verify(service).page(eq(1L), eq(15L), isNull(), isNull(),
isNull(), isNull(), isNull(), isNull(), isNull(), eq(9L), isNull());
verify(dataReadScope, never()).readScope(any(), any());
}
}
@@ -652,7 +652,7 @@ class DedupeTotalDataServiceTest {
rows.add(second);
when(dedupeTotalDataMapper.selectList(any())).thenReturn(rows);
DedupeTotalDataPageVo vo = service.page(3, 15, "", "", null, null, null, null, 1000L, 1L);
DedupeTotalDataPageVo vo = service.page(3, 15, "", "", null, null, null, null, 1000L, 1L, null);
ArgumentCaptor<LambdaQueryWrapper<DedupeTotalDataEntity>> queryCaptor =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
@@ -36,6 +36,8 @@ class InvalidAsinDataControllerTest {
private AdminAuthSupport adminAuthSupport;
@Mock
private PermissionMenuService permissionMenuService;
@Mock
private com.nanri.aiimage.common.service.DataReadScope dataReadScope;
@InjectMocks
private InvalidAsinDataController controller;
@@ -58,12 +60,13 @@ class InvalidAsinDataControllerTest {
when(adminAuthSupport.currentRole(operator)).thenReturn(null);
when(permissionMenuService.getUserColumnPermissions(7L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false, null))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
controller.page(1L, 15L, "", "", "", 3L, request);
controller.page(1L, 15L, "", "", "", 3L, null, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false, null);
}
@Test
@@ -73,7 +76,7 @@ class InvalidAsinDataControllerTest {
request.addParameter("superAdmin", "true");
when(adminAuthSupport.requireUser(request)).thenThrow(new BusinessException(401, "未登录"));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, request));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, null, request));
verifyNoInteractions(invalidAsinDataService);
verify(permissionMenuService, never()).requireUserOperator(any());
@@ -86,13 +89,50 @@ class InvalidAsinDataControllerTest {
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, 2L))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, 2L)).thenReturn(2L);
controller.page(1L, 15L, "", "", "", 3L, 2L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, 2L);
verify(permissionMenuService, never()).getUserColumnPermissions(eq(1L), eq("admin"));
}
@Test
void superAdminWithoutCompanyTabStaysUnfiltered() {
// 反向钉:tab 没传公司(companyId=null)⇒ 交给 service 的筛值必须是 null(= 不筛)。
// 哪天有人把它硬写成某个默认公司,全量视图会静默变成一家的视图。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, request);
controller.page(1L, 15L, "", "", "", 3L, null, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true);
verify(permissionMenuService, never()).getUserColumnPermissions(eq(1L), eq("admin"));
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, null);
}
@Test
void forgedCompanyTabForNonSuperAdminIsNarrowedToItsOwnCompany() {
// 非超管传别人的公司 id:出口给的是 null(不筛)而不是那家 —— 这页的隔离靠分组权限,
// 叠公司会把「靠分组可见」的行整批删掉。钉住"传什么都不算"的现网口径。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(9L, "admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
when(permissionMenuService.getUserColumnPermissions(9L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(dataReadScope.readCompanyId(operator, 5L)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 9L, false, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, 5L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 9L, false, null);
}
private AdminUserEntity user(Long id, String role) {
@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
@@ -39,14 +40,21 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class InvalidAsinDataServiceTest {
/** 操作者 7L 所属公司。故意取 2 不取 1:DEFAULT 1 那家也能通过"非空"这一断言,取 2 才钉得住"真从会话来"。 */
private static final Long OPERATOR_COMPANY_ID = 2L;
@Mock
private InvalidAsinDataMapper invalidAsinDataMapper;
@Mock
private ShopManageGroupService shopManageGroupService;
/** 归属从操作者会话推导(create 里那唯一一处 requireCompanyId):不 mock 就是构造注入不到、整个 service 空指针。 */
@Mock
private CompanyScopeSupport companyScopeSupport;
@InjectMocks
private InvalidAsinDataService service;
@Test
@SuppressWarnings({"rawtypes", "unchecked"})
void createManualRecordUsesAccessibleGroup() {
InvalidAsinDataCreateRequest request = new InvalidAsinDataCreateRequest();
request.setDataValue("B012345678");
@@ -55,6 +63,7 @@ class InvalidAsinDataServiceTest {
ShopManageGroupEntity group = group(9L, "group-a");
InvalidAsinDataEntity saved = data(91L, "MANUAL", 9L);
when(companyScopeSupport.requireCompanyId(7L)).thenReturn(OPERATOR_COMPANY_ID);
when(shopManageGroupService.listAccessibleGroupIds(7L, false)).thenReturn(Set.of(12L, 9L));
when(shopManageGroupService.getAccessibleById(9L, 7L, false)).thenReturn(group);
when(invalidAsinDataMapper.selectOne(any())).thenReturn(null);
@@ -74,6 +83,21 @@ class InvalidAsinDataServiceTest {
assertEquals("MANUAL", captor.getValue().getRecordSource());
assertEquals("group-a", item.getGroupName());
assertEquals("MANUAL", item.getRecordSource());
// 写侧归属:MANUAL 行的 company_id 必须真从操作者会话推导。V146 已摘掉该列的 DEFAULT 1,
// 没人推导就是 NULL —— 而 NULL 行在 readCompanyId 谓词下对所有公司 tab 都不可见(静默删除),
// 比"归属错一家"更难发现。
assertEquals(OPERATOR_COMPANY_ID, captor.getValue().getCompanyId());
assertEquals(7L, captor.getValue().getUploaderUserId());
// 重复预检必须与 V145 放宽后的唯一键 (company_id, data_value, brand) 同宽:少公司这一维,
// 第 2 家永远无法新增第 1 家已有的品牌(跨公司误报「ASIN 已存在」)。
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> unique =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectOne(unique.capture());
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
InvalidAsinDataEntity.class);
assertTrue(unique.getValue().getSqlSegment().contains("company_id"));
assertTrue(unique.getValue().getParamNameValuePairs().containsValue(OPERATOR_COMPANY_ID));
}
@Test
@@ -85,7 +109,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(manual));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of(9L, "group-a"));
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false, null);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -109,7 +133,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(automatic, orphan));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of());
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true, null);
assertEquals(2, page.getItems().size());
assertEquals("AUTO", page.getItems().getFirst().getRecordSource());
@@ -123,7 +147,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "", "", 9L, 1L, true);
service.page(1, 15, "", "", "", 9L, 1L, true, null);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -140,7 +164,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "B01", "acme", null, 1L, true);
service.page(1, 15, "", "B01", "acme", null, 1L, true, null);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -0,0 +1,125 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.service.ProductCategoryService;
import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「商品类目」controller 的正门接线(护栏 G2 断言 A 要求这些调用内联在 handler 块里,
* 本文件钉的是内联之后的<b>语义</b>:tab 的值确实进了出口、出口的结果确实交给了 service)。
*
* <p>G2 只看形状(有没有调、结果有没有被当实参用),看不见"把 service 那侧的实参改成 null"
* 这一记 —— 那一记由本文件的 {@code verify(service).list("面霜", 2L)} 负责。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryControllerCompanyScopeTest {
private static final Long OPERATOR_ID = 1L;
private static final Long COMPANY_ID = 2L;
@Mock
private ProductCategoryService productCategoryService;
@Mock
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
private ProductCategoryController controller() {
return new ProductCategoryController(productCategoryService, adminAuthSupport, dataReadScope);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyId,出口给什么 service 就用什么")
void listPassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyId(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().list(request, "面霜", COMPANY_ID);
verify(dataReadScope).readCompanyId(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(productCategoryService).list("面霜", COMPANY_ID);
}
@Test
@DisplayName("列表:非超管由出口判成\"不筛\",controller 不许自己补一个公司 id 进去")
void listUsesTheDorsVerdictForNonSuperAdmin() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyId(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().list(request, "面霜", COMPANY_ID);
verify(productCategoryService).list("面霜", null);
}
@Test
@DisplayName("children / search / export 三支同样走出口,漏一支就是那一处的 tab 仍是装饰")
void everyReadEndpointGoesThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyId(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
// export 的返回要真喂给 ResponseEntity.contentLength(bytes.length):mock 给 null 会 NPE 在断言之前的装配里。
when(productCategoryService.export("面霜", COMPANY_ID)).thenReturn(new byte[0]);
ProductCategoryController controller = controller();
controller.children(request, 10L, 1L, 20L, COMPANY_ID);
controller.search(request, "面霜", 1L, 20L, COMPANY_ID);
controller.export(request, "面霜", COMPANY_ID);
verify(productCategoryService).children(10L, 1L, 20L, COMPANY_ID);
verify(productCategoryService).search("面霜", 1L, 20L, COMPANY_ID);
verify(productCategoryService).export("面霜", COMPANY_ID);
verify(dataReadScope, times(3))
.readCompanyId(any(AdminUserEntity.class), eq(COMPANY_ID));
}
/** 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,controller 也不读 tab。 */
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("面霜套装");
body.setParentId(10L);
controller().create(request, body);
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(productCategoryService).create(eq(body), operatorId.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
}
private MockHttpServletRequest login() {
MockHttpServletRequest request = new MockHttpServletRequest();
request.addHeader("X-Internal-Token", "irrelevant-here");
return request;
}
private AdminUserEntity user() {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setRole("super_admin");
return user;
}
}
@@ -0,0 +1,310 @@
package com.nanri.aiimage.modules.productcategory.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity;
import com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryListVo;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 「商品类目」按公司视图的那几条不变量(V147 / 需求 2026-10-05「切 tab 数据还一样」)。
*
* <p>这一页的归属是<b>物化列</b>而不是账号集合,所以判据形状与 readScope 那一族不同:
* 可见集 = {@code company_id IN (0, X)},其中 0 是内置节点的哨兵。两支最容易静默坏掉的形状
* 都由本文件钉住:① 哨兵那半不许丢(丢了第 2 家是一棵空树,连自建根都挂不上);
* ② 给 LLM 用的那棵全局树不许被顺手加上公司谓词(加了货源归类的候选就按公司分叉)。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryCompanyScopeTest {
private static final long BUILTIN = 0L;
private static final Long OPERATOR_ID = 7L;
/** 故意取 2:DEFAULT 1 那一家通不过"值等于会话公司"这种断言,取 2 才钉得住"真从会话推导"。 */
private static final Long COMPANY_ID = 2L;
private static final Long BUILTIN_PARENT_ID = 10L;
@Mock
private ProductCategoryMapper productCategoryMapper;
@Mock
private CompanyScopeSupport companyScopeSupport;
private ProductCategoryService service;
@BeforeAll
static void initTableInfo() {
// Lambda 条件要解析列名,没有 TableInfo 时 getSqlSegment() 里根本不会出现 company_id。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ProductCategoryEntity.class);
}
@BeforeEach
void setUp() {
service = new ProductCategoryService(productCategoryMapper, companyScopeSupport);
}
@Test
@DisplayName("公司视图带哨兵 0:可见集是 (0, 该公司),只查自建会让第 2 家连自建根都挂不上")
void companyViewIncludesTheBuiltinSentinel() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
service.list(null, COMPANY_ID);
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
assertTrue(query.getSqlSegment().contains("company_id IN"), query.getSqlSegment());
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue(BUILTIN), "哨兵 0 必须留在可见集里:" + params);
assertTrue(params.containsValue(COMPANY_ID), "公司谓词丢了 tab 就是装饰:" + params);
}
/**
* 反向钉(新维度不许顺手回流到别的通路):{@link ProductCategoryService#list()} 唯一的消费者是
* 货源/外观的类目归类({@code SimilarAsinLlmService} 读的是全局树)。给它加公司谓词会让同一个
* "面霜"有 N 个 category_key、LLM 分类结果按公司分叉,那是成本不只是口径。
*/
@Test
@DisplayName("给 LLM 用的全局树不带公司谓词:按公司切会让归类结果按公司分叉")
void globalTreeForTheLlmConsumerStaysUnscoped() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
service.list();
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
String sql = query.getSqlSegment();
// 两条一起才算非恒真:只看"不含 company_id"时,一条空 segment(列名解析不到、wrapper 根本没拼)
// 也会通过,那条断言就变成恒绿。先证明 wrapper 真渲染了东西,再证明它一个实参都没带。
assertTrue(sql.contains("ORDER BY"), "wrapper 根本没渲染,下面的否证是空话:" + sql);
assertFalse(sql.contains("company_id"),
"无参 list() 被接上了公司谓词 —— 货源归类的候选树随之按公司分叉:" + sql);
assertTrue(query.getParamNameValuePairs().isEmpty(),
"全局树带出了实参(说明有谓词被塞进来):" + query.getParamNameValuePairs());
}
@Test
@DisplayName("搜索的公司谓词必须在整条 OR 之外:AND 结合更紧会让前两列命中不受公司约束")
void searchKeepsTheOrGroupWrappedBeforeTheCompanyPredicate() {
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of());
service.search("面霜", 1, 20, COMPANY_ID);
List<LambdaQueryWrapper<ProductCategoryEntity>> queries = capturedSearchWrappers();
for (LambdaQueryWrapper<ProductCategoryEntity> query : queries) {
String sql = query.getSqlSegment();
assertTrue(sql.contains(") AND company_id IN"),
"OR 组没有被包起来再 AND 公司(前两个 like 命中的行会跨公司):" + sql);
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue("%面霜%"), sql);
assertTrue(params.containsValue(COMPANY_ID), sql);
}
assertEquals(2, queries.size(), "count 与 list 两条查询都要带公司谓词");
}
@Test
@DisplayName("分页 children 的 count 与 list 两条查询同源,且子类目数徽章也按可见集聚合")
void childrenScopeCountListAndChildBadgeTogether() {
when(productCategoryMapper.selectCount(any())).thenReturn(1L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID)));
when(productCategoryMapper.selectMaps(any())).thenReturn(List.of());
service.children(BUILTIN_PARENT_ID, 1, 20, COMPANY_ID);
ArgumentCaptor<Wrapper<ProductCategoryEntity>> countCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(countCaptor.capture());
assertTrue(countCaptor.getValue().getSqlSegment().contains("company_id IN"));
LambdaQueryWrapper<ProductCategoryEntity> pageQuery = capturedListWrapper();
assertTrue(pageQuery.getSqlSegment().contains("company_id IN"));
assertTrue(pageQuery.getSqlSegment().contains("parent_id"));
// 「子类目数」徽章走全表聚合:不加公司谓词就会把别家子节点数算进来,数字与点开看到的树不一致。
ArgumentCaptor<Wrapper<ProductCategoryEntity>> badgeCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectMaps(badgeCaptor.capture());
assertTrue(badgeCaptor.getValue().getSqlSegment().contains("company_id IN"),
badgeCaptor.getValue().getSqlSegment());
}
@Test
@DisplayName("新增:归属从操作者会话推导,不靠 V147 那个临时 DEFAULT 1")
void createStampsTheOperatorsCompany() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(500L);
return 1;
});
when(productCategoryMapper.selectById(500L)).thenReturn(row(500L, BUILTIN_PARENT_ID, "面霜套装", COMPANY_ID));
service.create(saveRequest("面霜套装", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertFalse(Boolean.TRUE.equals(inserted.getValue().getIsBuiltin()));
assertTrue(inserted.getValue().getCategoryKey().startsWith("custom_"));
// 同级重名预检的范围 = 可见集(自建 + 内置):漏了它,第 2 家能在内置"护肤品"下再建一个同名"面霜",
// 页面一排两个而货源归类不知落到哪个;反过来跨家同名必须放行(那正是 uk_company_category_key 要解的)。
// 第 0 条=同级重名预检;findItem 里那条「子类目数」聚合不在本断言射程内(它按 parent_id 数,
// 不带公司谓词——那是详情返回值的计数,与列表可见集两回事)。
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(BUILTIN), "重名检查漏了内置那一半:" + params);
assertTrue(params.containsValue(COMPANY_ID), "重名检查漏了这一家自己:" + params);
}
@Test
@DisplayName("新增:父级挂在别家公司名下要 403,不能静默把行挪出可见集")
void createRejectsParentOwnedByAnotherCompany() {
Long foreignParentId = 77L;
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(foreignParentId))
.thenReturn(row(foreignParentId, null, "别家的根", 3L));
BusinessException exception = assertThrows(BusinessException.class,
() -> service.create(saveRequest("面霜套装", foreignParentId), OPERATOR_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).insert(any(ProductCategoryEntity.class));
}
@Test
@DisplayName("新增:内置节点(哨兵 0)当父级放行,否则第 2 家永远建不出子级")
void createAcceptsTheSharedBuiltinParent() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(501L);
return 1;
});
when(productCategoryMapper.selectById(501L)).thenReturn(row(501L, BUILTIN_PARENT_ID, "自建子级", COMPANY_ID));
service.create(saveRequest("自建子级", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertEquals(BUILTIN_PARENT_ID, inserted.getValue().getParentId());
}
@Test
@DisplayName("更新时按行自己的归属判可见集:内置行归 0、自建行归那一家,都不取 tab")
void updateUsesTheRowsOwnCompanyNotTheTab() {
ProductCategoryEntity custom = row(300L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID);
when(productCategoryMapper.selectById(300L)).thenReturn(custom);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
service.update(300L, saveRequest("面霜改名", BUILTIN_PARENT_ID));
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(COMPANY_ID), params.toString());
assertFalse(params.containsValue(3L),
"把行挪到可见集外的节点下面会让它从原本看得见它的 tab 里消失:" + params);
}
private ProductCategorySaveRequest saveRequest(String name, Long parentId) {
ProductCategorySaveRequest request = new ProductCategorySaveRequest();
request.setName(name);
request.setParentId(parentId);
return request;
}
private static ProductCategoryEntity row(Long id, Long parentId, String name, Long companyId) {
ProductCategoryEntity entity = new ProductCategoryEntity();
entity.setId(id);
entity.setParentId(parentId);
entity.setName(name);
entity.setCategoryKey("cat_" + id);
entity.setSortOrder(100);
entity.setCompanyId(companyId);
entity.setIsBuiltin(companyId == BUILTIN);
return entity;
}
@SuppressWarnings("unchecked")
private LambdaQueryWrapper<ProductCategoryEntity> capturedListWrapper() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(captor.capture());
return (LambdaQueryWrapper<ProductCategoryEntity>) captor.getValue();
}
/** create/update 之后 selectCount 至少两条(重名预检 + 详情里的子类目数),按调用顺序取。 */
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> countWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(captor.capture());
return captor.getAllValues().stream()
.map(wrapper -> (LambdaQueryWrapper<ProductCategoryEntity>) wrapper)
.toList();
}
/**
* MyBatis-Plus 的实参表是<b>惰性</b>填充的:不先求值 {@code getSqlSegment()},
* {@code getParamNameValuePairs()} 是个空 map——那会让"含 0"与"不含 3"两个方向的断言同时恒真。
* 读参数一律走这里,别在测试里各自记得。
*/
private static Map<String, Object> paramsOf(LambdaQueryWrapper<ProductCategoryEntity> query) {
query.getSqlSegment();
return query.getParamNameValuePairs();
}
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> capturedSearchWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> count = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(count.capture());
ArgumentCaptor<Wrapper<ProductCategoryEntity>> list = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(list.capture());
return List.of((LambdaQueryWrapper<ProductCategoryEntity>) count.getValue(),
(LambdaQueryWrapper<ProductCategoryEntity>) list.getValue());
}
@Test
@DisplayName("空关键字的直接搜索返回空页,不探库")
void blankKeywordSearchShortCircuits() {
ProductCategoryListVo vo = service.search(" ", 1, 20, COMPANY_ID);
assertEquals(0L, vo.getTotal());
verify(productCategoryMapper, never()).selectCount(any());
verify(productCategoryMapper, never()).selectMaps(any());
// CompanyScopeSupport 有 (Long) 与 (AdminUserEntity) 两形:any() 会撞上重载歧义(javac 直接拒绝)。
verify(companyScopeSupport, never()).requireCompanyId(anyLong());
}
}
@@ -0,0 +1,86 @@
package com.nanri.aiimage.modules.shopdatacrawl.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.shopdatacrawl.mapper.ShopDataCrawlAdminTasksMapper;
import com.nanri.aiimage.modules.shopdatacrawl.mapper.ShopDataCrawlItemMapper;
import com.nanri.aiimage.modules.shopdatacrawl.spi.DuplicateCheckRefreshPort;
import com.nanri.aiimage.modules.shopdatacrawl.spi.ManagedShopNamesPort;
import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* 店铺数据记录(D 类第二页)的公司 tab:可见店铺集的三条出口必须各不相同。
*
* <p>这一页的单位是「店铺」而不是行,所以公司条件落在店铺名集合上(与撞款页同一个 normalize);
* 两处最容易写错且都不报错的形状是:超管没切 tab 时给出空集合(整页突然空),
* 以及空成员集时给出 null(在这套语义里是"全量",等于把第 1 家的数据交给第 2 家)。</p>
*/
class ShopDataCrawlAdminTasksCompanyScopeTest {
private ManagedShopNamesPort port;
private ShopDataCrawlAdminTasksService service;
@BeforeEach
void setUp() {
port = mock(ManagedShopNamesPort.class);
service = new ShopDataCrawlAdminTasksService(
mock(ShopDataCrawlAdminTasksMapper.class), port,
mock(ShopDataCrawlItemMapper.class),
mock(FileResultMapper.class),
mock(ShopDataCrawlDailyFileService.class),
mock(OssStorageService.class),
mock(ShopDataCrawlTaskService.class),
mock(DuplicateCheckRefreshPort.class),
new ObjectMapper());
}
@Test
@DisplayName("超管没切公司 tab=null(全量),逐字等于接线前")
void superAdminWithoutCompanySeesEverything() {
assertThat(service.resolveVisibleShopKeys(1L, true, null)).isNull();
verify(port, never()).selectManagedShopNames(any());
verify(port, never()).selectShopNamesOwnedByMembers(anyList());
}
@Test
@DisplayName("超管切到某家公司=按店铺负责人取那家的店铺名,小写去空格")
void superAdminOnCompanyTabUsesShopOwnerRuler() {
when(port.selectShopNamesOwnedByMembers(List.of(7L, 8L)))
.thenReturn(List.of(" ShopA ", "shopa", "ShopB"));
assertThat(service.resolveVisibleShopKeys(1L, true, List.of(7L, 8L)))
.containsExactly("shopa", "shopb");
}
@Test
@DisplayName("空成员集=空列表而不是 null:这家没有店铺,不许退化成全量")
void emptyMemberSetIsNoShopsNotEverything() {
when(port.selectShopNamesOwnedByMembers(List.of())).thenReturn(List.of());
List<String> keys = service.resolveVisibleShopKeys(1L, true, List.of());
assertThat(keys).isNotNull();
assertThat(keys).isEmpty();
}
@Test
@DisplayName("非超管仍按分组关系推,公司成员集不参与(tab 不是安全边界)")
void nonSuperKeepsGroupBasedView() {
when(port.selectManagedShopNames(9L)).thenReturn(List.of("ShopC"));
assertThat(service.resolveVisibleShopKeys(9L, false, List.of(7L))).containsExactly("shopc");
verify(port, never()).selectShopNamesOwnedByMembers(anyList());
}
}
@@ -0,0 +1,180 @@
package com.nanri.aiimage.modules.shopduplicatecheck.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.nanri.aiimage.modules.shopduplicatecheck.TestFixtures;
import com.nanri.aiimage.modules.shopduplicatecheck.mapper.ShopDuplicateCheckSourceMapper;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.builder.annotation.MapperAnnotationBuilder;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* 店铺撞款监控的公司 tab(D 类第一页)。
*
* <p>要钉住的不是"筛了没筛",而是三件各自会静默出错的事:</p>
* <ol>
* <li><b>公司这一支必须换尺子</b>,从"主管分组关系"换到"店铺行自己的负责人"
* ({@code biz_shop_manage.created_by_id})。留在分组尺子上,第 1 家 tab 会把 12 个分组
* 里只挂 user_id 的那 2 个也算进来,与已上线的「店铺管理」页对不上——同一个 tab 两家页面前后
* 给出不同的店铺集合,比空页更容易被当成 bug 报。</li>
* <li><b>{@code null} 在这一页是"全量"而不是"没筛出东西"</b>。空成员集若退化成 null,
* "切到一家还没有店铺的账号公司"= 看到全部数据(越界方向恰好是少隔离那一侧)。</li>
* <li><b>非超管不许跟着 tab 改口径</b>(spec §4:tab 是视图开关,不是安全边界)。</li>
* </ol>
*/
class ShopDataDuplicateCheckCompanyScopeTest {
private ShopDuplicateCheckSourceMapper mapper;
private ShopDataDuplicateCheckQueryService service;
private ShopDataDuplicateCheckScanService.DuplicateScanView view;
@BeforeEach
void setUp() {
mapper = mock(ShopDuplicateCheckSourceMapper.class);
service = new ShopDataDuplicateCheckQueryService(mapper);
view = TestFixtures.view();
}
@Test
@DisplayName("超管没切公司 tab=全量(null),与接线前逐字一致")
void superAdminWithoutCompanyTabSeesEverything() {
assertThat(service.resolveVisibleShopKeys(1L, true, null)).isNull();
verify(mapper, never()).selectManagedShopNames(any());
verify(mapper, never()).selectShopNamesOwnedBy(anyList());
}
@Test
@DisplayName("超管切到某家公司=只按店铺负责人推,且不再碰分组尺子")
void companyTabSwitchesToTheShopOwnerRuler() {
when(mapper.selectShopNamesOwnedBy(List.of(7L, 8L)))
.thenReturn(Arrays.asList(" ShopA ", "ShopB", " ", null));
when(mapper.selectManagedShopNames(1L)).thenReturn(List.of("ShopZ"));
Set<String> keys = service.resolveVisibleShopKeys(1L, true, List.of(7L, 8L));
// trim + 小写 + 丢空:与主管那一支同一个 normalize,否则交集会因为大小写漏掉整店
assertThat(keys).containsExactly("shopa", "shopb");
verify(mapper, never()).selectManagedShopNames(any());
}
@Test
@DisplayName("空成员集=这家一家店铺都没有:必须是空集合,绝不能是 null(null=全量)")
void emptyMemberSetMeansNoShopsNotEverything() {
Set<String> keys = service.resolveVisibleShopKeys(1L, true, List.of());
assertThat(keys).isNotNull();
assertThat(keys).isEmpty();
// 空列表真喂进 mapper 会产出非法的 IN ()(见 mapperScript 那两支),所以必须在这里就挡住
verify(mapper, never()).selectShopNamesOwnedBy(anyList());
}
@Test
@DisplayName("非超管的可见范围只由分组关系决定,传进来的公司成员集不参与")
void nonSuperKeepsTheGroupBasedView() {
when(mapper.selectManagedShopNames(9L)).thenReturn(List.of("ShopC"));
Set<String> keys = service.resolveVisibleShopKeys(9L, false, List.of(7L));
assertThat(keys).containsExactly("shopc");
verify(mapper, never()).selectShopNamesOwnedBy(anyList());
}
@Test
@DisplayName("分组筛选叠在公司集之后:同组里别家公司的店不许被放回来")
void groupFilterNeverWidensTheCompanySet() {
// 夹具里 GroupA 含 ShopA + ShopB。公司集只给 shopa ⇒ 选 GroupA 也只能看到 shopa。
assertThat(service.withGroupFilter(Set.of("shopa"), view, "GroupA")).containsExactly("shopa");
assertThat(service.withGroupFilter(Set.of(), view, "GroupA")).isEmpty();
// 反向对照:不存在的分组名给出空集——证明这条链真在求交,而不是原样把入参退回来
assertThat(service.withGroupFilter(Set.of("shopa"), view, "NoSuchGroup")).isEmpty();
}
// ------------------------------------------------------------------ 端口
@Test
@DisplayName("端口(店铺数据记录用的那一条)对空/ null 成员集直接给空列表,不落 SQL")
void portGuardsEmptyMemberSet() {
ManagedShopNamesPortAdapter adapter = new ManagedShopNamesPortAdapter(mapper);
assertThat(adapter.selectShopNamesOwnedByMembers(List.of())).isEmpty();
assertThat(adapter.selectShopNamesOwnedByMembers(null)).isEmpty();
verify(mapper, never()).selectShopNamesOwnedBy(anyList());
when(mapper.selectShopNamesOwnedBy(List.of(3L))).thenReturn(List.of("ShopD"));
assertThat(adapter.selectShopNamesOwnedByMembers(List.of(3L))).containsExactly("ShopD");
}
// ------------------------------------------------------- 注解 SQL 真的能解析
/**
* {@code @Select} 里的 {@code <script>} + {@code foreach} 只有运行期才会报错,mock 掉的 mapper
* 一条也测不到。这里把注解原文交给 MyBatis 自己的动态 SQL 引擎跑一遍——
* 破坏点包括:{@code <>} 忘了转义(XML 解析当场抛)、foreach 的 collection 名写错(参数取不到)、
* #{mid} 被写成 ${mid}(占位符数对不上=SQL 注入面)。
*/
@Test
@DisplayName("selectShopNamesOwnedBy 的动态 SQL:两个成员=两个占位符,且字面量仍是参数绑定")
void mapperScriptBindsEveryMemberIdAsParameter() throws Exception {
String sql = boundSqlFor(List.of(7L, 8L)).getSql();
assertThat(sql)
.contains("biz_shop_manage")
.contains("created_by_id IN")
.doesNotContain("<script>")
.doesNotContain("foreach")
.doesNotContain("$");
// 占位符个数=成员个数:写成 ${mid} 会在这里露出来(少一个 ? 而串里多出字面值)
assertThat(sql.chars().filter(c -> c == '?').count()).isEqualTo(2);
assertThat(boundSqlFor(List.of(7L, 8L)).getParameterMappings()).hasSize(2);
}
@Test
@DisplayName("同一支 SQL 对空成员集产出残缺语句(IN 后面什么都没有)——端口那支 return List.of() 是承重的")
void mapperScriptCannotSurviveEmptyMemberSet() throws Exception {
String sql = boundSqlFor(List.of()).getSql();
// 实测这一版 MyBatis 的 foreach 在零元素时连括号都不给,语句就停在 "... created_by_id IN" 上:
// 1064 语法错。所以"空成员=这家没有店铺"必须在 Java 侧兜住,不能把空列表喂进 SQL。
assertThat(sql.trim()).endsWith("created_by_id IN");
assertThat(sql.chars().filter(c -> c == '?').count()).isZero();
}
@Test
@DisplayName("转义后的 <> 在生成的 SQL 里必须是真比较符,不能被吃掉或留成实体")
void mapperScriptKeepsTheNotEmptyPredicate() throws Exception {
String sql = boundSqlFor(List.of(7L)).getSql();
assertThat(sql).contains("<>");
assertThat(sql).doesNotContain("&lt;");
}
private static BoundSql boundSqlFor(List<Long> memberIds) throws Exception {
Method method = ShopDuplicateCheckSourceMapper.class
.getMethod("selectShopNamesOwnedBy", List.class);
String script = String.join(" ", method.getAnnotation(Select.class).value());
Configuration configuration = new MybatisConfiguration();
// 走注解构建器的同一条路径:把这条语句注册进 configuration,再向它要 BoundSql
new MapperAnnotationBuilder(configuration, ShopDuplicateCheckSourceMapper.class)
.parse();
MappedStatement statement = configuration.getMappedStatement(
ShopDuplicateCheckSourceMapper.class.getName() + ".selectShopNamesOwnedBy");
return statement.getBoundSql(Map.of("memberIds", memberIds));
}
}
@@ -230,7 +230,7 @@ class SkipPriceAsinServiceTest {
when(skipPriceAsinMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, null, null, null, null,
new BigDecimal("10.00"), new BigDecimal("20.00"), null, true);
new BigDecimal("10.00"), new BigDecimal("20.00"), null, true, null);
ArgumentCaptor<Wrapper<SkipPriceAsinEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(skipPriceAsinMapper).selectCount(captor.capture());
@@ -252,7 +252,7 @@ class SkipPriceAsinServiceTest {
when(skipPriceAsinMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, null, null, null, "DE",
new BigDecimal("15.00"), null, null, true);
new BigDecimal("15.00"), null, null, true, null);
ArgumentCaptor<Wrapper<SkipPriceAsinEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(skipPriceAsinMapper).selectCount(captor.capture());