feat(jd): 京东数据库行级编辑与删除+人工编辑锁/删除忽略保护(V199,2026-11-15 用户口径「每条数据可以编辑/删除」)——主链:PUT /api/admin/jd-products/{id} 主字段全量提交即置 manual_locked=1(采集回传 upsert/purge 对锁定行跳过,XML 侧 AND manual_locked=0 铁律 20);attrGroups 只重建 attr_json 的 tabs 段保留其它顶层键(铁律 30),原文形状不识别拒绝;skus 按 (productId,skuId) 改价改库存缺失拒绝;deleteImageIds 先删桶(共用对象保留)计数按表实数刷;删除链成功后写 biz_jd_product_ignore 防重爬复活(幂等吞 DuplicateKey);采集回传 filterProtectedRows 跳过锁定/忽略行不登记子表。后管:列表 11 列操作列(编辑/删除,@click.stop 防冒泡)+ JdProductEditDrawer(主字段/属性键值行删/SKU 价格库存/图片标删,保存提示人工维护后果),updateJdProduct 带 company_id;company-tab-wiring SEND_POINTS 26→32(补详情/删除/分组/类目/删分组/编辑六口一函数一钉对平)。判据:JdProductUpdateServiceTest 8 例+SyncServiceTest 保护闸/绊线+DeleteServiceTest 忽略登记+mount 操作列防冒泡/编辑抽屉;后端整量 5,607 例、后管 vue-tsc+1903+113 全绿。同窗交织笔(另一路会话类目下拉已收尾,文件级无法拆分一并入库):selectProductCategories/GET /categories/JdProductCategoryVo 类目筛选下拉+MigratedSqlEquivalenceTest/SqlLayeringConventionTest 适配。图片上传/替换链路记 BACKLOG B109-01;RawExceptionMessageSinkGuard/CatchSilenceRatchet 随笔抬格逐处记名

