增加游戏玩法界面和各个弹窗初版

This commit is contained in:
zpx committed 2026-11-20 18:51:48 +08:00
1 parent e84e14783e
commit eb48d8e845
211 files changed
+59920 -21

No files matched your search

+550
View File
@@ -1,6 +1,10 @@
import { test } from 'node:test';
import { strict as assert } from 'node:assert';
import { readFileSync, readdirSync } from 'node:fs';
import { transpileModule, ModuleKind, ScriptTarget } from 'typescript';
import { GuestLoginPresenter } from '../assets/login/scripts/GuestLoginPresenter';
import { GameRepository } from '../assets/orchard/scripts/GameRepository';
import { GameSession } from '../assets/orchard/scripts/GameSession';
import { StartupProgress } from '../assets/startup/scripts/StartupProgress';
test('waiting progress stays monotonic and below completion, even after long waits', () => {
@@ -70,4 +74,550 @@ test('loading binds the existing login without hiding its request-owning node',
const hidden = loading.loginControls.map((ref: Entry) => scene[ref.__id__]._name);
assert.ok(hidden.includes('GuestAccess')); assert.ok(hidden.includes('PrivacyLink'));
assert.ok(!hidden.includes('WelcomeComposition')); assert.ok(!hidden.includes('BrandMark'));
});
// Exercise the real adapters with tiny engine ports, without importing credentials or booting a scene.
function adapter<T>(file: string, imports: Record<string, unknown>): T {
const compiled = transpileModule(readFileSync(file, 'utf8'), {
compilerOptions: { module: ModuleKind.CommonJS, target: ScriptTarget.ES2020, experimentalDecorators: true },
});
const exports = {};
new Function('require', 'exports', compiled.outputText)((id: string) => {
assert.ok(Object.prototype.hasOwnProperty.call(imports, id), `Unexpected adapter import: ${id}`);
return imports[id];
}, exports);
return exports as T;
}
class TestNode {
active = true;
isValid = true;
private listeners = new Map<string, { callback: (...args: any[]) => void; target: unknown }[]>();
on(event: string, callback: (...args: any[]) => void, target: unknown): void {
this.listeners.set(event, [...(this.listeners.get(event) ?? []), { callback, target }]);
}
off(event: string, callback: (...args: any[]) => void, target: unknown): void {
this.listeners.set(event, (this.listeners.get(event) ?? []).filter(item => item.callback !== callback || item.target !== target));
}
emit(event: string, ...args: unknown[]): void {
for (const item of this.listeners.get(event) ?? []) item.callback.apply(item.target, args);
}
}
function pendingScene() {
let resolve!: (scene: any) => void;
let reject!: (error: Error) => void;
const promise = new Promise<any>((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
}
function loadingHarness() {
const pending = pendingScene();
const calls = { signIn: 0, prepare: 0, load: 0, clear: 0, launch: 0 };
let sceneRequest = pending.promise;
let transitionFailure: 'before' | 'after' | null = null;
const loaded = { scene: { getComponentInChildren: (name: string) => name === 'OrchardView' ? { enabled: true } : null } };
class TestComponent { node = new TestNode(); enabledInHierarchy = true; isValid = true; }
const engine = {
_decorator: { ccclass: () => (type: unknown) => type, property: (...args: unknown[]) => args.length > 1 ? undefined : () => {} },
Component: TestComponent, Node: TestNode, Button: { EventType: { CLICK: 'click' } },
Label: class {}, Sprite: class {}, SpriteFrame: class {}, SceneAsset: class {}, UITransform: class {},
director: { runSceneImmediate: () => {
calls.launch++;
if (transitionFailure === 'before') throw new Error('private transition error');
loading.onDisable(); Object.assign(loading, { isValid: false }); loading.onDestroy();
if (transitionFailure === 'after') throw new Error('private transition error');
} },
};
const { GuestLoginView: Login } = adapter<typeof import('../assets/login/scripts/GuestLoginView')>(
'assets/login/scripts/GuestLoginView.ts', {
cc: engine, './GuestLoginPresenter': { GuestLoginPresenter },
'./GuestRuntime': { createGuestLogin: () => ({ signIn: async () => {
calls.signIn++; return { guestId: identity, token: 'fixture-token', expires: 1 };
} }) },
});
const runtime = {
LOCK_IN_USE: 'This saved game is already open in another tab. Close it and tap the guest button to retry.',
LOCK_UNAVAILABLE: 'Exclusive saved game access is unavailable on this platform. Please use a supported browser and retry.',
session: null as GameSession | null,
prepareExclusive: async (id: string, signal?: AbortSignal): Promise<GameSession> => {
assert.equal(id, identity); calls.prepare++;
const session = {} as GameSession;
runtime.session = session;
signal?.addEventListener('abort', () => runtime.clear(session), { once: true });
return session;
},
loadScene: () => { calls.load++; return sceneRequest; },
clear: (expected?: GameSession) => {
if (expected && runtime.session !== expected) return;
runtime.session = null; calls.clear++;
},
};
const { StartupLoadingView: Loading } = adapter<typeof import('../assets/startup/scripts/StartupLoadingView')>(
'assets/startup/scripts/StartupLoadingView.ts', {
cc: engine, '../../login/scripts/GuestLoginView': { GuestLoginView: Login },
'../../orchard/scripts/OrchardRuntime': { OrchardRuntime: runtime }, './StartupProgress': { StartupProgress },
});
const login = new Login();
const button = { node: new TestNode(), interactable: true, isValid: true };
const status = { node: new TestNode(), string: '' };
login.guestButton = button as unknown as NonNullable<typeof login.guestButton>;
login.statusLabel = status as unknown as NonNullable<typeof login.statusLabel>;
const loading = new Loading();
const panel = new TestNode();
const percent = { string: '' };
loading.login = login;
loading.panel = panel as unknown as NonNullable<typeof loading.panel>;
loading.loginControls = [button.node, status.node] as unknown as typeof loading.loginControls;
loading.meter = { node: new TestNode(), getComponent: () => ({ setContentSize: () => {} }) } as unknown as NonNullable<typeof loading.meter>;
loading.percentage = percent as NonNullable<typeof loading.percentage>;
loading.caption = { string: '' } as NonNullable<typeof loading.caption>;
loading.onLoad(); login.onLoad(); loading.onEnable();
return { loading, login, calls, runtime, button, status, panel, percent, pending, loaded,
useScene: (request: Promise<any>) => { sceneRequest = request; },
failTransition: (when: 'before' | 'after') => { transitionFailure = when; } };
}
const identity = '0123456789abcdef0123456789abcdef';
const flush = async () => { for (let turn = 0; turn < 16; turn++) await Promise.resolve(); };
function finishLoading(view: { update(dt: number): void }): void {
for (let frame = 0; frame < 8; frame++) view.update(.1);
}
test('authenticated state waits for the credential-free success event and scene dependencies before 100%', async () => {
const h = loadingHarness();
assert.equal(h.panel.active, false);
let authenticatedState = false;
h.login.node.on('guest-login-state-changed', (state: { phase: string }) => {
if (state.phase === 'authenticated') {
authenticatedState = true;
assert.equal(h.calls.prepare, 0); assert.equal(h.login.guestId, null);
}
}, null);
h.button.node.emit('click');
h.loading.update(.1); h.loading.update(.1);
const waiting = Number.parseInt(h.percent.string);
await flush();
assert.equal(authenticatedState, true); assert.notEqual(h.percent.string, '100%');
assert.equal(h.login.guestId, identity);
assert.equal(h.calls.prepare, 1); assert.equal(h.calls.load, 1);
assert.ok(Number.parseInt(h.percent.string) >= waiting);
finishLoading(h.loading); assert.equal(h.calls.launch, 0);
h.pending.resolve(h.loaded); await flush();
h.loading.update(.1); h.loading.update(.1); h.loading.update(.1);
assert.equal(h.percent.string, '100%'); assert.equal(h.panel.active, true); assert.equal(h.calls.launch, 0);
h.loading.update(.1);
assert.equal(h.calls.launch, 1);
});
test('scene failure restores a usable guest button and retries preparation without authenticating again', async () => {
const h = loadingHarness();
h.button.node.emit('click'); await flush();
h.pending.reject(new Error('private loader details')); await flush();
assert.equal(h.panel.active, false); assert.equal(h.status.node.active, true);
assert.match(h.status.string, /tap the guest button to retry/);
assert.ok(!h.status.string.includes('private')); assert.equal(h.button.interactable, true);
h.useScene(Promise.resolve(h.loaded));
h.button.node.emit('click'); h.button.node.emit('click'); await flush();
finishLoading(h.loading);
assert.equal(h.calls.signIn, 1); assert.equal(h.calls.prepare, 2); assert.equal(h.calls.launch, 1);
});
test('storage failure is sanitized and the authenticated preparation can retry', async () => {
const h = loadingHarness();
h.runtime.prepareExclusive = async () => { throw new Error('private storage key'); };
h.button.node.emit('click'); await flush();
assert.equal(h.calls.load, 0); assert.equal(h.panel.active, false);
assert.match(h.status.string, /saved game has not been reset/); assert.ok(!h.status.string.includes('private'));
h.runtime.prepareExclusive = async () => { h.calls.prepare++; return {} as GameSession; };
h.useScene(Promise.resolve(h.loaded)); h.button.node.emit('click'); await flush();
finishLoading(h.loading);
assert.equal(h.calls.signIn, 1); assert.equal(h.calls.launch, 1);
});
test('disabled or destroyed loading ignores late scenes and an enabled authenticated view can resume', async () => {
for (const destroy of [false, true]) {
const h = loadingHarness(); h.button.node.emit('click'); await flush();
Object.assign(h.loading, { enabledInHierarchy: false }); h.loading.onDisable();
if (destroy) { Object.assign(h.loading, { isValid: false }); h.loading.onDestroy(); }
h.pending.resolve(h.loaded); await flush(); finishLoading(h.loading);
assert.equal(h.calls.launch, 0); assert.equal(h.panel.active, false);
if (!destroy) {
h.useScene(Promise.resolve(h.loaded)); Object.assign(h.loading, { enabledInHierarchy: true }); h.loading.onEnable(); await flush();
finishLoading(h.loading); assert.equal(h.calls.launch, 1); assert.equal(h.calls.signIn, 1);
}
}
});
test('missing game view is recoverable and pure authentication mode keeps the existing success display', async () => {
const h = loadingHarness();
h.useScene(Promise.resolve({ scene: { getComponentInChildren: () => null } }));
h.button.node.emit('click'); await flush(); finishLoading(h.loading);
assert.equal(h.calls.launch, 0); assert.equal(h.button.interactable, true);
const pure = loadingHarness(); pure.loading.transitionToGame = false;
let ready = 0; pure.loading.node.on('startup-preparation-ready', () => ready++, null);
pure.button.node.emit('click'); await flush(); finishLoading(pure.loading);
assert.equal(ready, 1); assert.equal(pure.calls.prepare, 0); assert.equal(pure.calls.launch, 0);
assert.equal(pure.status.string, 'Signed in successfully.'); assert.equal(pure.status.node.active, true);
});
test('local runtime isolates authenticated guests, refuses corrupt saves and uses all 32 random bits', () => {
const values = new Map<string, string>();
const storage = { getItem: (key: string) => values.get(key) ?? null, setItem: (key: string, value: string) => { values.set(key, value); } };
const { OrchardRuntime: Runtime } = adapter<typeof import('../assets/orchard/scripts/OrchardRuntime')>(
'assets/orchard/scripts/OrchardRuntime.ts', {
cc: { sys: { localStorage: storage }, assetManager: {} }, './GameRepository': { GameRepository }, './GameSession': { GameSession },
'../../login/scripts/GuestRuntime': { GUEST_SERVICE: { origin: 'https://fixture.test/', product: 'Fixture' } },
});
const cryptoDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'crypto');
let bits = 0;
try {
Object.defineProperty(globalThis, 'crypto', { configurable: true, value: {
getRandomValues: (array: Uint32Array) => { array[0] = bits; return array; },
} });
assert.throws(() => Runtime.getSession(), /Sign in to continue\./);
assert.throws(() => Runtime.prepare(''), /Sign in to continue\./); assert.equal(values.size, 0);
const first = Runtime.prepare(identity); assert.equal(Runtime.getSession(), first);
const scope = `fruit-pop:game:v1:${encodeURIComponent(`https://fixture.test|Fixture|${identity}`)}`;
assert.deepEqual([...values.keys()], [scope]);
const injected = first as unknown as { random(): number };
assert.equal(injected.random(), 0); bits = 0xffffffff;
assert.equal(injected.random(), 0xffffffff / 0x100000000); assert.ok(injected.random() < 1);
first.setBet(5000); Runtime.clear();
assert.throws(() => Runtime.getSession(), /Sign in to continue\./);
assert.equal(Runtime.prepare(identity).state.bet, 5000);
assert.equal(Runtime.prepare('fedcba9876543210fedcba9876543210').state.bet, 2000);
values.set(scope, 'corrupt existing save');
assert.throws(() => Runtime.prepare(identity), /saved game has not been reset/);
assert.equal(values.get(scope), 'corrupt existing save'); assert.equal(Runtime.session, null);
Object.defineProperty(globalThis, 'crypto', { configurable: true, value: undefined });
assert.throws(() => Runtime.prepare(identity), /Secure game preparation is unavailable/);
assert.equal(values.get(scope), 'corrupt existing save');
} finally {
if (cryptoDescriptor) Object.defineProperty(globalThis, 'crypto', cryptoDescriptor);
else Reflect.deleteProperty(globalThis, 'crypto');
}
});
type Runtime = typeof import('../assets/orchard/scripts/OrchardRuntime').OrchardRuntime;
function exclusiveHarness() {
const navigatorDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'navigator');
const cryptoDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'crypto');
const values = new Map<string, string>();
const held = new Map<string, object>();
const reads: string[] = [];
const writes: string[] = [];
const requests: { name: string; options: LockOptions; deliver(): void; settled: boolean }[] = [];
const runtimes: Runtime[] = [];
let deferred = false;
const locks = {
request: (name: string, options: LockOptions, callback: (lock: Lock | null) => unknown): Promise<unknown> => {
return new Promise((resolve, reject) => {
let delivered = false;
const request = { name, options, settled: false, deliver: () => {
if (delivered) return;
delivered = true;
const owner = {};
const available = !held.has(name);
if (available) held.set(name, owner);
const finish = (): void => {
if (held.get(name) === owner) held.delete(name);
request.settled = true;
};
try {
const result = callback(available ? { name, mode: 'exclusive' } : null);
Promise.resolve(result).then(value => { finish(); resolve(value); }, error => { finish(); reject(error); });
} catch (error) { finish(); reject(error); }
} };
requests.push(request);
if (!deferred) queueMicrotask(request.deliver);
});
},
};
Object.defineProperty(globalThis, 'navigator', { configurable: true, value: { locks } });
Object.defineProperty(globalThis, 'crypto', { configurable: true, value: {
getRandomValues: (array: Uint32Array) => { array.fill(0); return array; },
} });
const createRuntime = (): Runtime => {
const { OrchardRuntime } = adapter<{ OrchardRuntime: Runtime }>('assets/orchard/scripts/OrchardRuntime.ts', {
cc: { sys: { localStorage: {
getItem: (key: string) => { assert.ok(held.has(key), 'storage read before exclusive acquisition'); reads.push(key); return values.get(key) ?? null; },
setItem: (key: string, value: string) => { assert.ok(held.has(key), 'storage write without exclusive ownership'); writes.push(key); values.set(key, value); },
} }, assetManager: {} },
'./GameRepository': { GameRepository }, './GameSession': { GameSession },
'../../login/scripts/GuestRuntime': { GUEST_SERVICE: { origin: 'https://fixture.test/', product: 'Fixture' } },
});
runtimes.push(OrchardRuntime);
return OrchardRuntime;
};
return { values, held, reads, writes, requests, locks, createRuntime,
defer: () => { deferred = true; },
restore: async () => {
for (const runtime of runtimes) runtime.clear();
for (const request of requests) request.deliver();
await flush();
if (navigatorDescriptor) Object.defineProperty(globalThis, 'navigator', navigatorDescriptor);
else Reflect.deleteProperty(globalThis, 'navigator');
if (cryptoDescriptor) Object.defineProperty(globalThis, 'crypto', cryptoDescriptor);
else Reflect.deleteProperty(globalThis, 'crypto');
},
};
}
async function withExclusiveHarness(action: (h: ReturnType<typeof exclusiveHarness>) => Promise<void>): Promise<void> {
const harness = exclusiveHarness();
try { await action(harness); } finally { await harness.restore(); }
}
test('exclusive preparation denies another tab immediately without reading or writing its save', async () => {
await withExclusiveHarness(async h => {
const owner = h.createRuntime();
const contender = h.createRuntime();
const session = await owner.prepareExclusive(identity);
const scope = `fruit-pop:game:v1:${encodeURIComponent(`https://fixture.test|Fixture|${identity}`)}`;
assert.equal(h.requests[0].name, scope);
assert.deepEqual(h.requests[0].options, { mode: 'exclusive', ifAvailable: true });
assert.equal(h.requests[0].settled, false); assert.equal(h.held.size, 1);
const reads = h.reads.length; const writes = h.writes.length;
await assert.rejects(contender.prepareExclusive(identity), { message: contender.LOCK_IN_USE });
assert.equal(h.reads.length, reads); assert.equal(h.writes.length, writes);
assert.equal(contender.session, null); assert.equal(owner.getSession(), session);
session.setBet(5000); assert.equal(h.requests[0].settled, false);
owner.clear(); await flush();
assert.equal(h.requests[0].settled, true); assert.equal(h.held.size, 0);
const restored = await contender.prepareExclusive(identity);
assert.equal(restored.state.bet, 5000); assert.equal(restored.state.balance, 100_000);
assert.equal(h.writes.length, writes + 1);
});
});
test('unsupported browsers and lock service errors never touch saved data and can retry', async () => {
await withExclusiveHarness(async h => {
const runtime = h.createRuntime();
for (const navigator of [undefined, {}, { locks: {} }, { locks: { request: () => { throw new Error('private lock details'); } } },
{ locks: { request: () => Promise.reject(new Error('private lock details')) } }]) {
Object.defineProperty(globalThis, 'navigator', { configurable: true, value: navigator });
await assert.rejects(runtime.prepareExclusive(identity), { message: runtime.LOCK_UNAVAILABLE });
assert.equal(runtime.session, null); assert.equal(h.reads.length, 0); assert.equal(h.writes.length, 0);
}
Object.defineProperty(globalThis, 'navigator', { configurable: true, value: { locks: h.locks } });
await runtime.prepareExclusive(identity);
assert.equal(h.writes.length, 1);
});
});
test('same guest reuses its lifetime lock and rereads the stored session without granting again', async () => {
await withExclusiveHarness(async h => {
const runtime = h.createRuntime();
const first = await runtime.prepareExclusive(identity);
first.setBet(5000);
const reads = h.reads.length; const writes = h.writes.length;
const next = await runtime.prepareExclusive(identity);
assert.notEqual(next, first); assert.equal(next.state.bet, 5000);
assert.equal(h.requests.length, 1); assert.equal(h.requests[0].settled, false);
assert.ok(h.reads.length > reads); assert.equal(h.writes.length, writes);
runtime.clear(first); await flush();
assert.equal(runtime.getSession(), next); assert.equal(h.requests[0].settled, false);
});
});
test('switching guests releases only the old scope and invalid guests never write', async () => {
await withExclusiveHarness(async h => {
const runtime = h.createRuntime();
const old = await runtime.prepareExclusive(identity);
old.setBet(5000);
const other = await runtime.prepareExclusive('fedcba9876543210fedcba9876543210');
assert.equal(h.requests[0].settled, true); assert.equal(h.requests[1].settled, false);
assert.notEqual(h.requests[0].name, h.requests[1].name);
assert.equal(other.state.bet, 2000); assert.equal(h.held.size, 1);
runtime.clear(old); assert.equal(runtime.getSession(), other);
const writes = h.writes.length;
await assert.rejects(runtime.prepareExclusive(''), /Sign in to continue\./); await flush();
assert.equal(h.writes.length, writes); assert.equal(runtime.session, null); assert.equal(h.held.size, 0);
});
});
test('clear and cancellation settle a delayed acquisition without writing or clearing a newer lock', async () => {
for (const cancel of ['clear', 'abort'] as const) {
await withExclusiveHarness(async h => {
h.defer();
const runtime = h.createRuntime();
const controller = new AbortController();
const stale = runtime.prepareExclusive(identity, controller.signal);
const rejected = assert.rejects(stale, /cancelled/);
assert.equal(h.reads.length, 0); assert.equal(h.writes.length, 0);
if (cancel === 'clear') runtime.clear(); else controller.abort();
await rejected;
const current = runtime.prepareExclusive(identity);
h.requests[1].deliver(); const session = await current;
h.requests[0].deliver(); await flush();
assert.equal(runtime.getSession(), session); assert.equal(h.requests[1].settled, false);
assert.equal(h.writes.length, 1); assert.equal(h.held.size, 1);
runtime.clear(); runtime.clear(); await flush(); assert.equal(h.held.size, 0);
});
}
});
test('concurrent same-guest preparation shares one request and an obsolete abort cannot release the new owner', async () => {
await withExclusiveHarness(async h => {
h.defer();
const runtime = h.createRuntime();
const firstController = new AbortController();
const secondController = new AbortController();
const first = runtime.prepareExclusive(identity, firstController.signal);
const rejected = assert.rejects(first, /cancelled/);
const second = runtime.prepareExclusive(identity, secondController.signal);
firstController.abort();
assert.equal(h.requests.length, 1);
h.requests[0].deliver(); const session = await second; await rejected;
assert.equal(runtime.getSession(), session); assert.equal(h.writes.length, 1);
assert.equal(h.requests[0].settled, false);
secondController.abort(); await flush();
assert.equal(runtime.session, null); assert.equal(h.held.size, 0);
});
});
test('a late old-guest callback cannot prepare or release the current guest', async () => {
await withExclusiveHarness(async h => {
h.defer();
const runtime = h.createRuntime();
const stale = runtime.prepareExclusive(identity);
const rejected = assert.rejects(stale, /cancelled/);
const current = runtime.prepareExclusive('fedcba9876543210fedcba9876543210');
await rejected;
h.requests[1].deliver(); const session = await current;
h.requests[0].deliver(); await flush();
assert.equal(runtime.getSession(), session); assert.equal(h.writes.length, 1);
assert.equal(h.requests[0].settled, true); assert.equal(h.requests[1].settled, false);
});
});
test('cancellation between lock acquisition and restoration never reads or writes the old session', async () => {
await withExclusiveHarness(async h => {
h.defer();
const runtime = h.createRuntime();
const controller = new AbortController();
const stale = runtime.prepareExclusive(identity, controller.signal);
const rejected = assert.rejects(stale, /cancelled/);
h.requests[0].deliver();
controller.abort();
assert.equal(h.reads.length, 0); assert.equal(h.writes.length, 0);
const current = runtime.prepareExclusive('fedcba9876543210fedcba9876543210');
h.requests[1].deliver();
const session = await current; await rejected; await flush();
assert.equal(runtime.getSession(), session); assert.equal(h.writes.length, 1);
assert.equal(h.requests[0].settled, true); assert.equal(h.requests[1].settled, false);
});
});
test('cancelled callers and corrupt preparation never retain a lock or overwrite data', async () => {
await withExclusiveHarness(async h => {
const runtime = h.createRuntime();
const controller = new AbortController(); controller.abort();
await assert.rejects(runtime.prepareExclusive(identity, controller.signal), /cancelled/);
assert.equal(h.requests.length, 0); assert.equal(h.writes.length, 0);
const key = `fruit-pop:game:v1:${encodeURIComponent(`https://fixture.test|Fixture|${identity}`)}`;
h.values.set(key, 'corrupt existing save');
await assert.rejects(runtime.prepareExclusive(identity), /saved game has not been reset/); await flush();
assert.equal(h.values.get(key), 'corrupt existing save'); assert.equal(h.writes.length, 0);
assert.equal(h.requests[0].settled, true); assert.equal(h.held.size, 0);
assert.equal(runtime.session, null);
});
});
test('an immediate same-guest retry after clear reacquires and never overwrites the save', async () => {
await withExclusiveHarness(async h => {
const runtime = h.createRuntime();
const first = await runtime.prepareExclusive(identity); first.setBet(5000);
runtime.clear();
const second = await runtime.prepareExclusive(identity);
assert.equal(second.state.bet, 5000); assert.equal(h.writes.length, 2);
assert.equal(h.requests.length, 2); assert.equal(h.requests[0].settled, true);
assert.equal(h.requests[1].settled, false);
assert.equal(h.held.size, 1);
});
});
test('loading shows a fixed lock denial, retries without reauthentication and hands the session to the game', async () => {
const h = loadingHarness();
const prepare = h.runtime.prepareExclusive;
h.runtime.prepareExclusive = async () => { throw new Error(h.runtime.LOCK_IN_USE); };
h.button.node.emit('click'); await flush();
assert.equal(h.status.string, h.runtime.LOCK_IN_USE);
assert.equal(h.button.interactable, true); assert.equal(h.panel.active, false); assert.equal(h.calls.load, 0);
h.runtime.prepareExclusive = prepare;
h.useScene(Promise.resolve(h.loaded)); h.button.node.emit('click'); await flush();
const session = h.runtime.session;
assert.ok(session); finishLoading(h.loading);
assert.equal(h.calls.signIn, 1); assert.equal(h.calls.launch, 1);
assert.equal(h.calls.clear, 0); assert.equal(h.runtime.session, session);
});
test('loading releases failed scenes and destruction but successful scene handoff keeps the lock', async () => {
const failed = loadingHarness(); failed.button.node.emit('click'); await flush();
failed.pending.reject(new Error('private scene error')); await flush();
assert.equal(failed.runtime.session, null); assert.equal(failed.calls.clear, 1);
const missing = loadingHarness();
missing.useScene(Promise.resolve({ scene: { getComponentInChildren: () => null } }));
missing.button.node.emit('click'); await flush();
assert.equal(missing.runtime.session, null); assert.equal(missing.calls.clear, 1);
const cancelled = loadingHarness(); cancelled.button.node.emit('click'); await flush();
cancelled.loading.onDestroy(); assert.equal(cancelled.runtime.session, null); assert.equal(cancelled.calls.clear, 1);
const success = loadingHarness(); success.useScene(Promise.resolve(success.loaded));
success.button.node.emit('click'); await flush(); finishLoading(success.loading);
assert.equal(success.calls.launch, 1); assert.equal(success.calls.clear, 0);
});
test('failed scene handoff releases the session even if the old loading view has already been destroyed', async () => {
for (const when of ['before', 'after'] as const) {
const h = loadingHarness();
h.failTransition(when); h.useScene(Promise.resolve(h.loaded));
h.button.node.emit('click'); await flush(); finishLoading(h.loading);
assert.equal(h.calls.launch, 1); assert.equal(h.runtime.session, null); assert.equal(h.calls.clear, 1);
if (when === 'before') {
assert.equal(h.button.interactable, true); assert.equal(h.panel.active, false);
assert.match(h.status.string, /Unable to open the game/); assert.ok(!h.status.string.includes('private'));
}
}
});
test('loading ignores a late exclusive preparation without loading a scene or clearing a newer session', async () => {
const h = loadingHarness(); const late = pendingScene();
let signal: AbortSignal | undefined;
const prepare = h.runtime.prepareExclusive;
h.runtime.prepareExclusive = async (_id, cancellation) => { signal = cancellation; return late.promise; };
h.button.node.emit('click'); await flush();
Object.assign(h.loading, { enabledInHierarchy: false }); h.loading.onDisable();
assert.equal(signal?.aborted, true);
h.runtime.prepareExclusive = prepare; h.useScene(Promise.resolve(h.loaded));
Object.assign(h.loading, { enabledInHierarchy: true }); h.loading.onEnable(); await flush();
const current = h.runtime.session;
late.resolve({}); await flush(); finishLoading(h.loading);
assert.equal(h.calls.load, 1); assert.equal(h.calls.launch, 1);
assert.equal(h.runtime.session, current); assert.equal(h.calls.clear, 0);
});
test('a late scene failure after cancellation cannot release the resumed session', async () => {
const h = loadingHarness(); h.button.node.emit('click'); await flush();
const previous = h.runtime.session;
Object.assign(h.loading, { enabledInHierarchy: false }); h.loading.onDisable();
assert.equal(h.calls.clear, 1); assert.equal(h.runtime.session, null);
h.useScene(Promise.resolve(h.loaded));
Object.assign(h.loading, { enabledInHierarchy: true }); h.loading.onEnable(); await flush();
const current = h.runtime.session;
assert.notEqual(current, previous);
h.pending.reject(new Error('late old failure')); await flush(); finishLoading(h.loading);
assert.equal(h.runtime.session, current); assert.equal(h.calls.clear, 1); assert.equal(h.calls.launch, 1);
});
test('a late preparation rejection and login cancellation do not clear a newer preparation', async () => {
const h = loadingHarness(); const late = pendingScene();
let signal: AbortSignal | undefined;
const prepare = h.runtime.prepareExclusive;
h.runtime.prepareExclusive = async (_id, cancellation) => { signal = cancellation; return late.promise; };
h.button.node.emit('click'); await flush();
h.login.render({ phase: 'idle', message: '', enabled: true });
assert.equal(signal?.aborted, true); assert.equal(h.panel.active, false);
h.runtime.prepareExclusive = prepare; h.useScene(Promise.resolve(h.loaded));
Object.assign(h.loading, { enabledInHierarchy: false }); h.loading.onDisable();
Object.assign(h.loading, { enabledInHierarchy: true }); h.loading.onEnable(); await flush();
const current = h.runtime.session;
late.reject(new Error('private stale prepare error')); await flush(); finishLoading(h.loading);
assert.equal(h.calls.launch, 1); assert.equal(h.calls.clear, 0); assert.equal(h.runtime.session, current);
assert.ok(!h.status.string.includes('private'));
});