1633 lines
98 KiB
JavaScript
1633 lines
98 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { isDeepStrictEqual } from 'node:util';
|
|
import { readFile } from 'node:fs/promises';
|
|
import { registerHooks } from 'node:module';
|
|
import * as Rules from '../rules.ts';
|
|
|
|
const stats = JSON.parse(await readFile(new URL('../data/cloudRiseLevelStats.json', import.meta.url))).levels;
|
|
const profile = { username: '测试玩家', useravatar: '', useravatarIcon: 'icon_9' };
|
|
function runWith(scores = Array(99).fill(5)) {
|
|
const stage = Rules.matchStage(1, 100, 1000, stats, {}, [profile], () => 0.5);
|
|
stage.opponents = scores.map(success_num => ({ ...profile, start_level: 100, success_num }));
|
|
return { id: 'run', periodId: 'p1', status: 'playing', stage: 1, startedAt: 1000,
|
|
expiresAt: 1000 + Rules.DURATION, stages: [stage] };
|
|
}
|
|
|
|
test('truncated discrete normal has half its mass within 100 at edge and interior centers', () => {
|
|
for (const center of [1, 2, 50, 100, 101, 500, 1960, 3000]) {
|
|
assert.ok(Math.abs(Rules.centralMass(center, Rules.sigmaFor(center)) - 0.5) < 1e-9);
|
|
}
|
|
assert.notEqual(Rules.sigmaFor(100), Rules.sigmaFor(1000));
|
|
});
|
|
test('start weights equal entry counts times Gaussian, keep zero weights and 1960 bound', () => {
|
|
const weights = Rules.startWeights(100, stats), sigma = Rules.sigmaFor(100);
|
|
assert.equal(weights.length, 1960);
|
|
assert.ok(weights.slice(1920).every(x => x === 0));
|
|
const ratio = stats[98].enter_total / stats[99].enter_total * Math.exp(-1 / (2 * sigma * sigma));
|
|
assert.ok(Math.abs(weights[98] / weights[99] - ratio) < 1e-10);
|
|
assert.equal(Rules.weightedIndex([0, 1, 0], () => 0), 1);
|
|
});
|
|
test('histogram preserves duplicate sample probability; sample zero is not missing', () => {
|
|
const histogram = [1, 0, 2, 0, 0, 1];
|
|
assert.deepEqual([0, 0.249, 0.25, 0.749, 0.75, 0.999].map(x =>
|
|
Rules.sampleScore(100, 5, histogram, stats, () => x)), [0, 0, 2, 2, 5, 5]);
|
|
assert.equal(Rules.sampleScore(100, 5, [3, 0, 0, 0, 0, 0], stats, () => 0.9), 0);
|
|
});
|
|
test('cold simulation stops at first failure and uses preceding non-null rate', () => {
|
|
const rows = [{ level: 1, enter_total: 1, pass_rate: 0.5 }, { level: 2, enter_total: 1, pass_rate: null }];
|
|
const draws = [0.1, 0.2, 0.7, 0.1];
|
|
assert.equal(Rules.sampleScore(1, 5, undefined, rows, () => draws.shift()), 2);
|
|
assert.equal(draws.length, 1);
|
|
assert.equal(Rules.rateAt(1968, stats), 0.818);
|
|
assert.equal(Rules.sampleScore(1960, 9, undefined, stats, () => 0), 9);
|
|
});
|
|
test('one stage contains 99 pairs and has 100 initial survivors including zero-score opponents', () => {
|
|
const stage = Rules.matchStage(2, 100, 0, stats, {}, [profile], () => 0.99999);
|
|
assert.equal(stage.opponents.length, 99); assert.equal(stage.survivors, 100);
|
|
for (const o of stage.opponents) {
|
|
assert.ok(o.start_level >= 1 && o.start_level <= 1960);
|
|
assert.ok(o.success_num >= 0 && o.success_num <= 7);
|
|
}
|
|
const exposed = Rules.publicRun(runWith());
|
|
assert.equal('success_num' in exposed.stages[0].opponents[0], false);
|
|
assert.equal('start_level' in exposed.stages[0].opponents[0], false);
|
|
});
|
|
test('win progression leaves reward to client; duplicate settlement and manual next stage', () => {
|
|
const run = runWith([5, 5, ...Array(97).fill(0)]);
|
|
for (let i = 1; i <= 5; i++) {
|
|
Rules.beginAttempt(run, 'a' + i);
|
|
assert.equal(Rules.finishAttempt(run, 'a' + i, 'win', 2000), 0);
|
|
}
|
|
assert.equal(run.status, 'waiting'); assert.equal(run.stage, 1);
|
|
assert.equal(run.stages[0].survivors, 3);
|
|
assert.equal(Rules.finishAttempt(run, 'a5', 'win', 3000), 0);
|
|
assert.throws(() => Rules.beginAttempt(run, 'a6'));
|
|
});
|
|
test('fail before ten ends whole run; expiration does not fabricate a lost sample', () => {
|
|
const run = runWith();
|
|
Rules.beginAttempt(run, 'a1'); Rules.finishAttempt(run, 'a1', 'win', 2000);
|
|
Rules.beginAttempt(run, 'a2'); Rules.finishAttempt(run, 'a2', 'interrupted', 3000);
|
|
assert.equal(run.status, 'failed'); assert.equal(run.stages[0].success_num, 1);
|
|
const timed = runWith(); Rules.beginAttempt(timed, 'a1');
|
|
assert.equal(Rules.expire(timed, timed.expiresAt), true);
|
|
assert.equal(timed.stages[0].status, 'expired');
|
|
assert.equal(timed.stages[0].results.length, 0);
|
|
});
|
|
|
|
test('a missing or non-string attempt identifier cannot settle an unstarted round', () => {
|
|
for (const id of [undefined, null, '', 0, 1, {}, 'x'.repeat(101)]) {
|
|
const run = runWith();
|
|
assert.throws(() => Rules.beginAttempt(run, id));
|
|
assert.throws(() => Rules.finishAttempt(run, id, 'win', 2000));
|
|
assert.equal(run.stages[0].success_num, 0);
|
|
}
|
|
});
|
|
|
|
const db = { users: new Map(), activityConfigs: new Map(), cloudRiseSamples: new Map(), cloudRiseRuns: new Map() };
|
|
// Fixtures use the real shared collection envelope; helpers expose only the activity payload for scenario edits.
|
|
const configs = {
|
|
get: id => db.activityConfigs.get(id)?.config,
|
|
set(id, config) { db.activityConfigs.set(id,{_id:id,activityId:'cloudRise',recordType:'version',status:'published',configVersion:id,
|
|
effectiveFrom:config.startsAt,publishedAt:Math.min(Date.now(),config.startsAt)-1,config:structuredClone(config)}); },
|
|
clear:()=>db.activityConfigs.clear(),
|
|
values:()=>[...db.activityConfigs.values()].map(r=>r.config).values(),
|
|
get size(){return db.activityConfigs.size;}
|
|
};
|
|
let sampleFails = false, sampleAppendFails = 0;
|
|
const profiles = [profile];
|
|
globalThis.__cloudRiseTestProfiles = profiles;
|
|
const indexes = [];
|
|
function field(doc, path) {
|
|
const parts = path.split('.');
|
|
const read = (value, i) => i === parts.length ? value : Array.isArray(value)
|
|
? value.flatMap(item => read(item, i)) : read(value?.[parts[i]], i + 1);
|
|
return read(doc, 0);
|
|
}
|
|
function matches(doc, query) {
|
|
return Object.entries(query).every(([k, v]) => {
|
|
if (k === '$or') return v.some(q => matches(doc, q));
|
|
const actual = field(doc, k);
|
|
if (!v || typeof v !== 'object') return actual === v;
|
|
if (!Object.keys(v).some(key => key.startsWith('$'))) return isDeepStrictEqual(actual, v);
|
|
return Object.entries(v).every(([op, value]) => {
|
|
if (op === '$exists') return (actual !== undefined) === value;
|
|
if (op === '$elemMatch') return Array.isArray(actual) && actual.some(item => matches(item, value));
|
|
if (op === '$ne') return Array.isArray(actual) ? actual.every(item => item !== value) : actual !== value;
|
|
const compare = item => {
|
|
if (op === '$lte') return item <= value;
|
|
if (op === '$gte') return item >= value;
|
|
if (op === '$gt') return item > value;
|
|
if (op === '$in') return value.includes(item);
|
|
throw new Error('unsupported query operator: ' + op);
|
|
};
|
|
return Array.isArray(actual) ? actual.some(compare) : compare(actual);
|
|
});
|
|
});
|
|
}
|
|
function expression(expr, doc) {
|
|
if (typeof expr === 'string' && expr.startsWith('$')) return field(doc, expr.slice(1));
|
|
if (Array.isArray(expr)) return expr.map(v => expression(v, doc));
|
|
if (!expr || typeof expr !== 'object') return expr;
|
|
if ('$isArray' in expr) return Array.isArray(expression(expr.$isArray, doc));
|
|
if ('$ifNull' in expr) return expression(expr.$ifNull[0], doc) ?? expression(expr.$ifNull[1], doc);
|
|
if ('$cond' in expr) return expression(expr.$cond[expression(expr.$cond[0], doc) ? 1 : 2], doc);
|
|
return Object.fromEntries(Object.entries(expr).map(([key, value]) => [key, expression(value, doc)]));
|
|
}
|
|
function aggregate(rows, pipeline) {
|
|
for (const step of pipeline) {
|
|
if (step.$match) rows = rows.filter(row => matches(row, step.$match));
|
|
else if (step.$project) rows = rows.map(row => Object.fromEntries(Object.entries(step.$project)
|
|
.filter(([, value]) => value !== 0).map(([key, value]) => [key, value === 1 ? row[key] : expression(value, row)])));
|
|
else if (step.$unwind) {
|
|
const path = step.$unwind.slice(1);
|
|
rows = rows.flatMap(row => (field(row, path) || []).map(value => ({ ...row, [path]: value })));
|
|
} else if (step.$group) {
|
|
const groups = new Map();
|
|
for (const row of rows) {
|
|
const id = expression(step.$group._id, row), key = JSON.stringify(id);
|
|
const group = groups.get(key) || { _id: id };
|
|
for (const [name, value] of Object.entries(step.$group)) {
|
|
if (name === '_id') continue;
|
|
if ('$first' in value && !(name in group)) group[name] = expression(value.$first, row);
|
|
else if ('$sum' in value) group[name] = (group[name] || 0) + expression(value.$sum, row);
|
|
}
|
|
groups.set(key, group);
|
|
}
|
|
rows = [...groups.values()];
|
|
} else throw new Error('unsupported aggregation step');
|
|
}
|
|
return rows;
|
|
}
|
|
globalThis.__cloudRiseCloud = { mongo: { db: { collection(name) { return {
|
|
async insertOne(row) { if(db[name].has(row._id)) throw Error("duplicate key"); db[name].set(row._id,structuredClone(row)); return {insertedId:row._id}; },
|
|
async findOne(query, options) {
|
|
const rows = [...db[name].values()].filter(d => matches(d, query));
|
|
if (options?.sort) rows.sort((a, b) => {
|
|
for (const [k, direction] of Object.entries(options.sort)) {
|
|
if (field(a,k) !== field(b,k)) return (field(a,k) < field(b,k) ? -1 : 1) * direction;
|
|
}
|
|
return 0;
|
|
});
|
|
return structuredClone(rows[0] || null);
|
|
},
|
|
aggregate(pipeline) { return { async toArray() {
|
|
if (name === 'users') assert.fail('Matching must use the stats snapshot, not query the live users pool');
|
|
return aggregate([...db[name].values()], pipeline);
|
|
} }; },
|
|
find(query) {
|
|
let rows = [...db[name].values()].filter(row => matches(row, query));
|
|
return {
|
|
sort(spec) { rows.sort((a,b)=>{for(const [key,direction] of Object.entries(spec)){if(field(a,key)!==field(b,key))return(field(a,key)<field(b,key)?-1:1)*direction;}return 0;});return this; },
|
|
limit(n) { rows = rows.slice(0, n); return this; },
|
|
async toArray() { return structuredClone(rows); },
|
|
};
|
|
},
|
|
async deleteOne(query) {
|
|
const row = [...db[name].values()].find(doc => matches(doc, query));
|
|
return { deletedCount: row && db[name].delete(row._id) ? 1 : 0 };
|
|
},
|
|
async updateOne(query, update, options) {
|
|
if (name === 'cloudRiseSamples' && sampleFails) throw new Error('simulated sample write outage');
|
|
if (name === 'cloudRiseSamples' && update.$push && sampleAppendFails > 0) { sampleAppendFails--; throw Error('simulated append outage'); }
|
|
const doc = [...db[name].values()].find(d => matches(d, query));
|
|
if (!doc && options?.upsert) {
|
|
const id = query._id || 'generated-' + db[name].size;
|
|
if (db[name].has(id)) throw new Error('duplicate key');
|
|
db[name].set(id, { _id: id, ...query, ...structuredClone(update.$setOnInsert || update.$set) });
|
|
return { modifiedCount: 0, upsertedCount: 1 };
|
|
}
|
|
if (!doc) return { modifiedCount: 0, matchedCount: 0 };
|
|
Object.assign(doc, structuredClone(update.$set || {}));
|
|
for (const [k, v] of Object.entries(update.$push || {})) (doc[k] ||= []).push(structuredClone(v));
|
|
for (const k of Object.keys(update.$unset || {})) {
|
|
if (k === 'stages.$[].opponents') doc.stages.forEach(stage => { delete stage.opponents; });
|
|
else delete doc[k];
|
|
}
|
|
for (const [k, v] of Object.entries(update.$inc || {})) doc[k] = (doc[k] || 0) + v;
|
|
return { modifiedCount: 1, matchedCount: 1 };
|
|
},
|
|
async updateMany(query, update) {
|
|
let count = 0;
|
|
for (const row of [...db[name].values()]) if (matches(row, query)) {
|
|
await this.updateOne({ _id: row._id }, update); count++;
|
|
}
|
|
return { matchedCount: count, modifiedCount: count };
|
|
},
|
|
listIndexes() { return { async toArray() {
|
|
return indexes.filter(i => i.name === name).map(i => ({ key: i.spec, ...i.options }));
|
|
} }; },
|
|
async createIndex(spec, options) {
|
|
if (name === 'users' && spec.onlyId === 1 && options?.unique) {
|
|
const ids = [...db.users.values()].map(user => user.onlyId).filter(id => typeof id === 'number');
|
|
if (new Set(ids).size !== ids.length) throw Object.assign(new Error('duplicate onlyId'), { code: 11000 });
|
|
}
|
|
const existing = indexes.find(i => i.name === name && isDeepStrictEqual(i.spec, spec));
|
|
if (existing) {
|
|
if (!isDeepStrictEqual(existing.options, options)) throw new Error('IndexOptionsConflict');
|
|
return 'test_index';
|
|
}
|
|
indexes.push({ name, spec, options }); return 'test_index';
|
|
},
|
|
}; } } } };
|
|
globalThis.__cloudRiseCloud.database = () => ({ collection(name) { return { where(query) { return {
|
|
async getOne() { return { data: await globalThis.__cloudRiseCloud.mongo.db.collection(name).findOne(query) }; },
|
|
async update(value) { return globalThis.__cloudRiseCloud.mongo.db.collection(name).updateOne(query, { $set: value }); },
|
|
}; } }; } });
|
|
const analyticsReports = [];
|
|
let analyticsOffline = false, analyticsOnSend = null;
|
|
globalThis.__cloudRiseAnalyticsSend = async events => {
|
|
if (analyticsOffline) throw Error('simulated analytics outage');
|
|
analyticsReports.push(...structuredClone(events));
|
|
const hook = analyticsOnSend; analyticsOnSend = null;
|
|
if (hook) await hook();
|
|
return events.map(event => event.id);
|
|
};
|
|
const hooks = registerHooks({
|
|
resolve(specifier, context, next) {
|
|
if (specifier === '@lafjs/cloud') return { url: 'cloudrise:cloud', shortCircuit: true };
|
|
if (specifier === '@/activityConfig/store') return {url:new URL('../../activityConfig/store.ts',import.meta.url).href,shortCircuit:true};
|
|
if (specifier === '@/Utils') return { url: 'cloudrise:utils', shortCircuit: true };
|
|
if (specifier === '@/cloudRise/analytics') return { url: 'cloudrise:analytics', shortCircuit: true };
|
|
if (specifier === '@/cloudRise/periods') return {url:new URL('../periods.ts',import.meta.url).href,shortCircuit:true};
|
|
if (specifier === '@/cloudRise/rules') return { url: new URL('../rules.ts', import.meta.url).href, shortCircuit: true };
|
|
if (specifier === '@/cloudRise/stats') return { url: 'cloudrise:stats', shortCircuit: true };
|
|
if (specifier === '@/cloudRise/index') return { url: new URL('../index.ts', import.meta.url).href, shortCircuit: true };
|
|
if (specifier === '@/jungleConfig') return { url: new URL('../../jungleConfig.ts', import.meta.url).href, shortCircuit: true };
|
|
return next(specifier, context);
|
|
},
|
|
load(url, context, next) {
|
|
if (url === 'cloudrise:cloud') return { format: 'module', source: 'export default globalThis.__cloudRiseCloud;', shortCircuit: true };
|
|
if (url === 'cloudrise:stats') return { format: 'module', shortCircuit: true,
|
|
source: 'export {LEVEL_STATS} from ' + JSON.stringify(new URL('../stats.ts', import.meta.url).href)
|
|
+ '; export const OPPONENT_PROFILES = globalThis.__cloudRiseTestProfiles;' };
|
|
if (url === 'cloudrise:analytics') return { format: 'module', shortCircuit: true,
|
|
source: 'export {collect} from ' + JSON.stringify(new URL('../analytics.ts', import.meta.url).href)
|
|
+ '; export const send = (...args) => globalThis.__cloudRiseAnalyticsSend(...args);' };
|
|
if (url === 'cloudrise:utils') return { format: 'module', source: 'export default {checkToken:(a,b)=>a===b};', shortCircuit: true };
|
|
return next(url, context);
|
|
},
|
|
});
|
|
const { default: api, inactiveBefore, sampleHistogramPipeline, findOpenPeriod } = await import('../index.ts');
|
|
const { default: coinApi } = await import('../../userCoin.ts');
|
|
const { default: adminApi } = await import('../admin.ts');
|
|
const PersonalPeriods = await import('../periods.ts');
|
|
const realClock=Date.now;
|
|
test.afterEach(()=>{Date.now=realClock;});
|
|
const openPeriod=(onlyId,now=Date.now())=>PersonalPeriods.openForUser(onlyId,now);
|
|
function afterCooldown(){const at=PersonalPeriods.lastEndedAt(db.users.get('u'),Date.now())+PersonalPeriods.COOLDOWN_MS+1;Date.now=()=>at;}
|
|
hooks.deregister();
|
|
function setup() {
|
|
analyticsReports.length = 0; analyticsOffline = false; analyticsOnSend = null;
|
|
Object.values(db).forEach(m => m.clear()); sampleFails = false; sampleAppendFails = 0; indexes.length = 0; profiles.splice(0, profiles.length, profile);
|
|
db.users.set('u', { _id: 'u', onlyId: 1001, token: 'token', levelAmount: 99, coinAmount: 100 });
|
|
configs.set('current', { _id: 'current', periodId: 'p1', durationHours: 24,
|
|
startsAt: Date.now() - 1000, endsAt: Date.now() + 600000, unlockLevel: 1 });
|
|
}
|
|
// Existing gameplay scenarios use a deterministic personal-period fixture. Login behavior is tested below.
|
|
const call = async body => {
|
|
const user = db.users.get('u');
|
|
if (user && !user.cloudRisePeriod) {
|
|
const period = await findOpenPeriod(Date.now());
|
|
if (period) user.cloudRisePeriod = structuredClone(period);
|
|
}
|
|
return api({ body: { uid: '1001', token: 'token', ...body } });
|
|
};
|
|
const saveCoins = body => coinApi({ body: { uid: 'u', token: 'token', action: 'save', ...body } });
|
|
function forceScores(score = 5) {
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.stages.at(-1).opponents.forEach(o => { o.success_num = score; });
|
|
user.cloudRiseState = JSON.stringify(state);
|
|
}
|
|
async function winStage(run, stage, count) {
|
|
for (let i = 1; i <= count; i++) {
|
|
const attemptId = `s${stage}-${i}`;
|
|
assert.equal((await call({ action: 'begin', runId: run.id, stage, attemptId })).code, 1);
|
|
const result = await call({ action: 'finish', runId: run.id, stage, attemptId, outcome: 'win' });
|
|
assert.equal(result.code, 1);
|
|
}
|
|
}
|
|
test('API atomic signup, fixed opponents and manual stage start after registration closes', async () => {
|
|
setup();
|
|
const [a,b] = await Promise.all([call({ action: 'start', periodId: 'p1' }), call({ action: 'start', periodId: 'p1' })]);
|
|
assert.equal(a.code, 1); assert.equal(b.code, 1); assert.deepEqual(a.data.run, b.data.run);
|
|
forceScores(); await winStage(a.data.run, 1, 5);
|
|
let result = await call({ action: 'status' });
|
|
assert.equal(result.data.run.status, 'waiting'); assert.equal(result.data.run.stages.length, 1);
|
|
const expiresAt = result.data.run.expiresAt;
|
|
configs.get('current').endsAt = Date.now() - 1;
|
|
db.users.get('u').levelAmount = 110;
|
|
result = await call({ action: 'start_stage', runId: a.data.run.id, stage: 2 });
|
|
assert.equal(result.code, 1); assert.equal(result.data.run.stages[1].start_level, 111);
|
|
assert.equal(result.data.run.expiresAt, expiresAt);
|
|
const duplicate = await call({ action: 'start_stage', runId: a.data.run.id, stage: 2 });
|
|
assert.deepEqual(duplicate.data.run, result.data.run);
|
|
});
|
|
test('API concurrent finish records success without issuing coins; samples survive write failures', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); await winStage(data.run, 1, 4);
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'last' });
|
|
sampleFails = true;
|
|
const body = { action: 'finish', runId: data.run.id, stage: 1, attemptId: 'last', outcome: 'win' };
|
|
const results = await Promise.all([call(body), call(body)]);
|
|
assert.ok(results.every(r => r.code === 1 && r.data.sampleSyncPending));
|
|
assert.equal(db.users.get('u').coinAmount, 100);
|
|
assert.equal(db.users.get('u').cloudRiseCoinTotal, undefined);
|
|
sampleFails = false; await call({ action: 'status' }); await call(body);
|
|
assert.equal(db.cloudRiseSamples.size, 1); assert.equal(db.users.get('u').coinAmount, 100);
|
|
});
|
|
test('API interrupted first round consumes period, new period can start; expiry adds no sample', async () => {
|
|
setup(); let result = await call({ action: 'start', periodId: 'p1' });
|
|
await call({ action: 'begin', runId: result.data.run.id, stage: 1, attemptId: 'first' });
|
|
await call({ action: 'finish', runId: result.data.run.id, stage: 1, attemptId: 'first', outcome: 'interrupted' });
|
|
assert.equal((await call({ action: 'start', periodId: 'p1' })).code, 0);
|
|
assert.equal([...db.cloudRiseSamples.values()][0].samples[0].success_num, 0);
|
|
configs.get('current').periodId = 'p2'; db.users.get('u').cloudRisePeriod.periodId = 'p2';
|
|
result = await call({ action: 'start', periodId: 'p2' }); assert.equal(result.code, 1);
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1; user.cloudRiseState = JSON.stringify(state);
|
|
result = await call({ action: 'status' });
|
|
assert.equal(result.data.run.status, 'expired'); assert.equal(db.cloudRiseSamples.size, 1);
|
|
});
|
|
test('two-month inactive cutoff preserves dates and clamps at month-end', () => {
|
|
assert.equal(new Date(inactiveBefore(Date.UTC(2026,4,31))).toISOString(), '2026-03-31T00:00:00.000Z');
|
|
assert.equal(new Date(inactiveBefore(Date.UTC(2026,3,30))).toISOString(), '2026-02-28T00:00:00.000Z');
|
|
});
|
|
|
|
test('all three stages complete in sequence with three independent samples and one grant each', async () => {
|
|
setup(); let result = await call({ action: 'start', periodId: 'p1' });
|
|
const runId = result.data.run.id, deadline = result.data.run.expiresAt;
|
|
for (let stage = 1; stage <= 3; stage++) {
|
|
if (stage > 1) {
|
|
result = await call({ action: 'start_stage', runId, stage });
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.run.expiresAt, deadline);
|
|
}
|
|
forceScores([5, 7, 9][stage - 1]);
|
|
await winStage(result.data.run, stage, [5, 7, 9][stage - 1]);
|
|
result = await call({ action: 'status' });
|
|
const completed = result.data.run.stages.at(-1);
|
|
const reward = Math.ceil(completed.pool / completed.survivors);
|
|
result = await call({ action: 'save_reward', runId, stage, reward, coinAmount: db.users.get('u').coinAmount + reward });
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.run.status, stage === 3 ? 'completed' : 'waiting');
|
|
assert.equal(db.cloudRiseSamples.size, 1); assert.equal(db.cloudRiseSamples.get(runId).samples.length, stage);
|
|
}
|
|
assert.equal(result.data.coinAmount, 550);
|
|
assert.equal('cloudRiseCoinTotal' in result.data, false);
|
|
assert.equal(db.cloudRiseRuns.size, 1);
|
|
await call({ action: 'finish', runId, stage: 1, attemptId: 's1-5', outcome: 'win' });
|
|
assert.equal(db.users.get('u').coinAmount, 550);
|
|
assert.equal((await call({ action: 'start', periodId: 'p1' })).code, 0);
|
|
});
|
|
|
|
test('empty snapshot does not consume eligibility; matching excludes self and strips private profile fields', async () => {
|
|
setup(); profiles.length = 0;
|
|
assert.equal((await call({ action: 'start', periodId: 'p1' })).code, 0);
|
|
assert.equal(db.users.get('u').cloudRiseState, undefined);
|
|
profiles.push({ ...profile, onlyId: 1001, username: 'self' }, { ...profile, onlyId: 2002 });
|
|
const result = await call({ action: 'start', periodId: 'p1' });
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.run.stages[0].opponents[0].useravatarIcon, 'icon_9');
|
|
for (const opponent of result.data.run.stages[0].opponents) {
|
|
assert.equal(opponent.username, profile.username);
|
|
assert.equal(opponent.onlyId, undefined);
|
|
assert.equal(opponent.taskTime, undefined);
|
|
}
|
|
});
|
|
|
|
|
|
|
|
test('legacy coin save remains compatible before any award', async () => {
|
|
setup(); const result = await saveCoins({ coinAmount: 42 });
|
|
assert.equal(result.code, 1); assert.equal(db.users.get('u').coinAmount, 42);
|
|
});
|
|
|
|
test('admin requires configured secret, validates periods, and preserves enrolled deadline', async () => {
|
|
setup(); delete process.env.ADMIN_TOKEN;
|
|
assert.equal((await adminApi({ body: { action: 'save' } })).code, 0);
|
|
process.env.ADMIN_TOKEN = 'test-only';
|
|
try {
|
|
assert.equal((await adminApi({ body: { action: 'read', adminToken: 'wrong' } })).code, 0);
|
|
assert.equal((await adminApi({ body: { action: 'save', adminToken: 'test-only', config: '{}' } })).code, 0);
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
const config = { periodId: 'p2', configVersion: 'future-v1', startsAt: Date.now()+86400000, endsAt: Date.now()+2*86400000, unlockLevel: 1 };
|
|
assert.equal((await adminApi({ body: { action: 'save', adminToken: 'test-only', config: JSON.stringify(config) } })).code, 1);
|
|
assert.equal((await call({ action: 'status' })).data.run.expiresAt, data.run.expiresAt);
|
|
assert.equal((await adminApi({ body: { action: 'setup_indexes', adminToken: 'test-only' } })).code, 1);
|
|
} finally { delete process.env.ADMIN_TOKEN; }
|
|
});
|
|
|
|
test('index setup tolerates duplicate onlyId, prepares all indexes and can be retried', async () => {
|
|
setup(); process.env.ADMIN_TOKEN = 'test-only';
|
|
db.users.set('duplicate', { _id: 'duplicate', onlyId: 1001, token: 'other-token' });
|
|
const before = structuredClone([...db.users]);
|
|
const request = { body: { action: 'setup_indexes', adminToken: 'test-only' } };
|
|
try {
|
|
assert.equal((await adminApi(request)).code, 1);
|
|
assert.equal(indexes.length, 8);
|
|
const lookup = indexes.find(i => i.name === 'users' && i.spec.onlyId === 1);
|
|
assert(lookup && !lookup.options?.unique);
|
|
assert(indexes.some(i => i.name === 'activityConfigs' && i.options?.unique));
|
|
assert(indexes.some(i => i.name === 'cloudRiseSamples' && i.options?.unique));
|
|
assert(indexes.some(i => i.name === 'cloudRiseRuns'));
|
|
assert.equal((await adminApi(request)).code, 1);
|
|
assert.equal(indexes.length, 8);
|
|
assert.deepEqual([...db.users], before);
|
|
} finally { delete process.env.ADMIN_TOKEN; }
|
|
});
|
|
|
|
test('index setup preserves existing ordinary and unique onlyId indexes', async () => {
|
|
for (const options of [undefined, { unique: true },
|
|
{ unique: true, partialFilterExpression: { onlyId: { $type: 'number' } } }]) {
|
|
setup(); process.env.ADMIN_TOKEN = 'test-only';
|
|
indexes.push({ name: 'users', spec: { onlyId: 1 }, options });
|
|
try {
|
|
assert.equal((await adminApi({ body: { action: 'setup_indexes', adminToken: 'test-only' } })).code, 1);
|
|
assert.equal(indexes.length, 8);
|
|
assert.deepEqual(indexes.find(i => i.name === 'users' && i.spec.onlyId === 1).options, options);
|
|
} finally { delete process.env.ADMIN_TOKEN; }
|
|
}
|
|
});
|
|
|
|
test('real client service talks to real activity API: manual stages, client awards, and offline win recovery', async () => {
|
|
const { createRequire } = await import('node:module');
|
|
const { runInNewContext } = await import('node:vm');
|
|
const clientRoot = process.env.CLOUD_RISE_CLIENT_ROOT ? new URL(process.env.CLOUD_RISE_CLIENT_ROOT)
|
|
: new URL('../../../../../MatchMaster/', import.meta.url);
|
|
const requireClient = createRequire(new URL('package.json', clientRoot));
|
|
const ts = requireClient('typescript');
|
|
const storage = new Map();
|
|
const info = { uid: 'u', userId: 1001, token: 'token', coin: 100, level: 99, otherLevel: 0 };
|
|
const cc = { warn() {}, fx: { GameConfig: { GM_INFO: info }, StorageMessage: {
|
|
getStorage: key => storage.has(key) ? JSON.parse(storage.get(key)) : null,
|
|
setStorage: (key, value) => storage.set(key, JSON.stringify(value)),
|
|
} } };
|
|
let offline = false, dropRewardReply = false;
|
|
// Use the production encoder; passing JS objects directly misses form string coercion.
|
|
cc.fx.GameTool = { getWechatGameVersion: () => '开发版' };
|
|
cc.loader = { getXMLHttpRequest: () => ({
|
|
open(method, url) { assert.equal(method, 'POST'); assert.equal(url, 'https://fixture.invalid/cloudRise/index'); },
|
|
setRequestHeader(name, value) { assert.equal(name, 'Content-Type'); assert.equal(value, 'application/x-www-form-urlencoded'); },
|
|
send(encoded) {
|
|
const body = Object.fromEntries(new URLSearchParams(encoded));
|
|
assert.equal(body.uid, '1001');
|
|
if (body.action === 'save_reward') {
|
|
assert.equal(typeof body.reward, 'string'); assert.equal(typeof body.coinAmount, 'string');
|
|
}
|
|
if (offline) { this.onerror(); return; }
|
|
call(body).then(result => {
|
|
if (body.action === 'save_reward' && dropRewardReply) {
|
|
dropRewardReply = false; this.onerror(); return;
|
|
}
|
|
this.status = 200; this.readyState = 4; this.responseText = JSON.stringify(result); this.onreadystatechange();
|
|
});
|
|
},
|
|
}) };
|
|
const utilsSource = ts.createSourceFile('Utils.ts', await readFile(new URL('assets/Script/module/Pay/Utils.ts', clientRoot), 'utf8'), ts.ScriptTarget.Latest, true);
|
|
const postMethod = utilsSource.statements.find(ts.isClassDeclaration).members.find(n => n.name?.getText(utilsSource) === 'POST').getText(utilsSource);
|
|
const baseUrlMethod = utilsSource.statements.find(ts.isClassDeclaration).members.find(n => n.name?.getText(utilsSource) === 'apiBaseUrl').getText(utilsSource);
|
|
const postExports = {};
|
|
runInNewContext(ts.transpileModule(`export default class Utils { static httpip = 'https://fixture.invalid/'; static testHttpip = 'https://fixture.invalid/'; ${baseUrlMethod} ${postMethod} }`,
|
|
{ compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2017 } }).outputText,
|
|
{ cc, exports: postExports, MiniGameSdk: { API: { showToast() {} } } });
|
|
const utils = {
|
|
POST: postExports.default.POST.bind(postExports.default),
|
|
setUserLevel() { throw new Error("CloudRise must not upload mainline progress"); },
|
|
};
|
|
async function load(name, imports) {
|
|
const source = await readFile(new URL(name === 'CloudRiseRuntime' ? 'assets/cloud_rise_home/scripts/CloudRiseRuntime.ts' : 'assets/Script/module/Config/' + name + '.ts', clientRoot), 'utf8');
|
|
const exports = {};
|
|
runInNewContext(ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS,
|
|
target: ts.ScriptTarget.ES2017 } }).outputText, { cc, exports, console, Date, Math,
|
|
require: path => { assert.ok(path in imports); return imports[path]; } });
|
|
return exports.default;
|
|
}
|
|
const boot = async () => load('CloudRiseRuntime', { '../../Script/module/Pay/Utils': { default: utils },
|
|
'../../Script/module/Config/CloudRiseService': { default: await load('CloudRiseService', { '../Pay/Utils': { default: utils } }) } });
|
|
setup(); configs.get('current').pools = [12345, 23456, 34567]; let client = await boot();
|
|
assert.equal(await client.prepareMatch('integration-cancel'), true);
|
|
client.cancelMatch('integration-cancel'); await client.sync();
|
|
assert.equal(client.run(), null); assert.equal(client.data().available, true);
|
|
assert.equal(await client.prepareMatch('integration-first'), true);
|
|
assert.equal(await client.confirmMatch('integration-first'), true);
|
|
const deadline = client.run().expiresAt;
|
|
for (let stage = 1; stage <= 2; stage++) {
|
|
if (stage > 1) {
|
|
assert.equal(client.run().status, 'waiting');
|
|
const previous = db.users.get('u').cloudRiseState;
|
|
client.prepareRound(() => {}); client.finish(true); await client.sync();
|
|
assert.equal(db.users.get('u').cloudRiseState, previous);
|
|
info.level += 2;
|
|
assert.equal(await client.prepareMatch('integration-second'), true);
|
|
assert.equal(await client.confirmMatch('integration-second'), true);
|
|
assert.equal(client.stage().start_level, info.level + 1);
|
|
}
|
|
forceScores([5,7][stage - 1]);
|
|
for (let round = 0; round < [5,7][stage - 1]; round++) {
|
|
assert.equal(client.prepareRound(() => {}), true);
|
|
client.finish(true); info.level++; assert.equal(await client.sync(), true);
|
|
}
|
|
}
|
|
assert.equal(client.run().status, 'waiting');
|
|
assert.equal(info.coin, 470); assert.equal(db.users.get('u').coinAmount, 470);
|
|
assert.equal(client.run().expiresAt, deadline); assert.equal(db.cloudRiseSamples.size, 1); assert.equal([...db.cloudRiseSamples.values()][0].samples.length, 2);
|
|
await client.startStage(); client.prepareRound(() => {}); await client.sync();
|
|
offline = true; client.finish(true); assert.equal(await client.sync(), false);
|
|
client = await boot(); offline = false; assert.equal(await client.sync(), true);
|
|
assert.equal(client.run().status, 'playing'); assert.equal(client.stage().success_num, 1);
|
|
client.prepareRound(() => {}); client.finish(false); await client.sync();
|
|
assert.equal(client.run().status, 'failed'); assert.equal(info.coin, 470);
|
|
assert.equal(db.cloudRiseSamples.size, 1); assert.equal([...db.cloudRiseSamples.values()][0].samples.length, 3); assert.equal(db.users.get('u').cloudRiseCoinTotal, undefined);
|
|
|
|
// A committed reward with a lost response must still reach the local wallet after rollover.
|
|
setup(); storage.clear(); info.coin = 100; client = await boot();
|
|
await client.startStage(); forceScores();
|
|
for (let round = 0; round < 4; round++) { client.prepareRound(() => {}); client.finish(true); await client.sync(); }
|
|
dropRewardReply = true;
|
|
client.prepareRound(() => {}); client.finish(true); assert.equal(await client.sync(), false);
|
|
assert.equal(info.coin, 100); assert.equal(db.users.get('u').coinAmount, 200);
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1; user.cloudRiseState = JSON.stringify(state); openNextPeriod();
|
|
assert.equal(await client.sync(), true); assert.equal(client.run(), null); assert.equal(client.unseenResult(), false);
|
|
assert.equal(info.coin, 200); await client.sync(); assert.equal(info.coin, 200);
|
|
assert.equal(await client.startStage(), true); assert.equal(client.run().periodId, 'p2');
|
|
});
|
|
|
|
|
|
test('onlyId identifies the player for queries, settlement and archives; legacy Mongo uid is rejected', async () => {
|
|
setup();
|
|
db.users.set('1001', { _id: '1001', onlyId: 2002, token: 'other-token', coinAmount: 999 });
|
|
for (const uid of ['u', undefined, null, '', '01', '1e3', '1.5', {}, 0, -1, Number.MAX_SAFE_INTEGER + 1]) {
|
|
assert.equal((await call({ uid })).code, 0);
|
|
}
|
|
assert.equal((await call({ uid: 1001 })).code, 1);
|
|
assert.equal((await call({ uid: 1001, token: 'wrong' })).code, 0);
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'lost' });
|
|
assert.equal((await call({ action: 'finish', runId: data.run.id, stage: 1, attemptId: 'lost', outcome: 'lose' })).code, 1);
|
|
assert.equal([...db.cloudRiseSamples.values()][0].uid, '1001');
|
|
assert.equal([...db.cloudRiseRuns.values()][0].uid, '1001');
|
|
assert.equal(db.users.get('1001').cloudRiseState, undefined);
|
|
assert.equal(db.users.get('1001').coinAmount, 999);
|
|
});
|
|
|
|
test('configuration selection and signup use time only, ignoring legacy enabled and status', async () => {
|
|
setup();
|
|
const current = configs.get('current');
|
|
const active = { ...current, _id: 'other', periodId: 'p2', startsAt: current.startsAt + 1 };
|
|
configs.set('other', active);
|
|
for (const status of [undefined, 'inactive', 'active']) {
|
|
active.status = status;
|
|
const result = await call({});
|
|
assert.equal(result.code, 1); assert.equal(result.data.period.periodId, 'p2');
|
|
assert.equal('status' in result.data.period, false); assert.equal(result.data.available, true);
|
|
}
|
|
active.enabled = false;
|
|
const closed = await call({});
|
|
assert.equal(closed.code, 1); assert.equal(closed.data.period.periodId, 'p2');
|
|
assert.equal(closed.data.period.enabled, undefined); assert.equal(closed.data.available, true);
|
|
assert.equal((await call({ action: 'start', periodId: 'p1' })).code, 0, 'must not fall back to an older period');
|
|
assert.equal(db.users.get('u').cloudRiseState, undefined);
|
|
assert.equal((await call({ action: 'start', periodId: 'p2' })).code, 1);
|
|
});
|
|
|
|
test('activity time boundaries are inclusive at startsAt and exclusive at endsAt', async () => {
|
|
setup(); const config = configs.get('current');
|
|
const originalNow = Date.now;
|
|
try {
|
|
for (const [now, code] of [[config.startsAt - 1, 0], [config.startsAt, 1], [config.endsAt - 1, 1], [config.endsAt, 0]]) {
|
|
Date.now = () => now;
|
|
const result = await call({}); assert.equal(result.code, code);
|
|
if (!code) assert.deepEqual(result, { code: 0, data: null, msg: '活动未开启' });
|
|
}
|
|
} finally { Date.now = originalNow; }
|
|
});
|
|
|
|
test('closing enrollment preserves the enrolled player deadline, progress and next stage', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
configs.get('current').endsAt = Date.now();
|
|
const closed = await call({});
|
|
assert.equal(closed.data.period.periodId, 'p1'); assert.equal(closed.data.available, false);
|
|
assert.equal(closed.data.run.expiresAt, data.run.expiresAt);
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
assert.equal((await call({ action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 })).code, 1);
|
|
const next = await call({ action: 'start_stage', runId: data.run.id, stage: 2 });
|
|
assert.equal(next.code, 1); assert.equal(next.data.run.stage, 2);
|
|
assert.equal(next.data.run.expiresAt, data.run.expiresAt);
|
|
});
|
|
|
|
test('admin publishes immutable future shared versions and refuses changing an opened period', async () => {
|
|
setup(); process.env.ADMIN_TOKEN='test-only';
|
|
const admin=body=>adminApi({body:{adminToken:'test-only',...body}});
|
|
const future={periodId:'p2',startsAt:Date.now()+86400000,endsAt:Date.now()+2*86400000,unlockLevel:1};
|
|
for(const durationHours of [0,-1,1.5,'24']) assert.equal((await admin({action:'save',configVersion:'v2',config:{...future,durationHours}})).code,0);
|
|
const saved=await admin({action:'save',configVersion:'v2',config:future});assert.equal(saved.code,1);assert.equal(saved.data.durationHours,24);
|
|
assert.equal(configs.size,2);assert.equal((await admin({action:'read'})).data.periodId,'p1');
|
|
assert.equal((await admin({action:'read',periodId:'p2'})).data.configVersion,'v2');
|
|
assert.equal((await admin({action:'save',configVersion:'v2',config:{...future,unlockLevel:10}})).code,0);
|
|
assert.equal((await admin({action:'save',configVersion:'opened-edit',config:configs.get('current')})).code,0);
|
|
delete process.env.ADMIN_TOKEN;
|
|
});
|
|
|
|
test('client reward reports persist the reported balance once, without server reward arithmetic', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
const report = { action: 'save_reward', runId: data.run.id, stage: 1, reward: 123, coinAmount: 223 };
|
|
assert.equal((await call(report)).code, 0);
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
assert.equal(db.users.get('u').coinAmount, 100);
|
|
for (const patch of [{ reward: -1 }, { reward: 1.5 }, { coinAmount: NaN }, { coinAmount: 1 }]) {
|
|
assert.equal((await call({ ...report, ...patch })).code, 0);
|
|
}
|
|
const replies = await Promise.all([call(report), call(report)]);
|
|
assert.ok(replies.every(r => r.code === 1 && r.data.run.stages[0].rewardSaved));
|
|
assert.equal(db.users.get('u').coinAmount, 223);
|
|
assert.equal(replies[0].data.run.stages[0].reward, 123);
|
|
assert.equal((await saveCoins({ coinAmount: 80 })).code, 1);
|
|
assert.equal((await call(report)).code, 1);
|
|
assert.equal(db.users.get('u').coinAmount, 80);
|
|
});
|
|
|
|
test('won rewards remain reportable after personal expiry and must be saved before a new period', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1; user.cloudRiseState = JSON.stringify(state);
|
|
configs.get('current').periodId = 'p2'; db.users.get('u').cloudRisePeriod.periodId = 'p2';
|
|
assert.equal((await call({})).data.available, false);
|
|
assert.equal(db.cloudRiseRuns.size, 0);
|
|
const result = await call({ action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 });
|
|
assert.equal(result.code, 1); assert.equal(result.data.available, true);
|
|
assert.equal(db.cloudRiseRuns.size, 1);
|
|
assert.equal([...db.cloudRiseRuns.values()][0].stages[0].rewardSaved, true);
|
|
});
|
|
|
|
test('no open configuration returns only the closed response for unregistered players', async () => {
|
|
setup(); configs.clear();
|
|
for (const body of [{}, { action: 'start', periodId: 'p1' }, { action: 'begin', runId: 'missing' }]) {
|
|
assert.deepEqual(await call(body), { code: 0, data: null, msg: '活动未开启' });
|
|
}
|
|
assert.equal(db.users.get('u').cloudRiseState, undefined);
|
|
assert.equal(db.cloudRiseSamples.size, 0);
|
|
});
|
|
|
|
test('registration closing still permits personal play, result recovery and reward retries', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); configs.clear();
|
|
const status = await call({});
|
|
assert.equal(status.code, 1); assert.equal(status.data.period.periodId, 'p1');
|
|
assert.deepEqual(status.data.targets, [5, 7, 9]); assert.deepEqual(status.data.pools, [10000, 15000, 20000]);
|
|
assert.equal(status.data.run.id, data.run.id);
|
|
await winStage(data.run, 1, 5);
|
|
const report = { action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 };
|
|
assert.equal((await call(report)).code, 1);
|
|
assert.equal((await call(report)).code, 1);
|
|
assert.equal(db.users.get('u').coinAmount, 200);
|
|
const state = JSON.parse(db.users.get('u').cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1; db.users.get('u').cloudRiseState = JSON.stringify(state);
|
|
assert.equal((await call({})).data.run.status, 'expired');
|
|
assert.equal((await call(report)).code, 1);
|
|
});
|
|
|
|
function openNextPeriod() {
|
|
const current = configs.get('current');
|
|
configs.set('next', { ...current, _id: 'next', periodId: 'p2', startsAt: Date.now() - 1 });
|
|
db.users.get('u').cloudRisePeriod = {...structuredClone(configs.get('next')),configVersion:'next'};
|
|
}
|
|
|
|
test('new period status omits settled older runs while retaining durable history and eligibility', async () => {
|
|
for (const status of ['expired', 'failed', 'completed']) {
|
|
setup(); await call({ action: 'start', periodId: 'p1' });
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState), old = state.run;
|
|
old.status = status;
|
|
Object.assign(old.stages[0], { status: status === 'completed' ? 'won' : status === 'failed' ? 'lost' : 'expired',
|
|
rewardSaved: true, reward: status === 'completed' ? 100 : 0, endedAt: Date.now() });
|
|
user.cloudRiseState = JSON.stringify(state); openNextPeriod();
|
|
const result = await call({ action: 'status' });
|
|
assert.equal(result.data.period.periodId, 'p2'); assert.equal(result.data.available, true);
|
|
assert.equal(result.data.run, null); assert.equal(result.data.previousRun.id, old.id);
|
|
assert.equal(JSON.parse(user.cloudRiseState).run.id, old.id, 'status must not erase the idempotency source');
|
|
assert.equal(db.cloudRiseRuns.get(old.id).periodId, 'p1');
|
|
const joined = await call({ action: 'start', periodId: 'p2' });
|
|
assert.equal(joined.code, 1); assert.equal(joined.data.run.periodId, 'p2'); assert.equal(joined.data.run.stage, 1);
|
|
assert.deepEqual(JSON.parse(user.cloudRiseState).playedPeriods, ['p1', 'p2']);
|
|
assert.equal(db.cloudRiseRuns.get(old.id).periodId, 'p1');
|
|
}
|
|
});
|
|
|
|
test('a start request can expire an older run and join the new period without a preceding status request', async () => {
|
|
setup(); await call({ action: 'start', periodId: 'p1' });
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState), oldId = state.run.id;
|
|
state.run.expiresAt = Date.now() - 1; user.cloudRiseState = JSON.stringify(state); openNextPeriod();
|
|
const result = await call({ action: 'start', periodId: 'p2' });
|
|
assert.equal(result.code, 1); assert.equal(result.data.run.periodId, 'p2'); assert.equal(result.data.run.status, 'playing');
|
|
assert.equal(db.cloudRiseRuns.get(oldId).status, 'expired');
|
|
assert.equal(db.cloudRiseSamples.size, 0, 'expiry is not a loss sample');
|
|
});
|
|
|
|
test('new registration never hides an ongoing older personal run or its unsaved reward', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
openNextPeriod();
|
|
let result = await call({});
|
|
assert.equal(result.data.available, false); assert.equal(result.data.run.periodId, 'p1');
|
|
assert.equal((await call({ action: 'start', periodId: 'p2' })).code, 0);
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
result = await call({}); assert.equal(result.data.run.status, 'waiting');
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1; user.cloudRiseState = JSON.stringify(state);
|
|
result = await call({});
|
|
assert.equal(result.data.run.status, 'expired'); assert.equal(result.data.available, false);
|
|
assert.equal((await call({ action: 'start', periodId: 'p2' })).code, 0);
|
|
const report = { action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 };
|
|
result = await call(report); assert.equal(result.data.run, null); assert.equal(result.data.available, true);
|
|
result = await call(report); assert.equal(result.code, 1); assert.equal(result.data.coinAmount, 200);
|
|
});
|
|
|
|
test('editing dates with the same periodId does not reset participation or hide its terminal result', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'loss' });
|
|
await call({ action: 'finish', runId: data.run.id, stage: 1, attemptId: 'loss', outcome: 'lose' });
|
|
configs.get('current').endsAt += 86400000;
|
|
const result = await call({});
|
|
assert.equal(result.data.run.status, 'failed'); assert.equal(result.data.available, false);
|
|
assert.equal((await call({ action: 'start', periodId: 'p1' })).code, 0);
|
|
});
|
|
|
|
|
|
test('form reward fields save as numbers and retries preserve a newer balance', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(0);
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.stages[0].opponents.slice(0, 49).forEach(o => o.success_num = 5);
|
|
user.cloudRiseState = JSON.stringify(state); await winStage(data.run, 1, 5);
|
|
assert.equal((await call({})).data.run.stages[0].survivors, 50);
|
|
const report = { action: 'save_reward', runId: data.run.id, stage: '1', reward: '200', coinAmount: '300' };
|
|
const result = await call(report);
|
|
assert.equal(result.code, 1); assert.equal(result.data.run.stages[0].reward, 200);
|
|
assert.equal(user.coinAmount, 300); assert.equal(typeof user.coinAmount, 'number');
|
|
assert.equal(result.data.run.stages[0].rewardSaved, true);
|
|
await saveCoins({ coinAmount: 80 }); await call(report);
|
|
assert.equal(user.coinAmount, 80, 'a repeated receipt cannot credit twice or overwrite a newer balance');
|
|
});
|
|
|
|
test('invalid form or JSON reward integers leave both balance and receipt untouched', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
const report = { action: 'save_reward', runId: data.run.id, stage: '1', reward: '100', coinAmount: '200' };
|
|
for (const field of ['reward', 'coinAmount']) {
|
|
for (const value of [undefined, null, true, false, [], [200], {}, '', ' ', 'NaN', 'Infinity', '100x',
|
|
'1.5', '1e3', '0x10', '-1', '0', '9007199254740992', 1.5, -1, NaN, Infinity, 9007199254740992]) {
|
|
assert.equal((await call({ ...report, [field]: value })).code, 0, `${field}: ${String(value)}`);
|
|
assert.equal(db.users.get('u').coinAmount, 100);
|
|
assert.equal(!!JSON.parse(db.users.get('u').cloudRiseState).run.stages[0].rewardSaved, false);
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
test('admin saves custom pools in activityConfigs and rejects invalid payloads',async()=>{
|
|
setup();process.env.ADMIN_TOKEN='test-only';
|
|
const config={periodId:'future',startsAt:Date.now()+86400000,endsAt:Date.now()+2*86400000,unlockLevel:1};
|
|
let revision=0;
|
|
const save=config=>adminApi({body:{action:'save',adminToken:'test-only',configVersion:'v'+(++revision),config:JSON.stringify(config)}});
|
|
assert.deepEqual((await save(config)).data.pools,[10000,15000,20000]);
|
|
const pools=[123,456,789];assert.deepEqual((await save({...config,pools})).data.pools,pools);
|
|
const count=configs.size;
|
|
for(const invalid of [[],[1,2],[0,1,2],[1,-1,3],[1,2,1.5],['1',2,3]])assert.equal((await save({...config,pools:invalid})).code,0);
|
|
assert.equal(configs.size,count);delete process.env.ADMIN_TOKEN;
|
|
});
|
|
|
|
test('signup freezes all three pools across config edits, closing and a new period; archives keep the snapshot', async () => {
|
|
setup(); const pools = [12345, 23456, 34567], nextPools = [30000, 40000, 50000];
|
|
configs.get('current').pools = pools;
|
|
let result = await call({ action: 'start', periodId: 'p1' });
|
|
const run = result.data.run;
|
|
assert.deepEqual(run.pools, pools);
|
|
assert.deepEqual(JSON.parse(db.users.get('u').cloudRiseState).run.pools, pools);
|
|
configs.get('current').pools = nextPools;
|
|
assert.deepEqual((await call({})).data.pools, pools);
|
|
for (let stage = 1; stage <= 3; stage++) {
|
|
if (stage === 2) configs.get('current').enabled = false;
|
|
if (stage === 3) Object.assign(configs.get('current'), { enabled: true, periodId: 'p2' });
|
|
if (stage > 1) result = await call({ action: 'start_stage', runId: run.id, stage });
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.run.stages.at(-1).pool, pools[stage - 1]);
|
|
assert.deepEqual(result.data.pools, pools);
|
|
if (stage === 2) { assert.equal(result.data.period.enabled, undefined); assert.equal(result.data.available, false); }
|
|
if (stage === 3) assert.deepEqual(result.data.period.pools, pools);
|
|
forceScores([5, 7, 9][stage - 1]); await winStage(run, stage, [5, 7, 9][stage - 1]);
|
|
const reward = Math.ceil(pools[stage - 1] / 100);
|
|
result = await call({ action: 'save_reward', runId: run.id, stage, reward,
|
|
coinAmount: db.users.get('u').coinAmount + reward });
|
|
assert.equal(result.code, 1);
|
|
}
|
|
assert.equal(result.data.run.status, 'completed');
|
|
afterCooldown();
|
|
const nextPeriod = await openPeriod(1001);
|
|
result = await call({action:'status'});
|
|
assert.equal(result.data.run, null); assert.deepEqual(result.data.pools, nextPools);
|
|
assert.deepEqual([...db.cloudRiseRuns.values()][0].pools, pools);
|
|
result = await call({ action: 'start', periodId: nextPeriod.periodId });
|
|
assert.equal(result.code, 1); assert.deepEqual(result.data.run.pools, nextPools);
|
|
assert.equal(result.data.run.stages[0].pool, nextPools[0]);
|
|
});
|
|
|
|
test('legacy configs and runs retain defaults without applying newly configured pools', async () => {
|
|
setup(); assert.deepEqual((await call({})).data.pools, [10000, 15000, 20000]);
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
delete state.run.pools; state.run.stages[0].pool = 11000;
|
|
user.cloudRiseState = JSON.stringify(state);
|
|
configs.get('current').pools = [30000, 40000, 50000];
|
|
assert.deepEqual((await call({})).data.pools, [11000, 15000, 20000]);
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
const result = await call({ action: 'start_stage', runId: data.run.id, stage: 2 });
|
|
assert.equal(result.code, 1); assert.equal(result.data.run.stages[1].pool, 15000);
|
|
assert.deepEqual(JSON.parse(user.cloudRiseState).run.pools, [11000, 15000, 20000]);
|
|
});
|
|
|
|
test('an opened period stays joinable when stored progress lags behind the client', async () => {
|
|
for (const completed of [103, 109, 110]) {
|
|
setup(); configs.get('current').unlockLevel = 110;
|
|
db.users.get('u').levelAmount = completed;
|
|
const status = await call({});
|
|
assert.equal(status.code, 1); assert.equal(status.data.period.unlockLevel, 110);
|
|
assert.equal(status.data.available, true);
|
|
const result = await call({ action: 'start', periodId: 'p1' });
|
|
assert.equal(result.code, 1);
|
|
}
|
|
});
|
|
|
|
|
|
const sample = (stage, success_num, extra = {}) => ({ stage, start_level: 100, success_num, outcome: 'lost', reason: 'lose', endedAt: 123, ...extra });
|
|
const sampleDoc = (runId, samples, extra = {}) => ({ _id: runId, schemaVersion: 2, uid: '1001', runId, periodId: 'p1', samples, ...extra });
|
|
const histogram = stage => aggregate([...db.cloudRiseSamples.values()], sampleHistogramPipeline(stage));
|
|
|
|
test('stage samples append once under concurrent retries and older saved snapshots preserve later stages', async () => {
|
|
setup(); const result = await call({ action: 'start', periodId: 'p1' });const runId = result.data.run.id;
|
|
forceScores(); await winStage(result.data.run, 1, 5);
|
|
const saved = db.users.get('u').cloudRiseState;
|
|
await call({ action: 'start_stage', runId, stage: 2 });
|
|
await call({ action: 'begin', runId, stage: 2, attemptId: 'lost' });
|
|
await Promise.all(Array.from({ length: 6 }, () => call({ action: 'finish', runId, stage: 2, attemptId: 'lost', outcome: 'lose' })));
|
|
assert.equal(db.cloudRiseSamples.size, 1);
|
|
const doc = db.cloudRiseSamples.get(runId);
|
|
assert.equal(doc.schemaVersion, 2);assert.equal(doc.uid, '1001');assert.equal(doc.periodId, 'p1');
|
|
assert.deepEqual(Object.keys(doc).sort(),['_id','schemaVersion','uid','runId','periodId','samples'].sort());
|
|
assert.equal(doc._id,runId);assert.equal(doc.runId,runId);
|
|
for(const item of doc.samples)assert.deepEqual(Object.keys(item).sort(),['stage','start_level','success_num','outcome','reason','endedAt'].sort());
|
|
assert.deepEqual(doc.samples.map(s => s.stage).sort(), [1,2]);
|
|
db.users.get('u').cloudRiseState = saved;await call({ action: 'status' });
|
|
assert.deepEqual(doc.samples.map(s => s.stage).sort(), [1,2]);
|
|
assert.equal(doc.samples[1].success_num, 0);
|
|
});
|
|
|
|
test('a failed append retries from user state without losing or duplicating the stage sample', async () => {
|
|
setup();const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'lost' });
|
|
sampleAppendFails = 1;
|
|
const failed = await call({ action: 'finish', runId: data.run.id, stage: 1, attemptId: 'lost', outcome: 'lose' });
|
|
assert.equal(failed.data.sampleSyncPending, true);assert.equal(db.cloudRiseSamples.get(data.run.id).samples.length, 0);
|
|
assert.equal((await call({ action: 'status' })).data.sampleSyncPending, false);
|
|
await call({ action: 'status' });assert.equal(db.cloudRiseSamples.get(data.run.id).samples.length, 1);
|
|
});
|
|
|
|
test('array-only histogram counts equal scores across players and periods without mixing stages', () => {
|
|
setup();
|
|
const rows = [
|
|
sampleDoc('r1',[sample(1,2),sample(2,7)]),
|
|
sampleDoc('r2',[sample(1,2)],{periodId:'p2'}),
|
|
sampleDoc('r3',[sample(1,0)],{uid:'1002'}),
|
|
sampleDoc('r4',[sample(1,4),sample(2,6)],{uid:'1003'}),
|
|
sampleDoc('invalid',[sample(1,1,{outcome:'expired'}),sample(1,9),sample(1,2,{start_level:1961})]),
|
|
{_id:'flat',runId:'flat',uid:'1004',periodId:'p1',...sample(1,5)},
|
|
];
|
|
for(const row of rows)db.cloudRiseSamples.set(row._id,row);
|
|
assert.deepEqual(histogram(1),[{_id:{start:100,score:2},count:2},{_id:{start:100,score:0},count:1},{_id:{start:100,score:4},count:1}]);
|
|
assert.deepEqual(histogram(2),[{_id:{start:100,score:7},count:1},{_id:{start:100,score:6},count:1}]);
|
|
assert.deepEqual(histogram(3),[]);
|
|
});
|
|
|
|
test('sample indexes support only nested scores and one document per player-period', async () => {
|
|
setup();process.env.ADMIN_TOKEN='test-only';await adminApi({body:{action:'setup_indexes',adminToken:'test-only'}});
|
|
assert(!indexes.some(i=>i.name==='cloudRiseSamples'&&i.spec.stage===1));
|
|
assert(indexes.some(i=>i.name==='cloudRiseSamples'&&i.spec['samples.stage']===1&&i.spec['samples.start_level']===1&&i.spec['samples.success_num']===1));
|
|
assert(indexes.some(i=>i.name==='cloudRiseSamples'&&i.options?.unique&&i.spec.uid===1&&i.spec.periodId===1&&i.options.partialFilterExpression.schemaVersion===2));
|
|
delete process.env.ADMIN_TOKEN;
|
|
});
|
|
|
|
test('durationHours is snapshotted at signup and later config edits preserve expiry through stage changes', async () => {
|
|
setup(); const config = configs.get('current'); config.durationHours = 36;
|
|
const realNow = Date.now, now = realNow(); Date.now = () => now;
|
|
try {
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
assert.equal(data.period.durationHours, 36); assert.equal(data.run.durationHours, 36);
|
|
assert.equal(data.run.expiresAt, db.users.get('u').cloudRisePeriod.endsAt);
|
|
config.durationHours = 1; config.endsAt = now;
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
await call({ action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 });
|
|
const next = await call({ action: 'start_stage', runId: data.run.id, stage: 2 });
|
|
assert.equal(next.code, 1); assert.equal(next.data.run.expiresAt, data.run.expiresAt);
|
|
assert.equal(next.data.run.durationHours, 36);
|
|
Date.now = () => data.run.expiresAt;
|
|
assert.equal((await call({})).data.run.status, 'expired');
|
|
} finally { Date.now = realNow; }
|
|
});
|
|
|
|
test('legacy configurations default to 24 hours and legacy runs keep their saved deadlines', async () => {
|
|
setup(); delete configs.get('current').durationHours;
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
assert.equal(data.run.durationHours,24); assert.equal(data.run.expiresAt,db.users.get('u').cloudRisePeriod.endsAt);
|
|
const state = JSON.parse(db.users.get('u').cloudRiseState); delete state.run.durationHours;
|
|
db.users.get('u').cloudRiseState = JSON.stringify(state);
|
|
configs.get('current').durationHours = 48;
|
|
assert.equal((await call({})).data.run.expiresAt, data.run.expiresAt);
|
|
});
|
|
|
|
test('legacy migration action directs operators to the shared collection migration without writes',async()=>{
|
|
setup();process.env.ADMIN_TOKEN='test-only';const before=structuredClone([...db.activityConfigs]);
|
|
assert.equal((await adminApi({body:{action:'migrate_config'}})).code,0);
|
|
assert.equal((await adminApi({body:{action:'migrate_config',adminToken:'test-only'}})).code,0);
|
|
assert.deepEqual([...db.activityConfigs],before);delete process.env.ADMIN_TOKEN;
|
|
});
|
|
|
|
test('draft matching and cancellation never consume enrollment; retry confirms exactly once', async () => {
|
|
setup();
|
|
const prepare = id => call({action:'prepare_match', matchId:id, stage:1, periodId:'p1'});
|
|
const first = await prepare('match-first');
|
|
assert.equal(first.code,1); assert.equal(first.data.available,true); assert.equal(first.data.run,null);
|
|
assert.equal(first.data.matching.stage.opponents.length,99);
|
|
assert.equal(db.cloudRiseRuns.size,0); assert.equal(db.cloudRiseSamples.size,0);
|
|
assert.equal((await call({action:'cancel_match',matchId:'match-first'})).code,1);
|
|
assert.equal((await call({action:'status'})).data.matching,null);
|
|
assert.equal((await prepare('match-first')).data.matching,null,'late duplicate cannot resurrect cancelled preparation');
|
|
assert.equal((await call({action:'confirm_match',matchId:'match-first'})).code,0);
|
|
assert.equal((await prepare('match-second')).code,1);
|
|
const confirmed = await call({action:'confirm_match',matchId:'match-second'});
|
|
assert.equal(confirmed.code,1); assert.equal(confirmed.data.available,false); assert.equal(confirmed.data.run.status,'playing');
|
|
const runId=confirmed.data.run.id;
|
|
await call({action:'begin',runId,stage:1,attemptId:'attempt-1'});
|
|
const again=await call({action:'confirm_match',matchId:'match-second'});
|
|
assert.equal(again.data.run.stages[0].attemptId,'attempt-1');
|
|
assert.deepEqual(JSON.parse(db.users.get('u').cloudRiseState).playedPeriods,['p1']);
|
|
});
|
|
|
|
test('cancel arriving before or concurrently with prepare wins and does not cancel a new match', async()=>{
|
|
for(const concurrent of [false,true]){
|
|
setup(); const prepare=()=>call({action:'prepare_match',matchId:'race-old',stage:1,periodId:'p1'});
|
|
const cancel=()=>call({action:'cancel_match',matchId:'race-old'});
|
|
if(concurrent) await Promise.all([prepare(),cancel()]); else {await cancel(); await prepare();}
|
|
const state=JSON.parse(db.users.get('u').cloudRiseState);
|
|
assert.equal(state.pendingMatch,undefined);assert.deepEqual(state.playedPeriods,[]);assert.equal(state.run,null);
|
|
await call({action:'prepare_match',matchId:'race-new',stage:1,periodId:'p1'});
|
|
assert.equal((await cancel()).data.matching.id,'race-new');
|
|
assert.equal((await call({action:'confirm_match',matchId:'race-new'})).code,1);
|
|
}
|
|
});
|
|
|
|
test('later-stage cancellation preserves wins, reward receipts and deadline; concurrent receipt survives confirmation',async()=>{
|
|
setup();const {data}=await call({action:'start',periodId:'p1'});forceScores();await winStage(data.run,1,5);
|
|
const before=(await call({action:'status'})).data.run;
|
|
const prepare=id=>call({action:'prepare_match',matchId:id,runId:before.id,stage:2});
|
|
await prepare('stage-two-cancel');
|
|
const cancelled=await call({action:'cancel_match',matchId:'stage-two-cancel'});
|
|
assert.deepEqual(cancelled.data.run,before);
|
|
await prepare('stage-two-confirm');
|
|
await call({action:'save_reward',runId:before.id,stage:1,reward:100,coinAmount:200});
|
|
const confirmed=await call({action:'confirm_match',matchId:'stage-two-confirm'});
|
|
assert.equal(confirmed.code,1);assert.equal(confirmed.data.run.stage,2);
|
|
assert.equal(confirmed.data.run.expiresAt,before.expiresAt);
|
|
assert.equal(confirmed.data.run.stages[0].rewardSaved,true);assert.equal(confirmed.data.run.stages[0].reward,100);
|
|
assert.equal(confirmed.data.coinAmount,200);
|
|
});
|
|
|
|
test('registration closure before confirmation consumes no opportunity, and cancellation still succeeds',async()=>{
|
|
setup();await call({action:'prepare_match',matchId:'expired-match',stage:1,periodId:'p1'});
|
|
configs.get('current').endsAt=Date.now()-1; db.users.get('u').cloudRisePeriod.endsAt=Date.now()-1;
|
|
assert.equal((await call({action:'confirm_match',matchId:'expired-match'})).code,0);
|
|
assert.equal((await call({action:'cancel_match',matchId:'expired-match'})).code,1);
|
|
const state=JSON.parse(db.users.get('u').cloudRiseState);assert.equal(state.run,null);assert.deepEqual(state.playedPeriods,[]);
|
|
});
|
|
|
|
test('client level selects all three matching stages without modifying stored mainline progress', async () => {
|
|
setup(); let runId;
|
|
for (let stage = 1; stage <= 3; stage++) {
|
|
const levelAmount = [103, 156, 210][stage - 1], matchId = 'client-level-' + stage;
|
|
const body = { action: 'prepare_match', matchId, stage, levelAmount: String(levelAmount),
|
|
...(stage === 1 ? { periodId: 'p1' } : { runId }) };
|
|
const draft = await call(body);
|
|
assert.equal(draft.code, 1); assert.equal(draft.data.matching.stage.start_level, levelAmount + 1);
|
|
const retry = await call({ ...body, levelAmount: levelAmount + 50 });
|
|
assert.deepEqual(retry.data.matching, draft.data.matching, 'retry keeps the original matching snapshot');
|
|
const result = await call({ action: 'confirm_match', matchId });
|
|
assert.equal(result.code, 1); runId = result.data.run.id;
|
|
assert.equal(result.data.run.stages.at(-1).start_level, levelAmount + 1);
|
|
assert.equal(db.users.get('u').levelAmount, 99);
|
|
if (stage < 3) { forceScores([5, 7, 9][stage - 1]); await winStage(result.data.run, stage, [5, 7, 9][stage - 1]); }
|
|
}
|
|
});
|
|
|
|
test('direct stage entry uses client level; cancelled matching may restart with newer local progress', async () => {
|
|
setup(); let result = await call({ action: 'start', periodId: 'p1', levelAmount: 150 });
|
|
assert.equal(result.data.run.stages[0].start_level, 151);
|
|
forceScores(); await winStage(result.data.run, 1, 5);
|
|
result = await call({ action: 'start_stage', runId: result.data.run.id, stage: 2, levelAmount: '2000' });
|
|
assert.equal(result.data.run.stages[1].start_level, 2001, 'player progress is not capped to opponent sample range');
|
|
assert.equal(db.users.get('u').levelAmount, 99);
|
|
setup(); await call({ action: 'prepare_match', matchId: 'cancel-level', stage: 1, periodId: 'p1', levelAmount: 103 });
|
|
await call({ action: 'cancel_match', matchId: 'cancel-level' });
|
|
result = await call({ action: 'prepare_match', matchId: 'restart-level', stage: 1, periodId: 'p1', levelAmount: 120 });
|
|
assert.equal(result.data.matching.stage.start_level, 121); assert.equal(result.data.available, true);
|
|
});
|
|
|
|
test('matching level accepts zero and rejects malformed explicit values without consuming participation', async () => {
|
|
for (const levelAmount of [-1, 1.5, '', '12x', null, true, Number.MAX_SAFE_INTEGER]) {
|
|
setup();
|
|
const result = await call({ action: 'prepare_match', matchId: 'invalid-level', stage: 1, periodId: 'p1', levelAmount });
|
|
assert.equal(result.code, 0); assert.equal(result.msg, '当前关卡数无效');
|
|
assert.equal(db.users.get('u').cloudRiseState, undefined);
|
|
}
|
|
setup();
|
|
const result = await call({ action: 'prepare_match', matchId: 'zero-level', stage: 1, periodId: 'p1', levelAmount: '0' });
|
|
assert.equal(result.code, 1); assert.equal(result.data.matching.stage.start_level, 1);
|
|
});
|
|
|
|
test('another device resumes the same matching snapshot without overwriting either mainline progress or opponents', async () => {
|
|
setup();
|
|
const matchId = 'device-a-match';
|
|
const prepared = await call({ action: 'prepare_match', matchId, stage: 1, periodId: 'p1', levelAmount: 120 });
|
|
assert.equal(prepared.code, 1);
|
|
const matching = structuredClone(prepared.data.matching);
|
|
assert.equal(matching.stage.start_level, 121);
|
|
// The account's normal mainline sync may change independently while another device opens the activity.
|
|
db.users.get('u').levelAmount = 150;
|
|
const restored = await call({ action: 'status', levelAmount: 103 });
|
|
assert.deepEqual(restored.data.matching, matching);
|
|
const retried = await call({ action: 'prepare_match', matchId, stage: 1, periodId: 'p1', levelAmount: 103 });
|
|
assert.deepEqual(retried.data.matching, matching);
|
|
const confirmed = await call({ action: 'confirm_match', matchId, levelAmount: 103 });
|
|
assert.equal(confirmed.code, 1);
|
|
assert.equal(confirmed.data.run.stages[0].start_level, 121);
|
|
assert.deepEqual(confirmed.data.run.stages[0].opponents, matching.stage.opponents);
|
|
assert.equal(db.users.get('u').levelAmount, 150);
|
|
const again = await call({ action: 'confirm_match', matchId, levelAmount: 180 });
|
|
assert.deepEqual(again.data.run, confirmed.data.run);
|
|
assert.equal(db.users.get('u').levelAmount, 150);
|
|
});
|
|
|
|
|
|
test('shared config lookup ignores gold miner and draft versions',async()=>{
|
|
setup();const original=structuredClone(db.activityConfigs.get('current'));
|
|
db.activityConfigs.set('gold',{...original,_id:'gold',activityId:'goldMiner',config:{...original.config,periodId:'wrong'}});
|
|
db.activityConfigs.set('draft',{...original,_id:'draft',status:'draft',publishedAt:original.publishedAt+1,config:{...original.config,periodId:'draft'}});
|
|
const result=await call({action:'status'});assert.equal(result.code,1);assert.equal(result.data.period.periodId,'p1');
|
|
});
|
|
|
|
|
|
test('late publication is readable while the enrollment window and effective time remain enforced',async()=>{
|
|
setup();const now=Date.now(),row=db.activityConfigs.get('current');
|
|
row.publishedAt=now;
|
|
assert.ok(row.publishedAt>row.config.startsAt);
|
|
const status=await call({action:'status'});
|
|
assert.equal(status.code,1);assert.equal(status.data.period.periodId,'p1');
|
|
assert.equal(status.data.available,true);assert.equal(row.publishedAt,now);
|
|
const startsAt=row.config.startsAt,endsAt=row.config.endsAt;
|
|
row.effectiveFrom=now+1000;
|
|
assert.equal(await findOpenPeriod(now),null);
|
|
row.config.startsAt=now+1000;
|
|
assert.equal(await findOpenPeriod(now),null);
|
|
row.config.startsAt=startsAt;row.effectiveFrom=startsAt+1;
|
|
assert.equal(await findOpenPeriod(now),null);
|
|
row.effectiveFrom=startsAt;row.config.endsAt=now;
|
|
assert.equal(await findOpenPeriod(now),null);
|
|
row.config.endsAt=endsAt;
|
|
db.activityConfigs.set('newer',{...structuredClone(row),_id:'newer',configVersion:'newer',publishedAt:now+1});
|
|
assert.equal((await findOpenPeriod(now+1)).configVersion,'newer');
|
|
});
|
|
|
|
|
|
test('cloudRise published example passes admin validation and creates the shared envelope',async()=>{
|
|
setup();process.env.ADMIN_TOKEN='test-only';const original=Date.now;
|
|
Date.now=()=>Date.parse('2026-09-20T00:00:00+08:00');
|
|
try {
|
|
const body=JSON.parse(await readFile(new URL('../cloudRise-config.publish.example.json',import.meta.url),'utf8'));
|
|
body.adminToken='test-only';const result=await adminApi({body});assert.equal(result.code,1,JSON.stringify(result));
|
|
const row=[...db.activityConfigs.values()].find(r=>r.configVersion===body.configVersion);
|
|
assert.equal(row.activityId,'cloudRise');assert.deepEqual(row.config.pools,[10000,15000,20000]);
|
|
assert.equal(row.effectiveFrom,body.config.startsAt);
|
|
} finally {Date.now=original;delete process.env.ADMIN_TOKEN;}
|
|
});
|
|
|
|
|
|
test('compact drafts keep only their own opponents across all stages; confirmation appends once', async () => {
|
|
setup(); let runId;
|
|
const saved = () => JSON.parse(db.users.get('u').cloudRiseState);
|
|
for (let stage = 1; stage <= 3; stage++) {
|
|
const before = db.users.get('u').cloudRiseState ? saved().run : null;
|
|
const matchId = 'compact-stage-' + stage;
|
|
const body = { action: 'prepare_match', stage, matchId,
|
|
...(stage === 1 ? { periodId: 'p1' } : { runId }) };
|
|
assert.equal((await call(body)).code, 1);
|
|
const pending = saved().pendingMatch;
|
|
assert.equal(pending.run.stages.length, 1);
|
|
assert.equal(pending.run.stages[0].stage, stage);
|
|
assert.equal(pending.run.stages[0].opponents.length, 99);
|
|
assert.deepEqual(saved().run, before, 'preparation must not change official stages');
|
|
await call(body);
|
|
assert.deepEqual(saved().pendingMatch, pending, 'preparation retry must not reroll');
|
|
const confirmed = await call({ action: 'confirm_match', matchId });
|
|
assert.equal(confirmed.code, 1); runId = confirmed.data.run.id;
|
|
const run = saved().run;
|
|
assert.equal(run.stages.length, stage);
|
|
assert.deepEqual(run.stages.slice(0, -1), before?.stages || []);
|
|
assert.deepEqual(run.stages.at(-1).opponents, pending.run.stages[0].opponents);
|
|
assert.ok(run.stages.every(s => s.opponents.length === 99));
|
|
await call({ action: 'confirm_match', matchId });
|
|
assert.deepEqual(saved().run, run);
|
|
assert.equal(saved().pendingMatch, undefined);
|
|
forceScores([5, 7, 9][stage - 1]);
|
|
await winStage(run, stage, [5, 7, 9][stage - 1]);
|
|
assert.equal((await call({ action: 'save_reward', runId, stage, reward: 100, coinAmount: 100 + 100 * stage })).code, 1);
|
|
}
|
|
const live = saved().run, archive = db.cloudRiseRuns.get(runId);
|
|
assert.equal(live.status, 'completed');
|
|
assert.deepEqual(archive, { _id: runId, uid: '1001', ...live,
|
|
stages: live.stages.map(({ opponents, ...summary }) => summary) });
|
|
assert.equal(live.stages.reduce((n, s) => n + s.opponents.length, 0), 297);
|
|
const original = structuredClone(archive);
|
|
await call({ action: 'status' });
|
|
await call({ action: 'save_reward', runId, stage: 3, reward: 100, coinAmount: 400 });
|
|
assert.deepEqual(db.cloudRiseRuns.get(runId), original, 'archive and reward retries are idempotent');
|
|
assert.equal(db.users.get('u').coinAmount, 400);
|
|
});
|
|
|
|
test('legacy full-run drafts compact durably on status and keep matches and late reward receipts', async () => {
|
|
for (const objectState of [false, true]) {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); await winStage(data.run, 1, 5);
|
|
await call({ action: 'prepare_match', stage: 2, runId: data.run.id, matchId: 'legacy-draft' });
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
const ownStage = structuredClone(state.pendingMatch.run.stages[0]);
|
|
state.pendingMatch.run.stages = [...structuredClone(state.run.stages), ownStage];
|
|
user.cloudRiseState = objectState ? state : JSON.stringify(state);
|
|
const status = await call({ action: 'status' });
|
|
assert.equal(status.code, 1);
|
|
const compact = JSON.parse(user.cloudRiseState);
|
|
assert.deepEqual(compact.pendingMatch.run.stages, [ownStage]);
|
|
assert.deepEqual(compact.run, state.run);
|
|
assert.equal(status.data.matching.stage.opponents.length, 99);
|
|
if (objectState) assert.equal(state.pendingMatch.run.stages.length, 2, 'CAS source object must not be mutated');
|
|
await call({ action: 'save_reward', runId: data.run.id, stage: 1, reward: 100, coinAmount: 200 });
|
|
const confirmed = await call({ action: 'confirm_match', matchId: 'legacy-draft' });
|
|
assert.equal(confirmed.code, 1);
|
|
assert.equal(confirmed.data.run.stages[0].rewardSaved, true);
|
|
assert.deepEqual(JSON.parse(user.cloudRiseState).run.stages[1].opponents, ownStage.opponents);
|
|
}
|
|
});
|
|
|
|
test('failed and expired archives omit opponent copies while status retains settlement avatars', async () => {
|
|
for (const expired of [false, true]) {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
if (expired) {
|
|
const state = JSON.parse(db.users.get('u').cloudRiseState);
|
|
state.run.expiresAt = Date.now() - 1;
|
|
db.users.get('u').cloudRiseState = JSON.stringify(state);
|
|
} else {
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'lost-round' });
|
|
assert.equal((await call({ action: 'finish', runId: data.run.id, stage: 1, attemptId: 'lost-round', outcome: 'lose' })).code, 1);
|
|
}
|
|
const status = await call({ action: 'status' });
|
|
assert.equal(status.data.run.status, expired ? 'expired' : 'failed');
|
|
assert.equal(status.data.run.stages[0].opponents.length, 99);
|
|
const archive = db.cloudRiseRuns.get(data.run.id);
|
|
assert.equal('opponents' in archive.stages[0], false);
|
|
assert.equal(archive.stages[0].survivors, status.data.run.stages[0].survivors);
|
|
}
|
|
});
|
|
|
|
test('archive compaction is authenticated, paginated and idempotent without touching live state', async () => {
|
|
setup(); const oldToken = process.env.ADMIN_TOKEN;
|
|
process.env.ADMIN_TOKEN = 'compact-test';
|
|
try {
|
|
const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
const userBefore = structuredClone(db.users.get('u'));
|
|
const stage = JSON.parse(userBefore.cloudRiseState).run.stages[0];
|
|
for (const [id, status] of [['a', 'completed'], ['b', 'failed'], ['c', 'expired'], ['d', 'playing']]) {
|
|
db.cloudRiseRuns.set(id, { _id: id, id, uid: '1001', status,
|
|
stages: [structuredClone(stage), { stage: 2, reward: 120, rewardSaved: true }] });
|
|
}
|
|
const originals = structuredClone([...db.cloudRiseRuns]);
|
|
const runAdmin = body => adminApi({ body: { action: 'compact_archives', adminToken: 'compact-test', ...body } });
|
|
assert.equal((await runAdmin({ adminToken: 'wrong' })).code, 0);
|
|
for (const limit of [0, 501, 1.5]) assert.equal((await runAdmin({ limit })).code, 0);
|
|
assert.equal((await runAdmin({ afterId: 5 })).code, 0);
|
|
assert.deepEqual([...db.cloudRiseRuns], originals);
|
|
const first = await runAdmin({ limit: 2 });
|
|
assert.equal(first.code, 1); assert.deepEqual(first.data, { compacted: 2, nextCursor: 'b' });
|
|
const second = await runAdmin({ limit: 2, afterId: first.data.nextCursor });
|
|
assert.deepEqual(second.data, { compacted: 1, nextCursor: null });
|
|
assert.deepEqual((await runAdmin({})).data, { compacted: 0, nextCursor: null });
|
|
for (const [id, original] of originals) {
|
|
const expected = id === 'd' ? original : { ...original,
|
|
stages: original.stages.map(({ opponents, ...summary }) => summary) };
|
|
assert.deepEqual(db.cloudRiseRuns.get(id), expected);
|
|
}
|
|
assert.deepEqual(db.users.get('u'), userBefore);
|
|
assert.equal((await call({ action: 'status' })).data.run.id, data.run.id);
|
|
} finally {
|
|
if (oldToken === undefined) delete process.env.ADMIN_TOKEN;
|
|
else process.env.ADMIN_TOKEN = oldToken;
|
|
}
|
|
});
|
|
|
|
|
|
test('analytics start counts only finishing bots after confirmation and not cancelled preparations', async () => {
|
|
setup();
|
|
await call({ action: 'prepare_match', stage: 1, periodId: 'p1', matchId: 'analytics-cancel' });
|
|
assert.equal(analyticsReports.length, 0);
|
|
await call({ action: 'cancel_match', matchId: 'analytics-cancel' });
|
|
assert.equal(analyticsReports.length, 0);
|
|
await call({ action: 'prepare_match', stage: 1, periodId: 'p1', matchId: 'analytics-start' });
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.pendingMatch.run.stages[0].opponents.forEach((o,i) => { o.success_num = i < 17 ? 5 : 4; });
|
|
user.cloudRiseState = JSON.stringify(state);
|
|
assert.equal((await call({ action: 'confirm_match', matchId: 'analytics-start', isDebug: 'true' })).code, 1);
|
|
assert.equal(analyticsReports.length, 1);
|
|
assert.equal(analyticsReports[0].event, 'cloud_rise_start');
|
|
assert.equal(analyticsReports[0].appId, '95993f9ab6f1402a87abe5147827e5e0');
|
|
assert.deepEqual(analyticsReports[0].properties, { stage: 1, end_count: 17 });
|
|
await call({ action: 'confirm_match', matchId: 'analytics-start' }); await call({ action: 'status' });
|
|
assert.equal(analyticsReports.length, 1);
|
|
assert.equal(JSON.parse(user.cloudRiseState).analyticsQueue, undefined);
|
|
});
|
|
|
|
test('analytics reports all 5/7/9 steps and each saved stage award exactly once', async () => {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1', isDebug: false });
|
|
for (let stage = 1; stage <= 3; stage++) {
|
|
if (stage > 1) assert.equal((await call({ action: 'start_stage', runId: data.run.id, stage })).code, 1);
|
|
const target = [5,7,9][stage-1]; forceScores(target);
|
|
await winStage(data.run, stage, target);
|
|
assert.equal(analyticsReports.filter(e => e.event === 'cloud_rise_succeed').length, stage - 1);
|
|
assert.equal((await call({ action: 'save_reward', runId: data.run.id, stage, reward: 210, coinAmount: 100 + 210 * stage })).code, 1);
|
|
await call({ action: 'save_reward', runId: data.run.id, stage, reward: 999, coinAmount: 999 });
|
|
await call({ action: 'finish', runId: data.run.id, stage, attemptId: 's' + stage + '-' + target, outcome: 'win' });
|
|
const steps = analyticsReports.filter(e => e.event === 'cloud_rise_step' && e.properties.stage === stage);
|
|
assert.deepEqual(steps.map(e => e.properties), Array.from({length:target}, (_,i) => ({stage, step:i+1, result:'success'})));
|
|
}
|
|
assert.equal(analyticsReports.filter(e => e.event === 'cloud_rise_start').length, 3);
|
|
assert.deepEqual(analyticsReports.filter(e => e.event === 'cloud_rise_succeed').map(e => e.properties),
|
|
[1,2,3].map(stage => ({ stage, coin_amount: 210 })));
|
|
assert.equal(analyticsReports.filter(e => e.event === 'cloud_rise_fail').length, 0);
|
|
assert.ok(analyticsReports.every(e => e.appId === '40e3d5c5f2af49a4a074205564ce5dbb'));
|
|
});
|
|
|
|
test('analytics loss sends failure step and extra fail event; interrupted rounds also fail once', async () => {
|
|
for (const outcome of ['lose', 'interrupted']) {
|
|
setup(); const { data } = await call({ action: 'start', periodId: 'p1' });
|
|
forceScores(); await winStage(data.run, 1, 2);
|
|
await call({ action: 'begin', runId: data.run.id, stage: 1, attemptId: 'analytics-loss' });
|
|
const body = { action: 'finish', runId: data.run.id, stage: 1, attemptId: 'analytics-loss', outcome };
|
|
assert.equal((await call(body)).code, 1); await call(body); await call({ action: 'status' });
|
|
assert.deepEqual(analyticsReports.slice(-2).map(e => [e.event,e.properties]), [
|
|
['cloud_rise_step', { stage:1, step:3, result:'failure' }], ['cloud_rise_fail', { stage:1, step:3 }],
|
|
]);
|
|
assert.equal(analyticsReports.filter(e => e.event === 'cloud_rise_fail').length, 1);
|
|
}
|
|
});
|
|
|
|
test('analytics outage keeps events durable with original environment and IDs without failing play', async () => {
|
|
setup(); analyticsOffline = true;
|
|
const start = await call({ action: 'start', periodId: 'p1', isDebug: 'false' });
|
|
assert.equal(start.code, 1);
|
|
const user = db.users.get('u'), queued = JSON.parse(user.cloudRiseState).analyticsQueue;
|
|
assert.equal(queued.length, 1);
|
|
assert.equal((await call({ action:'begin', runId:start.data.run.id, stage:1, attemptId:'analytics-offline' })).code, 1);
|
|
analyticsOffline = false;
|
|
await call({ action:'status', isDebug:'true' });
|
|
assert.deepEqual(analyticsReports, queued, 'retry must not change the originating project or event ID');
|
|
assert.equal(JSON.parse(user.cloudRiseState).analyticsQueue, undefined);
|
|
await call({ action:'status' }); assert.equal(analyticsReports.length, 1);
|
|
});
|
|
|
|
test('analytics acknowledgement cannot overwrite concurrent gameplay and retries share the same event ID', async () => {
|
|
setup(); analyticsOffline = true;
|
|
const { data } = await call({ action:'start', periodId:'p1' });
|
|
analyticsOffline = false;
|
|
analyticsOnSend = async () => {
|
|
assert.equal((await call({ action:'begin', runId:data.run.id, stage:1, attemptId:'analytics-race' })).code, 1);
|
|
};
|
|
await call({ action:'status' });
|
|
const state = JSON.parse(db.users.get('u').cloudRiseState);
|
|
assert.equal(state.run.stages[0].attemptId, 'analytics-race');
|
|
assert.equal(state.analyticsQueue, undefined);
|
|
assert.equal(analyticsReports.length, 2, 'concurrent delivery is possible, deduplicated by the same firstCheckId');
|
|
assert.equal(analyticsReports[0].id, analyticsReports[1].id);
|
|
});
|
|
|
|
test('analytics ignores failed requests and existing history; personal expiration emits only a stage failure', async () => {
|
|
setup(); const { data } = await call({ action:'start', periodId:'p1' });
|
|
const count = analyticsReports.length;
|
|
assert.equal((await call({ action:'finish', runId:data.run.id, stage:1, attemptId:'not-started', outcome:'win' })).code, 0);
|
|
assert.equal(analyticsReports.length, count);
|
|
await call({ action:'status' }); assert.equal(analyticsReports.length, count);
|
|
const user = db.users.get('u'), state = JSON.parse(user.cloudRiseState);
|
|
state.run.expiresAt = Date.now()-1; user.cloudRiseState = JSON.stringify(state);
|
|
assert.equal((await call({ action:'status' })).code, 1);
|
|
assert.deepEqual(analyticsReports.at(-1).properties, { stage:1, step:1 });
|
|
assert.equal(analyticsReports.at(-1).event, 'cloud_rise_fail');
|
|
assert.equal(analyticsReports.filter(e => e.event === 'cloud_rise_step').length, 0);
|
|
await call({ action:'status' }); assert.equal(analyticsReports.length, count+1);
|
|
});
|
|
|
|
|
|
test('analytics concurrent matching and finish retries use one event identity per committed result', async () => {
|
|
setup();
|
|
const starts = await Promise.all([call({action:'start',periodId:'p1'}),call({action:'start',periodId:'p1'})]);
|
|
assert.ok(starts.every(r => r.code === 1));
|
|
const runId=starts[0].data.run.id;
|
|
assert.equal(new Set(analyticsReports.filter(e=>e.event==='cloud_rise_start').map(e=>e.id)).size,1);
|
|
await call({action:'begin',runId,stage:1,attemptId:'analytics-concurrent'});
|
|
const results = await Promise.all([0,1].map(()=>call({action:'finish',runId,stage:1,attemptId:'analytics-concurrent',outcome:'win'})));
|
|
assert.ok(results.every(r => r.code === 1));
|
|
const steps=analyticsReports.filter(e=>e.event==='cloud_rise_step');
|
|
assert.ok(steps.length>0);assert.equal(new Set(steps.map(e=>e.id)).size,1);
|
|
assert.deepEqual(steps[0].properties,{stage:1,step:1,result:'success'});
|
|
assert.equal(JSON.parse(db.users.get('u').cloudRiseState).run.stages[0].success_num,1);
|
|
});
|
|
|
|
test('analytics outage cannot undo a saved award or turn a retry amount into a second success event', async () => {
|
|
setup();const {data}=await call({action:'start',periodId:'p1'});forceScores();await winStage(data.run,1,5);
|
|
analyticsOffline=true;
|
|
assert.equal((await call({action:'save_reward',runId:data.run.id,stage:1,reward:210,coinAmount:310})).code,1);
|
|
assert.equal(db.users.get('u').coinAmount,310);
|
|
const queue=JSON.parse(db.users.get('u').cloudRiseState).analyticsQueue;
|
|
assert.equal(queue.length,1);assert.deepEqual(queue[0].properties,{stage:1,coin_amount:210});
|
|
analyticsOffline=false;
|
|
assert.equal((await call({action:'save_reward',runId:data.run.id,stage:1,reward:990,coinAmount:1090})).code,1);
|
|
assert.equal(db.users.get('u').coinAmount,310);
|
|
assert.deepEqual(analyticsReports.filter(e=>e.event==='cloud_rise_succeed'),queue);
|
|
});
|
|
|
|
|
|
test('personal Home opening creates one period without enrollment and repeated/concurrent logins preserve it', async()=>{
|
|
setup();const now=Date.now();
|
|
const [a,b]=await Promise.all([openPeriod(1001,now),openPeriod(1001,now)]);
|
|
assert.deepEqual(a,b);assert.equal(a.startsAt,now);assert.equal(a.endsAt-now,86400000);
|
|
assert.equal(db.users.get('u').cloudRiseState,undefined);
|
|
assert.deepEqual(await openPeriod(1001,now+1000),a);
|
|
assert.equal(db.cloudRiseRuns.size,0);assert.equal(db.cloudRiseSamples.size,0);assert.equal(analyticsReports.length,0);
|
|
});
|
|
|
|
test('Home request owns the unlock decision; the server only deduplicates active periods', async()=>{
|
|
setup();configs.get('current').unlockLevel=100;
|
|
const period=await openPeriod(1001);
|
|
assert.equal(period.unlockLevel,100);
|
|
db.users.get('u').levelAmount=101;
|
|
const next=await openPeriod(1001,period.endsAt+PersonalPeriods.COOLDOWN_MS+1);
|
|
assert.notEqual(next.periodId,period.periodId);
|
|
});
|
|
|
|
test('explicit requests may reopen ended periods without a server cooldown',async()=>{
|
|
for(const status of ['failed','completed']){
|
|
setup();const now=Date.now(),period=await openPeriod(1001,now),user=db.users.get('u');
|
|
const endedAt=now+1000;user.cloudRiseState=JSON.stringify({run:{periodId:period.periodId,status,expiresAt:period.endsAt,stages:[{endedAt}]}});
|
|
assert.equal(PersonalPeriods.lastEndedAt(user,endedAt),endedAt);
|
|
const [a,b]=await Promise.all([openPeriod(1001,endedAt+1),openPeriod(1001,endedAt+1)]);
|
|
assert.deepEqual(a,b);assert.notEqual(a.periodId,period.periodId);
|
|
}
|
|
});
|
|
|
|
|
|
test('Home opening action authenticates without requiring progress or matching',async()=>{
|
|
setup();configs.get('current').unlockLevel=100;
|
|
const request=extra=>api({body:{uid:1001,token:'token',action:'open_period',...extra}});
|
|
assert.equal((await request({token:'bad'})).code,0);
|
|
assert.equal(db.users.get('u').cloudRisePeriod,undefined);
|
|
const a=await request({}),b=await request({levelAmount:99});
|
|
assert.equal(a.code,1);assert.equal(b.code,1);assert.equal(a.data.period.periodId,b.data.period.periodId);
|
|
assert.equal(db.users.get('u').levelAmount,99);assert.equal(db.users.get('u').cloudRiseState,undefined);
|
|
assert.equal(db.cloudRiseRuns.size,0);assert.equal(analyticsReports.length,0);
|
|
});
|
|
|
|
test('natural expiry cooldown starts at the deadline, not a delayed status request',async()=>{
|
|
setup();const now=Date.now(),period=await openPeriod(1001,now),user=db.users.get('u');
|
|
assert.equal(PersonalPeriods.lastEndedAt(user,period.endsAt),period.endsAt);
|
|
user.cloudRiseState=JSON.stringify({run:{periodId:period.periodId,status:'expired',expiresAt:period.endsAt,stages:[{endedAt:period.endsAt+3600000}]}});
|
|
assert.equal(PersonalPeriods.lastEndedAt(user,period.endsAt+3600000),period.endsAt);
|
|
assert.ok(await openPeriod(1001,period.endsAt));
|
|
});
|
|
|
|
test('login and level reports contain no automatic CloudRise opener',async()=>{
|
|
for(const file of ['../../login.ts','../../userLevel.ts']){
|
|
const source=await readFile(new URL(file,import.meta.url),'utf8');
|
|
assert.doesNotMatch(source,/CloudRisePeriods|ensureOnLogin|ensureOnLevelProgress|openForUser/);
|
|
}
|
|
});
|
|
|
|
|
|
test('personal matching uses personal deadline and never restarts its countdown',async()=>{
|
|
setup();const now=Date.now();db.activityConfigs.get('current').effectiveFrom=now-120000; db.activityConfigs.get('current').publishedAt=now-120001;
|
|
const period=await openPeriod(1001,now-60000);
|
|
const prepared=await call({action:'prepare_match',periodId:period.periodId,stage:1,matchId:'personal-match'});
|
|
assert.equal(prepared.code,1);assert.equal(prepared.data.run,null);
|
|
const result=await call({action:'confirm_match',matchId:'personal-match'});
|
|
assert.equal(result.code,1);assert.equal(result.data.run.expiresAt,period.endsAt);
|
|
assert.ok(result.data.run.expiresAt-result.data.run.startedAt<86400000);
|
|
assert.deepEqual(await openPeriod(1001,now+1000),period);
|
|
});
|
|
|
|
test('personal period templates ignore old global end times and freeze per-player settings',async()=>{
|
|
setup();const now=Date.now(),row=db.activityConfigs.get('current');
|
|
row.config.endsAt=now-1;
|
|
const first=await openPeriod(1001,now);
|
|
assert.equal(first.endsAt,now+86400000);
|
|
row.config.durationHours=48;row.config.pools=[30000,40000,50000];
|
|
assert.deepEqual(await openPeriod(1001,now+1000),first);
|
|
const second=await openPeriod(1001,first.endsAt+PersonalPeriods.COOLDOWN_MS+1);
|
|
assert.notEqual(second.periodId,first.periodId);assert.equal(second.endsAt-second.startsAt,48*3600000);
|
|
assert.deepEqual(second.pools,[30000,40000,50000]);
|
|
});
|
|
|
|
test('personal ended challenges reopen only by request after cooldown',async()=>{
|
|
for(const status of ['failed','completed','expired']){
|
|
setup();const period=await openPeriod(1001);
|
|
const state={version:1,playedPeriods:[period.periodId],run:{id:'old',periodId:period.periodId,status,stage:1,pools:period.pools,
|
|
startedAt:period.startsAt,expiresAt:period.endsAt,stages:[]},analyticsQueue:[{id:'pending'}]};
|
|
db.users.get('u').cloudRiseState=JSON.stringify(state);
|
|
assert.equal(PersonalPeriods.openPeriodForUser(db.users.get('u'),Date.now()),null);
|
|
const result=await call({action:'status'});assert.equal(result.code,1);assert.equal(result.data.available,false);
|
|
assert.equal(db.users.get('u').cloudRisePeriod.periodId,period.periodId);
|
|
const preserved=db.users.get('u').cloudRiseState;
|
|
afterCooldown();const next=await openPeriod(1001);
|
|
assert.notEqual(next.periodId,period.periodId);assert.equal(db.users.get('u').cloudRiseState,preserved);
|
|
assert.deepEqual(await openPeriod(1001),next);
|
|
}
|
|
});
|
|
|
|
test('personal Home opening keeps pending reward receipts and active legacy challenges intact',async()=>{
|
|
setup();const period=await openPeriod(1001);
|
|
const start=await call({action:'start',periodId:period.periodId});forceScores();await winStage(start.data.run,1,5);
|
|
const before=db.users.get('u').cloudRiseState;
|
|
assert.deepEqual(await openPeriod(1001),period);assert.equal(db.users.get('u').cloudRiseState,before);
|
|
const state=JSON.parse(before);state.run.status='failed';db.users.get('u').cloudRiseState=JSON.stringify(state);
|
|
afterCooldown();const unsaved=db.users.get('u').cloudRiseState,next=await openPeriod(1001);
|
|
assert.notEqual(next.periodId,period.periodId);assert.equal(db.users.get('u').cloudRiseState,unsaved);
|
|
assert.equal((await call({action:'save_reward',runId:start.data.run.id,stage:1,reward:210,coinAmount:310})).code,1);
|
|
assert.equal((await call({action:'start',periodId:next.periodId})).code,1);
|
|
setup();const legacy=(await call({action:'start',periodId:'p1'})).data.run;
|
|
delete db.users.get('u').cloudRisePeriod;
|
|
const saved=db.users.get('u').cloudRiseState,recovered=await openPeriod(1001);
|
|
assert.equal(recovered.periodId,legacy.periodId);assert.equal(recovered.endsAt,legacy.expiresAt);
|
|
assert.equal(db.users.get('u').cloudRisePeriod,undefined);assert.equal(db.users.get('u').cloudRiseState,saved);
|
|
});
|
|
|
|
test('personal Home opening does not invent a template, rejects bad settings and isolates players',async()=>{
|
|
setup();db.users.get('u').cloudRiseState='';
|
|
assert.ok(await openPeriod(1001),'empty legacy state still allows login opening');
|
|
setup();configs.clear();assert.equal(await openPeriod(1001),null);
|
|
assert.equal(db.users.get('u').cloudRisePeriod,undefined);
|
|
setup();configs.get('current').durationHours=0;await assert.rejects(openPeriod(1001));
|
|
setup();db.users.set('other',{_id:'other',onlyId:1002,token:'other-token',levelAmount:1});
|
|
const a=await openPeriod(1001),b=await openPeriod(1002);
|
|
assert.notEqual(a.periodId,b.periodId);assert.equal(b.unlockLevel,1);
|
|
});
|
|
|
|
|
|
test('test-only fractional duration works through Home opening, matching, expiry and reopening',async()=>{
|
|
const oldEnv=process.env.PAYMENT_APP_ENV,realNow=Date.now;let now=realNow();Date.now=()=>now;
|
|
try {
|
|
process.env.PAYMENT_APP_ENV='test';setup();configs.get('current').durationHours=0.1;
|
|
const period=await openPeriod(1001);
|
|
assert.equal(period.endsAt-period.startsAt,360000);
|
|
const draft=await call({action:'prepare_match',stage:1,periodId:period.periodId,matchId:'short-test-match'});
|
|
assert.equal(draft.code,1);assert.equal(draft.data.period.durationHours,0.1);
|
|
const joined=await call({action:'confirm_match',matchId:'short-test-match'});
|
|
assert.equal(joined.code,1);assert.equal(joined.data.run.expiresAt,period.endsAt);
|
|
now=period.endsAt-1;assert.equal((await call({action:'status'})).data.run.status,'playing');
|
|
now=period.endsAt;assert.equal((await call({action:'status'})).data.run.status,'expired');
|
|
const next=await openPeriod(1001);
|
|
assert.notEqual(next.periodId,period.periodId);assert.equal(next.endsAt-Date.now(),360000);
|
|
} finally {
|
|
Date.now=realNow;if(oldEnv===undefined)delete process.env.PAYMENT_APP_ENV;else process.env.PAYMENT_APP_ENV=oldEnv;
|
|
}
|
|
});
|
|
|
|
test('fractional duration is rejected outside server test mode and invalid durations stay rejected',async()=>{
|
|
const oldEnv=process.env.PAYMENT_APP_ENV;
|
|
try {
|
|
for(const env of [undefined,'production','test']) {
|
|
if(env===undefined)delete process.env.PAYMENT_APP_ENV;else process.env.PAYMENT_APP_ENV=env;
|
|
assert.equal(PersonalPeriods.validDurationHours(0.1),env==='test');
|
|
assert.equal(PersonalPeriods.validDurationHours(1.5),env==='test');
|
|
assert.equal(PersonalPeriods.validDurationHours(1),true);
|
|
for(const bad of [0,-0.1,NaN,Infinity,'0.1',null,0.00000001,Number.MAX_SAFE_INTEGER])
|
|
assert.equal(PersonalPeriods.validDurationHours(bad),false,String(bad));
|
|
setup();configs.get('current').durationHours=0.1;
|
|
if(env!=='test') {
|
|
await assert.rejects(openPeriod(1001));
|
|
assert.equal((await call({action:'start',periodId:'p1',isDebug:false})).code,0);
|
|
}
|
|
}
|
|
} finally {if(oldEnv===undefined)delete process.env.PAYMENT_APP_ENV;else process.env.PAYMENT_APP_ENV=oldEnv;}
|
|
});
|
|
|
|
test('admin accepts fractional hours only in test mode and active personal deadlines remain frozen',async()=>{
|
|
const oldEnv=process.env.PAYMENT_APP_ENV,oldToken=process.env.ADMIN_TOKEN;
|
|
try {
|
|
setup();process.env.ADMIN_TOKEN='short-test-admin';process.env.PAYMENT_APP_ENV='production';
|
|
const config={...configs.get('current'),periodId:'short-admin',startsAt:Date.now()+60000,endsAt:Date.now()+120000,durationHours:0.1};
|
|
const body={action:'save',adminToken:'short-test-admin',configVersion:'short-v1',config};
|
|
assert.equal((await adminApi({body})).code,0);
|
|
process.env.PAYMENT_APP_ENV='test';assert.equal((await adminApi({body})).code,1);
|
|
const first=await openPeriod(1001);
|
|
configs.get('current').durationHours=0.1;
|
|
assert.deepEqual(await openPeriod(1001),first);
|
|
} finally {
|
|
if(oldEnv===undefined)delete process.env.PAYMENT_APP_ENV;else process.env.PAYMENT_APP_ENV=oldEnv;
|
|
if(oldToken===undefined)delete process.env.ADMIN_TOKEN;else process.env.ADMIN_TOKEN=oldToken;
|
|
}
|
|
});
|
|
|
|
|
|
test('expiry advances opponents one round for all stages, including never-played and final-step challenges',()=>{
|
|
for(const [number,target] of [[1,5],[2,7],[3,9]]) for(const score of [0,target-1]) {
|
|
const run=runWith([...Array(40).fill(target),...Array(59).fill(score)]),stage=run.stages[0];
|
|
run.stage=stage.stage=number;stage.target=target;stage.success_num=stage.round=score;
|
|
const results=structuredClone(stage.results);
|
|
assert.equal(Rules.expire(run,run.expiresAt),true);
|
|
assert.equal(stage.round,score+1);assert.equal(stage.success_num,score);assert.equal(stage.survivors,40);
|
|
assert.equal(Rules.publicRun(run).stages[0].opponents.filter(o=>o.alive).length,40);
|
|
assert.deepEqual(stage.results,results);assert.equal(stage.reward,0);
|
|
const saved=JSON.stringify(run);assert.equal(Rules.expire(run,run.expiresAt+1000),false);assert.equal(JSON.stringify(run),saved);
|
|
}
|
|
});
|
|
|
|
test('expiry between stages preserves the completed stage and its reward count',()=>{
|
|
const run=runWith(),stage=run.stages[0];run.status='waiting';stage.status='won';stage.success_num=stage.round=5;
|
|
stage.rewardSaved=true;stage.reward=210;
|
|
const before=structuredClone(stage);Rules.expire(run,run.expiresAt);
|
|
assert.deepEqual(stage,before);assert.equal(run.status,'expired');
|
|
});
|
|
|
|
|
|
test('enabled switch selects latest effective published version without fallback and defaults legacy to true',async()=>{
|
|
setup();const now=Date.now();
|
|
assert.ok(await PersonalPeriods.templateAt(now),'legacy enabled defaults true');
|
|
const old=db.activityConfigs.get('current');old.enabled=true;
|
|
const latest={...structuredClone(old),_id:'disabled',configVersion:'disabled',effectiveFrom:now-100,publishedAt:now-101,enabled:false};
|
|
db.activityConfigs.set(latest._id,latest);
|
|
db.activityConfigs.set('future',{...structuredClone(latest),_id:'future',configVersion:'future',effectiveFrom:now+1000,enabled:true});
|
|
db.activityConfigs.set('draft',{...structuredClone(latest),_id:'draft',status:'draft',effectiveFrom:now-1,enabled:true});
|
|
assert.equal(await PersonalPeriods.templateAt(now),null);
|
|
assert.equal(await openPeriod(1001,now),null);
|
|
assert.equal(db.users.get('u').cloudRisePeriod,undefined);
|
|
const reopened=await openPeriod(1001,now+1000);
|
|
assert.equal(reopened.configVersion,'future');
|
|
});
|
|
|
|
test('enabled switch preserves existing personal enrollment gameplay and reward settlement',async()=>{
|
|
setup();const now=Date.now(),period=await openPeriod(1001,now);
|
|
db.activityConfigs.get('current').enabled=false;
|
|
assert.deepEqual(await openPeriod(1001,now+1),period);
|
|
assert.deepEqual(PersonalPeriods.openPeriodForUser(db.users.get('u'),now+1),period);
|
|
assert.equal((await call({action:'status'})).data.available,true);
|
|
const draft=await call({action:'prepare_match',stage:1,periodId:period.periodId,matchId:'enabled-existing'});
|
|
assert.equal(draft.code,1);
|
|
const start=await call({action:'confirm_match',matchId:'enabled-existing'});
|
|
assert.equal(start.code,1);forceScores();await winStage(start.data.run,1,5);
|
|
assert.equal((await call({action:'save_reward',runId:start.data.run.id,stage:1,reward:100,coinAmount:200})).code,1);
|
|
assert.equal((await call({action:'start_stage',runId:start.data.run.id,stage:2})).code,1);
|
|
});
|
|
|
|
test('enabled switch blocks reopening ended or expired personal periods without changing their state',async()=>{
|
|
for(const status of ['failed','completed','expired','timeout']) {
|
|
setup();const now=Date.now(),period=await openPeriod(1001,now),user=db.users.get('u');
|
|
user.cloudRiseState=JSON.stringify({version:1,playedPeriods:[period.periodId],run:{periodId:period.periodId,status,stages:[]}});
|
|
db.activityConfigs.get('current').enabled=false;
|
|
const before=structuredClone(user),at=status==='timeout'?period.endsAt:now+1;
|
|
assert.equal(await openPeriod(1001,at),null);
|
|
assert.deepEqual(user,before);
|
|
db.activityConfigs.get('current').enabled=true;
|
|
const next=await openPeriod(1001,period.endsAt+PersonalPeriods.COOLDOWN_MS+1);
|
|
assert.notEqual(next.periodId,period.periodId);assert.equal(user.cloudRiseState,before.cloudRiseState);
|
|
}
|
|
});
|
|
|
|
test('admin enabled switch persists at version root validates booleans and preserves publish idempotency',async()=>{
|
|
const oldToken=process.env.ADMIN_TOKEN;
|
|
try {
|
|
setup();process.env.ADMIN_TOKEN='enabled-admin';
|
|
const config={...configs.get('current'),periodId:'enabled-admin',startsAt:Date.now()+60000,endsAt:Date.now()+3600000};
|
|
const body={action:'save',adminToken:'enabled-admin',configVersion:'enabled-v1',config,enabled:false};
|
|
for(const enabled of ['false',0,null]) assert.equal((await adminApi({body:{...body,enabled}})).code,0);
|
|
const saved=await adminApi({body});assert.equal(saved.code,1);assert.equal(saved.data.enabled,false);
|
|
const row=[...db.activityConfigs.values()].find(r=>r.configVersion==='enabled-v1');
|
|
assert.equal(row.enabled,false);assert.equal('enabled' in row.config,false);
|
|
assert.equal((await adminApi({body})).code,1);
|
|
assert.equal((await adminApi({body:{...body,enabled:true}})).code,0);
|
|
assert.equal((await adminApi({body:{action:'read',adminToken:'enabled-admin',periodId:config.periodId}})).data.enabled,false);
|
|
const defaults=await adminApi({body:{...body,configVersion:'enabled-default',enabled:undefined}});
|
|
assert.equal(defaults.code,1);assert.equal(defaults.data.enabled,true);
|
|
} finally {if(oldToken===undefined)delete process.env.ADMIN_TOKEN;else process.env.ADMIN_TOKEN=oldToken;}
|
|
});
|