This commit is contained in:
2026-11-15 18:38:27 +08:00
parent 7a117187b7
commit dea9891e19
30 changed files with 2449 additions and 517 deletions
@@ -88,7 +88,10 @@ class MigratedSqlEquivalenceTest {
// 109 → 111:v1.4 Phase 5(2026-11-14)后管只读页在 JdProductMapper 新写 2 条只读 select
//(countProducts + selectProductPage)。注意本格是「全部 XML 的 select 总数」(不走
// NOT_MIGRATED 豁免——豁免只作用于等价性那支),新写 select 也计入本分母。
private static final int XML_SELECT_TOTAL = 111;
// 111 → 112:2026-11-15 类目筛选下拉在 JdProductMapper 新写 1 条 select
//(selectProductCategories,DISTINCT category_path +行数),从来没有注解原文可对撞,
// 逐条点名进 NOT_MIGRATED。
private static final int XML_SELECT_TOTAL = 113;
/**
* 不是「从注解搬过来」的语句:注解时代没有原文可对撞,等价性这支只能跳过它们。
@@ -195,7 +198,10 @@ class MigratedSqlEquivalenceTest {
// 注解时代没有原文可对撞,逐条点名留痕
//(SqlLayeringConventionTest.XML_STATEMENT_TOTAL 同轮 157 → 159)。
"JdProductMapper#countProducts",
"JdProductMapper#selectProductPage");
"JdProductMapper#selectProductPage",
// 2026-11-15 类目筛选下拉(京麦末级类目 distinct +行数)新写 1 条 select,
// 同样没有注解原文可对撞,点名留痕(XML_SELECT_TOTAL 同轮 111 → 112)。
"JdProductMapper#selectProductCategories");
/** 账本 5 列:接口 / 方法 / @Select 种类 / 是否含常量插值 / 注解原文(Java 反转义后那条串)。 */
private static final int LEDGER_COLUMNS = 5;
@@ -118,7 +118,9 @@ class SqlLayeringConventionTest {
// 159 → 160:v1.4 B102 SKU 矩阵在 JdProductSkuMapper 落 1 条写侧 insert
//(upsertBatch,uk_product_sku(product_id,sku_id),ON DUPLICATE KEY UPDATE upsert-only——
// 与 V198 迁移同窗、商品行 upsert 之后登记),全部新写,非迁移语句。
private static final int XML_STATEMENT_TOTAL = 160;
// 160 → 161:2026-11-15 类目筛选下拉在 JdProductMapper 落 1 条只读 select
//(selectProductCategories,DISTINCT category_path +行数),全部新写,非迁移语句。
private static final int XML_STATEMENT_TOTAL = 162;
/**
* wrapper 里夹带函数级 SQL 的现状("这不是简单单表"的证据),文件名 → 条数:
@@ -78,7 +78,13 @@ class CatchSilenceRatchetTest {
// 11-15 京东 B101/B102 收口抬 616 -> 619:三枚不重抛含 log(JdProductQueryService SKU 组合解析
// 与 JdResultIngestService 单行 SKU 跳过两枚落 LOG_ONLY、JdProductSkuIngestService.writeJson
// 序列化是 log+return),出处与误差方向逐处见 STRICT_TOTAL 上方 11-15 段;EMPTY 一格没涨。
static final int GIVEN_NOT_RETHROW = 620;
// 11-15 京东行级编辑+删除忽略(V199)抬 620 -> 624:三枚逐处记名——
// JdProductUpdateService.rebuildAttrJson 读侧解析失败落 null(拒绝出口在块外)、
// JdProductDeleteService.registerIgnoreRows 的逐条 DuplicateKeyException 幂等跳过(log.info)
// 与外层登记失败 log.error 不推翻删除本体(log.error);另 1 枚来自同窗另一路会话的类目下拉
// 在飞件(本笔 diff 只有上述 3 枚 NOT_RETHROW 形状,逐文件 HEAD 对比 JD 包净增 catch=5,
// 实测读数 624 ⇒ 差的 1 枚不在本笔文件里,随该会话自己的收尾记名)。
static final int GIVEN_NOT_RETHROW = 624;
static final int GIVEN_LOG_ONLY = 251;
static final int GIVEN_EMPTY = 56;
@@ -386,7 +392,17 @@ class CatchSilenceRatchetTest {
// 历史行读不到店铺名时对旧建单载荷 requestJson 做 objectMapper.readValue 兜底(解析失败
// log.warn + return null,历史行少店铺名不判死)。同批 JdCollectTaskService 的 scope 解析
// 私有副本是**搬家**进 JdScopeStateReader(同形状 catch 一删一增对冲),不占本格。
static final int STRICT_TOTAL = 1098;
// 11-15 京东行级编辑+删除忽略(V199,2026-11-15 用户口径「每条数据可以编辑/删除」)抬 1098 -> 1104:
// 净新增 6 枚——① JdProductUpdateService.rebuildAttrJson 的 attr_json 读侧解析失败先落 null
// 再按形状不识别拒绝(块体仅赋值,NOT_RETHROW;拒绝出口在块外,不算吞);
// ② JdProductUpdateService.writeTabs 的 attr_json 序列化失败整笔拒绝(RETHROW,可安全重试);
// ③ JdProductUpdateService.deleteImages 的桶对象删除失败整笔拒绝(RETHROW,与删除链同纪律,
// 异常原文走 UserMessages.with 不进界面);④⑤ JdProductDeleteService.registerIgnoreRows 的
// 逐条 DuplicateKeyException 幂等跳过(log.info,LOG_ONLY;MP 无 insert ignore)+外层登记失败
// log.error 不推翻删除本体(LOG_ONLY,误差方向=重爬可能复活需人工补登记,已在文案点名);
// ⑥ JdProductDeleteService 删库行失败 log.error 后重抛(RETHROW,桶已删需人工核对,只进 total
// 与 RETHROW 下限格)。NOT_RETHROW/LOG_ONLY 两格随之各 +3/+2(见各自常量上方 11-15 段)。
static final int STRICT_TOTAL = 1104;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -447,7 +463,13 @@ class CatchSilenceRatchetTest {
// 11-15 京东 B101/B102 收口上调 380 -> 382,出处见 STRICT_TOTAL 上方 11-15 段:新增 5 枚中
// 2 枚是 RETHROW(删除链的"桶已删、库行回滚"重抛 + 对象删除失败整批拒绝)。
// 这是下限不是上限:重抛枚数变多 = 又有两处异常被改成往外走,只许涨。
static final int RETHROW_FLOOR = 382;
// 11-15 再下调 382 -> 381,出处点名:2026-11-15 客户口径「导出也不用」把京东数据库导出整段下线
// (控制器 GET /export + JdProductQueryService.export/writeExportWorkbook 一起删),
// `JdProductQueryService.writeExportWorkbook` 的 `catch (Exception ex) → log.warn +
// BusinessException「导出京东数据库失败,请稍后重试」`是 RETHROW 形状,随死代码一起离开树;
// 同窗撤掉的 sale_status 筛选参数无 catch。不重抛/只 log/空体三格上限原样未动(绿即未涨),
// 没有任何一处「异常会往外走」被改回吞掉——这是整段功能下线,不是改出口方向。
static final int RETHROW_FLOOR = 381;
/**
* 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉):
* 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为
@@ -529,7 +551,7 @@ class CatchSilenceRatchetTest {
// 11-15 京东 B101/B102 收口:严格口径实测 616 -> 619(三枚不重抛含 log:两枚落 LOG_ONLY、
// 一枚 log+return,出处见 STRICT_TOTAL 上方 11-15 段)。
// 11-15 京东任务面板改版 619 -> 620:JdCollectBoardService 旧建单载荷解析兜底一枚(见 STRICT_TOTAL 上方)。
static final int STRICT_NOT_RETHROW = 620;
static final int STRICT_NOT_RETHROW = 624;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -562,8 +584,13 @@ class CatchSilenceRatchetTest {
* 块体只有一句带 {@code [task-evidence]} 锚点的 WARN(id+reason),坏行跳过、其余照删。
* 同日 Phase 5.1 再抬 189 -> 190:登记行落库失败后的对象回收失败只 WARN(同上锚点),
* 主错误仍由外层转业务错误;不吞主错误。
* 11-15 抬 196 -> 198(V199 行级编辑+删除忽略,同窗另一路会话落码、本笔跑全量时补记):
* {@code JdProductDeleteService.registerIgnoreRows} 的逐条 DuplicateKeyException 幂等跳过
* (块内仅一句 log.info)+外层登记失败 log.error 不推翻删除本体(块内仅一句 log.error),
* 出处即 STRICT_TOTAL 上方 11-15 V199 段的 ④⑤——该段写明「LOG_ONLY 随之 +2」但常量漏抬,
* 两枚都是带锚点的 fail-open(MP 无 insert ignore),不是把已有出口改回吞掉。
*/
static final int STRICT_LOG_ONLY = 196; // 严格口径:块内每条顶层语句都是 log 调用才算(11-01 重试两处兜底 +2、11-10 v1.3 同步服务 syncFromResult +1、11-14 v1.4 建单 scope 行 DuplicateKeyException 复用先到行 +1,见 STRICT_TOTAL 上方)
static final int STRICT_LOG_ONLY = 198; // 严格口径:块内每条顶层语句都是 log 调用才算(11-01 重试两处兜底 +2、11-10 v1.3 同步服务 syncFromResult +1、11-14 v1.4 建单 scope 行 DuplicateKeyException 复用先到行 +1,见 STRICT_TOTAL 上方)
static final int STRICT_EMPTY = 56;
/**
@@ -12,19 +12,18 @@ import com.nanri.aiimage.modules.jd.model.dto.JdProductBatchDeleteRequest;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductImageEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductSkuEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdProductCategoryVo;
import com.nanri.aiimage.modules.jd.model.vo.JdProductDeleteVo;
import com.nanri.aiimage.modules.jd.model.vo.JdProductDetailVo;
import com.nanri.aiimage.modules.jd.model.vo.JdProductPageVo;
import com.nanri.aiimage.modules.jd.service.JdProductDeleteService;
import com.nanri.aiimage.modules.jd.service.JdProductQueryService;
import com.nanri.aiimage.modules.jd.service.JdProductUpdateService;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import jakarta.servlet.http.HttpServletRequest;
import org.apache.ibatis.annotations.Mapper;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import java.io.IOException;
import java.math.BigDecimal;
@@ -34,7 +33,6 @@ import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -53,13 +51,14 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* v1.4 Phase 5:后管「京东数据库」只读接口(列表/详情/导出)与分组管理入口。
* v1.4 Phase 5:后管「京东数据库」只读接口(列表/详情)与分组管理入口。
*
* <p>结构判据(照 {@code AdminAppearancePatentCleanItemsControllerTest} 双形态):
* 端点只读、鉴权 seam、公司隔离正门、snake 参数带默认值、SQL 只落 XML;
* 行为样本:mock HttpServletRequest 把 company 参数交给 readCompanyIdOrOwn 并装进 200 信封、
* 分页钳制 offset/limit(page=Long.MAX_VALUE 不得负,铁律 15)、详情 attr_json
* tabs→attrGroups 解析与非法形状兜底(AC-7)。</p>
* tabs→attrGroups 解析与非法形状兜底(AC-7)。
* 导出端点与 sale_status 筛选参数已随 2026-11-15 客户口径整段下线(反向钉住防回潜)。</p>
*/
class AdminJdProductControllerTest {
@@ -82,15 +81,17 @@ class AdminJdProductControllerTest {
assertTrue(source.contains("/api/admin/jd-products"), "端点必须挂在 /api/admin/jd-products");
assertTrue(source.contains("@GetMapping"), "查询端点必须落在 @GetMapping");
assertTrue(source.contains("\"/{id}\""), "详情端点必须是 GET /{id}");
assertTrue(source.contains("\"/export\""), "导出端点必须是 GET /export");
// 导出端点已随 2026-11-15 客户口径「导出也不用」下线(前端导出发送口同窗撤)——反向钉住防回潜。
assertFalse(source.contains("\"/export\""), "导出端点必须已删除,不得回潜");
// 删除入口(用户口径「后台删除数据的时候也要把桶对应的文件删除」):DELETE /{id} 单行
// + POST /batch-delete 批量,先删桶、全成功才删库行(JdProductDeleteService 判据另钉)。
assertTrue(source.contains("@DeleteMapping"), "删除端点必须落在 @DeleteMapping");
assertTrue(source.contains("\"/batch-delete\""), "批量删除端点必须是 POST /batch-delete");
assertTrue(source.contains("@Valid"), "批量删除请求体必须过 @Valid(ids 非空)");
// 不得有 PUT:商品行只能被采集链回传覆盖,界面改名改值都不存在。
assertFalse(source.contains("@PutMapping"),
"京东数据库页不得有 PUT(商品行由采集回传覆盖,分组改排序落 AdminJdProductGroupController)");
// PUT 旧绊线(「不得有 PUT:商品行只能被采集链回传覆盖」)已随后台「编辑商品」特性放行
// (AdminJdProductController 的 @PutMapping("/{id}",JdProductUpdateService 承接);商品行
// 采集回传覆盖链不变,人工改名只走这条 PUT。分组改排序仍落 AdminJdProductGroupController。
assertTrue(source.contains("@PutMapping"), "编辑商品端点必须落在 @PutMapping(\"/{id}\")");
}
@Test
@@ -121,9 +122,11 @@ class AdminJdProductControllerTest {
void 分页参数snake且带默认值() throws IOException {
String source = stripComments(Files.readString(CONTROLLER));
for (String param : List.of("page_size", "shop_name", "product_code", "title_keyword",
"sale_status", "group_id", "synced_from", "synced_to", "company_id")) {
"group_id", "synced_from", "synced_to", "company_id")) {
assertTrue(source.contains(param), "查询参数必须 snake_case:" + param);
}
// 商品状态筛选框已随 2026-11-15 客户口径从前端下线 ⇒ 服务端同名参数一起撤(反向钉住防回潜)。
assertFalse(source.contains("\"sale_status\""), "sale_status 筛选参数必须已删除,不得回潜");
assertTrue(source.contains("PageDefaults"), "page/page_size 默认值必须取 PageDefaults"
+ "(page_size 默认 20=PageDefaults.JD_PRODUCTS_PAGE_SIZE);"
+ "page 钳制防 (page-1)*page_size 溢出的行为样本见查询服务钳制支(铁律 15)");
@@ -172,7 +175,7 @@ class AdminJdProductControllerTest {
PermissionMenuService permissionMenuService = mock(PermissionMenuService.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, mock(JdProductDeleteService.class), authSupport,
queryService, mock(JdProductDeleteService.class), mock(JdProductUpdateService.class), authSupport,
permissionMenuService, dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
@@ -198,13 +201,43 @@ class AdminJdProductControllerTest {
assertEquals(pageVo, response.getData());
}
@Test
void 类目下拉端点走同一正门并回选项集() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, mock(JdProductDeleteService.class), mock(JdProductUpdateService.class), authSupport,
mock(PermissionMenuService.class), dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(7L);
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
// 非超管正门强制本公司:即使请求带别的 company_id 也按返回值收口(同一行为样本家族)。
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
JdProductCategoryVo row = new JdProductCategoryVo();
row.setName("艺考形体服");
row.setProductCount(85L);
when(queryService.categories(5L)).thenReturn(List.of(row));
ApiResponse<List<JdProductCategoryVo>> response = controller.categories(5L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(queryService).categories(5L);
assertEquals(Boolean.TRUE, response.isSuccess(), "类目下拉与列表同一鉴权正门(200 信封)");
assertEquals("艺考形体服", response.getData().get(0).getName(), "选项=已落库行的末级类目名");
assertEquals(85L, response.getData().get(0).getProductCount());
}
@Test
void 控制器详情走同一鉴权正门并回详情() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, mock(JdProductDeleteService.class), authSupport,
queryService, mock(JdProductDeleteService.class), mock(JdProductUpdateService.class), authSupport,
mock(PermissionMenuService.class), dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
@@ -233,7 +266,8 @@ class AdminJdProductControllerTest {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, deleteService, authSupport, mock(PermissionMenuService.class), dataReadScope);
queryService, deleteService, mock(JdProductUpdateService.class), authSupport,
mock(PermissionMenuService.class), dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(7L);
@@ -262,7 +296,8 @@ class AdminJdProductControllerTest {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, deleteService, authSupport, mock(PermissionMenuService.class), dataReadScope);
queryService, deleteService, mock(JdProductUpdateService.class), authSupport,
mock(PermissionMenuService.class), dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(7L);
@@ -280,37 +315,6 @@ class AdminJdProductControllerTest {
assertTrue(ex.getMessage().contains("本次未删除任何数据"), "整批拒绝的语义必须到界面");
}
@Test
void 控制器导出走同一正门并回Excel响应() {
JdProductQueryService queryService = mock(JdProductQueryService.class);
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
DataReadScope dataReadScope = mock(DataReadScope.class);
AdminJdProductController controller = new AdminJdProductController(
queryService, mock(JdProductDeleteService.class), authSupport,
mock(PermissionMenuService.class), dataReadScope);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(7L);
HttpServletRequest request = mock(HttpServletRequest.class);
when(authSupport.requireUser(request)).thenReturn(operator);
when(authSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyIdOrOwn(operator, 5L)).thenReturn(5L);
byte[] payload = "xlsx-bytes".getBytes(java.nio.charset.StandardCharsets.UTF_8);
when(queryService.export(5L, null, null, null, null, null, null, null)).thenReturn(payload);
ResponseEntity<byte[]> response = controller.export(null, null, null, null, null, null, null,
5L, request);
verify(dataReadScope).readCompanyIdOrOwn(operator, 5L);
verify(queryService).export(5L, null, null, null, null, null, null, null);
assertEquals(MediaType.parseMediaType(
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
response.getHeaders().getContentType(), "导出必须是 xlsx Content-Type");
assertTrue(response.getHeaders().getFirst(HttpHeaders.CONTENT_DISPOSITION).contains("filename*=UTF-8''"),
"中文文件名必须带 filename* UTF-8 轨(DownloadHeaderUtil 双轨口径)");
assertArrayEquals(payload, response.getBody(), "响应体必须原样是服务侧产出的字节");
}
@Test
void 查询服务分页钳制防溢出() {
JdProductMapper mapper = mock(JdProductMapper.class);
@@ -350,11 +354,6 @@ class AdminJdProductControllerTest {
() -> service.page(1L, 20L, null, null, null, null, null, null, from, to));
assertTrue(ex.getMessage().contains("开始时间不能晚于结束时间"), "倒挂时间按业务异常拒绝");
verify(mapper, never()).countProducts(any(), any(), any(), any(), any(), any(), any(), any());
// 导出与分页共用同一过滤面校验(同一个拒绝时机:不碰 mapper)。
BusinessException exportEx = assertThrows(BusinessException.class,
() -> service.export(null, null, null, null, null, null, from, to));
assertTrue(exportEx.getMessage().contains("开始时间不能晚于结束时间"),
"导出端点必须同样拒绝倒挂时间,不得绕过分页页签的校验口径");
}
@Test
@@ -366,13 +365,14 @@ class AdminJdProductControllerTest {
when(mapper.countProducts(any(), any(), any(), any(), any(), any(), any(), any())).thenReturn(0L);
// 超管显式传 5 ⇒ 按公司 5 筛(收窄);groupId ≤0 按没选分组处理;文本两侧空白剥掉。
service.page(1L, 20L, 5L, " 店铺甲 ", " SKU-1 ", " 连衣裙 ", "上架中", 0L, null, null);
verify(mapper).countProducts(eq(5L), eq("店铺甲"), eq("SKU-1"), eq("连衣裙"), eq("上架中"),
isNull(), isNull(), isNull());
// 类目(京麦末级类目名)走同一过滤面:传值原样直传、空白归 null。
service.page(1L, 20L, 5L, " 店铺甲 ", " SKU-1 ", " 连衣裙 ", " 艺考形体服 ", 0L, null, null);
verify(mapper).countProducts(eq(5L), eq("店铺甲"), eq("SKU-1"), eq("连衣裙"),
eq("艺考形体服"), isNull(), isNull(), isNull());
// 全量(scopedCompanyId=null)⇒ companyId 不过滤。
service.page(1L, 20L, null, null, null, null, null, null, null, null);
verify(mapper).countProducts(isNull(), isNull(), isNull(), isNull(), isNull(), isNull(),
isNull(), isNull());
verify(mapper).countProducts(isNull(), isNull(), isNull(), isNull(), isNull(),
isNull(), isNull(), isNull());
}
@Test
@@ -518,23 +518,6 @@ class AdminJdProductControllerTest {
assertThrows(BusinessException.class, () -> service.detail(0L, null));
}
@Test
void 导出超上限按业务错误拒绝且不取数() {
JdProductMapper mapper = mock(JdProductMapper.class);
JdProductQueryService service = new JdProductQueryService(mapper, mock(JdProductImageMapper.class),
mock(com.nanri.aiimage.modules.jd.mapper.JdProductSkuMapper.class),
mock(com.nanri.aiimage.modules.jd.mapper.JdProductGroupMapper.class));
when(mapper.countProducts(any(), any(), any(), any(), any(), any(), any(), any()))
.thenReturn(JdProductQueryService.EXPORT_MAX_ROWS + 1);
BusinessException ex = assertThrows(BusinessException.class,
() -> service.export(null, null, null, null, null, null, null, null));
assertTrue(ex.getMessage().contains("超过导出上限"),
"超上限必须给「缩小筛选范围」的可读文案,不能让用户等一次注定 OOM 的全量查询");
verify(mapper, never()).selectProductPage(any(), any(), any(), any(), any(), any(), any(),
any(), anyLong(), anyInt());
}
@Test
void 列表行分组名批量补齐且读不到不猜() {
JdProductMapper mapper = mock(JdProductMapper.class);
@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.jd.mapper.JdProductIgnoreMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductImageMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
@@ -50,6 +51,8 @@ class JdProductDeleteServiceTest {
@Mock
private JdProductImageMapper jdProductImageMapper;
@Mock
private JdProductIgnoreMapper jdProductIgnoreMapper;
@Mock
private JdProductRowDeleteService jdProductRowDeleteService;
@Mock
private OssStorageService ossStorageService;
@@ -63,7 +66,7 @@ class JdProductDeleteServiceTest {
TableInfoHelper.initTableInfo(assistant, JdProductEntity.class);
TableInfoHelper.initTableInfo(assistant, JdProductImageEntity.class);
service = new JdProductDeleteService(jdProductMapper, jdProductImageMapper,
jdProductRowDeleteService, ossStorageService);
jdProductIgnoreMapper, jdProductRowDeleteService, ossStorageService);
ReflectionTestUtils.setField(service, "bucket", "jd-products");
ReflectionTestUtils.setField(service, "keyPrefix", "jd-products/");
}
@@ -7,10 +7,12 @@ import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.jd.mapper.JdProductIgnoreMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdCollectTaskCreateRequest;
import com.nanri.aiimage.modules.jd.model.dto.JdIngestChunkRequest;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductIgnoreEntity;
import com.nanri.aiimage.modules.jd.model.vo.JdIngestChunkVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
@@ -84,6 +86,8 @@ class JdProductSyncServiceTest {
private JdProductSkuIngestService jdProductSkuIngestService;
@Mock
private JdProductRowDeleteService jdProductRowDeleteService;
@Mock
private JdProductIgnoreMapper jdProductIgnoreMapper;
@Spy
private ObjectMapper objectMapper = new ObjectMapper();
@@ -92,8 +96,11 @@ class JdProductSyncServiceTest {
@BeforeAll
static void initTableInfo() {
// MP 条件构造器在纯单测里必须先初始化实体 TableInfo(CollectDataCredentialFatalTest 同款)
// MP 条件构造器在纯单测里必须先初始化实体 TableInfo(CollectDataCredentialFatalTest 同款)。
// V199 保护闸的 LambdaQueryWrapper 也吃这两个实体的 lambda cache。
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), FileTaskEntity.class);
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), JdProductEntity.class);
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), JdProductIgnoreEntity.class);
}
// ---------- 夹具 ----------
@@ -177,6 +184,9 @@ class JdProductSyncServiceTest {
lenient().when(adminUserMapper.selectById(USER_ID)).thenReturn(owner(COMPANY_ID));
lenient().when(collectTaskService.readCreateRequest(any(FileTaskEntity.class))).thenReturn(createRequest());
lenient().when(collectTaskService.findScopeRow(TASK_ID)).thenReturn(scopeRow());
// V199 保护闸:默认无锁定行、无忽略三元组(保护用例各自覆盖自己的桩)。
lenient().when(jdProductMapper.selectList(any())).thenReturn(List.of());
lenient().when(jdProductIgnoreMapper.selectList(any())).thenReturn(List.of());
}
// ---------- 判据 ----------
@@ -392,6 +402,48 @@ class JdProductSyncServiceTest {
.anySatisfy(json -> assertThat(json).contains("覆盖清理失败"));
}
// ---------- V199 保护闸:人工编辑锁与删除忽略 ----------
@Test
void 人工编辑锁与删除忽略的行跳过落库不登记子表() {
stubHappyPath();
// 保护集:锁定行 10036442942137(manual_locked=1,后管编辑过)+ 忽略三元组 10036442942138(后管删过)
JdProductEntity locked = new JdProductEntity();
locked.setShopId("shop-001");
locked.setProductCode("10036442942137");
when(jdProductMapper.selectList(any())).thenReturn(List.of(locked));
JdProductIgnoreEntity ignored = new JdProductIgnoreEntity();
ignored.setCompanyId(COMPANY_ID);
ignored.setShopId("shop-001");
ignored.setProductCode("10036442942138");
when(jdProductIgnoreMapper.selectList(any())).thenReturn(List.of(ignored));
JdIngestChunkVo vo = service.submitChunk(TASK_ID,
chunk(item("10036442942137", "艺考形体服女"), item("10036442942138", "艺考形体服男"),
item("10036442942139", "艺考形体服新")), true);
// 命中保护集的两行连同其图片/SKU 登记一起跳过;只有第三行落库
@SuppressWarnings("unchecked")
ArgumentCaptor<List<JdProductEntity>> rowsCaptor = ArgumentCaptor.forClass(List.class);
verify(jdProductMapper).upsertBatch(rowsCaptor.capture());
assertThat(rowsCaptor.getValue()).extracting(JdProductEntity::getProductCode)
.containsExactly("10036442942139");
verify(jdProductImageIngestService, times(1)).registerTaskImages(
any(), eq(COMPANY_ID), eq("10036442942139"), any());
verify(jdProductSkuIngestService, times(1)).registerTaskSkus(
any(), eq(COMPANY_ID), eq("10036442942139"), any());
assertThat(vo.getUpserted()).isEqualTo(1);
}
@Test
void 覆盖清理SQL必须排除人工编辑锁的行_绊线() throws Exception {
// V199:人工编辑过的行不进覆盖清理候选——重爬不得整行删掉人工值。
String xml = Files.readString(Path.of("src/main/resources/mapper/jd/JdProductMapper.xml"));
String purge = xml.substring(xml.indexOf("selectSupersededProductIds"));
assertThat(purge).contains("manual_locked = 0",
"覆盖清理候选必须排除 manual_locked=1 的行(V199 人工编辑锁)");
}
@Test
void 覆盖清理SQL必须排除在飞任务行_绊线() throws Exception {
// 同店铺并发两单:先收尾的单不得把仍在跑(PENDING/RUNNING)的单已落的行抹掉,
@@ -0,0 +1,305 @@
package com.nanri.aiimage.modules.jd.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.jd.mapper.JdProductGroupMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductImageMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductMapper;
import com.nanri.aiimage.modules.jd.mapper.JdProductSkuMapper;
import com.nanri.aiimage.modules.jd.model.dto.JdProductUpdateRequest;
import com.nanri.aiimage.modules.jd.model.entity.JdProductEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductGroupEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductImageEntity;
import com.nanri.aiimage.modules.jd.model.entity.JdProductSkuEntity;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 后管「编辑京东商品」编排判据(PUT /api/admin/jd-products/{id},2026-11-15 用户口径)。
*
* <p>钉六件事:①归属闸(越界 id 按不存在拒绝,零写);②主字段全量保存即置人工编辑锁
* {@code manual_locked=1}(V199——没有这个锁,编辑会被下一次采集 upsert 覆盖回去);
* ③分组归属校验(跨公司挂组拒绝);④属性重建只覆写 attr_json 的 {@code tabs} 段、
* images/productCode 等其它顶层键原样保留(铁律 30 形状),原文形状不识别时拒绝而不是静默重写;
* ⑤SKU 按 (productId, skuId) 匹配改价改库存,缺失 skuId 拒绝;⑥删图=先删桶、共用对象保留、
* image_count 按表实数刷新。</p>
*/
@ExtendWith(MockitoExtension.class)
class JdProductUpdateServiceTest {
private static final Long PRODUCT_ID = 42L;
private static final Long COMPANY_ID = 5L;
@Mock
private JdProductMapper jdProductMapper;
@Mock
private JdProductSkuMapper jdProductSkuMapper;
@Mock
private JdProductImageMapper jdProductImageMapper;
@Mock
private JdProductGroupMapper jdProductGroupMapper;
@Mock
private OssStorageService ossStorageService;
private JdProductUpdateService service;
@BeforeAll
static void initTableInfo() {
// MP 条件构造器在纯单测里必须先初始化实体 TableInfo(JdProductDeleteServiceTest 同款)。
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, JdProductEntity.class);
TableInfoHelper.initTableInfo(assistant, JdProductSkuEntity.class);
TableInfoHelper.initTableInfo(assistant, JdProductImageEntity.class);
TableInfoHelper.initTableInfo(assistant, JdProductGroupEntity.class);
}
@BeforeEach
void setUp() {
service = new JdProductUpdateService(jdProductMapper, jdProductSkuMapper,
jdProductImageMapper, jdProductGroupMapper, ossStorageService);
ReflectionTestUtils.setField(service, "bucket", "jd-products");
ReflectionTestUtils.setField(service, "keyPrefix", "jd-products/");
}
// ---------- 夹具 ----------
private JdProductEntity productRow() {
JdProductEntity row = new JdProductEntity();
row.setId(PRODUCT_ID);
row.setCompanyId(COMPANY_ID);
row.setShopId("shop-001");
row.setProductCode("1003668397262");
row.setTitle("旧标题");
row.setAttrJson("{\"tabs\":[{\"tab\":\"商品基本信息\",\"attrs\":[{\"key\":\"brand\",\"label\":\"品牌\",\"value\":\"花屿巷\"}]}],"
+ "\"images\":[{\"type\":\"MAIN\",\"objectKey\":\"jd-products/5/aaa.jpg\"}],\"productCode\":\"1003668397262\"}");
return row;
}
private JdProductUpdateRequest mainFieldsOnly() {
JdProductUpdateRequest body = new JdProductUpdateRequest();
body.setTitle(" 新标题 ");
body.setBrand(" 新品牌 ");
body.setGroupId(null);
return body;
}
private void givenOwnedRow() {
when(jdProductMapper.selectById(PRODUCT_ID)).thenReturn(productRow());
}
/** 取 update 落下的 SET 键值对(paramNameValuePairs),供断言新值。 */
@SuppressWarnings("unchecked")
private Map<String, Object> capturedSetValues() {
ArgumentCaptor<Wrapper<JdProductEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductMapper).update(isNull(), captor.capture());
LambdaUpdateWrapper<JdProductEntity> wrapper = (LambdaUpdateWrapper<JdProductEntity>) captor.getValue();
return (Map<String, Object>) ReflectionTestUtils.getField(wrapper, "paramNameValuePairs");
}
// ---------- 判据 ----------
@Test
void 归属闸_越界或不存在按不存在拒绝且零写() {
JdProductEntity otherCompany = productRow();
otherCompany.setCompanyId(99L);
when(jdProductMapper.selectById(PRODUCT_ID)).thenReturn(otherCompany);
assertThatThrownBy(() -> service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("商品不存在");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
assertThatThrownBy(() -> service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID))
.isInstanceOf(BusinessException.class);
}
@Test
void 主字段全量保存即置人工编辑锁() {
givenOwnedRow();
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
Long id = service.update(PRODUCT_ID, mainFieldsOnly(), COMPANY_ID);
assertThat(id).isEqualTo(PRODUCT_ID);
Map<String, Object> values = capturedSetValues();
// 主字段全量提交:trim 落值(title/brand)
assertThat(values.values()).contains("新标题", "新品牌");
// SET 段必须带 manual_locked(V199 人工编辑锁本体)
ArgumentCaptor<Wrapper<JdProductEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductMapper).update(isNull(), captor.capture());
assertThat(((LambdaUpdateWrapper<JdProductEntity>) captor.getValue()).getSqlSet())
.contains("manual_locked");
// 主字段全量提交:trim 落值(title/brand)
assertThat(values.values()).contains("新标题").contains("新品牌");
}
@Test
void 分组必须属于本公司() {
givenOwnedRow();
JdProductUpdateRequest body = mainFieldsOnly();
body.setGroupId(7L);
JdProductGroupEntity group = new JdProductGroupEntity();
group.setId(7L);
group.setCompanyId(99L);
when(jdProductGroupMapper.selectById(7L)).thenReturn(group);
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("分组不存在或不属于当前公司");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
}
@Test
void 属性重建只覆写tabs段其余顶层键保留() {
givenOwnedRow();
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
JdProductUpdateRequest body = mainFieldsOnly();
JdProductUpdateRequest.AttrGroupDto group = new JdProductUpdateRequest.AttrGroupDto();
group.setGroupName("商品基本信息");
JdProductUpdateRequest.AttrDto attr = new JdProductUpdateRequest.AttrDto();
attr.setKey("brand");
attr.setLabel("品牌");
attr.setValue("新品牌值");
group.setAttrs(List.of(attr));
body.setAttrGroups(List.of(group));
service.update(PRODUCT_ID, body, COMPANY_ID);
Map<String, Object> values = capturedSetValues();
// 新 JSON 里有重建后的 tabs(新属性值落进去了),且 images/productCode 原样保留(铁律 30)
Object newJson = values.values().stream()
.filter(v -> v instanceof String s && s.contains("\"tabs\""))
.findFirst().orElseThrow();
assertThat((String) newJson).contains("新品牌值").contains("\"images\"").contains("1003668397262");
}
@Test
void 属性原文形状不识别时拒绝编辑防丢原文() {
JdProductEntity row = productRow();
row.setAttrJson("not-a-contract-shape");
when(jdProductMapper.selectById(PRODUCT_ID)).thenReturn(row);
JdProductUpdateRequest body = mainFieldsOnly();
body.setAttrGroups(List.of(new JdProductUpdateRequest.AttrGroupDto()));
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("属性原文形状不识别");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
}
@Test
void SKU按skuId匹配改价格库存_缺失拒绝() {
givenOwnedRow();
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
JdProductSkuEntity sku = new JdProductSkuEntity();
sku.setId(900L);
sku.setProductId(PRODUCT_ID);
sku.setSkuId("10238877506570");
when(jdProductSkuMapper.selectList(any())).thenReturn(List.of(sku));
JdProductUpdateRequest body = mainFieldsOnly();
JdProductUpdateRequest.SkuEditDto edit = new JdProductUpdateRequest.SkuEditDto();
edit.setSkuId("10238877506570");
edit.setPrice(new BigDecimal("199.00"));
edit.setStock(88);
body.setSkus(List.of(edit));
service.update(PRODUCT_ID, body, COMPANY_ID);
ArgumentCaptor<Wrapper<JdProductSkuEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(jdProductSkuMapper).update(isNull(), captor.capture());
Map<String, Object> values = (Map<String, Object>) ReflectionTestUtils.getField(
(LambdaUpdateWrapper<JdProductSkuEntity>) captor.getValue(), "paramNameValuePairs");
assertThat(values.values()).contains(new BigDecimal("199.00"), 88);
// 提交里有不存在的 skuId:整笔拒绝(行可能已被重新采集刷新,让用户刷新重试)
JdProductUpdateRequest bad = mainFieldsOnly();
JdProductUpdateRequest.SkuEditDto ghost = new JdProductUpdateRequest.SkuEditDto();
ghost.setSkuId("ghost-sku");
ghost.setPrice(BigDecimal.ONE);
bad.setSkus(List.of(ghost));
assertThatThrownBy(() -> service.update(PRODUCT_ID, bad, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("SKU 行不存在");
}
@Test
void 删图先删桶_共用对象保留_计数按表实数刷() {
givenOwnedRow();
when(jdProductMapper.update(isNull(), any(Wrapper.class))).thenReturn(1);
JdProductImageEntity owned = new JdProductImageEntity();
owned.setId(1L);
owned.setProductId(PRODUCT_ID);
owned.setObjectKey("jd-products/5/aaa.jpg");
JdProductImageEntity missing = new JdProductImageEntity();
missing.setId(2L);
missing.setProductId(999L);
when(jdProductImageMapper.selectList(any()))
// ① 归属校验:两张里有一张不属于本商品 → 整笔拒绝(本次未保存任何修改)
.thenReturn(List.of(owned))
// ② 共用性回查:同 key 被另一商品引用 → 保留对象
.thenReturn(List.of(new JdProductImageEntity()));
JdProductUpdateRequest body = mainFieldsOnly();
body.setDeleteImageIds(List.of(1L, 2L));
assertThatThrownBy(() -> service.update(PRODUCT_ID, body, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("本次未删除任何数据");
// 修正归属:只删 1L;同 key 被别的商品引用 ⇒ 对象保留、只删登记行、计数刷新
JdProductUpdateRequest fixed = mainFieldsOnly();
fixed.setDeleteImageIds(List.of(1L));
service.update(PRODUCT_ID, fixed, COMPANY_ID);
verify(ossStorageService, never()).removeObject(eq("jd-products"), eq("jd-products/5/aaa.jpg"));
verify(jdProductImageMapper).delete(any(Wrapper.class));
// update 共 3 次:两次 service.update() 的主字段各 1 次(第一次归属拒绝虽已过主字段
// 写点,但 @Transactional 会整笔回滚,DB 层零持久化)+ 删图后的计数刷新 1 次
verify(jdProductMapper, org.mockito.Mockito.times(3)).update(isNull(), any(Wrapper.class));
}
@Test
void 价格区间倒挂与负库存可读拒绝() {
givenOwnedRow();
JdProductUpdateRequest badPrice = mainFieldsOnly();
badPrice.setPriceMin(new BigDecimal("100"));
badPrice.setPriceMax(new BigDecimal("50"));
assertThatThrownBy(() -> service.update(PRODUCT_ID, badPrice, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("价格区间下限不能大于上限");
JdProductUpdateRequest badStock = mainFieldsOnly();
badStock.setStockTotal(-1);
assertThatThrownBy(() -> service.update(PRODUCT_ID, badStock, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("总库存不能为负数");
verify(jdProductMapper, never()).update(isNull(), any(Wrapper.class));
verify(jdProductSkuMapper, never()).update(isNull(), any(Wrapper.class));
verify(jdProductSkuMapper, never()).selectList(any());
verify(jdProductImageMapper, never()).delete(any(Wrapper.class));
}
}