435 lines
27 KiB
JavaScript
435 lines
27 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import { Script, createContext } from 'node:vm';
|
|
|
|
const read = name => JSON.parse(readFileSync(new URL(`../postman/${name}`, import.meta.url), 'utf8'));
|
|
const collection = read('gold-miner.postman_collection.json');
|
|
const template = read('gold-miner.postman_environment.json');
|
|
const requests = collection.item.flatMap(folder => folder.item);
|
|
const request = (folder, prefix) => {
|
|
const value = collection.item[folder - 1].item.find(item => item.name.startsWith(prefix));
|
|
assert.ok(value, `${folder}: ${prefix}`);
|
|
return value;
|
|
};
|
|
const script = (item, listen) => item.event.find(event => event.listen === listen)?.script.exec.join('\n') || '';
|
|
const copy = value => value === undefined ? value : JSON.parse(JSON.stringify(value));
|
|
const SKIP = Symbol('skip request');
|
|
|
|
// Executes the exported scripts without HTTP, Postman packages or real credentials.
|
|
function sandbox(values = {}) {
|
|
const env = new Map(template.values.map(({ key, value }) => [key, value]));
|
|
Object.entries({ baseUrl: 'https://test.invalid', uid: 'test-user', token: 'test-token', ...values })
|
|
.forEach(([key, value]) => env.set(key, String(value)));
|
|
let local = new Map(), counter = 0, response = {}, responseStatus = 200, failures = [];
|
|
const replace = value => value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
|
|
if (key === '$guid') return `00000000-0000-4000-8000-${String(++counter).padStart(12, '0')}`;
|
|
assert.ok(local.has(key) || env.has(key), `unresolved variable: ${key}`);
|
|
return local.has(key) ? local.get(key) : env.get(key);
|
|
});
|
|
const pm = {
|
|
environment: { get: key => env.get(key), set: (key, value) => env.set(key, String(value)), unset: key => env.delete(key) },
|
|
variables: { get: key => local.get(key) ?? env.get(key), set: (key, value) => local.set(key, String(value)), replaceIn: replace },
|
|
execution: { skipRequest() { throw SKIP; } },
|
|
response: { json: () => copy(response), to: { have: { status: status => assert.equal(status, responseStatus) } } },
|
|
expect: actual => ({ to: { eql: expected => assert.deepEqual(copy(actual), copy(expected)) } }),
|
|
test(name, callback) { try { callback(); } catch (error) { failures.push(new Error(`${name}: ${error.message}`)); } },
|
|
};
|
|
function run(code) { new Script(code).runInContext(createContext({ pm, console: { error() { } } })); }
|
|
return {
|
|
env,
|
|
pre(item) {
|
|
local = new Map();
|
|
try {
|
|
run(script(collection, 'prerequest'));
|
|
run(script(item, 'prerequest'));
|
|
return { body: item.request.body ? JSON.parse(replace(item.request.body.raw)) : undefined };
|
|
} catch (error) { if (error === SKIP) return { skipped: true }; throw error; }
|
|
},
|
|
post(item, payload, status = 200) {
|
|
response = payload; responseStatus = status; failures = [];
|
|
run(script(item, 'test'));
|
|
if (failures.length) throw new AggregateError(failures, failures.map(error => error.message).join('\n'));
|
|
},
|
|
};
|
|
}
|
|
|
|
const periodId = 'goldMiner:2026-09-17';
|
|
const startsAt = Date.parse('2026-09-17T00:00:00+08:00');
|
|
function info(overrides = {}) {
|
|
const d = {
|
|
status: 'unlocked', periodId, startsAt, endsAt: startsAt + 4 * 86400000,
|
|
serverTime: startsAt + 1000, productId: 'gold_miner', priceFen: 123,
|
|
progressWins: 5, maxTarget: 5, ...overrides,
|
|
};
|
|
d.tasks = [3, 5].map((targetWins, index) => ({
|
|
taskId: `task_${index + 1}`, targetWins, itemsSnapshot: [{ type: 'coin', count: 50 }],
|
|
progress: Math.min(d.progressWins, targetWins), completed: d.progressWins >= targetWins,
|
|
claimStatus: d.progressWins >= targetWins ? d.status === 'unlocked' ? 'claimable' : 'pending_unlock' : 'locked',
|
|
}));
|
|
return d;
|
|
}
|
|
const success = data => ({ code: 1, data, msg: '成功' });
|
|
const grant = () => ({ grantId: 'grant-1', taskId: 'task_1', items: [{ type: 'coin', count: 50 }], claimStatus: 'issuing', claimedThrough: 0, requiresClientDelivery: true });
|
|
|
|
test('collection, environment and every script are well formed', () => {
|
|
assert.equal(collection.info.schema, 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json');
|
|
assert.equal(requests.length, 48);
|
|
assert.equal(new Set(template.values.map(value => value.key)).size, template.values.length);
|
|
for (const key of ['token', 'adminToken', 'gmWinBody', 'legacySessionFrom']) {
|
|
const value = template.values.find(value => value.key === key);
|
|
assert.equal(value.type, 'secret'); assert.equal(value.value, '');
|
|
}
|
|
for (const item of [collection, ...requests]) {
|
|
for (const event of item.event) new Script(event.script.exec.join('\n'), { filename: `${item.name || 'collection'}:${event.listen}` });
|
|
}
|
|
for (const item of requests) {
|
|
assert.ok(['POST', 'GET'].includes(item.request.method));
|
|
if (item.request.method === 'POST') {
|
|
assert.equal(item.request.body.mode, 'raw');
|
|
assert.equal(item.request.header[0].value, 'application/json');
|
|
} else {
|
|
assert.equal(item.request.url.raw, '{{baseUrl}}/activityConfig/list');
|
|
assert.equal(item.request.body, undefined);
|
|
}
|
|
assert.equal(item.request.url.raw, `{{baseUrl}}/${item.request.url.path.join('/')}`);
|
|
const functionName = item.request.url.path.join('/');
|
|
assert.ok(readFileSync(new URL(`../../${functionName}.ts`, import.meta.url), 'utf8').length > 0);
|
|
if (functionName.startsWith('goldMiner')) {
|
|
assert.ok(['goldMiner/index', 'goldMiner/admin', 'goldMiner/merchantNotify'].includes(functionName), 'activity requests must use the current public routes');
|
|
const yaml = readFileSync(new URL(`../../${functionName}.yaml`, import.meta.url), 'utf8');
|
|
assert.match(yaml, /^name: (.+)$/m);
|
|
assert.equal(yaml.match(/^name: (.+)$/m)[1].trim(), functionName);
|
|
assert.match(yaml, /^\s+- POST\s*$/m);
|
|
}
|
|
assert.ok(script(item, 'test').includes('pm.test('));
|
|
if (item.request.body && !item.request.body.raw.startsWith('{{')) JSON.parse(item.request.body.raw);
|
|
}
|
|
});
|
|
|
|
test('unconfigured application is skipped without producing a request', () => {
|
|
const s = sandbox({ baseUrl: 'https://<APPID>.laf.run' });
|
|
assert.deepEqual(s.pre(request(1, '01')), { skipped: true });
|
|
});
|
|
|
|
test('changing account clears grants, progress payload and selected targets', () => {
|
|
const s = sandbox(); s.pre(request(1, '01'));
|
|
for (const key of ['gmWinBody', 'gmGrant', 'grantId', 'gmSavedGrantId', 'claimPeriodId', 'claimTaskId', 'outTradeNo']) s.env.set(key, 'stale');
|
|
s.env.set('uid', 'another-user');
|
|
assert.deepEqual(s.pre(request(1, '01')), { skipped: true });
|
|
for (const key of ['gmWinBody', 'gmGrant', 'grantId', 'gmSavedGrantId', 'claimPeriodId', 'claimTaskId', 'outTradeNo']) assert.equal(s.env.get(key), undefined);
|
|
assert.equal(s.pre(request(1, '01')).body.uid, 'another-user');
|
|
});
|
|
|
|
test('active info enforces shared progress and independent task claimability', () => {
|
|
const s = sandbox(); const item = request(1, '01');
|
|
s.post(item, success(info()));
|
|
assert.equal(s.env.get('periodId'), periodId);
|
|
assert.equal(s.env.get('secondTaskId'), 'task_2');
|
|
const broken = info(); broken.tasks[1].claimStatus = 'locked';
|
|
assert.throws(() => s.post(item, success(broken)), /活动状态结构/);
|
|
});
|
|
|
|
test('locked and unavailable responses accept missing task/product fields', () => {
|
|
const s = sandbox(); const item = request(1, '01');
|
|
s.post(item, success(info()));
|
|
s.post(item, success({ status: 'locked', serverTime: startsAt, periodId, tasks: [] }));
|
|
assert.equal(s.env.get('productId'), undefined);
|
|
assert.equal(s.env.get('periodId'), periodId);
|
|
s.post(item, success({ status: 'unavailable', serverTime: startsAt, tasks: [] }));
|
|
assert.equal(s.env.get('periodId'), undefined);
|
|
});
|
|
|
|
test('carry opening assertions check unlocked status and reset progress without exposing source', () => {
|
|
const s = sandbox({ expectedStatus: 'unlocked', expectedProgressWins: '0' });
|
|
const d = info({ progressWins: 0 });
|
|
s.post(request(1, '01'), success(d));
|
|
d.status = 'purchasable';
|
|
assert.throws(() => s.post(request(1, '01'), success(d)), /活动状态结构/);
|
|
});
|
|
|
|
test('info scripts reject leaked fields and preserve issuing as the only pending task', () => {
|
|
const s = sandbox(); const item = request(1, '01');
|
|
const d = info(); d.tasks[0].claimStatus = 'issuing';
|
|
s.post(item, success(d));
|
|
d.tasks[0].grantId = 'internal';
|
|
assert.throws(() => s.post(item, success(d)), /活动状态结构/);
|
|
delete d.tasks[0].grantId; d.entitlement = { status: 'unlocked' };
|
|
assert.throws(() => s.post(item, success(d)), /活动状态结构/);
|
|
});
|
|
|
|
test('purchase disabled info permits progress but blocks native and customer preorders', () => {
|
|
const s = sandbox({ currentMainLevel: 41, mainLevelAfterWin: 42 });
|
|
s.post(request(1, '01'), success(info({ status: 'purchase_disabled', progressWins: 0 })));
|
|
assert.equal(s.pre(request(2, '01')).body.levelAmount, 42);
|
|
assert.deepEqual(s.pre(request(3, '01')), { skipped: true });
|
|
assert.deepEqual(s.pre(request(7, '01')), { skipped: true });
|
|
});
|
|
|
|
test('new win creates one payload, retry reuses it even after current period changes', () => {
|
|
const s = sandbox({ periodId, currentMainLevel: 41, mainLevelAfterWin: 42, gmInfo: JSON.stringify(info({ progressWins: 0 })) });
|
|
const first = s.pre(request(2, '01')).body;
|
|
assert.equal(first.levelAmount, 42); assert.equal(first.goldMiner.clearedMainLevel, 42);
|
|
s.post(request(2, '01'), success({ levelAmount: 42, goldMiner: { code: 1, activityCounted: true, duplicate: false, progressWins: 1 } }));
|
|
s.env.set('periodId', 'goldMiner:2026-09-24'); s.env.set('token', 'renewed-token');
|
|
const retried = s.pre(request(2, '03')).body;
|
|
assert.deepEqual(retried.goldMiner, first.goldMiner);
|
|
assert.equal(retried.token, 'renewed-token');
|
|
s.post(request(2, '03'), success({ goldMiner: { code: 1, activityCounted: false, duplicate: true, progressWins: 1 } }));
|
|
const conflict = s.pre(request(2, '04')).body;
|
|
assert.equal(conflict.goldMiner.eventId, first.goldMiner.eventId);
|
|
assert.equal(conflict.levelAmount, first.levelAmount);
|
|
assert.equal(conflict.goldMiner.clearedMainLevel, 43);
|
|
assert.deepEqual(JSON.parse(s.env.get('gmWinBody')), first);
|
|
});
|
|
|
|
test('progress tests inspect nested failure, not only successful save envelope', () => {
|
|
const s = sandbox({ gmWinBefore: 0 });
|
|
assert.throws(() => s.post(request(2, '01'), success({ goldMiner: { code: 0, errorCode: 'PERIOD_ENDED' } })), /活动子结果与计数/);
|
|
s.post(request(2, '05'), success({ goldMiner: { code: 0, errorCode: 'PERIOD_ENDED' } }));
|
|
assert.throws(() => s.post(request(2, '05'), success({ goldMiner: { code: 1, progressWins: 1 } })), /不补记过期进度/);
|
|
});
|
|
|
|
test('qualification and capped events assert no progress, endless preserves main save', () => {
|
|
const s = sandbox({ periodId, currentMainLevel: 40, mainLevelAfterWin: 41, expectedProgressResult: 'qualification', gmInfo: JSON.stringify({ status: 'locked', periodId }) });
|
|
assert.equal(s.pre(request(2, '01')).body.levelAmount, 41);
|
|
s.post(request(2, '01'), success({ levelAmount: 41, goldMiner: { code: 1, activityCounted: false, reason: 'qualification_level', progressWins: 0 } }));
|
|
s.env.set('expectedProgressResult', 'capped'); s.env.set('endlessSequence', '999');
|
|
s.env.set('gmInfo', JSON.stringify(info()));
|
|
const endless = s.pre(request(2, '02')).body;
|
|
assert.equal(endless.isWuXian, 'true'); assert.equal(endless.levelAmount, 41);
|
|
assert.equal(endless.goldMiner.endlessSequence, 999);
|
|
s.post(request(2, '02'), success({ levelAmount: 41, goldMiner: { code: 1, activityCounted: false, duplicate: false, progressWins: 5 } }));
|
|
s.env.set('mainLevelAfterWin', '42');
|
|
assert.deepEqual(s.pre(request(2, '02')), { skipped: true });
|
|
});
|
|
|
|
test('order creation captures snapshot pricing and reuses original order identity', () => {
|
|
const s = sandbox();
|
|
s.post(request(1, '01'), success(info({ status: 'purchasable' })));
|
|
const first = s.pre(request(3, '01')).body;
|
|
assert.equal(first.itemPrice, 1); assert.equal(first.itemCount, 999);
|
|
s.post(request(3, '01'), success({ outTradeNo: 'order-1', signData: JSON.stringify({ productId: 'gold_miner', buyQuantity: 1, goodsPrice: 123, outTradeNo: 'order-1' }), signature: 'signature', paySig: 'paySig' }));
|
|
const retry = s.pre(request(3, '03')).body;
|
|
assert.notEqual(first.createRequestId, retry.createRequestId);
|
|
s.post(request(3, '03'), success({ outTradeNo: 'order-1' }));
|
|
assert.throws(() => s.post(request(3, '03'), success({ outTradeNo: 'order-2' })), /复用原订单/);
|
|
});
|
|
|
|
test('payment assertions distinguish pending, paid and late-payment routes', () => {
|
|
const s = sandbox({ outTradeNo: 'order-1' });
|
|
const items = collection.item[2].item.filter(item => item.name.startsWith('查单'));
|
|
for (const item of items) {
|
|
assert.equal(s.pre(item).body.outTradeNo, 'order-1');
|
|
s.post(item, { code: 0, errorCode: 'PAYMENT_PENDING' });
|
|
assert.throws(() => s.post(item, success({ pay_state: 2 })), /查单匹配指定状态/);
|
|
}
|
|
s.env.set('expectedPaymentState', 'paid');
|
|
assert.deepEqual(s.pre(items[0]), { skipped: true });
|
|
s.env.set('expectedTargetPeriodId', 'goldMiner:2026-09-24'); s.env.set('expectedFulfillmentRoute', 'carry_next');
|
|
const paid = success({ pay_state: 2, rewardDelivery: 'goldMiner.claim', goldMiner: { fulfillmentStatus: 'fulfilled', fulfillmentRoute: 'carry_next', targetPeriodId: 'goldMiner:2026-09-24' } });
|
|
for (const item of items) s.post(item, paid);
|
|
paid.data.goldMiner.targetPeriodId = periodId;
|
|
assert.throws(() => s.post(items[0], paid), /查单匹配指定状态/);
|
|
});
|
|
|
|
test('claim-save-confirm chain forbids premature confirmation and duplicate credit', () => {
|
|
const s = sandbox({ claimPeriodId: periodId, claimTaskId: 'task_1' });
|
|
s.pre(request(4, '01')); s.post(request(4, '01'), success(grant()));
|
|
assert.deepEqual(s.pre(request(4, '05')), { skipped: true });
|
|
s.post(request(4, '02'), success(grant()));
|
|
assert.throws(() => s.post(request(4, '02'), success({ ...grant(), grantId: 'grant-2' })), /重复领取无新奖励凭证/);
|
|
s.post(request(4, '03'), success({ coinAmount: 100 }));
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
s.env.set('coinAfterDelivery', '149');
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
s.env.set('coinAfterDelivery', '150');
|
|
assert.equal(s.pre(request(4, '04')).body.coinAmount, '150');
|
|
s.post(request(4, '04'), success({ coinAmount: 150 }));
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
assert.equal(s.pre(request(4, '05')).body.grantId, 'grant-1');
|
|
s.post(request(4, '05'), success({ grantId: 'grant-1', claimStatus: 'claimed', claimedThrough: 1 }));
|
|
s.pre(request(4, '05')); s.post(request(4, '05'), success({ grantId: 'grant-1', claimStatus: 'claimed', claimedThrough: 1 }));
|
|
assert.throws(() => s.post(request(4, '05'), success({ grantId: 'wrong-grant', claimStatus: 'claimed', claimedThrough: 2 })), /确认同一凭证/);
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
});
|
|
|
|
test('failed coin save cannot enable delivery confirmation', () => {
|
|
const s = sandbox({ claimPeriodId: periodId, claimTaskId: 'task_1' });
|
|
s.pre(request(4, '01')); s.post(request(4, '01'), success(grant()));
|
|
assert.throws(() => s.post(request(4, '04'), { code: 0, data: null }), /业务成功/);
|
|
assert.equal(s.env.get('gmSavedGrantId'), undefined);
|
|
assert.deepEqual(s.pre(request(4, '05')), { skipped: true });
|
|
});
|
|
|
|
test('selected historical task cannot use another task grant', () => {
|
|
const s = sandbox({ claimPeriodId: periodId, claimTaskId: 'task_1' });
|
|
s.pre(request(4, '01')); s.post(request(4, '01'), success(grant()));
|
|
s.env.set('claimTaskId', 'task_2');
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
assert.deepEqual(s.pre(request(4, '05')), { skipped: true });
|
|
});
|
|
|
|
test('empty settlement page retains cursor; terminal page blocks further requests', () => {
|
|
const s = sandbox();
|
|
s.post(request(5, '01'), success({ status: 'pending_delivery', items: [], nextCursor: 'history-cursor' }));
|
|
assert.equal(s.pre(request(5, '02')).body.afterId, 'history-cursor');
|
|
s.post(request(5, '02'), success({ status: 'pending_delivery', items: [], nextCursor: null }));
|
|
assert.deepEqual(s.pre(request(5, '02')), { skipped: true });
|
|
});
|
|
|
|
test('admin publication blocks blank commercial values; purchase flag is a JSON boolean', () => {
|
|
const s = sandbox({ adminToken: 'test-admin', adminPeriodId: periodId });
|
|
assert.deepEqual(s.pre(request(6, '02')), { skipped: true });
|
|
s.env.set('configJson', JSON.stringify({ priceFen: null, tasks: [] }));
|
|
assert.deepEqual(s.pre(request(6, '02')), { skipped: true });
|
|
s.env.set('configJson', JSON.stringify({ configVersion: 'test-v1', priceFen: 123, tasks: [{ taskId: 'test' }] }));
|
|
assert.equal(s.pre(request(6, '02')).body.config.priceFen, 123);
|
|
assert.deepEqual(s.pre(request(6, '03')), { skipped: true });
|
|
s.env.set('purchaseEnabled', 'false');
|
|
assert.equal(s.pre(request(6, '03')).body.purchaseEnabled, false);
|
|
});
|
|
|
|
|
|
test('legacy collection preserves scoped session ticket and gates real customer messages', () => {
|
|
const s = sandbox({ openid: 'openid' });
|
|
s.pre(request(1, '01'));
|
|
s.post(request(1, '01'), success(info({ status: 'purchasable' })));
|
|
assert.equal(s.pre(request(7, '01')).body.channel, 'legacy_ios');
|
|
const data = {
|
|
outTradeNo: 'order-1', periodId, priceFen: 123, productId: 'gold_miner', quantity: 1, channel: 'legacy_ios',
|
|
sessionFrom: JSON.stringify({ outTradeNo: 'order-1', propName: 'gold_miner', goldMinerTicket: 'scoped-ticket' })
|
|
};
|
|
s.post(request(7, '01'), success(data));
|
|
s.pre(request(7, '02')); s.post(request(7, '02'), success(data));
|
|
assert.throws(() => s.post(request(7, '02'), success({ ...data, outTradeNo: 'different' })), /复用原订单/);
|
|
assert.deepEqual(s.pre(request(7, '03')), { skipped: true });
|
|
s.env.set('allowCustomerMessage', 'true');
|
|
const sent = s.pre(request(7, '03')).body;
|
|
assert.equal(sent.SessionFrom, data.sessionFrom);
|
|
assert.equal(sent.FromUserName, 'openid'); assert.equal(sent.token, undefined);
|
|
s.post(request(7, '04'), true); assert.throws(() => s.post(request(7, '04'), { code: 0 }));
|
|
s.post(request(7, '05'), false); s.post(request(7, '06'), { code: 'FAIL' }, 500);
|
|
s.post(request(7, '07'), { code: 0, errorCode: 'PAYMENT_CHANNEL_CONFLICT' });
|
|
s.env.set('uid', 'other'); assert.deepEqual(s.pre(request(1, '01')), { skipped: true });
|
|
assert.equal(s.env.get('legacySessionFrom'), undefined); assert.equal(s.env.get('allowCustomerMessage'), undefined);
|
|
});
|
|
|
|
|
|
test('settling pages advance the cursor and settlement delivery uses original grant without claim', () => {
|
|
const s = sandbox({ settlementCursor: 'history-cursor' });
|
|
s.post(request(5, '02'), success({ status: 'settling', items: [], nextCursor: 'next-history-cursor' }));
|
|
assert.equal(s.pre(request(5, '02')).body.afterId, 'next-history-cursor');
|
|
s.post(request(5, '02'), success({ status: 'settling', items: [], nextCursor: null }));
|
|
assert.deepEqual(s.pre(request(5, '02')), { skipped: true });
|
|
assert.equal(s.pre(request(5, '01')).body.afterId, undefined);
|
|
s.post(request(5, '05'), success({ status: 'pending_delivery', items: [{ settlementId: 'settlement-1', periodId, rewards: [{ taskId: 'task_1', grantId: 'grant-1', items: [{ type: 'coin', count: 50 }] }] }], nextCursor: null }));
|
|
assert.equal(s.env.get('grantId'), 'grant-1');
|
|
assert.deepEqual(s.pre(request(5, '06')), { skipped: true });
|
|
s.post(request(4, '03'), success({ coinAmount: 100 })); s.env.set('coinAfterDelivery', '150');
|
|
assert.equal(s.pre(request(4, '04')).body.coinAmount, '150');
|
|
s.post(request(4, '04'), success({ coinAmount: 150 }));
|
|
const body = s.pre(request(5, '06')).body; assert.equal(body.action, 'confirm_settlement_delivery');
|
|
assert.deepEqual(body.grantIds, ['grant-1']); assert.equal(body.settlementId, 'settlement-1');
|
|
s.post(request(5, '06'), success({ settlementId: 'settlement-1', confirmedGrantIds: ['grant-1'], deliveryStatus: 'client_saved' }));
|
|
assert.deepEqual(s.pre(request(4, '04')), { skipped: true });
|
|
});
|
|
|
|
test('settlement collection omits client limits and accepts only globally empty no_pending_rewards responses', () => {
|
|
const s = sandbox();
|
|
for (const prefix of ['01', '05']) {
|
|
assert.equal(s.pre(request(5, prefix)).body.limit, undefined);
|
|
s.post(request(5, prefix), success({ status: 'no_pending_rewards', items: [], nextCursor: null }));
|
|
assert.equal(s.env.get('settlementCursor'), '');
|
|
assert.throws(() => s.post(request(5, prefix), success({ status: 'no_pending_rewards', items: [], nextCursor: 'next' })));
|
|
assert.throws(() => s.post(request(5, prefix), success({ status: 'no_pending_rewards', items: [{}], nextCursor: null })));
|
|
}
|
|
assert.deepEqual(s.pre(request(5, '02')), { skipped: true });
|
|
const negative = s.pre(request(1, '06')).body;
|
|
assert.equal(negative.limit, undefined); assert.equal(negative.afterId, 42);
|
|
});
|
|
|
|
test('temporary info accepts custom duration while weekly info still enforces the normal calendar', () => {
|
|
const s = sandbox(), d = info({ periodId: 'goldMiner:test:short', endsAt: startsAt + 1800000 });
|
|
s.post(request(1, '01'), success(d)); assert.equal(s.env.get('periodId'), d.periodId);
|
|
assert.throws(() => s.post(request(1, '01'), success({ ...d, periodId })), /活动状态结构/);
|
|
assert.throws(() => s.post(request(1, '01'), success({ ...d, serverTime: d.endsAt })), /活动状态结构/);
|
|
});
|
|
|
|
const schedule = (activities = []) => ({
|
|
schemaVersion: 1, serverNow: startsAt + 1000, windowEndsAt: startsAt + 1000 + 7 * 86400000,
|
|
refreshAt: Math.min(startsAt + 31000, ...activities.flatMap(a => [a.startsAt, a.endsAt]).filter(t => t > startsAt + 1000)), activities
|
|
});
|
|
const scheduleEntry = (extra = {}) => ({
|
|
activityId: 'goldMiner', periodId: 'goldMiner:test:short', configVersion: 'v1', startsAt,
|
|
endsAt: startsAt + 10000, unlockLevel: 41, phase: 'active', purchaseEnabled: true, ...extra
|
|
});
|
|
|
|
test('public schedule GET and POST require no login and do not overwrite player period or grant', () => {
|
|
const s = sandbox({ uid: '', token: '', adminToken: '', periodId: 'player-period', grantId: 'original-grant' });
|
|
assert.deepEqual(s.pre(request(8, '01')), { body: undefined }); assert.deepEqual(s.pre(request(8, '02')), { body: {} });
|
|
for (const item of collection.item[7].item) {
|
|
s.post(item, success(schedule([scheduleEntry()])));
|
|
assert.equal(s.env.get('periodId'), 'player-period'); assert.equal(s.env.get('grantId'), 'original-grant');
|
|
assert.equal(JSON.parse(s.env.get('gmActivitySchedule')).activities[0].periodId, 'goldMiner:test:short');
|
|
}
|
|
const yaml = readFileSync(new URL('../../activityConfig/list.yaml', import.meta.url), 'utf8');
|
|
assert.match(yaml, /^\s+- GET\s*$/m); assert.match(yaml, /^\s+- POST\s*$/m);
|
|
});
|
|
|
|
test('schedule accepts empty lists and cloudRise upcoming entries; errors preserve cached success', () => {
|
|
const s = sandbox(), item = request(8, '01'); s.post(item, success(schedule()));
|
|
assert.deepEqual(JSON.parse(s.env.get('gmActivitySchedule')).activities, []);
|
|
const cloud = { activityId: 'cloudRise', periodId: 'race', configVersion: 'v1', startsAt: startsAt + 5000, endsAt: startsAt + 60000, unlockLevel: 100, phase: 'upcoming' };
|
|
const d = schedule([cloud, scheduleEntry()]); s.post(item, success(d));
|
|
const cached = s.env.get('gmActivitySchedule');
|
|
assert.throws(() => s.post(item, { code: 0, data: null, msg: '数据库暂不可用' }), /公共日程查询成功/);
|
|
assert.equal(s.env.get('gmActivitySchedule'), cached);
|
|
assert.throws(() => s.post(item, success({ ...d, refreshAt: d.serverNow + 30000 })), /公共日程字段/);
|
|
assert.equal(s.env.get('gmActivitySchedule'), cached);
|
|
assert.throws(() => s.post(item, success(schedule([scheduleEntry({ tasks: [] })]))), /公共日程字段/);
|
|
assert.throws(() => s.post(item, success(schedule([scheduleEntry(), cloud]))), /公共日程字段/);
|
|
s.env.set('expectedListedPeriodId', 'missing'); assert.throws(() => s.post(item, success(d)), /公共日程字段/);
|
|
s.env.set('expectedListedPeriodId', 'goldMiner:test:short'); s.post(item, success(d));
|
|
});
|
|
|
|
test('integrated temporary publisher reuses the same draft and validates immutable response', () => {
|
|
const s = sandbox({ adminToken: 'admin-test' }), item = request(6, '04'); const first = s.pre(item).body;
|
|
assert.equal(first.action, 'publish_test_period'); assert.equal(first.endsAt - first.startsAt, 1800000);
|
|
assert.match(first.periodId, /^goldMiner:test:/); assert.deepEqual(s.pre(item).body, first);
|
|
assert.equal(s.env.get('tempPeriodId'), first.periodId); assert.equal(s.env.get('testPeriodRequestBody'), undefined);
|
|
const result = {
|
|
periodId: first.periodId, startsAt: first.startsAt, endsAt: first.endsAt, nextStartsAt: first.endsAt + 1000,
|
|
configHash: 'hash', configSnapshot: { ...first.config, effectiveFromPeriodId: first.periodId }
|
|
};
|
|
s.post(item, success(result)); assert.throws(() => s.post(item, success({ ...result, endsAt: first.endsAt + 1 })), /时间与请求一致/);
|
|
const standalone = read('gold-miner-test-period.postman_collection.json').item[0];
|
|
assert.equal(script(item, 'prerequest'), script(standalone, 'prerequest')); assert.equal(script(item, 'test'), script(standalone, 'test'));
|
|
});
|
|
|
|
test('public cached schedule is cleared when switching deployment context', () => {
|
|
const s = sandbox(); s.pre(request(8, '01')); s.post(request(8, '01'), success(schedule()));
|
|
s.env.set('baseUrl', 'https://another.invalid'); assert.deepEqual(s.pre(request(8, '01')), { skipped: true });
|
|
assert.equal(s.env.get('gmActivitySchedule'), undefined); assert.deepEqual(s.pre(request(8, '01')), { body: undefined });
|
|
});
|
|
|
|
|
|
test('VIP Postman publication and pending-unlock display match the six-tier protocol', () => {
|
|
const config = JSON.parse(readFileSync(new URL('../vip-tiers.example.json', import.meta.url), 'utf8')).config;
|
|
const s = sandbox({ adminToken: 'admin-test', configJson: JSON.stringify(config) });
|
|
assert.deepEqual(s.pre(request(6, '02')).body.config, config);
|
|
s.post(request(6, '02'), success(config));
|
|
const unpaid = info({ status: 'purchasable', vipLevel: 0, priceFen: 300, productId: 'gold_miner_vip0' });
|
|
s.post(request(1, '01'), success(unpaid));
|
|
assert.ok(unpaid.tasks.every(t => t.claimStatus === 'pending_unlock'));
|
|
assert.equal(s.env.get('productId'), 'gold_miner_vip0');
|
|
const broken = copy(unpaid); broken.tasks[0].claimStatus = 'claimable';
|
|
assert.throws(() => s.post(request(1, '01'), success(broken)), /活动状态结构/);
|
|
// Independent tasks can all be ready, including with progress beyond the selected tier's cap.
|
|
s.post(request(1, '01'), success(info({ vipLevel: 1, progressWins: 61 })));
|
|
s.env.set('claimPeriodId', periodId); s.env.set('claimTaskId', 'task_2');
|
|
s.pre(request(4, '08')); s.post(request(4, '08'), success({ ...grant(), taskId: 'task_2' }));
|
|
assert.equal(s.env.get('claimTaskId'), 'task_2');
|
|
s.post(request(4, '05'), success({ grantId: 'grant-1', claimStatus: 'claimed', claimedThrough: 0 }));
|
|
});
|