218 lines
16 KiB
JavaScript
218 lines
16 KiB
JavaScript
// In-memory payment responses only: no network, real payments or analytics sends.
|
|
const test = require('node:test'), assert = require('node:assert/strict');
|
|
const fs = require('node:fs'), path = require('node:path'), vm = require('node:vm'), ts = require('typescript');
|
|
const quiet = { log() {}, warn() {}, error() {} };
|
|
const compile = source => ts.transpileModule(source, { compilerOptions: { target: 7, module: 1, experimentalDecorators: true } }).outputText;
|
|
function load(file, dependencies, globals = {}) {
|
|
const context = { exports: {}, require: name => dependencies[name] || { default: {} }, console: quiet, ...globals };
|
|
vm.runInNewContext(compile(fs.readFileSync(file, 'utf8')), context);
|
|
return context.exports.default;
|
|
}
|
|
function methods(file, names) {
|
|
const source = ts.createSourceFile(file, fs.readFileSync(file, 'utf8'), 99, true);
|
|
return source.statements.find(ts.isClassDeclaration).members
|
|
.filter(m => m.name && names.includes(m.name.getText(source))).map(m => m.getText(source)).join('\n');
|
|
}
|
|
const pyramidContext = { require, __dirname, structuredClone, queueMicrotask, setTimeout, clearTimeout, console: quiet };
|
|
vm.runInNewContext(fs.readFileSync(path.join(__dirname, 'test-pyramid-client.cjs'), 'utf8')
|
|
.split("test('collect_pyramid reports")[0] + ';globalThis.makeFixture = fixture;', pyramidContext);
|
|
|
|
for (const channel of ['success', 'ios-success', 'fallback']) {
|
|
for (const scenario of ['immediate', 'retry', 'restart']) test(`Pyramid ${channel}: ${scenario} reports original order once`, async () => {
|
|
const f = pyramidContext.makeFixture();
|
|
f.state.canPay = true; f.state.canDraw = false; f.mode(channel); await f.S.sync();
|
|
if (scenario === 'immediate') f.paid();
|
|
await f.S.buy();
|
|
let service = f.S;
|
|
if (scenario !== 'immediate') {
|
|
assert.equal(f.payments.length, 0); assert.ok(service.data().pendingOrder);
|
|
f.state.levels[0].itemPrice = 9900; // A refreshed offer cannot change the old order's amount.
|
|
f.paid(); if (scenario === 'restart') service = f.restart(); await service.sync(true);
|
|
}
|
|
assert.equal(service.data().pendingOrder, null); assert.equal(f.payments.length, 1);
|
|
assert.deepEqual(Array.from(f.payments[0]), [100, f.calls.find(c => c.outTradeNo).outTradeNo, '购买金字塔:pay_test']);
|
|
await service.sync(true); await f.restart().sync(true); assert.equal(f.payments.length, 1);
|
|
});
|
|
}
|
|
test('Pyramid closed, cancelled and unconfirmed orders do not report', async () => {
|
|
for (const mode of ['cancel', 'success']) {
|
|
const f = pyramidContext.makeFixture(); f.state.canPay = true; f.mode(mode); await f.S.sync(); await f.S.buy();
|
|
assert.equal(f.payments.length, 0);
|
|
const post = f.U.POST;
|
|
f.U.POST = (route, body, cb, options) => body.action === 'query'
|
|
? cb({ code: 1, data: { paymentStatus: 'closed' } }) : post.call(f.U, route, body, cb, options);
|
|
await f.S.sync(true); assert.equal(f.payments.length, 0);
|
|
}
|
|
});
|
|
test('Pyramid legacy pending record uses server order metadata after period change', async () => {
|
|
const f = pyramidContext.makeFixture();
|
|
f.storage.set('pyramid:v1:local/:u', { confirmingOrder: { orderId: 'old', periodId: 'ended', level: 2 } });
|
|
const post = f.U.POST;
|
|
f.U.POST = (route, body, cb, options) => body.action === 'query'
|
|
? cb({ code: 1, data: { paymentStatus: 'succeeded', goodsPrice: '1800', itemCount: 1, itemid: 'old-product' } })
|
|
: post.call(f.U, route, body, cb, options);
|
|
await f.S.sync(); assert.deepEqual(Array.from(f.payments[0]), [1800, 'old', '购买金字塔:old-product']);
|
|
});
|
|
|
|
const { fixture: goldFixture } = require('./coin-madness/check-api.cjs');
|
|
for (const channel of ['android', 'ios', 'customer']) test(`GoldMiner ${channel} reports purchase and not a later refresh`, async () => {
|
|
const f = goldFixture(new Map(), { ios: channel !== 'android' });
|
|
f.client.iosPaymentLog = () => {};
|
|
if (channel === 'customer') f.game.iosCanPay = false;
|
|
f.info.status = 'purchasable';
|
|
assert.equal((await f.client.request('purchase', { periodId: f.periodId })).code, 1);
|
|
assert.equal(f.payments.length, 1); assert.equal(f.payments[0][0], 300);
|
|
assert.equal(f.payments[0][1], channel === 'customer' ? 'legacy-1' : 'order-1');
|
|
await f.client.refresh(); assert.equal(f.payments.length, 1);
|
|
});
|
|
test('GoldMiner restart reports legacy order from server price, not current activity price', async () => {
|
|
const storage = new Map(), first = goldFixture(storage);
|
|
first.client.ledger.orders.old = { outTradeNo: 'old-order', ios: false };
|
|
first.client.persist();
|
|
const f = goldFixture(storage, { intercept(route, body, ok) {
|
|
if (route.includes('getPayInfo')) {
|
|
ok({ pay_state: 2, goodsPrice: 1800, itemCount: 1, itemid: 'gold_miner_old',
|
|
rewardDelivery: 'goldMiner.claim', goldMiner: { fulfillmentRoute: 'carry_next', targetPeriodId: 'goldMiner:next' } });
|
|
return true;
|
|
}
|
|
} });
|
|
f.info.priceFen = 9900; await f.client.refresh();
|
|
assert.deepEqual(f.payments, [[1800, 'old-order', '购买金币狂热:gold_miner_old']]);
|
|
});
|
|
test('GoldMiner cancellation and pending confirmation do not report', async () => {
|
|
const cancelled = goldFixture(new Map(), { cancelPay: true }); cancelled.info.status = 'purchasable';
|
|
await cancelled.client.request('purchase', { periodId: cancelled.periodId }); assert.equal(cancelled.payments.length, 0);
|
|
const pending = goldFixture(new Map(), { intercept(route, body, ok, fail) {
|
|
if (route.includes('getPayInfo')) { fail('PAYMENT_PENDING'); return true; }
|
|
} });
|
|
await assert.rejects(pending.client.queryOrder({ outTradeNo: 'pending', ios: false }));
|
|
assert.equal(pending.payments.length, 0);
|
|
});
|
|
|
|
function passFixture(platform = 'android', direct = true) {
|
|
const payments = [], delivered = [], gm = { uid: 'u', iosCanPay: direct, allOutTradeNo: [] };
|
|
const check = { hasSchedule: () => true, reviewOrders: new Set(), syncClock() {} };
|
|
const utils = {
|
|
buyProp(a, b, c, d, e, cb) { cb({ outTradeNo: 'pass-order' }); },
|
|
getPayInfo(cb) { cb({ code: 1, data: { pay_state: 2 } }); },
|
|
GoKEFu(a, cb, created) { created('pass-order'); cb('success'); },
|
|
getIosPayInfo(a, cb) { cb({ code: 1 }); },
|
|
async completePassOrder(order) { delivered.push(order); return { data: { rewards: [] } }; },
|
|
async settlementRequest() { return { data: { serverTime: Date.now(), rows: [] } }; }
|
|
};
|
|
const sdk = { API: { yinli_Pay: (...args) => payments.push(args) } };
|
|
const View = load('assets/Script/BattlePassSettlement.ts', {
|
|
'./module/Pay/Utils': { default: utils }, './Sdk/MiniGameSdk': { MiniGameSdk: sdk },
|
|
'./module/Config/BattlePassSettlementCheck': { default: { forPlayer: () => check } },
|
|
'./module/Config/BattlePassSettlementModel': { settlementSteps: rows => rows }
|
|
}, { cc: { _decorator: { ccclass: T => T }, Component: class {}, isValid: () => true,
|
|
warn() {}, fx: { GameConfig: { GM_INFO: gm } } }, wx: { getSystemInfoSync: () => ({ platform }) } });
|
|
const view = new View(); view.root = {}; view.row = { offer: 'shown', end: 1 };
|
|
view.playRewards = (r, cb) => cb(); view.next = () => {}; view.finish = () => {}; view.isCurrentRun = () => true;
|
|
return { view, utils, payments, delivered, gm, sdk };
|
|
}
|
|
for (const [platform, direct] of [['android', true], ['ios', true], ['ios', false]]) {
|
|
test(`post-season pass ${platform}/${direct} reports the paid order`, async () => {
|
|
const f = passFixture(platform, direct); await f.view.purchase(); if (!direct) f.view.checkIos();
|
|
await new Promise(setImmediate);
|
|
assert.deepEqual(f.delivered, ['pass-order']);
|
|
assert.deepEqual(f.payments, [[1800, 'pass-order', '购买上期战令:battlepass']]);
|
|
});
|
|
}
|
|
for (const [itemid, price] of [['battlepass', 1800], ['battlepass_30', 3000], ['battlepass_12', 1200]]) {
|
|
test(`settlement recovery reports ${itemid} with its actual amount`, async () => {
|
|
const f = passFixture(); f.gm.allOutTradeNo = [{ outTradeNo: 'recovered', itemid, goodsPrice: String(price), itemCount: 1 }];
|
|
await f.view.run(() => {});
|
|
assert.deepEqual(f.payments, [[price, 'recovered', '补发充值成功' + itemid]]); assert.equal(f.gm.allOutTradeNo.length, 0);
|
|
});
|
|
test(`home recovery reports ${itemid} after fulfillment`, async () => {
|
|
const f = passFixture(); f.gm.allOutTradeNo = [{ outTradeNo: 'recovered', itemid, goodsPrice: String(price) }];
|
|
Object.assign(f.utils, { recoverJunglePayments() {}, getShopDouble(cb) { cb({ code: 1, data: { shopDouble: {} } }); } });
|
|
const context = { exports: {}, Utils: f.utils, MiniGameSdk: f.sdk, console: quiet,
|
|
HomePopupQueue: { get: () => ({ has: () => false }) }, wx: { getSystemInfoSync: () => ({ platform: 'android' }) },
|
|
cc: { sys: { platform: 'wx', WECHAT_GAME: 'wx' }, fx: { GameConfig: { GM_INFO: f.gm, isGameplayEntryPreparing: () => false } } } };
|
|
vm.runInNewContext(compile('class Home {' + methods('assets/Script/JiaZai.ts', ['getOrder']) + '};exports.Home=Home'), context);
|
|
const home = new context.exports.Home(); home.deferHomePopupWhileTransfer = () => false; home.isHomeRuntimeAlive = () => false;
|
|
home.getOrder(); await new Promise(setImmediate);
|
|
assert.deepEqual(f.payments, [[price, 'recovered', '补发充值成功' + itemid]]);
|
|
});
|
|
}
|
|
test('SDK failure cannot block post-season rewards', async () => {
|
|
const f = passFixture(); let rewards = 0; f.view.playRewards = () => rewards++;
|
|
f.sdk.API.yinli_Pay = () => { throw Error('SDK offline'); }; await f.view.fulfill('paid'); assert.equal(rewards, 1);
|
|
});
|
|
test('post-season pending payment, failed fulfillment and stale-account results do not report', async () => {
|
|
const pending = passFixture(); pending.utils.getPayInfo = cb => cb({ code: 0, data: { pay_state: -1 } });
|
|
pending.view.error = () => {}; await pending.view.purchase(); assert.equal(pending.payments.length, 0);
|
|
const failed = passFixture(); failed.utils.completePassOrder = async () => { throw Error('network'); };
|
|
failed.view.error = () => {}; await failed.view.fulfill('failed'); assert.equal(failed.payments.length, 0);
|
|
const stale = passFixture(); let resolve; stale.utils.completePassOrder = () => new Promise(done => resolve = done);
|
|
const completion = stale.view.fulfill('old-account'); stale.gm.uid = 'other'; resolve({ data: { rewards: [] } });
|
|
await completion; assert.equal(stale.payments.length, 0);
|
|
});
|
|
|
|
function jungleFixture(storage = new Map()) {
|
|
const payments = [], calls = [], game = { uid: 'u', token: 't' };
|
|
const cc = { warn() {}, fx: { GameConfig: { GM_INFO: game }, GameTool: { shushu_Track() {} }, StorageMessage: {
|
|
getStorage: key => structuredClone(storage.get(key)), setStorage: (key, value) => storage.set(key, structuredClone(value))
|
|
} } };
|
|
const sdk = { API: { yinli_Pay: (...args) => payments.push(args) } };
|
|
const context = { exports: {}, cc, MiniGameSdk: sdk, console: quiet,
|
|
wx: { requestMidasPaymentGameItem() {}, openCustomerServiceConversation() {} } };
|
|
const names = ['junglePaymentKey', 'rememberJunglePayment', 'forgetJunglePayment', 'recoverJunglePayments', 'buyProp', 'GoKEFu'];
|
|
vm.runInNewContext(compile('class Utils {static apiBaseUrl(){return "test/";} static createPaymentOrderNo(){return "customer-order";}'
|
|
+ methods('assets/Script/module/Pay/Utils.ts', names) + '};exports.Utils=Utils;'), context);
|
|
const U = context.exports.Utils;
|
|
U.POST = (route, body, cb) => { calls.push({ route, body }); cb({ code: 1, data: route.includes('orderPaySig')
|
|
? { outTradeNo: 'direct-order', signData: 's', signature: 's', paySig: 's' } : { pay_state: 2 } }); };
|
|
U.setPayInfo = (cb, order) => { calls.push({ route: 'complete', order }); cb({ code: 1 }); };
|
|
return { U, payments, calls, storage, game, cc, sdk };
|
|
}
|
|
test('Jungle journals direct and customer orders before opening payment, then recovers on restart', async () => {
|
|
const first = jungleFixture();
|
|
first.U.buyProp('jungle_treasure_1', 1, 600, 'android', 'jungle_treasure_1', () => {});
|
|
first.U.GoKEFu({ payment_name: 'jungle_treasure_2', price: 1200, payment_count: 1 }, () => {});
|
|
assert.equal(Object.keys(first.storage.get(first.U.junglePaymentKey())).length, 2); assert.equal(first.payments.length, 0);
|
|
const f = jungleFixture(first.storage); await f.U.recoverJunglePayments([]);
|
|
assert.deepEqual(f.payments, [[600, 'direct-order', '补发充值成功jungle_treasure_1'], [1200, 'customer-order', '补发充值成功jungle_treasure_2']]);
|
|
await f.U.recoverJunglePayments([]); assert.equal(f.payments.length, 2);
|
|
});
|
|
test('Jungle legacy login order is reported and acknowledged without granting shop rewards', async () => {
|
|
const f = jungleFixture(); await f.U.recoverJunglePayments([{ outTradeNo: 'old', itemid: 'jungle_treasure_3', goodsPrice: '1800', type: 'ios' }]);
|
|
assert.deepEqual(f.payments, [[1800, 'old', '补发充值成功jungle_treasure_3']]);
|
|
assert.equal(f.calls.filter(c => c.route === 'complete').length, 1);
|
|
});
|
|
test('Jungle pending orders are retained; customer confirmation can report on a later login', async () => {
|
|
const f = jungleFixture(); f.U.rememberJunglePayment('pending', 'jungle_treasure_1', 600, true);
|
|
f.U.POST = (route, body, cb) => cb({ code: 0 }); await f.U.recoverJunglePayments([]);
|
|
assert.equal(f.payments.length, 0); assert.ok(f.storage.get(f.U.junglePaymentKey()).pending);
|
|
f.U.POST = (route, body, cb) => cb({ code: route === 'wx/iosgetPayInfo' ? 1 : 0 });
|
|
await f.U.recoverJunglePayments([]); assert.equal(f.payments.length, 1);
|
|
});
|
|
test('Jungle failed acknowledgment and SDK exception leave the order available for retry', async () => {
|
|
const f = jungleFixture(); f.U.rememberJunglePayment('paid', 'jungle_treasure_1', 600, false);
|
|
f.U.setPayInfo = cb => cb({ code: 0 }); await f.U.recoverJunglePayments([]); assert.equal(f.payments.length, 0);
|
|
f.U.setPayInfo = cb => cb({ code: 1 }); const report = f.sdk.API.yinli_Pay;
|
|
f.sdk.API.yinli_Pay = () => { throw Error('offline'); }; await f.U.recoverJunglePayments([]);
|
|
assert.ok(f.storage.get(f.U.junglePaymentKey()).paid);
|
|
f.sdk.API.yinli_Pay = report; await f.U.recoverJunglePayments([]); assert.equal(f.payments.length, 1);
|
|
});
|
|
test('Jungle recovery ignores stale-account replies and callbacks already reported by the activity', async () => {
|
|
for (const switchAccount of [true, false]) {
|
|
const f = jungleFixture(); f.U.rememberJunglePayment('paid', 'jungle_treasure_1', 600, false); let reply;
|
|
f.U.POST = (route, body, cb) => reply = cb; const pending = f.U.recoverJunglePayments([]);
|
|
if (switchAccount) f.game.uid = 'another'; else f.U.forgetJunglePayment('paid');
|
|
reply({ code: 1, data: { pay_state: 2 } }); await pending; assert.equal(f.payments.length, 0);
|
|
}
|
|
});
|
|
test('Jungle normal callback clears the journal and does not re-report an order completed by recovery', async () => {
|
|
const f = jungleFixture();
|
|
const context = { exports: {}, Utils: f.U, MiniGameSdk: f.sdk, cc: f.cc };
|
|
vm.runInNewContext(compile('class Jungle {' + methods('assets/jungle_treasure/script/jungle_Manager.ts', ['completeDirectPayResultPolling']) + '};exports.Jungle=Jungle;'), context);
|
|
const view = new context.exports.Jungle(); view.directPayTier = { id: 1, productId: 'jungle_treasure_1' };
|
|
view.directPayOrderNo = 'paid'; view.pendingPaymentPrice = 600; view.stopDirectPayResultPolling = () => {}; view.refreshAfterPayment = () => {};
|
|
f.U.rememberJunglePayment('paid', 'jungle_treasure_1', 600, false);
|
|
view.completeDirectPayResultPolling(); await f.U.recoverJunglePayments([]); assert.equal(f.payments.length, 1);
|
|
view.completeDirectPayResultPolling(); assert.equal(f.payments.length, 1);
|
|
});
|