R524809
435 lines
18 KiB
TypeScript
435 lines
18 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { randomUUID } from 'node:crypto';
|
|
import type { AddressInfo } from 'node:net';
|
|
import type { Database } from '@atlas/database';
|
|
import type { NestExpressApplication } from '@nestjs/platform-express';
|
|
import { afterAll, beforeAll, describe, it } from 'vitest';
|
|
import { DATABASE } from '../src/database/database.module.js';
|
|
import { createApplication } from '../src/main.js';
|
|
|
|
let app: NestExpressApplication;
|
|
let database: Database;
|
|
let baseUrl = '';
|
|
let workspaceId = '';
|
|
let userId = '';
|
|
async function request(path: string, init: RequestInit = {}) {
|
|
const response = await fetch(`${baseUrl}${path}`, {
|
|
redirect: 'manual',
|
|
...init,
|
|
headers: { 'Content-Type': 'application/json', ...init.headers },
|
|
});
|
|
return {
|
|
response,
|
|
body:
|
|
response.status === 204 || response.status === 302
|
|
? undefined
|
|
: ((await response.json()) as any),
|
|
};
|
|
}
|
|
|
|
describe('扩展授权与采集 HTTP 集成测试', () => {
|
|
beforeAll(async () => {
|
|
Object.assign(process.env, {
|
|
NODE_ENV: 'test',
|
|
SWAGGER_ENABLED: 'false',
|
|
AUTH_REGISTER_IP_LIMIT: '100',
|
|
AUTH_REGISTER_EMAIL_LIMIT: '100',
|
|
});
|
|
const created = await createApplication();
|
|
app = created.app;
|
|
database = app.get<Database>(DATABASE);
|
|
await app.listen(0, '127.0.0.1');
|
|
baseUrl = `http://127.0.0.1:${(app.getHttpServer().address() as AddressInfo).port}`;
|
|
});
|
|
afterAll(async () => {
|
|
await database.workspaceTransaction(workspaceId, async (tx) => {
|
|
await tx.query(
|
|
'DELETE FROM atlas.idempotency_requests WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.outbox_events WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.operations WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.collection_asset_transfers WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.product_variant_platform_listings WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.product_platform_profiles WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query('DELETE FROM atlas.stores WHERE workspace_id = $1', [
|
|
workspaceId,
|
|
]);
|
|
await tx.query(
|
|
'DELETE FROM atlas.product_variants WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.products WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.collection_items WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.extension_authorization_codes WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.extension_sessions WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
});
|
|
await database.query(
|
|
'DELETE FROM atlas.workspace_memberships WHERE user_id = $1',
|
|
[userId],
|
|
);
|
|
await database.query('DELETE FROM atlas.workspaces WHERE id = $1', [
|
|
workspaceId,
|
|
]);
|
|
await database.query('DELETE FROM atlas.users WHERE id = $1', [userId]);
|
|
await app.close();
|
|
});
|
|
|
|
it('未登录令牌返回可操作的扩展会话错误', async () => {
|
|
const session = await request('/api/extension/session');
|
|
assert.equal(session.response.status, 401);
|
|
assert.equal(session.body.error.code, 'SESSION_EXPIRED');
|
|
assert.equal(
|
|
session.body.error.message,
|
|
'Atlas ERP 登录已过期，请重新登录',
|
|
);
|
|
});
|
|
|
|
it('通过 Atlas Web access token 写入来源商品，并以新快照覆盖重复采集', async () => {
|
|
const registration = await request('/api/auth/register', {
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
email: `extension-${randomUUID()}@example.test`,
|
|
password: 'correct-horse-battery-staple-123',
|
|
password_confirmation: 'correct-horse-battery-staple-123',
|
|
}),
|
|
});
|
|
assert.equal(registration.response.status, 201);
|
|
userId = registration.body.data.user.id;
|
|
workspaceId = registration.body.data.workspace.id;
|
|
const webAccessToken = registration.body.data.access_token as string;
|
|
const session = await request('/api/extension/session', {
|
|
headers: { Authorization: `Bearer ${webAccessToken}` },
|
|
});
|
|
assert.equal(session.response.status, 200);
|
|
assert.equal(session.body.data.workspace.id, workspaceId);
|
|
const payload = {
|
|
source: {
|
|
platform: 'ozon',
|
|
itemKey: '123456789',
|
|
canonicalUrl: 'https://www.ozon.ru/product/demo-123456789/',
|
|
collectedAt: new Date().toISOString(),
|
|
parserVersion: 'test-1',
|
|
},
|
|
common: {
|
|
title: { value: '来源商品', confidence: 'verified' },
|
|
sourcePrice: { amount: '99.90', currencyCode: 'RUB' },
|
|
attributes: [],
|
|
categories: [],
|
|
},
|
|
variantAxes: [],
|
|
variants: [
|
|
{
|
|
sourceVariantKey: '123456789',
|
|
sourceSku: '123456789',
|
|
displayName: '默认 SKU',
|
|
selections: [],
|
|
confidence: 'verified',
|
|
evidenceRefs: ['page'],
|
|
},
|
|
],
|
|
assets: [
|
|
{
|
|
url: 'https://images.example.test/product.jpg',
|
|
role: 'source_main',
|
|
relation: 'product_candidate',
|
|
sortOrder: 0,
|
|
evidenceRef: 'page',
|
|
},
|
|
],
|
|
evidence: [{ ref: 'page', kind: 'page', path: 'test' }],
|
|
};
|
|
const first = await request('/api/extension/materials', {
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${webAccessToken}`,
|
|
'Idempotency-Key': randomUUID(),
|
|
},
|
|
body: JSON.stringify(payload),
|
|
});
|
|
assert.equal(first.response.status, 201);
|
|
assert.equal(first.body.data.reused, false);
|
|
assert.equal(first.body.data.collection_item.status, 'ready_for_edit');
|
|
assert.equal(first.body.data.materialization.pending_selection, 1);
|
|
assert.equal(first.body.data.materialization.queued, 0);
|
|
const platforms = await request('/api/platforms', {
|
|
headers: { Authorization: `Bearer ${webAccessToken}` },
|
|
});
|
|
const targetPlatform = platforms.body.data.find(
|
|
(platform: { code: string }) => platform.code === 'OZON',
|
|
);
|
|
assert.ok(targetPlatform);
|
|
await database.workspaceTransaction(workspaceId, async (tx) => {
|
|
await tx.query(
|
|
`INSERT INTO atlas.stores
|
|
(workspace_id, platform_id, name, platform_client_id, currency_code,
|
|
is_default, status, credential_status)
|
|
VALUES (current_setting('app.workspace_id')::uuid, $1, '复采测试店铺',
|
|
$2, 'RUB', true, 'active', 'valid')`,
|
|
[targetPlatform.id, `refresh-${randomUUID()}`],
|
|
);
|
|
});
|
|
const editorContext = await request(
|
|
`/api/collection-items/${first.body.data.collection_item.id}/editor-contexts`,
|
|
{
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${webAccessToken}`,
|
|
'X-Atlas-Platform-Id': targetPlatform.id,
|
|
'Idempotency-Key': randomUUID(),
|
|
},
|
|
},
|
|
);
|
|
assert.equal(editorContext.response.status, 201);
|
|
// Simulate real draft work before the source page is collected again.
|
|
// Re-collection must neither delete this SKU nor overwrite its Atlas
|
|
// fields / platform mapping just because a newer source snapshot arrives.
|
|
await database.workspaceTransaction(workspaceId, async (tx) => {
|
|
const variant = await tx.query<{ id: string }>(
|
|
`SELECT id FROM atlas.product_variants
|
|
WHERE product_id = $1 AND source_variant_key = '123456789'`,
|
|
[first.body.data.product_id],
|
|
);
|
|
await tx.query(
|
|
`UPDATE atlas.products SET source_title = '人工确认商品名'
|
|
WHERE id = $1`,
|
|
[first.body.data.product_id],
|
|
);
|
|
await tx.query(
|
|
`UPDATE atlas.product_variants
|
|
SET display_name = '人工确认 SKU', purchase_cost_cny = '88.80'
|
|
WHERE id = $1`,
|
|
[variant.rows[0].id],
|
|
);
|
|
await tx.query(
|
|
`UPDATE atlas.product_variant_platform_listings
|
|
SET offer_id = 'manual-offer-001'
|
|
WHERE product_variant_id = $1`,
|
|
[variant.rows[0].id],
|
|
);
|
|
});
|
|
// A sibling Ozon URL has a different entered SKU. It must still reuse
|
|
// the item because the submitted real-SKU sets overlap at 123456789.
|
|
const refreshedPayload = {
|
|
...payload,
|
|
source: {
|
|
...payload.source,
|
|
itemKey: '987654321',
|
|
canonicalUrl: 'https://www.ozon.ru/product/demo-987654321/',
|
|
collectedAt: new Date(Date.now() + 1_000).toISOString(),
|
|
parserVersion: 'test-2',
|
|
},
|
|
common: {
|
|
...payload.common,
|
|
title: {
|
|
value: '第二次采集的中文标题',
|
|
confidence: 'verified',
|
|
},
|
|
sourcePrice: { amount: '109.90', currencyCode: 'RUB' },
|
|
},
|
|
variants: [
|
|
{
|
|
sourceVariantKey: '123456789',
|
|
sourceSku: '123456789',
|
|
displayName: '第一 SKU',
|
|
selections: [],
|
|
confidence: 'verified',
|
|
evidenceRefs: ['page'],
|
|
},
|
|
{
|
|
sourceVariantKey: '987654321',
|
|
sourceSku: '987654321',
|
|
displayName: '第二次采集 SKU',
|
|
selections: [],
|
|
confidence: 'verified',
|
|
evidenceRefs: ['page'],
|
|
},
|
|
],
|
|
assets: [
|
|
{
|
|
url: 'https://images.example.test/refreshed-product.jpg',
|
|
role: 'source_main',
|
|
relation: 'product_candidate',
|
|
sortOrder: 0,
|
|
evidenceRef: 'page',
|
|
},
|
|
{
|
|
url: 'https://videos.example.test/refreshed-product.mp4',
|
|
mediaType: 'video',
|
|
posterUrl:
|
|
'https://images.example.test/refreshed-video-poster.jpg',
|
|
role: 'source_main',
|
|
relation: 'product_candidate',
|
|
sortOrder: 1,
|
|
evidenceRef: 'page',
|
|
},
|
|
],
|
|
};
|
|
const second = await request('/api/extension/materials', {
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${webAccessToken}`,
|
|
'Idempotency-Key': randomUUID(),
|
|
},
|
|
body: JSON.stringify(refreshedPayload),
|
|
});
|
|
assert.equal(second.response.status, 200);
|
|
assert.equal(second.body.data.reused, true);
|
|
assert.equal(second.body.data.refreshed, true);
|
|
assert.equal(
|
|
second.body.data.collection_item.id,
|
|
first.body.data.collection_item.id,
|
|
);
|
|
assert.equal(second.body.data.materialization.pending_selection, 2);
|
|
assert.equal(second.body.data.materialization.queued, 0);
|
|
const editorAfterRefresh = await request(
|
|
`/api/products/${first.body.data.product_id}/editor`,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${webAccessToken}`,
|
|
'X-Atlas-Platform-Id': targetPlatform.id,
|
|
},
|
|
},
|
|
);
|
|
assert.equal(editorAfterRefresh.response.status, 200);
|
|
assert.equal(
|
|
editorAfterRefresh.body.data.product.common.source_title,
|
|
'人工确认商品名',
|
|
);
|
|
const originalVariant = editorAfterRefresh.body.data.variants.find(
|
|
(variant: { source_variant_key: string }) =>
|
|
variant.source_variant_key === '123456789',
|
|
);
|
|
assert.equal(originalVariant.display_name, '人工确认 SKU');
|
|
assert.equal(originalVariant.purchase_cost_cny, '88.8000');
|
|
assert.equal(originalVariant.listing.offer_id, 'manual-offer-001');
|
|
const discoveredVariant = editorAfterRefresh.body.data.variants.find(
|
|
(variant: { source_variant_key: string }) =>
|
|
variant.source_variant_key === '987654321',
|
|
);
|
|
assert.ok(discoveredVariant);
|
|
assert.equal(discoveredVariant.listing.status, 'not_listed');
|
|
const inspection = await request(
|
|
`/api/collection-items/${first.body.data.collection_item.id}`,
|
|
{ headers: { Authorization: `Bearer ${webAccessToken}` } },
|
|
);
|
|
assert.equal(inspection.response.status, 200);
|
|
assert.equal(inspection.body.data.title, '第二次采集的中文标题');
|
|
assert.equal(
|
|
inspection.body.data.normalized_payload.source.parserVersion,
|
|
'test-2',
|
|
);
|
|
assert.equal(inspection.body.data.variants.length, 2);
|
|
assert.deepEqual(
|
|
inspection.body.data.variants.map(
|
|
(variant: { source_variant_key: string }) =>
|
|
variant.source_variant_key,
|
|
),
|
|
['123456789', '987654321'],
|
|
);
|
|
assert.equal(inspection.body.data.asset_transfers.length, 2);
|
|
assert.equal(
|
|
inspection.body.data.asset_transfers[0].source_url,
|
|
'https://images.example.test/refreshed-product.jpg',
|
|
);
|
|
assert.equal(
|
|
inspection.body.data.asset_transfers[0].status,
|
|
'pending_selection',
|
|
);
|
|
const videoTransfer = inspection.body.data.asset_transfers.find(
|
|
(transfer: { media_type: string }) =>
|
|
transfer.media_type === 'video',
|
|
);
|
|
assert.equal(
|
|
videoTransfer?.source_url,
|
|
'https://videos.example.test/refreshed-product.mp4',
|
|
);
|
|
assert.equal(
|
|
videoTransfer?.poster_url,
|
|
'https://images.example.test/refreshed-video-poster.jpg',
|
|
);
|
|
const eventsBeforeSelection = await database.workspaceTransaction(
|
|
workspaceId,
|
|
async (tx) =>
|
|
tx.query<{ count: string }>(
|
|
`SELECT count(*)::text AS count FROM atlas.outbox_events
|
|
WHERE event_type = 'collection.assets.materialize.requested'
|
|
AND event_payload->>'collection_item_id' = $1`,
|
|
[first.body.data.collection_item.id],
|
|
),
|
|
);
|
|
assert.equal(eventsBeforeSelection.rows[0]?.count, '0');
|
|
const materialization = await request(
|
|
`/api/collection-items/${first.body.data.collection_item.id}/asset-materializations`,
|
|
{
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${webAccessToken}`,
|
|
'Idempotency-Key': randomUUID(),
|
|
},
|
|
body: JSON.stringify({
|
|
transfer_ids: [inspection.body.data.asset_transfers[0].id],
|
|
}),
|
|
},
|
|
);
|
|
assert.equal(materialization.response.status, 202);
|
|
const afterSelection = await request(
|
|
`/api/collection-items/${first.body.data.collection_item.id}`,
|
|
{ headers: { Authorization: `Bearer ${webAccessToken}` } },
|
|
);
|
|
assert.equal(afterSelection.response.status, 200);
|
|
assert.ok(
|
|
['queued', 'running', 'failed', 'succeeded'].includes(
|
|
afterSelection.body.data.asset_transfers[0].status,
|
|
),
|
|
);
|
|
const eventsAfterSelection = await database.workspaceTransaction(
|
|
workspaceId,
|
|
async (tx) =>
|
|
tx.query<{ count: string }>(
|
|
`SELECT count(*)::text AS count FROM atlas.outbox_events
|
|
WHERE event_type = 'collection.assets.materialize.requested'
|
|
AND event_payload->>'collection_item_id' = $1`,
|
|
[first.body.data.collection_item.id],
|
|
),
|
|
);
|
|
assert.equal(eventsAfterSelection.rows[0]?.count, '1');
|
|
const transferWorkspace = await database.workspaceTransaction(
|
|
workspaceId,
|
|
async (tx) =>
|
|
tx.query<{ workspace_id: string }>(
|
|
'SELECT workspace_id FROM atlas.collection_asset_transfers WHERE id = $1',
|
|
[inspection.body.data.asset_transfers[0].id],
|
|
),
|
|
);
|
|
assert.equal(transferWorkspace.rows[0]?.workspace_id, workspaceId);
|
|
});
|
|
});
|