'use strict'; /** * 库存盘点模块(stock.check.*)集成测试。 * * 测试层次: * - systems.stockCheck(业务层):状态机、单号生成、明细快照、作业记录(wms_stock_check_record)、 * 汇总重算等核心逻辑,直连本地开发库(config.local.js,127.0.0.1:3307)验证真实写入/查询链路; * - systemMethods.stock.check(方法包装层):仓库上下文注入、统一 success/fail 包装、 * 业务错误码 400 透传。 * * 覆盖范围(本轮适配:detail 精简为只返回任务本身信息({ check })、明细范围行/盘点结果由 * result 返回、新增 result 返回盘点结果聚合、 * 主表移除 check_date 字段(start_time=首个明细写入时间、end_time=完成盘点时间)、 * patternCreate 移除 mode 入参): * - create 单号全局递增(跨仓库接续)与 uk_check_no 撞号自动重取(并发兜底); * - create 盘点方式规则:type=location 一律强制盲盘 blind(忽略前端传入的 mode), * type=store/goods 按传入值(缺省默认明盘 open);type 缺省 location,all 已下线(400); * - addDetail 类型分派:goods/store 按 stock_ids、location 按 locations, * 维度互斥报 400;货主一致性校验(invalid_stock_ids); * type=location 缺省 locations 自动生成全仓库启用库位明细(原全盘语义);库位行幂等跳过; * - addDetail location_ids 库位ID直查(新增入参):location 类型按 wms_location_space.id * + warehouse_id 直查校验(与 locations 同传时 location_ids 优先、locations 忽略), * 无效 ID 计入 invalid_location_ids;幂等按 uk_check_location;商品型任务传 location_ids 报 400; * addLocationDetail 兼容入口薄封装转调 addDetail(返回结构不变); * - report 覆盖式上报(mode=created/updated,space_id 必传并按库位ID落库);商品行 stock_id 不一致 400, * 库位行 stock_id 必填/本仓库校验/库位以明细为准; * - uk_detail_stock_location(detail_id, stock_id, location_code) 唯一索引并发加固 * (历史无库位记录库中存空串 ''、recordList 接口返回 null;report 不再产生该分组); * - recordList/recordDelete 作业记录查询与删除; * - batchDelete 批量删除:仅作废任务删除(事务级联清空主表/明细/作业记录), * 非作废与查不到的任务计入 skipped_ids(保持入参顺序);单值 ids 兼容、去重、 * 200 上限与 400 参数校验;方法层仓库上下文注入与 success/failure 包装; * - detailDelete 批量删除明细(本轮升级:单值删除 → 批量删除):detailIds 单值自动转数组 * (单次上限 200)、仅 created/rejected 状态允许(否则 400)、未命中明细计入 skipped_ids * 不报错(deleted_ids/skipped_ids 保持入参顺序)、删除后防御性清理 wms_stock_check_record * 并重算 total_items;返回结构 { deleted_count, deleted_ids, skipped_ids, total_items }; * 400 边界(任务ID为空/任务不存在/状态不允许/请至少选择一个明细/单次最多删除 200 条明细); * 方法层 detail_ids/detailIds/detail_id 三种入参写法兼容与 success/failure 包装; * - list 筛选扩展:type/mode 单值或数组 in、store_id、created_at 单值 gte 与 * [from,to] between(直插 created_at 造数)、start_time/end_time 盘点时间范围 * (report/finish 后落库)、type+status 组合筛选、非法时间值静默忽略; * where 标准结构(operator/value)经方法层 prepareWhereContext 提取(eq/in/between); * - list 货主名称补齐:rows 每条补 store_name(合约表 wms_store_warehouse.store_remask 优先、 * wms_store.company_name 兜底、store_id 为空或查不到为空串), * store_id 筛选 + store_name 组合返回口径校验; * - detail 只返回任务本身信息({ check },_formatCheckRow 口径),不返回明细范围行 * 与盘点作业聚合(明细范围行/盘点结果由 result 返回、作业记录由 recordList 返回); * 400 边界(任务ID为空/任务不存在); * - result 返回盘点结果聚合:商品行 checked_quantity/diff_quantity/is_diff/status/location_codes/ * checkers/last_checked_at/records/locations,库位行 stocks 按商品聚合(账面来自 wms_storage) * 与行级 checked_quantity/diff_quantity; * - 汇总差异口径:商品行用快照、库位行用 wms_storage 实时账面; * - workData 盘点作业数据(单接口三视图,is_goods 驱动;不返回 check,任务信息由 detail 返回): * location 视图库位结构(任务库位范围行为列表,行内挂 goods 子列表与 has_unknown/checkers/status)、 * goods 视图商品结构(按商品汇总,同商品多库位明细合并为一行:行级账面为快照合计、 * 作业记录跨明细按库位合并、locations 带该库位明细ID 与账面快照;明盘返回 * system_quantity/checked_quantity/diff_quantity/is_diff 与 locations.quantity,盲盘不含任何数量字段)、space 视图聚合库位结构(wms_storage 所在库位 * 按拣货路径排序,明盘含库位账面/已盘数量,盲盘不含数量);无记录任务子列表为空、 * 响应为 { view, rows, total, page, pageSize }(view=解析后的视图 location/goods/space;不返回 check,任务信息由 detail 返回)、400 边界(任务ID/任务不存在/跨仓库隔离) * 与状态限制(created/submitted/rejected/completed/cancelled 均 400,仅 approved/checking 可拉取) * 及方法层 is_goods 透传/success 包装; * - finish 允许部分未盘完成(未盘商品行按实盘 0 计盘亏,库位行按商品聚合计盈亏,返回 unchecked_items); * - exportStockChecks 导出(盘点明细=作业记录口径):Sheet1「盘点单」一行一个任务、 * Sheet2「盘点明细」一行一条实际盘点记录(不导出未盘范围行),商品快照从 * wms_stock_warehouse 补齐、空库位编码输出为空、total_count=作业记录总数; * mock COS 上传后回读 Excel 校验列名/列序/单元格值; * 未知商品(stock_id 为空)导出商品编码=扫描条码、商品名称=名称快照。 * - 未知商品记录(stock_id 可空 + barcode/item_name,迁移 20261001100000): * report 库位行仅传 barcode(未命中系统条码)→ stock_id=NULL + barcode + item_name 落库 * (item_name 缺省=barcode,显式传名称按快照);barcode 命中 wms_stock_barcodes 系统条码 * → 回填 stock_id 按已知商品处理(商品行命中其他商品报 400);未知商品覆盖式查重 * (同 detail+同 barcode+同库位二次上报 → mode=updated 数量更新不新增); * result 商品行/库位行均输出行级 unknown_items [{ barcode, item_name, checked_quantity }] * (未知商品无账面:实盘=盘盈计入行级差异,stocks 保持只含已知商品); * finish 未知商品计入 profit_total/diff_items; * report 未传 stock_id 且未传 barcode 沿用原报错口径; * 已知商品原链路回归(stock_id 匹配、库位行必填、barcode/item_name 保持 NULL)。 * - 图片独立维护:FileReference(business_type=stock_check_record、business_id=记录ID) * 挂载到 recordList 与 result.records 的 images [{ id: file_id, url }](无图片为空数组); * recordDelete 删除记录时清理其 FileReference 图片引用; * recordList 未知商品 item_code=条码、item_name=名称快照(已知商品维持明细快照)。 * - 操作日志(wms_operation_log,business_type=stock_check):10 个写操作成功路径 * 写入日志(直查表断言 operation_code/business_id/warehouse_id/message/operator 快照), * batchDelete 仅 deletedIds 非空写 1 条(business_id=首个删除 id),失败路径不写日志。 * - patternList/patternCreate 盘点定式快速创建:5 个定式清单(id/name/description/type)、 * 按定式收集对象(空库位/错发/临期/静态/预警)后任务直接 submitted 落库 * (明细快照、total_items 重算、STOCK_CHECK_CREATE 日志含 pattern_id、static 定式 * 写 wms_stock_static_check_task 并排除已盘商品)、盘点方式由定式范围类型固定 * (库位类盲盘 blind、商品类明盘 open)、主表不含 check_date(start_time/end_time 承载盘点时间语义)、 * 400 边界(定式不存在/无对象/未开启预警/缺仓库)、方法层 success/failure 包装与仓库注入。 * * 运行前提(显式开启真实库,普通测试运行自动跳过,与 interceptRealDb.chain.test.js 口径一致): * cmd /c "set DISPATCH_FACTORY_TEST_MYSQL=1&& npx egg-bin test test/app/service/systems/stock_check.test.js" * * 固定测试参数(与 wms-test-agent 约定一致): * - 测试仓库 ID:100000 * - 测试货主 ID:1000000 * * 数据策略:按用户偏好,本测试不清理写入数据(保留以供核对写入格式), * 用例通过唯一标题/关键字与"断言包含关系"的方式保证可重复执行。 */ const assert = require('node:assert/strict'); const crypto = require('node:crypto'); const mm = require('egg-mock'); const ExcelJS = require('exceljs'); const REAL_DB_ENABLED = process.env.DISPATCH_FACTORY_TEST_MYSQL === '1'; const runner = REAL_DB_ENABLED ? describe : describe.skip; const TEST_WAREHOUSE_ID = 100000; // 另一测试仓库(跨仓库隔离/全局递增验证口径,与 detailDelete 仓库隔离用例一致) const OTHER_TEST_WAREHOUSE_ID = 100001; const TEST_STORE_ID = 1000000; // 真实测试账号(开发库 wms_account_store_employee:id=4,account_id=1 liufumingren,store_id=100000,status=1) const TEST_CREATOR_ID = 4; const TEST_CREATOR_NAME = '阿猫'; // 固定测试库位编码与对应 wms_location_space.id(warehouse_id=100000) const TEST_LOCATION_CODE = 'A1715-01-01-01'; const TEST_LOCATION_ID = 26885; // 无库存的启用库位(用于库位行账面 0 口径验证,warehouse_id=100000) const TEST_EMPTY_LOCATION_CODE = 'E07-01-02-01'; // 有效库位过滤 SQL(与业务排除无头库位口径一致:库位未删除且所属 zone 存在未删除) const VALID_SPACE_SQL = '(SELECT ls.id FROM wms_location_space ls ' + 'JOIN wms_location_zone z ON z.id = ls.zone_id AND z.deleted_at IS NULL ' + 'WHERE ls.deleted_at IS NULL)'; // 第二/第三有效库位(report 已改为 space_id 必传,多库位用例必须用真实库位),在 before 中初始化 let TEST_LOCATION_CODE_2 = null; let TEST_LOCATION_ID_2 = 0; let TEST_LOCATION_CODE_3 = null; let titleSeq = 0; /** * 生成唯一标题,避免多次执行测试时互相干扰。 * * @param {string} prefix 标题前缀。 * @return {string} 唯一标题。 */ function uniqueTitle(prefix) { titleSeq += 1; return `${prefix}_${Date.now()}_${titleSeq}`; } /** * 获取当前日期片段(YYYYMMDD),用于校验单号前缀。 * * @return {string} 日期片段。 */ function currentDatePart() { const now = new Date(); return `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}`; } runner('test/app/service/systems/stock_check.test.js(库存盘点真实库集成测试)', function() { this.timeout(300000); let app; let ctx; before(async () => { app = mm.app({ baseDir: process.cwd(), env: 'local', clean: false, cache: false, }); await app.ready(); ctx = app.createAnonymousContext(); // 校验固定测试库位编码在当前开发库真实存在,且 location_id 与常量一致(不一致快速失败) const space = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_LOCATION_CODE }, attributes: [ 'id' ], raw: true, }); assert.ok(space, `固定测试库位编码不存在(warehouse_id=${TEST_WAREHOUSE_ID}, code=${TEST_LOCATION_CODE})`); assert.equal(Number(space.id), TEST_LOCATION_ID, '固定测试库位 ID 与本地库实际值不一致'); // 多库位用例所需的有效库位(report 的 space_id 必传,不能再用虚构编码) const extraLocations = (await fetchValidLocations(3)) .filter(item => item.space_code !== TEST_LOCATION_CODE && item.space_code !== TEST_EMPTY_LOCATION_CODE); assert.ok(extraLocations.length >= 2, '测试仓库应至少存在 2 个额外有效库位(多库位用例依赖)'); TEST_LOCATION_CODE_2 = extraLocations[0].space_code; TEST_LOCATION_ID_2 = extraLocations[0].id; TEST_LOCATION_CODE_3 = extraLocations[1].space_code; }); after(async () => { await app.close(); }); afterEach(() => { mm.restore(); }); // ------------------- 辅助函数(业务层直调) ------------------- /** * 创建盘点任务(业务层直调,固定测试仓库)。 * 默认 type=goods(商品维度用例口径);库位维度用例显式传 type=location。 * * @param {Object} [options] 创建参数覆盖项。 * @return {Promise} 格式化后的盘点任务行。 */ async function createCheck(options = {}) { return ctx.service.systems.stockCheck.create({ warehouseId: options.warehouseId !== undefined ? options.warehouseId : TEST_WAREHOUSE_ID, title: options.title || uniqueTitle('盘点单元测试'), type: options.type || 'goods', mode: options.mode || 'open', storeId: options.storeId !== undefined ? options.storeId : null, isStatic: options.isStatic, remark: options.remark, creatorId: options.creatorId || TEST_CREATOR_ID, creatorName: options.creatorName || TEST_CREATOR_NAME, }); } /** * 拉取固定测试仓库下的真实库存行(用于生成盘点明细快照)。 * * @param {number} count 行数。 * @param {Object} [options] 过滤选项。 * @param {boolean} [options.requireUnlocked=false] 仅取无锁定量商品 * (wms_storage SUM(locked_quantity)=0,静态盘点上报要求商品已完成拣货)。 * @return {Promise>} 库存行。 */ async function fetchStockRows(count = 2, options = {}) { // 取「仅在单个启用库位有库存」的商品:商品明细按「商品 + 库位」拆行后每商品 1 行, // 保证 total_items 与商品数一致(多库位商品拆多行、无库存库位商品不可加入盘点) const { Op, fn, col, literal } = ctx.app.Sequelize; const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, }, attributes: [ 'stock_id', [ fn('COUNT', fn('DISTINCT', col('space_id'))), 'spaceCount' ], [ literal('SUM(locked_quantity)'), 'lockedQuantity' ], ], group: [ 'stock_id' ], raw: true, }); const singleSpaceStockIds = storageRows .filter(row => Number(row.spaceCount) === 1) .filter(row => options.requireUnlocked !== true || (Number(row.lockedQuantity) || 0) === 0) .map(row => Number(row.stock_id)); return ctx.model.StockWarehouse.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, store_id: TEST_STORE_ID, id: { [Op.in]: singleSpaceStockIds }, }, order: [[ 'id', 'ASC' ]], limit: count, raw: true, }); } /** * 拉取固定测试仓库下其他货主的库存行(货主隔离校验用)。 * * @return {Promise} 库存行。 */ async function fetchOtherStoreStockRow() { const { Op } = ctx.app.Sequelize; return ctx.model.StockWarehouse.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, store_id: { [Op.ne]: TEST_STORE_ID }, }, order: [[ 'id', 'ASC' ]], raw: true, }); } /** * 拉取其他仓库的库存行(跨仓库隔离校验用)。 * * @return {Promise} 库存行。 */ async function fetchOtherWarehouseStockRow() { const { Op } = ctx.app.Sequelize; return ctx.model.StockWarehouse.findOne({ where: { warehouse_id: { [Op.ne]: TEST_WAREHOUSE_ID } }, order: [[ 'id', 'ASC' ]], raw: true, }); } /** * 查询库位商品账面数量(wms_storage 按 stock_id SUM(可用数量),与实现口径一致)。 * * @param {number} spaceId 库位ID。 * @param {Array} stockIds 商品库存ID列表。 * @return {Promise>} stock_id -> 账面数量。 */ async function fetchStorageQuantity(spaceId, stockIds) { const { Op, literal } = ctx.app.Sequelize; const rows = await ctx.model.Storage.findAll({ where: { space_id: Number(spaceId), stock_id: { [Op.in]: stockIds.map(id => Number(id)) }, }, attributes: [ 'stock_id', [ literal('SUM(available_quantity)'), 'totalQuantity' ]], group: [ 'stock_id' ], raw: true, }); return new Map(rows.map(row => [ Number(row.stock_id), Number(row.totalQuantity) || 0 ])); } /** * 查询库位下真实库存商品ID列表(用于库位行多商品上报,按 stock_id 升序)。 * * @param {number} spaceId 库位ID。 * @param {number} [count] 行数。 * @return {Promise>} 商品库存ID列表。 */ async function fetchStorageStockIds(spaceId, count = 2) { const rows = await ctx.model.Storage.findAll({ where: { space_id: Number(spaceId) }, attributes: [ 'stock_id' ], group: [ 'stock_id' ], order: [[ 'stock_id', 'ASC' ]], limit: count, raw: true, }); return rows.map(row => Number(row.stock_id)); } /** * 取固定测试仓库下「只存放在单一库位」的有效商品与库位对(保证库位-商品一一对应, * 供 space 视图聚合/排序用例使用),并附库位编码/名称与账面数量(账面口径与实现一致: * wms_storage 按 warehouse+space+stock+is_enabled=1 SUM(available_quantity)) * 及锁定数量(SUM(locked_quantity))。 * * @param {number} count 对数。 * @return {Promise>} [{ spaceId, stockId, spaceCode, customName, book, bookLocked }]。 */ async function fetchSpaceStockPairs(count = 3) { const { Op, fn, col, literal } = ctx.app.Sequelize; const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, }, attributes: [ 'space_id', 'stock_id' ], raw: true, }); // 商品 → 库位集合(筛选只存放在单一库位的商品,避免同商品多库位干扰聚合断言) const spacesByStock = new Map(); for (const row of storageRows) { const stockId = Number(row.stock_id); if (!spacesByStock.has(stockId)) { spacesByStock.set(stockId, new Set()); } spacesByStock.get(stockId).add(Number(row.space_id)); } const candidatesBySpace = new Map(); for (const [ stockId, spaceSet ] of spacesByStock) { if (spaceSet.size !== 1) { continue; } const spaceId = [ ...spaceSet ][0]; if (!candidatesBySpace.has(spaceId)) { candidatesBySpace.set(spaceId, []); } candidatesBySpace.get(spaceId).push(stockId); } const pairs = []; const sortedSpaces = [ ...candidatesBySpace.keys() ].sort((left, right) => left - right); for (const spaceId of sortedSpaces) { const stockId = candidatesBySpace.get(spaceId).sort((left, right) => left - right)[0]; const stock = await ctx.model.StockWarehouse.findOne({ where: { id: stockId, warehouse_id: TEST_WAREHOUSE_ID, is_valid: 'Y' }, attributes: [ 'id' ], raw: true, }); if (!stock) { continue; } const space = await ctx.model.LocationSpace.findOne({ where: { id: spaceId }, attributes: [ 'id', 'space_code', 'custom_name' ], raw: true, }); if (!space) { continue; } const bookRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_id: spaceId, stock_id: stockId, is_enabled: 1, }, attributes: [ [ ctx.app.Sequelize.literal('SUM(available_quantity)'), 'totalQuantity' ], [ fn('SUM', col('locked_quantity')), 'totalLockedQuantity' ], ], raw: true, }); pairs.push({ spaceId, stockId, spaceCode: String(space.space_code || '').trim(), customName: String(space.custom_name || '').trim(), book: Number(bookRows[0] && bookRows[0].totalQuantity) || 0, bookLocked: Number(bookRows[0] && bookRows[0].totalLockedQuantity) || 0, }); if (pairs.length >= count) { break; } } assert.ok( pairs.length >= Math.min(count, 2), `固定测试仓库应存在至少 ${Math.min(count, 2)} 个单一库位库存商品(space 视图真实数据依赖)` ); return pairs; } /** * 按实现口径解析货主名(合约表 store_remask 优先、公司名兜底、查不到为 null), * 供 workData 各视图 store_name 字段交叉验证。 * * @param {number} storeId 货主ID。 * @return {Promise} 货主名称。 */ async function resolveStoreName(storeId) { const normalizedId = Number(storeId); if (!Number.isInteger(normalizedId) || normalizedId <= 0) { return null; } const contract = await ctx.model.StoreWarehouse.findOne({ where: { store_id: normalizedId, warehouse_id: TEST_WAREHOUSE_ID }, attributes: [ 'store_remask' ], raw: true, }); if (contract && contract.store_remask) { return contract.store_remask; } const store = await ctx.model.Store.findOne({ where: { id: normalizedId }, attributes: [ 'company_name' ], raw: true, }); return (store && store.company_name) || null; } /** * 创建一条已审核(approved)的库位维度盘点任务(固定测试库位),返回主表与库位明细行。 * * @return {Promise} { check, detail }。 */ async function createApprovedLocationCheck() { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); return { check, detail: details.rows[0] }; } /** * 业务层:添加盘点明细(商品维度)。 * * @param {number} checkId 盘点任务ID。 * @param {Array} stockIds 库存ID列表。 * @return {Promise} 添加结果。 */ async function addDetail(checkId, stockIds) { return ctx.service.systems.stockCheck.addDetail({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, stockIds, }); } /** * 业务层:添加盘点明细(库位维度)。 * * @param {number} checkId 盘点任务ID。 * @param {Array} [locations] 库位编码列表(缺省时按任务类型处理)。 * @return {Promise} 添加结果。 */ async function addLocationDetail(checkId, locations) { return ctx.service.systems.stockCheck.addDetail({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, locations, }); } /** * 业务层:添加盘点明细(原始参数透传,用于维度互斥等参数校验场景)。 * * @param {Object} params 添加参数(自动注入固定测试仓库)。 * @return {Promise} 添加结果。 */ async function addDetailRaw(params = {}) { return ctx.service.systems.stockCheck.addDetail({ warehouseId: TEST_WAREHOUSE_ID, ...params, }); } /** * 业务层:批量添加库位明细(兼容入口,按库位ID直查)。 * * @param {number} checkId 盘点任务ID。 * @param {Array} locationIds 库位ID列表。 * @return {Promise} 添加结果。 */ async function addLocationDetailByIds(checkId, locationIds) { return ctx.service.systems.stockCheck.addLocationDetail({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, locationIds, }); } /** * 取一个本地库中不存在的库位ID(按当前最大 ID 递增,避免与真实数据冲突)。 * * @return {Promise} 不存在的库位ID。 */ async function fetchMissingLocationId() { const { fn, col } = ctx.app.Sequelize; const maxRow = await ctx.model.LocationSpace.findOne({ attributes: [[ fn('MAX', col('id')), 'maxId' ]], raw: true, }); return Number(maxRow && maxRow.maxId) + 1000; } /** * 业务层:提交审核。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} 提交结果。 */ async function submitCheck(checkId) { return ctx.service.systems.stockCheck.submit({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, }); } /** * 业务层:取消任务。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} 取消结果。 */ async function cancelCheck(checkId) { return ctx.service.systems.stockCheck.cancel({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, }); } /** * 业务层:审核任务。 * * @param {number} checkId 盘点任务ID。 * @param {string} action approve/reject。 * @param {string} [reason] 驳回原因。 * @return {Promise} 审核结果。 */ async function auditCheck(checkId, action, reason) { return ctx.service.systems.stockCheck.audit({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, action, reason, }); } /** * 取测试仓库内 N 个分区有效(zone 存在未删除)的库位,供多库位上报用例使用。 * * @param {number} count 需要的库位数量。 * @return {Promise>} [{ id, space_code }](按 id 升序,过滤空编码)。 */ async function fetchValidLocations(count = 3) { const rows = await ctx.model.LocationSpace.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID }, attributes: [ 'id', 'space_code' ], include: [{ model: ctx.model.LocationZone, as: 'zone', attributes: [], required: true, }], order: [[ 'id', 'ASC' ]], limit: count + 20, raw: true, }); return rows .filter(row => String(row.space_code || '').trim()) .slice(0, count) .map(row => ({ id: Number(row.id), space_code: String(row.space_code).trim() })); } /** * 解析上报应携带的 space_id(库位ID):就近取「本仓库 + 分区有效」的库位行。 * report 已改为 space_id 必传,测试通过本函数模拟调用方从取回数据中拿到的库位ID。 * * @param {number} detailId 盘点明细ID。 * @param {string} [location] 上报库位编码。 * @return {Promise} 库位ID(解析不到返回 0)。 */ async function resolveReportSpaceId(detailId, location) { const { Op } = ctx.app.Sequelize; const code = location !== undefined && location !== null ? String(location).trim() : ''; const validZoneInclude = [{ model: ctx.model.LocationZone, as: 'zone', attributes: [], required: true, }]; if (code) { const row = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: code }, attributes: [ 'id' ], include: validZoneInclude, order: [[ 'id', 'ASC' ]], raw: true, }); return row ? Number(row.id) : 0; } const detail = await ctx.model.StockCheckDetail.findOne({ where: { id: Number(detailId), warehouse_id: { [Op.or]: [ TEST_WAREHOUSE_ID, OTHER_TEST_WAREHOUSE_ID ] } }, attributes: [ 'location_id', 'location_code', 'warehouse_id' ], raw: true, }); if (!detail) { return 0; } const candidateIds = []; if (Number(detail.location_id) > 0) { candidateIds.push(Number(detail.location_id)); } const detailCode = String(detail.location_code || '').trim(); if (detailCode) { const rows = await ctx.model.LocationSpace.findAll({ where: { warehouse_id: Number(detail.warehouse_id), space_code: detailCode }, attributes: [ 'id' ], include: validZoneInclude, order: [[ 'id', 'ASC' ]], raw: true, }); for (const row of rows) { if (!candidateIds.includes(Number(row.id))) { candidateIds.push(Number(row.id)); } } } if (candidateIds.length === 0) { return 0; } const validRow = await ctx.model.LocationSpace.findOne({ where: { id: { [Op.in]: candidateIds } }, attributes: [ 'id' ], include: validZoneInclude, order: [[ 'id', 'ASC' ]], raw: true, }); return validRow ? Number(validRow.id) : 0; } /** * 业务层:盘点作业上报。 * space_id 必传(report 强制要求):未显式传 options.spaceId 时按上报库位编码/明细库位自动解析。 * * @param {number} checkId 盘点任务ID。 * @param {number} detailId 明细ID。 * @param {number} quantity 实盘数量。 * @param {string} [location] 库位编码。 * @param {Object} [options] 覆盖项(spaceId/stockId/barcode/itemName/checkerId/checkerName/is_empty; * spaceId 显式传 0/null 表示「不携带库位ID」用于 400 用例; * 库位行必传 stockId 或 barcode(或 is_empty=true 空库位标记),itemName 为未知商品名称快照)。 * @return {Promise} 上报结果(含新增作业记录 record 与主表汇总)。 */ async function reportCheck(checkId, detailId, quantity, location, options = {}) { const spaceId = options.spaceId !== undefined ? options.spaceId : await resolveReportSpaceId(detailId, location); return ctx.service.systems.stockCheck.report({ warehouseId: options.warehouseId !== undefined ? options.warehouseId : TEST_WAREHOUSE_ID, id: checkId, detailId, quantity, location, spaceId, stockId: options.stockId, barcode: options.barcode, itemName: options.itemName, is_empty: options.is_empty, checkerId: options.checkerId !== undefined ? options.checkerId : TEST_CREATOR_ID, checkerName: options.checkerName !== undefined ? options.checkerName : TEST_CREATOR_NAME, }); } /** * 业务层:完成盘点。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} 完成结果。 */ async function finishCheck(checkId) { return ctx.service.systems.stockCheck.finish({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, }); } /** * 业务层:查询列表。 * * @param {Object} [params] 查询参数。 * @return {Promise} 列表结果。 */ async function listChecks(params = {}) { return ctx.service.systems.stockCheck.list({ warehouseId: TEST_WAREHOUSE_ID, ...params, }); } /** * 业务层:查询任务详情(主表信息 + 全部明细范围行)。 * detail 接口只返回任务本身信息({ check });明细范围行改由直查明细表补齐 * (等价于原 detail.rows 的纯范围行口径),供用例获取明细 ID / 快照字段使用。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} { check, rows, total }。 */ async function detailCheck(checkId) { const { check } = await ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, }); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: checkId, warehouse_id: TEST_WAREHOUSE_ID }, order: [[ 'id', 'ASC' ]], raw: true, }); return { check, rows, total: rows.length }; } /** * 业务层:查询盘点结果聚合(范围行 + 作业记录聚合)。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} { check, rows, total }。 */ async function resultCheck(checkId) { return ctx.service.systems.stockCheck.result({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, }); } /** * 业务层:拉取盘点作业数据(视图由任务类型与 is_goods 驱动)。 * * @param {number} checkId 盘点任务ID。 * @param {Object} [options] 可选参数 { isGoods, keyword, onlyAbnormal, pagination }。 * @return {Promise} { view, rows, total, page, pageSize }。 */ async function workDataCheck(checkId, options = {}) { const extraParams = options && typeof options === 'object' ? options : {}; return ctx.service.systems.stockCheck.workData({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, ...extraParams, }); } /** * 业务层:拉取盘点作业数据明细(库位明细单行 / 商品钻取)。 * * @param {number|Object} input 明细ID(数字)或 { id, stockId, detailId } 参数对象。 * @return {Promise} 库位单行或商品 { check_id, stock_id, summary, rows }。 */ async function workDataDetailCheck(input) { const params = input !== null && typeof input === 'object' ? input : { detailId: input }; return ctx.service.systems.stockCheck.workDataDetail({ warehouseId: TEST_WAREHOUSE_ID, ...params, }); } /** * 读取主表最新状态。 * * @param {number} checkId 盘点任务ID。 * @return {Promise} 主表行(plain)。 */ async function findCheckRow(checkId) { const row = await ctx.model.StockCheck.findOne({ where: { id: Number(checkId) }, }); return row ? row.get({ plain: true }) : null; } /** * 直插主表 created_at(造不同创建时间的历史任务,供 created_at 范围筛选用例使用)。 * * @param {number} checkId 盘点任务ID。 * @param {Date} createdAt 目标创建时间。 * @return {Promise} 更新后的主表行(plain)。 */ async function setCheckCreatedAt(checkId, createdAt) { await ctx.model.StockCheck.update( { created_at: createdAt }, { where: { id: Number(checkId) } } ); return findCheckRow(checkId); } /** * 查询盘点作业记录(wms_stock_check_record)。 * * @param {number} checkId 盘点任务ID。 * @param {number} [detailId] 明细ID(可选,用于限定某条明细)。 * @return {Promise>} 作业记录行(plain,按 id 升序)。 */ async function queryRecords(checkId, detailId) { const where = { check_id: Number(checkId) }; if (detailId !== undefined) { where.detail_id = Number(detailId); } return ctx.model.StockCheckRecord.findAll({ where, order: [[ 'id', 'ASC' ]], raw: true, }); } /** * 业务层:删除作业记录(批量:单值自动转数组,未命中计入 skipped_ids 不报错)。 * * @param {number} checkId 盘点任务ID。 * @param {Array|number} recordIds 作业记录ID(单值或数组,单次上限 200)。 * @return {Promise} 删除结果(含重算后的汇总)。 */ async function deleteRecord(checkId, recordIds) { return ctx.service.systems.stockCheck.recordDelete({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, recordIds, }); } /** * 业务层:删除盘点明细(批量:单值自动转数组,未命中计入 skipped_ids 不报错)。 * * @param {number} checkId 盘点任务ID。 * @param {Array|number} detailIds 盘点明细ID(单值或数组,单次上限 200)。 * @return {Promise} { deleted_count, deleted_ids, skipped_ids, total_items }。 */ async function deleteDetail(checkId, detailIds) { return ctx.service.systems.stockCheck.detailDelete({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, detailIds, }); } /** * 业务层:删除盘点明细(原始参数透传,用于参数校验场景)。 * * @param {Object} params 删除参数(自动注入固定测试仓库)。 * @return {Promise} { deleted_count, deleted_ids, skipped_ids, total_items }。 */ async function deleteDetailRaw(params = {}) { return ctx.service.systems.stockCheck.detailDelete({ warehouseId: TEST_WAREHOUSE_ID, ...params, }); } /** * 业务层:查询作业记录列表。 * * @param {Object} [params] 查询参数(id/detailId/pagination)。 * @return {Promise} { rows, total, page, pageSize }。 */ async function listRecords(params = {}) { return ctx.service.systems.stockCheck.recordList({ warehouseId: TEST_WAREHOUSE_ID, ...params, }); } /** * 业务层:批量删除盘点任务(固定测试仓库)。 * * @param {Array|number} ids 盘点任务ID(数组或单值)。 * @return {Promise} { total, deleted_count, skipped_count, deleted_ids, skipped_ids }。 */ async function batchDeleteCheck(ids) { return ctx.service.systems.stockCheck.batchDelete({ warehouseId: TEST_WAREHOUSE_ID, ids, }); } /** * 业务层:批量删除盘点任务(原始参数透传,用于参数校验场景)。 * * @param {Object} params 批量删除参数。 * @return {Promise} { total, deleted_count, skipped_count, deleted_ids, skipped_ids }。 */ async function batchDeleteRaw(params = {}) { return ctx.service.systems.stockCheck.batchDelete(params); } /** * 取一个当前库中不存在的盘点任务 ID(基于主表最大 ID 偏移,避免误删历史数据)。 * * @return {Promise} 不存在的主键 ID。 */ async function findFreeCheckId() { const row = await ctx.model.StockCheck.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); return (row ? Number(row.id) : 0) + 1000000; } /** * 取一个当前库中不存在的盘点明细 ID(基于明细表最大 ID 偏移,避免误删历史数据)。 * * @return {Promise} 不存在的主键 ID。 */ async function findFreeDetailId() { const row = await ctx.model.StockCheckDetail.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); return (row ? Number(row.id) : 0) + 1000000; } /** * 创建一条已作废的盘点任务(含 1 条商品明细,status=cancelled)。 * * @return {Promise} { check, stock }。 */ async function createCancelledCheck() { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await cancelCheck(check.id); return { check, stock: stocks[0] }; } /** * 构造商品条码(wms_stock_barcodes,固定测试仓库,条码值唯一)。 * * @param {number} stockId 商品库存ID(wms_stock_warehouse.id,需属于测试仓库)。 * @param {string} [barcode] 条码值(缺省自动生成唯一条码)。 * @return {Promise} { barcode, stockBarcode }。 */ async function createStockBarcode(stockId, barcode) { const barcodeValue = barcode || uniqueTitle('TEST-BARCODE'); const stockBarcode = await ctx.model.StockBarcode.create({ stock_id: Number(stockId), warehouse_id: TEST_WAREHOUSE_ID, barcode: barcodeValue, description: '盘点未知商品测试条码', create_time: new Date(), }); return { barcode: barcodeValue, stockBarcode }; } /** * 为作业记录挂载图片(图片独立维护口径:wms_file + wms_file_reference, * business_type=stock_check_record、business_id=记录ID)。 * * @param {number} recordId 作业记录ID。 * @return {Promise} { file, reference }。 */ async function createRecordImage(recordId) { const token = uniqueTitle('img'); const file = await ctx.model.File.create({ warehouse_id: TEST_WAREHOUSE_ID, file_key: `test/stock_check/${token}.jpg`, file_url: `https://img.test.local/${token}.jpg`, file_name: `${token}.jpg`, file_size: 1024, file_type: 'stock_check_image', mime_type: 'image/jpeg', md5_hash: crypto.createHash('md5').update(token).digest('hex'), sha1_hash: crypto.createHash('sha1').update(token).digest('hex'), storage_mode: 'cos', uploader_id: String(TEST_CREATOR_ID), uploader_name: TEST_CREATOR_NAME, created_at: new Date(), }); const reference = await ctx.model.FileReference.create({ file_id: file.id, warehouse_id: TEST_WAREHOUSE_ID, business_type: 'stock_check_record', business_id: String(recordId), display_order: 0, created_by: String(TEST_CREATOR_ID), created_at: new Date(), }); return { file, reference }; } // ------------------- create:创建盘点任务 ------------------- describe('create 创建盘点任务', () => { it('生成 PD+YYYYMMDD+6位序号单号,初始状态 created', async () => { const result = await createCheck(); assert.match(result.check_no, /^PD\d{14}$/, `单号格式应为 PD+YYYYMMDD+6位序号: ${result.check_no}`); assert.ok(result.check_no.startsWith(`PD${currentDatePart()}`), '单号日期部分应为当前日期'); assert.equal(result.status, 'created'); assert.equal(result.detail_status, 'none_checked'); assert.equal(result.total_items, 0); assert.equal(result.checked_items, 0); const row = await findCheckRow(result.id); assert.equal(row.warehouse_id, TEST_WAREHOUSE_ID, '主表应写入固定测试仓库 ID'); assert.equal(row.check_no, result.check_no); }); it('同仓库连续创建序号递增', async () => { const first = await createCheck(); const second = await createCheck(); const firstSeq = Number(first.check_no.slice(-6)); const secondSeq = Number(second.check_no.slice(-6)); assert.equal(secondSeq, firstSeq + 1, `序号应连续递增: ${first.check_no} -> ${second.check_no}`); }); it('跨仓库创建序号全局递增:另一仓库单号接续本仓库序号', async () => { const first = await createCheck(); const second = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); const firstSeq = Number(first.check_no.slice(-6)); const secondSeq = Number(second.check_no.slice(-6)); assert.equal( secondSeq, firstSeq + 1, `跨仓库序号应接续递增(不按仓库隔离): ${first.check_no} -> ${second.check_no}` ); const secondRow = await ctx.model.StockCheck.findOne({ where: { id: second.id }, raw: true, }); assert.equal(Number(secondRow.warehouse_id), OTHER_TEST_WAREHOUSE_ID, '第二个任务应写入另一测试仓库'); }); it('单号撞 uk_check_no 唯一键自动重取:创建成功且取到下一号', async () => { const service = ctx.service.systems.stockCheck; const expectedNo = await service.generateCheckNo(); const expectedSeq = Number(expectedNo.slice(-6)); // 预插入同前缀同序号单号,模拟并发创建先占号 const occupied = await ctx.model.StockCheck.create({ warehouse_id: OTHER_TEST_WAREHOUSE_ID, check_no: expectedNo, title: uniqueTitle('盘点单元测试-撞号占位'), type: 'location', mode: 'blind', status: 'created', detail_status: 'none_checked', creator_id: TEST_CREATOR_ID, creator_name: TEST_CREATOR_NAME, }); assert.equal(occupied.check_no, expectedNo, '占位单号应等于预取单号'); // 模拟并发撞号:首次取号强制返回已占用单号,随后恢复真实取号逻辑, // 使 create 的第一次 INSERT 真实触发 uk_check_no 冲突并进入重试。 const originalGenerate = service.generateCheckNo.bind(service); let generateCalls = 0; mm(service, 'generateCheckNo', async () => { generateCalls += 1; if (generateCalls === 1) { return expectedNo; } return originalGenerate(); }); const created = await createCheck(); mm.restore(); assert.equal(generateCalls, 2, '撞号后应重新取号一次(第一次撞号、第二次成功)'); const createdSeq = Number(created.check_no.slice(-6)); assert.equal( createdSeq, expectedSeq + 1, `撞号后应自动重取下一号: ${expectedNo} -> ${created.check_no}` ); const rowCount = await ctx.model.StockCheck.count({ where: { check_no: created.check_no } }); assert.equal(rowCount, 1, '重取后的单号应正常落库且全局唯一'); }); it('isCheckNoDuplicateError:仅 ER_DUP_ENTRY 且命中 check_no 唯一索引判为撞号', () => { const service = ctx.service.systems.stockCheck; const dupError = new Error('insert duplicate'); dupError.parent = { code: 'ER_DUP_ENTRY', sqlMessage: "Duplicate entry 'PD20260929000001' for key 'wms_stock_check.uk_check_no'", }; assert.equal(service.isCheckNoDuplicateError(dupError), true, 'uk_check_no 唯一键冲突应判定为撞号'); const primaryError = new Error('insert duplicate'); primaryError.parent = { code: 'ER_DUP_ENTRY', sqlMessage: "Duplicate entry '1' for key 'PRIMARY'" }; assert.equal(service.isCheckNoDuplicateError(primaryError), false, '主键冲突不应判定为撞号'); const deadlockError = new Error('deadlock'); deadlockError.parent = { code: 'ER_LOCK_DEADLOCK', sqlMessage: 'Deadlock found' }; assert.equal(service.isCheckNoDuplicateError(deadlockError), false, '其他错误码不应判定为撞号'); const noParentError = new Error("Duplicate entry for key 'uk_check_no'"); assert.equal(service.isCheckNoDuplicateError(noParentError), false, '缺少 parent 元数据不应判定为撞号'); }); it('非法 type/mode 或按货主缺货主时报 400(check_date 已移除入参)', async () => { await assert.rejects(async () => { await createCheck({ type: 'bad_type' }); }, error => error.code === 400); await assert.rejects(async () => { await createCheck({ mode: 'bad_mode' }); }, error => error.code === 400); await assert.rejects(async () => { await createCheck({ type: 'store', storeId: null }); }, error => error.code === 400); }); it('create 不写 check_date:返回与主表均不含该字段,start_time/end_time 初始为空', async () => { const result = await createCheck(); assert.equal(result.status, 'created'); assert.equal( Object.prototype.hasOwnProperty.call(result, 'check_date'), false, 'create 返回结果不应含 check_date 字段' ); const row = await findCheckRow(result.id); assert.equal( Object.prototype.hasOwnProperty.call(row, 'check_date'), false, '主表行不应含 check_date 字段' ); assert.equal(row.start_time, null, '创建时 start_time 应为空(首次上报明细才写入)'); assert.equal(row.end_time, null, '创建时 end_time 应为空(完成盘点才写入)'); }); it('type=location 传 mode=open:按库位盘点一律盲盘,忽略前端传入', async () => { const result = await createCheck({ type: 'location', mode: 'open' }); assert.equal(result.mode, 'blind', '按库位盘点应强制盲盘,忽略前端传入的 mode=open'); const row = await findCheckRow(result.id); assert.equal(row.mode, 'blind', '主表应落库 blind'); }); it('type=all 已下线:创建报 400(全盘语义并入 location)', async () => { await assert.rejects(async () => { await createCheck({ type: 'all' }); }, error => error.code === 400 && /盘点范围类型不合法/.test(error.message)); }); it('type=goods 传 mode=blind:按商品盘点保留传入值', async () => { const result = await createCheck({ type: 'goods', mode: 'blind' }); assert.equal(result.mode, 'blind', '按商品盘点应保留传入的 mode=blind'); const row = await findCheckRow(result.id); assert.equal(row.mode, 'blind', '主表应落库 blind'); }); it('type=store 不传 mode:按商品盘点默认明盘 open', async () => { // 业务层直调且不传 mode,验证默认明盘(绕过 createCheck 辅助函数的 mode 兜底) const result = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('盘点单元测试-货主默认明盘'), type: 'store', storeId: TEST_STORE_ID, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); assert.equal(result.mode, 'open', '按货主盘点不传 mode 应默认明盘 open'); const row = await findCheckRow(result.id); assert.equal(row.mode, 'open', '主表应落库 open'); }); it('is_static 静态标记:缺省 0、传 1/true 落库 1、兼容 isStatic 驼峰与 list/detail 返回、库位盘点强制 0', async () => { // 缺省不传 → 普通盘点 const normal = await createCheck({ title: uniqueTitle('静态标记-缺省') }); assert.equal(Number(normal.is_static), 0, '缺省应为普通盘点(0)'); assert.equal(Number((await findCheckRow(normal.id)).is_static), 0, '主表应落库 0'); // 业务层传 isStatic=1 → 静态盘点 const staticCheck = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态标记-开启'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); assert.equal(Number(staticCheck.is_static), 1, '传 isStatic=1 应返回 is_static=1'); assert.equal(Number((await findCheckRow(staticCheck.id)).is_static), 1, '主表应落库 1'); // detail 返回该字段 const detail = await ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: staticCheck.id, }); assert.equal(Number(detail.check.is_static), 1, 'detail 应返回 is_static'); // list 返回该字段 const listResult = await listChecks({ pagination: { page: 1, pageSize: 200 } }); const listed = listResult.rows.find(row => Number(row.id) === Number(staticCheck.id)); assert.ok(listed, '前置:list 应能查到该任务'); assert.equal(Number(listed.is_static), 1, 'list 行应返回 is_static'); // 方法层兼容 is_static 下划线与 isStatic 驼峰两种写法(需仓库上下文,临时设置 ctx.user) const previousUser = ctx.user; ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; try { const viaMethodSnake = await ctx.service.systemMethods.stock.check.create({ title: uniqueTitle('静态标记-方法层下划线'), type: 'goods', is_static: 1, }); assert.equal(viaMethodSnake.flag, 'success'); assert.equal(Number(viaMethodSnake.data.is_static), 1, '方法层 is_static 应透传'); const viaMethodCamel = await ctx.service.systemMethods.stock.check.create({ title: uniqueTitle('静态标记-方法层驼峰'), type: 'goods', isStatic: 'true', }); assert.equal(viaMethodCamel.flag, 'success'); assert.equal(Number(viaMethodCamel.data.is_static), 1, "方法层 isStatic='true' 应透传"); } finally { ctx.user = previousUser; } // 其他值(0/'false'/空串)视为普通盘点 for (const value of [ 0, 'false', '', false ]) { const created = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle(`静态标记-非开启-${String(value)}`), type: 'goods', isStatic: value, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); assert.equal(Number(created.is_static), 0, `isStatic=${JSON.stringify(value)} 应为普通盘点`); } // 仅对商品盘点有效:按库位盘点(location)即使传 isStatic=1 也一律 0 for (const value of [ 1, true, 'true' ]) { const locationCheck = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle(`静态标记-库位盘点-${String(value)}`), type: 'location', isStatic: value, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); assert.equal(Number(locationCheck.is_static), 0, `按库位盘点传 isStatic=${JSON.stringify(value)} 应强制为 0`); assert.equal(Number((await findCheckRow(locationCheck.id)).is_static), 0, '库位盘点主表应落库 0'); } }); }); // ------------------- addDetail:添加盘点明细 ------------------- describe('addDetail 添加盘点明细', () => { it('按 stock_ids 生成明细快照(item_code/item_name/spec/system_quantity)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); const stockIds = stocks.map(stock => stock.id); const result = await addDetail(check.id, stockIds); assert.equal(result.added, 2); assert.equal(result.skipped, 0); assert.equal(result.total_items, 2); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, order: [[ 'id', 'ASC' ]], raw: true, }); assert.equal(rows.length, 2); for (const row of rows) { const stock = stocks.find(item => item.id === Number(row.stock_id)); assert.ok(stock, `明细应命中库存快照 stock_id=${row.stock_id}`); assert.equal(row.item_code, stock.item_code, 'item_code 快照不一致'); assert.equal(row.item_name, stock.item_name, 'item_name 快照不一致'); assert.equal(row.spec, stock.sku_property, 'spec 应快照 sku_property'); // 拆行口径:system_quantity = 该商品在其库存库位的账面(wms_storage SUM(可用数量)) const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, stock_id: Number(row.stock_id), space_id: Number(row.location_id), is_enabled: 1, }, raw: true, }); const expectedSystemQuantity = storageRows.reduce( (sum, item) => sum + (Number(item.available_quantity) || 0), 0 ); assert.equal(Number(row.system_quantity), expectedSystemQuantity, 'system_quantity 应为该库位账面'); assert.equal(row.batch_no, null, '批次快照默认应为空'); } // 明细范围行由直查明细表校验(detail 接口只返回任务本身信息):商品行 scope_type=goods 且绑定库存库位 const detailResult = await detailCheck(check.id); assert.equal(detailResult.total, 2); for (const row of detailResult.rows) { assert.equal(row.scope_type, 'goods', '商品明细 scope_type 应为 goods'); assert.ok(row.stock_id, '商品明细应含 stock_id'); assert.ok(row.location_id, '商品明细应绑定库存库位'); assert.ok(row.location_code, '商品明细应绑定库位编码'); } // 盘点前(无作业记录):result 直接返回明细范围行(wms_stock_check_detail) const checkResult = await resultCheck(check.id); assert.equal(checkResult.total, 2); for (const row of checkResult.rows) { assert.equal(row.scope_type, 'goods'); assert.ok(row.stock_id, '明细行应含 stock_id'); assert.ok(row.location_code, '明细行应含库位编码'); assert.ok(Number(row.system_quantity) >= 0, '明细行应含账面快照'); } const recordCount = await ctx.model.StockCheckRecord.count({ where: { check_id: check.id }, }); assert.equal(recordCount, 0, '添加明细阶段不应写作业记录'); }); it('重复添加同一 stock_id 幂等跳过,不重复生成明细', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); const stockIds = stocks.map(stock => stock.id); const first = await addDetail(check.id, stockIds); const second = await addDetail(check.id, stockIds); assert.equal(first.added, 2); assert.equal(second.added, 0); assert.equal(second.skipped, 2); const count = await ctx.model.StockCheckDetail.count({ where: { check_id: check.id }, }); assert.equal(count, 2, '重复添加不应生成多余明细'); }); it('多库位商品按「商品 + 库位」拆多行,各行账面为该库位库存', async () => { const { Op, literal } = ctx.app.Sequelize; // 找一个在两个启用库位都有库存的商品 const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, }, attributes: [ 'stock_id', 'space_id', [ literal('SUM(available_quantity)'), 'totalQuantity' ]], group: [ 'stock_id', 'space_id' ], raw: true, }); const spacesByStock = new Map(); for (const row of storageRows) { const stockId = Number(row.stock_id); if (!spacesByStock.has(stockId)) { spacesByStock.set(stockId, []); } spacesByStock.get(stockId).push(row); } const multiStockEntry = [ ...spacesByStock.entries() ].find(([ , rows ]) => rows.length >= 2); assert.ok(multiStockEntry, '前置:测试库应存在多库位库存商品'); const multiStockId = Number(multiStockEntry[0]); const multiStock = await ctx.model.StockWarehouse.findOne({ where: { id: multiStockId, warehouse_id: TEST_WAREHOUSE_ID }, raw: true, }); assert.ok(multiStock, '前置:多库位商品应存在于 wms_stock_warehouse'); const check = await createCheck({ type: 'goods', storeId: multiStock.store_id || null }); const result = await addDetail(check.id, [ multiStockId ]); assert.equal(result.added, multiStockEntry[1].length, 'added 应为拆分明细行数(商品按库位拆多行)'); assert.equal(result.total_items, 1, '按商品盘点 total_items 按商品计数(多库位拆多行仍计 1 项)'); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, order: [[ 'id', 'ASC' ]], raw: true, }); assert.equal(rows.length, multiStockEntry[1].length); const spaceIds = rows.map(row => Number(row.location_id)).sort((a, b) => a - b); assert.deepEqual( spaceIds, multiStockEntry[1].map(row => Number(row.space_id)).sort((a, b) => a - b), '明细行应覆盖商品全部库存库位' ); const quantityBySpace = new Map(multiStockEntry[1].map(row => [ Number(row.space_id), Number(row.totalQuantity) || 0 ])); for (const row of rows) { assert.equal(Number(row.system_quantity), quantityBySpace.get(Number(row.location_id)), '各行账面应为该库位库存'); assert.ok(row.location_code, '各行应绑定库位编码'); } // 拆行任务可正常提交 const submitResult = await submitCheck(check.id); assert.equal(submitResult.status, 'submitted'); }); it('商品在仓库中没有启用库存库位 → 计入 invalid_stock_ids 不入明细', async () => { const check = await createCheck(); // 构造无库存库位的商品(只写 wms_stock_warehouse,不写 wms_storage) const [ fabricatedResult ] = await ctx.model.query( `INSERT INTO wms_stock_warehouse (item_code, item_name, store_id, stock_unit, item_type, create_at, warehouse_id, is_valid, quantity, is_shelf_life_mgmt, remaining_threshold_days) VALUES (:itemCode, '盘点拆行测试商品', :storeId, '个', 'normal', NOW(), :warehouseId, 'Y', 3, 'N', 0)`, { replacements: { itemCode: `PATT-NOLOC-${Date.now()}`, storeId: TEST_STORE_ID, warehouseId: TEST_WAREHOUSE_ID, }, type: ctx.model.QueryTypes.INSERT, } ); const fabricatedId = Number(fabricatedResult); const validStocks = await fetchStockRows(1); const result = await addDetail(check.id, [ validStocks[0].id, fabricatedId ]); assert.equal(result.added, 1, '仅有效商品入明细'); assert.deepEqual(result.invalid_stock_ids, [ fabricatedId ], '无库存库位商品应计入 invalid_stock_ids'); assert.equal(result.total_items, 1); }); it('不存在的 stock_id 计入 invalid_stock_ids,不影响有效明细', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); const result = await addDetail(check.id, [ stocks[0].id, 999999999 ]); assert.equal(result.added, 1); assert.deepEqual(result.invalid_stock_ids, [ 999999999 ]); assert.equal(result.total_items, 1); }); it('空 stock_ids 报 400', async () => { const check = await createCheck(); await assert.rejects(async () => { await addDetail(check.id, []); }, error => error.code === 400); }); it('submitted 状态不允许添加明细,报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await assert.rejects(async () => { await addDetail(check.id, [ stocks[0].id ]); }, error => error.code === 400); }); }); // ------------------- addDetail:盘点范围类型分派(商品/库位维度互斥) ------------------- describe('addDetail 盘点范围类型分派', () => { it('goods/store 类型传 locations 报 400(商品与库位维度互斥)', async () => { const goodsCheck = await createCheck({ type: 'goods' }); await assert.rejects(async () => { await addDetailRaw({ id: goodsCheck.id, locations: [ TEST_LOCATION_CODE ] }); }, error => error.code === 400 && /按商品盘点/.test(error.message)); const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); await assert.rejects(async () => { await addDetailRaw({ id: storeCheck.id, locations: [ TEST_LOCATION_CODE ] }); }, error => error.code === 400 && /按商品盘点/.test(error.message)); }); it('location 类型传 stock_ids 报 400(库位与商品维度互斥)', async () => { const stocks = await fetchStockRows(1); const locationCheck = await createCheck({ type: 'location' }); await assert.rejects(async () => { await addDetailRaw({ id: locationCheck.id, stockIds: [ stocks[0].id ] }); }, error => error.code === 400 && /按库位盘点/.test(error.message)); }); it('type=location 缺省 locations 自动生成全仓库启用库位明细(排除无头库位),重复添加全部幂等跳过', async () => { const check = await createCheck({ type: 'location' }); // 有效库位口径:启用且所属 zone 存在未删除(与业务排除无头库位口径一致) const enabledSpaces = await ctx.model.LocationSpace.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: true }, attributes: [ 'space_code' ], include: [{ model: ctx.model.LocationZone, as: 'zone', attributes: [], required: true, }], order: [[ 'id', 'ASC' ]], raw: true, }); const enabledCount = new Set(enabledSpaces .map(row => String(row.space_code || '').trim()) .filter(Boolean)).size; assert.ok(enabledCount > 0, '固定测试仓库应存在启用库位'); const result = await addLocationDetail(check.id, undefined); assert.equal(result.added, enabledCount, '自动生成的明细数应等于全仓库启用库位数'); assert.equal(result.skipped, 0); assert.deepEqual(result.invalid_locations, []); assert.deepEqual(result.invalid_stock_ids, []); assert.equal(result.total_items, enabledCount); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, order: [[ 'id', 'ASC' ]], raw: true, }); assert.equal(rows.length, enabledCount); for (const row of rows) { assert.equal(row.scope_type, 'location', '全盘自动生成的明细应为库位行'); assert.equal(row.stock_id, null, '库位行不应写商品 ID'); assert.equal(row.item_code, null, '库位行不应写商品编码快照'); assert.equal(Number(row.system_quantity), 0, '库位行账面快照固定为 0'); assert.ok(row.location_code, '库位行应写库位编码'); assert.ok(row.location_id, '库位行应写库位 ID'); } const testLocationRow = rows.find(row => row.location_code === TEST_LOCATION_CODE); assert.ok(testLocationRow, '固定测试库位应包含在自动生成明细中'); assert.equal(Number(testLocationRow.location_id), TEST_LOCATION_ID); // 幂等:再次缺省添加 → 全部跳过,不重复生成明细 const again = await addLocationDetail(check.id, undefined); assert.equal(again.added, 0); assert.equal(again.skipped, enabledCount); assert.equal(again.total_items, enabledCount); }); it('历史遗留 type=all 任务拒绝添加明细:报 400(all 已下线,防御脏数据)', async () => { const legacyCheck = await ctx.model.StockCheck.create({ warehouse_id: TEST_WAREHOUSE_ID, check_no: `DIA${Date.now()}`, title: uniqueTitle('盘点单元测试-历史all任务'), type: 'all', mode: 'blind', status: 'created', detail_status: 'none_checked', creator_id: TEST_CREATOR_ID, creator_name: TEST_CREATOR_NAME, }); await assert.rejects(async () => { await addLocationDetail(legacyCheck.id, [ TEST_LOCATION_CODE ]); }, error => error.code === 400 && /盘点范围类型不合法/.test(error.message)); }); it('库位添加:有效编码落库 scope_type/location 字段、无效编码计入 invalid_locations、重复添加幂等跳过', async () => { const check = await createCheck({ type: 'location' }); const first = await addLocationDetail(check.id, [ TEST_LOCATION_CODE, 'NOT_EXIST_SPACE_999' ]); assert.equal(first.added, 1); assert.equal(first.skipped, 0); assert.deepEqual(first.invalid_locations, [ 'NOT_EXIST_SPACE_999' ], '未匹配编码应计入非法库位'); assert.deepEqual(first.invalid_stock_ids, []); assert.equal(first.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1, '非法库位不应落库'); assert.equal(rows[0].scope_type, 'location'); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '库位行应落库 location_id'); assert.equal(rows[0].location_code, TEST_LOCATION_CODE, '库位行应落库 location_code'); assert.equal(rows[0].stock_id, null); assert.equal(rows[0].item_code, null); assert.equal(Number(rows[0].system_quantity), 0); const second = await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); assert.equal(second.added, 0); assert.equal(second.skipped, 1, '同库位重复添加应幂等跳过'); assert.equal(second.total_items, 1); const count = await ctx.model.StockCheckDetail.count({ where: { check_id: check.id }, }); assert.equal(count, 1, '重复添加不应生成多余明细'); }); it('无头库位(所属 zone 不存在)计入 invalid_locations 且不入库', async () => { // fixture:造一个 zone 不存在的库位(zone_id 无外键约束,模拟无头库位) const headless = await ctx.model.LocationSpace.create({ warehouse_id: TEST_WAREHOUSE_ID, zone_id: 999999999, location_type_id: 1, space_code: 'HDLS-TEST-001', }); try { const check = await createCheck({ type: 'location' }); const result = await addLocationDetail(check.id, [ TEST_LOCATION_CODE, 'HDLS-TEST-001' ]); assert.equal(result.added, 1, '仅有效库位应入库'); assert.deepEqual(result.invalid_locations, [ 'HDLS-TEST-001' ], '无头库位应计入 invalid_locations'); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true }); assert.equal(rows.length, 1, '无头库位不应落库'); assert.equal(rows[0].location_code, TEST_LOCATION_CODE); } finally { await ctx.model.LocationSpace.destroy({ where: { id: headless.id }, force: true }); } }); it('按货主盘点:任务货主与商品货主不一致计入 invalid_stock_ids 且不入库', async () => { const check = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); const stocks = await fetchStockRows(1); const foreignStock = await fetchOtherStoreStockRow(); assert.ok(foreignStock, '固定测试仓库应存在其他货主的商品(货主隔离校验依赖)'); const result = await addDetail(check.id, [ stocks[0].id, foreignStock.id ]); assert.equal(result.added, 1, '仅任务货主商品应入库'); assert.deepEqual(result.invalid_stock_ids, [ Number(foreignStock.id) ], '其他货主商品应计入非法列表'); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1, '其他货主商品不应生成明细'); assert.equal(Number(rows[0].stock_id), stocks[0].id); }); }); // ------------------- addDetail:location_ids 库位ID直查(新增入参) ------------------- describe('addDetail location_ids 库位ID直查', () => { it('type=location 传 location_ids:按 ID 直查落库 scope_type=location 行,invalid_location_ids=[]', async () => { const check = await createCheck({ type: 'location' }); const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); assert.equal(result.added, 1); assert.equal(result.skipped, 0); assert.deepEqual(result.invalid_location_ids, [], '有效库位ID不应计入非法列表'); assert.deepEqual(result.invalid_locations, []); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1); assert.equal(rows[0].scope_type, 'location', '库位ID直查生成的明细应为库位行'); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '库位行应落库 location_id'); assert.equal(rows[0].location_code, TEST_LOCATION_CODE, '库位行应落库 location_code'); assert.equal(rows[0].stock_id, null); assert.equal(rows[0].item_code, null); assert.equal(Number(rows[0].system_quantity), 0); }); it('type=location 传 location_ids:只添加指定库位,不触发全盘自动生成', async () => { const check = await createCheck({ type: 'location' }); const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); assert.equal(result.added, 1); assert.equal(result.skipped, 0); assert.deepEqual(result.invalid_location_ids, []); assert.equal(result.total_items, 1, '显式传库位ID时不应按全盘自动生成全部启用库位'); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); assert.equal(rows[0].location_code, TEST_LOCATION_CODE); }); it('location_ids 与 locations 同传:location_ids 优先,locations 忽略(无效编码不进 invalid_locations)', async () => { const check = await createCheck({ type: 'location' }); const result = await addDetailRaw({ id: check.id, locations: [ 'NOT_EXIST_SPACE_999' ], locationIds: [ TEST_LOCATION_ID ], }); assert.equal(result.added, 1); assert.equal(result.skipped, 0); assert.deepEqual(result.invalid_location_ids, []); assert.deepEqual(result.invalid_locations, [], 'locations 被忽略时不应解析编码,也不应计入非法库位'); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '应按 location_ids 的库位 ID 落库'); assert.equal(rows[0].location_code, TEST_LOCATION_CODE); }); it('无效 location_id(不存在/其他仓库)计入 invalid_location_ids 且不入库', async () => { const { Op } = ctx.app.Sequelize; const check = await createCheck({ type: 'location' }); // 其他仓库的真实库位 ID:ID 存在但 warehouse_id 不属于当前仓库,应视为无效 const foreignSpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: { [Op.ne]: TEST_WAREHOUSE_ID } }, attributes: [ 'id', 'space_code' ], order: [[ 'id', 'ASC' ]], raw: true, }); assert.ok(foreignSpace, '本地库应存在其他仓库的库位(跨仓库隔离校验依赖)'); const missingLocationId = await fetchMissingLocationId(); const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID, missingLocationId, foreignSpace.id ], }); assert.equal(result.added, 1); assert.equal(result.skipped, 0); assert.deepEqual( result.invalid_location_ids, [ missingLocationId, Number(foreignSpace.id) ], '不存在与其他仓库的库位ID应按入参顺序计入非法列表' ); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1, '无效库位ID不应落库'); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); }); it('无头库位 ID(zone 不存在)计入 invalid_location_ids 且不入库', async () => { // fixture:造一个 zone 不存在的库位(zone_id 无外键约束,模拟无头库位) const headless = await ctx.model.LocationSpace.create({ warehouse_id: TEST_WAREHOUSE_ID, zone_id: 999999999, location_type_id: 1, space_code: 'HDLS-TEST-002', }); try { const check = await createCheck({ type: 'location' }); const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID, headless.id ] }); assert.equal(result.added, 1, '仅有效库位应入库'); assert.deepEqual(result.invalid_location_ids, [ Number(headless.id) ], '无头库位ID应计入非法列表'); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true }); assert.equal(rows.length, 1, '无头库位不应落库'); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); } finally { await ctx.model.LocationSpace.destroy({ where: { id: headless.id }, force: true }); } }); it('幂等:同次重复 ID 去重、重复传同一 location_id 跳过、编码路径已入库后 ID 路径也跳过', async () => { const check = await createCheck({ type: 'location' }); const first = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID, TEST_LOCATION_ID ], }); assert.equal(first.added, 1, '同次调用重复 ID 应去重只新增一次'); assert.equal(first.skipped, 0); assert.equal(first.total_items, 1); const second = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); assert.equal(second.added, 0); assert.equal(second.skipped, 1, '重复传同一 location_id 应幂等跳过'); assert.equal(second.total_items, 1); // 跨路径幂等(uk_check_location 口径):编码路径已入库,再按 ID 添加应跳过 const anotherCheck = await createCheck({ type: 'location' }); await addLocationDetail(anotherCheck.id, [ TEST_LOCATION_CODE ]); const cross = await addDetailRaw({ id: anotherCheck.id, locationIds: [ TEST_LOCATION_ID ] }); assert.equal(cross.added, 0, '编码路径已入库的库位,ID 路径应跳过'); assert.equal(cross.skipped, 1); assert.equal(cross.total_items, 1); const count = await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }); assert.equal(count, 1, '重复添加不应生成多余明细'); }); it('goods/store 类型传 location_ids 报 400(按商品盘点,不能添加库位明细)', async () => { const goodsCheck = await createCheck({ type: 'goods' }); await assert.rejects(async () => { await addDetailRaw({ id: goodsCheck.id, locationIds: [ TEST_LOCATION_ID ] }); }, error => error.code === 400 && /按商品盘点,不能添加库位明细/.test(error.message)); const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); await assert.rejects(async () => { await addDetailRaw({ id: storeCheck.id, locationIds: [ TEST_LOCATION_ID ] }); }, error => error.code === 400 && /按商品盘点,不能添加库位明细/.test(error.message)); }); it('addLocationDetail 兼容入口:转调 addDetail 落库,返回结构不变(过滤 invalid_locations/invalid_stock_ids)', async () => { const check = await createCheck({ type: 'location' }); const missingLocationId = await fetchMissingLocationId(); const result = await addLocationDetailByIds(check.id, [ TEST_LOCATION_ID, missingLocationId ]); assert.deepEqual( Object.keys(result).sort(), [ 'added', 'invalid_location_ids', 'skipped', 'total_items' ].sort(), '兼容入口返回结构应保持不变' ); assert.equal(result.added, 1); assert.equal(result.skipped, 0); assert.deepEqual(result.invalid_location_ids, [ missingLocationId ]); assert.equal(result.total_items, 1); const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true, }); assert.equal(rows.length, 1, '无效库位ID不应落库'); assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); assert.equal(rows[0].location_code, TEST_LOCATION_CODE); }); it('addLocationDetail 参数校验保持旧口径:空库位ID与超 200 上限报 400', async () => { const check = await createCheck({ type: 'location' }); await assert.rejects(async () => { await addLocationDetailByIds(check.id, []); }, error => error.code === 400 && /至少选择一个库位/.test(error.message)); await assert.rejects(async () => { await addLocationDetailByIds(check.id, undefined); }, error => error.code === 400 && /至少选择一个库位/.test(error.message)); const overLimitIds = Array.from({ length: 201 }, (_, index) => index + 1); await assert.rejects(async () => { await addLocationDetailByIds(check.id, overLimitIds); }, error => error.code === 400 && /200/.test(error.message)); }); }); // ------------------- detailDelete:删除盘点明细 ------------------- describe('detailDelete 删除盘点明细', () => { it('created 状态删除 1 条明细(detailIds 单值自动转数组):deleted_count=1、total_items 重算、detail 中该 stock_id 消失', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const before = await detailCheck(check.id); assert.equal(before.total, 2); const deletedDetail = before.rows[0]; const keptDetail = before.rows[1]; const result = await deleteDetail(check.id, deletedDetail.id); assert.equal(result.deleted_count, 1); assert.deepEqual(result.deleted_ids.map(Number), [ Number(deletedDetail.id) ], '返回的明细 ID 应一致'); assert.deepEqual(result.skipped_ids, [], '全部命中不应有跳过明细'); assert.equal(result.total_items, 1, '删除后主表明细数应重算为 1'); const row = await findCheckRow(check.id); assert.equal(row.total_items, 1, '主表 total_items 应同步重算'); const after = await detailCheck(check.id); assert.equal(after.total, 1); assert.ok( !after.rows.some(item => Number(item.stock_id) === Number(deletedDetail.stock_id)), '被删除明细的 stock_id 应从 detail 中消失' ); assert.ok( after.rows.some(item => Number(item.stock_id) === Number(keptDetail.stock_id)), '未删除明细应保留' ); }); it('批量删除 2 条明细:deleted_count=2、deleted_ids 保持入参顺序、total_items 减 2、DB 明细清空', async () => { const check = await createCheck(); const stocks = await fetchStockRows(3); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); assert.equal(details.total, 3, '前置:任务应有 3 条明细'); const targetIds = [ details.rows[0].id, details.rows[1].id ]; const result = await deleteDetail(check.id, targetIds); assert.equal(result.deleted_count, 2); assert.deepEqual(result.deleted_ids.map(Number), targetIds.map(Number), 'deleted_ids 应保持入参顺序'); assert.deepEqual(result.skipped_ids, [], '全部命中不应有跳过明细'); assert.equal(result.total_items, 1, '删除 2 条后主表明细数应重算为 1'); assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 应同步重算'); // DB 明细清空校验:被删 ID 消失、仅剩未删除的 1 条 const remaining = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, attributes: [ 'id' ], raw: true, }); const remainingIds = remaining.map(row => Number(row.id)); for (const targetId of targetIds) { assert.ok(!remainingIds.includes(Number(targetId)), `被删明细 ${targetId} 应从 DB 消失`); } assert.deepEqual(remainingIds, [ Number(details.rows[2].id) ], '仅剩未删除的 1 条明细'); }); it('混合删除:存在 + 不存在 ID 分流(deleted_ids/skipped_ids 均保持入参顺序)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); assert.equal(details.total, 2); const missingIdA = await findFreeDetailId(); const missingIdB = missingIdA + 1; const mixed = [ missingIdA, details.rows[0].id, missingIdB, details.rows[1].id ]; const result = await deleteDetail(check.id, mixed); assert.equal(result.deleted_count, 2); assert.deepEqual( result.deleted_ids.map(Number), [ Number(details.rows[0].id), Number(details.rows[1].id) ], 'deleted_ids 应保持命中明细的入参顺序' ); assert.deepEqual( result.skipped_ids.map(Number), [ missingIdA, missingIdB ], 'skipped_ids 应保持未命中明细的入参顺序' ); assert.equal(result.total_items, 0, '命中明细全部删除后主表明细数重算为 0'); assert.equal( await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), 0, 'DB 明细应清空' ); }); it('detailIds 超过 200 条报 400(单次最多删除 200 条明细)', async () => { const check = await createCheck(); const tooManyIds = Array.from({ length: 201 }, (_, index) => index + 1); await assert.rejects( () => deleteDetailRaw({ id: check.id, detailIds: tooManyIds }), error => error.code === 400 && /单次最多删除 200 条明细/.test(error.message) ); }); it('重复删除同一明细不报错:未命中计入 skipped_ids(deleted_count=0,不改变剩余明细)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); await deleteDetail(check.id, details.rows[0].id); const result = await deleteDetail(check.id, details.rows[0].id); assert.equal(result.deleted_count, 0, '重复删除不应命中'); assert.deepEqual(result.deleted_ids, [], '重复删除不应有命中明细'); assert.deepEqual( result.skipped_ids.map(Number), [ Number(details.rows[0].id) ], '未命中明细应计入 skipped_ids' ); assert.equal(result.total_items, 1, '未命中删除不应改变剩余明细数'); assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 不应变化'); }); it('submitted/approved/checking 状态删除明细报 400', async () => { // submitted 状态 const submittedCheck = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(submittedCheck.id, stocks.map(stock => stock.id)); await submitCheck(submittedCheck.id); const submittedDetails = await detailCheck(submittedCheck.id); await assert.rejects(async () => { await deleteDetail(submittedCheck.id, submittedDetails.rows[0].id); }, error => error.code === 400 && /不允许删除明细/.test(error.message)); // approved 状态 const approvedCheck = await createCheck(); const moreStocks = await fetchStockRows(2); await addDetail(approvedCheck.id, moreStocks.map(stock => stock.id)); await submitCheck(approvedCheck.id); await auditCheck(approvedCheck.id, 'approve'); const approvedDetails = await detailCheck(approvedCheck.id); await assert.rejects(async () => { await deleteDetail(approvedCheck.id, approvedDetails.rows[0].id); }, error => error.code === 400 && /不允许删除明细/.test(error.message)); // checking 状态(approved → 首次上报 → checking) await reportCheck(approvedCheck.id, approvedDetails.rows[0].id, 0); assert.equal((await findCheckRow(approvedCheck.id)).status, 'checking'); await assert.rejects(async () => { await deleteDetail(approvedCheck.id, approvedDetails.rows[0].id); }, error => error.code === 400 && /不允许删除明细/.test(error.message)); }); it('rejected 状态可删除明细(submit→audit reject 后删除成功)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'reject', '明细商品有误,请重新盘点'); assert.equal((await findCheckRow(check.id)).status, 'rejected'); const details = await detailCheck(check.id); const result = await deleteDetail(check.id, details.rows[0].id); assert.equal(result.deleted_count, 1); assert.deepEqual(result.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); assert.deepEqual(result.skipped_ids, []); assert.equal(result.total_items, 1); assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 应同步重算'); }); it('detailIds 缺失/全非法值或任务 id 非法报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); // detailIds 缺失 await assert.rejects( () => deleteDetailRaw({ id: check.id }), error => error.code === 400 && /请至少选择一个明细/.test(error.message) ); // detailIds 全非法值(归一化后为空):单值与数组形态均报 400 for (const badDetailIds of [ null, '', 0, -1, 1.5, 'abc', [], [ 0, -1, 1.5, 'abc' ]]) { await assert.rejects( () => deleteDetailRaw({ id: check.id, detailIds: badDetailIds }), error => error.code === 400 && /请至少选择一个明细/.test(error.message) ); } // 任务 id 非法 await assert.rejects( () => deleteDetailRaw({ id: 'abc', detailIds: [ 1 ] }), error => error.code === 400 && /任务ID/.test(error.message) ); }); it('仓库隔离:其他仓库任务不可删除;跨仓库明细未命中计入 skipped_ids', async () => { const otherWarehouseId = OTHER_TEST_WAREHOUSE_ID; // 其他仓库任务(直接造数,避免与单号生成器按仓库隔离序号、全局唯一索引的耦合): // 本仓库视角任务不存在 const otherCheck = await ctx.model.StockCheck.create({ warehouse_id: otherWarehouseId, check_no: `DIA${Date.now()}`, title: uniqueTitle('盘点单元测试-仓库隔离'), type: 'location', mode: 'blind', status: 'created', detail_status: 'none_checked', creator_id: TEST_CREATOR_ID, creator_name: TEST_CREATOR_NAME, }); await assert.rejects(async () => { await deleteDetail(otherCheck.id, 1); }, error => error.code === 400 && /任务不存在/.test(error.message)); // 同任务下跨仓库明细:仓库隔离查询查不到 → 计入 skipped_ids(不报错) // (uk_check_stock(check_id, stock_id) 唯一索引下跨仓库明细须使用不同商品,避免直接撞索引) const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, [ stocks[0].id ]); const foreignDetail = await ctx.model.StockCheckDetail.create({ check_id: check.id, warehouse_id: otherWarehouseId, stock_id: stocks[1].id, item_code: 'FOREIGN-ISOLATION-ITEM', item_name: '仓库隔离测试商品', system_quantity: 1, }); const skippedResult = await deleteDetail(check.id, foreignDetail.id); assert.equal(skippedResult.deleted_count, 0, '跨仓库明细不应命中删除'); assert.deepEqual(skippedResult.deleted_ids, []); assert.deepEqual( skippedResult.skipped_ids.map(Number), [ Number(foreignDetail.id) ], '跨仓库明细应计入 skipped_ids' ); // 未命中删除不改变本仓库明细 const afterSkip = await detailCheck(check.id); assert.equal(afterSkip.total, 1, '本仓库明细应保持未删除'); // 清理跨仓库明细,恢复任务数据形态后本仓库明细删除不受影响 await ctx.model.StockCheckDetail.destroy({ where: { id: foreignDetail.id } }); const details = await detailCheck(check.id); const result = await deleteDetail(check.id, details.rows[0].id); assert.equal(result.deleted_count, 1); assert.deepEqual(result.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); assert.equal(result.total_items, 0, '本仓库明细删除后任务内无剩余明细'); }); it('防御清理:明细存在作业记录时删除明细一并清除记录', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); const targetDetail = details.rows[0]; // created 状态正常流程不会有作业记录,直接造数模拟防御清理场景 await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: targetDetail.id, stock_id: targetDetail.stock_id, location_code: 'DEFENSE-CLEAN-001', quantity: 5, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); assert.equal( (await queryRecords(check.id, targetDetail.id)).length, 1, '造数应写入一条作业记录' ); const result = await deleteDetail(check.id, targetDetail.id); assert.equal(result.deleted_count, 1); assert.deepEqual(result.deleted_ids.map(Number), [ Number(targetDetail.id) ]); assert.deepEqual(result.skipped_ids, []); assert.equal(result.total_items, 1, '删除明细后主表明细数重算为 1'); assert.equal( (await queryRecords(check.id, targetDetail.id)).length, 0, '该明细的作业记录应一并清除' ); assert.equal( await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 0, '任务内不应残留作业记录' ); const after = await detailCheck(check.id); assert.equal(after.total, 1, '仅剩 1 条未删除明细'); }); it('防御清理(批量):带作业记录的 2 条明细批量删除后作业记录全部清空', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); assert.equal(details.total, 2); // created 状态正常流程不会有作业记录,批量造数模拟防御清理场景 for (const detail of details.rows) { await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: detail.stock_id, location_code: `DEFENSE-BATCH-${detail.id}`, quantity: 5, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); } assert.equal( await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 2, '前置:应有 2 条作业记录' ); const targetIds = details.rows.map(detail => detail.id); const result = await deleteDetail(check.id, targetIds); assert.equal(result.deleted_count, 2); assert.deepEqual(result.deleted_ids.map(Number), targetIds.map(Number)); assert.deepEqual(result.skipped_ids, []); assert.equal(result.total_items, 0, '批量删除后主表明细数重算为 0'); assert.equal( await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 0, '批量删除后任务内不应残留作业记录' ); assert.equal( await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), 0, '批量删除后 DB 明细应清空' ); }); }); // ------------------- submit/cancel/audit:状态流转 ------------------- describe('submit/cancel/audit 状态流转', () => { it('无明细不允许提交(400);有明细提交后置 submitted', async () => { const check = await createCheck(); await assert.rejects(async () => { await submitCheck(check.id); }, error => error.code === 400); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const result = await submitCheck(check.id); assert.equal(result.status, 'submitted'); const row = await findCheckRow(check.id); assert.equal(row.status, 'submitted'); }); it('submitted 状态重复提交报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await assert.rejects(async () => { await submitCheck(check.id); }, error => error.code === 400); }); it('库位范围明细缺少库位(location_id/location_code 为空)不可提交', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); // 直写一条缺库位的脏数据明细(location_id/location_code 均为空) await ctx.model.StockCheckDetail.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, scope_type: 'location', stock_id: null, item_code: null, item_name: null, spec: null, batch_no: null, system_quantity: 0, location_id: null, location_code: '', }); await assert.rejects(async () => { await submitCheck(check.id); }, error => error.code === 400 && /缺少库位的盘点明细/.test(error.message)); // 清除脏数据后正常提交 await ctx.model.StockCheckDetail.destroy({ where: { check_id: check.id, location_code: '' }, }); const result = await submitCheck(check.id); assert.equal(result.status, 'submitted'); }); it('created/submitted 状态可取消 → cancelled;cancelled 终态不可再取消', async () => { const createdCheck = await createCheck(); const cancelledFromCreated = await cancelCheck(createdCheck.id); assert.equal(cancelledFromCreated.status, 'cancelled'); const submittedCheck = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(submittedCheck.id, [ stocks[0].id ]); await submitCheck(submittedCheck.id); const cancelledFromSubmitted = await cancelCheck(submittedCheck.id); assert.equal(cancelledFromSubmitted.status, 'cancelled'); await assert.rejects(async () => { await cancelCheck(submittedCheck.id); }, error => error.code === 400); }); it('audit approve → approved;approved 状态再次审核报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); const result = await auditCheck(check.id, 'approve'); assert.equal(result.status, 'approved'); assert.equal((await findCheckRow(check.id)).status, 'approved'); await assert.rejects(async () => { await auditCheck(check.id, 'approve'); }, error => error.code === 400); }); it('audit reject → rejected 并写入驳回原因;驳回后可重新提交', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); const rejected = await auditCheck(check.id, 'reject', '明细商品有误,请重新盘点'); assert.equal(rejected.status, 'rejected'); const row = await findCheckRow(check.id); assert.equal(row.status, 'rejected'); assert.equal(row.remark, '明细商品有误,请重新盘点'); const resubmitted = await submitCheck(check.id); assert.equal(resubmitted.status, 'submitted'); }); it('非法审核动作或非 submitted 状态审核报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await assert.rejects(async () => { await auditCheck(check.id, 'bad_action'); }, error => error.code === 400); const createdCheck = await createCheck(); await assert.rejects(async () => { await auditCheck(createdCheck.id, 'approve'); }, error => error.code === 400); }); it('商品任务提交审核刷新明细行账面快照(提交时点账面),主表不写额外快照', async () => { const { literal } = ctx.app.Sequelize; const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const details = await detailCheck(check.id); assert.equal(details.rows.length, 1, '单库位商品应只有一条明细行'); const detail = details.rows[0]; const stockId = Number(detail.stock_id); const spaceId = Number(detail.location_id); // 提交前账面(口径与实现一致:SUM 可用数量) const bookRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, stock_id: stockId, space_id: spaceId, is_enabled: 1, }, attributes: [ [ literal('SUM(available_quantity)'), 'totalQuantity' ], ], raw: true, }); const bookTotal = Number((bookRows[0] || {}).totalQuantity) || 0; // 模拟提交前库存变动:一条库存行可用数量 +100(finally 恢复) const storageRow = await ctx.model.Storage.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, stock_id: stockId, space_id: spaceId, is_enabled: 1, }, raw: true, }); assert.ok(storageRow, '前置:应存在库存行'); await ctx.model.Storage.update( { available_quantity: Number(storageRow.available_quantity) + 100 }, { where: { id: storageRow.id } } ); try { await submitCheck(check.id); const row = await findCheckRow(check.id); assert.equal(row.status, 'submitted'); assert.equal(row.scope_snapshot, null, '主表不写额外快照(明细表已完整记录)'); const afterDetails = await detailCheck(check.id); assert.equal( Number(afterDetails.rows[0].system_quantity), bookTotal + 100, '明细行库位级账面快照应刷新为提交时账面' ); } finally { await ctx.model.Storage.update( { available_quantity: Number(storageRow.available_quantity) }, { where: { id: storageRow.id } } ); } }); it('库位范围任务提交不刷新商品账面快照(明细行 system_quantity 保持 0、主表 scope_snapshot 保持 null)', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); const row = await findCheckRow(check.id); assert.equal(row.status, 'submitted'); assert.equal(row.scope_snapshot, null, '库位范围任务不写商品账面快照'); const details = await detailCheck(check.id); assert.equal(Number(details.rows[0].system_quantity), 0, '库位明细行账面快照保持 0'); }); }); // ------------------- report:盘点作业上报 ------------------- describe('report 盘点作业上报', () => { it('实盘数量为负数或非整数报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await assert.rejects(async () => { await reportCheck(check.id, detailId, -1); }, error => error.code === 400); await assert.rejects(async () => { await reportCheck(check.id, detailId, 1.5); }, error => error.code === 400); }); it('report 写记录表:record 字段完整(check_id/warehouse_id/detail_id/stock_id/quantity/checker/checked_at)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const result = await reportCheck(check.id, detail.id, 7, TEST_LOCATION_CODE); assert.equal(Number(result.detail_id), Number(detail.id), '返回的明细 ID 应一致'); assert.equal(result.total_items, 1); assert.equal(result.checked_items, 1, '该明细存在记录应计入已盘'); assert.equal(result.detail_status, 'all_checked'); assert.ok(result.record, '应返回新增的作业记录'); assert.equal(Number(result.record.check_id), check.id, '记录应关联盘点任务'); assert.equal(Number(result.record.warehouse_id), TEST_WAREHOUSE_ID, '记录应写入固定测试仓库'); assert.equal(Number(result.record.detail_id), Number(detail.id), '记录应关联明细'); assert.equal(Number(result.record.stock_id), Number(detail.stock_id), '记录应冗余商品库存 ID'); assert.equal(Number(result.record.quantity), 7, '记录应写入实盘数量'); assert.equal(Number(result.record.checker_id), TEST_CREATOR_ID, '记录应写入盘点人 ID'); assert.equal(result.record.checker_name, TEST_CREATOR_NAME, '记录应写入盘点人名称'); assert.ok(result.record.checked_at, '记录应写入上报时间'); assert.equal(result.mode, 'created', '首次上报 mode 应为 created'); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 1, '上报一次应写入一条作业记录'); }); it('同一明细多库位多次上报:写入多条记录,明细已盘数量=合计,checked_items 只计一次', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const firstReport = await reportCheck(check.id, firstDetail.id, 10, TEST_LOCATION_CODE); const secondReport = await reportCheck(check.id, firstDetail.id, 5, TEST_EMPTY_LOCATION_CODE); await reportCheck(check.id, secondDetail.id, 0); assert.equal(firstReport.mode, 'created', '首次上报 mode 应为 created'); assert.equal(secondReport.mode, 'created', '不同库位上报应新增记录'); const firstRecords = await queryRecords(check.id, firstDetail.id); assert.equal(firstRecords.length, 2, '同一明细不同库位两次上报应写入两条作业记录'); assert.equal(Number(firstRecords[0].quantity), 10); assert.equal(Number(firstRecords[1].quantity), 5); const after = await resultCheck(check.id); const firstRow = after.rows.find(row => Number(row.id) === Number(firstDetail.id)); assert.equal(firstRow.checked_quantity, 15, '明细已盘数量应为多条记录合计'); assert.equal(firstRow.status, 'checked'); assert.deepEqual( firstRow.location_codes, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ], '多库位编码应合并' ); assert.equal(firstRow.records.length, 2, 'records 应包含该明细全部作业记录'); const row = await findCheckRow(check.id); assert.equal(row.checked_items, 2, 'checked_items 按明细去重计数,不因多记录重复累计'); assert.equal(row.detail_status, 'all_checked'); }); it('盘盈/无差异场景:按明细聚合校验 diff_quantity/is_diff,汇总 diff_items 正确', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const firstResult = await reportCheck( check.id, firstDetail.id, Number(firstDetail.system_quantity) + 5 ); assert.equal(firstResult.checked_items, 1); assert.equal(firstResult.detail_status, 'partial_checked', '部分已盘'); const afterFirst = await resultCheck(check.id); const firstRow = afterFirst.rows.find(row => Number(row.id) === Number(firstDetail.id)); assert.equal(firstRow.checked_quantity, Number(firstDetail.system_quantity) + 5); assert.equal(firstRow.diff_quantity, 5, '盘盈 5'); assert.equal(firstRow.is_diff, 1, '有差异应标记 is_diff=1'); assert.equal(firstRow.status, 'checked'); const secondResult = await reportCheck( check.id, secondDetail.id, Number(secondDetail.system_quantity) ); assert.equal(secondResult.checked_items, 2); assert.equal(secondResult.diff_items, 1); assert.equal(secondResult.detail_status, 'all_checked', '全部已盘'); const afterSecond = await resultCheck(check.id); const secondRow = afterSecond.rows.find(row => Number(row.id) === Number(secondDetail.id)); assert.equal(secondRow.diff_quantity, 0, '数量一致差异为 0'); assert.equal(secondRow.is_diff, 0, '无差异应标记 is_diff=0'); }); it('明细差异=已盘合计-账面快照(非单次上报数量)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const snapshot = Number(detail.system_quantity); // 第一次上报数量=账面快照 → 单次差异 0 await reportCheck(check.id, detail.id, snapshot, TEST_LOCATION_CODE); const afterFirst = await resultCheck(check.id); assert.equal(afterFirst.rows[0].checked_quantity, snapshot); assert.equal(afterFirst.rows[0].diff_quantity, 0, '单次上报无差异'); assert.equal(afterFirst.rows[0].is_diff, 0); // 第二次上报 5(另一库位)→ 已盘合计=账面+5,差异应按合计而非单次上报数量计算 const secondResult = await reportCheck(check.id, detail.id, 5, TEST_EMPTY_LOCATION_CODE); assert.equal(secondResult.diff_items, 1, '按合计计算应产生 1 条差异明细'); const afterSecond = await resultCheck(check.id); assert.equal(afterSecond.rows[0].checked_quantity, snapshot + 5, '已盘数量应为账面+5'); assert.equal(afterSecond.rows[0].diff_quantity, 5, '差异=已盘合计-账面快照'); assert.equal(afterSecond.rows[0].is_diff, 1); }); it('首次上报将主表 approved 自动转 checking 并写 start_time(≈首个明细写入时间)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const beforeRow = await findCheckRow(check.id); assert.equal(beforeRow.status, 'approved'); assert.equal(beforeRow.start_time, null); const details = await detailCheck(check.id); const beforeReport = Date.now(); await reportCheck(check.id, details.rows[0].id, 0); const afterReport = Date.now(); const afterRow = await findCheckRow(check.id); assert.equal(afterRow.status, 'checking', '首次上报应自动转盘点作业中'); assert.ok(afterRow.start_time, '应写入实际开始时间'); const startTs = new Date(afterRow.start_time).getTime(); assert.ok( startTs >= beforeReport - 5000 && startTs <= afterReport + 5000, 'start_time 应≈第一个盘点明细写入时间' ); }); it('space_id 必传:库位以 space_id 对应库位为准,编码不一致报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); assert.equal(result.record.location_code, TEST_LOCATION_CODE); assert.equal(Number(result.record.location_id), TEST_LOCATION_ID, '库位编码命中应回填 location_id'); const records = await queryRecords(check.id, details.rows[0].id); assert.equal(records.length, 1); assert.equal(Number(records[0].location_id), TEST_LOCATION_ID, '记录表应持久化回填的 location_id'); assert.equal(records[0].location_code, TEST_LOCATION_CODE); // 上报编码与 space_id 对应库位编码不一致 → 400(库位以 space_id 为准,不再按编码猜) await assert.rejects(async () => { await reportCheck(check.id, details.rows[0].id, 3, 'NOT_EXIST_SPACE_999', { spaceId: TEST_LOCATION_ID }); }, error => error.code === 400 && error.message.includes('库位ID不一致')); }); it('同仓库同编码存在多条库位时:上报沿用明细固化 location_id,space 视图不产生幽灵行', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const detailLocationId = Number(detail.location_id); assert.ok(detailLocationId > 0, '前置:商品明细应带库位ID'); const originSpace = await ctx.model.LocationSpace.findByPk(detailLocationId, { raw: true }); assert.ok(originSpace, '前置:明细库位应存在'); // 构造同仓库同编码的历史重复库位(所属分区不存在,即无头库位) let duplicateSpace = null; try { duplicateSpace = await ctx.model.LocationSpace.create({ warehouse_id: TEST_WAREHOUSE_ID, zone_id: 99999999, location_type_id: Number(originSpace.location_type_id) || 1, space_code: detail.location_code, }); assert.ok(Number(duplicateSpace.id) > 0, '前置:重复库位应创建成功'); // 上报库位与明细一致 → 沿用明细固化库位,不被同编码重复库位抢走 const result = await reportCheck(check.id, detail.id, 5, detail.location_code); assert.equal( Number(result.record.location_id), detailLocationId, '同编码多条库位时应沿用明细固化 location_id' ); // 模拟历史脏数据(记录被写成重复库位)→ space 视图应归并回有效库位,只出一行且带库位自定义字段 await ctx.model.StockCheckRecord.update( { location_id: Number(duplicateSpace.id) }, { where: { check_id: check.id, detail_id: detail.id } } ); const data = await workDataCheck(check.id); assert.equal(data.view, 'space'); const rows = data.rows.filter(row => row.space_code === detail.location_code); assert.equal(rows.length, 1, '同编码重复库位不应产生幽灵行'); assert.equal(Number(rows[0].id), detailLocationId, '应归并到明细固化库位'); assert.equal(rows[0].custom_name, originSpace.custom_name || null, '库位自定义名称应取有效库位行'); const item = rows[0].goods.find(goods => Number(goods.stock_id) === Number(detail.stock_id)); assert.ok(item, '归并后的库位行应包含该商品'); assert.equal(Number(item.checked_quantity), 5, '实盘数量应继续落在有效库位行上'); assert.equal(item.status, 'checked'); } finally { if (duplicateSpace) { await ctx.model.LocationSpace.destroy({ where: { id: duplicateSpace.id }, force: true }); } } }); it('space_id 必传且优先:直传库位ID按ID落库;缺失/编码不一致/跨仓库/分区已删除报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; // 1) 只传 space_id(不传 location):编码由库位行反推,记录直接用该 ID const first = await reportCheck(check.id, detailId, 4, undefined, { spaceId: TEST_LOCATION_ID }); assert.equal(Number(first.record.location_id), TEST_LOCATION_ID, '直传 space_id 应原样落库'); assert.equal(first.record.location_code, TEST_LOCATION_CODE, '库位编码应由库位行反推'); // 2) location 与 space_id 同时传且编码一致:通过 const second = await reportCheck(check.id, detailId, 6, TEST_LOCATION_CODE, { spaceId: TEST_LOCATION_ID }); assert.equal(Number(second.record.location_id), TEST_LOCATION_ID); assert.equal(Number(second.record.quantity), 6); // 3) 编码与 ID 不一致:400 await assert.rejects(async () => { await reportCheck(check.id, detailId, 6, TEST_EMPTY_LOCATION_CODE, { spaceId: TEST_LOCATION_ID }); }, error => error.code === 400 && error.message.includes('库位ID不一致')); // 4) 其他仓库的库位ID:400 const otherWarehouseSpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: OTHER_TEST_WAREHOUSE_ID }, attributes: [ 'id' ], raw: true, }); if (otherWarehouseSpace) { await assert.rejects(async () => { await reportCheck(check.id, detailId, 6, undefined, { spaceId: Number(otherWarehouseSpace.id) }); }, error => error.code === 400 && error.message.includes('上报库位不存在')); } // 5) 无头库位(分区已删除)的ID:400 let headlessSpace = null; try { headlessSpace = await ctx.model.LocationSpace.create({ warehouse_id: TEST_WAREHOUSE_ID, zone_id: 99999998, location_type_id: 1, space_code: `HD-${Date.now()}`, }); await assert.rejects(async () => { await reportCheck(check.id, detailId, 6, undefined, { spaceId: Number(headlessSpace.id) }); }, error => error.code === 400 && error.message.includes('上报库位不存在')); } finally { if (headlessSpace) { await ctx.model.LocationSpace.destroy({ where: { id: headlessSpace.id }, force: true }); } } // 6) 缺失/非法值:400(不允许退回按编码猜库位) for (const spaceId of [ null, '', 0, -5, 'abc' ]) { await assert.rejects(async () => { await reportCheck(check.id, detailId, 6, TEST_LOCATION_CODE, { spaceId }); }, error => error.code === 400 && error.message.includes('缺少库位ID')); } // 完全不传 space_id(直接调业务层,绕过测试辅助的自动解析)同样 400 await assert.rejects(async () => { await ctx.service.systems.stockCheck.report({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, detailId, quantity: 6, location: TEST_LOCATION_CODE, checkerId: TEST_CREATOR_ID, checkerName: TEST_CREATOR_NAME, }); }, error => error.code === 400 && error.message.includes('缺少库位ID')); }); it('实盘数量超上限报 400(不落库、不返回 500)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await assert.rejects(async () => { await reportCheck(check.id, detailId, 6955416422066, TEST_LOCATION_CODE); }, error => error.code === 400 && error.message.includes('实盘数量不能超过')); const records = await queryRecords(check.id, detailId); assert.equal(records.length, 0, '超限上报不应落库'); // 边界值本身允许 const boundary = await reportCheck(check.id, detailId, 2147483647, TEST_LOCATION_CODE); assert.equal(Number(boundary.record.quantity), 2147483647); }); it('上报写入操作日志:message 含库位编码/ID,before_changes 记录库位与明细库位快照', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE); const log = await ctx.model.OperationLog.findOne({ where: { business_type: 'stock_check', business_id: String(check.id), operation_code: 'STOCK_CHECK_REPORT', }, order: [[ 'id', 'DESC' ]], raw: true, }); assert.ok(log, '应写入 STOCK_CHECK_REPORT 操作日志'); assert.ok(log.message.includes(TEST_LOCATION_CODE), 'message 应包含库位编码'); assert.ok(log.message.includes(`#${TEST_LOCATION_ID}`), 'message 应包含库位ID'); assert.ok(log.before_changes, 'before_changes 应落库'); const changes = typeof log.before_changes === 'string' ? JSON.parse(log.before_changes) : log.before_changes; assert.equal(changes.detail_id, Number(detailId)); assert.equal(changes.location_code, TEST_LOCATION_CODE); assert.equal(changes.location_id, TEST_LOCATION_ID); assert.equal(changes.quantity, 3); assert.equal(changes.mode, 'created'); }); it('非 approved/checking 状态上报报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const details = await detailCheck(check.id); await assert.rejects(async () => { await reportCheck(check.id, details.rows[0].id, 1); }, error => error.code === 400); }); it('同明细同库位重复上报:记录仍 1 条、数量为最新值、mode=updated', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const first = await reportCheck(check.id, detailId, 7, TEST_LOCATION_CODE); assert.equal(first.mode, 'created', '首次上报 mode 应为 created'); const second = await reportCheck(check.id, detailId, 9, TEST_LOCATION_CODE); assert.equal(second.mode, 'updated', '同库位重复上报 mode 应为 updated'); assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); assert.equal(Number(second.record.quantity), 9, '记录数量应为最新值'); assert.equal(Number(second.record.checker_id), TEST_CREATOR_ID, '盘点人应更新为最新上报人'); const records = await queryRecords(check.id, detailId); assert.equal(records.length, 1, '同明细同库位只保留一条记录'); assert.equal(Number(records[0].quantity), 9, '库内记录数量应为最新值'); assert.equal(records[0].location_code, TEST_LOCATION_CODE); const after = await resultCheck(check.id); assert.equal(after.rows[0].checked_quantity, 9, '已盘数量应为最新值而非两次之和'); assert.equal(after.rows[0].records.length, 1); }); it('同明细跨库位:不同库位新增、同库位覆盖更新,已盘=各库位最新值合计', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const created = await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); assert.equal(created.mode, 'created'); const updated = await reportCheck(check.id, detailId, 12, TEST_LOCATION_CODE); assert.equal(updated.mode, 'updated', '同库位重复上报应覆盖更新'); const otherLocation = await reportCheck(check.id, detailId, 5, TEST_EMPTY_LOCATION_CODE); assert.equal(otherLocation.mode, 'created', '不同库位应新增记录'); const records = await queryRecords(check.id, detailId); assert.equal(records.length, 2, '两个库位各保留一条记录'); const quantityByCode = new Map(records.map(record => [ record.location_code, Number(record.quantity) ])); assert.equal(quantityByCode.get(TEST_LOCATION_CODE), 12, '同库位保留最新值'); assert.equal(quantityByCode.get(TEST_EMPTY_LOCATION_CODE), 5); const after = await resultCheck(check.id); assert.equal(after.rows[0].checked_quantity, 17, '已盘数量=各库位最新值合计'); const row = await findCheckRow(check.id); assert.equal(row.checked_items, 1, 'checked_items 按明细去重不重复累计'); }); it('space_id 必传:未携带库位ID上报报 400;历史无库位记录(location_code=空串)仍可查询归一为 null', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const detailId = detail.id; // 1) 不传 space_id → 400(不再有"无库位上报"通道) await assert.rejects(async () => { await reportCheck(check.id, detailId, 8, undefined, { spaceId: 0 }); }, error => error.code === 400 && error.message.includes('缺少库位ID')); // 2) 历史脏数据(location_code 空串)仍可查询:recordList 空串归一为 null const legacy = await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detailId, stock_id: Number(detail.stock_id), location_id: null, location_code: '', quantity: 8, is_empty: false, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); assert.ok(Number(legacy.id) > 0, '前置:历史无库位记录应写入成功'); const listed = await listRecords({ id: check.id, detailId }); assert.equal(listed.total, 1); assert.equal(listed.rows[0].location_code, null, '接口返回无库位记录 location_code 应为 null'); }); it('唯一索引加固:同明细同库位连续上报 DB 记录总数恒为 1', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; // 同库位连续三次上报:覆盖式语义下 DB 只保留 1 条记录 await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); await reportCheck(check.id, detailId, 11, TEST_LOCATION_CODE); const last = await reportCheck(check.id, detailId, 12, TEST_LOCATION_CODE); assert.equal(last.mode, 'updated', '第三次同库位上报应为覆盖更新'); // 另一库位再报一次:新增 1 条(共 2 条) await reportCheck(check.id, detailId, 4, TEST_EMPTY_LOCATION_CODE); const records = await queryRecords(check.id, detailId); assert.equal(records.length, 2, '两个库位各 1 条记录'); assert.equal( await ctx.model.StockCheckRecord.count({ where: { detail_id: detailId, location_code: TEST_LOCATION_CODE }, }), 1, '同库位分组记录数恒为 1(唯一索引生效)' ); assert.equal( await ctx.model.StockCheckRecord.count({ where: { detail_id: detailId, location_code: null }, }), 0, '库中不应存在 location_code 为 NULL 的记录' ); }); it('唯一索引 DB 层验证:重复 (detail_id, stock_id, location_code) 直接插入被拒绝', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; // 业务链路先写入一条有库位记录,再直接插入同组记录 → 触发唯一约束错误 await reportCheck(check.id, detail.id, 7, TEST_LOCATION_CODE); await assert.rejects(async () => { await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: detail.stock_id, location_id: TEST_LOCATION_ID, location_code: TEST_LOCATION_CODE, quantity: 99, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); }, error => error.name === 'SequelizeUniqueConstraintError'); // 历史无库位(空串)分组同样受唯一索引约束 await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: detail.stock_id, location_id: null, location_code: '', quantity: 3, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); await assert.rejects(async () => { await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: detail.stock_id, location_id: null, location_code: '', quantity: 88, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); }, error => error.name === 'SequelizeUniqueConstraintError'); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 2, '被唯一索引拒绝的插入不应落库'); }); }); // ------------------- report:库位行与商品行 stock_id 维度校验 ------------------- describe('report 库位行与商品行 stock_id 维度校验', () => { it('库位行缺 stock_id 报 400', async () => { const { check, detail } = await createApprovedLocationCheck(); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 1); }, error => error.code === 400 && /必须指定商品/.test(error.message)); }); it('库位行商品非本仓库报 400', async () => { const { check, detail } = await createApprovedLocationCheck(); const foreignStock = await fetchOtherWarehouseStockRow(); assert.ok(foreignStock, '应存在其他仓库商品用于跨仓库隔离校验'); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 1, undefined, { stockId: foreignStock.id }); }, error => error.code === 400 && /不属于本仓库/.test(error.message)); }); it('库位行上报库位与明细库位不一致报 400', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const otherSpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, attributes: [ 'id' ], raw: true, }); assert.ok(otherSpace, '前置:另一有效库位应存在'); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 1, TEST_EMPTY_LOCATION_CODE, { stockId: stocks[0].id, spaceId: Number(otherSpace.id), }); }, error => error.code === 400 && /库位与盘点明细库位不一致/.test(error.message)); }); it('库位行正常上报:record 含 stock_id、库位以明细为准,覆盖式按 (detail,stock,location) 更新', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const stockId = stocks[0].id; const first = await reportCheck(check.id, detail.id, 5, TEST_LOCATION_CODE, { stockId }); assert.equal(first.mode, 'created'); assert.equal(Number(first.record.stock_id), stockId, '记录应写入上报商品 ID'); assert.equal(first.record.location_code, TEST_LOCATION_CODE, '库位应以明细库位为准'); assert.equal(Number(first.record.location_id), TEST_LOCATION_ID, '库位 ID 应取明细库位'); assert.equal(first.checked_items, 1); assert.equal(first.detail_status, 'all_checked'); // 同明细 + 同商品 + 同库位(未传库位同样以明细库位为准)→ 覆盖更新 const second = await reportCheck(check.id, detail.id, 9, undefined, { stockId }); assert.equal(second.mode, 'updated', '同 (detail,stock,location) 应覆盖更新'); assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 1); assert.equal(Number(records[0].quantity), 9); assert.equal(Number(records[0].stock_id), stockId); }); it('商品行上报 stock_id 与明细商品不一致报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await assert.rejects(async () => { await reportCheck(check.id, details.rows[0].id, 1, undefined, { stockId: stocks[1].id }); }, error => error.code === 400 && /上报商品与盘点明细商品不一致/.test(error.message)); }); it('同库位行多商品上报:记录按 (detail,stock,location) 各自落库,不撞唯一索引', async () => { const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); const first = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stockIds[0] }); assert.equal(first.mode, 'created'); const second = await reportCheck(check.id, detail.id, 4, undefined, { stockId: stockIds[1] }); assert.equal(second.mode, 'created', '不同商品应新增记录而非覆盖'); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 2, '同库位行多商品应各保留一条记录(uk_detail_stock_location 生效)'); for (const record of records) { assert.equal(record.location_code, TEST_LOCATION_CODE); } // 覆盖式:同商品再报更新原记录,记录数不变 const updated = await reportCheck(check.id, detail.id, 7, undefined, { stockId: stockIds[0] }); assert.equal(updated.mode, 'updated'); const after = await queryRecords(check.id, detail.id); assert.equal(after.length, 2, '覆盖更新后记录数不变'); const updatedRecord = after.find(record => Number(record.stock_id) === stockIds[0]); assert.equal(Number(updatedRecord.quantity), 7); }); }); // ------------------- recordDelete:删除作业记录 ------------------- describe('recordDelete 删除作业记录', () => { it('删除后汇总回退:明细回到未盘、detail_status=未盘,主表状态不回退', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 5, TEST_LOCATION_CODE); const beforeRow = await findCheckRow(check.id); assert.equal(beforeRow.status, 'checking'); assert.equal(beforeRow.checked_items, 1); const records = await queryRecords(check.id, details.rows[0].id); assert.equal(records.length, 1); const result = await deleteRecord(check.id, records[0].id); assert.equal(result.deleted_count, 1, '应标记删除 1 条'); assert.deepEqual(result.deleted_ids.map(Number), [ Number(records[0].id) ]); assert.deepEqual(result.skipped_ids, []); assert.equal(result.total_items, 2); assert.equal(result.checked_items, 0, '删除后已盘明细回退为 0'); assert.equal(result.diff_items, 0); assert.equal(result.detail_status, 'none_checked', '明细记录删光回到未盘'); const remaining = await queryRecords(check.id, details.rows[0].id); assert.equal(remaining.length, 0, '记录应被删除'); const afterRow = await findCheckRow(check.id); assert.equal(afterRow.status, 'checking', '主表状态不回退'); assert.equal(afterRow.checked_items, 0); assert.equal(afterRow.detail_status, 'none_checked'); const after = await resultCheck(check.id); const targetRow = after.rows.find(row => Number(row.id) === Number(details.rows[0].id)); assert.ok(targetRow, '记录删光后应返回明细范围行'); assert.equal(targetRow.scope_type, 'goods'); assert.ok(Number(targetRow.system_quantity) >= 0, '明细行应含账面快照'); }); it('非 approved/checking 状态删除报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await assert.rejects(async () => { await deleteRecord(check.id, 999999999); }, error => error.code === 400); }); it('作业记录不属于该盘点任务计入 skipped_ids 不报错(批量口径)', async () => { const checkA = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(checkA.id, [ stocks[0].id ]); await submitCheck(checkA.id); await auditCheck(checkA.id, 'approve'); const detailsA = await detailCheck(checkA.id); const reportResult = await reportCheck(checkA.id, detailsA.rows[0].id, 3, TEST_LOCATION_CODE); const checkB = await createCheck(); await addDetail(checkB.id, [ stocks[0].id ]); await submitCheck(checkB.id); await auditCheck(checkB.id, 'approve'); const result = await ctx.service.systems.stockCheck.recordDelete({ warehouseId: TEST_WAREHOUSE_ID, id: checkB.id, recordIds: [ reportResult.record.id ], }); assert.equal(result.deleted_count, 0); assert.deepEqual(result.deleted_ids, []); assert.deepEqual(result.skipped_ids.map(Number), [ Number(reportResult.record.id) ], '不属于该任务的记录应计入 skipped_ids'); }); }); // ------------------- recheckClearLocation:重盘清除库位 ------------------- describe('recheckClearLocation 重盘清除库位(按库位清除盘点信息)', () => { it('清除库位记录:记录清空、汇总回退、库位回到未盘(含空库位标记一并清除)', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const stocks = await fetchStorageStockIds(TEST_LOCATION_ID, 1); await reportCheck(check.id, detailId, 5, undefined, { stockId: stocks[0] }); // 覆盖为空标记 await reportCheck(check.id, detailId, 0, undefined, { is_empty: true }); assert.equal((await queryRecords(check.id, detailId)).length, 1, '前置:空标记记录存在'); const result = await ctx.service.systems.stockCheck.recheckClearLocation({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: TEST_LOCATION_ID, }); assert.equal(Number(result.detail_id), Number(detailId)); assert.equal(result.location_id, TEST_LOCATION_ID); assert.equal(result.deleted_count, 1, '应清除该库位全部记录(含空标记)'); assert.equal(result.checked_items, 0, '清除后已盘回退为 0'); assert.equal(result.detail_status, 'none_checked'); assert.equal((await queryRecords(check.id, detailId)).length, 0, '记录应被清空'); const data = await workDataCheck(check.id); const row = data.rows[0]; assert.equal(row.status, 'unchecked', '库位回到未盘'); assert.equal(row.is_empty, false, '空标记一并清除'); assert.deepEqual(row.goods, []); }); it('非库位任务(商品任务)→ 400 仅库位盘点任务支持重盘清除库位', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); await assert.rejects(async () => { await ctx.service.systems.stockCheck.recheckClearLocation({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: TEST_LOCATION_ID, }); }, error => error.code === 400 && /仅库位盘点任务支持重盘清除库位/.test(error.message)); }); it('库位不在任务范围 → 400 该库位不在盘点任务范围内', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); await assert.rejects(async () => { await ctx.service.systems.stockCheck.recheckClearLocation({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: TEST_LOCATION_ID, }); }, error => error.code === 400 && /该库位不在盘点任务范围内/.test(error.message)); }); it('状态不允许(created)→ 400 当前状态不允许清除库位盘点信息', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await assert.rejects(async () => { await ctx.service.systems.stockCheck.recheckClearLocation({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: TEST_LOCATION_ID, }); }, error => error.code === 400 && /不允许清除库位盘点信息/.test(error.message)); }); it('方法层:location_id/locationId 兼容 + success 包装 + 非库位任务 failure 400', async () => { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const emptySpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, attributes: [ 'id' ], raw: true, }); const emptyLocationId = Number(emptySpace.id); const result = await ctx.service.systemMethods.stock.check.recheckClearLocation({ id: check.id, location_id: emptyLocationId, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.deleted_count, 0, '未盘库位清除记录数应为 0'); assert.equal(result.data.location_id, emptyLocationId); const goodsCheck = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(goodsCheck.id, [ stocks[0].id ]); await submitCheck(goodsCheck.id); await auditCheck(goodsCheck.id, 'approve'); const failure = await ctx.service.systemMethods.stock.check.recheckClearLocation({ id: goodsCheck.id, locationId: TEST_LOCATION_ID, }); assert.equal(failure.flag, 'failure'); assert.equal(failure.code, 400); assert.match(failure.message, /仅库位盘点任务支持重盘清除库位/); }); }); // ------------------- recordList:查询作业记录 ------------------- describe('recordList 查询作业记录', () => { it('按任务查询:返回全字段+item_code/item_name,按 id 倒序', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); await reportCheck(check.id, details.rows[1].id, 4); const result = await listRecords({ id: check.id }); assert.equal(result.total, 2); assert.equal(result.rows.length, 2); assert.equal(result.page, 1); assert.equal(result.pageSize, 20); assert.ok(Number(result.rows[0].id) > Number(result.rows[1].id), '应按记录 id 倒序'); for (const row of result.rows) { assert.equal(Number(row.check_id), check.id, '记录应关联盘点任务'); assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '记录应限定固定测试仓库'); assert.ok(row.detail_id, '记录应含明细 ID'); assert.ok(row.stock_id, '记录应含库存商品 ID'); assert.ok(row.checked_at, '记录应含上报时间'); assert.ok(row.item_code, '记录应回填商品编码'); assert.ok(row.item_name, '记录应回填商品名称'); } }); it('按明细查询:仅返回该明细的记录,仅传 detail_id 也可查', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; await reportCheck(check.id, firstDetail.id, 3, TEST_LOCATION_CODE); await reportCheck(check.id, details.rows[1].id, 4); const byTaskAndDetail = await listRecords({ id: check.id, detailId: firstDetail.id }); assert.equal(byTaskAndDetail.total, 1, '只返回该明细的记录'); assert.equal(Number(byTaskAndDetail.rows[0].detail_id), Number(firstDetail.id)); assert.equal(Number(byTaskAndDetail.rows[0].quantity), 3); assert.equal(byTaskAndDetail.rows[0].item_code, firstDetail.item_code); const byDetailOnly = await listRecords({ detailId: firstDetail.id }); assert.equal(byDetailOnly.total, 1, '仅传 detail_id 应可查询'); assert.equal(Number(byDetailOnly.rows[0].detail_id), Number(firstDetail.id)); }); it('分页:total 为全量,按页返回且两页无交集', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const reportLocations = await fetchValidLocations(3); assert.equal(reportLocations.length, 3, '前置:测试仓库应有 3 个有效库位'); await reportCheck(check.id, detailId, 1, reportLocations[0].space_code, { spaceId: reportLocations[0].id }); await reportCheck(check.id, detailId, 2, reportLocations[1].space_code, { spaceId: reportLocations[1].id }); await reportCheck(check.id, detailId, 3, reportLocations[2].space_code, { spaceId: reportLocations[2].id }); const firstPage = await listRecords({ id: check.id, pagination: { page: 1, pageSize: 2 }, }); assert.equal(firstPage.total, 3); assert.equal(firstPage.rows.length, 2); assert.equal(firstPage.page, 1); assert.equal(firstPage.pageSize, 2); const secondPage = await listRecords({ id: check.id, pagination: { page: 2, pageSize: 2 }, }); assert.equal(secondPage.total, 3); assert.equal(secondPage.rows.length, 1); const firstPageIds = firstPage.rows.map(row => Number(row.id)); const secondPageIds = secondPage.rows.map(row => Number(row.id)); for (const firstId of firstPageIds) { assert.ok(!secondPageIds.includes(firstId), '两页记录不应重复'); for (const secondId of secondPageIds) { assert.ok(firstId > secondId, '倒序分页:第一页记录 id 应大于第二页'); } } }); it('id 与 detail_id 均未传报 400', async () => { await assert.rejects(async () => { await listRecords({}); }, error => error.code === 400); }); }); // ------------------- finish:完成盘点 ------------------- describe('finish 完成盘点', () => { it('存在未盘明细不再拦截:未盘按实盘 0 计盘亏,返回 unchecked_items', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const checkedDetail = details.rows[0]; const uncheckedDetail = details.rows[1]; await reportCheck(check.id, checkedDetail.id, Number(checkedDetail.system_quantity) + 2); const result = await finishCheck(check.id); assert.equal(result.status, 'completed'); assert.equal(result.total_items, 2); assert.equal(result.checked_items, 1); assert.equal(result.unchecked_items, 1, '未盘明细数应为 1'); assert.equal(result.profit_total, 2, '已盘明细盘盈 2'); assert.equal( result.loss_total, Number(uncheckedDetail.system_quantity), '未盘明细按实盘 0 处理,盘亏=账面快照' ); assert.equal(result.diff_items, 2, '盘盈 1 条 + 未盘盘亏 1 条'); const row = await findCheckRow(check.id); assert.equal(row.status, 'completed'); assert.equal(row.detail_status, 'all_checked'); assert.equal(row.checked_items, 1); assert.equal(row.diff_items, 2); assert.ok(row.end_time, '完成盘点应写入 end_time'); }); it('全部已盘 → completed + end_time,盘盈盘亏汇总正确', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; await reportCheck(check.id, firstDetail.id, Number(firstDetail.system_quantity) + 5); await reportCheck(check.id, secondDetail.id, Number(secondDetail.system_quantity) - 3); const beforeFinish = Date.now(); const result = await finishCheck(check.id); const afterFinish = Date.now(); assert.equal(result.status, 'completed'); assert.equal(result.total_items, 2); assert.equal(result.checked_items, 2); assert.equal(result.diff_items, 2); assert.equal(result.unchecked_items, 0, '全部已盘时未盘明细数应为 0'); assert.equal(result.profit_total, 5, '盘盈合计应为 5'); assert.equal(result.loss_total, 3, '盘亏合计应为 3'); const row = await findCheckRow(check.id); assert.equal(row.status, 'completed'); assert.equal(row.detail_status, 'all_checked'); assert.ok(row.end_time, '完成盘点应写入 end_time'); const endTs = new Date(row.end_time).getTime(); assert.ok( endTs >= beforeFinish - 5000 && endTs <= afterFinish + 5000, 'end_time 应≈完成盘点时间' ); }); }); // ------------------- 汇总/差异:库位行口径 ------------------- describe('汇总/差异 库位行口径', () => { it('库位行差异口径:任一商品实盘≠账面即该行有差异,diff_items 按明细去重', async () => { const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); const bookA = Number(bookMap.get(stockIds[0]) || 0); // 实盘=账面 → 无差异 const first = await reportCheck(check.id, detail.id, bookA, undefined, { stockId: stockIds[0] }); assert.equal(first.diff_items, 0, '实盘=账面应无差异'); assert.equal(first.detail_status, 'all_checked'); // 实盘=账面+3 → 该行有差异(行内任一商品差异即整行差异) const second = await reportCheck(check.id, detail.id, bookA + 3, undefined, { stockId: stockIds[0] }); assert.equal(second.diff_items, 1); assert.equal(second.checked_items, 1, 'checked_items 按明细去重不重复累计'); const result = await resultCheck(check.id); const row = result.rows[0]; assert.equal(row.is_diff, 1); assert.equal(row.stocks[0].diff_quantity, 3); }); it('finish 库位行按商品聚合 vs wms_storage 计算盘盈盘亏,未盘库位行不计差异', async () => { const check = await createCheck({ type: 'location' }); const emptySpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, raw: true, }); assert.ok(emptySpace, `空库位编码不存在(${TEST_EMPTY_LOCATION_CODE})`); assert.equal( await ctx.model.Storage.count({ where: { space_id: Number(emptySpace.id) } }), 0, '测试用空库位应无库存记录' ); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); const bookA = Number(bookMap.get(stockIds[0]) || 0); const bookB = Number(bookMap.get(stockIds[1]) || 0); assert.ok(bookB >= 2, '库位行盘亏用例要求第二商品账面≥2(真实数据不满足时需调整固定库位)'); const details = await detailCheck(check.id); const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); await reportCheck(check.id, checkedDetail.id, bookA + 5, undefined, { stockId: stockIds[0] }); await reportCheck(check.id, checkedDetail.id, bookB - 2, undefined, { stockId: stockIds[1] }); const result = await finishCheck(check.id); assert.equal(result.status, 'completed'); assert.equal(result.total_items, 2); assert.equal(result.checked_items, 1, '仅固定测试库位行已盘'); assert.equal(result.unchecked_items, 1, '未盘空库位行计入未盘'); assert.equal(result.diff_items, 1, '库位行差异按明细去重计数'); assert.equal(result.profit_total, 5, '盘盈合计=商品A +5'); assert.equal(result.loss_total, 2, '盘亏合计=商品B -2'); const row = await findCheckRow(check.id); assert.equal(row.status, 'completed'); assert.equal(row.diff_items, 1); assert.ok(row.end_time, '完成盘点应写入 end_time'); }); }); // ------------------- list:列表查询 ------------------- describe('list 列表查询', () => { it('status 单值筛选:仅返回指定状态的任务', async () => { const createdCheck = await createCheck(); const submittedCheck = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(submittedCheck.id, [ stocks[0].id ]); await submitCheck(submittedCheck.id); const result = await listChecks({ status: 'submitted' }); assert.ok(Array.isArray(result.rows)); assert.ok(result.rows.length > 0); for (const row of result.rows) { assert.equal(row.status, 'submitted', '筛选结果只能包含 submitted 状态'); } const ids = result.rows.map(row => row.id); assert.ok(ids.includes(submittedCheck.id), '应包含本次提交的任务'); assert.ok(!ids.includes(createdCheck.id), 'created 任务不应出现在 submitted 筛选结果中'); }); it('status 数组筛选:created/submitted 均可命中', async () => { const createdCheck = await createCheck(); const submittedCheck = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(submittedCheck.id, [ stocks[0].id ]); await submitCheck(submittedCheck.id); const result = await listChecks({ status: [ 'created', 'submitted' ] }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(createdCheck.id), 'created 任务应命中数组筛选'); assert.ok(ids.includes(submittedCheck.id), 'submitted 任务应命中数组筛选'); for (const row of result.rows) { assert.ok([ 'created', 'submitted' ].includes(row.status), `非法状态出现在筛选结果: ${row.status}`); } }); it('store_id 货主筛选:只返回固定测试货主的任务', async () => { const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: uniqueTitle('货主筛选'), }); const result = await listChecks({ storeId: TEST_STORE_ID }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(storeCheck.id), '固定测试货主的任务应命中筛选'); for (const row of result.rows) { assert.equal(Number(row.store_id), TEST_STORE_ID, '筛选结果只能包含固定测试货主'); } }); it('list 返回 store_name:store 类型任务(store_id=1000000)取合约备注,无合约回退公司全称', async () => { const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: uniqueTitle('store_name合约备注'), }); const result = await listChecks({ keyword: storeCheck.title }); const row = result.rows.find(item => item.id === storeCheck.id); assert.ok(row, '本次创建的任务应出现在 keyword 查询结果中'); assert.ok(Object.prototype.hasOwnProperty.call(row, 'store_name'), 'rows 每条应包含 store_name 字段'); assert.equal(typeof row.store_name, 'string', 'store_name 应为字符串'); assert.ok(row.store_name.length > 0, 'store_id=1000000 的任务 store_name 不应为空'); // 与实现口径对齐:优先合约表 store_remask,无合约/备注为空时回退公司全称 const contractRow = await ctx.model.StoreWarehouse.findOne({ where: { store_id: TEST_STORE_ID, warehouse_id: TEST_WAREHOUSE_ID }, attributes: [ 'store_remask' ], raw: true, }); if (contractRow && contractRow.store_remask) { assert.equal(row.store_name, contractRow.store_remask, '有合约备注时应与 wms_store_warehouse.store_remask 一致'); } else { const storeRow = await ctx.model.Store.findOne({ where: { id: TEST_STORE_ID }, attributes: [ 'company_name' ], raw: true, }); assert.ok(storeRow && storeRow.company_name, '无合约备注时 wms_store.company_name 应存在且非空(否则无法兜底)'); assert.equal(row.store_name, storeRow.company_name, '无合约备注时应回退 wms_store.company_name'); } }); it('list 返回 store_name 空串:type=location 任务 store_id 为空', async () => { const allCheck = await createCheck({ type: 'location', title: uniqueTitle('store_name空串全盘') }); const mainRow = await findCheckRow(allCheck.id); assert.ok(mainRow.store_id === null || mainRow.store_id === undefined || mainRow.store_id === 0 || mainRow.store_id === '', '库位任务 store_id 应为空'); const result = await listChecks({ keyword: allCheck.title }); const row = result.rows.find(item => item.id === allCheck.id); assert.ok(row, '本次创建的任务应出现在 keyword 查询结果中'); assert.ok(Object.prototype.hasOwnProperty.call(row, 'store_name'), 'rows 每条应包含 store_name 字段'); assert.equal(row.store_name, '', 'store_id 为空的任务 store_name 应为空字符串'); }); it('store_id 筛选 + store_name 组合正确:仅返回该货主任务且名称一致', async () => { const prefix = uniqueTitle('store_name组合筛选'); const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: `${prefix}-store` }); const goodsCheck = await createCheck({ title: `${prefix}-goods` }); const result = await listChecks({ storeId: TEST_STORE_ID, keyword: prefix }); const ids = result.rows.map(item => item.id); assert.ok(ids.includes(storeCheck.id), 'store 类型任务应命中 store_id 筛选'); assert.ok(!ids.includes(goodsCheck.id), 'store_id 为空的商品任务不应命中 store_id 筛选'); const contractRow = await ctx.model.StoreWarehouse.findOne({ where: { store_id: TEST_STORE_ID, warehouse_id: TEST_WAREHOUSE_ID }, attributes: [ 'store_remask' ], raw: true, }); const fallbackRow = contractRow && contractRow.store_remask ? null : await ctx.model.Store.findOne({ where: { id: TEST_STORE_ID }, attributes: [ 'company_name' ], raw: true, }); const expectedName = (contractRow && contractRow.store_remask) || (fallbackRow && fallbackRow.company_name) || ''; for (const row of result.rows) { assert.equal(Number(row.store_id), TEST_STORE_ID, 'store_id 筛选结果只能包含固定测试货主'); assert.equal(row.store_name, expectedName, '筛选行 store_name 应与合约备注(或公司全称兜底)一致'); } const target = result.rows.find(item => item.id === storeCheck.id); assert.ok(target, '本次创建的任务应出现在 store_id 筛选结果中'); assert.ok(target.store_name.length > 0, '固定测试货主的 store_name 不应为空'); }); it('分页 total 正确:keyword 限定范围后按页返回', async () => { const prefix = uniqueTitle('分页测试'); await createCheck({ title: `${prefix}-1` }); await createCheck({ title: `${prefix}-2` }); await createCheck({ title: `${prefix}-3` }); const firstPage = await listChecks({ keyword: prefix, pagination: { page: 1, pageSize: 2 }, }); assert.equal(firstPage.total, 3, 'total 应为关键词命中的全部 3 条'); assert.equal(firstPage.rows.length, 2, '第一页应返回 2 条'); const secondPage = await listChecks({ keyword: prefix, pagination: { page: 2, pageSize: 2 }, }); assert.equal(secondPage.total, 3); assert.equal(secondPage.rows.length, 1, '第二页应返回 1 条'); }); it('type 单值筛选:location 与 goods 任务并存时只返回 location', async () => { const locationCheck = await createCheck({ type: 'location' }); const goodsCheck = await createCheck(); const result = await listChecks({ type: 'location' }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(locationCheck.id), 'location 任务应命中 type=location'); assert.ok(!ids.includes(goodsCheck.id), 'goods 任务不应命中 type=location'); for (const row of result.rows) { assert.equal(row.type, 'location', '筛选结果只能包含 location 任务'); } }); it('type 数组筛选 in:命中仅限传入类型(store 不混入 location/goods)', async () => { const locationCheck = await createCheck({ type: 'location' }); const goodsCheck = await createCheck(); const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); const result = await listChecks({ type: [ 'location', 'goods' ] }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(locationCheck.id), 'location 任务应命中数组筛选'); assert.ok(ids.includes(goodsCheck.id), 'goods 任务应命中数组筛选'); assert.ok(!ids.includes(storeCheck.id), 'store 任务不应命中 location/goods 数组筛选'); for (const row of result.rows) { assert.ok([ 'location', 'goods' ].includes(row.type), `非法类型出现在筛选结果: ${row.type}`); } }); it('mode 筛选:open/blind 各命中对应任务(location 强制盲盘口径)', async () => { const openCheck = await createCheck({ type: 'goods', mode: 'open' }); const blindCheck = await createCheck({ type: 'location' }); const blindRow = await findCheckRow(blindCheck.id); assert.equal(blindRow.mode, 'blind', 'location 任务应被强制为盲盘,作为 mode 筛选的盲盘样本'); const openResult = await listChecks({ mode: 'open' }); const openIds = openResult.rows.map(row => row.id); assert.ok(openIds.includes(openCheck.id), 'open 任务应命中 mode=open'); assert.ok(!openIds.includes(blindCheck.id), 'blind 任务不应命中 mode=open'); for (const row of openResult.rows) { assert.equal(row.mode, 'open', 'mode=open 筛选结果只能包含明盘任务'); } const bothResult = await listChecks({ mode: [ 'open', 'blind' ] }); const bothIds = bothResult.rows.map(row => row.id); assert.ok(bothIds.includes(openCheck.id), 'mode 数组筛选应命中 open 任务'); assert.ok(bothIds.includes(blindCheck.id), 'mode 数组筛选应命中 blind 任务'); }); it('created_at 单值 gte:只返回创建时间不早于阈值的任务(直插 created_at 造数)', async () => { const oldCheck = await createCheck({ title: uniqueTitle('created_at单值gte') }); const newCheck = await createCheck({ title: uniqueTitle('created_at单值gte') }); const oldRow = await setCheckCreatedAt(oldCheck.id, new Date('2019-06-15T00:00:00Z')); const newRow = await setCheckCreatedAt(newCheck.id, new Date('2021-05-10T00:00:00Z')); assert.equal(new Date(oldRow.created_at).getFullYear(), 2019, 'created_at 应直插为 2019 年'); assert.equal(new Date(newRow.created_at).getFullYear(), 2021, 'created_at 应直插为 2021 年'); const result = await listChecks({ createdAt: '2021-01-01' }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(newCheck.id), '2021 年创建的任务应命中 gte=2021-01-01'); assert.ok(!ids.includes(oldCheck.id), '2019 年创建的任务不应命中 gte=2021-01-01'); }); it('created_at 区间 between:只返回区间内创建的任务(直插 created_at 造数)', async () => { const inRangeCheck = await createCheck({ title: uniqueTitle('created_at区间between') }); const outRangeCheck = await createCheck({ title: uniqueTitle('created_at区间between') }); await setCheckCreatedAt(inRangeCheck.id, new Date('2019-06-15T00:00:00Z')); await setCheckCreatedAt(outRangeCheck.id, new Date('2021-05-10T00:00:00Z')); const result = await listChecks({ createdAt: [ '2019-01-01', '2019-12-31' ] }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(inRangeCheck.id), '2019-06 创建的任务应命中 2019 年区间'); assert.ok(!ids.includes(outRangeCheck.id), '2021 年创建的任务不应命中 2019 年区间'); }); it('start_time/end_time 范围:report/finish 后按盘点时间范围筛选', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); await finishCheck(check.id); const finishedRow = await findCheckRow(check.id); assert.ok(finishedRow.start_time, 'report 后 start_time 应落库'); assert.ok(finishedRow.end_time, 'finish 后 end_time 应落库'); const wideRange = [ '2000-01-01', '2099-12-31' ]; const startHit = await listChecks({ startTime: wideRange }); assert.ok(startHit.rows.map(row => row.id).includes(check.id), 'start_time 应命中宽区间'); const endHit = await listChecks({ endTime: wideRange }); assert.ok(endHit.rows.map(row => row.id).includes(check.id), 'end_time 应命中宽区间'); const pastRange = [ '1990-01-01', '1999-12-31' ]; const startMiss = await listChecks({ startTime: pastRange }); assert.ok(!startMiss.rows.map(row => row.id).includes(check.id), 'start_time 不应命中 1999 年前的区间'); const endMiss = await listChecks({ endTime: pastRange }); assert.ok(!endMiss.rows.map(row => row.id).includes(check.id), 'end_time 不应命中 1999 年前的区间'); }); it('组合筛选 type+status:两个条件同时生效', async () => { const goodsSubmitted = await createCheck({ title: uniqueTitle('组合筛选type-status') }); const goodsCreated = await createCheck({ title: uniqueTitle('组合筛选type-status') }); const locationSubmitted = await createCheck({ type: 'location', title: uniqueTitle('组合筛选type-status') }); const stocks = await fetchStockRows(1); await addDetail(goodsSubmitted.id, [ stocks[0].id ]); await submitCheck(goodsSubmitted.id); await addLocationDetail(locationSubmitted.id, [ TEST_LOCATION_CODE ]); await submitCheck(locationSubmitted.id); const result = await listChecks({ type: 'goods', status: 'submitted' }); const ids = result.rows.map(row => row.id); assert.ok(ids.includes(goodsSubmitted.id), 'goods+submitted 任务应命中组合筛选'); assert.ok(!ids.includes(goodsCreated.id), 'goods+created 任务不应命中 status=submitted'); assert.ok(!ids.includes(locationSubmitted.id), 'location+submitted 任务不应命中 type=goods'); for (const row of result.rows) { assert.equal(row.type, 'goods', '组合筛选结果只能包含 goods 任务'); assert.equal(row.status, 'submitted', '组合筛选结果只能包含 submitted 任务'); } }); it('非法时间值静默忽略:单值/数组/空值均不报错', async () => { const check = await createCheck({ title: uniqueTitle('非法时间值') }); const singleResult = await listChecks({ createdAt: 'not-a-date' }); assert.ok(Array.isArray(singleResult.rows), '非法单值时间不应报错'); assert.equal(typeof singleResult.total, 'number', '非法单值时间应返回正常分页结构'); assert.ok(singleResult.rows.map(row => row.id).includes(check.id), '非法单值时间应按无条件返回全部任务'); const rangeResult = await listChecks({ createdAt: [ 'bad-from', 'bad-to' ] }); assert.ok(Array.isArray(rangeResult.rows), '两端均非法的区间不应报错'); assert.ok(rangeResult.rows.map(row => row.id).includes(check.id), '两端均非法的区间应按无条件返回全部任务'); const partialRangeResult = await listChecks({ startTime: [ 'bad-from', '2099-12-31' ] }); assert.ok(Array.isArray(partialRangeResult.rows), '一端非法的区间不应报错(降级为 lte)'); const emptyResult = await listChecks({ createdAt: '' }); assert.ok(Array.isArray(emptyResult.rows), '空字符串时间不应报错'); }); }); // ------------------- detail:查询任务详情(只返回任务本身信息) ------------------- describe('detail 查询任务详情(只返回任务本身信息)', () => { it('只返回任务本身信息({ check }),不返回明细 rows/total', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const result = await ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, }); assert.deepEqual(Object.keys(result).sort(), [ 'check' ], 'detail 只返回 check,不返回 rows/total'); assert.equal(result.rows, undefined, 'detail 不应返回明细 rows'); assert.equal(result.total, undefined, 'detail 不应返回明细 total'); assert.equal(Number(result.check.id), Number(check.id)); assert.equal(result.check.check_no, check.check_no); assert.equal(result.check.status, 'created'); assert.equal(result.check.detail_status, 'none_checked'); assert.equal(result.check.total_items, 2, 'check.total_items 应为明细行数'); assert.equal(result.check.checked_items, 0); assert.equal(result.check.diff_items, 0); assert.ok(result.check.created_at, 'check 应含创建时间'); // 数量差异汇总:未盘商品行按实盘 0 计盘亏(loss_total = 账面快照合计,正数口径) const snapshotRows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: Number(check.id) }, attributes: [ 'system_quantity' ], raw: true, }); const expectedLoss = snapshotRows.reduce((sum, row) => sum + (Number(row.system_quantity) || 0), 0); assert.equal(result.check.profit_total, 0, '未盘任务盘盈应为 0'); assert.equal(result.check.loss_total, expectedLoss, '未盘任务盘亏应为账面快照合计(与 finish 未盘口径一致)'); }); it('已盘后数量差异汇总:profit_total/loss_total 与 finish 口径一致', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const firstSnapshot = Number(firstDetail.system_quantity); const secondSnapshot = Number(secondDetail.system_quantity); // 第一行盘盈 2、第二行盘亏 1 await reportCheck(check.id, firstDetail.id, firstSnapshot + 2, TEST_LOCATION_CODE); await reportCheck(check.id, secondDetail.id, secondSnapshot - 1, TEST_EMPTY_LOCATION_CODE); const detailResult = await ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, }); assert.equal(detailResult.check.profit_total, 2, '盘盈合计应为 2'); assert.equal(detailResult.check.loss_total, 1, '盘亏合计应为 1(正数口径)'); // 与 finish 返回口径交叉验证 const finishResult = await finishCheck(check.id); assert.equal(detailResult.check.profit_total, finishResult.profit_total, 'detail 盘盈应与 finish 一致'); assert.equal(detailResult.check.loss_total, finishResult.loss_total, 'detail 盘亏应与 finish 一致'); assert.equal(detailResult.check.diff_items, finishResult.diff_items, 'detail 差异明细数应与 finish 一致'); }); it('盘点任务ID 非法 / 任务不存在报 400', async () => { const missingId = await findFreeCheckId(); await assert.rejects( () => ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: 0 }), error => error.code === 400 && /盘点任务ID不能为空/.test(error.message) ); await assert.rejects( () => ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: missingId }), error => error.code === 400 && /盘点任务不存在/.test(error.message) ); }); }); // ------------------- result:盘点结果聚合 ------------------- describe('result 盘点结果聚合', () => { it('盘点前(无作业记录):rows 直接返回 wms_stock_check_detail 明细范围行', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const result = await resultCheck(check.id); const details = await detailCheck(check.id); assert.equal(result.total, 2); assert.equal(result.rows.length, details.rows.length); for (const row of result.rows) { assert.equal(row.scope_type, 'goods', '明细行应含 scope_type'); assert.ok(row.stock_id, '明细行应含 stock_id'); assert.ok(row.location_id, '明细行应含 location_id'); assert.ok(row.location_code, '明细行应含库位编码'); assert.ok(row.item_code, '明细行应含商品编码快照'); assert.ok(Number(row.system_quantity) >= 0, '明细行应含账面快照'); } assert.deepEqual( result.rows.map(row => Number(row.id)), details.rows.map(row => Number(row.id)), 'rows 应为明细表原始行' ); }); it('待提交(submitted)状态:rows 同样返回明细范围行(后台盘点前查看明细)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); const result = await resultCheck(check.id); assert.equal(result.check.status, 'submitted'); assert.equal(result.rows.length, 2, '待提交任务应返回明细范围行'); assert.ok( result.rows.every(row => row.scope_type === 'goods' && row.stock_id && row.location_code), '待提交任务 rows 应为明细表原始行(含商品/库位/快照)' ); }); it('已盘明细:location_codes/checkers 合并去重、records 完整、last_checked_at 取最近', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人A' }); await reportCheck(check.id, detailId, 2, TEST_LOCATION_CODE_3, { checkerName: '盘点人B' }); const result = await resultCheck(check.id); const row = result.rows[0]; assert.equal(row.checked_quantity, 9, '已盘数量应为三条记录合计'); assert.equal(row.status, 'checked'); assert.deepEqual(row.location_codes, [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2, TEST_LOCATION_CODE_3 ], '库位编码应合并去重'); assert.deepEqual(row.checkers, [ '盘点人A', '盘点人B' ], '盘点人应合并去重'); assert.equal(row.records.length, 3, 'records 应包含全部作业记录'); for (const record of row.records) { assert.ok(record.location_code, '记录应含库位编码'); assert.ok(record.quantity !== undefined, '记录应含实盘数量'); assert.ok(record.checker_name, '记录应含盘点人'); assert.ok(record.checked_at, '记录应含上报时间'); } assert.ok(row.last_checked_at, '最近盘点时间应非空'); const lastRecord = row.records[row.records.length - 1]; assert.equal( new Date(row.last_checked_at).getTime(), new Date(lastRecord.checked_at).getTime(), 'last_checked_at 应为最近一条记录的上报时间' ); }); it('result 与 detail 行一一对应:范围行数与行 id 完全一致', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 1, TEST_LOCATION_CODE); const result = await resultCheck(check.id); assert.equal(result.total, details.total, 'result 与 detail 范围行数应一致'); assert.equal(result.rows.length, details.rows.length); const detailIds = details.rows.map(row => Number(row.id)); const resultIds = result.rows.map(row => Number(row.id)); assert.deepEqual(resultIds, detailIds, 'result 行 id 集合应与 detail 一致'); for (const row of result.rows) { assert.ok(row.stock_id, '商品范围行应含 stock_id'); } }); it('result 商品行聚合与 recordList 交叉验证:checked_quantity/diff/locations 与记录表口径一致', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const snapshot = Number(details.rows[0].system_quantity); await reportCheck(check.id, detailId, snapshot + 2, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人B' }); const result = await resultCheck(check.id); const row = result.rows[0]; const listed = await listRecords({ id: check.id, detailId }); assert.equal(listed.total, 2, 'recordList 应返回该明细全部作业记录'); const expectedChecked = listed.rows.reduce((sum, record) => sum + Number(record.quantity), 0); assert.equal(row.checked_quantity, expectedChecked, 'checked_quantity 应与 recordList 数量合计一致'); assert.equal(row.diff_quantity, expectedChecked - snapshot, 'diff_quantity=已盘合计-账面快照'); assert.equal(row.is_diff, 1); assert.equal(row.status, 'checked'); assert.equal(row.records.length, listed.total, 'records 条数应与 recordList 一致'); assert.deepEqual( row.records.map(record => Number(record.id)).sort((left, right) => left - right), listed.rows.map(record => Number(record.id)).sort((left, right) => left - right), 'records 记录 id 应与 recordList 完全一致' ); assert.deepEqual( row.location_codes.sort(), [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2 ].sort(), 'location_codes 应与记录库位编码一致' ); const locationQuantityMap = new Map(row.locations.map(item => [ item.location_code, item.quantity ])); assert.equal(locationQuantityMap.get(TEST_LOCATION_CODE), snapshot + 2, '有库位组数量应为该库位上报值'); assert.equal(locationQuantityMap.get(TEST_LOCATION_CODE_2), 4, '无库位组数量应为该库位上报值'); }); it('多库位商品合并为一行:locations 输出各库位账面快照与实盘,差异=实盘合计-账面快照合计', async () => { const { Op, literal } = ctx.app.Sequelize; // 找一个在两个启用库位都有库存的商品(与 addDetail 拆行用例同口径) const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, }, attributes: [ 'stock_id', 'space_id', [ literal('SUM(available_quantity)'), 'totalQuantity' ]], group: [ 'stock_id', 'space_id' ], raw: true, }); const spacesByStock = new Map(); for (const row of storageRows) { const stockId = Number(row.stock_id); if (!spacesByStock.has(stockId)) { spacesByStock.set(stockId, []); } spacesByStock.get(stockId).push(row); } const multiStockEntry = [ ...spacesByStock.entries() ].find(([ , rows ]) => rows.length >= 2); assert.ok(multiStockEntry, '前置:测试库应存在多库位库存商品'); const multiStockId = Number(multiStockEntry[0]); const multiStock = await ctx.model.StockWarehouse.findOne({ where: { id: multiStockId, warehouse_id: TEST_WAREHOUSE_ID }, raw: true, }); assert.ok(multiStock, '前置:多库位商品应存在于 wms_stock_warehouse'); const check = await createCheck({ type: 'goods', storeId: multiStock.store_id || null }); const addResult = await addDetail(check.id, [ multiStockId ]); assert.equal(addResult.total_items, 1, '按商品盘点 total_items 按商品计数'); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); assert.ok(details.rows.length >= 2, '前置:商品应按库位拆成多行'); // 全部库位上报:第一个库位盘盈 5、第二个库位盘盈 1、其余库位实盘=账面(差异合计恒为 6) const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; for (const detail of details.rows) { let quantity = Number(detail.system_quantity); if (Number(detail.id) === Number(firstDetail.id)) { quantity += 5; } if (Number(detail.id) === Number(secondDetail.id)) { quantity += 1; } await reportCheck(check.id, detail.id, quantity, detail.location_code || undefined); } const result = await resultCheck(check.id); assert.equal(result.total, 1, '多库位商品应合并为一行'); assert.equal(result.rows.length, 1); const row = result.rows[0]; assert.equal(Number(row.stock_id), multiStockId); assert.equal(row.scope_type, 'goods'); assert.equal(row.location_id, null, '合并行不绑定单一库位'); assert.equal(row.location_code, null, '合并行不绑定单一库位编码'); const totalSnapshot = details.rows.reduce((sum, detail) => sum + Number(detail.system_quantity), 0); assert.equal(Number(row.system_quantity), totalSnapshot, '行级账面=各库位账面快照合计'); assert.equal(row.checked_quantity, totalSnapshot + 6, '已盘数量=各库位实盘合计'); assert.equal(row.diff_quantity, 6, '差异=实盘合计-账面快照合计'); assert.equal(row.is_diff, 1); assert.equal(row.status, 'checked'); assert.equal(row.records.length, details.rows.length, 'records 应包含全部库位作业记录'); const firstLocation = row.locations.find(item => item.location_code === firstDetail.location_code); assert.ok(firstLocation, 'locations 应含第一个库位'); assert.equal(Number(firstLocation.system_quantity), Number(firstDetail.system_quantity), '库位账面=创建明细时的快照'); assert.equal(Number(firstLocation.quantity), Number(firstDetail.system_quantity) + 5, '库位实盘=该库位上报值'); const secondLocation = row.locations.find(item => item.location_code === secondDetail.location_code); assert.ok(secondLocation, 'locations 应含第二个库位'); assert.equal(Number(secondLocation.system_quantity), Number(secondDetail.system_quantity), '库位账面=创建明细时的快照'); assert.equal(Number(secondLocation.quantity), Number(secondDetail.system_quantity) + 1, '库位实盘=该库位上报值'); }); }); // ------------------- result.locations:库位分组聚合 ------------------- describe('result.locations 库位分组聚合', () => { it('多库位分组:按库位聚合数量、空库位归 null 组、按组内首条记录 id 升序', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); await reportCheck(check.id, detailId, 5, TEST_LOCATION_CODE_2); await reportCheck(check.id, detailId, 7, TEST_LOCATION_CODE); await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE_3); const result = await resultCheck(check.id); const row = result.rows[0]; // 商品按商品合并后:快照库位(含账面快照)+ 已盘库位(按首条记录 id 升序追加) const quantityByCode = new Map(row.locations.map(location => [ location.location_code, location.quantity ])); assert.equal(quantityByCode.get(TEST_LOCATION_CODE), 7, '命中库位数量应为该库位最新值'); assert.equal(quantityByCode.get(TEST_LOCATION_CODE_2), 5); assert.equal(quantityByCode.get(TEST_LOCATION_CODE_3), 3); const snapshotEntry = row.locations.find(location => Number(location.system_quantity) > 0); assert.ok(snapshotEntry, '应含账面快照库位(system_quantity=创建明细时账面快照)'); assert.equal( Number(snapshotEntry.system_quantity), Number(details.rows[0].system_quantity), '账面快照应为明细快照值' ); const checkedEntry = row.locations.find(location => location.location_code === TEST_LOCATION_CODE); assert.equal(Number(checkedEntry.location_id), TEST_LOCATION_ID, '命中库位应回填 location_id'); const otherEntry = row.locations.find(location => location.location_code === TEST_LOCATION_CODE_2); assert.equal(Number(otherEntry.location_id), TEST_LOCATION_ID_2, '有效库位应回填 location_id'); assert.equal(row.checked_quantity, 15, '已盘数量=各库位最新值合计'); assert.equal(row.records.length, 3, 'records 流水保持三条'); assert.equal(row.location_codes.length, 3, '既有聚合字段 location_codes 不变'); }); it('历史无库位记录(location_code=空串)归入 location_code=null 组(report 不再产生该分组)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; // report 已强制 space_id,无库位上报直接被拒 await assert.rejects(async () => { await reportCheck(check.id, detail.id, 4, undefined, { spaceId: 0 }); }, error => error.code === 400 && error.message.includes('缺少库位ID')); // 历史脏数据(空串库位)仍按既有口径归入 null 组 await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: Number(detail.stock_id), location_id: null, location_code: '', quantity: 6, is_empty: false, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); const result = await resultCheck(check.id); const row = result.rows[0]; const nullGroup = row.locations.find(location => location.location_code === null); assert.ok(nullGroup, '空库位归 location_code=null 组'); assert.equal(nullGroup.location_id, null); assert.equal(Number(nullGroup.quantity), 6, '无库位组数量为该记录实盘值'); assert.equal(Number(nullGroup.system_quantity), 0, '无库位组无账面快照'); assert.equal(Number(row.checked_quantity), 6); }); }); // ------------------- result:库位行 stocks 聚合(账面来自 wms_storage) ------------------- describe('result 库位行 stocks 聚合', () => { it('库位行 stocks 按商品聚合:多商品账面来自 wms_storage、行级差异为各商品差异代数和', async () => { const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); const bookA = Number(bookMap.get(stockIds[0]) || 0); const bookB = Number(bookMap.get(stockIds[1]) || 0); const qtyA = bookA + 5; const qtyB = Math.max(0, bookB - 2); await reportCheck(check.id, detail.id, qtyA, undefined, { stockId: stockIds[0] }); await reportCheck(check.id, detail.id, qtyB, undefined, { stockId: stockIds[1] }); const result = await resultCheck(check.id); const row = result.rows[0]; assert.equal(row.scope_type, 'location', '库位行应输出 scope_type=location'); assert.equal(row.status, 'checked'); assert.equal(row.checked_quantity, qtyA + qtyB, '行级已盘数量=行内商品已盘合计'); const expectedDiff = 5 + (qtyB - bookB); assert.equal(row.diff_quantity, expectedDiff, '行级差异=各商品差异代数和'); assert.equal(row.is_diff, expectedDiff !== 0 ? 1 : 0); assert.equal(row.stocks.length, 2); assert.deepEqual( row.stocks.map(stock => Number(stock.stock_id)), stockIds, 'stocks 应按 stock_id 升序' ); const stockA = row.stocks[0]; assert.equal(Number(stockA.system_quantity), bookA, '账面应来自 wms_storage 实时汇总'); assert.equal(stockA.checked_quantity, qtyA); assert.equal(stockA.diff_quantity, 5); assert.ok(stockA.item_code, 'stocks 应回填商品编码'); const stockB = row.stocks[1]; assert.equal(Number(stockB.system_quantity), bookB); assert.equal(stockB.checked_quantity, qtyB); assert.equal(stockB.diff_quantity, qtyB - bookB); // 与作业记录表交叉验证:records 商品 ID 应与上报商品一致 assert.equal(row.records.length, 2, 'records 应包含行内全部作业记录'); assert.deepEqual( row.records.map(record => Number(record.stock_id)).sort((left, right) => left - right), [ ...stockIds ].sort((left, right) => left - right), 'records 商品 ID 应与上报商品一致' ); }); it('库位无库存时账面按 0:diff=已盘-0', async () => { const check = await createCheck({ type: 'location' }); const emptySpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, raw: true, }); assert.ok(emptySpace, `空库位编码不存在(${TEST_EMPTY_LOCATION_CODE})`); const storageCount = await ctx.model.Storage.count({ where: { space_id: Number(emptySpace.id) }, }); assert.equal(storageCount, 0, '测试用空库位应无库存记录(账面 0 口径依赖)'); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const stocks = await fetchStockRows(1); const details = await detailCheck(check.id); const detail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); await reportCheck(check.id, detail.id, 7, undefined, { stockId: stocks[0].id }); const result = await resultCheck(check.id); const row = result.rows.find(item => item.location_code === TEST_EMPTY_LOCATION_CODE); assert.equal(row.stocks.length, 1); assert.equal(Number(row.stocks[0].system_quantity), 0, '无库存库位账面应为 0'); assert.equal(row.stocks[0].checked_quantity, 7); assert.equal(row.stocks[0].diff_quantity, 7, 'diff=已盘-0'); assert.equal(row.diff_quantity, 7); assert.equal(row.is_diff, 1); }); }); // ------------------- workData:盘点作业数据(单接口三视图) ------------------- describe('workData 盘点作业数据(location/goods/space 单接口三视图)', () => { it('location 视图:库位范围行与明细一致、未盘行 status=unchecked、子列表为空、不返回 check 且 view=location', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); assert.equal(details.total, 2, '前置:任务应有两条库位范围行'); const data = await workDataCheck(check.id, 'location'); assert.deepEqual( Object.keys(data).sort(), [ 'page', 'pageSize', 'rows', 'total', 'view' ], 'workData 只返回作业数据行 + view(不返回 check,任务信息请调 detail)' ); assert.equal(data.view, 'location', '库位任务应返回 view=location'); assert.equal(data.total, 2); assert.equal(data.rows.length, 2); assert.equal((await findCheckRow(check.id)).mode, 'blind', '库位维度任务应为盲盘'); assert.deepEqual( data.rows.map(row => Number(row.detail_id)), details.rows.map(row => Number(row.id)), 'location 行应与任务库位范围行一一对应(按明细 id 升序)' ); for (const row of data.rows) { const detail = details.rows.find(item => Number(item.id) === Number(row.detail_id)); const space = await ctx.model.LocationSpace.findOne({ where: { id: Number(detail.location_id) }, attributes: [ 'space_code', 'custom_name' ], raw: true, }); assert.equal(Number(row.location_id), Number(detail.location_id), 'location_id 应来自明细快照'); assert.equal(row.location_code, detail.location_code, 'location_code 应来自明细快照'); assert.equal( row.location_name, (space.custom_name || space.space_code) || detail.location_code, 'location_name 应为 custom_name 兜底 space_code' ); assert.equal(row.status, 'unchecked', '无作业记录应输出未盘'); assert.equal(row.has_unknown, false); assert.equal(row.checked_at, null); assert.deepEqual(row.checkers, []); assert.deepEqual(row.goods, []); } }); it('keyword 过滤:仅库位任务生效,按 location_code/location_name 模糊匹配(不区分大小写)后再分页', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const spaceRows = await ctx.model.LocationSpace.findAll({ where: { space_code: { [ctx.app.Sequelize.Op.in]: [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ] } }, attributes: [ 'id', 'space_code', 'custom_name' ], raw: true, }); const spaceA = spaceRows.find(row => row.space_code === TEST_LOCATION_CODE); const spaceE = spaceRows.find(row => row.space_code === TEST_EMPTY_LOCATION_CODE); // 1) 按 location_code 前缀匹配(小写验证不区分大小写) const byCode = await workDataCheck(check.id, { keyword: 'a1715' }); assert.equal(byCode.total, 1, '按库位编码前缀应命中 1 行'); assert.equal(byCode.rows.length, 1); assert.equal(byCode.rows[0].location_code, TEST_LOCATION_CODE); // 2) 按 location_name 匹配(取名称中不被另一库位编码/名称包含的唯一字符做关键字) const nameA = (spaceA && (spaceA.custom_name || spaceA.space_code)) || TEST_LOCATION_CODE; const otherTexts = [ TEST_EMPTY_LOCATION_CODE, spaceE && spaceE.custom_name ] .filter(Boolean) .map(text => String(text).toLowerCase()); const uniqueChar = Array.from(String(nameA)) .find(char => !otherTexts.some(text => text.includes(String(char).toLowerCase()))); if (uniqueChar) { const byName = await workDataCheck(check.id, { keyword: uniqueChar }); assert.equal(byName.total, 1, '按库位名称唯一字符应命中 1 行'); assert.equal(byName.rows[0].location_code, TEST_LOCATION_CODE); } // 3) 无命中关键字 → total=0、rows=[] const miss = await workDataCheck(check.id, { keyword: 'ZZZ-NO-MATCH-998' }); assert.equal(miss.total, 0); assert.deepEqual(miss.rows, []); // 4) 空白关键字 → 视为未传,不过滤 const blank = await workDataCheck(check.id, { keyword: ' ' }); assert.equal(blank.total, 2, '空白关键字应不过滤'); // 5) 非库位任务忽略 keyword(goods 任务 space 视图) const goodsCheck = await createCheck({ type: 'goods' }); const stocks = await fetchStockRows(1); await addDetail(goodsCheck.id, [ stocks[0].id ]); await submitCheck(goodsCheck.id); await auditCheck(goodsCheck.id, 'approve'); const goodsAll = await workDataCheck(goodsCheck.id); const goodsFiltered = await workDataCheck(goodsCheck.id, { keyword: 'ZZZ-NO-MATCH-998' }); assert.equal(goodsFiltered.total, goodsAll.total, '商品任务应忽略 keyword'); }); it('space 视图行 location_id 与 id 同义(供调用方直接回传 report 的 location_id)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const data = await workDataCheck(check.id); assert.equal(data.view, 'space'); assert.ok(data.rows.length > 0, '前置:space 视图应有库位行'); for (const row of data.rows) { assert.ok(Number(row.id) > 0, 'id 应为库位ID'); assert.equal(Number(row.location_id), Number(row.id), 'location_id 应与 id 一致'); } }); it('space 视图:库位仅按拣货顺序排序(pick_sequence 升序,pick_priority 与库位 id 不参与)', async () => { // 1) 找两个不同库位、各只有一个库存库位的商品(确保 space 视图恰好聚合这两个库位) const pairs = await fetchSpaceStockPairs(2); assert.ok(pairs.length >= 2, '测试仓库应至少有 2 个单库位启用库存库位(真实数据依赖)'); const spaceA = Number(pairs[0].spaceId); const spaceB = Number(pairs[1].spaceId); const stockA = Number(pairs[0].stockId); const stockB = Number(pairs[1].stockId); const stockRows = await ctx.model.StockWarehouse.findAll({ where: { id: { [ctx.app.Sequelize.Op.in]: [ stockA, stockB ] }, warehouse_id: TEST_WAREHOUSE_ID, }, attributes: [ 'id' ], raw: true, }); assert.equal(stockRows.length, 2, '两个商品均应属于测试仓库'); const check = await createCheck({ type: 'goods' }); await addDetail(check.id, [ stockA, stockB ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); // 2) 记录库位原始排序值,验证后恢复(不污染开发库拣货路径数据) const spaceRows = await ctx.model.LocationSpace.findAll({ where: { id: { [ctx.app.Sequelize.Op.in]: [ spaceA, spaceB ] } }, attributes: [ 'id', 'pick_sequence', 'pick_priority' ], raw: true, }); const originalValues = new Map(spaceRows.map(row => [ Number(row.id), { pick_sequence: row.pick_sequence, pick_priority: row.pick_priority }, ])); const restoreSpaces = async () => { for (const [ spaceId, values ] of originalValues.entries()) { await ctx.model.LocationSpace.update( { pick_sequence: values.pick_sequence, pick_priority: values.pick_priority }, { where: { id: spaceId } } ); } }; try { // 阶段1:pick_priority 相同(50)时按 pick_sequence 升序 → B(100) 在 A(200) 前 await ctx.model.LocationSpace.update( { pick_sequence: 200, pick_priority: 50 }, { where: { id: spaceA } } ); await ctx.model.LocationSpace.update( { pick_sequence: 100, pick_priority: 50 }, { where: { id: spaceB } } ); let data = await workDataCheck(check.id); assert.equal(data.view, 'space', '商品任务默认应为 space 视图'); assert.deepEqual( data.rows.map(row => Number(row.id)), [ spaceB, spaceA ], 'pick_sequence 应升序(小值在前)' ); // 阶段2:pick_sequence 相同(300)时 pick_priority 不参与排序, // 同值保持库位查询顺序(实际按 id 升序);两方向设置 priority 断言顺序不变, // 若实现误把 priority 纳入排序键,总有一组断言会失败 const [ smallerId, largerId ] = [ spaceA, spaceB ].sort((left, right) => left - right); await ctx.model.LocationSpace.update( { pick_sequence: 300, pick_priority: 10 }, { where: { id: smallerId } } ); await ctx.model.LocationSpace.update( { pick_sequence: 300, pick_priority: 90 }, { where: { id: largerId } } ); data = await workDataCheck(check.id); assert.deepEqual( data.rows.map(row => Number(row.id)), [ smallerId, largerId ], 'pick_priority 不参与排序(同 pick_sequence 保持原顺序,升序误入会交换)' ); await ctx.model.LocationSpace.update( { pick_sequence: 300, pick_priority: 90 }, { where: { id: smallerId } } ); await ctx.model.LocationSpace.update( { pick_sequence: 300, pick_priority: 10 }, { where: { id: largerId } } ); data = await workDataCheck(check.id); assert.deepEqual( data.rows.map(row => Number(row.id)), [ smallerId, largerId ], 'pick_priority 不参与排序(同 pick_sequence 保持原顺序,降序误入会交换)' ); } finally { await restoreSpaces(); } }); it('only_abnormal 过滤 location 视图:仅保留未盘行与含未知商品行,兼容 onlyAbnormal 驼峰写法', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); const uncheckedDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); assert.ok(checkedDetail && uncheckedDetail, '前置:两条库位范围行均应存在'); // 已盘行(无未知商品):上报后应被过滤,仅剩未盘行 const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0] }); const abnormal = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(abnormal.total, 1, '已盘无未知商品行应被过滤,仅剩未盘行'); assert.equal(Number(abnormal.rows[0].detail_id), Number(uncheckedDetail.id)); assert.equal(abnormal.rows[0].status, 'unchecked'); // 未传 only_abnormal → 不过滤;onlyAbnormal 驼峰写法等价 const all = await workDataCheck(check.id, {}); assert.equal(all.total, 2, '未传 only_abnormal 应不过滤'); const camel = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(camel.total, 1, 'onlyAbnormal 驼峰写法应等价生效'); // 已盘行补充未知商品记录 → has_unknown=true 视为差异,应保留 await reportCheck(check.id, checkedDetail.id, 7, undefined, { barcode: uniqueTitle('ONLY-ABN-UNKNOWN') }); const abnormal2 = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(abnormal2.total, 2, '未知商品行(has_unknown)应视为差异保留'); const checkedRow = abnormal2.rows.find(row => Number(row.detail_id) === Number(checkedDetail.id)); assert.equal(checkedRow.has_unknown, true); }); it('only_abnormal 过滤 goods 视图明盘:未盘行与差异行保留、已盘平账行移除、total 为过滤后行数', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const diffDetail = details.rows[0]; const flatDetail = details.rows[1]; const diffSnapshot = Number(diffDetail.system_quantity); const flatSnapshot = Number(flatDetail.system_quantity); // 仅第一行盘盈(差异)→ only_abnormal 应保留差异行与未盘行 await reportCheck(check.id, diffDetail.id, diffSnapshot + 2, TEST_LOCATION_CODE); const first = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true }); assert.equal(first.view, 'goods'); assert.equal(first.total, 2, '差异行 + 未盘行应均保留'); assert.deepEqual( first.rows.map(row => Number(row.stock_id)).sort((left, right) => left - right), [ Number(diffDetail.stock_id), Number(flatDetail.stock_id) ].sort((left, right) => left - right), '保留行应为差异行与未盘行(goods 视图按商品汇总,行键为 stock_id)' ); const flatRow = first.rows.find(row => Number(row.stock_id) === Number(flatDetail.stock_id)); assert.ok( !flatRow.locations.some(location => Array.isArray(location.record_ids) && location.record_ids.length > 0), '未盘行应无任何作业记录' ); // 第二行平账(已盘无差异)→ 仅剩差异行 await reportCheck(check.id, flatDetail.id, flatSnapshot, TEST_LOCATION_CODE); const second = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true }); assert.equal(second.total, 1, '已盘平账行应被过滤,仅剩差异行'); assert.equal(Number(second.rows[0].stock_id), Number(diffDetail.stock_id)); assert.equal(second.rows[0].is_diff, 1); // 过滤在分页切片之前:pageSize=1 时 rows 为当前页、total 仍为过滤后行数 const paged = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true, pagination: { page: 1, pageSize: 1 } }); assert.equal(paged.total, 1); assert.equal(paged.rows.length, 1); // false/0/空串视为未传不过滤 for (const value of [ false, 0, 'false', '' ]) { const noFilter = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: value }); assert.equal(noFilter.total, 2, `only_abnormal=${JSON.stringify(value)} 应不过滤`); } }); it('only_abnormal 过滤 space 视图明盘:行内 goods 按未盘/数量差异过滤、空行移除', async () => { const pairs = await fetchSpaceStockPairs(2); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const diffPair = pairs[0]; const flatPair = pairs[1]; const diffDetail = details.rows.find(row => Number(row.stock_id) === diffPair.stockId); const flatDetail = details.rows.find(row => Number(row.stock_id) === flatPair.stockId); // 库位1盘盈(差异)、库位2未盘 → 两个库位行均应保留(差异子项 + 未盘子项) await reportCheck(check.id, diffDetail.id, diffPair.book + 2, diffPair.spaceCode); const first = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(first.view, 'space'); assert.equal(first.total, 2, '差异库位与未盘库位均应保留'); const diffRow = first.rows.find(row => Number(row.id) === diffPair.spaceId); const uncheckedRow = first.rows.find(row => Number(row.id) === flatPair.spaceId); assert.ok(diffRow && uncheckedRow, '差异库位与未盘库位行均应存在'); assert.equal(diffRow.goods.length, 1, '差异库位行应保留差异商品子项'); assert.equal(Number(diffRow.goods[0].checked_quantity), diffPair.book + 2); assert.equal(uncheckedRow.goods.length, 1); assert.equal(uncheckedRow.goods[0].status, 'unchecked'); // 库位2平账(已盘无差异)→ 该库位行整体移除,仅剩差异库位行 await reportCheck(check.id, flatDetail.id, flatPair.book, flatPair.spaceCode); const second = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(second.total, 1, '已盘平账库位行应被整体移除'); assert.equal(Number(second.rows[0].id), diffPair.spaceId); assert.equal(second.rows[0].goods.length, 1, '保留行内 goods 应仅剩差异商品'); }); it('only_abnormal 过滤 space 视图盲盘:无数量字段仅按未盘过滤(已盘行移除)', async () => { const pairs = await fetchSpaceStockPairs(2); const check = await createCheck({ mode: 'blind' }); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const reportedDetail = details.rows.find(row => Number(row.stock_id) === pairs[0].stockId); await reportCheck(check.id, reportedDetail.id, 6, pairs[0].spaceCode); const data = await workDataCheck(check.id, { onlyAbnormal: true }); assert.equal(data.total, 1, '盲盘已盘行无法判断差异应移除,仅剩未盘库位行'); assert.equal(Number(data.rows[0].id), pairs[1].spaceId, '保留行应为未盘库位'); assert.equal(data.rows[0].goods[0].status, 'unchecked'); }); it('only_abnormal 与 keyword 叠加:location 视图先 keyword 过滤再按未盘/差异过滤', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0] }); // keyword 命中已盘行 + only_abnormal → 已盘行被过滤 → 0 行 const hitChecked = await workDataCheck(check.id, { keyword: 'a1715', onlyAbnormal: true }); assert.equal(hitChecked.total, 0, 'keyword 命中的已盘行被 only_abnormal 过滤后应为空'); // keyword 命中未盘行 + only_abnormal → 1 行 const hitUnchecked = await workDataCheck(check.id, { keyword: TEST_EMPTY_LOCATION_CODE, onlyAbnormal: true }); assert.equal(hitUnchecked.total, 1, 'keyword 命中的未盘行应保留'); assert.equal(hitUnchecked.rows[0].status, 'unchecked'); }); it('workDataDetail:按明细ID返回单行(结构同 location 视图行),已盘/未盘口径与列表一致', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const targetDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); const emptyDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); assert.ok(targetDetail && emptyDetail, '前置:两条库位范围行均应存在'); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); const reported = await reportCheck(check.id, targetDetail.id, 6, undefined, { stockId: stockIds[0] }); const row = await workDataDetailCheck(targetDetail.id); assert.deepEqual( Object.keys(row).sort(), [ 'checked_at', 'checkers', 'detail_id', 'goods', 'has_unknown', 'is_empty', 'location_code', 'location_id', 'location_name', 'space_id', 'status' ].sort(), '单行字段应与 location 视图行结构一致' ); assert.equal(Number(row.detail_id), Number(targetDetail.id)); assert.equal(Number(row.location_id), Number(targetDetail.location_id)); assert.equal(row.location_code, targetDetail.location_code); assert.ok(row.location_name, '应输出库位名称'); assert.equal(row.status, 'checked'); assert.equal(row.has_unknown, false); assert.equal(row.is_empty, false); assert.equal(row.goods.length, 1, 'goods 应含已盘商品'); assert.equal(Number(row.goods[0].record_id), Number(reported.record.id)); assert.ok(row.checkers.includes(TEST_CREATOR_NAME)); assert.ok(row.checked_at); // 与 workData 列表对应行逐字段一致 const listData = await workDataCheck(check.id, 'location'); const listRow = listData.rows.find(item => Number(item.detail_id) === Number(targetDetail.id)); assert.deepEqual(row, listRow, 'workDataDetail 单行应与 workData 列表对应行一致'); // 未盘明细 → unchecked 空行 const emptyRow = await workDataDetailCheck(emptyDetail.id); assert.equal(emptyRow.status, 'unchecked'); assert.deepEqual(emptyRow.goods, []); assert.deepEqual(emptyRow.checkers, []); assert.equal(emptyRow.checked_at, null); assert.equal(emptyRow.is_empty, false); assert.equal(emptyRow.has_unknown, false); }); it('workDataDetail 校验:明细ID非法/不存在/任务未审核均拒绝', async () => { await assert.rejects(async () => workDataDetailCheck(null), /请提供盘点明细ID/); await assert.rejects(async () => workDataDetailCheck(999999999), /盘点明细不存在/); // 任务未审核 → 状态校验拒绝 const check2 = await createCheck({ type: 'location' }); const locDetails = await addLocationDetail(check2.id, [ TEST_LOCATION_CODE ]); assert.ok(locDetails, '前置:应成功添加库位明细'); const pendingDetails = await detailCheck(check2.id); await assert.rejects( async () => workDataDetailCheck(pendingDetails.rows[0].id), /仅审核完成(approved)或盘点作业中(checking)/ ); }); it('workDataDetail 商品钻取:传 id + stock_id 返回 summary 汇总与按库位分行(账面快照/实盘/库位ID/明细ID)', async () => { const check = await createCheck({ type: 'goods' }); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const targetDetail = details.rows[0]; const snapshot = Number(targetDetail.system_quantity); // 上报库位取一个与该商品明细库位不同的测试库位(验证「已盘库位 vs 明细库位」两类分行) const reportCode = [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2, TEST_EMPTY_LOCATION_CODE ] .find(code => code && String(code) !== String(targetDetail.location_code)); assert.ok(reportCode, '前置:应存在与商品明细库位不同的测试库位'); // 上报:盘盈 2 await reportCheck(check.id, targetDetail.id, snapshot + 2, reportCode); const detail = await workDataDetailCheck({ id: check.id, stockId: targetDetail.stock_id }); assert.equal(Number(detail.check_id), Number(check.id), '应返回任务ID'); assert.equal(Number(detail.stock_id), Number(targetDetail.stock_id), '应返回商品ID'); assert.equal(detail.view, undefined, '不做 view/rows 视图包装'); assert.ok(detail.item_code !== undefined, '应含商品编码'); assert.ok(detail.item_name !== undefined, '应含商品名称'); assert.ok(Array.isArray(detail.images), '应含商品图片数组'); assert.ok(detail.summary, '应返回汇总数据 summary'); assert.equal(Number(detail.summary.system_quantity), snapshot, '汇总账面应为明细快照合计'); assert.equal(Number(detail.summary.checked_quantity), snapshot + 2, '汇总实盘应为实盘合计'); assert.equal(Number(detail.summary.diff_quantity), 2, '汇总差异应为实盘-账面'); assert.equal(Number(detail.summary.is_diff), 1); assert.ok(Array.isArray(detail.rows) && detail.rows.length >= 1, '应返回按库位的分行数据 rows'); const checkedRow = detail.rows.find(row => String(row.location_code) === String(reportCode)); assert.ok(checkedRow, '已盘库位应出现在 rows'); // 上报库位不是该商品的明细库位(商品实际库位在别处)→ 该分行无明细ID、快照为 0 assert.equal(checkedRow.detail_id, null, '非明细库位分行不应带明细ID'); assert.equal(Number(checkedRow.checked_quantity), snapshot + 2, '分行实盘应与上报一致'); assert.equal(Number(checkedRow.snapshot_quantity), 0, '无明细快照的库位账面快照为 0'); assert.equal(Number(checkedRow.diff_quantity), snapshot + 2, '分行差异=实盘-快照'); assert.equal(typeof checkedRow.system_quantity, 'number', '明盘分行应含当前账面数量'); assert.equal(typeof checkedRow.locked_quantity, 'number', '明盘分行应含锁定数量'); assert.ok(checkedRow.checked_at, '已盘库位应有上报时间'); // 库位ID:location_id 与同义 space_id 均为 wms_location_space.id,可直接回传 report assert.equal(Number(checkedRow.location_id), Number(checkedRow.space_id)); const spaceRow = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: reportCode }, attributes: [ 'id' ], order: [[ 'id', 'ASC' ]], raw: true, }); assert.equal(Number(checkedRow.location_id), Number(spaceRow.id), '分行库位ID应与库位编码对应'); // 明细库位分行:带明细ID与账面快照,未盘(实盘 0,差异=-快照) const ownRow = detail.rows.find(row => String(row.location_code) === String(targetDetail.location_code)); assert.ok(ownRow, '商品明细库位应出现在 rows'); assert.equal(Number(ownRow.detail_id), Number(targetDetail.id), '明细库位分行应带该库位明细ID'); assert.equal(Number(ownRow.snapshot_quantity), snapshot, '明细库位分行应带该库位账面快照'); assert.equal(Number(ownRow.checked_quantity), 0, '未盘库位实盘为 0'); assert.equal(ownRow.checked_at, null, '未盘库位 checked_at 应为 null'); // 与 workData goods 视图行交叉验证 const goodsAll = await workDataCheck(check.id, { isGoods: true }); const goodsRow = goodsAll.rows.find(item => Number(item.stock_id) === Number(targetDetail.stock_id)); assert.ok(goodsRow, 'goods 视图应含该商品行'); assert.equal(Number(detail.summary.checked_quantity), Number(goodsRow.checked_quantity), '汇总实盘应与 goods 视图一致'); assert.equal(Number(detail.summary.diff_quantity), Number(goodsRow.diff_quantity), '汇总差异应与 goods 视图一致'); assert.equal(detail.rows.length, goodsRow.locations.length, '分行数应与 goods 视图 locations 一致'); // 兼容:传商品范围明细ID 也返回同一钻取结构 const byDetailId = await workDataDetailCheck({ detailId: targetDetail.id }); assert.equal(Number(byDetailId.stock_id), Number(targetDetail.stock_id)); assert.equal(Number(byDetailId.summary.checked_quantity), snapshot + 2); }); it('workDataDetail 商品钻取盲盘:不返回数量字段,行信息仍输出', async () => { const check = await createCheck({ type: 'goods', mode: 'blind' }); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const targetDetail = details.rows[0]; await reportCheck(check.id, targetDetail.id, 6, TEST_LOCATION_CODE); const detail = await workDataDetailCheck({ id: check.id, stockId: targetDetail.stock_id }); assert.equal(Number(detail.stock_id), Number(targetDetail.stock_id)); assert.equal( Object.prototype.hasOwnProperty.call(detail, 'summary'), false, '盲盘不应返回汇总数量' ); assert.ok(detail.rows.length >= 1, 'rows 应包含商品所在库位'); for (const row of detail.rows) { for (const key of [ 'system_quantity', 'locked_quantity', 'snapshot_quantity', 'checked_quantity', 'diff_quantity' ]) { assert.equal( Object.prototype.hasOwnProperty.call(row, key), false, `盲盘分行不应含数量字段 ${key}` ); } assert.ok(row.location_code, '盲盘分行仍应输出库位编码'); assert.ok(Array.isArray(row.record_ids), '盲盘分行仍应输出作业记录ID'); } }); it('location 视图:已盘/未盘 status、checkers 合并去重、checked_at 取最近、goods.quantity 为最新覆盖值', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); const uncheckedDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); assert.ok(checkedDetail && uncheckedDetail, '前置:两条库位范围行均应存在'); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0], checkerName: '盘点人A' }); await reportCheck(check.id, checkedDetail.id, 5, undefined, { stockId: stockIds[1], checkerName: '盘点人B' }); // 覆盖式上报:同商品再报,goods.quantity 应为最新值 await reportCheck(check.id, checkedDetail.id, 9, undefined, { stockId: stockIds[0], checkerName: '盘点人A' }); const data = await workDataCheck(check.id, 'location'); const checkedRow = data.rows.find(row => Number(row.detail_id) === Number(checkedDetail.id)); const uncheckedRow = data.rows.find(row => Number(row.detail_id) === Number(uncheckedDetail.id)); assert.equal(checkedRow.status, 'checked', '有作业记录的库位行应输出已盘'); assert.deepEqual(checkedRow.checkers, [ '盘点人A', '盘点人B' ], '盘点人应按记录顺序合并去重'); assert.ok(checkedRow.checked_at, '已盘行应输出最近盘点时间'); assert.equal(checkedRow.has_unknown, false); const goodsByStock = new Map(checkedRow.goods.map(item => [ Number(item.stock_id), item ])); assert.equal(checkedRow.goods.length, 2, 'goods 应含两个已盘商品'); assert.equal(goodsByStock.get(stockIds[0]).quantity, 9, '覆盖更新后 quantity 应为最新值'); assert.equal(goodsByStock.get(stockIds[1]).quantity, 5); assert.equal(goodsByStock.get(stockIds[0]).checker_name, '盘点人A'); const records = await queryRecords(check.id, checkedDetail.id); const latestCheckedAt = records.reduce((latest, record) => { const timestamp = new Date(record.checked_at).getTime(); return latest === null || timestamp > latest ? timestamp : latest; }, null); assert.equal( new Date(checkedRow.checked_at).getTime(), latestCheckedAt, 'checked_at 应为该库位最近一条记录的上报时间' ); assert.equal(uncheckedRow.status, 'unchecked', '无作业记录的库位行应输出未盘'); assert.equal(uncheckedRow.checked_at, null); assert.deepEqual(uncheckedRow.checkers, []); assert.deepEqual(uncheckedRow.goods, []); assert.equal(uncheckedRow.has_unknown, false); }); it('location 视图 goods 子项:商品信息/货主名/条码/商品图片与 getStockDetails 交叉验证', async () => { const { check, detail } = await createApprovedLocationCheck(); // 取一个有效的库存商品(跳过已从库存表删除的商品) const storageStockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 5); let stockId = null; for (const candidate of storageStockIds) { const valid = await ctx.model.StockWarehouse.findOne({ where: { id: candidate, warehouse_id: TEST_WAREHOUSE_ID, is_valid: 'Y' }, attributes: [ 'id' ], raw: true, }); if (valid) { stockId = candidate; break; } } assert.ok(stockId, '前置:固定测试库位应存在有效库存商品'); const reported = await reportCheck(check.id, detail.id, 7, undefined, { stockId }); const stockDetail = (await ctx.service.systems.stockWarehouse.getStockDetails([ stockId ], { warehouseId: TEST_WAREHOUSE_ID, }))[0]; assert.ok(stockDetail, '前置:商品详情应可查询'); const data = await workDataCheck(check.id, 'location'); const goods = data.rows[0].goods; assert.equal(goods.length, 1, 'goods 应只含已盘商品'); const item = goods[0]; assert.equal(Number(item.record_id), Number(reported.record.id), 'goods 子项应关联作业记录'); assert.equal(Number(item.stock_id), stockId); assert.equal(item.item_code, stockDetail.item_code || null); assert.equal(item.item_name, stockDetail.item_name || null); assert.equal(item.barcode, (stockDetail.barcodes[0] && stockDetail.barcodes[0].barcode) || null); assert.deepEqual(item.images, stockDetail.image_url || [], 'goods 图片应挂载商品图片列表'); assert.equal(Number(item.store_id), Number(stockDetail.store_id) || 0); assert.equal(item.store_name, await resolveStoreName(Number(stockDetail.store_id)), '货主名应为合约备注优先、公司名兜底'); assert.equal(item.quantity, 7, '实盘数量应与上报一致'); assert.equal(item.checker_name, TEST_CREATOR_NAME); assert.ok(item.checked_at, '应输出上报时间'); }); it('location 视图 goods 子项:未知商品也并入 goods(stock_id=null 输出记录快照)+ 记录图片挂载 + has_unknown 标记', async () => { const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); const knownReport = await reportCheck(check.id, detail.id, 4, undefined, { stockId: stockIds[0] }); const unknownBarcode = uniqueTitle('WORKDATA-UNKNOWN'); const unknownReport = await reportCheck(check.id, detail.id, 7, undefined, { barcode: unknownBarcode, itemName: '未知商品快照名称', }); const { file } = await createRecordImage(Number(unknownReport.record.id)); const data = await workDataCheck(check.id, 'location'); const row = data.rows[0]; assert.equal(row.has_unknown, true, '存在未知商品记录应标记 has_unknown'); assert.equal(row.goods.length, 2, '已知商品与未知商品均应进入 goods 子列表'); const knownGoods = row.goods.find(item => Number(item.record_id) === Number(knownReport.record.id)); assert.ok(knownGoods, '已知商品应在 goods 子列表'); assert.ok(Number(knownGoods.stock_id) > 0, '已知商品 stock_id 应为正整数'); const unknownGoods = row.goods.find(item => Number(item.record_id) === Number(unknownReport.record.id)); assert.ok(unknownGoods, '未知商品应在 goods 子列表'); assert.equal(unknownGoods.stock_id, null, '未知商品 stock_id 应为 null'); assert.equal(unknownGoods.item_code, unknownBarcode, '未知商品编码列应兑底扫描条码'); assert.equal(unknownGoods.barcode, unknownBarcode); assert.equal(unknownGoods.item_name, '未知商品快照名称', '未知商品名称应为上报快照'); assert.equal(unknownGoods.quantity, 7); assert.equal(unknownGoods.checker_name, TEST_CREATOR_NAME); assert.ok(unknownGoods.checked_at, '应输出上报时间'); assert.deepEqual(unknownGoods.images, [{ id: file.id, url: file.file_url }], '未知商品图片应挂载记录图片'); }); it('库位模式空库位标记:is_empty 上报 → 记录落库 is_empty=1、location 视图行 is_empty=true/goods=[]、计入已盘', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); assert.equal(result.record.is_empty, true, '空标记记录 is_empty 应为 true'); assert.equal(result.record.stock_id, null); assert.equal(result.record.barcode, null); assert.equal(result.record.quantity, 0); assert.equal(result.checked_items, 1, '空标记应计入已盘'); assert.equal(result.diff_items, 0, '账面无库存库位标记空应无差异'); assert.equal(result.detail_status, 'all_checked'); const data = await workDataCheck(check.id); const row = data.rows[0]; assert.equal(row.is_empty, true, 'location 行应输出 is_empty 标记'); assert.equal(row.status, 'checked', '空库位标记后应视为已盘点'); assert.deepEqual(row.goods, [], '空库位 goods 应为空'); assert.equal(row.has_unknown, false); assert.ok(row.checkers.includes(TEST_CREATOR_NAME), '空库位盘点人应计入 checkers'); }); it('空库位标记与商品记录互斥:标记空清商品记录,再上报商品清空标记', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); await reportCheck(check.id, details.rows[0].id, 3, undefined, { stockId: stockIds[0] }); // 标记空 → 商品记录被清除,仅剩空标记记录 await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); const afterEmpty = await queryRecords(check.id, details.rows[0].id); assert.equal(afterEmpty.length, 1, '标记空后应仅剩一条空标记记录'); assert.equal(Number(afterEmpty[0].is_empty), 1, '空标记记录 is_empty 应为 1'); // 再上报商品 → 空标记被清除,仅剩商品记录 const result = await reportCheck(check.id, details.rows[0].id, 5, undefined, { stockId: stockIds[0] }); const afterGoods = await queryRecords(check.id, details.rows[0].id); assert.equal(afterGoods.length, 1, '上报商品后应仅剩一条商品记录'); assert.equal(Number(afterGoods[0].is_empty), 0); assert.equal(Number(afterGoods[0].stock_id), stockIds[0]); const data = await workDataCheck(check.id); assert.equal(data.rows[0].is_empty, false, '再上报商品后行级 is_empty 应为 false'); assert.equal(result.detail_status, 'all_checked'); }); it('有账面库存的库位标记空 → 盘亏差异(主表 diff_items=1、result 库位行差异为负)', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); assert.equal(result.diff_items, 1, '账面有库存的库位标记空应计盘亏差异'); const agg = await resultCheck(check.id); const row = agg.rows[0]; assert.equal(row.is_empty, true); assert.equal(row.is_diff, 1); assert.ok(Number(row.diff_quantity) < 0, '盘亏差异应为负数'); assert.equal(row.status, 'checked'); assert.deepEqual(row.stocks, [], '空库位行 stocks 应为空'); assert.deepEqual(row.unknown_items, [], '空库位行 unknown_items 应为空'); }); it('商品明细行传 is_empty → 400(仅库位盘点明细支持空库位标记)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await assert.rejects(async () => { await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); }, error => error.code === 400 && /仅库位盘点明细支持空库位标记/.test(error.message)); }); it('markEmpty:库位任务标记空成功(记录/汇总/视图一致)', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await ctx.service.systems.stockCheck.markEmpty({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, detailId: details.rows[0].id, }); assert.equal(result.record.is_empty, true, '应写入空标记记录'); assert.equal(result.checked_items, 1); assert.equal(result.detail_status, 'all_checked'); const data = await workDataCheck(check.id); assert.equal(data.rows[0].is_empty, true); assert.equal(data.rows[0].status, 'checked'); }); it('markEmpty:非库位任务(商品任务)→ 400 仅库位盘点任务支持空库位标记', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await assert.rejects(async () => { await ctx.service.systems.stockCheck.markEmpty({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, detailId: details.rows[0].id, }); }, error => error.code === 400 && /仅库位盘点任务支持空库位标记/.test(error.message)); }); it('markEmpty:状态不允许(created)→ 400 当前状态不允许盘点作业', async () => { const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); const details = await detailCheck(check.id); await assert.rejects(async () => { await ctx.service.systems.stockCheck.markEmpty({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, detailId: details.rows[0].id, }); }, error => error.code === 400 && /不允许盘点作业/.test(error.message)); }); it('workData 挂载作业照片与 record_ids:location goods 子项 / goods locations 项 / space goods 项', async () => { // location 视图:已知商品 goods 子项挂记录图片(FileReference) const { check: locationCheck, detail: locationDetail } = await createApprovedLocationCheck(); const locationStocks = await fetchStorageStockIds(TEST_LOCATION_ID, 1); const locationReport = await reportCheck(locationCheck.id, locationDetail.id, 3, undefined, { stockId: locationStocks[0] }); const { file: locationImage } = await createRecordImage(Number(locationReport.record.id)); const locationData = await workDataCheck(locationCheck.id); const locationGoods = locationData.rows[0].goods[0]; assert.equal(Number(locationGoods.record_id), Number(locationReport.record.id), 'location goods 子项应含 record_id'); assert.deepEqual( locationGoods.images, [{ id: Number(locationImage.id), url: locationImage.file_url }], 'location goods 子项应挂作业照片(记录图片)' ); // goods/space 视图:locations/goods 子项输出 record_ids 与作业照片(供编辑移除) const pairs = await fetchSpaceStockPairs(1); const goodsCheck = await createCheck(); await addDetail(goodsCheck.id, [ pairs[0].stockId ]); await submitCheck(goodsCheck.id); await auditCheck(goodsCheck.id, 'approve'); const details = await detailCheck(goodsCheck.id); const goodsReport = await reportCheck(goodsCheck.id, details.rows[0].id, 5, pairs[0].spaceCode); const { file: goodsImage } = await createRecordImage(Number(goodsReport.record.id)); const goodsData = await workDataCheck(goodsCheck.id, { isGoods: true }); const locationItem = goodsData.rows[0].locations[0]; assert.deepEqual(locationItem.record_ids.map(Number), [ Number(goodsReport.record.id) ], 'goods 视图 locations 项应含 record_ids'); assert.deepEqual(locationItem.images, [{ id: Number(goodsImage.id), url: goodsImage.file_url }], 'goods 视图 locations 项应挂作业照片'); const spaceData = await workDataCheck(goodsCheck.id); const spaceGoods = spaceData.rows[0].goods[0]; assert.deepEqual(spaceGoods.record_ids.map(Number), [ Number(goodsReport.record.id) ], 'space 视图 goods 子项应含 record_ids'); assert.deepEqual(spaceGoods.images, [{ id: Number(goodsImage.id), url: goodsImage.file_url }], 'space 视图 goods 子项应挂作业照片'); }); it('goods 视图明盘:system_quantity/checked_quantity/diff_quantity/is_diff/locations.quantity 与 result 交叉验证', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const snapshot = Number(firstDetail.system_quantity); await reportCheck(check.id, firstDetail.id, snapshot + 2, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); await reportCheck(check.id, firstDetail.id, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人B' }); const data = await workDataCheck(check.id, { isGoods: true }); assert.equal(data.total, 2); const firstRow = data.rows.find(row => Number(row.stock_id) === Number(firstDetail.stock_id)); assert.equal(Number(firstRow.system_quantity), snapshot, '账面应来自明细快照'); assert.equal(firstRow.checked_quantity, snapshot + 6, '已盘合计应为多库位实盘之和'); assert.equal(firstRow.diff_quantity, 6, '差异=已盘合计-账面快照'); assert.equal(firstRow.is_diff, 1); const quantityByCode = new Map(firstRow.locations.map(item => [ item.location_code, Number(item.quantity) ])); assert.equal(quantityByCode.get(TEST_LOCATION_CODE), snapshot + 2, '已盘库位实盘应与上报一致'); assert.equal(quantityByCode.get(TEST_LOCATION_CODE_2), 4, '已盘库位实盘应与上报一致'); const checkedLocationA = firstRow.locations.find(item => item.location_code === TEST_LOCATION_CODE); const checkedLocationB = firstRow.locations.find(item => item.location_code === TEST_LOCATION_CODE_2); assert.equal(checkedLocationA.checker_name, '盘点人A'); assert.equal(checkedLocationB.checker_name, '盘点人B'); assert.ok(checkedLocationA.checked_at && checkedLocationB.checked_at); assert.equal(typeof checkedLocationA.system_quantity, 'number', '明盘已盘库位应含账面数量'); assert.equal(typeof checkedLocationB.system_quantity, 'number', '明盘已盘库位应含账面数量'); assert.equal(typeof checkedLocationA.locked_quantity, 'number', '明盘已盘库位应含锁定数量'); assert.equal(typeof checkedLocationB.locked_quantity, 'number', '明盘已盘库位应含锁定数量'); // 与 result 聚合交叉验证:checked_quantity/diff_quantity/is_diff 口径一致 const result = await resultCheck(check.id); const resultFirst = result.rows.find(row => Number(row.id) === Number(firstDetail.id)); assert.equal(firstRow.checked_quantity, resultFirst.checked_quantity); assert.equal(firstRow.diff_quantity, resultFirst.diff_quantity); assert.equal(firstRow.is_diff, resultFirst.is_diff); // 未盘行:明盘按 0 处理、locations 为商品所在库位列表(无作业信息) const secondRow = data.rows.find(row => Number(row.stock_id) === Number(secondDetail.stock_id)); assert.equal(Number(secondRow.system_quantity), Number(secondDetail.system_quantity)); assert.equal(secondRow.checked_quantity, 0); assert.equal(secondRow.diff_quantity, 0); assert.equal(secondRow.is_diff, 0); assert.ok(Array.isArray(secondRow.locations), '未盘行 locations 应为数组(商品所在库位列表)'); for (const location of secondRow.locations) { assert.equal(location.checked_at, null, '未盘库位 checked_at 应为 null'); assert.equal(Number(location.quantity), 0, '未盘库位实盘应为 0'); assert.equal(typeof location.system_quantity, 'number', '明盘未盘库位应含账面数量'); assert.equal(typeof location.locked_quantity, 'number', '明盘未盘库位应含锁定数量'); } }); it('goods 视图:商品信息/store_name/barcode/images 挂载(未盘行 locations=商品所在库位列表、明盘零差异)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails( stocks.map(stock => stock.id), { warehouseId: TEST_WAREHOUSE_ID } ); const data = await workDataCheck(check.id, { isGoods: true }); assert.equal(data.total, 2); for (const row of data.rows) { const detail = details.rows.find(item => Number(item.stock_id) === Number(row.stock_id)); const stockDetail = stockDetails.find(item => Number(item.id) === Number(row.stock_id)); assert.ok(stockDetail, '前置:商品详情应可查询'); assert.equal(row.item_code, stockDetail.item_code || detail.item_code || null); assert.equal(row.item_name, stockDetail.item_name || detail.item_name || null); assert.equal(row.spec, (stockDetail.sku_property || detail.spec) || null); assert.equal(Number(row.store_id), Number(stockDetail.store_id) || 0); assert.equal(row.store_name, await resolveStoreName(Number(row.store_id))); assert.equal(row.barcode, (stockDetail.barcodes[0] && stockDetail.barcodes[0].barcode) || null); assert.deepEqual(row.images, stockDetail.image_url || [], 'images 应挂载商品图片列表'); // 未盘行 locations = 商品所在全部库位(wms_storage,与业务口径一致排除无头库位),每库位无作业信息、实盘 0 const storageRows = await ctx.model.Storage.findAll({ where: { stock_id: Number(row.stock_id), warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [ctx.app.Sequelize.Op.in]: ctx.app.Sequelize.literal(VALID_SPACE_SQL) }, }, attributes: [ 'space_id' ], raw: true, }); // 有效库位数:storage 行中能在库位表查到(有 space_code)的库位 const storageSpaceIds = [ ...new Set(storageRows.map(item => Number(item.space_id)).filter(id => id > 0)) ]; let validSpaceCount = 0; if (storageSpaceIds.length > 0) { const spaceRows = await ctx.model.LocationSpace.findAll({ where: { id: { [ctx.app.Sequelize.Op.in]: storageSpaceIds } }, attributes: [ 'id' ], raw: true, }); validSpaceCount = spaceRows.length; } assert.ok( row.locations.length >= validSpaceCount, '未盘行 locations 应包含商品所在全部库位' ); for (const location of row.locations) { assert.equal(location.checked_at, null, '未盘库位 checked_at 应为 null'); assert.deepEqual(location.record_ids, [], '未盘库位 record_ids 应为空数组'); assert.equal(Number(location.quantity), 0, '未盘库位实盘应为 0'); assert.equal(typeof location.system_quantity, 'number', '明盘未盘库位应含账面数量'); assert.equal(typeof location.locked_quantity, 'number', '明盘未盘库位应含锁定数量'); // locations 应回传库位ID(供调用方直接回传 stock.check.report 的 location_id) assert.ok( Number(location.location_id) > 0, 'locations 应含有效库位ID(location_id)' ); if (location.location_code) { const spaceRow = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: location.location_code }, order: [[ 'id', 'ASC' ]], attributes: [ 'id' ], raw: true, }); assert.equal(Number(location.location_id), Number(spaceRow.id), 'location_id 应与库位编码对应'); } } assert.equal(Number(row.system_quantity), Number(detail.system_quantity), '账面应为明细快照'); assert.equal(row.checked_quantity, 0); assert.equal(row.diff_quantity, 0); assert.equal(row.is_diff, 0); } }); it('goods 视图多库位商品按商品汇总为一行:账面快照合计、跨明细按库位合并、workDataDetail 返回汇总+分行', async () => { const { Op, literal } = ctx.app.Sequelize; // 前置:找一个在两个及以上启用库位都有库存的商品(addDetail 按「商品 + 库位」拆多行明细) const storageRows = await ctx.model.Storage.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: 1, space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, }, attributes: [ 'stock_id', 'space_id', [ literal('SUM(available_quantity)'), 'totalQuantity' ]], group: [ 'stock_id', 'space_id' ], raw: true, }); const spacesByStock = new Map(); for (const row of storageRows) { const stockId = Number(row.stock_id); if (!spacesByStock.has(stockId)) { spacesByStock.set(stockId, []); } spacesByStock.get(stockId).push(row); } const multiStockEntry = [ ...spacesByStock.entries() ].find(([ , rows ]) => rows.length >= 2); assert.ok(multiStockEntry, '前置:测试库应存在多库位库存商品'); const multiStockId = Number(multiStockEntry[0]); const multiStock = await ctx.model.StockWarehouse.findOne({ where: { id: multiStockId, warehouse_id: TEST_WAREHOUSE_ID }, raw: true, }); assert.ok(multiStock, '前置:多库位商品应存在于 wms_stock_warehouse'); const check = await createCheck({ type: 'goods', storeId: multiStock.store_id || null }); await addDetail(check.id, [ multiStockId ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); assert.equal(details.rows.length, multiStockEntry[1].length, '前置:多库位商品按库位拆多行明细'); const detailIds = details.rows.map(row => Number(row.id)); const snapshotTotal = details.rows.reduce((sum, row) => sum + (Number(row.system_quantity) || 0), 0); // 两个库位分别上报(记录落在各自明细行),汇总行应合并 const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const firstCode = String(firstDetail.location_code || '').trim(); const secondCode = String(secondDetail.location_code || '').trim(); const firstReport = await reportCheck(check.id, firstDetail.id, 7, firstCode); const secondReport = await reportCheck(check.id, secondDetail.id, 3, secondCode); const data = await workDataCheck(check.id, { isGoods: true }); assert.equal(data.total, 1, '同商品多库位明细应汇总为一行'); const row = data.rows[0]; assert.equal(Number(row.stock_id), multiStockId); assert.equal( Object.prototype.hasOwnProperty.call(row, 'detail_id'), false, 'goods 汇总视图行不再输出明细ID(逐库位明细走 workDataDetail)' ); assert.equal(Number(row.system_quantity), snapshotTotal, '行级账面应为各库位明细快照之和'); assert.equal(row.checked_quantity, 10, '行级已盘合计应跨明细合并'); assert.equal(row.diff_quantity, 10 - snapshotTotal); assert.equal(row.is_diff, row.diff_quantity !== 0 ? 1 : 0); const quantityByCode = new Map(row.locations.map(item => [ item.location_code, Number(item.quantity) ])); assert.equal(quantityByCode.get(firstCode), 7, '首个库位实盘应来自其明细下记录'); assert.equal(quantityByCode.get(secondCode), 3, '第二个库位实盘应来自另一条明细下记录'); const firstLocation = row.locations.find(item => item.location_code === firstCode); const secondLocation = row.locations.find(item => item.location_code === secondCode); assert.deepEqual(firstLocation.record_ids, [ Number(firstReport.record.id) ]); assert.deepEqual(secondLocation.record_ids, [ Number(secondReport.record.id) ]); // locations 每项带该库位明细ID 与账面快照(供逐库位上报/钻取) assert.equal(Number(firstLocation.detail_id), Number(firstDetail.id)); assert.equal(Number(secondLocation.detail_id), Number(secondDetail.id)); assert.equal(Number(firstLocation.snapshot_quantity), Number(firstDetail.system_quantity)); assert.equal(Number(secondLocation.snapshot_quantity), Number(secondDetail.system_quantity)); // workDataDetail:id + stock_id 返回该商品的汇总 + 按库位分行 const detail = await workDataDetailCheck({ id: check.id, stockId: multiStockId }); assert.equal(detail.rows.length, detailIds.length, '分行数应等于该商品的库位明细行数'); assert.equal(Number(detail.summary.system_quantity), snapshotTotal, '汇总账面=各行快照之和'); assert.equal(Number(detail.summary.checked_quantity), 10, '汇总实盘=各行实盘之和'); assert.equal(Number(detail.summary.diff_quantity), 10 - snapshotTotal); const firstDetailRow = detail.rows.find(item => item.location_code === firstCode); const secondDetailRow = detail.rows.find(item => item.location_code === secondCode); assert.equal(Number(firstDetailRow.detail_id), Number(firstDetail.id), '分行应带该库位明细ID'); assert.equal(Number(secondDetailRow.detail_id), Number(secondDetail.id)); assert.equal(Number(firstDetailRow.checked_quantity), 7); assert.equal(Number(secondDetailRow.checked_quantity), 3); assert.equal(Number(firstDetailRow.diff_quantity), 7 - Number(firstDetail.system_quantity)); assert.equal(Number(secondDetailRow.diff_quantity), 3 - Number(secondDetail.system_quantity)); // 分行实盘之和 = 汇总实盘(与 goods 视图行级 checked_quantity 一致) assert.equal( detail.rows.reduce((sum, item) => sum + (Number(item.checked_quantity) || 0), 0), Number(row.checked_quantity) ); }); it('report 兼容:不传 detail_id 时按 id + stock_id + space_id 反查该商品明细上报', async () => { const check = await createCheck({ type: 'goods' }); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const targetDetail = details.rows[0]; const spaceId = Number(targetDetail.location_id); const reported = await ctx.service.systems.stockCheck.report({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, stockId: targetDetail.stock_id, spaceId, quantity: 12, checkerId: TEST_CREATOR_ID, checkerName: TEST_CREATOR_NAME, }); assert.equal(Number(reported.detail_id), Number(targetDetail.id), '应反查命中该商品的库位明细'); assert.equal(Number(reported.record.stock_id), Number(targetDetail.stock_id)); assert.equal(Number(reported.record.quantity), 12); // 既无 detail_id 也无 stock_id → 400 await assert.rejects( async () => ctx.service.systems.stockCheck.report({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, spaceId, quantity: 1, checkerId: TEST_CREATOR_ID, checkerName: TEST_CREATOR_NAME, }), /盘点明细ID不能为空/ ); // 商品不在本任务盘点范围 → 400 await assert.rejects( async () => ctx.service.systems.stockCheck.report({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, stockId: 999999999, spaceId, quantity: 1, checkerId: TEST_CREATOR_ID, checkerName: TEST_CREATOR_NAME, }), /盘点明细不存在/ ); }); it('账面取值按任务静态标记:静态任务取明细快照、非静态任务取当前 storage(goods/space/workDataDetail 一致)', async () => { // 静态任务上报要求商品已完成拣货(无锁定量),故只取无锁定商品 const stocks = await fetchStockRows(1, { requireUnlocked: true }); const targetStock = stocks[0]; const DELTA = 7; /** * 构造一个已审核通过的商品任务,并在审核后人为改动该库位账面(模拟盘点期间库存变动)。 * * @param {boolean} isStatic 是否静态盘点。 * @return {Promise} { check, detailRow, snapshot, liveBook, spaceId }。 */ async function prepareCheck(isStatic) { const check = await createCheck({ title: uniqueTitle(`账面口径-${isStatic ? '静态' : '非静态'}`), type: 'goods', isStatic, }); await addDetail(check.id, [ targetStock.id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailRow = details.rows[0]; const spaceId = Number(detailRow.location_id); const snapshot = Number(detailRow.system_quantity); await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity + :delta WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { delta: DELTA, warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); const liveRows = await ctx.model.query( `SELECT COALESCE(SUM(available_quantity), 0) AS total FROM wms_storage WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId }, type: ctx.model.QueryTypes.SELECT, } ); return { check, detailRow, spaceId, snapshot, liveBook: Number(liveRows[0] && liveRows[0].total) || 0 }; } /** * 回滚人为库存变动。 * * @param {number} spaceId 库位ID。 * @return {Promise} 无返回值。 */ async function restoreBook(spaceId) { await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity - :delta WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { delta: DELTA, warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); } const spaceIdList = []; const checkIdList = []; try { // ── 静态任务:账面=快照(冻结),当前 storage 仅作为参考字段输出 ── const staticPrepared = await prepareCheck(true); spaceIdList.push(staticPrepared.spaceId); checkIdList.push(staticPrepared.check.id); assert.ok(staticPrepared.liveBook > staticPrepared.snapshot, '前置:人为变动后当前账面应大于快照'); const staticGoods = await workDataCheck(staticPrepared.check.id, { isGoods: true }); const staticRow = staticGoods.rows[0]; const staticLocation = staticRow.locations.find(item => item.detail_id !== null); assert.equal(Number(staticRow.is_static), 1); assert.equal(staticRow.book_source, 'snapshot', '静态任务账面来源应为快照'); assert.equal( Number(staticRow.system_quantity), staticPrepared.snapshot, '静态任务行级账面应取明细快照(不受盘点期间库存变动影响)' ); assert.equal(Number(staticLocation.system_quantity), staticPrepared.snapshot, '静态任务库位账面应取快照'); assert.equal(Number(staticLocation.snapshot_quantity), staticPrepared.snapshot); assert.equal(Number(staticLocation.storage_quantity), staticPrepared.liveBook, '当前 storage 账面作为参考字段输出'); // 上报后差异按快照计算 await reportCheck(staticPrepared.check.id, staticPrepared.detailRow.id, staticPrepared.snapshot - 2, staticPrepared.detailRow.location_code); const staticAfterReport = await workDataCheck(staticPrepared.check.id, { isGoods: true }); assert.equal( Number(staticAfterReport.rows[0].diff_quantity), -2, '静态任务差异=实盘-快照(而非实盘-当前账面)' ); // space 视图同口径 const staticSpace = await workDataCheck(staticPrepared.check.id); const staticSpaceItem = staticSpace.rows .flatMap(row => row.goods || []) .find(item => Number(item.stock_id) === Number(targetStock.id)); assert.ok(staticSpaceItem, 'space 视图应含该商品'); assert.equal(Number(staticSpaceItem.system_quantity), staticPrepared.snapshot, 'space 视图静态任务账面应取快照'); assert.equal(Number(staticSpaceItem.storage_quantity), staticPrepared.liveBook); // workDataDetail 同口径 const staticDrill = await workDataDetailCheck({ id: staticPrepared.check.id, stockId: targetStock.id }); assert.equal(Number(staticDrill.is_static), 1); assert.equal(staticDrill.book_source, 'snapshot'); assert.equal(Number(staticDrill.summary.system_quantity), staticPrepared.snapshot, '钻取汇总账面应取快照'); const staticDrillRow = staticDrill.rows.find(item => item.detail_id !== null); assert.equal(Number(staticDrillRow.system_quantity), staticPrepared.snapshot); assert.equal(Number(staticDrillRow.snapshot_quantity), staticPrepared.snapshot); assert.equal(Number(staticDrillRow.storage_quantity), staticPrepared.liveBook); // ── 非静态任务:账面=当前 storage,快照仅作参考字段 ── const normalPrepared = await prepareCheck(false); spaceIdList.push(normalPrepared.spaceId); checkIdList.push(normalPrepared.check.id); const normalGoods = await workDataCheck(normalPrepared.check.id, { isGoods: true }); const normalRow = normalGoods.rows[0]; const normalLocation = normalRow.locations.find(item => item.detail_id !== null); assert.equal(Number(normalRow.is_static), 0); assert.equal(normalRow.book_source, 'storage', '非静态任务账面来源应为当前 storage'); assert.equal(Number(normalRow.system_quantity), normalPrepared.liveBook, '非静态任务行级账面应取当前 storage'); assert.equal(Number(normalLocation.system_quantity), normalPrepared.liveBook); assert.equal(Number(normalLocation.snapshot_quantity), normalPrepared.snapshot, '快照仍作为参考字段输出'); await reportCheck(normalPrepared.check.id, normalPrepared.detailRow.id, normalPrepared.liveBook - 3, normalPrepared.detailRow.location_code); const normalAfterReport = await workDataCheck(normalPrepared.check.id, { isGoods: true }); assert.equal( Number(normalAfterReport.rows[0].diff_quantity), -3, '非静态任务差异=实盘-当前账面' ); const normalSpace = await workDataCheck(normalPrepared.check.id); const normalSpaceItem = normalSpace.rows .flatMap(row => row.goods || []) .find(item => Number(item.stock_id) === Number(targetStock.id)); assert.equal(Number(normalSpaceItem.system_quantity), normalPrepared.liveBook, 'space 视图非静态任务账面应取当前 storage'); const normalDrill = await workDataDetailCheck({ id: normalPrepared.check.id, stockId: targetStock.id }); assert.equal(Number(normalDrill.is_static), 0); assert.equal(normalDrill.book_source, 'storage'); assert.equal(Number(normalDrill.summary.system_quantity), normalPrepared.liveBook); } finally { for (const spaceId of spaceIdList) { await restoreBook(spaceId); } // 收尾:完成盘点释放静态锁定,避免留存的 checking 静态任务影响后续锁定相关用例 for (const checkId of checkIdList) { const latestRow = await findCheckRow(checkId); if (latestRow && [ 'approved', 'checking' ].includes(String(latestRow.status))) { await ctx.service.systems.stockCheck.finish({ warehouseId: TEST_WAREHOUSE_ID, id: checkId }); } } } }); it('静态盘点拣货完成标记:商品仍有锁定量时 picking_completed=0 且 report 拒绝上报', async () => { const stocks = await fetchStockRows(1, { requireUnlocked: true }); const targetStock = stocks[0]; const LOCK_DELTA = 2; // 前置:测试商品在测试仓库不应有锁定量(否则 picking_completed 初值即为 0,用例无法区分) const lockedBefore = await ctx.model.query( `SELECT COALESCE(SUM(locked_quantity), 0) AS total FROM wms_storage WHERE warehouse_id = :warehouseId AND stock_id = :stockId`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id }, type: ctx.model.QueryTypes.SELECT, } ); assert.equal( Number(lockedBefore[0] && lockedBefore[0].total) || 0, 0, '前置:测试商品在测试仓库不应有锁定量' ); const check = await createCheck({ title: uniqueTitle('静态拣货完成'), type: 'goods', isStatic: 1, }); await addDetail(check.id, [ targetStock.id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailRow = details.rows[0]; const spaceId = Number(detailRow.location_id); // 模拟分配储位:available → locked(quantity 不变),即该商品仍有在途待拣出库 const shiftLock = async delta => { await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity - :delta, locked_quantity = locked_quantity + :delta WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { delta, warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); }; try { await shiftLock(LOCK_DELTA); // goods 视图:picking_completed=0,并输出该商品仓库内锁定量合计 const lockedGoods = await workDataCheck(check.id, { isGoods: true }); const lockedRow = lockedGoods.rows[0]; assert.equal(Number(lockedRow.is_static), 1); assert.equal(Number(lockedRow.picking_completed), 0, '商品仍有锁定量时 picking_completed 应为 0'); assert.equal(Number(lockedRow.locked_quantity), LOCK_DELTA, '行级应输出该商品锁定量合计'); // workDataDetail 同口径 const lockedDrill = await workDataDetailCheck({ id: check.id, stockId: targetStock.id }); assert.equal(Number(lockedDrill.picking_completed), 0, '钻取 picking_completed 应为 0'); assert.equal(Number(lockedDrill.locked_quantity), LOCK_DELTA, '钻取应输出该商品锁定量合计'); // space 视图(workData 默认视图)goods 子项同口径 const lockedSpace = await workDataCheck(check.id); const lockedSpaceItem = lockedSpace.rows .flatMap(row => row.goods || []) .find(item => Number(item.stock_id) === Number(targetStock.id)); assert.ok(lockedSpaceItem, 'space 视图应含该商品'); assert.equal(Number(lockedSpaceItem.picking_completed), 0, 'space 视图 picking_completed 应为 0'); // workDataSpaceDetails(space 视图分页版)同口径 const lockedSpaceDetails = await ctx.service.systems.stockCheck.workDataSpaceDetails({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: spaceId, }); const lockedSpaceDetailItem = (lockedSpaceDetails.rows[0] && lockedSpaceDetails.rows[0].goods || []) .find(item => Number(item.stock_id) === Number(targetStock.id)); assert.ok(lockedSpaceDetailItem, 'workDataSpaceDetails 库位行应含该商品'); assert.equal( Number(lockedSpaceDetailItem.picking_completed), 0, 'workDataSpaceDetails picking_completed 应为 0' ); // 未完成拣货:report 拒绝上报 await assert.rejects( async () => reportCheck(check.id, detailRow.id, 1, detailRow.location_code), /商品尚未完成拣货,不满足静态盘点要求,请先等待该商品完全完成拣货/ ); // 拣货完成(锁定量清零)后 picking_completed=1,可正常上报 await shiftLock(-LOCK_DELTA); const doneGoods = await workDataCheck(check.id, { isGoods: true }); assert.equal(Number(doneGoods.rows[0].picking_completed), 1, '无锁定量时 picking_completed 应为 1'); assert.equal(Number(doneGoods.rows[0].locked_quantity), 0, '无锁定量时行级锁定量应为 0'); const doneSpaceDetails = await ctx.service.systems.stockCheck.workDataSpaceDetails({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: spaceId, }); const doneSpaceDetailItem = (doneSpaceDetails.rows[0] && doneSpaceDetails.rows[0].goods || []) .find(item => Number(item.stock_id) === Number(targetStock.id)); assert.equal( Number(doneSpaceDetailItem && doneSpaceDetailItem.picking_completed), 1, '拣货完成后 workDataSpaceDetails 的 picking_completed 应为 1' ); const reported = await reportCheck(check.id, detailRow.id, 1, detailRow.location_code); assert.equal(Number(reported.record.quantity), 1, '拣货完成后应允许上报'); } finally { // 收尾:完成盘点释放静态锁定,避免留存的 checking 静态任务影响后续锁定相关用例 const latestRow = await findCheckRow(check.id); if (latestRow && [ 'approved', 'checking' ].includes(String(latestRow.status))) { await ctx.service.systems.stockCheck.finish({ warehouseId: TEST_WAREHOUSE_ID, id: check.id }); } // 兜底回滚:无论用例是否中途失败,都把锁定量搬回可用数量 await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity + locked_quantity, locked_quantity = 0 WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId AND locked_quantity > 0`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); } }); it('goods 视图盲盘:不含任何数量字段(system_quantity/checked_quantity/diff_quantity/is_diff 与 locations.quantity)', async () => { const check = await createCheck({ mode: 'blind' }); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 5, TEST_LOCATION_CODE); await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE_2); const data = await workDataCheck(check.id, { isGoods: true }); const row = data.rows[0]; assert.ok(row.locations.length >= 2, 'locations 应包含商品所在库位与已盘库位'); const checkedCodes = [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2 ]; for (const code of checkedCodes) { const location = row.locations.find(item => String(item.location_code) === code); assert.ok(location, `已盘库位 ${code} 应出现在 locations`); assert.ok(location.checked_at, `已盘库位 ${code} 应有上报时间`); } assert.ok( row.locations.some(location => !location.checked_at), '未盘库位 checked_at 应为 null' ); for (const key of [ 'system_quantity', 'checked_quantity', 'diff_quantity', 'is_diff' ]) { assert.equal( Object.prototype.hasOwnProperty.call(row, key), false, `盲盘行不应包含数量字段 ${key}` ); } for (const location of row.locations) { assert.equal( Object.prototype.hasOwnProperty.call(location, 'quantity'), false, '盲盘 locations 不应包含 quantity' ); assert.equal( Object.prototype.hasOwnProperty.call(location, 'system_quantity'), false, '盲盘 locations 不应包含账面数量' ); assert.equal( Object.prototype.hasOwnProperty.call(location, 'locked_quantity'), false, '盲盘 locations 不应包含锁定数量' ); assert.ok(location.location_code, '盲盘仍应输出库位编码'); } }); it('space 视图:库位聚合与 wms_storage 一致、按拣货路径排序(pick_sequence/pick_priority/id 兜底)', async () => { const pairs = await fetchSpaceStockPairs(3); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const data = await workDataCheck(check.id, 'space'); const returnedIds = data.rows.map(row => Number(row.id)); assert.deepEqual( [ ...returnedIds ].sort((left, right) => left - right), pairs.map(pair => pair.spaceId).sort((left, right) => left - right), '聚合库位集合应与任务商品所在库位(wms_storage)一致' ); for (const pair of pairs) { const row = data.rows.find(item => Number(item.id) === pair.spaceId); assert.ok(row, `任务商品所在库位 ${pair.spaceId} 应出现在聚合列表`); assert.equal(row.space_code, pair.spaceCode || null, '库位编码应来自库位表'); assert.equal(row.custom_name, pair.customName || null, '库位名称应为库位表 custom_name 原值'); assert.equal(row.goods.length, 1, '该库位仅一个任务商品,goods 应恰好一条'); assert.equal(Number(row.goods[0].stock_id), pair.stockId, '库位行应挂载该库位的任务商品'); } // 排序口径:pick_sequence 升序、pick_priority 降序、同值按库位 id 升序兜底(与实现一致) const { Op } = ctx.app.Sequelize; const locationRows = await ctx.model.LocationSpace.findAll({ where: { id: { [Op.in]: returnedIds } }, attributes: [ 'id', 'pick_sequence', 'pick_priority' ], raw: true, }); const locationById = new Map(locationRows.map(row => [ Number(row.id), row ])); const expectedIds = [ ...returnedIds ].sort((left, right) => { const leftRow = locationById.get(left) || {}; const rightRow = locationById.get(right) || {}; const sequenceDiff = Number(leftRow.pick_sequence || 0) - Number(rightRow.pick_sequence || 0); if (sequenceDiff !== 0) { return sequenceDiff; } const priorityDiff = Number(rightRow.pick_priority || 0) - Number(leftRow.pick_priority || 0); if (priorityDiff !== 0) { return priorityDiff; } return left - right; }); assert.deepEqual(returnedIds, expectedIds, 'space 视图应按拣货路径排序'); }); it('space 视图明盘:库位账面=wms_storage SUM、已盘=该库位实盘合计、status 已盘/未盘', async () => { const pairs = await fetchSpaceStockPairs(2); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const reported = pairs[0]; const reportedDetail = details.rows.find(row => Number(row.stock_id) === reported.stockId); const reportedQuantity = reported.book + 2; await reportCheck(check.id, reportedDetail.id, reportedQuantity, reported.spaceCode); const data = await workDataCheck(check.id, 'space'); const reportedRow = data.rows.find(row => Number(row.id) === reported.spaceId); assert.ok(reportedRow, '已盘库位应出现在聚合列表'); assert.equal(reportedRow.goods.length, 1); const reportedGoods = reportedRow.goods[0]; assert.equal(Number(reportedGoods.detail_id), Number(reportedDetail.id)); assert.equal(Number(reportedGoods.stock_id), reported.stockId); assert.equal(Number(reportedGoods.system_quantity), reported.book, '库位账面应为 wms_storage SUM(可用数量)'); assert.equal(Number(reportedGoods.locked_quantity), reported.bookLocked, '库位锁定数量应为 wms_storage SUM(locked_quantity)'); assert.equal(Number(reportedGoods.checked_quantity), reportedQuantity, '已盘应为该库位实盘合计'); assert.equal(reportedGoods.status, 'checked'); const unreported = pairs[1]; const unreportedRow = data.rows.find(row => Number(row.id) === unreported.spaceId); assert.ok(unreportedRow, '未盘库位应出现在聚合列表'); assert.equal(unreportedRow.goods.length, 1); const unreportedGoods = unreportedRow.goods[0]; assert.equal(Number(unreportedGoods.system_quantity), unreported.book); assert.equal(Number(unreportedGoods.locked_quantity), unreported.bookLocked, '未盘库位锁定数量也应输出'); assert.equal(Number(unreportedGoods.checked_quantity), 0, '未盘库位已盘数量应为 0'); assert.equal(unreportedGoods.status, 'unchecked'); }); it('space 视图盲盘:不返回数量字段、status 与库位信息仍输出', async () => { const pairs = await fetchSpaceStockPairs(2); const check = await createCheck({ mode: 'blind' }); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const reportedDetail = details.rows.find(row => Number(row.stock_id) === pairs[0].stockId); await reportCheck(check.id, reportedDetail.id, 6, pairs[0].spaceCode); const data = await workDataCheck(check.id, 'space'); const reportedRow = data.rows.find(row => Number(row.id) === pairs[0].spaceId); const unreportedRow = data.rows.find(row => Number(row.id) === pairs[1].spaceId); assert.ok(reportedRow && unreportedRow, '两个库位均应出现在聚合列表'); for (const [ row, pair ] of [[ reportedRow, pairs[0] ], [ unreportedRow, pairs[1] ]]) { assert.equal(row.space_code, pair.spaceCode || null); assert.equal(row.custom_name, pair.customName || null); assert.equal(row.goods.length, 1); const goods = row.goods[0]; assert.equal(Number(goods.stock_id), pair.stockId); assert.equal( Object.prototype.hasOwnProperty.call(goods, 'system_quantity'), false, '盲盘不应包含库位账面' ); assert.equal( Object.prototype.hasOwnProperty.call(goods, 'locked_quantity'), false, '盲盘不应包含库位锁定数量' ); assert.equal( Object.prototype.hasOwnProperty.call(goods, 'checked_quantity'), false, '盲盘不应包含已盘数量' ); assert.ok(goods.status, '盲盘仍应输出已盘/未盘状态'); } assert.equal(reportedRow.goods[0].status, 'checked'); assert.equal(unreportedRow.goods[0].status, 'unchecked'); }); it('视图驱动规则:库位任务一律 location(无视 is_goods/view)、商品任务默认 space、is_goods=true 才 goods', async () => { // 库位任务:传 is_goods=true 仍返回 location 视图行(库位范围行) const { check: locationCheck } = await createApprovedLocationCheck(); const locRows = await workDataCheck(locationCheck.id, { isGoods: true }); assert.equal(locRows.view, 'location', '库位任务无视 is_goods,view 应为 location'); assert.equal(locRows.total, 1, '库位任务应返回库位范围行'); assert.ok(locRows.rows.every(row => row.location_id !== undefined), 'location 视图行应含 location_id'); // 商品任务:默认(不传 is_goods)→ space 聚合库位视图 const pairs = await fetchSpaceStockPairs(2); const goodsCheck = await createCheck(); await addDetail(goodsCheck.id, pairs.map(pair => pair.stockId)); await submitCheck(goodsCheck.id); await auditCheck(goodsCheck.id, 'approve'); const defaultView = await workDataCheck(goodsCheck.id); assert.equal(defaultView.view, 'space', '商品任务默认 view 应为 space'); assert.equal(defaultView.total, 2, '商品任务默认应返回聚合库位视图'); assert.ok(defaultView.rows.every(row => row.space_code !== undefined), 'space 视图行应含 space_code'); // 商品任务:is_goods=true → goods 商品视图(明细行) const goodsView = await workDataCheck(goodsCheck.id, { isGoods: true }); assert.equal(goodsView.view, 'goods', 'is_goods=true 时 view 应为 goods'); assert.equal(goodsView.total, 2); assert.ok(goodsView.rows.every(row => row.stock_id !== undefined), 'goods 视图行应含 stock_id'); // view 入参已废弃:库位任务传 view='space' 仍返回 location 行 const viewIgnored = await workDataCheck(locationCheck.id, 'space'); assert.equal(viewIgnored.view, 'location'); assert.equal(viewIgnored.total, 1); assert.ok(viewIgnored.rows.every(row => row.location_id !== undefined), 'view 入参被忽略,库位任务仍返回 location 行'); }); it('is_goods 非 true(false/0/字符串/缺省)一律按默认聚合库位视图', async () => { const pairs = await fetchSpaceStockPairs(1); const check = await createCheck(); await addDetail(check.id, [ pairs[0].stockId ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); for (const value of [ undefined, false, 0, 'false', '' ]) { const data = await workDataCheck(check.id, { isGoods: value }); assert.equal(data.view, 'space', `is_goods=${JSON.stringify(value)} 应按默认 space 返回`); assert.equal(data.total, 1, `is_goods=${JSON.stringify(value)} 应按默认 space 返回`); assert.ok(data.rows[0].space_code !== undefined, '非 true 值应按默认 space 视图返回'); } }); it('分页:rows 按页切片、total 为全量行数、page/pageSize 归一化(默认 20、上限 200、非法回退)', async () => { const pairs = await fetchSpaceStockPairs(3); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const callWithPagination = pagination => ctx.service.systems.stockCheck.workData({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, view: 'space', pagination, }); // page=1 pageSize=2 → 2 行,total 仍为全量 3 const firstPage = await callWithPagination({ page: 1, pageSize: 2 }); assert.equal(firstPage.total, 3, 'total 应为全量行数(未分页口径)'); assert.equal(firstPage.rows.length, 2, 'pageSize=2 应只返回 2 行'); assert.equal(firstPage.page, 1); assert.equal(firstPage.pageSize, 2); // page=2 pageSize=2 → 剩余 1 行,两页并集覆盖全量且不重叠 const secondPage = await callWithPagination({ page: 2, pageSize: 2 }); assert.equal(secondPage.rows.length, 1); const pagedIds = [ ...firstPage.rows.map(row => Number(row.id)), ...secondPage.rows.map(row => Number(row.id)), ].sort((left, right) => left - right); assert.deepEqual( pagedIds, pairs.map(pair => pair.spaceId).sort((left, right) => left - right), '两页并集应覆盖全量库位且不重叠' ); // 不传分页 → 默认 page=1/pageSize=20,返回全量 const defaultPage = await workDataCheck(check.id, 'space'); assert.equal(defaultPage.total, 3); assert.equal(defaultPage.rows.length, 3, '默认 pageSize=20 应返回全部 3 行'); assert.equal(defaultPage.page, 1); assert.equal(defaultPage.pageSize, 20); // 非法分页值(page=-1/pageSize=0)→ 回退默认 const invalidPage = await callWithPagination({ page: -1, pageSize: 0 }); assert.equal(invalidPage.page, 1); assert.equal(invalidPage.pageSize, 20); assert.equal(invalidPage.rows.length, 3); // pageSize 超上限 500 → 收敛到 200(本任务全量 3 行全部返回) const hugePage = await callWithPagination({ page: 1, pageSize: 500 }); assert.equal(hugePage.pageSize, 200); assert.equal(hugePage.rows.length, 3); // 超出范围页 → rows 空、total 仍为全量 const beyondPage = await callWithPagination({ page: 3, pageSize: 2 }); assert.equal(beyondPage.total, 3); assert.deepEqual(beyondPage.rows, [], '超出范围页应返回空行'); }); it('400 边界:任务 ID 为空/非法(undefined/0/负数/非数字)', async () => { const assertInvalidId = async badId => { await assert.rejects(async () => { await ctx.service.systems.stockCheck.workData({ warehouseId: TEST_WAREHOUSE_ID, id: badId, }); }, error => error.code === 400 && /任务ID不能为空/.test(error.message)); }; for (const badId of [ undefined, 0, -1, 'abc' ]) { await assertInvalidId(badId); } }); it('400 边界:任务不存在', async () => { const missingId = await findFreeCheckId(); await assert.rejects(async () => { await workDataCheck(missingId, 'goods'); }, error => error.code === 400 && /任务不存在/.test(error.message)); }); it('400 边界:其他仓库任务不可见(仓库隔离)', async () => { const other = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); await assert.rejects(async () => { await workDataCheck(other.id, 'goods'); }, error => error.code === 400 && /任务不存在/.test(error.message)); }); it('400 状态限制:created/submitted/cancelled 状态拉取作业数据均拒绝且 message 含状态说明', async () => { const assertStatusRejected = async (checkId, label) => { await assert.rejects(async () => { await workDataCheck(checkId, 'goods'); }, error => error.code === 400 && /不允许拉取盘点作业数据/.test(error.message) && /仅审核完成(approved)或盘点作业中(checking)的任务可拉取/.test(error.message) && error.message.includes(`当前状态(${label})`)); }; // created:任务创建(含明细)后未提交审核即拉取 const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await assertStatusRejected(check.id, '已创建'); // submitted:提交审核后(未审核)拉取 await submitCheck(check.id); await assertStatusRejected(check.id, '待审核'); // cancelled:取消任务后拉取 await cancelCheck(check.id); await assertStatusRejected(check.id, '已取消'); }); it('400 状态限制:rejected 状态拉取作业数据 → 400 且 message 含状态说明', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'reject', '任务信息有误'); await assert.rejects(async () => { await workDataCheck(check.id, 'goods'); }, error => error.code === 400 && /不允许拉取盘点作业数据/.test(error.message) && error.message.includes('当前状态(已驳回)')); }); it('400 状态限制:completed 状态拉取作业数据 → 400 且 message 含状态说明', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); await finishCheck(check.id); await assert.rejects(async () => { await workDataCheck(check.id, 'goods'); }, error => error.code === 400 && /不允许拉取盘点作业数据/.test(error.message) && error.message.includes('当前状态(已完成)')); }); it('workDataSpaceDetails:传入 location_id 只返回该库位行(total=1,结构与 space 视图一致)', async () => { const pairs = await fetchSpaceStockPairs(2); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const target = pairs[0]; const data = await ctx.service.systems.stockCheck.workDataSpaceDetails({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, locationId: target.spaceId, }); assert.equal(data.view, 'space', 'view 应恒为 space'); assert.equal(data.total, 1, '传入库位ID时应只返回该库位'); assert.equal(data.rows.length, 1); const row = data.rows[0]; assert.equal(Number(row.id), target.spaceId, '行 id 应为库位ID'); assert.equal(row.space_code, target.spaceCode || null); assert.equal(row.custom_name, target.customName || null); assert.equal(row.goods.length, 1, '该库位仅一个任务商品'); assert.equal(Number(row.goods[0].stock_id), target.stockId, 'goods 应挂载该库位的任务商品'); assert.equal(Number(row.goods[0].system_quantity), target.book, '明盘库位账面应为 wms_storage SUM(可用数量)'); assert.equal(Number(row.goods[0].locked_quantity), target.bookLocked, '明盘库位锁定数量应为 wms_storage SUM(locked_quantity)'); assert.equal(Number(row.goods[0].checked_quantity), 0, '未盘库位已盘应为 0'); assert.equal(row.goods[0].status, 'unchecked'); }); it('workDataSpaceDetails:不传 location_id 按分页返回全部 space 行(total/rows/page/pageSize 口径)', async () => { const pairs = await fetchSpaceStockPairs(3); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const data = await ctx.service.systems.stockCheck.workDataSpaceDetails({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, pagination: { page: 1, pageSize: 2 }, }); assert.equal(data.view, 'space'); assert.equal(data.total, 3, '应返回全部 3 个库位行数'); assert.equal(data.rows.length, 2, 'pageSize=2 应只返回 2 行'); assert.equal(data.page, 1); assert.equal(data.pageSize, 2); const page1Ids = data.rows.map(row => Number(row.id)); assert.ok( page1Ids.every(id => pairs.some(pair => pair.spaceId === id)), '第一页返回库位应属于任务商品所在库位集合' ); // 第二页 const page2 = await ctx.service.systems.stockCheck.workDataSpaceDetails({ warehouseId: TEST_WAREHOUSE_ID, id: check.id, pagination: { page: 2, pageSize: 2 }, }); assert.equal(page2.total, 3); assert.equal(page2.rows.length, 1, '第二页应返回剩余 1 行'); assert.equal(page2.page, 2); // 两页合并应与任务商品所在库位全集一致 const mergedIds = [ ...page1Ids, ...page2.rows.map(row => Number(row.id)) ].sort((left, right) => left - right); assert.deepEqual( mergedIds, pairs.map(pair => pair.spaceId).sort((left, right) => left - right), '两页合并的库位集合应与任务商品所在库位一致' ); }); it('workDataSpaceDetails 方法层:仓库注入 + location_id 驼峰兼容 + success 包装', async () => { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; const pairs = await fetchSpaceStockPairs(2); const check = await createCheck(); await addDetail(check.id, pairs.map(pair => pair.stockId)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const result = await ctx.service.systemMethods.stock.check.workDataSpaceDetails({ id: check.id, locationId: pairs[0].spaceId, }); assert.equal(result.flag, 'success'); assert.equal(result.data.view, 'space'); assert.equal(result.data.total, 1); assert.equal(Number(result.data.rows[0].id), pairs[0].spaceId, '库位ID驼峰写法应生效'); // 库位任务(type=location)不适用 space 视图聚合,但接口仍按任务类型构建(无 goods 明细返回空) const locationCheck = await createCheck({ type: 'location' }); await addLocationDetail(locationCheck.id, [ TEST_LOCATION_CODE ]); await submitCheck(locationCheck.id); await auditCheck(locationCheck.id, 'approve'); const locationResult = await ctx.service.systemMethods.stock.check.workDataSpaceDetails({ id: locationCheck.id, }); assert.equal(locationResult.flag, 'success'); assert.equal(locationResult.data.view, 'space'); assert.equal(locationResult.data.total, 0, '库位任务无商品范围明细,space 聚合应为空'); }); }); // ------------------- systemMethods.stock.check.workData:方法包装层 ------------------- describe('systemMethods.stock.check.workData 方法包装层', () => { /** 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 */ function mockCurrentUser() { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; } it('is_goods 透传 + 仓库上下文注入 + success 包装', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const result = await ctx.service.systemMethods.stock.check.workData({ id: check.id, is_goods: true }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal( Object.prototype.hasOwnProperty.call(result.data, 'check'), false, '方法层 workData 不返回 check(任务信息请调 detail)' ); assert.equal(result.data.view, 'goods', '方法层 workData 应返回解析后的 view'); assert.equal(result.data.total, 1); assert.equal(result.data.rows.length, 1); assert.equal(Number(result.data.rows[0].stock_id), Number(stocks[0].id), 'is_goods=true 应返回商品视图行'); assert.equal( Object.prototype.hasOwnProperty.call(result.data.rows[0], 'system_quantity'), true, '明盘商品视图应含账面快照' ); }); it('view 入参已废弃:传非法 view 不报错,商品任务默认 space、is_goods=true 时 goods', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); // view 传非法值不报错(入参已废弃忽略) const invalidView = await ctx.service.systemMethods.stock.check.workData({ id: check.id, view: 'invalid' }); assert.equal(invalidView.flag, 'success'); assert.equal(invalidView.code, 1); // is_goods=true 返回商品视图(商品行含 stock_id 与明盘账面快照) const goodsResult = await ctx.service.systemMethods.stock.check.workData({ id: check.id, view: 'invalid', is_goods: true }); assert.equal(goodsResult.flag, 'success'); assert.equal(goodsResult.data.total, 1); assert.equal(Number(goodsResult.data.rows[0].stock_id), Number(stocks[0].id), 'is_goods=true 应返回商品视图行'); assert.equal( Object.prototype.hasOwnProperty.call(goodsResult.data.rows[0], 'system_quantity'), true, '明盘商品视图应含账面快照' ); }); it('workDataDetail 方法层:id + stock_id 返回 summary + rows,兼容 stockId 驼峰与 detail_id', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const targetDetail = details.rows[0]; const snapshot = Number(targetDetail.system_quantity); await reportCheck(check.id, targetDetail.id, snapshot + 1, TEST_LOCATION_CODE); const bySnake = await ctx.service.systemMethods.stock.check.workDataDetail({ id: check.id, stock_id: stocks[0].id, }); assert.equal(bySnake.flag, 'success'); assert.equal(bySnake.code, 1); assert.equal(Number(bySnake.data.stock_id), Number(stocks[0].id)); assert.equal(Number(bySnake.data.summary.checked_quantity), snapshot + 1, '方法层应返回汇总数据'); assert.ok(Array.isArray(bySnake.data.rows) && bySnake.data.rows.length >= 1, '方法层应返回分行数据'); const byCamel = await ctx.service.systemMethods.stock.check.workDataDetail({ id: check.id, stockId: stocks[0].id, }); assert.equal(byCamel.flag, 'success'); assert.equal(Number(byCamel.data.summary.checked_quantity), snapshot + 1); // 兼容旧写法:只传 detail_id(商品范围明细) const byDetailId = await ctx.service.systemMethods.stock.check.workDataDetail({ detail_id: targetDetail.id }); assert.equal(byDetailId.flag, 'success'); assert.equal(Number(byDetailId.data.stock_id), Number(stocks[0].id)); // 缺少必要参数 → failure 400 包装 const missing = await ctx.service.systemMethods.stock.check.workDataDetail({ id: check.id }); assert.equal(missing.flag, 'failure'); assert.equal(missing.code, 400); }); }); // ------------------- exportStockChecks:盘点导出(盘点明细=作业记录口径) ------------------- describe('exportStockChecks 盘点导出(盘点明细=作业记录口径)', () => { /** Sheet1「盘点单」表头(列名与列序,与实现完全一致) */ const SHEET1_HEADERS = [ '盘点单号', '盘点名称', '盘点范围', '盘点方式', '盘点状态', '盘点进度', '货主ID', '创建人', '明细行数', '已盘行数', '差异行数', '开始时间', '结束时间', '备注', ]; /** Sheet2「盘点明细」表头(作业记录口径:一行一条实际盘点记录) */ const SHEET2_HEADERS = [ '盘点单号', '商品编码', '商品名称', '库位编码', '实盘数量', '盘点人', '盘点时间', ]; /** * mock 上传服务:拦截 uploadFile 收集文件流 Buffer(不发起真实 COS 上传), * uploadSuccessNotify 返回落库记录。 * * @return {Object} captured 捕获的上传调用与文件 Buffer。 */ function mockUploadService() { const captured = { buffers: [], uploadCalls: [], notifyCalls: [] }; app.mockService('systems.upload', 'uploadFile', async function(fileStream, uploadOptions = {}) { captured.uploadCalls.push({ filename: fileStream.filename, key: uploadOptions.key, fileSize: fileStream.fileSize, }); const chunks = []; for await (const chunk of fileStream) { chunks.push(chunk); } captured.buffers.push(Buffer.concat(chunks)); const key = uploadOptions.key; return { fileName: key, url: `https://cdn.test.local/${key}`, cdnUrl: `https://cdn.test.local/${key}`, cosUrl: `https://cos.test.local/${key}`, }; }); app.mockService('systems.upload', 'uploadSuccessNotify', async function(data) { captured.notifyCalls.push(data); return { fileId: 90001, fileUrl: `https://cdn.test.local/${data.fileKey}`, fileKey: data.fileKey, fileName: data.fileName, }; }); return captured; } /** * 将最近一次上传的 Excel Buffer 回读为工作簿。 * * @param {Object} captured mockUploadService 返回的捕获对象。 * @return {Promise} ExcelJS 工作簿。 */ async function readBackWorkbook(captured) { assert.ok(captured.buffers.length > 0, '上传文件流未捕获到内容'); const workbook = new ExcelJS.Workbook(); await workbook.xlsx.load(captured.buffers[captured.buffers.length - 1]); return workbook; } /** * 读取单元格值(空值统一归一为空字符串)。 * * @param {Object} worksheet ExcelJS 工作表。 * @param {number} rowNo 行号(1 起)。 * @param {number} colNo 列号(1 起)。 * @return {*} 单元格值。 */ function getCell(worksheet, rowNo, colNo) { const value = worksheet.getRow(rowNo).getCell(colNo).value; return value === null || value === undefined ? '' : value; } /** * 收集工作表表头列名(按列序)。 * * @param {Object} worksheet ExcelJS 工作表。 * @return {Array} 表头列名。 */ function collectHeaders(worksheet) { const headers = []; for (let col = 1; col <= worksheet.actualColumnCount; col += 1) { const value = worksheet.getRow(1).getCell(col).value; headers.push(value === null || value === undefined ? '' : String(value)); } return headers; } /** * 导出指定盘点任务(直调业务层,上传服务已 mock),返回导出结果与回读工作簿。 * * @param {Array} ids 盘点任务ID列表。 * @param {Object} captured mockUploadService 返回的捕获对象。 * @param {Array} [progressCalls] 进度回调收集数组。 * @return {Promise} { result, workbook }。 */ async function exportChecks(ids, captured, progressCalls = []) { const result = await ctx.service.systems.stockCheck.exportStockChecks({ warehouseId: TEST_WAREHOUSE_ID, ids, onProgress: async progress => { progressCalls.push(progress); }, }); const workbook = await readBackWorkbook(captured); return { result, workbook }; } it('Sheet2 明细行数=作业记录数:未盘范围行不导出,total_count=记录总数', async () => { const captured = mockUploadService(); // 商品维度任务:2 条范围行,仅第一条上报作业记录(第二条保持未盘) const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); assert.equal(details.rows.length, 2, '前置:2 条盘点范围行'); await submitCheck(check.id); await auditCheck(check.id, 'approve'); await reportCheck(check.id, details.rows[0].id, 5); const records = await queryRecords(check.id); assert.equal(records.length, 1, '前置:仅 1 条作业记录'); const progressCalls = []; const { result, workbook } = await exportChecks([ check.id ], captured, progressCalls); // 返回统计:total_count=作业记录总数(而非范围行数) assert.equal(result.total_count, 1); assert.equal(result.current_count, 1); assert.match(result.filename, /^库存盘点导出_\d{14}\.xlsx$/, '文件名格式应为 库存盘点导出_时间戳.xlsx'); // 双 Sheet 名称 + 表头列名列序 assert.equal(workbook.worksheets.length, 2); assert.equal(workbook.worksheets[0].name, '盘点单'); assert.equal(workbook.worksheets[1].name, '盘点明细'); assert.deepEqual(collectHeaders(workbook.worksheets[0]), SHEET1_HEADERS); assert.deepEqual(collectHeaders(workbook.worksheets[1]), SHEET2_HEADERS); // Sheet1 无「盘点日期」列;开始时间=首次上报时间(非空)、结束时间未完成(空) const sheet1 = workbook.worksheets[0]; assert.ok( !collectHeaders(sheet1).includes('盘点日期'), 'Sheet1 不应含「盘点日期」列' ); assert.notEqual(getCell(sheet1, 2, 12), '', 'Sheet1 开始时间应非空(首次上报已写 start_time)'); assert.equal(getCell(sheet1, 2, 13), '', 'Sheet1 结束时间应为空(未完成盘点)'); // Sheet1:表头 + 1 个任务;Sheet2:表头 + 1 条作业记录(未盘的第 2 条范围行不导出) assert.equal(workbook.worksheets[0].actualRowCount, 2); assert.equal(workbook.worksheets[1].actualRowCount, 2); // Sheet2 数据行:盘点单号/实盘数量正确 const sheet2 = workbook.worksheets[1]; assert.equal(getCell(sheet2, 2, 1), check.check_no); assert.equal(getCell(sheet2, 2, 5), 5); // 进度推送 totalCount 为作业记录总数 const progressWithTotal = progressCalls.find(item => item && item.totalCount !== undefined); assert.ok(progressWithTotal, '应推送包含 totalCount 的进度'); assert.equal(progressWithTotal.totalCount, 1); }); it('库位行记录导出含商品快照:item_code/item_name 从 wms_stock_warehouse 补齐', async () => { const captured = mockUploadService(); const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); assert.ok(stockIds.length > 0, '前置:固定库位下存在库存商品'); await reportCheck(check.id, details.rows[0].id, 7, TEST_LOCATION_CODE, { stockId: stockIds[0] }); const stockRow = await ctx.model.StockWarehouse.findOne({ where: { id: stockIds[0] }, attributes: [ 'id', 'item_code', 'item_name' ], raw: true, }); const { result, workbook } = await exportChecks([ check.id ], captured); assert.equal(result.total_count, 1); const sheet2 = workbook.worksheets[1]; assert.equal(sheet2.actualRowCount, 2); assert.equal(getCell(sheet2, 2, 1), check.check_no); assert.equal(getCell(sheet2, 2, 2), stockRow.item_code, '商品编码应来自 wms_stock_warehouse'); assert.equal(getCell(sheet2, 2, 3), stockRow.item_name, '商品名称应来自 wms_stock_warehouse'); assert.equal(getCell(sheet2, 2, 4), TEST_LOCATION_CODE); assert.equal(getCell(sheet2, 2, 5), 7); assert.equal(getCell(sheet2, 2, 6), TEST_CREATOR_NAME); assert.notEqual(getCell(sheet2, 2, 7), '', '盘点时间应非空'); }); it('历史空库位记录(location_code="")导出库位编码为空', async () => { const captured = mockUploadService(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; // report 已强制 space_id,这里直接构造历史脏数据(空串库位)验证导出兼容 await ctx.model.StockCheckRecord.create({ check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: detail.id, stock_id: Number(detail.stock_id), location_id: null, location_code: '', quantity: 3, is_empty: false, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }); const records = await queryRecords(check.id); assert.equal(records.length, 1); assert.equal(records[0].location_code, '', '前置:库中 location_code 应为空串'); const { workbook } = await exportChecks([ check.id ], captured); const sheet2 = workbook.worksheets[1]; assert.equal(sheet2.actualRowCount, 2); assert.equal(getCell(sheet2, 2, 1), check.check_no); assert.equal(getCell(sheet2, 2, 4), '', '空库位记录的库位编码应导出为空'); assert.equal(getCell(sheet2, 2, 5), 3); }); it('多任务导出:按盘点单号分组正确,Sheet1 一行一个任务', async () => { const captured = mockUploadService(); const checkA = await createCheck(); const checkB = await createCheck(); const quantityMap = new Map([ [ checkA.id, 4 ], [ checkB.id, 6 ], ]); for (const check of [ checkA, checkB ]) { const stocks = await fetchStockRows(1); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, quantityMap.get(check.id)); } const { result, workbook } = await exportChecks([ checkA.id, checkB.id ], captured); assert.equal(result.total_count, 2); // Sheet1:表头 + 2 个任务(按 id 升序) const sheet1 = workbook.worksheets[0]; assert.equal(sheet1.actualRowCount, 3); assert.equal(getCell(sheet1, 2, 1), checkA.check_no); assert.equal(getCell(sheet1, 3, 1), checkB.check_no); // Sheet2:两条作业记录按盘点单号各归各任务 const sheet2 = workbook.worksheets[1]; assert.equal(sheet2.actualRowCount, 3); assert.equal(getCell(sheet2, 2, 1), checkA.check_no, '第一条记录应属于任务A'); assert.equal(getCell(sheet2, 2, 5), 4); assert.equal(getCell(sheet2, 3, 1), checkB.check_no, '第二条记录应属于任务B'); assert.equal(getCell(sheet2, 3, 5), 6); }); it('未知商品导出口径:Sheet2 商品编码=扫描条码、商品名称=名称快照', async () => { const captured = mockUploadService(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 2, TEST_LOCATION_CODE); const unknownBarcode = uniqueTitle('UNKNOWN-EXPORT'); await reportCheck(check.id, details.rows[0].id, 4, TEST_LOCATION_CODE_2, { barcode: unknownBarcode, itemName: '导出未知商品快照', }); const { result, workbook } = await exportChecks([ check.id ], captured); assert.equal(result.total_count, 2); const sheet2 = workbook.worksheets[1]; assert.equal(sheet2.actualRowCount, 3, '表头 + 2 条作业记录'); assert.equal(getCell(sheet2, 2, 2), details.rows[0].item_code, '已知商品编码来自 wms_stock_warehouse'); assert.equal(getCell(sheet2, 3, 2), unknownBarcode, '未知商品编码列显示扫描条码'); assert.equal(getCell(sheet2, 3, 3), '导出未知商品快照', '未知商品名称列显示名称快照'); assert.equal(getCell(sheet2, 3, 4), TEST_LOCATION_CODE_2); assert.equal(getCell(sheet2, 3, 5), 4); }); }); // ------------------- exportCheckDetail:盘点明细导出(按盘点范围分流) ------------------- describe('exportCheckDetail 盘点明细导出(商品盘点分库位明细/汇总+差异,库位盘点简化)', () => { /** 商品盘点 Sheet1「汇总和差异」表头 */ const SUMMARY_SHEET_HEADERS = [ '盘点单号', '商品编码', '条码', '商品名称', '规格', '账面数量', '盘点数量', '差异数量', '差异类型', ]; /** 商品盘点 Sheet2「库位明细」表头 */ const LOCATION_SHEET_HEADERS = [ '库位编码', '数量', '条码', '商品名称' ]; /** 库位盘点 Sheet「盘点明细」表头 */ const SIMPLE_SHEET_HEADERS = [ '库位编码', '商品编码', '商品名称', '盘点数量' ]; function mockUploadService() { const captured = { buffers: [], uploadCalls: [], notifyCalls: [] }; app.mockService('systems.upload', 'uploadFile', async function(fileStream, uploadOptions = {}) { captured.uploadCalls.push({ filename: fileStream.filename, key: uploadOptions.key, fileSize: fileStream.fileSize, }); const chunks = []; for await (const chunk of fileStream) { chunks.push(chunk); } captured.buffers.push(Buffer.concat(chunks)); const key = uploadOptions.key; return { fileName: key, url: `https://cdn.test.local/${key}`, cdnUrl: `https://cdn.test.local/${key}`, cosUrl: `https://cos.test.local/${key}`, }; }); app.mockService('systems.upload', 'uploadSuccessNotify', async function(data) { captured.notifyCalls.push(data); return { fileId: 90002, fileUrl: `https://cdn.test.local/${data.fileKey}`, fileKey: data.fileKey, fileName: data.fileName, }; }); return captured; } async function readBackWorkbook(captured) { assert.ok(captured.buffers.length > 0, '上传文件流未捕获到内容'); const workbook = new ExcelJS.Workbook(); await workbook.xlsx.load(captured.buffers[captured.buffers.length - 1]); return workbook; } function getCell(worksheet, rowNo, colNo) { const value = worksheet.getRow(rowNo).getCell(colNo).value; return value === null || value === undefined ? '' : value; } function collectHeaders(worksheet) { const headers = []; for (let col = 1; col <= worksheet.actualColumnCount; col += 1) { const value = worksheet.getRow(1).getCell(col).value; headers.push(value === null || value === undefined ? '' : String(value)); } return headers; } async function exportDetail(checkId) { return ctx.service.systems.stockCheck.exportCheckDetail({ warehouseId: TEST_WAREHOUSE_ID, id: checkId, onProgress: () => {}, }); } /** * 按实现口径解析库位显示文本:自定义名称 → 自定义编码 → 库位编码。 * * @param {string} code 库位编码。 * @return {Promise} 期望显示的库位文本。 */ async function resolveLocationDisplay(code) { const space = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: String(code || '').trim() }, attributes: [ 'space_code', 'custom_name', 'custom_barcode' ], raw: true, }); if (!space) { return String(code || '').trim(); } return String(space.custom_name || '').trim() || String(space.custom_barcode || '').trim() || String(space.space_code || '').trim(); } it('商品任务:两个 sheet——「汇总和差异」每商品一行 + 「库位明细」库位/数量/条码/商品名称', async () => { const captured = mockUploadService(); const { Op } = ctx.app.Sequelize; const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const firstDetail = details.rows[0]; const secondDetail = details.rows[1]; const firstSnapshot = Number(firstDetail.system_quantity); const secondSnapshot = Number(secondDetail.system_quantity); // 在商品自身快照库位上报:第一商品盘盈 7、第二商品持平 await reportCheck(check.id, firstDetail.id, firstSnapshot + 7, firstDetail.location_code); await reportCheck(check.id, secondDetail.id, secondSnapshot, secondDetail.location_code); // 商品条码(wms_stock_barcodes 按 stock_id 取第一条,口径与实现一致) const barcodeRows = await ctx.model.StockBarcode.findAll({ where: { warehouse_id: TEST_WAREHOUSE_ID, stock_id: { [Op.in]: [ Number(firstDetail.stock_id), Number(secondDetail.stock_id) ] }, }, attributes: [ 'stock_id', 'barcode' ], order: [[ 'id', 'ASC' ]], raw: true, }); const barcodeByStock = new Map(); for (const row of barcodeRows) { const rowStockId = Number(row.stock_id); if (!barcodeByStock.has(rowStockId)) { barcodeByStock.set(rowStockId, String(row.barcode || '').trim()); } } const result = await exportDetail(check.id); assert.equal(result.total_count, 4, '汇总 2 行 + 作业记录 2 行'); const workbook = await readBackWorkbook(captured); assert.equal(workbook.worksheets.length, 2, '商品盘点固定两个 sheet'); const summarySheet = workbook.worksheets[0]; assert.equal(summarySheet.name, '汇总和差异'); assert.deepEqual(collectHeaders(summarySheet), SUMMARY_SHEET_HEADERS); assert.equal(summarySheet.actualRowCount, 3, '表头 + 2 商品'); assert.equal(getCell(summarySheet, 2, 2), firstDetail.item_code); assert.equal( getCell(summarySheet, 2, 3), barcodeByStock.get(Number(firstDetail.stock_id)) || '', '条码=商品条码' ); assert.equal(getCell(summarySheet, 2, 6), firstSnapshot, '账面=快照合计'); assert.equal(getCell(summarySheet, 2, 7), firstSnapshot + 7); assert.equal(getCell(summarySheet, 2, 8), 7); assert.equal(getCell(summarySheet, 2, 9), '盘盈'); assert.equal(getCell(summarySheet, 3, 8), 0, '持平商品差异 0'); assert.equal(getCell(summarySheet, 3, 9), '', '持平商品差异类型为空'); const locationSheet = workbook.worksheets[1]; assert.equal(locationSheet.name, '库位明细'); assert.deepEqual(collectHeaders(locationSheet), LOCATION_SHEET_HEADERS); assert.equal(locationSheet.actualRowCount, 3, '表头 + 2 条作业记录'); assert.equal( getCell(locationSheet, 2, 1), await resolveLocationDisplay(firstDetail.location_code), '库位显示=自定义名称→自定义编码→库位编码' ); assert.equal(getCell(locationSheet, 2, 2), firstSnapshot + 7, '数量=实盘'); assert.equal(getCell(locationSheet, 2, 3), barcodeByStock.get(Number(firstDetail.stock_id)) || '', '条码=商品条码'); assert.equal(getCell(locationSheet, 2, 4), firstDetail.item_name); assert.equal( getCell(locationSheet, 3, 1), await resolveLocationDisplay(secondDetail.location_code), '库位显示=自定义名称→自定义编码→库位编码' ); assert.equal(getCell(locationSheet, 3, 2), secondSnapshot); assert.equal(getCell(locationSheet, 3, 4), secondDetail.item_name); }); it('库位任务:单 sheet 库位/商品编码/商品名称/盘点数量(未知商品编码=条码)', async () => { const captured = mockUploadService(); const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); assert.ok(stockIds.length > 0, '前置:固定测试库位应存在库存商品'); await reportCheck(check.id, detail.id, 3, undefined, { stockId: stockIds[0] }); const unknownBarcode = uniqueTitle('LOCATION-EXPORT-UNKNOWN'); await reportCheck(check.id, detail.id, 4, undefined, { barcode: unknownBarcode }); const result = await exportDetail(check.id); assert.equal(result.total_count, 2, '两条作业记录'); const workbook = await readBackWorkbook(captured); assert.equal(workbook.worksheets.length, 1, '库位任务单 sheet'); const sheet = workbook.worksheets[0]; assert.equal(sheet.name, '盘点明细'); assert.deepEqual(collectHeaders(sheet), SIMPLE_SHEET_HEADERS); assert.equal(sheet.actualRowCount, 3, '表头 + 2 行'); assert.equal( getCell(sheet, 2, 1), await resolveLocationDisplay(TEST_LOCATION_CODE), '库位列显示=自定义名称→自定义编码→库位编码' ); assert.equal(getCell(sheet, 2, 4), 3, '盘点数量'); assert.equal(getCell(sheet, 3, 2), unknownBarcode, '未知商品编码=扫描条码'); assert.equal(getCell(sheet, 3, 4), 4); }); it('方法层 exportDetail:返回任务ID并异步完成(进度复用 exportTaskProgress)', async () => { mockUploadService(); ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const result = await ctx.service.systemMethods.stock.check.exportDetail({ id: check.id }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.ok(result.task_id, '应返回导出任务ID'); assert.equal(result.status, 'submitted'); // 轮询导出进度至终态(上传服务已 mock,egg-mock 环境内可正常执行) const taskId = result.task_id; let progress = null; for (let attempt = 0; attempt < 50; attempt++) { progress = await ctx.service.systemMethods.stock.check.exportTaskProgress({ task_id: taskId }); if (progress.status === 'success' || progress.status === 'failed') { break; } await new Promise(resolve => setTimeout(resolve, 100)); } assert.equal(progress.status, 'success', `导出任务应完成: ${progress.error}`); assert.ok(progress.download_url, '完成后应返回下载链接'); // 未传 id 报 400 const invalid = await ctx.service.systemMethods.stock.check.exportDetail({}); assert.equal(invalid.flag, 'failure'); assert.equal(invalid.code, 400); }); }); // ------------------- 未知商品记录 + 图片独立维护(迁移 20261001100000) ------------------- describe('未知商品记录 + 图片独立维护', () => { it('未知商品:库位行仅传 barcode(不存在)→ stock_id=NULL、barcode/item_name 落库(item_name 缺省=barcode)', async () => { const { check, detail } = await createApprovedLocationCheck(); const unknownBarcode = uniqueTitle('UNKNOWN-BARCODE'); // 前置:条码未命中本仓库系统商品 assert.equal( await ctx.model.StockBarcode.count({ where: { warehouse_id: TEST_WAREHOUSE_ID, barcode: unknownBarcode }, }), 0, '前置:测试条码不应命中系统商品' ); const result = await reportCheck(check.id, detail.id, 5, undefined, { barcode: unknownBarcode }); assert.equal(result.mode, 'created'); assert.equal(result.record.stock_id, null, '未知商品 stock_id 应为 NULL'); assert.equal(result.record.barcode, unknownBarcode, '记录应写入扫描条码'); assert.equal(result.record.item_name, unknownBarcode, 'item_name 缺省应为条码'); assert.equal(result.record.location_code, TEST_LOCATION_CODE, '库位以明细库位为准'); assert.equal(result.checked_items, 1); assert.equal(result.detail_status, 'all_checked'); const record = await ctx.model.StockCheckRecord.findOne({ where: { id: Number(result.record.id) }, raw: true, }); assert.equal(record.stock_id, null, '库中 stock_id 应为 NULL'); assert.equal(record.barcode, unknownBarcode); assert.equal(record.item_name, unknownBarcode); }); it('未知商品:显式传 item_name 按快照落库(非缺省条码)', async () => { const { check, detail } = await createApprovedLocationCheck(); const unknownBarcode = uniqueTitle('UNKNOWN-BARCODE-NAME'); const result = await reportCheck(check.id, detail.id, 2, undefined, { barcode: unknownBarcode, itemName: '未知商品快照名称', }); assert.equal(result.record.stock_id, null); assert.equal(result.record.barcode, unknownBarcode); assert.equal(result.record.item_name, '未知商品快照名称', 'item_name 应为显式快照'); }); it('barcode 命中系统条码:库位行回填 stock_id 按已知商品处理,重复上报覆盖更新', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const stockId = Number(stocks[0].id); const knownBarcode = uniqueTitle('KNOWN-BARCODE'); await createStockBarcode(stockId, knownBarcode); const first = await reportCheck(check.id, detail.id, 3, undefined, { barcode: knownBarcode }); assert.equal(first.mode, 'created'); assert.equal(Number(first.record.stock_id), stockId, '命中系统条码应回填 stock_id'); assert.equal(first.record.barcode, knownBarcode, '已知商品记录冗余条码'); assert.equal(first.record.item_name, null, '已知商品不落 item_name'); const second = await reportCheck(check.id, detail.id, 6, undefined, { barcode: knownBarcode }); assert.equal(second.mode, 'updated', '回填后按 (detail,stock,location) 覆盖更新'); assert.equal(Number(second.record.id), Number(first.record.id)); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 1, '同 (detail,stock,location) 只保留一条记录'); assert.equal(Number(records[0].stock_id), stockId); assert.equal(Number(records[0].quantity), 6); }); it('商品行 barcode 命中系统条码:与明细商品一致回填 stock_id;命中其他商品报 400', async () => { const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const barcodeForA = uniqueTitle('GOODS-BARCODE-A'); const barcodeForB = uniqueTitle('GOODS-BARCODE-B'); await createStockBarcode(stocks[0].id, barcodeForA); await createStockBarcode(stocks[1].id, barcodeForB); const hit = await reportCheck(check.id, detail.id, 4, undefined, { barcode: barcodeForA }); assert.equal(hit.mode, 'created'); assert.equal(Number(hit.record.stock_id), Number(detail.stock_id), '命中且一致应回填明细商品'); assert.equal(hit.record.barcode, barcodeForA); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 4, undefined, { barcode: barcodeForB }); }, error => error.code === 400 && /上报商品与盘点明细商品不一致/.test(error.message)); }); it('未知商品覆盖式:同 detail+同 barcode+同库位二次上报 → updated、数量更新、不新增记录', async () => { const { check, detail } = await createApprovedLocationCheck(); const unknownBarcode = uniqueTitle('UNKNOWN-UPDATE'); const first = await reportCheck(check.id, detail.id, 5, undefined, { barcode: unknownBarcode }); assert.equal(first.mode, 'created'); const second = await reportCheck(check.id, detail.id, 9, undefined, { barcode: unknownBarcode }); assert.equal(second.mode, 'updated', '同 barcode 同库位应覆盖更新'); assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); const records = await queryRecords(check.id, detail.id); assert.equal(records.length, 1, '未知商品同 barcode 同库位只保留一条记录'); assert.equal(Number(records[0].quantity), 9); }); it('result 库位行 unknown_items:未知实盘=盘盈差异、stocks 保持只含已知商品', async () => { const { check, detail } = await createApprovedLocationCheck(); const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); assert.ok(stockIds.length > 0, '前置:固定测试库位应存在库存商品'); const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); const bookA = Number(bookMap.get(stockIds[0]) || 0); await reportCheck(check.id, detail.id, bookA, undefined, { stockId: stockIds[0] }); const unknownBarcode = uniqueTitle('UNKNOWN-RESULT'); await reportCheck(check.id, detail.id, 7, undefined, { barcode: unknownBarcode }); const result = await resultCheck(check.id); const row = result.rows[0]; assert.equal(row.checked_quantity, bookA + 7, '行级已盘=已知+未知合计'); assert.equal(row.diff_quantity, 7, '未知商品无账面:差异=实盘=盘盈'); assert.equal(row.is_diff, 1); assert.deepEqual(row.unknown_items, [ { barcode: unknownBarcode, item_name: unknownBarcode, checked_quantity: 7 }, ], 'unknown_items 应为未知商品聚合'); assert.equal(row.stocks.length, 1, 'stocks 保持只含已知商品'); assert.equal(Number(row.stocks[0].stock_id), Number(stockIds[0])); assert.equal(row.stocks[0].diff_quantity, 0, '已知商品账面持平无差异'); }); it('result 商品行 unknown_items:已知+未知混合,行级差异=已知差异+未知实盘', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; const snapshot = Number(detail.system_quantity); await reportCheck(check.id, detail.id, snapshot, TEST_LOCATION_CODE); const unknownBarcode = uniqueTitle('GOODS-UNKNOWN'); await reportCheck(check.id, detail.id, 4, TEST_LOCATION_CODE_2, { barcode: unknownBarcode }); const result = await resultCheck(check.id); const row = result.rows[0]; assert.equal(row.status, 'checked'); assert.equal(row.checked_quantity, snapshot + 4); assert.equal(row.diff_quantity, 4, '未知实盘计入商品行差异'); assert.equal(row.is_diff, 1); assert.deepEqual(row.unknown_items, [ { barcode: unknownBarcode, item_name: unknownBarcode, checked_quantity: 4 }, ], '商品行同样输出 unknown_items'); }); it('finish 未知商品计入 profit_total/diff_items(无账面=盘盈)', async () => { const { check, detail } = await createApprovedLocationCheck(); const unknownBarcode = uniqueTitle('UNKNOWN-FINISH'); await reportCheck(check.id, detail.id, 11, undefined, { barcode: unknownBarcode }); const result = await finishCheck(check.id); assert.equal(result.status, 'completed'); assert.equal(result.total_items, 1); assert.equal(result.checked_items, 1); assert.equal(result.unchecked_items, 0); assert.equal(result.diff_items, 1, '未知商品必然差异计入 diff_items'); assert.equal(result.profit_total, 11, '未知商品实盘=盘盈'); assert.equal(result.loss_total, 0); const row = await findCheckRow(check.id); assert.equal(row.status, 'completed'); assert.equal(row.diff_items, 1); }); it('图片独立维护:FileReference(business_type=stock_check_record) 挂载 recordList 与 result.records', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const knownReport = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stocks[0].id }); const unknownBarcode = uniqueTitle('UNKNOWN-IMAGE-EMPTY'); const unknownReport = await reportCheck(check.id, detail.id, 2, undefined, { barcode: unknownBarcode }); const { file } = await createRecordImage(Number(knownReport.record.id)); const listed = await listRecords({ id: check.id, detailId: detail.id }); assert.equal(listed.total, 2); const listedKnown = listed.rows.find(row => Number(row.id) === Number(knownReport.record.id)); const listedUnknown = listed.rows.find(row => Number(row.id) === Number(unknownReport.record.id)); assert.deepEqual( listedKnown.images, [{ id: Number(file.id), url: file.file_url }], 'recordList 应挂载 FileReference 图片' ); assert.deepEqual(listedUnknown.images, [], '无图片记录 images 应为空数组'); const result = await resultCheck(check.id); const records = result.rows[0].records; assert.equal(records.length, 2); const resultKnown = records.find(record => Number(record.id) === Number(knownReport.record.id)); const resultUnknown = records.find(record => Number(record.id) === Number(unknownReport.record.id)); assert.deepEqual( resultKnown.images, [{ id: Number(file.id), url: file.file_url }], 'result.records 应挂载 FileReference 图片' ); assert.deepEqual(resultUnknown.images, [], 'result 无图片记录 images 应为空数组'); }); it('recordDelete 删除记录时清理其 FileReference 图片引用', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const reportResult = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stocks[0].id }); const recordId = Number(reportResult.record.id); await createRecordImage(recordId); assert.equal( await ctx.model.FileReference.count({ where: { business_type: 'stock_check_record', business_id: String(recordId) }, }), 1, '前置:图片引用已创建' ); await deleteRecord(check.id, recordId); assert.equal( await ctx.model.FileReference.count({ where: { business_type: 'stock_check_record', business_id: String(recordId) }, }), 0, '删除记录后其图片引用应被清理' ); assert.equal((await queryRecords(check.id, detail.id)).length, 0, '作业记录应被删除'); }); it('recordList 未知商品展示口径:item_code=条码、item_name=名称快照;已知商品维持明细快照', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detail = details.rows[0]; await reportCheck(check.id, detail.id, 2, TEST_LOCATION_CODE); const unknownBarcode = uniqueTitle('UNKNOWN-LIST'); await reportCheck(check.id, detail.id, 3, TEST_LOCATION_CODE_2, { barcode: unknownBarcode, itemName: '盘点神秘商品', }); const listed = await listRecords({ id: check.id, detailId: detail.id }); assert.equal(listed.total, 2); const unknownRow = listed.rows.find(row => row.stock_id === null); const knownRow = listed.rows.find(row => row.stock_id !== null); assert.ok(unknownRow, '应存在未知商品记录'); assert.ok(knownRow, '应存在已知商品记录'); assert.equal(unknownRow.item_code, unknownBarcode, '未知商品编码列显示扫描条码'); assert.equal(unknownRow.item_name, '盘点神秘商品', '未知商品名称列显示名称快照'); assert.equal(unknownRow.barcode, unknownBarcode, '记录含原始条码字段'); assert.equal(knownRow.item_code, detail.item_code, '已知商品编码列维持明细快照'); assert.equal(knownRow.item_name, detail.item_name, '已知商品名称列维持明细快照'); assert.deepEqual(unknownRow.images, [], '无图片记录 images 应为空数组'); assert.equal(unknownRow.store_id, null, '未知商品 store_id 应为 null'); assert.equal(unknownRow.store_name, null, '未知商品 store_name 应为 null'); assert.equal(unknownRow.spec, null, '未知商品 spec 应为 null'); }); it('recordList 对齐 workData:已知商品挂 store_id/store_name/spec/商品条码,保留记录全字段', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const reportResult = await reportCheck(check.id, details.rows[0].id, 3, undefined, { stockId: stocks[0].id }); const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails( [ stocks[0].id ], { warehouseId: TEST_WAREHOUSE_ID } ); const stockDetail = stockDetails.find(item => Number(item.id) === Number(stocks[0].id)) || {}; const listed = await listRecords({ id: check.id }); assert.equal(listed.total, 1); const row = listed.rows[0]; assert.equal(Number(row.id), Number(reportResult.record.id)); // 保留记录全字段 for (const key of [ 'check_id', 'warehouse_id', 'detail_id', 'stock_id', 'location_id', 'quantity', 'checker_id', 'checker_name', 'checked_at', 'is_empty', 'remark' ]) { assert.ok(Object.prototype.hasOwnProperty.call(row, key), `应保留全字段 ${key}`); } // 对齐 workData 商品口径 assert.equal(Number(row.store_id), Number(stockDetail.store_id) || 0, '应挂商品货主ID'); assert.ok(row.store_name, '应解析货主名'); assert.equal(row.spec, stockDetail.sku_property || null, '应挂商品规格'); assert.ok(row.item_code); assert.ok(row.barcode, '应挂商品条码(workData 口径)'); assert.deepEqual(row.images, [], '保留 images 作业照片字段'); }); it('report 未传 stock_id 且未传 barcode:库位行报 400,barcode 空串同口径', async () => { const { check, detail } = await createApprovedLocationCheck(); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 1); }, error => error.code === 400 && /必须指定商品/.test(error.message)); await assert.rejects(async () => { await reportCheck(check.id, detail.id, 1, undefined, { barcode: ' ' }); }, error => error.code === 400 && /必须指定商品/.test(error.message)); }); it('已知商品原链路回归:库位行传 stock_id 正常上报,barcode/item_name 保持 NULL', async () => { const { check, detail } = await createApprovedLocationCheck(); const stocks = await fetchStockRows(1); const result = await reportCheck(check.id, detail.id, 6, undefined, { stockId: stocks[0].id }); assert.equal(result.mode, 'created'); assert.equal(Number(result.record.stock_id), Number(stocks[0].id)); assert.equal(result.record.barcode, null, '已知商品未传条码 barcode 应为 NULL'); assert.equal(result.record.item_name, null, '已知商品 item_name 应为 NULL'); assert.equal(result.checked_items, 1); const row = await findCheckRow(check.id); assert.equal(row.checked_items, 1); }); }); // ------------------- 操作日志(wms_operation_log):10 个写操作落库验证 ------------------- describe('操作日志落库(wms_operation_log,business_type=stock_check)', () => { /** * 查询某个盘点任务的全部操作日志(按 id 升序)。 * * @param {number} checkId 盘点任务ID。 * @return {Promise>} 日志行(plain)。 */ async function queryOperationLogs(checkId) { return ctx.model.OperationLog.findAll({ where: { business_type: 'stock_check', business_id: String(checkId) }, order: [[ 'id', 'ASC' ]], raw: true, }); } /** * 查询某个盘点任务指定 operation_code 的日志行。 * * @param {number} checkId 盘点任务ID。 * @param {string} operationCode 操作编码。 * @return {Promise>} 日志行(plain)。 */ async function queryOperationLogsByCode(checkId, operationCode) { const logs = await queryOperationLogs(checkId); return logs.filter(item => item.operation_code === operationCode); } it('create 写入 STOCK_CHECK_CREATE:business_id=任务 id、warehouse_id=100000、message 含单号', async () => { const result = await createCheck(); const logs = await queryOperationLogsByCode(result.id, 'STOCK_CHECK_CREATE'); assert.equal(logs.length, 1, '创建成功后应写入 1 条 STOCK_CHECK_CREATE 日志'); const log = logs[0]; assert.equal(log.business_type, 'stock_check'); assert.equal(log.business_id, String(result.id), 'business_id 应为任务 id'); assert.equal(Number(log.warehouse_id), TEST_WAREHOUSE_ID, 'warehouse_id 应为固定测试仓库'); assert.ok(log.message && log.message.includes(result.check_no), `message 应包含单号: ${log.message}`); }); it('addDetail/detailDelete 分别写入 STOCK_CHECK_ADD_DETAIL 与 STOCK_CHECK_DELETE_DETAIL', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const details = await detailCheck(check.id); const detailId = details.rows[0].id; await deleteDetail(check.id, detailId); const addLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_ADD_DETAIL'); assert.equal(addLogs.length, 1, '添加明细成功后应写入 1 条 STOCK_CHECK_ADD_DETAIL 日志'); assert.ok(addLogs[0].message && addLogs[0].message.includes('添加盘点明细'), `message 应含操作描述: ${addLogs[0].message}`); assert.equal(Number(addLogs[0].warehouse_id), TEST_WAREHOUSE_ID); const deleteLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_DELETE_DETAIL'); assert.equal(deleteLogs.length, 1, '删除明细成功后应写入 1 条 STOCK_CHECK_DELETE_DETAIL 日志'); assert.ok( deleteLogs[0].message && deleteLogs[0].message.includes('删除盘点明细'), `message 应含操作描述: ${deleteLogs[0].message}` ); assert.ok( deleteLogs[0].message && deleteLogs[0].message.includes('删除 1 个,跳过 0 个'), `message 应含批量删除统计: ${deleteLogs[0].message}` ); assert.equal(Number(deleteLogs[0].warehouse_id), TEST_WAREHOUSE_ID); }); it('submit/cancel 分别写入 STOCK_CHECK_SUBMIT 与 STOCK_CHECK_CANCEL', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await cancelCheck(check.id); const submitLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_SUBMIT'); assert.equal(submitLogs.length, 1, '提交审核成功后应写入 1 条 STOCK_CHECK_SUBMIT 日志'); assert.equal(submitLogs[0].business_id, String(check.id)); assert.ok(submitLogs[0].message && submitLogs[0].message.includes('提交审核'), `message 应含操作描述: ${submitLogs[0].message}`); const cancelLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CANCEL'); assert.equal(cancelLogs.length, 1, '取消成功后应写入 1 条 STOCK_CHECK_CANCEL 日志'); assert.equal(cancelLogs[0].business_id, String(check.id)); assert.ok(cancelLogs[0].message && cancelLogs[0].message.includes('取消盘点任务'), `message 应含操作描述: ${cancelLogs[0].message}`); }); it('report/recordDelete 分别写入 STOCK_CHECK_REPORT 与 STOCK_CHECK_DELETE_RECORD', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const reportResult = await reportCheck(check.id, detailId, 7); assert.equal(reportResult.mode, 'created'); const reportLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_REPORT'); assert.equal(reportLogs.length, 1, '上报成功后应写入 1 条 STOCK_CHECK_REPORT 日志'); assert.equal(reportLogs[0].business_id, String(check.id)); assert.equal(Number(reportLogs[0].warehouse_id), TEST_WAREHOUSE_ID); assert.ok(reportLogs[0].message && reportLogs[0].message.includes(`明细 ${detailId}`), `message 应含 detail_id: ${reportLogs[0].message}`); assert.ok(reportLogs[0].message && reportLogs[0].message.includes('实盘 7'), `message 应含实盘数量: ${reportLogs[0].message}`); const records = await queryRecords(check.id, detailId); assert.equal(records.length, 1, '前置:应有 1 条作业记录'); await deleteRecord(check.id, records[0].id); const deleteLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_DELETE_RECORD'); assert.equal(deleteLogs.length, 1, '删除作业记录后应写入 1 条 STOCK_CHECK_DELETE_RECORD 日志'); assert.ok(deleteLogs[0].message && deleteLogs[0].message.includes('批量删除盘点作业记录 1 条'), `message 应含批量删除描述: ${deleteLogs[0].message}`); }); it('finish 写入 STOCK_CHECK_FINISH:message 含差异汇总(盘盈/盘亏)', async () => { const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 0); const finishResult = await finishCheck(check.id); assert.equal(finishResult.status, 'completed'); const logs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_FINISH'); assert.equal(logs.length, 1, '完成后应写入 1 条 STOCK_CHECK_FINISH 日志'); assert.equal(logs[0].business_id, String(check.id)); assert.ok(logs[0].message && logs[0].message.includes('完成盘点'), `message 应含操作描述: ${logs[0].message}`); assert.ok(logs[0].message && logs[0].message.includes('盘盈'), `message 应含盘盈汇总: ${logs[0].message}`); assert.ok(logs[0].message && logs[0].message.includes('盘亏'), `message 应含盘亏汇总: ${logs[0].message}`); }); it('audit approve/reject 写入 STOCK_CHECK_AUDIT:reject message 含驳回原因', async () => { const approveCheck = await createCheck(); const approveStocks = await fetchStockRows(1); await addDetail(approveCheck.id, [ approveStocks[0].id ]); await submitCheck(approveCheck.id); await auditCheck(approveCheck.id, 'approve'); const rejectCheck = await createCheck(); const rejectStocks = await fetchStockRows(1); await addDetail(rejectCheck.id, [ rejectStocks[0].id ]); await submitCheck(rejectCheck.id); const rejectReason = '实盘与账面差异过大-测试驳回'; await auditCheck(rejectCheck.id, 'reject', rejectReason); const approveLogs = await queryOperationLogsByCode(approveCheck.id, 'STOCK_CHECK_AUDIT'); assert.equal(approveLogs.length, 1, '审核通过应写入 1 条 STOCK_CHECK_AUDIT 日志'); assert.ok(approveLogs[0].message && approveLogs[0].message.includes('审核通过'), `approve message 应含动作: ${approveLogs[0].message}`); const rejectLogs = await queryOperationLogsByCode(rejectCheck.id, 'STOCK_CHECK_AUDIT'); assert.equal(rejectLogs.length, 1, '审核驳回应写入 1 条 STOCK_CHECK_AUDIT 日志'); assert.ok(rejectLogs[0].message && rejectLogs[0].message.includes('审核驳回'), `reject message 应含动作: ${rejectLogs[0].message}`); assert.ok(rejectLogs[0].message && rejectLogs[0].message.includes(rejectReason), 'reject 日志 message 应包含驳回原因'); }); it('batchDelete 删除 2 个作废任务仅写 1 条日志:business_id=首个删除 id、message 含删除/跳过数量', async () => { const cancelledA = await createCancelledCheck(); const cancelledB = await createCancelledCheck(); const result = await batchDeleteCheck([ cancelledA.check.id, cancelledB.check.id ]); assert.equal(result.deleted_count, 2); assert.equal(result.skipped_count, 0); const logsA = await queryOperationLogsByCode(cancelledA.check.id, 'STOCK_CHECK_BATCH_DELETE'); assert.equal(logsA.length, 1, '删除 2 个任务应只写 1 条日志,business_id 取首个删除 id'); assert.equal(logsA[0].business_id, String(cancelledA.check.id), 'business_id 应为首个删除任务 id'); assert.equal(Number(logsA[0].warehouse_id), TEST_WAREHOUSE_ID); assert.ok(logsA[0].message && logsA[0].message.includes('删除 2 个'), `message 应含删除数量: ${logsA[0].message}`); assert.ok(logsA[0].message && logsA[0].message.includes('跳过 0 个'), `message 应含跳过数量: ${logsA[0].message}`); const logsB = await queryOperationLogsByCode(cancelledB.check.id, 'STOCK_CHECK_BATCH_DELETE'); assert.equal(logsB.length, 0, '第二个删除 id 不应单独写日志'); // deletedIds 为空(全跳过)时不写日志 const missingId = await findFreeCheckId(); const skipResult = await batchDeleteCheck([ missingId ]); assert.equal(skipResult.deleted_count, 0); assert.equal(skipResult.skipped_count, 1); const skipLogs = await queryOperationLogsByCode(missingId, 'STOCK_CHECK_BATCH_DELETE'); assert.equal(skipLogs.length, 0, 'deletedIds 为空时不应写 STOCK_CHECK_BATCH_DELETE 日志'); }); it('失败路径不写日志:submit 空任务/report 非法状态 400 后无新日志', async () => { const check = await createCheck(); await assert.rejects(async () => { await submitCheck(check.id); }, error => error.code === 400 && /明细/.test(error.message)); const submitLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_SUBMIT'); assert.equal(submitLogs.length, 0, 'submit 失败后不应写入 STOCK_CHECK_SUBMIT 日志'); // created 状态不允许盘点作业:report 状态校验失败后不应写 STOCK_CHECK_REPORT await assert.rejects(async () => { await reportCheck(check.id, 1, 1); }, error => error.code === 400 && /状态/.test(error.message)); const reportLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_REPORT'); assert.equal(reportLogs.length, 0, 'report 失败后不应写入 STOCK_CHECK_REPORT 日志'); // 对照:create 成功日志仍在 const createLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CREATE'); assert.equal(createLogs.length, 1, '对照:STOCK_CHECK_CREATE 成功日志应存在'); }); it('operator 快照:operator_id/operator_name 与上下文一致', async () => { // 真实测试工号(开发库 wms_account_store_employee:id=38,account autotest_acc_mgmt_keep,store_id=100000,status=1) const operatorId = 38; const operatorName = '测试工号保留'; ctx.user = { employees_id: operatorId, employees_name: operatorName }; const check = await createCheck(); delete ctx.user; const logs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CREATE'); assert.equal(logs.length, 1); assert.equal(String(logs[0].operator_id), String(operatorId), 'operator_id 应快照 employees_id'); assert.equal(logs[0].operator_name, operatorName, 'operator_name 应快照 employees_name'); }); }); // ------------------- patternList/patternCreate:盘点定式快速创建 ------------------- describe('盘点定式 patternList/patternCreate(业务层 + 方法层)', () => { /** 静态定式测试阈值:小时数(300 天,隔离开发库真实商品最后流水集中在 250~300 天的口径) */ const STATIC_TEST_HOURS = 7200; /** 构造静态商品的主表创建时间(距今 330 天,超过阈值) */ const STATIC_STOCK_AGE_DAYS = 330; /** 构造数据序号(保证 item_code/批次号等唯一) */ let fabricatedSeq = 0; /** 上一个 static 用例构造的商品 ID(供再次调用排除断言) */ let staticStockAId = null; /** 生成构造数据唯一后缀。 */ function nextFabricatedSuffix() { fabricatedSeq += 1; return `${Date.now()}-${fabricatedSeq}`; } /** 读取测试仓库 wms_store 实例(subject_config 归一化后返回)。 */ async function fetchSubjectConfigInstance() { return ctx.model.Store.findOne({ where: { id: TEST_WAREHOUSE_ID } }); } /** * 临时修改测试仓库 subject_config,fn 执行后恢复原值。 * * @param {Object} patch 待合并的配置覆盖项。 * @param {Function} fn 配置生效期间执行的异步函数。 * @return {Promise<*>} fn 的返回值。 */ async function withSubjectConfig(patch, fn) { const store = await fetchSubjectConfigInstance(); const previous = store.subject_config; await store.update({ subject_config: { ...previous, ...patch } }); try { return await fn(); } finally { await ctx.model.Store.update( { subject_config: previous }, { where: { id: TEST_WAREHOUSE_ID } } ); } } /** * 业务层:按定式创建盘点任务(自动注入固定测试仓库与创建人)。 * * @param {Object} [params={}] 创建参数覆盖项。 * @return {Promise} patternCreate 返回结果。 */ async function patternCreateRaw(params = {}) { return ctx.service.systems.stockCheck.patternCreate({ warehouseId: TEST_WAREHOUSE_ID, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, ...params, }); } /** * 按定式收集盘点对象(业务层直调 stockCheckPatterns.collectById)。 * * @param {string} patternId 定式ID。 * @return {Promise} 收集结果。 */ async function collectPattern(patternId) { return ctx.service.systems.stockCheckPatterns.collectById(patternId, { warehouseId: TEST_WAREHOUSE_ID, }); } /** * 直查任务全部明细行(按 id 升序)。 * * @param {number} checkId 盘点任务ID。 * @return {Promise>} 明细行(plain)。 */ async function queryCheckDetails(checkId) { return ctx.model.StockCheckDetail.findAll({ where: { check_id: Number(checkId) }, order: [[ 'id', 'ASC' ]], raw: true, }); } /** * 构造一个全新商品主表行(raw SQL,固定测试仓库/货主)。 * * @param {Object} [options={}] 构造参数(itemCode/createAt/quantity/shelfLife/thresholdDays)。 * @return {Promise} { id, itemCode }。 */ async function createFabricatedStock(options = {}) { const itemCode = options.itemCode || `PATT-STOCK-${nextFabricatedSuffix()}`; const [ result ] = await ctx.model.query( `INSERT INTO wms_stock_warehouse (item_code, item_name, store_id, stock_unit, item_type, create_at, warehouse_id, is_valid, quantity, is_shelf_life_mgmt, remaining_threshold_days) VALUES (:itemCode, '盘点定式测试商品', :storeId, '个', 'normal', :createAt, :warehouseId, 'Y', :quantity, :shelfLife, :thresholdDays)`, { replacements: { itemCode, storeId: TEST_STORE_ID, createAt: options.createAt || new Date(), warehouseId: TEST_WAREHOUSE_ID, quantity: options.quantity !== undefined ? options.quantity : 0, shelfLife: options.shelfLife || 'N', thresholdDays: options.thresholdDays !== undefined ? options.thresholdDays : 0, }, type: ctx.model.QueryTypes.INSERT, } ); return { id: Number(result), itemCode }; } /** * 构造一条库存行(raw SQL,固定测试仓库/货主/库位)。 * * @param {Object} [options={}] 构造参数(stockId/spaceId/batchNo/quantity/expiryDate/orderNo)。 * @return {Promise} 批次号。 */ async function createFabricatedStorage(options = {}) { const batchNo = options.batchNo || `PATT-BATCH-${nextFabricatedSuffix()}`; await ctx.model.query( `INSERT INTO wms_storage (warehouse_id, store_id, space_id, stock_id, batch_no, inventory_type, quantity, expiry_date, inbound_time, inbound_order_no) VALUES (:warehouseId, :storeId, :spaceId, :stockId, :batchNo, 'ZP', :quantity, :expiryDate, NOW(), :orderNo)`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, storeId: TEST_STORE_ID, spaceId: options.spaceId, stockId: options.stockId, batchNo, quantity: options.quantity !== undefined ? options.quantity : 5, expiryDate: options.expiryDate || null, orderNo: options.orderNo || `PATT-IN-${nextFabricatedSuffix()}`, }, type: ctx.model.QueryTypes.INSERT, } ); return batchNo; } /** * 构造错发售后工单与订单明细分表行(raw SQL,固定测试仓库)。 * * @param {number} stockId 关联商品库存ID。 * @return {Promise} { orderId, afterSaleNo }。 */ async function createFabricatedMisShipment(stockId) { const suffix = nextFabricatedSuffix(); const [ maxRows ] = await ctx.model.query( 'SELECT COALESCE(MAX(order_id), 0) AS maxOrderId FROM wms_order_items_100000', { type: ctx.model.QueryTypes.SELECT } ); const orderId = Number(maxRows.maxOrderId) + 1; await ctx.model.query( `INSERT INTO wms_order_items_100000 (order_id, item_code, item_name, stock_id, actual_price, created_at, updated_at) VALUES (:orderId, 'PATT-ITEM', '错发盘点测试商品', :stockId, 0, NOW(), NOW())`, { replacements: { orderId, stockId }, type: ctx.model.QueryTypes.INSERT, } ); const afterSaleNo = `AS${currentDatePart()}T${suffix}`; await ctx.model.query( `INSERT INTO wms_after_sale (warehouse_id, after_sale_no, type, sub_type, status, title, creator_id, order_id) VALUES (:warehouseId, :afterSaleNo, 'order', 'mis_shipment', 'pending', '错发盘点测试工单', :creatorId, :orderId)`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, afterSaleNo, creatorId: TEST_CREATOR_ID, orderId, }, type: ctx.model.QueryTypes.INSERT, } ); return { orderId, afterSaleNo }; } it('patternList:返回 5 个定式,id/name/description/type 字段完整且 type 取值合法', async () => { const result = await ctx.service.systems.stockCheck.patternList(); assert.equal(result.total, 5); assert.equal(result.patterns.length, 5); assert.deepEqual( result.patterns.map(item => item.id), [ 'empty_location', 'mis_shipment', 'expiring', 'static', 'warning' ], '定式顺序应与注册顺序一致' ); for (const pattern of result.patterns) { assert.deepEqual( Object.keys(pattern).sort(), [ 'description', 'id', 'name', 'type' ], '每条定式应仅包含 id/name/description/type 字段' ); assert.ok(pattern.id, 'id 不应为空'); assert.ok(pattern.name, 'name 不应为空'); assert.ok(pattern.description, 'description 不应为空'); assert.ok([ 'location', 'goods' ].includes(pattern.type), `type 取值非法: ${pattern.type}`); } const locationPatterns = result.patterns.filter(item => item.type === 'location'); assert.deepEqual(locationPatterns.map(item => item.id), [ 'empty_location' ]); for (const goodsPattern of [ 'mis_shipment', 'expiring', 'static', 'warning' ]) { assert.equal( result.patterns.find(item => item.id === goodsPattern).type, 'goods', `${goodsPattern} 应为 goods 型定式` ); } }); it('method 层 patternList:success 包装返回 patterns/total', async () => { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; const result = await ctx.service.systemMethods.stock.check.patternList(); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.total, 5); assert.equal(result.data.patterns.length, 5); }); it('patternCreate(warning):submitted/none_checked、type=goods、mode=open、不含 check_date、明细快照、total_items、check_no 与日志 STOCK_CHECK_CREATE(含 pattern_id)', async () => { const title = uniqueTitle('预警定式创建'); const result = await withSubjectConfig( { stock_warning_enabled: true, stock_warning_quantity: 999999999 }, async () => { const collected = await collectPattern('warning'); assert.ok(collected.stock_ids.length > 0, '前置:开启预警后应存在符合条件的商品'); return patternCreateRaw({ patternId: 'warning', title, remark: '定式创建测试', }); } ); assert.equal(result.pattern_id, 'warning'); const check = result.check; assert.match(check.check_no, /^PD\d{14}$/, `应生成盘点单号: ${check.check_no}`); assert.equal(check.status, 'submitted', '定式创建的任务应直接进入待审核'); assert.equal(check.detail_status, 'none_checked'); assert.equal(check.type, 'goods', 'warning 定式应为按商品盘点'); assert.equal(check.mode, 'open', '商品类定式应固定明盘(open)'); assert.equal(Number(check.is_static), 0, '非静态定式创建的任务应为普通盘点(is_static=0)'); assert.equal( Object.prototype.hasOwnProperty.call(check, 'check_date'), false, 'patternCreate 返回不应含 check_date 字段' ); assert.equal(check.start_time, null, '定式创建任务 start_time 应为空'); assert.equal(check.end_time, null, '定式创建任务 end_time 应为空'); assert.equal(check.title, title); assert.equal(check.creator_id, TEST_CREATOR_ID); assert.ok(result.total_items > 0, '应有明细行'); const row = await findCheckRow(check.id); assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID); assert.equal(row.status, 'submitted'); assert.equal(row.total_items, result.total_items); assert.equal( Object.prototype.hasOwnProperty.call(row, 'check_date'), false, '主表行不应含 check_date 字段' ); const details = await queryCheckDetails(check.id); const detailStockIds = new Set(details.map(detail => Number(detail.stock_id))); assert.equal(detailStockIds.size, result.total_items, 'total_items 应按商品计数(多库位商品拆多行仍计 1 项)'); assert.ok(details.length >= result.total_items, '明细行数应不少于商品数(按「商品+库位」拆行)'); for (const detail of details) { assert.equal(detail.scope_type, 'goods'); assert.ok(detail.stock_id, '商品明细应含 stock_id'); assert.ok(detail.item_code, '商品明细应含商品编码快照'); } const logs = await ctx.model.OperationLog.findAll({ where: { business_type: 'stock_check', business_id: String(check.id), operation_code: 'STOCK_CHECK_CREATE', }, raw: true, }); assert.equal(logs.length, 1, '应写入 1 条 STOCK_CHECK_CREATE 日志'); assert.ok(logs[0].message && logs[0].message.includes('warning'), `日志应含 pattern_id: ${logs[0].message}`); assert.ok(logs[0].message && logs[0].message.includes(check.check_no), '日志应含盘点单号'); assert.equal(Number(logs[0].warehouse_id), TEST_WAREHOUSE_ID); }); it('patternCreate 参数校验:定式不存在/缺仓库 → 400 且未创建任务(mode/check_date 已移除入参)', async () => { const beforeRow = await ctx.model.StockCheck.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); const beforeMax = beforeRow ? Number(beforeRow.id) : 0; await assert.rejects(async () => { await patternCreateRaw({ patternId: 'not_exists' }); }, error => error.code === 400 && /盘点定式不存在/.test(error.message)); await assert.rejects(async () => { await ctx.service.systems.stockCheck.patternCreate({ warehouseId: 0, patternId: 'warning', }); }, error => error.code === 400 && /仓库/.test(error.message)); const afterRow = await ctx.model.StockCheck.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); assert.equal(afterRow ? Number(afterRow.id) : 0, beforeMax, '参数非法时不应创建任务'); }); it('empty_location 收集口径:直查 wms_storage 对比,账面为空库位入库、有库存库位不入', async () => { const { Op } = ctx.app.Sequelize; const emptySpace = await ctx.model.LocationSpace.findOne({ where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, attributes: [ 'id' ], raw: true, }); const emptyStorageCnt = await ctx.model.Storage.count({ where: { space_id: Number(emptySpace.id), quantity: { [Op.gt]: 0 } }, }); const stockStorageCnt = await ctx.model.Storage.count({ where: { space_id: TEST_LOCATION_ID, quantity: { [Op.gt]: 0 } }, }); assert.equal(emptyStorageCnt, 0, `前置:${TEST_EMPTY_LOCATION_CODE} 应无 quantity>0 库存`); assert.ok(stockStorageCnt > 0, `前置:${TEST_LOCATION_CODE} 应有 quantity>0 库存`); const collected = await collectPattern('empty_location'); const codes = collected.locations.map(item => item.location_code); assert.ok(codes.includes(TEST_EMPTY_LOCATION_CODE), '账面为空库位应被收集'); assert.ok(!codes.includes(TEST_LOCATION_CODE), '有库存库位不应被收集'); for (const location of collected.locations) { assert.ok(Number(location.location_id) > 0, 'location_id 应为正整数'); assert.ok(location.location_code, 'location_code 不应为空'); } }); it('empty_location patternCreate:明细只含空库位(location 行)、total_items=收集数、mode=blind、不含 check_date', async () => { const collected = await collectPattern('empty_location'); assert.ok(collected.locations.length > 0, '前置:应存在账面为空库位'); const result = await patternCreateRaw({ patternId: 'empty_location', title: uniqueTitle('空库位定式创建'), }); assert.equal(result.pattern_id, 'empty_location'); assert.equal(result.check.type, 'location'); assert.equal(result.check.status, 'submitted'); assert.equal(result.check.mode, 'blind', '库位类定式应固定盲盘(blind)'); assert.equal( Object.prototype.hasOwnProperty.call(result.check, 'check_date'), false, 'patternCreate 返回不应含 check_date 字段' ); assert.equal(result.check.start_time, null, '定式创建任务 start_time 应为空'); assert.equal(result.check.end_time, null, '定式创建任务 end_time 应为空'); assert.equal(result.total_items, collected.locations.length); const details = await queryCheckDetails(result.check.id); assert.equal(details.length, result.total_items); const collectedCodes = new Set(collected.locations.map(item => item.location_code)); for (const detail of details) { assert.equal(detail.scope_type, 'location', '库位明细行 scope_type 应为 location'); assert.equal(detail.stock_id, null, '库位明细行不应含 stock_id'); assert.ok(Number(detail.location_id) > 0, '库位明细行应含 location_id'); assert.ok(collectedCodes.has(detail.location_code), `明细库位应属于收集结果: ${detail.location_code}`); } assert.ok( details.some(item => item.location_code === TEST_EMPTY_LOCATION_CODE), '明细应含账面为空库位' ); assert.ok( !details.some(item => item.location_code === TEST_LOCATION_CODE), '明细不应含有库存库位' ); }); it('warning 定式:开启配置后低于阈值商品入明细;关闭配置 → 400 未开启库存预警', async () => { let lowStockId = 0; await withSubjectConfig( { stock_warning_enabled: true, stock_warning_quantity: 2 }, async () => { const lowStock = await createFabricatedStock({ quantity: 1 }); lowStockId = lowStock.id; // 商品必须有库存库位才能入明细(商品任务按库位盘点拆行) await createFabricatedStorage({ stockId: lowStock.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); const collected = await collectPattern('warning'); assert.ok(collected.stock_ids.includes(lowStock.id), '低于阈值商品应被收集'); const result = await patternCreateRaw({ patternId: 'warning', title: uniqueTitle('预警阈值创建'), }); const details = await queryCheckDetails(result.check.id); assert.ok( details.some(item => Number(item.stock_id) === lowStock.id), '低于阈值商品应写入明细' ); } ); assert.ok(lowStockId > 0, '前置:应已构造低于阈值商品'); await assert.rejects(async () => { await patternCreateRaw({ patternId: 'warning' }); }, error => error.code === 400 && /未开启库存预警/.test(error.message)); }); it('static 定式:超时商品入明细,创建后写入 wms_stock_static_check_task', async () => { const stockA = await createFabricatedStock({ itemCode: `PATT-STATIC-A-${nextFabricatedSuffix()}`, createAt: new Date(Date.now() - STATIC_STOCK_AGE_DAYS * 24 * 3600 * 1000), }); staticStockAId = stockA.id; await createFabricatedStorage({ stockId: stockA.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); const result = await withSubjectConfig( { stock_static_hours: STATIC_TEST_HOURS }, async () => { const collected = await collectPattern('static'); assert.ok(collected.stock_ids.includes(stockA.id), '构造的超时商品应被收集'); return patternCreateRaw({ patternId: 'static', title: uniqueTitle('静态定式创建'), }); } ); assert.equal(result.pattern_id, 'static'); assert.equal(result.check.type, 'goods'); assert.equal(result.check.mode, 'open', '商品类定式应固定明盘(open)'); assert.equal(Number(result.check.is_static), 1, '静态定式创建的任务应标记为静态盘点'); const staticTaskRow = await findCheckRow(result.check.id); assert.equal(Number(staticTaskRow.is_static), 1, '主表应落库 is_static=1'); const details = await queryCheckDetails(result.check.id); assert.ok(details.some(item => Number(item.stock_id) === stockA.id), '超时商品应写入明细'); const taskRows = await ctx.model.StockStaticCheckTask.findAll({ where: { stock_id: stockA.id }, raw: true, }); assert.ok(taskRows.length >= 1, '创建成功后应写入静态盘点任务关联记录'); }); it('static 再次调用:已盘商品被排除,明细不再包含', async () => { assert.ok(staticStockAId > 0, '前置:上一个用例应已构造静态商品 A'); const stockB = await createFabricatedStock({ itemCode: `PATT-STATIC-B-${nextFabricatedSuffix()}`, createAt: new Date(Date.now() - STATIC_STOCK_AGE_DAYS * 24 * 3600 * 1000), }); await createFabricatedStorage({ stockId: stockB.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); const result = await withSubjectConfig( { stock_static_hours: STATIC_TEST_HOURS }, async () => { const collected = await collectPattern('static'); assert.ok(collected.stock_ids.includes(stockB.id), '新构造超时商品应被收集'); assert.ok( !collected.stock_ids.includes(staticStockAId), '已写入静态任务记录的商品应被排除' ); return patternCreateRaw({ patternId: 'static', title: uniqueTitle('静态定式再次创建'), }); } ); const details = await queryCheckDetails(result.check.id); assert.ok(details.some(item => Number(item.stock_id) === stockB.id), '再次调用应只含新超时商品'); assert.ok( !details.some(item => Number(item.stock_id) === staticStockAId), '已盘商品不应再出现在明细中' ); }); it('expiring 定式:构造保质期管理商品与已过期库存 → 入明细', async () => { const expiryStock = await createFabricatedStock({ itemCode: `PATT-EXP-${nextFabricatedSuffix()}`, shelfLife: 'Y', thresholdDays: null, }); await createFabricatedStorage({ stockId: expiryStock.id, spaceId: TEST_LOCATION_ID, quantity: 3, expiryDate: new Date(Date.now() - 24 * 3600 * 1000), }); const collected = await collectPattern('expiring'); assert.ok(collected.stock_ids.includes(expiryStock.id), '临期商品应被收集'); const result = await patternCreateRaw({ patternId: 'expiring', title: uniqueTitle('临期定式创建'), }); assert.equal(result.check.type, 'goods'); const details = await queryCheckDetails(result.check.id); assert.ok( details.some(item => Number(item.stock_id) === expiryStock.id), '临期商品应写入明细' ); }); it('mis_shipment 定式:构造错发工单与订单明细商品 → 入明细', async () => { const stocks = await fetchStockRows(1); assert.equal(stocks.length, 1); const stockId = Number(stocks[0].id); await createFabricatedMisShipment(stockId); const collected = await collectPattern('mis_shipment'); assert.ok(collected.stock_ids.includes(stockId), '错发工单关联商品应被收集'); const result = await patternCreateRaw({ patternId: 'mis_shipment', title: uniqueTitle('错发定式创建'), }); assert.equal(result.check.type, 'goods'); const details = await queryCheckDetails(result.check.id); assert.ok( details.some(item => Number(item.stock_id) === stockId), '错发商品应写入明细' ); }); it('无符合条件的商品 → 400「没有符合条件的商品」且未创建任务', async () => { const beforeRow = await ctx.model.StockCheck.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); const beforeMax = beforeRow ? Number(beforeRow.id) : 0; await withSubjectConfig( { stock_warning_enabled: true, stock_warning_quantity: 0 }, async () => { await assert.rejects(async () => { await patternCreateRaw({ patternId: 'warning' }); }, error => error.code === 400 && /没有符合条件的商品/.test(error.message)); } ); const afterRow = await ctx.model.StockCheck.findOne({ attributes: [ 'id' ], order: [[ 'id', 'DESC' ]], raw: true, }); assert.equal(afterRow ? Number(afterRow.id) : 0, beforeMax, '无对象时不应创建任务'); }); it('method 层 patternCreate:驼峰 patternId 兼容、仓库注入、定式不存在/缺仓库 400 包装', async () => { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; const result = await ctx.service.systemMethods.stock.check.patternCreate({ patternId: 'mis_shipment', title: uniqueTitle('方法层驼峰创建'), }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.pattern_id, 'mis_shipment'); assert.equal(result.data.check.status, 'submitted'); assert.ok(result.data.total_items >= 1, '错发定式应收集到商品'); const row = await findCheckRow(result.data.check.id); assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); const notFound = await ctx.service.systemMethods.stock.check.patternCreate({ pattern_id: 'not_exists', }); assert.equal(notFound.flag, 'failure'); assert.equal(notFound.code, 400); assert.match(notFound.message, /盘点定式不存在/); ctx.user = null; const noWarehouse = await ctx.service.systemMethods.stock.check.patternCreate({ pattern_id: 'mis_shipment', }); assert.equal(noWarehouse.flag, 'failure'); assert.equal(noWarehouse.code, 400); assert.match(noWarehouse.message, /仓库/); }); }); // ------------------- systemMethods.stock.check:方法包装层 ------------------- describe('systemMethods.stock.check 方法包装层', () => { /** * 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 */ function mockCurrentUser() { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; } it('create:注入仓库上下文并统一 success 包装', async () => { mockCurrentUser(); const result = await ctx.service.systemMethods.stock.check.create({ title: uniqueTitle('方法层创建'), type: 'location', mode: 'open', }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.match(result.data.check_no, /^PD\d{14}$/); assert.equal(result.data.status, 'created'); assert.equal(result.data.creator_id, TEST_CREATOR_ID, '创建人应由上下文注入'); assert.equal(result.data.creator_name, TEST_CREATOR_NAME); const row = await findCheckRow(result.data.id); assert.equal(row.warehouse_id, TEST_WAREHOUSE_ID, '仓库 ID 应由 ctx.user.store_id 注入'); assert.equal( Object.prototype.hasOwnProperty.call(result.data, 'check_date'), false, '方法层 create 返回不应含 check_date 字段' ); assert.equal( Object.prototype.hasOwnProperty.call(row, 'check_date'), false, '主表行不应含 check_date 字段' ); assert.equal(row.start_time, null, '创建时 start_time 应为空'); assert.equal(row.end_time, null, '创建时 end_time 应为空'); }); it('list:where.status 数组筛选与统一 success 包装', async () => { mockCurrentUser(); const result = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 10 }, where: { status: [ 'created', 'submitted' ] }, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.ok(Array.isArray(result.data.rows)); assert.ok(Number(result.data.total) >= result.data.rows.length, 'total 应不小于当前页行数'); for (const row of result.data.rows) { assert.ok([ 'created', 'submitted' ].includes(row.status)); } }); it('list:where.type 标准结构(operator/eq/value)只返回 location 任务', async () => { mockCurrentUser(); const locationCheck = await createCheck({ type: 'location', title: uniqueTitle('方法层type标准结构') }); const goodsCheck = await createCheck({ title: uniqueTitle('方法层type标准结构') }); const result = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 200 }, where: { type: { operator: 'eq', value: 'location' } }, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); const ids = result.data.rows.map(row => row.id); assert.ok(ids.includes(locationCheck.id), '标准结构 eq=location 应命中 location 任务'); assert.ok(!ids.includes(goodsCheck.id), '标准结构 eq=location 不应命中 goods 任务'); for (const row of result.data.rows) { assert.equal(row.type, 'location', '标准结构筛选结果只能包含 location 任务'); } }); it('list:where.type 数组 in 与 where.mode 组合筛选', async () => { mockCurrentUser(); const goodsOpen = await createCheck({ type: 'goods', mode: 'open', title: uniqueTitle('方法层in-mode组合') }); const locationBlind = await createCheck({ type: 'location', title: uniqueTitle('方法层in-mode组合') }); const typeInResult = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 200 }, where: { type: [ 'location', 'goods' ] }, }); assert.equal(typeInResult.flag, 'success'); const typeInIds = typeInResult.data.rows.map(row => row.id); assert.ok(typeInIds.includes(goodsOpen.id), 'goods 任务应命中 type in 数组'); assert.ok(typeInIds.includes(locationBlind.id), 'location 任务应命中 type in 数组'); for (const row of typeInResult.data.rows) { assert.ok([ 'location', 'goods' ].includes(row.type), `非法类型出现在 in 筛选结果: ${row.type}`); } const modeResult = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 200 }, where: { mode: 'blind' }, }); assert.equal(modeResult.flag, 'success'); const modeIds = modeResult.data.rows.map(row => row.id); assert.ok(modeIds.includes(locationBlind.id), '盲盘任务应命中 mode=blind'); assert.ok(!modeIds.includes(goodsOpen.id), '明盘任务不应命中 mode=blind'); }); it('list:where.store_id 货主筛选与 where.created_at between(标准结构)', async () => { mockCurrentUser(); const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: uniqueTitle('方法层store_id') }); const storeResult = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 200 }, where: { store_id: TEST_STORE_ID }, }); assert.equal(storeResult.flag, 'success'); const storeIds = storeResult.data.rows.map(row => row.id); assert.ok(storeIds.includes(storeCheck.id), '固定测试货主的任务应命中 where.store_id'); for (const row of storeResult.data.rows) { assert.equal(Number(row.store_id), TEST_STORE_ID, 'where.store_id 筛选结果只能包含固定测试货主'); } const inRangeCheck = await createCheck({ title: uniqueTitle('方法层created_at区间') }); const outRangeCheck = await createCheck({ title: uniqueTitle('方法层created_at区间') }); await setCheckCreatedAt(inRangeCheck.id, new Date('2019-06-15T00:00:00Z')); const betweenResult = await ctx.service.systemMethods.stock.check.list({ pagination: { page: 1, pageSize: 200 }, where: { created_at: { operator: 'between', value: { from: '2019-01-01', to: '2019-12-31' }, }, }, }); assert.equal(betweenResult.flag, 'success'); const betweenIds = betweenResult.data.rows.map(row => row.id); assert.ok(betweenIds.includes(inRangeCheck.id), '标准结构 between 应命中 2019 年创建的任务'); assert.ok(!betweenIds.includes(outRangeCheck.id), '标准结构 between 不应命中 2019 年外创建的任务'); }); it('addDetail:业务错误码 400 经方法层包装为 failure', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); const result = await ctx.service.systemMethods.stock.check.addDetail({ id: check.id, stock_ids: [ stocks[0].id ], }); assert.equal(result.flag, 'failure'); assert.equal(result.code, 400, 'submitted 状态添加明细应包装为 400'); assert.ok(result.message, '应返回错误文案'); }); it('addDetail:location_ids(snake)与 locationIds(驼峰)均可用并成功包装', async () => { mockCurrentUser(); const snakeCheck = await createCheck({ type: 'location' }); const snakeResult = await ctx.service.systemMethods.stock.check.addDetail({ id: snakeCheck.id, location_ids: [ TEST_LOCATION_ID ], }); assert.equal(snakeResult.flag, 'success'); assert.equal(snakeResult.code, 1); assert.equal(snakeResult.data.added, 1); assert.equal(snakeResult.data.skipped, 0); assert.deepEqual(snakeResult.data.invalid_location_ids, []); assert.equal(snakeResult.data.total_items, 1); const camelCheck = await createCheck({ type: 'location' }); const camelResult = await ctx.service.systemMethods.stock.check.addDetail({ id: camelCheck.id, locationIds: [ TEST_LOCATION_ID ], }); assert.equal(camelResult.flag, 'success'); assert.equal(camelResult.code, 1); assert.equal(camelResult.data.added, 1); assert.deepEqual(camelResult.data.invalid_location_ids, []); for (const checkId of [ snakeCheck.id, camelCheck.id ]) { const row = await ctx.model.StockCheckDetail.findOne({ where: { check_id: checkId }, raw: true, }); assert.equal(Number(row.location_id), TEST_LOCATION_ID, '方法层库位行应落库 location_id'); assert.equal(row.location_code, TEST_LOCATION_CODE, '方法层库位行应落库 location_code'); } }); it('addLocationDetail:方法层成功包装(snake/驼峰均可用),商品型任务转调报 400 包装为 failure', async () => { mockCurrentUser(); const snakeCheck = await createCheck({ type: 'location' }); const snakeResult = await ctx.service.systemMethods.stock.check.addLocationDetail({ id: snakeCheck.id, location_ids: [ TEST_LOCATION_ID ], }); assert.equal(snakeResult.flag, 'success'); assert.equal(snakeResult.code, 1); assert.equal(snakeResult.data.added, 1); assert.equal(snakeResult.data.skipped, 0); assert.deepEqual(snakeResult.data.invalid_location_ids, []); assert.equal(snakeResult.data.total_items, 1); const camelCheck = await createCheck({ type: 'location' }); const camelResult = await ctx.service.systemMethods.stock.check.addLocationDetail({ id: camelCheck.id, locationIds: [ TEST_LOCATION_ID ], }); assert.equal(camelResult.flag, 'success'); assert.equal(camelResult.code, 1); assert.equal(camelResult.data.added, 1); assert.deepEqual(camelResult.data.invalid_location_ids, []); // 商品型任务转调 addDetail 报 400,经方法层包装为 failure const goodsCheck = await createCheck(); const failure = await ctx.service.systemMethods.stock.check.addLocationDetail({ id: goodsCheck.id, location_ids: [ TEST_LOCATION_ID ], }); assert.equal(failure.flag, 'failure'); assert.equal(failure.code, 400); assert.match(failure.message, /按商品盘点,不能添加库位明细/); }); it('detail:success 包装只返回任务本身信息({ check }),不含明细 rows/total', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); const result = await ctx.service.systemMethods.stock.check.detail({ id: check.id, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.deepEqual(Object.keys(result.data).sort(), [ 'check' ], '方法层 detail 只返回 check'); assert.equal(result.data.rows, undefined, '方法层 detail 不应返回明细 rows'); assert.equal(result.data.total, undefined, '方法层 detail 不应返回明细 total'); assert.equal(Number(result.data.check.id), Number(check.id)); assert.equal(result.data.check.check_no, check.check_no); assert.equal(result.data.check.total_items, 1, 'check.total_items 应为明细行数'); }); it('detail:任务ID 非法 / 任务不存在经方法层包装为 failure 400', async () => { mockCurrentUser(); const invalid = await ctx.service.systemMethods.stock.check.detail({ id: 0 }); assert.equal(invalid.flag, 'failure'); assert.equal(invalid.code, 400); assert.match(invalid.message, /盘点任务ID不能为空/); const missing = await ctx.service.systemMethods.stock.check.detail({ id: await findFreeCheckId() }); assert.equal(missing.flag, 'failure'); assert.equal(missing.code, 400); assert.match(missing.message, /盘点任务不存在/); }); it('result:仓库上下文注入、success 包装返回盘点结果聚合', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const snapshot = Number(details.rows[0].system_quantity); await reportCheck(check.id, detailId, snapshot + 3, TEST_LOCATION_CODE); const result = await ctx.service.systemMethods.stock.check.result({ id: check.id, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.total, 1); assert.equal(result.data.rows.length, 1); const row = result.data.rows[0]; assert.equal(Number(row.check_id), check.id, '范围行应关联盘点任务'); assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); assert.equal(row.checked_quantity, snapshot + 3, '已盘数量=各库位记录合计'); assert.equal(row.diff_quantity, 3); assert.equal(row.is_diff, 1); assert.equal(row.status, 'checked'); assert.equal(row.records.length, 1); assert.deepEqual(row.location_codes, [ TEST_LOCATION_CODE ]); const checkedLocation = row.locations.find(item => item.location_code === TEST_LOCATION_CODE); assert.ok(checkedLocation, '应含已盘库位'); assert.equal(Number(checkedLocation.location_id), TEST_LOCATION_ID, '命中库位应回填 location_id'); assert.equal(Number(checkedLocation.quantity), snapshot + 3, '已盘库位实盘应为上报值'); }); it('result:任务不存在包装为 failure 400', async () => { mockCurrentUser(); const result = await ctx.service.systemMethods.stock.check.result({ id: 999999999, }); assert.equal(result.flag, 'failure'); assert.equal(result.code, 400); assert.ok(result.message, '应返回错误文案'); }); it('report:注入仓库/盘点人上下文,success 包装返回作业记录', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await ctx.service.systemMethods.stock.check.report({ id: check.id, detail_id: details.rows[0].id, quantity: 6, location: TEST_LOCATION_CODE, space_id: TEST_LOCATION_ID, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(Number(result.data.record.warehouse_id), TEST_WAREHOUSE_ID, '仓库 ID 应由 ctx.user.store_id 注入'); assert.equal(Number(result.data.record.checker_id), TEST_CREATOR_ID, '盘点人 ID 应由上下文注入'); assert.equal(result.data.record.checker_name, TEST_CREATOR_NAME); assert.equal(Number(result.data.record.quantity), 6); assert.equal(Number(result.data.record.location_id), TEST_LOCATION_ID, '库位以 space_id 为准'); assert.equal(result.data.detail_status, 'all_checked'); }); it('report:方法层未携带 space_id 包装为 failure 400', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await ctx.service.systemMethods.stock.check.report({ id: check.id, detail_id: details.rows[0].id, quantity: 6, location: TEST_LOCATION_CODE, }); assert.equal(result.flag, 'failure'); assert.equal(result.code, 400); assert.ok(result.message.includes('缺少库位ID'), '缺少库位ID应返回明确文案'); }); it('report:方法层透传 space_id/locationId 别名,按库位ID落库', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const snake = await ctx.service.systemMethods.stock.check.report({ id: check.id, detail_id: details.rows[0].id, quantity: 2, location: TEST_LOCATION_CODE, space_id: TEST_LOCATION_ID, }); assert.equal(snake.flag, 'success'); assert.equal(Number(snake.data.record.location_id), TEST_LOCATION_ID, 'space_id 别名应透传为 locationId'); const camel = await ctx.service.systemMethods.stock.check.report({ id: check.id, detail_id: details.rows[0].id, quantity: 3, location: TEST_LOCATION_CODE, locationId: TEST_LOCATION_ID, }); assert.equal(camel.flag, 'success'); assert.equal(Number(camel.data.record.location_id), TEST_LOCATION_ID, 'locationId 驼峰应透传'); const tooLarge = await ctx.service.systemMethods.stock.check.report({ id: check.id, detail_id: details.rows[0].id, quantity: 6955416422066, location: TEST_LOCATION_CODE, }); assert.equal(tooLarge.flag, 'failure'); assert.equal(tooLarge.code, 400, '超限数量应返回业务 400 而非 500'); }); it('markEmpty:方法层 success 包装(库位任务)+ 非库位任务 failure 400', async () => { mockCurrentUser(); const check = await createCheck({ type: 'location' }); await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const result = await ctx.service.systemMethods.stock.check.markEmpty({ id: check.id, detail_id: details.rows[0].id, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.record.is_empty, true); assert.equal(result.data.detail_status, 'all_checked'); const goodsCheck = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(goodsCheck.id, [ stocks[0].id ]); await submitCheck(goodsCheck.id); await auditCheck(goodsCheck.id, 'approve'); const goodsDetails = await detailCheck(goodsCheck.id); const failure = await ctx.service.systemMethods.stock.check.markEmpty({ id: goodsCheck.id, detail_id: goodsDetails.rows[0].id, }); assert.equal(failure.flag, 'failure'); assert.equal(failure.code, 400); assert.match(failure.message, /仅库位盘点任务支持空库位标记/); }); it('recordList:方法层 success 包装,按任务查询记录并回填商品信息', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(2); await addDetail(check.id, stocks.map(stock => stock.id)); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); await reportCheck(check.id, details.rows[1].id, 4); const result = await ctx.service.systemMethods.stock.check.recordList({ id: check.id, pagination: { page: 1, pageSize: 10 }, }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.total, 2); assert.equal(result.data.rows.length, 2); for (const row of result.data.rows) { assert.equal(Number(row.check_id), check.id, '记录应限定在指定任务'); assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); assert.ok(row.item_code, '记录应回填商品编码'); } }); it('recordDelete:方法层批量兼容 record_ids/recordIds/record_id 三种写法,未命中计入 skipped、删除后汇总回退', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(1); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const details = await detailCheck(check.id); const detailId = details.rows[0].id; const first = await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE); const second = await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2); // record_ids 下划线数组写法(批量入口),混入不存在的 ID 计入 skipped const snakeResult = await ctx.service.systemMethods.stock.check.recordDelete({ id: check.id, record_ids: [ first.record.id, 999999999 ], }); assert.equal(snakeResult.flag, 'success', `record_ids 批量删除应成功: ${snakeResult.message}`); assert.equal(snakeResult.code, 1); assert.equal(snakeResult.data.deleted_count, 1); assert.deepEqual(snakeResult.data.deleted_ids.map(Number), [ Number(first.record.id) ]); assert.deepEqual(snakeResult.data.skipped_ids, [ 999999999 ], '未命中记录应计入 skipped_ids'); assert.equal(snakeResult.data.checked_items, 1, '删除一条后仍有一条记录'); // recordId 驼峰单值写法(单值自动转数组) const camelResult = await ctx.service.systemMethods.stock.check.recordDelete({ id: check.id, recordId: second.record.id, }); assert.equal(camelResult.flag, 'success', `recordId 单值删除应成功: ${camelResult.message}`); assert.equal(camelResult.data.deleted_count, 1); assert.deepEqual(camelResult.data.deleted_ids.map(Number), [ Number(second.record.id) ]); assert.equal(camelResult.data.checked_items, 0, '全部删除后已盘回退为 0'); assert.equal(camelResult.data.detail_status, 'none_checked'); }); it('detailDelete:detail_ids/detailIds/detail_id 三种写法兼容、success 包装、未命中计入 skipped、状态限制包装为 failure', async () => { mockCurrentUser(); const check = await createCheck(); const stocks = await fetchStockRows(3); await addDetail(check.id, stocks.map(stock => stock.id)); const details = await detailCheck(check.id); assert.equal(details.total, 3, '前置:任务应有 3 条明细'); // detail_ids 下划线数组写法(批量入口) const snakeResult = await ctx.service.systemMethods.stock.check.detailDelete({ id: check.id, detail_ids: [ details.rows[0].id ], }); assert.equal(snakeResult.flag, 'success'); assert.equal(snakeResult.code, 1); assert.equal(snakeResult.data.deleted_count, 1); assert.deepEqual(snakeResult.data.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); assert.deepEqual(snakeResult.data.skipped_ids, []); assert.equal(snakeResult.data.total_items, 2); // detailIds 驼峰写法(兼容别名,单值自动转数组) const camelResult = await ctx.service.systemMethods.stock.check.detailDelete({ id: check.id, detailIds: details.rows[1].id, }); assert.equal(camelResult.flag, 'success'); assert.equal(camelResult.code, 1); assert.equal(camelResult.data.deleted_count, 1); assert.deepEqual(camelResult.data.deleted_ids.map(Number), [ Number(details.rows[1].id) ]); assert.deepEqual(camelResult.data.skipped_ids, []); assert.equal(camelResult.data.total_items, 1); // detail_id 旧版单值写法(兼容入口,单值自动转数组) const legacyResult = await ctx.service.systemMethods.stock.check.detailDelete({ id: check.id, detail_id: details.rows[2].id, }); assert.equal(legacyResult.flag, 'success'); assert.equal(legacyResult.code, 1); assert.equal(legacyResult.data.deleted_count, 1); assert.deepEqual(legacyResult.data.deleted_ids.map(Number), [ Number(details.rows[2].id) ]); assert.deepEqual(legacyResult.data.skipped_ids, []); assert.equal(legacyResult.data.total_items, 0); // 已删除明细再次删除:未命中 → success + skipped_ids(不再报 400) const repeatedResult = await ctx.service.systemMethods.stock.check.detailDelete({ id: check.id, detail_id: details.rows[0].id, }); assert.equal(repeatedResult.flag, 'success'); assert.equal(repeatedResult.code, 1); assert.equal(repeatedResult.data.deleted_count, 0); assert.deepEqual(repeatedResult.data.deleted_ids, []); assert.deepEqual(repeatedResult.data.skipped_ids.map(Number), [ Number(details.rows[0].id) ]); // 状态不允许 → failure 400 包装 const submittedCheck = await createCheck(); const submittedStocks = await fetchStockRows(1); await addDetail(submittedCheck.id, [ submittedStocks[0].id ]); await submitCheck(submittedCheck.id); const submittedDetails = await detailCheck(submittedCheck.id); const statusFailure = await ctx.service.systemMethods.stock.check.detailDelete({ id: submittedCheck.id, detail_ids: [ submittedDetails.rows[0].id ], }); assert.equal(statusFailure.flag, 'failure'); assert.equal(statusFailure.code, 400); assert.match(statusFailure.message, /不允许删除明细/); }); }); // ------------------- batchDelete:批量删除盘点任务(业务层) ------------------- describe('batchDelete 批量删除盘点任务(业务层)', () => { it('作废任务删除:主表/明细/作业记录全部物理删除(事务级联)', async () => { const { check, stock } = await createCancelledCheck(); const details = await detailCheck(check.id); assert.equal(details.total, 1, '前置:作废任务应有 1 条明细'); // report 仅 approved/checking 状态开放,作废任务无法自然产生作业记录; // 直写两条记录用于验证 batchDelete 级联删除 record 表。 await ctx.model.StockCheckRecord.bulkCreate([ { check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: details.rows[0].id, stock_id: stock.id, location_code: TEST_LOCATION_CODE, quantity: 3, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }, { check_id: check.id, warehouse_id: TEST_WAREHOUSE_ID, detail_id: details.rows[0].id, stock_id: stock.id, location_code: '', quantity: 5, checker_id: TEST_CREATOR_ID, checker_name: TEST_CREATOR_NAME, checked_at: new Date(), }, ]); assert.equal( await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 2, '前置:应有 2 条作业记录' ); const result = await batchDeleteCheck([ check.id ]); assert.equal(result.total, 1); assert.equal(result.deleted_count, 1); assert.equal(result.skipped_count, 0); assert.deepEqual(result.deleted_ids, [ check.id ]); assert.deepEqual(result.skipped_ids, []); // 级联物理删除:主表 / 明细 / 作业记录全部清空 assert.equal(await findCheckRow(check.id), null, '主表行应物理删除'); assert.equal(await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), 0, '明细应物理删除'); assert.equal(await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 0, '作业记录应物理删除'); }); it('非作废状态任务全部跳过:created/submitted/approved/completed 数据保持', async () => { const created = await createCheck(); const submitted = await createCheck(); const submittedStocks = await fetchStockRows(1); await addDetail(submitted.id, [ submittedStocks[0].id ]); await submitCheck(submitted.id); const approved = await createCheck(); const approvedStocks = await fetchStockRows(1); await addDetail(approved.id, [ approvedStocks[0].id ]); await submitCheck(approved.id); await auditCheck(approved.id, 'approve'); const completed = await createCheck(); const completedStocks = await fetchStockRows(1); await addDetail(completed.id, [ completedStocks[0].id ]); await submitCheck(completed.id); await auditCheck(completed.id, 'approve'); const completedDetails = await detailCheck(completed.id); await reportCheck(completed.id, completedDetails.rows[0].id, 1); await finishCheck(completed.id); const ids = [ created.id, submitted.id, approved.id, completed.id ]; const result = await batchDeleteCheck(ids); assert.equal(result.total, 4); assert.equal(result.deleted_count, 0); assert.equal(result.skipped_count, 4); assert.deepEqual(result.deleted_ids, []); assert.deepEqual(result.skipped_ids, ids, 'skipped_ids 应保持入参顺序'); // 数据保持:主表仍在且状态不变,明细仍在 assert.equal((await findCheckRow(created.id)).status, 'created'); assert.equal((await findCheckRow(submitted.id)).status, 'submitted'); assert.equal((await findCheckRow(approved.id)).status, 'approved'); assert.equal((await findCheckRow(completed.id)).status, 'completed'); for (const checkId of [ submitted.id, approved.id, completed.id ]) { assert.equal( await ctx.model.StockCheckDetail.count({ where: { check_id: checkId } }), 1, `任务 ${checkId} 明细应保持` ); } }); it('混合批量:仅删除作废任务,其余跳过,计数与顺序正确', async () => { const cancelledA = await createCancelledCheck(); const kept = await createCheck(); const cancelledB = await createCancelledCheck(); const missingId = await findFreeCheckId(); const ids = [ cancelledA.check.id, kept.id, missingId, cancelledB.check.id ]; const result = await batchDeleteCheck(ids); assert.equal(result.total, 4); assert.equal(result.deleted_count, 2); assert.equal(result.skipped_count, 2); assert.deepEqual(result.deleted_ids, [ cancelledA.check.id, cancelledB.check.id ], 'deleted_ids 保持入参顺序'); assert.deepEqual(result.skipped_ids, [ kept.id, missingId ], 'skipped_ids 保持入参顺序'); assert.equal(await findCheckRow(cancelledA.check.id), null, '作废任务 A 应删除'); assert.equal(await findCheckRow(cancelledB.check.id), null, '作废任务 B 应删除'); assert.equal((await findCheckRow(kept.id)).status, 'created', '非作废任务应保持'); }); it('不存在的 ID 计入 skipped_ids', async () => { const missingId = await findFreeCheckId(); const result = await batchDeleteCheck([ missingId ]); assert.equal(result.total, 1); assert.equal(result.deleted_count, 0); assert.equal(result.skipped_count, 1); assert.deepEqual(result.skipped_ids, [ missingId ]); assert.deepEqual(result.deleted_ids, []); }); it('ids 空/非法 → 400', async () => { await assert.rejects(async () => { await batchDeleteCheck([]); }, error => error.code === 400 && /ids/.test(error.message)); await assert.rejects(async () => { await batchDeleteRaw({ warehouseId: TEST_WAREHOUSE_ID, ids: undefined }); }, error => error.code === 400 && /ids/.test(error.message)); await assert.rejects(async () => { await batchDeleteCheck([ 0, -1, 'abc' ]); }, error => error.code === 400 && /ids/.test(error.message)); await assert.rejects(async () => { await batchDeleteRaw({ warehouseId: 0, ids: [ 1 ] }); }, error => error.code === 400 && /仓库/.test(error.message)); }); it('超过 200 个上限 → 400;200 个边界正常返回', async () => { const baseId = await findFreeCheckId(); const overLimitIds = Array.from({ length: 201 }, (_, index) => baseId + index); await assert.rejects(async () => { await batchDeleteCheck(overLimitIds); }, error => error.code === 400 && /200/.test(error.message)); const boundaryIds = Array.from({ length: 200 }, (_, index) => baseId + index + 1000); const result = await batchDeleteCheck(boundaryIds); assert.equal(result.total, 200); assert.equal(result.deleted_count, 0); assert.equal(result.skipped_count, 200); }); it('单值 ids 兼容(传数字而非数组)', async () => { const { check } = await createCancelledCheck(); const result = await batchDeleteCheck(check.id); assert.equal(result.total, 1); assert.equal(result.deleted_count, 1); assert.deepEqual(result.deleted_ids, [ check.id ]); assert.equal(await findCheckRow(check.id), null, '单值 ids 也应正常删除'); }); it('重复 id 去重后只删一次', async () => { const { check } = await createCancelledCheck(); const result = await batchDeleteCheck([ check.id, check.id, check.id ]); assert.equal(result.total, 1); assert.equal(result.deleted_count, 1); assert.equal(result.skipped_count, 0); assert.deepEqual(result.deleted_ids, [ check.id ]); }); }); // ------------------- systemMethods.stock.check.batchDelete:方法包装层 ------------------- describe('systemMethods.stock.check.batchDelete 方法包装层', () => { /** 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 */ function mockCurrentUser() { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; } it('success 包装:作废任务删除成功,仓库由 ctx.user.store_id 注入', async () => { mockCurrentUser(); const { check } = await createCancelledCheck(); const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ check.id ] }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.total, 1); assert.equal(result.data.deleted_count, 1); assert.equal(result.data.skipped_count, 0); assert.deepEqual(result.data.deleted_ids, [ check.id ]); assert.equal(await findCheckRow(check.id), null, '主表行应物理删除(仓库注入正确才可删除)'); }); it('仓库隔离:其他仓库的作废任务计入 skipped_ids 不删除', async () => { mockCurrentUser(); // 其他仓库(100001)作废任务:方法层当前上下文仓库为 100000,应跳过不删 const other = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); await ctx.service.systems.stockCheck.cancel({ warehouseId: OTHER_TEST_WAREHOUSE_ID, id: other.id, }); const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ other.id ] }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.deleted_count, 0); assert.equal(result.data.skipped_count, 1); assert.deepEqual(result.data.skipped_ids, [ other.id ]); assert.equal((await findCheckRow(other.id)).status, 'cancelled', '其他仓库任务应保持'); }); it('ids 空 → failure 400 包装', async () => { mockCurrentUser(); const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [] }); assert.equal(result.flag, 'failure'); assert.equal(result.code, 400); assert.ok(result.message, '应返回错误文案'); }); it('缺少仓库上下文 → failure 400 包装', async () => { ctx.user = null; const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ 1 ] }); assert.equal(result.flag, 'failure'); assert.equal(result.code, 400); assert.match(result.message, /仓库/); }); it('单值 ids 兼容(方法层传数字)', async () => { mockCurrentUser(); const { check } = await createCancelledCheck(); const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ check.id ] }); assert.equal(result.flag, 'success'); assert.equal(result.code, 1); assert.equal(result.data.deleted_count, 1); assert.deepEqual(result.data.deleted_ids, [ check.id ]); }); }); // ------------------- staticLockList:静态盘点锁定商品(公共查询 + 缓存) ------------------- describe('staticLockList 静态盘点锁定商品(公共查询 + 缓存 + 审核刷新快照)', () => { /** 设置当前上下文用户(方法层需仓库上下文)。 */ function mockCurrentUser() { ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME, }; } /** * 读取锁定缓存原始值(用于断言缓存命中/失效)。 * * @return {Promise} 缓存载荷。 */ async function readLockCache() { return ctx.app.getCacheAsync(`stock_check:static_lock:${TEST_WAREHOUSE_ID}`); } /** * 清理锁定缓存,保证用例互不影响。 * * @return {Promise} 无返回值。 */ async function clearLockCache() { await ctx.app.delCacheAsync(`stock_check:static_lock:${TEST_WAREHOUSE_ID}`); } /** * 业务层:查询静态锁定列表。 * * @return {Promise} { warehouse_id, stock_ids, rows, total, cached, updated_at }。 */ async function staticLockList() { return ctx.service.systems.stockCheck.staticLockList({ warehouseId: TEST_WAREHOUSE_ID }); } it('仅统计 is_static=1 且 approved/checking 任务的商品;submitted 与普通任务不计入', async () => { await clearLockCache(); const stocks = await fetchStockRows(2); // 静态任务 A:审核通过(锁定中) const staticCheck = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-审核通过'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(staticCheck.id, [ stocks[0].id ]); await submitCheck(staticCheck.id); await auditCheck(staticCheck.id, 'approve'); // 静态任务 B:待审核(未锁定) const pendingCheck = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-待审核'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(pendingCheck.id, [ stocks[1].id ]); await submitCheck(pendingCheck.id); const lockList = await staticLockList(); const lockedIds = lockList.stock_ids.map(Number); assert.ok(lockedIds.includes(Number(stocks[0].id)), '审核通过的静态任务商品应锁定'); assert.equal( lockedIds.includes(Number(stocks[1].id)), false, '待审核的静态任务商品不应锁定' ); for (const stockId of lockedIds) { assert.ok(Number.isInteger(stockId) && stockId > 0, '锁定集合应为正整数商品ID'); } const targetRow = lockList.rows.find(row => Number(row.stock_id) === Number(stocks[0].id)); assert.ok(targetRow, 'rows 应含锁定商品'); assert.ok(targetRow.check_ids.includes(Number(staticCheck.id)), 'rows 应含来源任务ID'); assert.ok(targetRow.check_nos.length >= 1, 'rows 应含来源单号'); assert.ok(Array.isArray(targetRow.location_codes) && targetRow.location_codes.length >= 1, 'rows 应含盘点库位编码'); // 普通(非静态)任务即使审核通过也不锁定 const normalCheck = await createCheck({ title: uniqueTitle('静态锁定-普通任务') }); const normalStock = (await fetchStockRows(3)).find(stock => Number(stock.id) !== Number(stocks[0].id) && Number(stock.id) !== Number(stocks[1].id)); if (normalStock) { await addDetail(normalCheck.id, [ normalStock.id ]); await submitCheck(normalCheck.id); await auditCheck(normalCheck.id, 'approve'); const afterNormal = await staticLockList(); assert.equal( afterNormal.stock_ids.map(Number).includes(Number(normalStock.id)), false, '非静态任务不应进入锁定集合' ); } }); it('缓存命中与失效:二次查询命中缓存,审核/完成/取消后缓存清除', async () => { await clearLockCache(); const stocks = await fetchStockRows(1); const check = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-缓存'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); // 提交审核不锁定:首次查询未命中缓存,且不包含本任务 const beforeApprove = await staticLockList(); assert.equal(beforeApprove.cached, false, '首次查询应回源'); assert.equal( beforeApprove.rows.some(row => row.check_ids.map(Number).includes(Number(check.id))), false, '待审核阶段不锁定(rows 不应含该任务)' ); // 审核通过后缓存被立即重建(不是删除等下次回源)→ 含本任务;查询命中缓存 await auditCheck(check.id, 'approve'); const cacheAfterAudit = await readLockCache(); assert.ok(cacheAfterAudit, '审核通过应重建锁定缓存(不留空窗)'); assert.ok( cacheAfterAudit.rows.some(row => row.check_ids.map(Number).includes(Number(check.id))), '重建后的缓存应包含刚审核通过的任务' ); const afterApprove = await staticLockList(); assert.equal(afterApprove.cached, true, '审核后查询应直接命中已重建的缓存'); const lockedRow = afterApprove.rows.find(row => Number(row.stock_id) === Number(stocks[0].id)); assert.ok(lockedRow, '审核通过后该商品应出现在锁定集合'); assert.ok(lockedRow.check_ids.map(Number).includes(Number(check.id)), '锁定行应含该任务ID'); assert.ok(afterApprove.updated_at, '缓存载荷应含 updated_at'); // 完成盘点 → 缓存重建且本任务已被移除 await finishCheck(check.id); const cacheAfterFinish = await readLockCache(); assert.ok(cacheAfterFinish, '完成盘点应重建锁定缓存'); assert.equal( cacheAfterFinish.rows.some(row => row.check_ids.map(Number).includes(Number(check.id))), false, '重建后的缓存不应再包含已完成任务' ); const afterFinish = await staticLockList(); assert.equal(afterFinish.cached, true, '完成后查询命中已重建的缓存'); assert.equal( afterFinish.rows.some(row => row.check_ids.map(Number).includes(Number(check.id))), false, '已完成任务不应出现在锁定集合' ); // 取消任务 → 同样失效 const cancelledCheck = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-取消'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await staticLockList(); await cancelCheck(cancelledCheck.id); const cacheAfterCancel = await readLockCache(); assert.ok(cacheAfterCancel, '取消任务应重建锁定缓存'); assert.equal( cacheAfterCancel.rows.some(row => row.check_ids.map(Number).includes(Number(cancelledCheck.id))), false, '重建后的缓存不应包含已取消任务' ); }); it('isStockStaticLocked:按商品判断是否锁定(读缓存),未锁定返回 false', async () => { await clearLockCache(); const stocks = await fetchStockRows(2); const check = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-单商品判断'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const lockedHit = await ctx.service.systems.stockCheck.isStockStaticLocked({ warehouseId: TEST_WAREHOUSE_ID, stockId: stocks[0].id, }); assert.equal(lockedHit.locked, true, '锁定中的商品应返回 locked=true'); assert.deepEqual(lockedHit.locked_stock_ids, [ Number(stocks[0].id) ]); assert.equal(Number(lockedHit.rows[0].stock_id), Number(stocks[0].id)); const lockedMiss = await ctx.service.systems.stockCheck.isStockStaticLocked({ warehouseId: TEST_WAREHOUSE_ID, stockId: [ stocks[1].id, 999999999 ], }); assert.equal(lockedMiss.locked, false, '未锁定商品应返回 locked=false'); assert.deepEqual(lockedMiss.locked_stock_ids, []); await assert.rejects( async () => ctx.service.systems.stockCheck.isStockStaticLocked({ warehouseId: TEST_WAREHOUSE_ID }), /商品ID不能为空/ ); await assert.rejects( async () => ctx.service.systems.stockCheck.staticLockList({ warehouseId: 0 }), /无法获取当前仓库上下文/ ); }); it('审核通过刷新商品明细账面快照:提交后库存变化,审核时快照刷新为审核时点账面', async () => { const stocks = await fetchStockRows(1); const targetStock = stocks[0]; const check = await createCheck({ title: uniqueTitle('审核刷新快照'), type: 'goods' }); const added = await addDetail(check.id, [ targetStock.id ]); assert.ok(added.added >= 1, '前置:应生成商品明细(按库位拆行)'); const detailsBefore = await detailCheck(check.id); const targetDetail = detailsBefore.rows[0]; const spaceId = Number(targetDetail.location_id); /** * 读取指定商品在指定库位的当前账面(可用数量)。 * * @return {Promise} 账面数量。 */ async function readSpaceBook() { const rows = await ctx.model.query( `SELECT COALESCE(SUM(available_quantity), 0) AS total FROM wms_storage WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId }, type: ctx.model.QueryTypes.SELECT, } ); return Number(rows[0] && rows[0].total) || 0; } const bookOnSubmit = await readSpaceBook(); // 提交审核:快照=提交时点账面 await submitCheck(check.id); const afterSubmit = await ctx.model.StockCheckDetail.findByPk(targetDetail.id, { raw: true }); assert.equal(Number(afterSubmit.system_quantity), bookOnSubmit, '提交时快照应等于提交时点账面'); // 模拟提交后、审核前的库存变动(该库位每行可用数量 +5) await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity + 5 WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); const bookAfterChange = await readSpaceBook(); assert.ok(bookAfterChange > bookOnSubmit, '前置:库存变动后账面应增加'); try { const auditResult = await auditCheck(check.id, 'approve'); assert.equal( Number(auditResult.snapshot_refreshed) >= 1, true, '审核通过应刷新快照并返回刷新行数' ); const afterAudit = await ctx.model.StockCheckDetail.findByPk(targetDetail.id, { raw: true }); assert.equal( Number(afterAudit.system_quantity), bookAfterChange, '审核通过后快照应刷新为审核时点账面(快照随库存变动更新为最新账面)' ); } finally { // 回滚本次人为库存变更,避免污染开发库 await ctx.model.query( `UPDATE wms_storage SET available_quantity = available_quantity - 5 WHERE warehouse_id = :warehouseId AND stock_id = :stockId AND space_id = :spaceId`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, stockId: targetStock.id, spaceId } } ); } }); it('完成盘点立即释放锁定:finish 清除缓存并返回 released_stock_ids,之后该商品不再锁定', async () => { await clearLockCache(); // 构造一个只属于本用例的商品(避免被历史静态任务同时锁定,便于验证释放) const uniqueSuffix = `${Date.now()}-${Math.floor(Math.random() * 1000)}`; const itemCode = `VERIFY-LOCK-${uniqueSuffix}`; const [ fabricatedId ] = await ctx.model.query( `INSERT INTO wms_stock_warehouse (item_code, item_name, store_id, stock_unit, item_type, create_at, warehouse_id, is_valid, quantity, is_shelf_life_mgmt, remaining_threshold_days) VALUES (:itemCode, '静态锁定释放测试商品', :storeId, '个', 'normal', NOW(), :warehouseId, 'Y', 3, 'N', 0)`, { replacements: { itemCode, storeId: TEST_STORE_ID, warehouseId: TEST_WAREHOUSE_ID } } ); const stockId = Number(fabricatedId); const [ validLocation ] = await fetchValidLocations(1); assert.ok(validLocation, '前置:应存在有效库位'); await ctx.model.query( `INSERT INTO wms_storage (warehouse_id, store_id, space_id, stock_id, batch_no, inventory_type, quantity, expiry_date, inbound_time, inbound_order_no) VALUES (:warehouseId, :storeId, :spaceId, :stockId, :batchNo, 'ZP', 3, NULL, NOW(), :orderNo)`, { replacements: { warehouseId: TEST_WAREHOUSE_ID, storeId: TEST_STORE_ID, spaceId: validLocation.id, stockId, batchNo: `VERIFY-LOCK-BATCH-${uniqueSuffix}`, orderNo: `VERIFY-LOCK-IN-${uniqueSuffix}`, }, type: ctx.model.QueryTypes.INSERT, } ); const check = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-完成释放'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(check.id, [ stockId ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); // 审核后锁定 const lockedBefore = await ctx.service.systems.stockCheck.isStockStaticLocked({ warehouseId: TEST_WAREHOUSE_ID, stockId, }); assert.equal(lockedBefore.locked, true, '审核通过后该商品应在锁定集合中'); // 完成盘点 → 清缓存 + 返回释放商品 + 不再锁定 const finishResult = await finishCheck(check.id); assert.equal(finishResult.status, 'completed'); assert.deepEqual(finishResult.released_stock_ids, [ stockId ], 'finish 应返回本任务覆盖的商品ID'); const cacheAfterFinish = await readLockCache(); assert.ok(cacheAfterFinish, '完成盘点应重建锁定缓存(不留空窗)'); assert.equal( cacheAfterFinish.stock_ids.includes(stockId), false, '重建后的缓存不应再包含该商品(已释放)' ); // 完成盘点后该商品解除锁定,且缓存已重建(回源口径) const lockedAfter = await ctx.service.systems.stockCheck.isStockStaticLocked({ warehouseId: TEST_WAREHOUSE_ID, stockId, }); assert.equal(lockedAfter.locked, false, '完成盘点后该商品应解除锁定'); assert.deepEqual(lockedAfter.locked_stock_ids, []); assert.equal(lockedAfter.cached, true, '完成时已重建缓存,判断应命中缓存'); // 清理本用例构造的商品数据 await ctx.model.query('DELETE FROM wms_storage WHERE stock_id = :stockId', { replacements: { stockId } }); await ctx.model.query('DELETE FROM wms_stock_warehouse WHERE id = :stockId', { replacements: { stockId } }); }); it('空集合也缓存(不穿透):无锁定任务的仓库首次回源、二次命中;并发未命中只回源一次且结果一致', async () => { // 用另一个测试仓库(无静态任务)验证「空结果缓存」与并发 singleflight const emptyWarehouseId = OTHER_TEST_WAREHOUSE_ID; const emptyKey = `stock_check:static_lock:${emptyWarehouseId}`; await ctx.app.delCacheAsync(emptyKey); const firstEmpty = await ctx.service.systems.stockCheck.staticLockList({ warehouseId: emptyWarehouseId }); assert.equal(firstEmpty.cached, false, '首次查询应回源'); assert.deepEqual(firstEmpty.stock_ids, [], '无锁定任务时为空集合'); assert.equal(firstEmpty.total, 0); const secondEmpty = await ctx.service.systems.stockCheck.staticLockList({ warehouseId: emptyWarehouseId }); assert.equal(secondEmpty.cached, true, '空集合也会被缓存,二次查询命中(不穿透数据库)'); assert.deepEqual(secondEmpty.stock_ids, []); // 并发未命中:singleflight 共用同一次回源,结果一致 await ctx.app.delCacheAsync(emptyKey); const concurrent = await Promise.all(Array.from({ length: 5 }, () => ctx.service.systems.stockCheck.staticLockList({ warehouseId: emptyWarehouseId }))); assert.equal(concurrent.length, 5); for (const item of concurrent) { assert.deepEqual(item.stock_ids, [], '并发查询结果应一致'); } assert.ok( concurrent.every(item => item.cached === false), '并发未命中时均由同一次回源答复(cached=false),不会各自打出多轮 SQL' ); // forceRefresh 强制回源 const forced = await ctx.service.systems.stockCheck.staticLockList({ warehouseId: emptyWarehouseId, forceRefresh: true, }); assert.equal(forced.cached, false, 'forceRefresh 应跳过缓存回源'); await ctx.app.delCacheAsync(emptyKey); }); it('防脏读:回源期间发生状态流转(代次变化)时不写入旧快照,缓存保持为空由下次回源', async () => { const guardWarehouseId = OTHER_TEST_WAREHOUSE_ID; const guardKey = `stock_check:static_lock:${guardWarehouseId}`; await ctx.app.delCacheAsync(guardKey); const service = ctx.service.systems.stockCheck; const originalQuery = service._queryStaticLockRows; try { // 模拟「查询过程中另一个审核/完成流转正在重建缓存」:查询内部递增锁定代次 service._queryStaticLockRows = async warehouseId => { await service._bumpStaticLockGeneration(warehouseId); return originalQuery.call(service, warehouseId); }; const guarded = await service.staticLockList({ warehouseId: guardWarehouseId, forceRefresh: true }); assert.equal(guarded.cache_skipped, true, '代次变化时不写缓存'); assert.equal(await ctx.app.getCacheAsync(guardKey), null, '旧快照不应写入缓存(避免脏读)'); assert.deepEqual(guarded.stock_ids, [], '仍返回本次查询结果,供调用方使用'); // 恢复后正常写缓存 service._queryStaticLockRows = originalQuery; const normal = await service.staticLockList({ warehouseId: guardWarehouseId, forceRefresh: true }); assert.equal(normal.cache_skipped, undefined, '无并发流转时正常写缓存'); assert.ok(await ctx.app.getCacheAsync(guardKey), '缓存已写入'); // 状态流转会递增代次(审核通过时由 refreshStaticLockCache 递增) const generationBefore = await service._readStaticLockGeneration(guardWarehouseId); await service.refreshStaticLockCache(guardWarehouseId); const generationAfter = await service._readStaticLockGeneration(guardWarehouseId); assert.ok(generationAfter > generationBefore, 'refreshStaticLockCache 应递增锁定代次'); } finally { service._queryStaticLockRows = originalQuery; await ctx.app.delCacheAsync(guardKey); } }); it('getStaticLockConflict:锁定商品返回可读冲突文案,未锁定返回空', async () => { await clearLockCache(); const stocks = await fetchStockRows(1); const check = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-冲突文案'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); const conflict = await ctx.service.systems.stockCheck.getStaticLockConflict({ warehouseId: TEST_WAREHOUSE_ID, stockIds: [ stocks[0].id ], actionLabel: '分配储位', }); assert.equal(conflict.locked, true); assert.match(conflict.message, /禁止分配储位/); assert.match(conflict.message, new RegExp(check.check_no), '冲突文案应含盘点单号'); assert.equal(Number(conflict.rows[0].stock_id), Number(stocks[0].id)); const noConflict = await ctx.service.systems.stockCheck.getStaticLockConflict({ warehouseId: TEST_WAREHOUSE_ID, stockIds: [ 999999999 ], actionLabel: '移库', }); assert.equal(noConflict.locked, false); assert.equal(noConflict.message, ''); assert.deepEqual(noConflict.rows, []); // 空入参不查库、不报错 const emptyInput = await ctx.service.systems.stockCheck.getStaticLockConflict({ warehouseId: TEST_WAREHOUSE_ID, stockIds: [], }); assert.equal(emptyInput.locked, false); }); it('方法层 staticLockList:仓库上下文注入、success 包装、缓存标识透出', async () => { await clearLockCache(); mockCurrentUser(); const stocks = await fetchStockRows(1); const check = await ctx.service.systems.stockCheck.create({ warehouseId: TEST_WAREHOUSE_ID, title: uniqueTitle('静态锁定-方法层'), type: 'goods', isStatic: 1, creatorId: TEST_CREATOR_ID, creatorName: TEST_CREATOR_NAME, }); await addDetail(check.id, [ stocks[0].id ]); await submitCheck(check.id); await auditCheck(check.id, 'approve'); // 审核通过时已重建缓存 → 首次调用即命中缓存 const warmed = await ctx.service.systemMethods.stock.check.staticLockList(); assert.equal(warmed.data.cached, true, '审核通过已重建缓存,首次调用应命中'); // 手动清除缓存后首次调用回源(cached=false),再次调用命中 await clearLockCache(); const first = await ctx.service.systemMethods.stock.check.staticLockList(); assert.equal(first.flag, 'success'); assert.equal(first.code, 1); assert.equal(Number(first.data.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); assert.ok(first.data.stock_ids.map(Number).includes(Number(stocks[0].id))); assert.equal(first.data.cached, false); assert.equal(first.data.total, first.data.rows.length); const second = await ctx.service.systemMethods.stock.check.staticLockList(); assert.equal(second.flag, 'success'); assert.equal(second.data.cached, true, '二次调用应命中缓存'); // 缺仓库上下文 → failure 400 ctx.user = null; const noWarehouse = await ctx.service.systemMethods.stock.check.staticLockList(); assert.equal(noWarehouse.flag, 'failure'); assert.equal(noWarehouse.code, 400); }); }); });