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}));
});