homegames-common 1.7.0 → 1.7.2

package/test/studio-handoff.test.cjs

@@ -0,0 +1,94 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict');
+const { randomUUID } = require('node:crypto');
+const { openGameInStudio, receiveGameInStudio } = require('../studio-handoff');
+const send = (0, eval)('(' + openGameInStudio.toString() + ')'); // Also runs embedded in HTML.
+const tick = () => new Promise(resolve => setImmediate(resolve));
+function pair(origin = 'null', protocol = 'https:') {
+    function endpoint(location) {
+        const events = new Map();
+        return { location, crypto: { randomUUID },
+            addEventListener(type, fn) { events.set(type, fn); },
+            removeEventListener(type) { events.delete(type); },
+            emit(type, event) { events.get(type)?.(event); },
+            get listenerCount() { return events.size; } };
+    }
+    const game = endpoint({ origin, protocol }), studio = endpoint({ origin: 'https://studio.example' });
+    const traffic = [];
+    const gameRef = { postMessage(data, target) {
+        traffic.push({ direction: 'game', data, target });
+        assert.ok(target === '*' || target === origin);
+        queueMicrotask(() => game.emit('message', { data, origin: studio.location.origin, source: studioRef }));
+    } };
+    const studioRef = { closed: false, postMessage(data, target) {
+        traffic.push({ direction: 'studio', data, target });
+        assert.equal(target, studio.location.origin);
+        queueMicrotask(() => studio.emit('message', { data, origin, source: gameRef }));
+    } };
+    game.open = url => { studio.location.hash = new URL(url).hash; return studioRef; };
+    studio.opener = gameRef;
+    return { game, studio, gameRef, studioRef, traffic };
+}
+
+for (const [protocol, origin] of [['file:', 'null'], ['file:', 'file://'], ['https:', 'https://game.example']]) test(`complete archive travels directly from ${origin} and is acknowledged after persistence`, async () => {
+    const ctx = pair(origin, protocol), bytes = new Uint8Array([80, 75, 0, 255, 7]);
+    let getCount = 0, saved = false, release, imports = 0;
+    const sent = send(ctx.game, () => { getCount++; return bytes; }, 'https://studio.example/studio.html').then(() => { saved = true; });
+    const received = receiveGameInStudio(ctx.studio, async value => {
+        imports++; assert.deepEqual(value, bytes);
+        await new Promise(resolve => { release = resolve; }); return 'project';
+    });
+    await tick();
+    assert.equal(saved, false);
+    const packet = ctx.traffic.find(item => item.direction === 'studio').data;
+    ctx.studioRef.postMessage(packet, ctx.studio.location.origin); // Duplicate delivery must not create a second project.
+    await tick(); assert.equal(imports, 1); release();
+    assert.equal(await received, 'project'); await sent;
+    assert.equal(getCount, 1); assert.equal(saved, true);
+    assert.equal(ctx.game.listenerCount + ctx.studio.listenerCount, 0);
+    assert.ok(!ctx.studio.location.hash.includes('bytes'));
+});
+
+test('unrelated windows, origins, and tokens cannot inject an archive or acknowledge a transfer', async () => {
+    const ctx = pair(), bytes = new Uint8Array([1]); let imports = 0;
+    const sent = send(ctx.game, () => bytes, 'https://studio.example/studio.html');
+    const token = new URLSearchParams(ctx.studio.location.hash.slice(1)).get('edit');
+    const valid = { source: ctx.gameRef, origin: 'null', data: { type: 'homegames-studio-game', token, bytes } };
+    const received = receiveGameInStudio(ctx.studio, () => { imports++; });
+    for (const patch of [{ source: {} }, { origin: 'https://evil.example' }, { data: { ...valid.data, token: randomUUID() } }]) {
+        ctx.studio.emit('message', { ...valid, ...patch });
+    }
+    assert.equal(imports, 0);
+    await received; await sent; assert.equal(imports, 1);
+});
+
+test('failed persistence reaches the sender and releases both sides', async () => {
+    const ctx = pair();
+    const sent = assert.rejects(send(ctx.game, () => new Uint8Array([1]), 'https://studio.example/studio.html'), /storage full/);
+    const received = assert.rejects(receiveGameInStudio(ctx.studio, () => { throw new Error('storage full'); }), /storage full/);
+    await Promise.all([sent, received]);
+    assert.equal(ctx.game.listenerCount + ctx.studio.listenerCount, 0);
+});
+
+test('popup blocking and archive failures keep a usable recovery error', async () => {
+    const blocked = pair(); blocked.game.open = () => null;
+    await assert.rejects(send(blocked.game, () => {}), /import its HTML or ZIP/);
+    assert.equal(blocked.game.listenerCount, 0);
+    const ctx = pair();
+    const sent = assert.rejects(send(ctx.game, () => { throw new Error('Copy failed'); }, 'https://studio.example/studio.html'), /Copy failed/);
+    const received = receiveGameInStudio(ctx.studio, () => {});
+    const caught = assert.rejects(received, /closed/);
+    await sent; ctx.studio.emit('pagehide'); await caught;
+    assert.equal(ctx.game.listenerCount + ctx.studio.listenerCount, 0);
+});
+
+test('timeout and closed tabs clean up pending transfers', async t => {
+    t.mock.timers.enable({ apis: ['setTimeout', 'setInterval'] });
+    const ctx = pair();
+    const sent = assert.rejects(send(ctx.game, () => {}, 'https://studio.example/studio.html'), /did not receive/);
+    t.mock.timers.tick(90000); await sent; assert.equal(ctx.game.listenerCount, 0);
+    const closed = pair();
+    const pending = assert.rejects(send(closed.game, () => {}, 'https://studio.example/studio.html'), /closed/);
+    closed.studioRef.closed = true; t.mock.timers.tick(500); await pending;
+    assert.equal(closed.game.listenerCount, 0);
+});

package/test/studio-thumbnail.test.cjs

@@ -0,0 +1,21 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict');
+const { thumbnailPath } = require('../portable-project');
+const project = source => ({'homegame.json':JSON.stringify({entry:'index.js'}),'index.js':source,
+    'assets/cover.png':new Uint8Array([137,80,78,71]),'unfinished.js':'class {'});
+
+test('Studio reads declared local artwork without evaluating game code or requiring other files to compile', () => {
+    const files = project("globalThis.thumbnailCodeRan = true; const COVER = './assets/cover.png'; class Game { static metadata() { return {thumbnail:COVER}; } }");
+    assert.equal(thumbnailPath(files), 'assets/cover.png');
+    assert.equal(globalThis.thumbnailCodeRan, undefined);
+    assert.equal(thumbnailPath({...files,'index.js':new TextEncoder().encode(files['index.js'])}), 'assets/cover.png');
+});
+
+test('missing, unsafe, computed and unfinished thumbnail metadata falls back without executing it', () => {
+    for(const value of ["'https://example.com/cover.png'", "'../cover.png'", "'assets/missing.png'", '(globalThis.thumbnailCodeRan = true)']) {
+        assert.equal(thumbnailPath(project(`class Game { static metadata() { return {thumbnail:${value}}; } }`)), null);
+    }
+    assert.equal(thumbnailPath(project('class {')), null);
+    assert.equal(thumbnailPath({}), null);
+    assert.equal(globalThis.thumbnailCodeRan, undefined);
+});