yeuimu
93ac525c55
解析去运行时化（三层架构，plans/refactor/organize-script-refactor.md）： - 同步 = 纯镜像：upsertOriginGood 不再写解析列、不再自动挂族；详情同步仍触发重算 - 整理 = 显式人工动作（OrganizeService）：解析列回填 → 派生标签（人工接管永不 覆盖）→ auto-group 建族 → 全量重算；入口 CLI（pnpm --filter @inkreach/api organize）+ POST /product-families/organize + 后台「整理」按钮 - 重算 = 纯结构化聚合：不再按名称重派生标签（防上游改名倒灌，回归测试覆盖）； 矩阵维度只认标签/CUSTOM 显式标签，未整理成员不进矩阵；工艺=不打印时 印花数量以单面占位（纯结构化规则）；「恢复自动」走整理的单链接派生 - 派生默认补齐（脚本层假设）：名称无单/双面且工艺非不打印 → 印花数量单面印花 - goods 服务建品/更新后仅镜像标签+重算（不派生）；含商品名入库规范化 （normalizeGoodName，管理员输入边界质检） - organize.service.spec 由 tag-sync spec 迁移 + 防倒灌回归；sync/recompute/ public/families spec 全部适配；API 173/173，admin typecheck+22/22
450 lines
16 KiB
TypeScript
450 lines
16 KiB
TypeScript
import { Test } from '@nestjs/testing';
|
|
import {
|
|
BadRequestException,
|
|
NotFoundException,
|
|
} from '@nestjs/common';
|
|
import { GoodsService } from './goods.service';
|
|
import { PrismaService } from '../prisma/prisma.service';
|
|
import { SyncService } from '../sync/sync.service';
|
|
import { FamilyRecomputeService } from '../product-families/family-recompute.service';
|
|
|
|
describe('GoodsService', () => {
|
|
let service: GoodsService;
|
|
let prisma: PrismaService;
|
|
const stamp = Date.now();
|
|
|
|
// Fixtures
|
|
let countryId: bigint;
|
|
let country2Id: bigint;
|
|
let categoryId: bigint;
|
|
let childCategoryId: bigint;
|
|
let tagId: bigint;
|
|
let positionId: bigint;
|
|
let originGoodIds: bigint[] = [];
|
|
|
|
beforeAll(async () => {
|
|
const moduleRef = await Test.createTestingModule({
|
|
providers: [
|
|
GoodsService,
|
|
PrismaService,
|
|
{
|
|
provide: SyncService,
|
|
useValue: { queueProductDetailSync: jest.fn() },
|
|
},
|
|
{
|
|
provide: FamilyRecomputeService,
|
|
// 全量并行跑时其他套件的扫名归族可能把本套件夹具链接收进族，
|
|
// create/update 会调用 syncFamilyTags —— mock 必须覆盖全部被调方法
|
|
useValue: {
|
|
enqueue: jest.fn(),
|
|
recomputeFamily: jest.fn().mockResolvedValue(undefined),
|
|
syncFamilyTags: jest.fn().mockResolvedValue({ goodsUpdated: 0, linksUpdated: 0 }),
|
|
refreshLinkTags: jest.fn().mockResolvedValue(undefined),
|
|
mirrorLinkTagsToGoods: jest.fn().mockResolvedValue(undefined),
|
|
},
|
|
},
|
|
],
|
|
}).compile();
|
|
service = moduleRef.get(GoodsService);
|
|
prisma = moduleRef.get(PrismaService);
|
|
await prisma.onModuleInit();
|
|
|
|
const country = await prisma.country.create({
|
|
data: { countryName: `Goods Country ${stamp}` },
|
|
});
|
|
countryId = country.id;
|
|
const country2 = await prisma.country.create({
|
|
data: { countryName: `Goods Country 2 ${stamp}` },
|
|
});
|
|
country2Id = country2.id;
|
|
|
|
const cat = await prisma.category.create({
|
|
data: { categoryName: `Goods Cat ${stamp}` },
|
|
});
|
|
categoryId = cat.id;
|
|
const child = await prisma.category.create({
|
|
data: { categoryName: `Goods Child ${stamp}`, parentCategoryId: cat.id },
|
|
});
|
|
childCategoryId = child.id;
|
|
|
|
const tag = await prisma.tag.create({
|
|
data: { tagName: `Goods Tag ${stamp}`, tagColor: '#00FF00' },
|
|
});
|
|
tagId = tag.id;
|
|
|
|
const pos = await prisma.position.create({
|
|
data: { indexVal: 1, countryId, categoryId },
|
|
});
|
|
positionId = pos.id;
|
|
|
|
const originGoods = await Promise.all(
|
|
Array.from({ length: 5 }).map((_, i) =>
|
|
prisma.originGood.create({
|
|
data: {
|
|
sdsGoodId: `sds-goods-${stamp}-${i}`,
|
|
goodName: `Goods Origin ${stamp} ${i}`,
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
originGoodIds = originGoods.map((og) => og.id);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
// Wipe all goods first so origin_goods/category can be removed.
|
|
await prisma.good.deleteMany({
|
|
where: { goodName: { contains: `Goods Test ${stamp}` } },
|
|
});
|
|
await prisma.good.deleteMany({
|
|
where: { goodName: { contains: `Origin ${stamp}` } },
|
|
});
|
|
await prisma.originGood.deleteMany({
|
|
where: { id: { in: originGoodIds } },
|
|
});
|
|
await prisma.position.delete({ where: { id: positionId } });
|
|
await prisma.tag.delete({ where: { id: tagId } });
|
|
await prisma.category.delete({ where: { id: childCategoryId } });
|
|
await prisma.category.delete({ where: { id: categoryId } });
|
|
await prisma.country.delete({ where: { id: countryId } });
|
|
await prisma.country.delete({ where: { id: country2Id } });
|
|
await prisma.onModuleDestroy();
|
|
});
|
|
|
|
it('should be defined', () => {
|
|
expect(service).toBeDefined();
|
|
});
|
|
|
|
it('creates and reads back a good', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} basic`,
|
|
originGoodId: Number(originGoodIds[0]),
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
tagIds: [Number(tagId)],
|
|
positionId: Number(positionId),
|
|
goodPriority: 3,
|
|
});
|
|
expect(created.id).toBeTruthy();
|
|
expect(created.country?.countryName).toBeTruthy();
|
|
expect(created.tags.some((t) => t.tagColor === '#00FF00')).toBe(true);
|
|
|
|
const fetched = await service.findOne(BigInt(created.id));
|
|
expect(fetched.goodName).toBe(`Goods Test ${stamp} basic`);
|
|
});
|
|
|
|
it('creates, edits, and removes a fully editable custom good', async () => {
|
|
const created = await service.createCustom({
|
|
goodName: `Goods Test ${stamp} custom`,
|
|
goodImage: 'https://example.com/custom.png',
|
|
goodPrice: '29.90',
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
tagIds: [Number(tagId)],
|
|
detail: {
|
|
productCode: `CUSTOM-${stamp}`,
|
|
materialDescription: 'Cotton',
|
|
sizeChart: { columns: [], rows: [] },
|
|
packageSpecs: { rows: [] },
|
|
},
|
|
variants: [
|
|
{ sku: `CUSTOM-SKU-${stamp}`, sizeName: 'S', price: '29.90' },
|
|
],
|
|
});
|
|
|
|
expect(created.originGood?.source).toBe('CUSTOM');
|
|
expect(created.originGood?.isCustom).toBe(true);
|
|
expect(created.originGood?.goodPrice).toBe('29.9');
|
|
expect(created.variants).toHaveLength(1);
|
|
|
|
const updated = await service.updateCustomContent(BigInt(created.id), {
|
|
goodName: `Goods Test ${stamp} custom edited`,
|
|
goodPrice: '39.90',
|
|
detail: { materialDescription: 'Organic cotton' },
|
|
variants: [
|
|
{ sku: `CUSTOM-SKU-${stamp}-M`, sizeName: 'M', price: '39.90' },
|
|
],
|
|
});
|
|
expect(updated.goodName).toContain('custom edited');
|
|
expect(updated.originGood?.goodPrice).toBe('39.9');
|
|
expect(updated.originDetail?.materialDescription).toBe('Organic cotton');
|
|
expect(updated.originDetail?.productCode).toBe(`CUSTOM-${stamp}`);
|
|
expect(updated.variants[0]?.sizeName).toBe('M');
|
|
|
|
const customOriginId = BigInt(updated.originGoodId);
|
|
await service.remove(BigInt(updated.id));
|
|
await expect(
|
|
prisma.originGood.findUnique({ where: { id: customOriginId } }),
|
|
).resolves.toBeNull();
|
|
});
|
|
|
|
it('filters by countryId, tagId, positionId and keyword', async () => {
|
|
const result = await service.findAll({
|
|
page: 1,
|
|
pageSize: 20,
|
|
countryId: Number(countryId),
|
|
tagId: Number(tagId),
|
|
keyword: `Goods Test ${stamp}`,
|
|
});
|
|
expect(result.items.length).toBeGreaterThan(0);
|
|
expect(result.items.every((g) => g.countryId === countryId.toString())).toBe(true);
|
|
expect(
|
|
result.items.every((g) => g.tags.some((t) => t.id === tagId.toString())),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('categoryId filter includes descendants recursively', async () => {
|
|
const inChild = await service.create({
|
|
goodName: `Goods Test ${stamp} child`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
countryId: Number(countryId),
|
|
categoryId: Number(childCategoryId),
|
|
});
|
|
const result = await service.findAll({
|
|
page: 1,
|
|
pageSize: 20,
|
|
categoryId: Number(categoryId),
|
|
keyword: `Goods Test ${stamp}`,
|
|
});
|
|
const ids = result.items.map((g) => g.id);
|
|
expect(ids).toContain(inChild.id);
|
|
});
|
|
|
|
it('batch update priority is atomic', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} prio`,
|
|
originGoodId: Number(originGoodIds[2]),
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
const result = await service.batchUpdatePriority({
|
|
items: [{ id: Number(created.id), priority: 42 }],
|
|
});
|
|
expect(result.count).toBe(1);
|
|
const after = await service.findOne(BigInt(created.id));
|
|
expect(after.goodPriority).toBe(42);
|
|
});
|
|
|
|
it('batch create creates all rows or none', async () => {
|
|
// Count of goods whose originGoodId is one of the two fixture ids,
|
|
// so we are independent of goodName (which batch derives from origin).
|
|
const before = await service.findAll({
|
|
page: 1,
|
|
pageSize: 100,
|
|
keyword: `Goods Origin ${stamp}`,
|
|
});
|
|
const created = await service.batchCreate({
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
defaultPriority: 1,
|
|
items: [
|
|
{ originGoodId: Number(originGoodIds[3]) },
|
|
{ originGoodId: Number(originGoodIds[4]) },
|
|
],
|
|
});
|
|
expect(created.length).toBe(2);
|
|
const after = await service.findAll({
|
|
page: 1,
|
|
pageSize: 100,
|
|
keyword: `Goods Origin ${stamp}`,
|
|
});
|
|
expect(after.total).toBe(before.total + 2);
|
|
});
|
|
|
|
it('batch create rolls back on failure', async () => {
|
|
const before = await service.findAll({
|
|
page: 1,
|
|
pageSize: 100,
|
|
keyword: `Goods Origin ${stamp}`,
|
|
});
|
|
await expect(
|
|
service.batchCreate({
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
items: [
|
|
{ originGoodId: Number(originGoodIds[0]) },
|
|
{ originGoodId: 99999999 }, // missing -> failure
|
|
],
|
|
}),
|
|
).rejects.toBeInstanceOf(BadRequestException);
|
|
const after = await service.findAll({
|
|
page: 1,
|
|
pageSize: 100,
|
|
keyword: `Goods Origin ${stamp}`,
|
|
});
|
|
expect(after.total).toBe(before.total);
|
|
});
|
|
|
|
describe('good name normalization', () => {
|
|
it('create/update 时把结构完整的原始链接名规范化为 品名+型号', async () => {
|
|
const created = await service.create({
|
|
goodName: '德国(不包邮)230g水洗T恤-DETM002-双面印花',
|
|
originGoodId: Number(originGoodIds[0]),
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
try {
|
|
expect(created.goodName).toBe('230g水洗T恤 DETM002');
|
|
const updated = await service.update(BigInt(created.id), {
|
|
goodName: '加拿大（不包邮）180g纯棉T恤-CATM001-单面印花',
|
|
});
|
|
expect(updated.goodName).toBe('180g纯棉T恤 CATM001');
|
|
} finally {
|
|
await prisma.good.delete({ where: { id: BigInt(created.id) } });
|
|
}
|
|
});
|
|
|
|
it('非链接结构的名称原样保留（已解析名/自定义名）', async () => {
|
|
const created = await service.create({
|
|
goodName: '230g水洗T恤 DETM002',
|
|
originGoodId: Number(originGoodIds[0]),
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
try {
|
|
expect(created.goodName).toBe('230g水洗T恤 DETM002');
|
|
const updated = await service.update(BigInt(created.id), {
|
|
goodName: '自定义商品 ABC',
|
|
});
|
|
expect(updated.goodName).toBe('自定义商品 ABC');
|
|
} finally {
|
|
await prisma.good.delete({ where: { id: BigInt(created.id) } });
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('merged origin goods', () => {
|
|
it('creates a good with merged origin goods and reads them back', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} merged`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[2]), Number(originGoodIds[3])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
expect(created.mergedOriginGoods.map((m) => m.id).sort()).toEqual(
|
|
[originGoodIds[2].toString(), originGoodIds[3].toString()].sort(),
|
|
);
|
|
const fetched = await service.findOne(BigInt(created.id));
|
|
expect(fetched.mergedOriginGoods.length).toBe(2);
|
|
});
|
|
|
|
it('rejects mergedOriginGoodIds containing the primary', async () => {
|
|
await expect(
|
|
service.create({
|
|
goodName: `Goods Test ${stamp} bad-primary`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[1])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
}),
|
|
).rejects.toThrow(BadRequestException);
|
|
});
|
|
|
|
it('rejects mergedOriginGoodIds that do not exist', async () => {
|
|
await expect(
|
|
service.create({
|
|
goodName: `Goods Test ${stamp} bad-missing`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [999999999],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
}),
|
|
).rejects.toThrow(BadRequestException);
|
|
});
|
|
|
|
it('replaces merged origin goods on update', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} replace`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[2])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
const updated = await service.update(BigInt(created.id), {
|
|
mergedOriginGoodIds: [Number(originGoodIds[3]), Number(originGoodIds[4])],
|
|
});
|
|
expect(updated.mergedOriginGoods.map((m) => m.id).sort()).toEqual(
|
|
[originGoodIds[3].toString(), originGoodIds[4].toString()].sort(),
|
|
);
|
|
});
|
|
|
|
it('moves old primary into merged list when switching primary', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} switch`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[2])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
const updated = await service.update(BigInt(created.id), {
|
|
originGoodId: Number(originGoodIds[2]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[1]), Number(originGoodIds[3])],
|
|
});
|
|
expect(updated.originGoodId).toBe(originGoodIds[2].toString());
|
|
expect(updated.mergedOriginGoods.map((m) => m.id).sort()).toEqual(
|
|
[originGoodIds[1].toString(), originGoodIds[3].toString()].sort(),
|
|
);
|
|
});
|
|
|
|
it('cascades merged rows on good removal', async () => {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} cascade`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[2])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
await service.remove(BigInt(created.id));
|
|
const rows = await prisma.goodOriginGood.count({
|
|
where: { goodId: BigInt(created.id) },
|
|
});
|
|
expect(rows).toBe(0);
|
|
});
|
|
|
|
it('returns merged variants with source annotation in detail', async () => {
|
|
const v1 = await prisma.originGoodVariant.create({
|
|
data: {
|
|
originGoodId: originGoodIds[1],
|
|
sdsVariantId: `mv-pri-${stamp}`,
|
|
sku: `MV-PRI-${stamp}`,
|
|
colorName: '黑色',
|
|
},
|
|
});
|
|
const v2 = await prisma.originGoodVariant.create({
|
|
data: {
|
|
originGoodId: originGoodIds[2],
|
|
sdsVariantId: `mv-sec-${stamp}`,
|
|
sku: `MV-SEC-${stamp}`,
|
|
colorName: '白色',
|
|
},
|
|
});
|
|
try {
|
|
const created = await service.create({
|
|
goodName: `Goods Test ${stamp} variants`,
|
|
originGoodId: Number(originGoodIds[1]),
|
|
mergedOriginGoodIds: [Number(originGoodIds[2])],
|
|
countryId: Number(countryId),
|
|
categoryId: Number(categoryId),
|
|
});
|
|
const detail = await service.findOne(BigInt(created.id));
|
|
const sources = new Set(
|
|
detail.variants.map((v) => v['originGoodId'] as string),
|
|
);
|
|
expect(sources.has(originGoodIds[1].toString())).toBe(true);
|
|
expect(sources.has(originGoodIds[2].toString())).toBe(true);
|
|
expect(detail.variants).toHaveLength(2);
|
|
expect(detail.mergedOriginGoods.find((m) => m.id === originGoodIds[2].toString())?.variantCount).toBe(1);
|
|
} finally {
|
|
await prisma.originGoodVariant.delete({ where: { id: v1.id } });
|
|
await prisma.originGoodVariant.delete({ where: { id: v2.id } });
|
|
}
|
|
});
|
|
});
|
|
|
|
it('throws NotFoundException for unknown id', async () => {
|
|
await expect(service.findOne(BigInt(99999999))).rejects.toBeInstanceOf(
|
|
NotFoundException,
|
|
);
|
|
});
|
|
});
|