-
Предпросмотр обрабатывает только выбранный файл. Декомпилированные скрипты сохраняются в unrpyc.zip, для каждого .rpa создаётся отдельный ZIP с папками и файлами архива. Сценарии .rpyc/.rpymc внутри него восстанавливаются в .rpy/.rpym, поддерживаемые .pyc в .py. Если исходник уже есть, он сохраняется без замены.
+
Предпросмотр обрабатывает только выбранный файл. Декомпилированные скрипты сохраняются в unrpyc.zip, для каждого .rpa создаётся отдельный ZIP с папками и файлами архива. Скрипты .rpyc/.rpymc внутри него восстанавливаются в .rpy/.rpym, поддерживаемые .pyc в .py. Если исходник уже есть, он сохраняется без замены.
UnRpyc восстанавливает .rpyc и .rpymc. Файлы Ren'Py 6/7 тоже обрабатываются, но совместимость зависит от версии игры. Комментарии и исходное форматирование в скомпилированных файлах не сохраняются.
Расширенная декомпиляция добавляет извлечённые блоки в конец скрипта для изучения и адаптации с сохранением исходных контейнеров. Если Python-блок содержит только байткод, вместо него остаются комментарий и pass с предупреждением.
uncompyle6 восстанавливает .pyc с байткодом Python 2.0–3.8. Версии 3.9 и новее не поддерживаются. Для файлов из __pycache__ исходник получает обычное имя .py. Комментарии и исходное форматирование не восстанавливаются.
diff --git a/tests/app_regressions_browser.cjs b/tests/app_regressions_browser.cjs
new file mode 100644
index 0000000..9d2afa3
--- /dev/null
+++ b/tests/app_regressions_browser.cjs
@@ -0,0 +1,141 @@
+/* Optional native-browser regressions. Start ES Doc and set NODE_PATH to
+ Playwright; APP_TEST_URL defaults to http://127.0.0.1:8012. */
+const assert = require('node:assert/strict');
+const {chromium} = require('playwright');
+const origin = process.env.APP_TEST_URL || 'http://127.0.0.1:8012';
+
+const softNavigate = async (page, path) => {
+ await page.evaluate(href => {
+ const link = document.createElement('a');
+ link.href = href;
+ document.body.appendChild(link);
+ link.click();
+ link.remove();
+ }, path);
+ await page.waitForURL(origin + path);
+ await page.waitForFunction(href => window.__lastRegressionNavigation === href, origin + path);
+};
+
+(async () => {
+ const browser = await chromium.launch({headless: true});
+ try {
+ const page = await browser.newPage();
+ const errors = [];
+ page.on('pageerror', error => errors.push(error.message));
+ await page.addInitScript(() => {
+ window.__regressionDocument = 'original';
+ window.__regressionListeners = new Set();
+ window.__regressionObservers = new Set();
+ const originalAdd = window.addEventListener;
+ window.addEventListener = function (type, callback, options) {
+ if (options?.signal && ['scroll', 'resize', 'hashchange', 'load'].includes(type)) {
+ const record = {type};
+ window.__regressionListeners.add(record);
+ options.signal.addEventListener('abort', () => window.__regressionListeners.delete(record), {once: true});
+ }
+ return originalAdd.call(this, type, callback, options);
+ };
+ const OriginalObserver = window.ResizeObserver;
+ window.ResizeObserver = class extends OriginalObserver {
+ constructor(callback) { super(callback); window.__regressionObservers.add(this); }
+ observe(target, options) { this.target = target; super.observe(target, options); }
+ disconnect() { window.__regressionObservers.delete(this); super.disconnect(); }
+ };
+ originalAdd.call(window, 'esdoc:navigation', event => {
+ window.__lastRegressionNavigation = event.detail.url;
+ });
+ });
+ await page.goto(origin + '/docs/variables');
+ await page.waitForFunction(() => typeof window.__esdocDocsCleanup === 'function');
+ await page.evaluate(() => window.__regressionDocument = 'retained');
+ for (const slug of ['screens', 'videos', 'variables', 'screens', 'videos']) {
+ await softNavigate(page, '/docs/' + slug);
+ const live = await page.evaluate(() => ({
+ document: window.__regressionDocument,
+ listeners: window.__regressionListeners.size,
+ observers: [...window.__regressionObservers].filter(observer => observer.target?.closest('#sidebar-contents')).length,
+ }));
+ assert.deepEqual(live, {document: 'retained', listeners: 4, observers: 1});
+ }
+
+ // Two real Back actions while the first HTTP request is held open.
+ let heldRoute, announceRequest;
+ const started = new Promise(resolve => { announceRequest = resolve; });
+ await page.route('**/docs/screens', route => { heldRoute = route; announceRequest(); });
+ await page.evaluate(() => history.back());
+ await started;
+ await page.evaluate(() => history.back());
+ await page.waitForURL(origin + '/docs/variables');
+ await page.waitForFunction(() => document.querySelector('#sidebar-all a[aria-current="page"]')
+ ?.getAttribute('href') === '/docs/variables');
+ await heldRoute.abort().catch(() => {});
+ await page.unroute('**/docs/screens');
+ assert.equal(new URL(page.url()).pathname, '/docs/variables');
+ assert.equal(await page.evaluate(() => window.__regressionDocument), 'retained');
+
+ await softNavigate(page, '/materials');
+ assert.deepEqual(await page.evaluate(() => ({
+ listeners: window.__regressionListeners.size,
+ observers: [...window.__regressionObservers].filter(observer => observer.target?.closest('#sidebar-contents')).length,
+ })), {listeners: 0, observers: 0});
+
+ // Pending search results must remain hidden after clearing the field.
+ let searchRoute, announceSearch;
+ const searchStarted = new Promise(resolve => { announceSearch = resolve; });
+ await page.route('**/api/search?**', route => { searchRoute = route; announceSearch(); });
+ await page.locator('#site-search-input').fill('Луна');
+ await searchStarted;
+ await page.locator('#site-search-input').fill('');
+ await searchRoute.fulfill({json: [{label: 'Луна', url: '/stale'}]});
+ await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
+ assert.equal(await page.locator('#site-search-results').isHidden(), true);
+ assert.equal(await page.locator('#site-search-input').getAttribute('aria-expanded'), 'false');
+ assert.deepEqual(errors, []);
+ await page.close();
+ console.log('Native browser checks passed: article cleanup, overlapping Back actions and dismissed search.');
+
+ // A small valid WAV exercises real Audio playback with both stores denied.
+ const samples = 8000 * 8, wav = Buffer.alloc(44 + samples * 2);
+ wav.write('RIFF'); wav.writeUInt32LE(wav.length - 8, 4); wav.write('WAVEfmt ', 8);
+ wav.writeUInt32LE(16, 16); wav.writeUInt16LE(1, 20); wav.writeUInt16LE(1, 22);
+ wav.writeUInt32LE(8000, 24); wav.writeUInt32LE(16000, 28); wav.writeUInt16LE(2, 32);
+ wav.writeUInt16LE(16, 34); wav.write('data', 36); wav.writeUInt32LE(samples * 2, 40);
+ for (const failure of ['getter', 'methods']) {
+ const playerPage = await browser.newPage();
+ const playerErrors = [];
+ playerPage.on('pageerror', error => playerErrors.push(error.message));
+ await playerPage.addInitScript(failure => {
+ for (const name of ['localStorage', 'sessionStorage']) Object.defineProperty(window, name, {
+ configurable: true,
+ get() {
+ if (failure === 'getter') throw new DOMException('Storage denied', 'SecurityError');
+ return {getItem() { throw new Error('denied'); }, setItem() { throw new Error('denied'); },
+ removeItem() { throw new Error('denied'); }};
+ },
+ });
+ }, failure);
+ await playerPage.route('**/regression.wav', route => route.fulfill({body: wav, contentType: 'audio/wav'}));
+ await playerPage.goto(origin + '/');
+ await playerPage.evaluate(() => {
+ const button = document.createElement('button');
+ button.id = 'regression-play'; button.hidden = true;
+ button.dataset.playSrc = '/regression.wav'; button.dataset.playName = 'Regression audio';
+ button.textContent = 'Play'; document.body.appendChild(button);
+ window.dispatchEvent(new CustomEvent('esdoc:navigation'));
+ });
+ await playerPage.locator('#regression-play').click();
+ await playerPage.waitForFunction(() => document.querySelector('#regression-play').getAttribute('aria-pressed') === 'true');
+ assert.equal(await playerPage.locator('.res-nowplaying').isVisible(), true);
+ await playerPage.locator('.res-volume input').evaluate(input => {
+ input.value = '0.35'; input.dispatchEvent(new Event('input', {bubbles: true}));
+ });
+ assert.equal(await playerPage.locator('.res-volume input').inputValue(), '0.35');
+ await playerPage.locator('.res-nowplaying-pause').click();
+ await playerPage.waitForFunction(() => document.querySelector('#regression-play').getAttribute('aria-pressed') === 'false');
+ assert.equal(await playerPage.locator('#regression-play').getAttribute('aria-pressed'), 'false');
+ assert.deepEqual(playerErrors, []);
+ await playerPage.close();
+ }
+ console.log('Native audio checks passed with storage getters and methods denied.');
+ } finally { await browser.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/tests/characters_browser.cjs b/tests/characters_browser.cjs
new file mode 100644
index 0000000..65eeb09
--- /dev/null
+++ b/tests/characters_browser.cjs
@@ -0,0 +1,82 @@
+/* Run against a local ES Doc server. Set NODE_PATH to bundled Node packages. */
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const {chromium} = require('playwright');
+const target = process.env.CHARACTERS_TEST_URL || 'http://127.0.0.1:8013/tools/characters';
+(async () => {
+ const browser = await chromium.launch({headless:true});
+ const page = await browser.newPage({viewport:{width:1440,height:1100}});
+ const errors = []; page.on('pageerror',error => errors.push(error.message));
+ try {
+ await page.goto(target); await page.locator('#characters-app').waitFor({state:'visible'});
+ const code = () => page.locator('#character-code').inputValue();
+ assert.equal(await page.locator('.page-title').textContent(),'Создатель простых персонажей');
+ assert.equal(await page.locator('#character-name-mode,#character-all-settings,#character-value-who_size').count(),0);
+ await page.locator('#character-name').fill(''); assert.match(await code(),/Character\(\s*None/);
+ assert(await page.locator('#character-namebox').isHidden());
+ await page.locator('#character-name').fill('player_name');
+ await page.locator('#character-dynamic').check(); assert.match(await code(),/dynamic=True/);
+ assert(await page.locator('#character-dynamic-warning').isVisible());
+ const name = await page.locator('#character-preview-who').textContent();
+ await page.waitForTimeout(200); assert.notEqual(await page.locator('#character-preview-who').textContent(),name);
+ await page.locator('#character-color-who_color').fill('#123456');
+ await page.locator('#character-value-what_underline').selectOption('True');
+ await page.locator('#character-value-what_strikethrough').selectOption('True');
+ assert.equal(await page.locator('#character-preview-what').evaluate(el => el.style.textDecoration),'underline line-through');
+ await page.locator('#character-kind').selectOption('un'); assert.match(await code(),/kind=un/);
+ assert.match(await code(),/who_color="#123456"/);
+ await page.locator('#character-kind').selectOption('custom');
+ await page.locator('#character-custom-kind').fill('my_character');
+ assert.match(await code(),/kind=my_character/); assert.match(await code(),/who_color="#123456"/);
+ await page.locator('#character-value-what_suffix').fill('!'); assert.match(await code(),/what_suffix="!"/);
+ await page.locator('#character-value-who_font').fill('fonts/custom.ttf');
+ assert.match(await code(),/who_font="fonts\/custom.ttf"/);
+ assert.match(await page.locator('#character-help-who_font').textContent(),/невозможно предсмотреть/);
+ await page.locator('#character-variable').fill('bad name'); assert(await page.locator('#character-copy').isDisabled());
+ await page.locator('#character-fix-error').click(); assert.equal(await page.evaluate(() => document.activeElement.id),'character-variable');
+ await page.locator('#character-variable').fill('e');
+ const saved = await code(); await page.locator('#character-reset').click(); await page.locator('#character-undo').click(); assert.equal(await code(),saved);
+ await page.reload(); await page.locator('#characters-app').waitFor({state:'visible'}); assert.equal(await code(),saved);
+ const draft = await page.evaluate(() => localStorage.getItem('es-doc-character-draft-v1'));
+ await page.locator('#character-reset').click();
+ await page.locator('#character-project-file').setInputFiles({name:'character.json',mimeType:'application/json',buffer:Buffer.from(draft)});
+ await page.waitForFunction(() => document.querySelector('#character-code').value.includes('kind=my_character'));
+ assert.equal(await code(),saved);
+ await page.emulateMedia({reducedMotion:'reduce'}); await page.locator('#character-name').fill('player_name_reduced');
+ const reduced = await page.locator('#character-preview-who').textContent(); await page.waitForTimeout(200); assert.equal(await page.locator('#character-preview-who').textContent(),reduced);
+ await page.locator('#character-dynamic').uncheck();
+ const background = await page.locator('#character-dialogue-window').evaluate(el => getComputedStyle(el).backgroundImage);
+ assert.match(background,/dialogue_box\/day\/dialogue_box.png/);
+ const artwork = await page.request.get(new URL('/resource/raw/images/gui/dialogue_box/day/dialogue_box.png',target).href); assert.equal(artwork.status(),200);
+ await page.locator('#character-kind').selectOption('');
+ await page.locator('#character-name').fill('Семён');
+ await page.locator('#character-value-who_color').fill('');
+ await page.locator('#character-value-what_underline').selectOption(''); await page.locator('#character-value-what_strikethrough').selectOption('');
+ const geometry = await page.locator('#character-dialogue-window').evaluate(el => {
+ const box = el.getBoundingClientRect(), who = document.querySelector('#character-preview-who').getBoundingClientRect(), what = document.querySelector('#character-preview-what').getBoundingClientRect();
+ return {ratio:box.width/box.height,whoX:(who.left-box.left)/box.width,whoY:(who.top-box.top)/box.height,whatY:(what.top-box.top)/box.height};
+ });
+ assert(Math.abs(geometry.ratio - 1572/151) < .02,'Original dialogue artwork must keep its aspect ratio');
+ assert(Math.abs(geometry.whoX - 20/1572) < .002,'Name keeps the original left inset');
+ assert(Math.abs(geometry.whoY - 15/151) < .01,'Name keeps the original vertical inset');
+ assert(Math.abs(geometry.whatY - 48/151) < .01,'Dialogue starts below the original name tab');
+ await page.locator('#character-preview-heading').scrollIntoViewIfNeeded();
+ await page.screenshot({path:'temp/characters-desktop.png'});
+ await page.setViewportSize({width:390,height:844});
+ await page.locator('#character-preview-heading').scrollIntoViewIfNeeded();
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+ await page.screenshot({path:'temp/characters-mobile.png'});
+ await page.locator('#character-zoom').click();
+ assert.equal(await page.locator('#character-zoom').getAttribute('aria-pressed'),'true');
+ const zoom = await page.locator('#character-stage').evaluate(el => {const box=el.getBoundingClientRect(); return {width:box.width,ratio:box.width/box.height};});
+ assert(zoom.width >= 960); assert(Math.abs(zoom.ratio-1572/151) < .02);
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth),'Zoom scroll stays inside the preview');
+ await page.locator('#character-name').fill('Имя'.repeat(100)); await page.locator('#character-sample').fill('Длинная реплика '.repeat(100));
+ const longRatio = await page.locator('#character-stage').evaluate(el => el.clientWidth/el.clientHeight);
+ assert(Math.abs(longRatio - 1572/151) < .1,'Long text must not stretch the artwork');
+ await page.locator('#character-zoom').click();
+
+ await page.locator('.page-back').click(); await page.waitForURL('**/tools'); await page.goBack(); await page.locator('#characters-app').waitFor({state:'visible'});
+ assert.deepEqual(errors,[]); console.log('Character browser checks passed (desktop/mobile, dynamic/reduced motion, inheritance, export, draft and undo).');
+ } finally { await browser.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/tests/characters_core.test.mjs b/tests/characters_core.test.mjs
new file mode 100644
index 0000000..ae36f3b
--- /dev/null
+++ b/tests/characters_core.test.mjs
@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import {readFileSync, existsSync} from 'node:fs';
+import vm from 'node:vm';
+import test from 'node:test';
+
+const window = {};
+for (const file of ['characters-catalog.js', 'characters-core.js']) {
+ const path = new URL('../static/js/' + file, import.meta.url);
+ if (existsSync(path)) vm.runInNewContext(readFileSync(path, 'utf8'), {window});
+}
+const core = () => { assert.ok(window.ESDocCharacters); return window.ESDocCharacters; };
+const state = () => ({variable: 'e', name: 'Семён', nameMode: 'text', sample: 'Привет!', values: {}});
+
+test('simple creator exports empty names as narration and restricts restored properties', () => {
+ const s = state(); s.name = '';
+ assert.match(core().compile(s).code, /Character\(None\)/);
+ s.values = {who_color:{mode:'text',value:'#abc'}, what_size:{mode:'number',value:'42'}};
+ const restored = core().simpleState(s);
+ assert.equal(restored.values.who_color.value, '#abc');
+ assert.equal(restored.values.what_size, undefined);
+ assert.equal(restored.nameMode, 'text');
+ assert.equal(restored.values.dynamic.value, 'False', 'Normal names must not inherit DynamicCharacter evaluation');
+});
+
+test('simple properties cover both name and dialogue without engine settings', () => {
+ const keys = core().fields.map(field => field.key);
+ for (const prefix of ['who','what']) for (const property of ['color','prefix','suffix','font','bold','italic','strikethrough','underline']) {
+ assert(keys.includes(prefix + '_' + property));
+ }
+ assert.equal(keys.length, 18);
+});
+
+test('unset properties inherit; explicit False, zero and None survive export', () => {
+ const s = state();
+ s.values = {what_bold: {mode: 'boolean', value: 'False'}, what_kerning: {mode: 'number', value: '0'}, callback: {mode: 'expression', value: 'None'}};
+ const result = core().compile(s);
+ assert.deepEqual(Array.from(result.errors), []);
+ assert.match(result.code, /what_bold=False/);
+ assert.match(result.code, /what_kerning=0/);
+ assert.match(result.code, /callback=None/);
+ assert.doesNotMatch(result.code, /who_color/);
+});
+
+test('strings escape quotes, backslashes and newlines and keep RenPy tags', () => {
+ const s = state(); s.name = '"Имя"\\\n{b}[player]';
+ assert.ok(core().compile(s).code.includes('"\\"Имя\\"\\\\\\n{b}[player]"'));
+});
+
+test('narration, inherited name and callable name are distinct', () => {
+ const s = state(); s.nameMode = 'none';
+ assert.match(core().compile(s).code, /Character\(None\)/);
+ s.nameMode = 'inherit';
+ assert.match(core().compile(s).code, /Character\(\)/);
+ s.nameMode = 'expression'; s.name = 'get_name';
+ assert.match(core().compile(s).code, /Character\(get_name\)/);
+});
+
+test('Python values preserve tuples, calls and numeric int/float distinction without execution', () => {
+ const c = core();
+ assert.equal(c.serialize({mode:'expression',value:'[(2, "#0008", 0, 1)]'}), '[(2, "#0008", 0, 1)]');
+ assert.equal(c.serialize({mode:'expression',value:'my_callback'}), 'my_callback');
+ assert.equal(c.serialize({mode:'number',value:'1.0'}), '1.0');
+ assert.throws(() => c.serialize({mode:'number',value:'NaN'}));
+ assert.throws(() => c.serialize({mode:'expression',value:'Frame("x.png"'}));
+ assert.throws(() => c.serialize({mode:'expression',value:'True); hacked() #'}));
+});
+
+test('invalid identifiers and keyword injections block the entire export', () => {
+ const s = state(); s.variable = 'class';
+ assert.ok(core().compile(s).errors.length);
+ assert.equal(core().compile(s).code, '');
+ s.variable = 'семён';
+ assert.equal(core().compile(s).errors.length, 0);
+ s.values['what_color); bad()'] = {mode:'text',value:'#fff'};
+ assert.equal(core().compile(s).code, '');
+ s.values = {name: {mode:'text',value:'Duplicate'}};
+ assert.equal(core().compile(s).code, '');
+});
+
+test('project import rejects corrupt or executable structure and preserves exact configured values', () => {
+ const s = state(); s.values.what_color = {mode:'text', value:'#abc8'};
+ const c = core();
+ const encoded = c.project(s);
+ assert.equal(c.compile(c.importProject(encoded)).code, c.compile(s).code);
+ for (const bad of ['{}', '{"version":99}', '{"version":1,"state":{"values":{"__proto__":{}}}}']) {
+ assert.throws(() => c.importProject(bad));
+ }
+ assert.throws(() => c.importProject('null'), /Неподдерживаемый формат проекта/);
+});
+
+test('preview parser handles outline tuples and rejects Python calls without executing them', () => {
+ const c = core();
+ assert.equal(c.literal('[(2, "#0008", 0, 1)]').ok, true);
+ assert.equal(c.literal('True').value, true);
+ assert.equal(c.literal('None').value, null);
+ assert.equal(c.literal('callback()').ok, false);
+ assert.equal(c.literal('1 + 2').ok, false);
+ assert.equal(c.literal('['.repeat(40) + ']'.repeat(40)).ok, false);
+});
diff --git a/tests/colors_ui.test.mjs b/tests/colors_ui.test.mjs
index d3f589f..e314360 100644
--- a/tests/colors_ui.test.mjs
+++ b/tests/colors_ui.test.mjs
@@ -45,10 +45,10 @@ function page(options = {}) {
const copied = [];
const stored = new Map();
const timers = new Map();
- const window = {...options, navigator: {clipboard: {writeText: async value => copied.push(value)}},
+ const window = {...options, navigator: {clipboard: {writeText: async value => copied.push(value)}, ...options.navigator},
localStorage: {getItem: key => stored.get(key), setItem: (key, value) => stored.set(key, value)}};
let timerId = 0;
- const context = vm.createContext({ document, window, AbortController, Event, setTimeout: callback => { timers.set(++timerId, callback); return timerId; }, clearTimeout: id => timers.delete(id) });
+ const context = vm.createContext({ document, window, AbortController, DOMException, Event, setTimeout: callback => { timers.set(++timerId, callback); return timerId; }, clearTimeout: id => timers.delete(id) });
for (const file of ['colors-named.js', 'colors-core.js', 'colors.js']) vm.runInContext(fs.readFileSync(new URL('../static/js/' + file, import.meta.url), 'utf8'), context);
const input = (id, value) => { const element = get('colors-' + id); element.focus(); element.value = value; element.emit('input'); };
return { get: id => get('colors-' + id), input, copied, window, stored, document, runTimers: () => { for (const callback of timers.values()) callback(); timers.clear(); } };
@@ -105,6 +105,105 @@ test('changing palette and selecting a swatch resets alpha and invalid inputs',
assert.equal(ui.get('swatches').children[0].children[3].getAttribute('aria-pressed'), 'true');
});
+test('unavailable pipette stays visible and explains browser support on click', () => {
+ for (const options of [{isSecureContext: true}, {isSecureContext: false, EyeDropper: class {}}]) {
+ const ui = page(options);
+ const original = ui.get('output-hex').value;
+ assert.equal(ui.get('eyedropper').hidden, false);
+ ui.get('eyedropper').click();
+ assert.equal(ui.get('status').textContent, 'Пипетка недоступна в вашем браузере.');
+ assert.equal(ui.get('output-hex').value, original);
+ assert.equal(ui.get('eyedropper-overlay').hidden, true);
+ }
+});
+
+test('pipette warning appears only in Firefox', () => {
+ for (const [userAgent, visible] of [
+ ['Mozilla/5.0 Gecko/20100101 Firefox/143.0', true],
+ ['Mozilla/5.0 FxiOS/143.0', true],
+ ['Mozilla/5.0 Chrome/143.0 Safari/537.36', false],
+ ['', false]
+ ]) {
+ const ui = page({navigator: {userAgent}});
+ assert.equal(ui.get('eyedropper-warning').hidden, !visible);
+ assert.equal(ui.get('eyedropper').title, undefined);
+ }
+});
+
+test('Firefox tooltip supports hover, keyboard focus, Escape and touch', () => {
+ const ui = page({navigator: {userAgent: 'Firefox/143.0'}});
+ const warning = ui.get('eyedropper-warning');
+ const trigger = ui.get('eyedropper-warning-trigger');
+ const tooltip = ui.get('eyedropper-tooltip');
+ warning.emit('pointerenter', {pointerType: 'mouse'});
+ assert.equal(tooltip.hidden, true);
+ ui.runTimers();
+ assert.equal(tooltip.hidden, false);
+ warning.emit('pointerleave');
+ assert.equal(tooltip.hidden, true);
+ trigger.emit('focus');
+ assert.equal(tooltip.hidden, false);
+ ui.document.emit('keydown', {key: 'Escape'});
+ assert.equal(tooltip.hidden, true);
+ trigger.emit('blur');
+ warning.emit('pointerenter', {pointerType: 'mouse'});
+ warning.emit('pointerleave');
+ ui.runTimers();
+ assert.equal(tooltip.hidden, true);
+ trigger.click();
+ assert.equal(tooltip.hidden, false);
+ ui.window.__esdocColorsCleanup();
+ ui.runTimers();
+ assert.equal(tooltip.hidden, true);
+});
+
+test('screen capture selects external window colors from a frozen preview using its own coordinates', async () => {
+ let stopped = 0, drawn = 0, sampled;
+ const ui = page({isSecureContext: true, navigator: {mediaDevices: {getDisplayMedia: async options => {
+ assert.equal(options.preferCurrentTab, undefined);
+ return {getTracks: () => [{stop: () => stopped++}]};
+ }}}});
+ ui.document.createElement = name => {
+ assert.equal(name, 'video');
+ return {videoWidth: 1600, videoHeight: 900, play: async () => {}};
+ };
+ const canvas = ui.get('screen-canvas');
+ canvas.getBoundingClientRect = () => ({left: 100, top: 20, width: 800, height: 450});
+ canvas.getContext = () => ({drawImage: () => drawn++, getImageData: (x, y) => {
+ sampled = [x, y]; return {data: [18, 52, 86, 255]};
+ }});
+ ui.get('eyedropper').click();
+ assert.equal(ui.get('status').textContent, 'Выберите экран или окно для снимка.');
+ await new Promise(resolve => setImmediate(resolve));
+ assert.equal(canvas.hidden, false);
+ assert.equal(stopped, 1);
+ assert.equal(drawn, 1);
+ ui.get('eyedropper-overlay').emit('pointerdown', {target: canvas, button: 0, clientX: 500, clientY: 245, preventDefault() {}});
+ await new Promise(resolve => setImmediate(resolve));
+ assert.deepEqual(sampled, [800, 450]);
+ assert.equal(drawn, 1);
+ assert.equal(ui.get('output-hex').value, '#123456');
+ assert.equal(canvas.hidden, true);
+ assert.equal(ui.get('eyedropper-overlay').hidden, true);
+});
+
+test('screen capture cancellation during permission prompt stops a late stream', async () => {
+ let resolveCapture, stopped = 0;
+ const ui = page({isSecureContext: true, navigator: {mediaDevices: {
+ getDisplayMedia: () => new Promise(resolve => { resolveCapture = resolve; })
+ }}});
+ const original = ui.get('output-hex').value;
+ ui.get('eyedropper').click();
+ ui.document.emit('keydown', {key: 'Escape', preventDefault() {}});
+ resolveCapture({getTracks: () => [{stop: () => stopped++}]});
+ await new Promise(resolve => setImmediate(resolve));
+ assert.equal(stopped, 1);
+ assert.equal(ui.get('screen-canvas').hidden, true);
+ assert.equal(ui.get('eyedropper-overlay').hidden, true);
+ assert.equal(ui.get('eyedropper').disabled, false);
+ assert.equal(ui.get('output-hex').value, original);
+});
+
test('right click or Escape cancels the eyedropper without applying a late result', async () => {
let resolvePick, signal;
const ui = page({isSecureContext: true, EyeDropper: class {
diff --git a/tests/create_tools_fixtures.py b/tests/create_tools_fixtures.py
index b396293..e7add2e 100644
--- a/tests/create_tools_fixtures.py
+++ b/tests/create_tools_fixtures.py
@@ -1,5 +1,7 @@
"""Synthetic Ren'Py/RPA fixtures for the optional real-browser smoke test."""
from pathlib import Path
+import pickle
+import zlib
from tests.test_tools_engine import EngineTests, archive
@@ -17,6 +19,18 @@ def main():
(root / 'bad.rpyc').write_bytes(b'not a compiled RenPy script')
(root / 'images.rpa').write_bytes(archive({'images/test.txt': [(b'second archive', b'')]}))
+ # Seek over a large payload so fixture creation does not allocate it in RAM.
+ length, key = 65 * 1024 * 1024, 0xDEADBEEF
+ index_offset = 34 + length + 2
+ with (root / 'large.rpa').open('wb') as output:
+ output.write(f'RPA-3.0 {index_offset:016x} {key:08x}\n'.encode())
+ output.seek(34 + length)
+ output.write(b'ok')
+ output.write(zlib.compress(pickle.dumps({
+ 'big.bin': [(34 ^ key, length ^ key, b'')],
+ 'small.txt': [((34 + length) ^ key, 2 ^ key, b'')],
+ }, protocol=2)))
+
if __name__ == '__main__':
main()
diff --git a/tests/docs_lifecycle.test.mjs b/tests/docs_lifecycle.test.mjs
new file mode 100644
index 0000000..df62e97
--- /dev/null
+++ b/tests/docs_lifecycle.test.mjs
@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import vm from 'node:vm';
+
+const source = readFileSync(new URL('../static/js/docs.js', import.meta.url), 'utf8');
+const tick = () => new Promise(resolve => setImmediate(resolve));
+const emit = (target, name, properties = {}) => {
+ const event = new Event(name);
+ for (const [name, value] of Object.entries(properties)) Object.defineProperty(event, name, { value });
+ target.dispatchEvent(event);
+};
+
+function docs() {
+ const window = new EventTarget(), frames = new Map(), media = [], observers = [], css = [], pushes = [];
+ let frameId = 0, currentPage, resolveFonts;
+ class ResizeObserver {
+ constructor(callback) { this.callback = callback; observers.push(this); }
+ observe() {}
+ disconnect() { this.disconnected = true; }
+ }
+ window.ResizeObserver = ResizeObserver;
+ const context = vm.createContext({
+ window, ResizeObserver, AbortController, location: { hash: '' }, innerHeight: 1000, scrollY: 0,
+ addEventListener: window.addEventListener.bind(window),
+ requestAnimationFrame: fn => { const id = ++frameId; frames.set(id, fn); return id; },
+ cancelAnimationFrame: id => frames.delete(id),
+ getComputedStyle: () => ({ scrollPaddingTop: '64px' }),
+ matchMedia: () => { const item = new EventTarget(); item.matches = false; media.push(item); return item; },
+ history: { pushState: (...args) => pushes.push(args) },
+ document: {
+ getElementById: id => ({ 'sidebar-all': currentPage.tree, 'sidebar-contents': currentPage.contents,
+ section: currentPage.heading })[id],
+ querySelectorAll: selector => selector.startsWith('.sidebar-toc') ? currentPage.links : currentPage.headings,
+ documentElement: { scrollHeight: 2000, style: { setProperty: (...args) => css.push(args) } },
+ fonts: { ready: new Promise(resolve => { resolveFonts = resolve; }) },
+ },
+ });
+ function page(hasHeadings = true) {
+ const summary = { offsetHeight: 32, focus() {} };
+ const tree = new EventTarget(), contents = new EventTarget();
+ for (const details of [tree, contents]) {
+ details.open = false;
+ details.contains = () => false;
+ details.querySelector = selector => selector === 'summary' ? summary : null;
+ details.closest = () => null;
+ }
+ const link = { hash: '#section', classList: { add() {}, remove() {} }, setAttribute() {}, removeAttribute() {} };
+ const result = {
+ tree, contents, reads: 0, links: hasHeadings ? [link] : [],
+ heading: { id: 'section',
+ getBoundingClientRect() { result.reads++; return { top: 0 }; },
+ setAttribute() {}, focus() {}, scrollIntoView() {},
+ },
+ };
+ result.headings = hasHeadings ? [result.heading] : [];
+ currentPage = result;
+ vm.runInContext(source, context);
+ result.reads = 0;
+ return result;
+ }
+ function flush() {
+ const callbacks = [...frames.values()]; frames.clear(); callbacks.forEach(fn => fn());
+ }
+ return { window, page, flush, frames, media, observers, css, pushes, resolveFonts };
+}
+
+test('repeated article navigation retains only the current scroll handler', () => {
+ const site = docs(), pages = [];
+ for (let i = 0; i < 12; i++) pages.push(site.page());
+ emit(site.window, 'scroll');
+ site.flush();
+ assert.ok(pages.at(-1).reads > 0);
+ assert.ok(pages.slice(0, -1).every(page => page.reads === 0), 'Old articles still inspect their headings');
+ assert.ok(site.observers.slice(0, -1).every(observer => observer.disconnected));
+});
+
+test('explicit cleanup removes global and media handlers and disconnects the observer', () => {
+ const site = docs(), page = site.page();
+ assert.equal(typeof site.window.__esdocDocsCleanup, 'function');
+ site.window.__esdocDocsCleanup();
+ for (const name of ['scroll', 'resize', 'hashchange', 'load']) emit(site.window, name);
+ for (const media of site.media) { media.matches = true; emit(media, 'change'); }
+ site.flush();
+ assert.equal(page.reads, 0);
+ assert.equal(page.tree.open, false);
+ assert.equal(page.contents.open, false);
+ assert.equal(site.observers[0].disconnected, true);
+ const writes = site.css.length;
+ site.observers[0].callback();
+ assert.equal(site.css.length, writes);
+});
+
+test('pages without headings still clean up their disclosure handlers and observer', () => {
+ const site = docs(), page = site.page(false);
+ assert.equal(typeof site.window.__esdocDocsCleanup, 'function');
+ site.window.__esdocDocsCleanup();
+ for (const media of site.media) { media.matches = true; emit(media, 'change'); }
+ assert.equal(page.tree.open, false);
+ assert.equal(page.contents.open, false);
+ assert.equal(site.observers[0].disconnected, true);
+});
+
+test('cleanup cancels scroll frames and prevents deferred font and TOC callbacks', async () => {
+ const site = docs(), page = site.page();
+ emit(site.window, 'scroll');
+ emit(page.contents, 'click', { button: 0, target: { closest: () => page.links[0] } });
+ assert.ok(site.frames.size > 0);
+ assert.equal(typeof site.window.__esdocDocsCleanup, 'function');
+ site.window.__esdocDocsCleanup();
+ site.flush();
+ site.resolveFonts();
+ await tick();
+ assert.equal(site.frames.size, 0);
+ assert.equal(page.reads, 0);
+ assert.deepEqual(site.pushes, []);
+});
diff --git a/tests/navigation.test.mjs b/tests/navigation.test.mjs
new file mode 100644
index 0000000..b8a97f5
--- /dev/null
+++ b/tests/navigation.test.mjs
@@ -0,0 +1,221 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import vm from 'node:vm';
+
+const source = readFileSync(new URL('../static/js/navigation.js', import.meta.url), 'utf8');
+const tick = () => new Promise(resolve => setImmediate(resolve));
+
+function navigation({ holdStyles = false, holdScripts = false } = {}) {
+ const events = {}, requests = [], links = [], scripts = [], pushes = [], redirects = [];
+ const content = { innerHTML: 'initial' };
+ let current = new URL('https://example.test/docs/current');
+ const location = {
+ get href() { return current.href; },
+ set href(value) { redirects.push(value); current = new URL(value, current); },
+ get origin() { return current.origin; },
+ get pathname() { return current.pathname; },
+ get search() { return current.search; },
+ };
+ function element(kind) {
+ const handlers = {};
+ return {
+ kind, dataset: {}, removed: false,
+ addEventListener: (name, fn) => { handlers[name] = fn; },
+ remove() { this.removed = true; },
+ loaded() { handlers.load?.(); },
+ };
+ }
+ const document = {
+ title: 'initial', body: { className: '' }, documentElement: { dataset: {} },
+ getElementById: () => content,
+ addEventListener: (name, fn) => { events['document-' + name] = fn; },
+ querySelectorAll: selector => selector.startsWith('script') ? scripts.filter(s => !s.removed) : [],
+ createElement: element,
+ head: {
+ querySelectorAll: () => links.filter(link => !link.removed),
+ appendChild(item) {
+ (item.kind === 'link' ? links : scripts).push(item);
+ if (item.kind === 'link' ? !holdStyles : !holdScripts) queueMicrotask(() => item.loaded());
+ },
+ },
+ };
+ const fetch = (url, options) => new Promise((resolve, reject) => requests.push({ url, options, resolve, reject }));
+ const window = {
+ fetch, DOMParser: true, scrollTo() {}, dispatchEvent() {},
+ addEventListener: (name, fn) => { events[name] = fn; },
+ };
+ const history = {
+ pushState(state, title, url) { pushes.push(url); current = new URL(url); },
+ replaceState(state, title, url) { current = new URL(url); },
+ };
+ class DOMParser {
+ parseFromString(text) {
+ const page = JSON.parse(text);
+ return {
+ title: page.name, body: { className: page.name },
+ getElementById: () => ({ innerHTML: page.name }),
+ head: { querySelectorAll: selector => selector.startsWith('link')
+ ? (page.styles || []).map(href => ({ href }))
+ : (page.scripts || []).map(src => ({ src })) },
+ };
+ }
+ }
+ vm.runInNewContext(source, {
+ window, document, fetch, location, history, DOMParser, URL, AbortController,
+ CustomEvent: class {}, localStorage: { getItem: () => null },
+ });
+ return {
+ content, document, location, requests, links, scripts, pushes, redirects, window,
+ replace(url) { current = new URL(url, current); },
+ pop(path) { current = new URL(path, current); events.popstate(); },
+ click(path) {
+ let prevented = false;
+ events['document-click']({
+ button: 0, target: { closest: () => ({ href: new URL(path, current).href, hasAttribute: () => false }) },
+ preventDefault() { prevented = true; },
+ });
+ return prevented;
+ },
+ respond(index, page, { ok = true, type = 'text/html' } = {}) {
+ requests[index].resolve({ ok, headers: { get: () => type }, text: async () => JSON.stringify(page) });
+ },
+ };
+}
+
+test('the latest Back or Forward event wins even while the previous fetch is pending', async () => {
+ const nav = navigation();
+ nav.pop('/docs/first');
+ nav.pop('/docs/latest');
+ assert.equal(nav.requests.length, 2);
+ assert.equal(nav.requests[0].options.signal.aborted, true);
+ nav.respond(1, { name: 'latest' });
+ await tick();
+ nav.respond(0, { name: 'first' });
+ await tick();
+ assert.equal(nav.content.innerHTML, 'latest');
+ assert.equal(nav.location.pathname, '/docs/latest');
+ assert.deepEqual(nav.pushes, []);
+});
+
+test('Back supersedes a pending clicked link without creating another history entry', async () => {
+ const nav = navigation();
+ assert.equal(nav.click('/docs/clicked'), true);
+ nav.pop('/docs/back');
+ assert.equal(nav.requests.length, 2);
+ nav.respond(1, { name: 'back' });
+ nav.respond(0, { name: 'clicked' });
+ await tick();
+ assert.equal(nav.content.innerHTML, 'back');
+ assert.deepEqual(nav.pushes, []);
+});
+
+for (const failure of ['network', 'HTTP', 'body']) {
+ test(`a stale ${failure} failure cannot redirect away from the latest navigation`, async () => {
+ const nav = navigation();
+ nav.pop('/docs/first');
+ nav.pop('/docs/latest');
+ assert.equal(nav.requests.length, 2);
+ nav.respond(1, { name: 'latest' });
+ await tick();
+ if (failure === 'network') nav.requests[0].reject(new Error('offline'));
+ else if (failure === 'body') nav.requests[0].resolve({
+ ok: true, headers: { get: () => 'text/html' }, text: async () => { throw new Error('body failed'); },
+ });
+ else nav.respond(0, {}, { ok: false });
+ await tick();
+ assert.deepEqual(nav.redirects, []);
+ assert.equal(nav.content.innerHTML, 'latest');
+ });
+}
+
+test('superseded stylesheet loads are removed without removing the current page styles', async () => {
+ const nav = navigation({ holdStyles: true });
+ nav.pop('/docs/first');
+ nav.respond(0, { name: 'first', styles: ['/first.css'] });
+ await tick();
+ nav.pop('/docs/latest');
+ assert.equal(nav.requests.length, 2);
+ nav.respond(1, { name: 'latest', styles: ['/latest.css'] });
+ await tick();
+ const latest = nav.links.find(link => link.href === '/latest.css');
+ latest.loaded();
+ await tick();
+ nav.links.find(link => link.href === '/first.css').loaded();
+ await tick();
+ assert.equal(nav.content.innerHTML, 'latest');
+ assert.deepEqual(nav.links.filter(link => !link.removed).map(link => link.href), ['/latest.css']);
+});
+
+test('pending page scripts finish before the next page replaces their DOM', async () => {
+ const nav = navigation({ holdScripts: true });
+ nav.pop('/docs/first');
+ nav.respond(0, { name: 'first', scripts: ['/first.js', '/obsolete.js'] });
+ await tick();
+ nav.pop('/docs/latest');
+ assert.equal(nav.requests.length, 2);
+ nav.respond(1, { name: 'latest' });
+ await tick();
+ assert.equal(nav.content.innerHTML, 'first');
+ nav.scripts[0].loaded();
+ await tick();
+ assert.equal(nav.content.innerHTML, 'latest');
+ assert.ok(!nav.scripts.some(script => script.src === '/obsolete.js'));
+});
+
+test('a finishing script cannot leave its query parameters on the selected history entry', async () => {
+ const nav = navigation({ holdScripts: true });
+ nav.pop('/resources/original/bg');
+ nav.respond(0, { name: 'resources', scripts: ['/resources.js'] });
+ await tick();
+ nav.pop('/docs/latest');
+ nav.respond(1, { name: 'latest' });
+ await tick();
+ // Resource filters use replaceState while their script initializes.
+ nav.replace('/docs/latest?time=night');
+ nav.scripts[0].loaded();
+ await tick();
+ assert.equal(nav.content.innerHTML, 'latest');
+ assert.equal(nav.location.href, 'https://example.test/docs/latest');
+});
+
+test('ordinary clicked navigation still pushes history and updates the page', async () => {
+ const nav = navigation();
+ assert.equal(nav.click('/docs/new'), true);
+ nav.respond(0, { name: 'new', scripts: ['/new.js'], styles: ['/new.css'] });
+ await tick();
+ assert.equal(nav.content.innerHTML, 'new');
+ assert.deepEqual(nav.pushes, ['https://example.test/docs/new']);
+ assert.equal(nav.scripts.length, 1);
+});
+
+test('a second clicked link supersedes the first without a stale history push', async () => {
+ const nav = navigation();
+ assert.equal(nav.click('/docs/first'), true);
+ assert.equal(nav.click('/docs/latest'), true);
+ nav.respond(1, { name: 'latest' });
+ await tick();
+ nav.respond(0, { name: 'first' });
+ await tick();
+ assert.equal(nav.content.innerHTML, 'latest');
+ assert.deepEqual(nav.pushes, ['https://example.test/docs/latest']);
+});
+
+test('an active navigation failure still falls back to the browser', async () => {
+ const nav = navigation();
+ nav.pop('/docs/unavailable');
+ nav.requests[0].reject(new Error('offline'));
+ await tick();
+ assert.deepEqual(nav.redirects, ['https://example.test/docs/unavailable']);
+});
+
+test('article handlers are cleaned up before replacing the page content', async () => {
+ const nav = navigation();
+ let oldContent;
+ nav.window.__esdocDocsCleanup = () => { oldContent = nav.content.innerHTML; };
+ nav.pop('/docs/new');
+ nav.respond(0, { name: 'new' });
+ await tick();
+ assert.equal(oldContent, 'initial');
+ assert.equal(nav.content.innerHTML, 'new');
+});
diff --git a/tests/player_storage.test.mjs b/tests/player_storage.test.mjs
new file mode 100644
index 0000000..2eea3b2
--- /dev/null
+++ b/tests/player_storage.test.mjs
@@ -0,0 +1,106 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import vm from 'node:vm';
+
+const load = name => readFileSync(new URL('../static/js/' + name, import.meta.url), 'utf8');
+
+class Element {
+ constructor() {
+ this.attrs = {}; this.dataset = {}; this.handlers = {}; this.children = new Map();
+ this.style = { setProperty() {} };
+ const classes = new Set();
+ this.classList = {
+ add: (...names) => names.forEach(name => classes.add(name)),
+ remove: (...names) => names.forEach(name => classes.delete(name)),
+ contains: name => classes.has(name),
+ };
+ }
+ addEventListener(name, fn) { (this.handlers[name] ||= []).push(fn); }
+ emit(name, event = {}) { (this.handlers[name] || []).forEach(fn => fn(event)); }
+ setAttribute(name, value) { this.attrs[name] = value; }
+ querySelector(selector) {
+ if (!this.children.has(selector)) this.children.set(selector, new Element());
+ return this.children.get(selector);
+ }
+ contains() { return false; }
+ matches() { return false; }
+}
+
+function storage(values = {}, fails) {
+ const items = new Map(Object.entries(values));
+ const check = operation => { if (fails === operation) throw new Error('Storage denied'); };
+ return {
+ getItem(key) { check('getItem'); return items.get(key) ?? null; },
+ setItem(key, value) { check('setItem'); items.set(key, value); },
+ removeItem(key) { check('removeItem'); items.delete(key); },
+ items,
+ };
+}
+
+function player(local, session, deniedGetter) {
+ const button = new Element();
+ button.hidden = true;
+ button.dataset = { playSrc: '/resource/audio/test.ogg', playName: 'Test track' };
+ let audio;
+ class Audio extends Element {
+ constructor() { super(); audio = this; this.paused = true; this.currentTime = 0; this.duration = 120; }
+ play() { this.paused = false; this.emit('play'); return Promise.resolve(); }
+ pause() { this.paused = true; this.emit('pause'); }
+ }
+ const bars = [], status = {}, window = new Element();
+ const document = {
+ getElementById: () => status,
+ createElement: () => new Element(),
+ querySelectorAll: selector => selector === '[data-play-src]' ? [button] : [],
+ body: { appendChild: item => bars.push(item) },
+ };
+ const context = vm.createContext({ window, document, Audio, localStorage: local, sessionStorage: session });
+ if (deniedGetter) Object.defineProperty(context, deniedGetter, {
+ get() { throw new Error('SecurityError: storage access denied'); },
+ });
+ vm.runInContext(load('icons.js'), context);
+ vm.runInContext(load('player-state.js'), context);
+ vm.runInContext(load('player.js'), context);
+ return { audio, button, bar: bars[0], window, status };
+}
+
+for (const target of ['localStorage', 'sessionStorage']) {
+ for (const failure of ['getter', 'getItem', 'setItem', 'removeItem']) {
+ test(`audio controls work when ${target} ${failure} is denied`, () => {
+ const local = storage({}, target === 'localStorage' ? failure : undefined);
+ const session = storage({}, target === 'sessionStorage' ? failure : undefined);
+ const ui = player(local, session, failure === 'getter' ? target : undefined);
+ assert.equal(ui.button.hidden, false);
+ ui.button.emit('click');
+ assert.equal(ui.audio.paused, false);
+ assert.equal(ui.button.attrs['aria-pressed'], 'true');
+ assert.equal(ui.bar.classList.contains('res-nowplaying--visible'), true);
+ const volume = ui.bar.querySelector('.res-volume input');
+ volume.value = '0.35';
+ volume.emit('input');
+ assert.equal(ui.audio.volume, 0.35);
+ assert.equal(volume.value, 0.35);
+ ui.bar.querySelector('.res-nowplaying-pause').emit('click');
+ assert.equal(ui.audio.paused, true);
+ ui.window.emit('pagehide', { persisted: false });
+ });
+ }
+}
+
+test('available storage still restores volume and track position and persists playback', () => {
+ const local = storage({ 'es-doc-volume': '0.25' });
+ const session = storage({ 'es-doc-player-v2': JSON.stringify({
+ src: '/resource/audio/test.ogg', name: 'Saved track', time: 15, playing: true, repeat: true,
+ }) });
+ const ui = player(local, session);
+ assert.equal(ui.audio.volume, 0.25);
+ assert.equal(ui.audio.paused, false);
+ assert.equal(ui.audio.loop, true);
+ ui.audio.emit('loadedmetadata');
+ assert.equal(ui.audio.currentTime, 15);
+ ui.audio.emit('timeupdate');
+ assert.equal(JSON.parse(session.items.get('es-doc-player-v2')).time, 15);
+ ui.window.emit('pagehide', { persisted: false });
+ assert.equal(session.items.has('es-doc-player-v2'), false);
+});
diff --git a/tests/rpa_browser.cjs b/tests/rpa_browser.cjs
new file mode 100644
index 0000000..3e6536b
--- /dev/null
+++ b/tests/rpa_browser.cjs
@@ -0,0 +1,274 @@
+/* Run with ES Doc on port 8012 and Playwright in NODE_PATH.
+ RPA_TEST_URL and PLAYWRIGHT_CHANNEL can override the defaults. */
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { chromium } = require('playwright');
+const root = path.resolve(__dirname, '..');
+const fixtures = path.join(root, 'temp/rpa-tree-browser/game');
+const target = process.env.RPA_TEST_URL || 'http://127.0.0.1:8012/tools/unpack?mode=pack';
+const resources = {
+ 'my_mod/images/bg.png': Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aWQAAAABJRU5ErkJggg==', 'base64'),
+ 'my_mod/audio/тема.ogg': Buffer.from([0, 255, 128, 65]),
+ 'my_mod/empty.txt': Buffer.alloc(0),
+ 'my_mod/script.rpy': Buffer.from('label my_mod_start:\n return\n'),
+};
+for (const [name, data] of Object.entries(resources)) {
+ const file = path.join(fixtures, name);
+ fs.mkdirSync(path.dirname(file), { recursive: true });
+ fs.writeFileSync(file, data);
+}
+
+(async () => {
+ const browser = await chromium.launch({ headless: true, channel: process.env.PLAYWRIGHT_CHANNEL || 'msedge' });
+ try {
+ const context = await browser.newContext({ viewport: { width: 1440, height: 1000 }, colorScheme: 'light' });
+ const page = await context.newPage();
+ const errors = [], requests = [];
+ page.on('pageerror', error => errors.push(error.message));
+ context.on('request', request => requests.push([request.method(), request.url()]));
+ await page.goto(target);
+ await page.locator('#tools-controls').waitFor({ state: 'visible' });
+ assert(!await page.locator('#tools-pack-settings').isVisible());
+ assert(!await page.locator('#tools-pack-integration').isVisible());
+ assert(await page.locator('#tools-mode-pack').isChecked());
+ await page.locator('#tools-folder').setInputFiles(fixtures);
+ await page.locator('#tools-export-start').waitFor({ state: 'visible' });
+ assert(await page.locator('#tools-pack-settings').isVisible());
+ assert(await page.locator('#tools-add').isVisible());
+ const missingDescriptions = await page.locator('#tools-app [aria-describedby]').evaluateAll(elements =>
+ elements.filter(element => element.getClientRects().length).flatMap(element =>
+ element.getAttribute('aria-describedby').split(/\s+/).filter(id => !document.getElementById(id))));
+ assert.deepEqual(missingDescriptions, []);
+ assert.equal(await page.locator('#tools-pack-strip').inputValue(), 'game/');
+ assert(await page.locator('#tools-browser').isVisible());
+ await page.locator('#tools-browser-list button').filter({hasText: 'my_mod/'}).click();
+ await page.locator('#tools-browser-list button').filter({hasText: 'images/'}).click();
+ await page.locator('#tools-browser-list button').filter({hasText: 'bg.png'}).click();
+ assert(await page.locator('#tools-browser-preview img').isVisible());
+ await page.locator('#tools-browser-search').fill('/');
+ const verifiedPaths = await page.locator('#tools-browser-list button[data-entry-id]').allTextContents();
+ await page.locator('#tools-pack-prefix').fill('../outside');
+ assert(await page.locator('#tools-export-start').isDisabled());
+ assert(await page.locator('#tools-pack-error').isVisible());
+ assert.match(await page.locator('#tools-pack-prefix-error').textContent(), /относительный путь.*my_mod/);
+ assert(await page.locator('#tools-pack-preview-note').isVisible());
+ assert.deepEqual(await page.locator('#tools-browser-list button[data-entry-id]').allTextContents(), verifiedPaths);
+ await page.locator('#tools-pack-prefix').fill('');
+ await page.locator('#tools-pack-name').fill('my_mod');
+ await page.locator('#tools-mode-unpack').check();
+ assert(!await page.locator('#tools-queue').isVisible());
+ await page.locator('#tools-mode-pack').check();
+ await page.locator('#tools-browser-search').fill('/');
+ assert.deepEqual(await page.locator('#tools-browser-list button[data-entry-id]').allTextContents(), verifiedPaths);
+ assert.equal(await page.locator('#tools-pack-name').inputValue(), 'my_mod');
+ await page.locator('#tools-browser-search').fill('bg.png');
+ assert.equal(await page.locator('#tools-browser-list button[data-entry-id]').count(), 1);
+
+ // Cancel lazy startup and retry from the same File objects.
+ await page.locator('#tools-export-start').click();
+ assert(await page.locator('#tools-export-dialog').isVisible());
+ assert(await page.locator('#tools-export-actions #tools-cancel').isVisible());
+ await page.keyboard.press('Escape');
+ assert(!await page.locator('#tools-export-dialog').isVisible());
+ assert.match(await page.locator('#tools-status').textContent(), /отменена/);
+ assert(await page.locator('#tools-queue').isVisible());
+ const download = page.waitForEvent('download', { timeout: 90000 });
+ await page.locator('#tools-export-start').click();
+ const saved = await download;
+ assert.equal(saved.suggestedFilename(), 'my_mod.rpa');
+ const archive = path.join(root, 'temp/rpa-browser/my_mod.rpa');
+ await saved.saveAs(archive);
+ assert.match(await page.locator('#tools-result-description').textContent(), /Файлов в RPA: 4/);
+ assert(await page.locator('#tools-pack-integration').isVisible());
+ assert.match(await page.locator('#tools-pack-install-archive').textContent(), /my_mod\.rpa$/);
+ assert(await page.locator('#tools-export-dialog').isVisible());
+ assert.match(await page.locator('#tools-export-status').textContent(), /Скачивание запущено/);
+ assert.equal(await page.locator('.tools-dialog-downloads :is(button, a):visible').count(), 1);
+ assert.equal(await page.locator('#tools-download-all').innerText(), 'Скачать');
+ assert(await page.locator('#tools-download-all .tools-icon-download').isVisible());
+ assert(await page.locator('#tools-export-info').isVisible());
+ const repeated = page.waitForEvent('download');
+ await page.locator('#tools-download-all').click();
+ assert.equal((await repeated).suggestedFilename(), 'my_mod.rpa');
+ const downloadReview = path.join(root, 'temp/tools-workflow-review');
+ fs.mkdirSync(downloadReview, { recursive: true });
+ for (const [name, width, theme] of [['download-desktop', 1440, 'light'], ['download-mobile', 390, 'light'],
+ ['download-desktop-dark', 1440, 'dark'], ['download-mobile-dark', 390, 'dark']]) {
+ await page.setViewportSize({ width, height: 1000 });
+ await page.evaluate(theme => document.documentElement.dataset.theme = theme, theme);
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+ await page.screenshot({ path: path.join(downloadReview, name + '.png') });
+ }
+ await page.setViewportSize({ width: 1440, height: 1000 });
+ await page.evaluate(() => document.documentElement.dataset.theme = 'light');
+ await page.keyboard.press('Escape');
+ assert(!await page.locator('#tools-export-dialog').isVisible());
+ assert(await page.locator('#tools-export-start').evaluate(el => el === document.activeElement));
+ await page.locator('#tools-export-start').click();
+ assert(await page.locator('#tools-export-dialog').isVisible());
+ await page.locator('#tools-export-close').click();
+ assert.equal(await page.locator('#tools-queue').isVisible(), true);
+ await page.locator('#tools-browser-search').fill('/');
+ assert.deepEqual(await page.locator('#tools-browser-list button[data-entry-id]').allTextContents(), verifiedPaths);
+ await page.locator('#tools-pack-prefix').fill('alternate');
+ assert(!await page.locator('#tools-pack-integration').isVisible());
+ assert.equal(await page.locator('#tools-browser-list button[data-entry-id]').first().textContent(), 'alternate/' + verifiedPaths[0]);
+ assert(await page.locator('#tools-export-start').isEnabled());
+ await page.locator('#tools-pack-prefix').fill('');
+ const python = path.join(root, '.venv/Scripts/python.exe');
+ execFileSync(python, ['-c', [
+ 'import pathlib, pickle, zlib, sys',
+ 'data = pathlib.Path(sys.argv[1]).read_bytes()',
+ 'assert data.startswith(b"RPA-3.0 ")',
+ 'offset, key = int(data[8:24], 16), int(data[25:33], 16)',
+ 'index = pickle.loads(zlib.decompress(data[offset:]))',
+ 'for name, records in index.items():',
+ ' content = b"".join(data[start ^ key:(start ^ key) + (length ^ key)] for start, length in records)',
+ ' assert content == (pathlib.Path(sys.argv[2]) / name).read_bytes(), name',
+ 'assert len(index) == 4',
+ ].join('\n'), archive, fixtures]);
+ await page.locator('#tools-browser-search').fill('script.rpy');
+ await page.locator('#tools-browser-list button[data-entry-id]').click();
+ await page.locator('#tools-browser-preview pre .k').first().waitFor({state: 'visible', timeout: 90000});
+ assert.match(await page.locator('#tools-browser-preview code').textContent(), /label my_mod_start/);
+ await page.locator('#tools-browser-search').fill('/');
+ assert(requests.every(([method]) => method === 'GET'), JSON.stringify(requests));
+ assert(!requests.some(([, url]) => /vendor\.zip|bytecode\.zip/.test(url)), 'Packing must not load decompilers');
+
+ // Open our output in the existing unpacker, including Unicode names.
+ await page.locator('#tools-mode-unpack').check();
+ assert(!await page.locator('#tools-options').isVisible());
+ await page.locator('#tools-files').setInputFiles(archive);
+ await page.locator('#tools-browser-list button').first().waitFor({ state: 'visible', timeout: 90000 });
+ assert(await page.locator('#tools-options').isVisible());
+ assert.equal(await page.locator('#tools-add-label').textContent(), 'Добавить ещё');
+ await page.locator('#tools-mode-pack').check();
+ await page.locator('#tools-browser-search').fill('/');
+ assert.deepEqual(await page.locator('#tools-browser-list button[data-entry-id]').allTextContents(), verifiedPaths);
+ await page.locator('#tools-mode-unpack').check();
+ await page.locator('#tools-browser-list button').first().waitFor({ state: 'visible', timeout: 90000 });
+ await page.locator('#tools-browser-search').fill('тема');
+ assert.match(await page.locator('#tools-browser-list').textContent(), /тема.ogg/);
+ const extracted = page.waitForEvent('download', { timeout: 90000 });
+ await page.locator('#tools-export-start').click();
+ const zip = await extracted;
+ assert.equal(zip.suggestedFilename(), 'my_mod.zip');
+ const zipPath = path.join(root, 'temp/rpa-browser/my_mod.zip');
+ await zip.saveAs(zipPath);
+ assert(await page.locator('#tools-export-dialog').isVisible());
+ assert.equal(await page.locator('#tools-export-title').textContent(), 'Готово');
+ for (const [name, width, theme] of [['unpack-dialog-desktop', 1440, 'light'], ['unpack-dialog-mobile', 390, 'light'],
+ ['unpack-dialog-desktop-dark', 1440, 'dark'], ['unpack-dialog-mobile-dark', 390, 'dark']]) {
+ await page.setViewportSize({ width, height: 1000 });
+ await page.evaluate(theme => document.documentElement.dataset.theme = theme, theme);
+ await page.screenshot({ path: path.join(downloadReview, name + '.png') });
+ }
+ await page.setViewportSize({ width: 1440, height: 1000 });
+ await page.evaluate(() => document.documentElement.dataset.theme = 'light');
+ await page.locator('#tools-export-close').click();
+ assert(!await page.locator('#tools-options').isVisible());
+ assert.equal(await page.locator('#tools-add-label').textContent(), 'Добавить файлы или папку');
+ execFileSync(python, ['-c', [
+ 'import pathlib, zipfile, sys',
+ 'with zipfile.ZipFile(sys.argv[1]) as archive:',
+ ' for name in archive.namelist():',
+ ' assert archive.read(name) == (pathlib.Path(sys.argv[2]) / name).read_bytes(), name',
+ ' assert len(archive.namelist()) == 4',
+ ].join('\n'), zipPath, fixtures]);
+ assert.deepEqual(errors, []);
+
+ // Multiple outputs and failed exports stay in the same dialog.
+ await page.locator('#tools-files').setInputFiles(['first.rpa', 'second.rpa'].map(name => ({
+ name, mimeType: 'application/octet-stream', buffer: fs.readFileSync(archive),
+ })));
+ await page.locator('#tools-export-start').click();
+ await page.waitForFunction(() => document.querySelector('#tools-export-title').textContent === 'Готово'
+ && document.querySelectorAll('#tools-downloads a').length === 2);
+ assert(!await page.locator('#tools-download-all').isVisible());
+ assert.deepEqual(await page.locator('#tools-downloads a').evaluateAll(links => links.map(link => link.download)), ['first.zip', 'second.zip']);
+ assert.equal(await page.locator('#tools-downloads a:visible').count(), 2);
+ await page.locator('#tools-export-close').click();
+ await page.locator('#tools-files').setInputFiles({ name: 'bad.rpyc', mimeType: 'application/octet-stream', buffer: Buffer.from('invalid') });
+ await page.locator('#tools-export-start').click();
+ await page.waitForFunction(() => document.querySelector('#tools-export-title').textContent === 'Не удалось обработать файлы');
+ assert(await page.locator('#tools-export-errors').isVisible());
+ assert.equal(await page.locator('#tools-download-all').innerText(), 'Повторить обработку');
+ assert(await page.locator('#tools-download-all').isEnabled());
+ await page.locator('#tools-export-close').click();
+
+ // Remove a folder by keyboard, including its descendants, then the remaining root.
+ await page.locator('#tools-mode-pack').check();
+ await page.locator('#tools-clear').click();
+ await page.locator('#tools-folder').setInputFiles(fixtures);
+ await page.locator('#tools-browser-search').fill('');
+ await page.locator('#tools-browser-list button').filter({hasText: 'my_mod/'}).click();
+ const removeImages = page.getByRole('button', { name: 'Убрать папку my_mod/images/ и все вложенные файлы', exact: true });
+ await removeImages.focus();
+ await page.keyboard.press('Enter');
+ assert.match(await page.locator('#tools-count').textContent(), /3 файла/);
+ assert.equal(await page.locator('#tools-browser-list button').filter({hasText: 'images/'}).count(), 0);
+ assert.equal(await page.locator('#tools-browser-list button').filter({hasText: 'audio/'}).count(), 1);
+ assert(await page.locator('#tools-browser-list .tools-remove-source').nth(1).evaluate(el => el === document.activeElement));
+ await page.locator('#tools-browser-crumbs button').filter({hasText: 'Все файлы'}).click();
+ await page.getByRole('button', { name: 'Убрать папку my_mod/ и все вложенные файлы', exact: true }).focus();
+ await page.keyboard.press('Enter');
+ assert(!await page.locator('#tools-browser').isVisible());
+ assert(!await page.locator('#tools-pack-settings').isVisible());
+ assert.equal(await page.locator('#tools-add-label').textContent(), 'Добавить файлы или папку');
+ assert(await page.locator('#tools-add').evaluate(el => el === document.activeElement));
+ assert(!await page.locator('#tools-export-start').isVisible());
+
+ // Reach a file beyond the former 200-row limit, then remove it by keyboard.
+ await page.locator('#tools-files').setInputFiles(Array.from({ length: 251 }, (_, i) => ({
+ name: `item-${String(i).padStart(3, '0')}.bin`, mimeType: 'application/octet-stream', buffer: Buffer.from([i % 256]),
+ })));
+ assert.equal(await page.locator('#tools-browser-list button[data-entry-id]').count(), 100);
+ await page.locator('#tools-queue-next').click();
+ await page.locator('#tools-queue-next').click();
+ assert.equal(await page.locator('#tools-browser-list button[data-entry-id]').count(), 51);
+ assert.match(await page.locator('#tools-queue-range').textContent(), /201–251 из 251/);
+ await page.locator('#tools-browser-search').fill('item-250');
+ await page.locator('#tools-browser-list .tools-remove-source').focus();
+ await page.keyboard.press('Enter');
+ assert(await page.locator('#tools-add').evaluate(el => el === document.activeElement));
+ await page.locator('#tools-browser-search').fill('');
+ await page.locator('#tools-browser-list .tools-remove-source').first().focus();
+ await page.keyboard.press('Enter');
+ assert(await page.locator('#tools-browser-list .tools-remove-source').first().evaluate(el => el === document.activeElement));
+ await page.locator('#tools-clear').click();
+ await page.locator('#tools-files').setInputFiles({ name: 'last.txt', mimeType: 'text/plain', buffer: Buffer.from('last') });
+ await page.locator('#tools-browser-list .tools-remove-source').focus();
+ await page.keyboard.press('Enter');
+ assert(await page.locator('#tools-add').evaluate(el => el === document.activeElement));
+
+ // One visual inspection round, desktop and mobile / light and dark.
+ const review = path.join(root, 'temp/tools-workflow-review');
+ fs.mkdirSync(review, { recursive: true });
+ for (const [name, width, theme] of [['desktop', 1440, 'light'], ['mobile', 390, 'light'],
+ ['desktop-dark', 1440, 'dark'], ['mobile-dark', 390, 'dark']]) {
+ await page.setViewportSize({ width, height: 1000 });
+ await page.goto(target);
+ await page.evaluate(theme => document.documentElement.dataset.theme = theme, theme);
+ await page.locator('#tools-folder').setInputFiles(fixtures);
+ await page.locator('#tools-export-start').waitFor({ state: 'visible' });
+ await page.evaluate(() => document.fonts.ready);
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth), name + ' overflow');
+ const contrasts = await page.locator('#tools-pack-settings input, #tools-pack-settings select, #tools-queue-search').evaluateAll(fields => {
+ const rgb = color => color.match(/[\d.]+/g).slice(0, 3).map(Number);
+ const luminance = color => rgb(color).map(v => {
+ v /= 255; return v <= .04045 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4;
+ }).reduce((total, v, i) => total + v * [.2126, .7152, .0722][i], 0);
+ return fields.map(field => {
+ const style = getComputedStyle(field);
+ const a = luminance(style.borderTopColor), b = luminance(style.backgroundColor);
+ return { id: field.id, ratio: (Math.max(a, b) + .05) / (Math.min(a, b) + .05) };
+ });
+ });
+ assert(contrasts.every(({ ratio }) => ratio >= 3), JSON.stringify({ name, contrasts }));
+ await page.screenshot({ path: path.join(review, name + '.png'), fullPage: true });
+ }
+ console.log('Browser RPA creation, cancellation, extraction, byte comparison, local GET-only processing and responsive checks passed.');
+ } finally { await browser.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/tests/search_results.test.mjs b/tests/search_results.test.mjs
index 0e50588..f825dbc 100644
--- a/tests/search_results.test.mjs
+++ b/tests/search_results.test.mjs
@@ -5,7 +5,7 @@ import vm from 'node:vm';
const script = readFileSync(new URL('../static/js/search.js', import.meta.url), 'utf8');
-async function searchBox(rows) {
+async function searchBox(rows, fetchRows = async () => rows) {
const handlers = {};
const attrs = {};
const input = {
@@ -28,18 +28,71 @@ async function searchBox(rows) {
vm.runInNewContext(script, {
document: {
getElementById: id => ({ 'site-search': form, 'site-search-input': input, 'site-search-results': list })[id],
- querySelector: () => null, addEventListener: () => {},
- body: { classList: { add: () => {} } },
+ querySelector: () => null,
+ addEventListener: (event, handler) => { handlers['document-' + event] = handler; },
+ body: { classList: { add: () => {}, remove: () => {}, contains: () => false } },
},
- window, fetch: async () => ({ ok: true, json: async () => rows }),
+ window, fetch: async () => ({ ok: true, json: fetchRows }),
setTimeout: fn => { update = fn; }, clearTimeout: () => {},
});
handlers.input();
update();
await new Promise(resolve => setImmediate(resolve));
- return { handlers, input, list, status, window, attrs };
+ return { handlers, input, list, status, window, attrs, flush: () => update() };
}
+for (const dismiss of ['clear', 'Escape', 'outside click']) {
+ for (const fails of [false, true]) {
+ test(`pending search ${fails ? 'failure' : 'results'} stays dismissed after ${dismiss}`, async () => {
+ let resolve, reject;
+ const pending = new Promise((yes, no) => { resolve = yes; reject = no; });
+ const box = await searchBox([], () => pending);
+ if (dismiss === 'clear') {
+ box.input.value = '';
+ box.handlers.input();
+ box.flush();
+ } else if (dismiss === 'Escape') {
+ box.handlers.keydown({ key: 'Escape', preventDefault: () => {} });
+ } else {
+ box.handlers['document-click']({ target: {} });
+ }
+ if (fails) reject(new Error('offline'));
+ else resolve([{ label: 'Луна', url: '/stale' }]);
+ await new Promise(done => setImmediate(done));
+ assert.equal(box.list.hidden, true);
+ assert.equal(box.attrs['aria-expanded'], 'false');
+ assert.equal(box.status.textContent || '', '');
+ });
+ }
+}
+
+test('typing another query invalidates results before its debounce fires', async () => {
+ let resolve;
+ const pending = new Promise(done => { resolve = done; });
+ const box = await searchBox([], () => pending);
+ box.input.value = 'Ночь';
+ box.handlers.input();
+ resolve([{ label: 'Луна', url: '/stale' }]);
+ await new Promise(done => setImmediate(done));
+ assert.equal(box.list.hidden, true);
+ assert.ok(!box.list.innerHTML.includes('Луна'));
+});
+
+test('an older response cannot replace results from the latest query', async () => {
+ let resolveOld;
+ const old = new Promise(done => { resolveOld = done; });
+ let calls = 0;
+ const box = await searchBox([], () => ++calls === 1 ? old : [{ label: 'Ночь', url: '/latest' }]);
+ box.input.value = 'Ночь';
+ box.handlers.input();
+ box.flush();
+ await new Promise(done => setImmediate(done));
+ resolveOld([{ label: 'Луна', url: '/stale' }]);
+ await new Promise(done => setImmediate(done));
+ box.handlers.keydown({ key: 'Enter', preventDefault: () => {} });
+ assert.equal(box.window.location.href, '/latest');
+});
+
test('mixed global results have distinct groups and retain ranking within each group', async () => {
const box = await searchBox([
{ kind: 'file', label: 'Луна.rpy', url: '/resources/browser/Луна.rpy' },
diff --git a/tests/test_image_cache.py b/tests/test_image_cache.py
new file mode 100644
index 0000000..bb695ce
--- /dev/null
+++ b/tests/test_image_cache.py
@@ -0,0 +1,90 @@
+import asyncio
+import os
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from unittest.mock import patch
+
+from PIL import Image
+
+from app.routes.res import _ensure_tinted
+from app.utils.config import CONFIG
+from app.utils.lifespan.sprites_cache import compose_sprite, is_composed, sprites_path
+from app.utils.lifespan.tint_cache import compose_tint, is_tinted
+
+
+class ImageCacheTests(unittest.TestCase):
+ def setUp(self):
+ directory = TemporaryDirectory()
+ self.addCleanup(directory.cleanup)
+ self.root = Path(directory.name)
+ self.game = self.root / 'game'
+ self.game.mkdir()
+ declarations = self.game / 'sprites.rpy'
+ declarations.write_text('', encoding='utf-8')
+ os.utime(declarations, (100, 100))
+ for change in (patch.object(CONFIG, 'res_path', self.game),
+ patch.object(CONFIG, 'cache_path', self.root / 'cache'),
+ patch.object(CONFIG, 'sprite_layers', {'fixture': ['layer.png']}),
+ patch.object(CONFIG, 'resources', {})):
+ change.start()
+ self.addCleanup(change.stop)
+ sprites_path().mkdir(parents=True)
+
+ def image(self, name, color, timestamp=100):
+ path = self.game / name
+ Image.new('RGBA', (2, 2), color).save(path)
+ os.utime(path, (timestamp, timestamp))
+ return path
+
+ def test_recomposes_sprite_after_layer_replacement(self):
+ self.image('layer.png', 'red')
+ output = compose_sprite('fixture')
+ os.utime(output, (200, 200))
+ self.assertTrue(is_composed('fixture'))
+ self.image('layer.png', 'lime', timestamp=300)
+ self.assertFalse(is_composed('fixture'))
+ compose_sprite('fixture')
+ with Image.open(output) as image:
+ red, green, _ = image.convert('RGB').getpixel((0, 0))
+ self.assertGreater(green, 200)
+ self.assertLess(red, 20)
+
+ def test_tint_refreshes_when_factors_change_without_source_edits(self):
+ source = self.image('source.png', 'white')
+ output = compose_tint('bg', 'fixture', source, (1, 0, 0))
+ os.utime(output, (200, 200))
+ CONFIG.resources = {'original': {'bg': [{'name': 'fixture', 'file': 'source.png', 'tint': (0, 1, 0)}]}}
+ asyncio.run(_ensure_tinted('bg', 'fixture'))
+ with Image.open(output) as image:
+ red, green, _ = image.convert('RGB').getpixel((0, 0))
+ self.assertGreater(green, 200)
+ self.assertLess(red, 20)
+
+ def test_tint_refreshes_when_source_identity_changes_to_an_older_file(self):
+ first = self.image('first.png', 'red')
+ self.image('second.png', 'lime', timestamp=50)
+ output = compose_tint('bg', 'fixture', first, (1, 1, 1))
+ os.utime(output, (200, 200))
+ CONFIG.resources = {'original': {'bg': [{'name': 'fixture', 'file': 'second.png', 'tint': (1, 1, 1)}]}}
+ asyncio.run(_ensure_tinted('bg', 'fixture'))
+ with Image.open(output) as image:
+ red, green, _ = image.convert('RGB').getpixel((0, 0))
+ self.assertGreater(green, 200)
+ self.assertLess(red, 20)
+
+ def test_tint_cache_reuses_matching_inputs_and_rebuilds_legacy_metadata(self):
+ source = self.image('source.png', 'white')
+ tint = (1, 0, 0)
+ output = compose_tint('bg', 'fixture', source, tint)
+ self.assertTrue(is_tinted('bg', 'fixture', source, tint))
+ output.with_suffix('.json').unlink()
+ self.assertFalse(is_tinted('bg', 'fixture', source, tint))
+ compose_tint('bg', 'fixture', source, tint)
+ self.assertTrue(is_tinted('bg', 'fixture', source, tint))
+
+ def test_cached_sprite_is_invalid_when_a_layer_is_removed(self):
+ layer = self.image('layer.png', 'red')
+ compose_sprite('fixture')
+ layer.unlink()
+ self.assertFalse(is_composed('fixture'))
diff --git a/tests/test_md_containers.py b/tests/test_md_containers.py
new file mode 100644
index 0000000..2a9bd6d
--- /dev/null
+++ b/tests/test_md_containers.py
@@ -0,0 +1,43 @@
+import re
+import unittest
+from html import unescape
+from unittest.mock import patch
+
+from app.utils.config import CONFIG
+from app.utils.md import render
+
+
+class ContainerFenceTests(unittest.TestCase):
+ def test_standalone_banner_does_not_steal_the_outer_closer(self):
+ with patch.object(CONFIG, 'config', {}):
+ for marker in (':::stub', ':::stub A short note'):
+ with self.subTest(marker=marker):
+ html = render(f':::details Example\n{marker}\n\nINSIDE\n:::\n\nOUTSIDE\n')[2]
+ self.assertIn('
'))
+ self.assertGreater(html.index('OUTSIDE'), html.index(' '))
+
+ def test_paired_banner_keeps_its_own_closer(self):
+ with patch.object(CONFIG, 'config', {}):
+ html = render(':::details Example\n:::stub\nA note\n:::\n\nINSIDE\n:::\n\nOUTSIDE\n')[2]
+ self.assertIn('
'))
+ self.assertLess(html.index(''), html.index('INSIDE'))
+ self.assertLess(html.index('INSIDE'), html.index(' '))
+
+ def test_fenced_marker_examples_do_not_close_or_open_containers(self):
+ for fence in ('```', '~~~~'):
+ for marker in (':::', ':::info', ':::details Literal'):
+ with self.subTest(fence=fence, marker=marker):
+ source = f':::details Example\n{fence}text\n{marker}\n{fence}\n\nINSIDE\n:::\n\nOUTSIDE\n'
+ html = render(source)[2]
+ self.assertIn('
]*>', '', html)))
+ self.assertLess(html.index('INSIDE'), html.index(' '))
+ self.assertGreater(html.index('OUTSIDE'), html.index(''))
+
+ def test_short_fence_does_not_end_long_fenced_example(self):
+ html = render(':::info\n````text\n```\n:::\n````\n\nINSIDE\n:::\n')[2]
+ self.assertLess(html.index('INSIDE'), html.index('
