259 lines
11 KiB
TypeScript
259 lines
11 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: string;
|
|
let token = '';
|
|
let workspaceId = '';
|
|
let userId = '';
|
|
let platformId = '';
|
|
let storeId = '';
|
|
let listingId = '';
|
|
let runId = '';
|
|
|
|
async function request(path: string, init: RequestInit = {}) {
|
|
const response = await fetch(`${baseUrl}${path}`, {
|
|
...init,
|
|
headers: { 'Content-Type': 'application/json', ...init.headers },
|
|
});
|
|
return { response, body: (await response.json()) as Record<string, any> };
|
|
}
|
|
|
|
function auth(extra: Record<string, string> = {}) {
|
|
return {
|
|
Authorization: `Bearer ${token}`,
|
|
'X-Atlas-Platform-Id': platformId,
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
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}`;
|
|
const registered = await request('/api/auth/register', {
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
email: `online-${randomUUID()}@example.test`,
|
|
password: 'correct-horse-battery-staple-123',
|
|
password_confirmation: 'correct-horse-battery-staple-123',
|
|
}),
|
|
});
|
|
assert.equal(registered.response.status, 201);
|
|
token = registered.body.data.access_token;
|
|
workspaceId = registered.body.data.workspace.id;
|
|
userId = registered.body.data.user.id;
|
|
const platforms = await request('/api/platforms', {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
platformId = platforms.body.data.find(
|
|
(platform: { code: string }) => platform.code === 'OZON',
|
|
).id;
|
|
storeId = randomUUID();
|
|
await database.workspaceTransaction(workspaceId, async (tx) => {
|
|
await tx.query(
|
|
`INSERT INTO atlas.stores (id, workspace_id, platform_id, name, platform_client_id, currency_code, is_default, status, credential_status)
|
|
VALUES ($1, $2, $3, '测试门店', $4, 'RUB', true, 'active', 'valid')`,
|
|
[storeId, workspaceId, platformId, `online-http-${storeId}`],
|
|
);
|
|
const run = await tx.query<{ id: string }>(
|
|
`INSERT INTO atlas.platform_product_sync_runs
|
|
(workspace_id, store_id, platform_id, trigger_source, status, completed_at)
|
|
VALUES ($1, $2, $3, 'manual', 'succeeded', now()) RETURNING id`,
|
|
[workspaceId, storeId, platformId],
|
|
);
|
|
runId = run.rows[0].id;
|
|
const listing = await tx.query<{ id: string }>(
|
|
`INSERT INTO atlas.platform_listings
|
|
(workspace_id, store_id, platform_id, remote_product_id, offer_id, remote_sku, name,
|
|
currency_code, selling_price, visible, moderation_status, stock_summary,
|
|
image_summary, source, last_sync_run_id, last_synced_at, raw_payload)
|
|
VALUES ($1, $2, $3, '123456', 'test-offer', '654321', '测试商品',
|
|
'RUB', 99, true, 'approved', '{"total":0,"has_data":true}',
|
|
'{"url":null,"width_px":null,"height_px":null}', 'external_sync', $4, now(), '{}') RETURNING id`,
|
|
[workspaceId, storeId, platformId, runId],
|
|
);
|
|
listingId = listing.rows[0].id;
|
|
await tx.query(
|
|
`INSERT INTO atlas.platform_listings
|
|
(workspace_id, store_id, platform_id, remote_product_id, offer_id, name,
|
|
visible, stock_summary, image_summary, source, last_sync_run_id, last_synced_at,
|
|
missing_since, archived_at, raw_payload)
|
|
VALUES ($1, $2, $3, '123457', 'archived-offer', '归档商品',
|
|
NULL, '{"total":0,"has_data":false}', '{}', 'external_sync', $4,
|
|
now(), now() - interval '8 days', now(), '{}')`,
|
|
[workspaceId, storeId, platformId, runId],
|
|
);
|
|
});
|
|
});
|
|
|
|
afterAll(async () => {
|
|
if (workspaceId && database) {
|
|
await database.workspaceTransaction(workspaceId, async (tx) => {
|
|
await tx.query(
|
|
'DELETE FROM atlas.platform_listing_sync_snapshots WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.platform_listings WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.platform_product_sync_runs WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
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.store_secrets WHERE workspace_id = $1',
|
|
[workspaceId],
|
|
);
|
|
await tx.query(
|
|
'DELETE FROM atlas.stores 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,
|
|
]);
|
|
}
|
|
if (app) await app.close();
|
|
});
|
|
|
|
it('列表、详情与同步历史按平台店铺返回镜像，不返回原始响应', async () => {
|
|
const listed = await request(
|
|
`/api/platform-listings?store_id=${storeId}&q=test-offer`,
|
|
{ headers: auth() },
|
|
);
|
|
assert.equal(listed.response.status, 200);
|
|
assert.equal(listed.body.data.length, 1);
|
|
assert.equal(listed.body.data[0].visible, true);
|
|
assert.equal(listed.body.data[0].selling_price, '99.00');
|
|
assert.deepEqual(listed.body.data[0].stock_summary, {
|
|
total: 0,
|
|
has_data: true,
|
|
});
|
|
assert.equal(listed.body.meta.store.id, storeId);
|
|
assert.equal(listed.body.meta.last_sync_status, 'succeeded');
|
|
assert.equal('raw_payload' in listed.body.data[0], false);
|
|
const detail = await request(`/api/platform-listings/${listingId}`, {
|
|
headers: auth(),
|
|
});
|
|
assert.equal(detail.response.status, 200);
|
|
assert.equal(detail.body.data.offer_id, 'test-offer');
|
|
const runs = await request(
|
|
`/api/stores/${storeId}/platform-product-sync-runs`,
|
|
{ headers: auth() },
|
|
);
|
|
assert.equal(runs.response.status, 200);
|
|
assert.equal(runs.body.data[0].id, runId);
|
|
const run = await request(`/api/platform-product-sync-runs/${runId}`, {
|
|
headers: auth(),
|
|
});
|
|
assert.equal(run.response.status, 200);
|
|
assert.equal(run.body.data.status, 'succeeded');
|
|
});
|
|
|
|
it('筛选未知可见性与缺少平台头的请求按契约处理', async () => {
|
|
const unknown = await request(
|
|
`/api/platform-listings?store_id=${storeId}&visibility=unknown`,
|
|
{ headers: auth() },
|
|
);
|
|
assert.equal(unknown.response.status, 200);
|
|
assert.equal(unknown.body.data.length, 0);
|
|
const archived = await request(
|
|
`/api/platform-listings?store_id=${storeId}&visibility=unknown&include_archived=true`,
|
|
{ headers: auth() },
|
|
);
|
|
assert.equal(archived.response.status, 200);
|
|
assert.equal(archived.body.data.length, 1);
|
|
assert.equal(archived.body.data[0].offer_id, 'archived-offer');
|
|
const missingHeader = await request('/api/platform-listings', {
|
|
headers: { Authorization: `Bearer ${token}` },
|
|
});
|
|
assert.equal(missingHeader.response.status, 400);
|
|
assert.equal(
|
|
missingHeader.body.error.code,
|
|
'PLATFORM_CONTEXT_REQUIRED',
|
|
);
|
|
const noCredentials = await request(
|
|
`/api/stores/${storeId}/platform-product-sync-runs`,
|
|
{
|
|
method: 'POST',
|
|
headers: auth({ 'Idempotency-Key': randomUUID() }),
|
|
body: JSON.stringify({ reason: 'manual_refresh' }),
|
|
},
|
|
);
|
|
assert.equal(noCredentials.response.status, 422);
|
|
assert.equal(
|
|
noCredentials.body.error.code,
|
|
'STORE_CREDENTIAL_UNAVAILABLE',
|
|
);
|
|
});
|
|
|
|
it('触发同步写入 Outbox，同一幂等键复用任务，并发请求返回冲突', async () => {
|
|
await database.workspaceTransaction(workspaceId, (tx) =>
|
|
tx.query(
|
|
`INSERT INTO atlas.store_secrets
|
|
(workspace_id, store_id, kind, secret_ciphertext, secret_nonce,
|
|
encryption_key_version, fingerprint, status)
|
|
VALUES ($1, $2, 'seller_api_key', $3, $4, 'v1', $5, 'valid')`,
|
|
[workspaceId, storeId, Buffer.alloc(32), Buffer.alloc(12), randomUUID()],
|
|
),
|
|
);
|
|
const key = randomUUID();
|
|
const post = (idempotencyKey: string) =>
|
|
request(`/api/stores/${storeId}/platform-product-sync-runs`, {
|
|
method: 'POST',
|
|
headers: auth({ 'Idempotency-Key': idempotencyKey }),
|
|
body: JSON.stringify({ reason: 'manual_refresh' }),
|
|
});
|
|
const created = await post(key);
|
|
assert.equal(created.response.status, 202);
|
|
assert.equal(created.body.data.sync_run.status, 'queued');
|
|
const repeated = await post(key);
|
|
assert.equal(repeated.response.status, 202);
|
|
assert.equal(repeated.body.data.sync_run.id, created.body.data.sync_run.id);
|
|
const concurrent = await post(randomUUID());
|
|
assert.equal(concurrent.response.status, 409);
|
|
assert.equal(concurrent.body.error.code, 'SYNC_ALREADY_RUNNING');
|
|
const events = await database.workspaceTransaction(workspaceId, (tx) =>
|
|
tx.query<{ count: string }>(
|
|
`SELECT count(*)::text AS count FROM atlas.outbox_events
|
|
WHERE aggregate_id = $1 AND event_type = 'platform_product_sync.requested'`,
|
|
[created.body.data.sync_run.id],
|
|
),
|
|
);
|
|
assert.equal(events.rows[0].count, '1');
|
|
});
|
|
});
|