Vito Sansevero
316f8673b3
The review gains a first row, LoraManager ("<source> settings · <mode>
storage · library <name>", the settings file as its hover title), and its
Found row counts metadata files, LoRAs and LoRAs with local images. A plan
whose LoraManager settings cannot be used takes the close-only path:
"LoraManager settings: not usable: <reason>. Nothing was changed." The
browser fixture writes each LoRA's model file and can leave out the local
preview, so the download, gate and cancel specs still exercise CivitAI.
225 lines
16 KiB
JavaScript
225 lines
16 KiB
JavaScript
// System › Integrations (#249 System S10 Task 27): the host values and saves behind the LoRA rows (D114), the D106
|
||
// renderer and detection lines, and the D107 import review built from the server's plan.
|
||
const test = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
|
||
const integrations = import('../../web/js/workspace/system-integrations.mjs');
|
||
const kinds = import('../../web/js/workspace/activity-kinds.mjs');
|
||
|
||
const CONCEPT = fs.readFileSync(path.join(__dirname, '../../docs/concepts/workspace/app.js'), 'utf8');
|
||
const SOURCE = fs.readFileSync(path.join(__dirname, '../../web/js/workspace/system-integrations.mjs'), 'utf8');
|
||
|
||
test('the section keeps the concept rows, labels and options in order', () => {
|
||
const start = CONCEPT.indexOf('case "integrations":');
|
||
const body = CONCEPT.slice(start, CONCEPT.indexOf('break;', start));
|
||
const rows = [...body.matchAll(/setting\("([^"]+)", "([^"]+)", "([^"]+)"/g)].map(([, id, label]) => [id, label]);
|
||
assert.deepEqual(rows.map(([id]) => id), ['send-destination', 'renderer', 'return-canvas', 'lora-enable', 'lora-triggers',
|
||
'civitai-key']);
|
||
for (const [id, label] of rows) {
|
||
assert.ok(SOURCE.includes(`id: '${id}', label: '${label}'`), `${id} keeps the concept label "${label}"`);
|
||
}
|
||
for (const option of ['Ask each time', 'Selected Prompt Manager node', 'Create a Prompt Manager (+/-) node',
|
||
'Follow host renderer', 'Classic', 'Nodes 2.0']) assert.ok(body.includes(option) && SOURCE.includes(`'${option}'`), option);
|
||
for (const surface of ['ComfyUI', 'LoRA & resources']) assert.ok(SOURCE.includes(`'h2', '${surface}'`), surface);
|
||
assert.ok(body.includes('"LoRA reference data", "Review and import resource metadata."'));
|
||
// Prototype copy is never shipped (Global constraints): the sample detection line and the mock warning.
|
||
assert.ok(!SOURCE.includes('Sample detection'));
|
||
assert.ok(!SOURCE.includes('Do not enter a real key'));
|
||
assert.ok(!SOURCE.includes('Simulate import'));
|
||
});
|
||
|
||
test('LoRA status becomes host values: drafted flags and read-only facts kept apart', async () => {
|
||
const { loraValues } = await integrations;
|
||
assert.deepEqual(loraValues({ enabled: true, trigger_words_enabled: false, path: 'custom_nodes/ComfyUI-Lora-Manager',
|
||
has_civitai_api_key: true, detected: true, detected_path: 'custom_nodes/ComfyUI-Lora-Manager', trigger_cache_loaded: true }), {
|
||
lora_enabled: true, lora_trigger_words_enabled: false, clear_civitai_api_key: false,
|
||
lora_path: 'custom_nodes/ComfyUI-Lora-Manager', lora_detected: true, lora_detected_path: 'custom_nodes/ComfyUI-Lora-Manager',
|
||
lora_detected_usable: true, lora_has_key: true, lora_cache_loaded: true,
|
||
});
|
||
const empty = loraValues({});
|
||
assert.equal(empty.lora_enabled, false);
|
||
assert.equal(empty.lora_path, '');
|
||
assert.equal(empty.lora_has_key, false);
|
||
// The key itself is never part of what the page holds from the server.
|
||
assert.ok(!Object.keys(loraValues({ civitai_api_key: 'secret' })).includes('civitai_api_key'));
|
||
});
|
||
|
||
test('host changes split between /lora/enable and /settings', async () => {
|
||
const { splitHostChanges } = await integrations;
|
||
assert.deepEqual(splitHostChanges({ lora_enabled: true, result_timeout: 5 }),
|
||
{ lora: { lora_enabled: true }, settings: { result_timeout: 5 } });
|
||
assert.deepEqual(splitHostChanges({ result_timeout: 5 }), { lora: null, settings: { result_timeout: 5 } });
|
||
assert.deepEqual(splitHostChanges({ civitai_api_key: 'k', clear_civitai_api_key: false }),
|
||
{ lora: { civitai_api_key: 'k', clear_civitai_api_key: false }, settings: null });
|
||
assert.deepEqual(splitHostChanges(undefined), { lora: null, settings: null });
|
||
});
|
||
|
||
test('key never prefilled; blank keeps; Clear saved key clears; saved through Save preferences (D114)', async () => {
|
||
const { loraPayload, keyText, KEY_COPY } = await integrations;
|
||
const saved = { lora_enabled: true, lora_trigger_words_enabled: false, lora_path: 'custom_nodes/LM', lora_has_key: true };
|
||
// The whole LoRA state goes with every save; the saved path is kept; no key unless one was typed.
|
||
assert.deepEqual(loraPayload({ lora_trigger_words_enabled: true }, saved),
|
||
{ enabled: true, trigger_words_enabled: true, path: 'custom_nodes/LM' });
|
||
assert.deepEqual(loraPayload({ civitai_api_key: ' ' }, saved), { enabled: true, trigger_words_enabled: false, path: 'custom_nodes/LM' });
|
||
assert.deepEqual(loraPayload({ civitai_api_key: ' new-key ' }, saved),
|
||
{ enabled: true, trigger_words_enabled: false, path: 'custom_nodes/LM', civitai_api_key: 'new-key' });
|
||
assert.deepEqual(loraPayload({ clear_civitai_api_key: true, civitai_api_key: 'ignored' }, saved),
|
||
{ enabled: true, trigger_words_enabled: false, path: 'custom_nodes/LM', clear_civitai_api_key: true });
|
||
assert.deepEqual(loraPayload({ lora_enabled: true }, {}), { enabled: true, trigger_words_enabled: false, path: '' });
|
||
assert.equal(keyText({ lora_has_key: true }, {}), KEY_COPY.saved);
|
||
assert.equal(keyText({ lora_has_key: false }, {}), KEY_COPY.none);
|
||
assert.equal(keyText({ lora_has_key: true }, { clear_civitai_api_key: true }), KEY_COPY.clearing);
|
||
assert.equal(keyText({ lora_has_key: false }, { civitai_api_key: 'k' }), KEY_COPY.replacing);
|
||
assert.equal(keyText({}, {}), null);
|
||
assert.deepEqual(KEY_COPY, { saved: 'A key is saved.', none: 'No key saved.', clearing: 'The saved key is removed when you save.',
|
||
replacing: 'The new key replaces the saved one when you save.' });
|
||
});
|
||
|
||
test('LoRA rows show detected / enabled / cache-loaded separately', async () => {
|
||
const { detectionText, cacheText } = await integrations;
|
||
assert.equal(detectionText({ lora_detected: true, lora_detected_path: 'custom_nodes/ComfyUI-Lora-Manager' }),
|
||
'Detected: custom_nodes/ComfyUI-Lora-Manager.');
|
||
assert.equal(detectionText({ lora_detected: true, lora_detected_path: '' }), 'Detected.');
|
||
assert.equal(detectionText({ lora_detected: false }), 'Not detected in ComfyUI’s custom_nodes folders.');
|
||
assert.equal(detectionText({}), null);
|
||
// S10 review N5: a linked install outside custom_nodes is found but can't be enabled.
|
||
assert.equal(detectionText({ lora_detected: true, lora_detected_path: 'LoRA-Manager', lora_detected_usable: false }),
|
||
'Found at LoRA-Manager, but outside ComfyUI’s custom_nodes folders, so it can’t be enabled.');
|
||
assert.equal((await integrations).loraValues({ detected: true, detected_usable: false }).lora_detected_usable, false);
|
||
assert.equal(cacheText({ lora_cache_loaded: true }), 'Trigger words are loaded.');
|
||
assert.equal(cacheText({ lora_cache_loaded: false }), 'Trigger words are not loaded.');
|
||
assert.equal(cacheText({}), null);
|
||
});
|
||
|
||
test('host compatibility shows the detected renderer as status (D106)', async () => {
|
||
const { rendererText, RENDERER_COPY } = await integrations;
|
||
const host = (...renderers) => ({ hostId: 'h', label: 'PromptManager — ComfyUI', targets: renderers.map((renderer, id) =>
|
||
({ id: String(id), roles: ['positive'], renderer })) });
|
||
assert.equal(rendererText([]), RENDERER_COPY.none);
|
||
assert.equal(rendererText(null), RENDERER_COPY.none);
|
||
assert.equal(rendererText([host()]), RENDERER_COPY.noNodes);
|
||
assert.equal(rendererText([host('vue')]), RENDERER_COPY.noNodes);
|
||
assert.equal(rendererText([host('classic')]), 'Detected: Classic (1 ComfyUI window).');
|
||
assert.equal(rendererText([host('nodes2', 'nodes2')]), 'Detected: Nodes 2.0 (1 ComfyUI window).');
|
||
assert.equal(rendererText([host('nodes2'), host('classic')]), 'Detected: Classic and Nodes 2.0 (2 ComfyUI windows).');
|
||
});
|
||
|
||
test('the import review shows replacement, blocked items and network effects (D107)', async () => {
|
||
const { importGrid } = await integrations;
|
||
const plan = { lora_files: 2221, with_metadata: 615, with_local_media: 476, skipped: 1606, current_imports: 5,
|
||
blocked_by_pairs: 0, planned_downloads: 4,
|
||
layout: { source: 'portable', settings_file: '~/ComfyUI/custom_nodes/LM/settings.json', error: null, mode: 'centralized',
|
||
library: 'comfyui', example_images: true },
|
||
scope: { count: 2, label: 'Replace 5 imported prompts with 2 LoRAs' }, protected: { count: 0, reasons: [] },
|
||
backup: { policy: 'on', destination_label: 'prompts.db.backup_<date and time>' }, network: { planned_downloads: 4, api_key: true },
|
||
media: { deletes_files: false, label: 'No files are removed; image links are replaced' } };
|
||
assert.deepEqual(importGrid(plan), [
|
||
['LoraManager', 'portable settings · centralized storage · library comfyui'],
|
||
['Scope', 'Replace 5 imported prompts with 2 LoRAs'],
|
||
['Found', '2,221 metadata files · 615 LoRAs · 476 with local images'],
|
||
['Protected', 'Nothing is protected'],
|
||
['Network', 'Downloads up to 4 example images from CivitAI with your saved key'],
|
||
['Backup', 'Create and verify before changes (prompts.db.backup_<date and time>)'],
|
||
['Media on disk', 'No files are removed; image links are replaced'],
|
||
]);
|
||
const blocked = importGrid({ ...plan, planned_downloads: 1, network: { api_key: false }, protected: { count: 2,
|
||
reasons: ['2 imported prompts used by saved pairs'] } });
|
||
assert.deepEqual(blocked[3], ['Protected', '2 imported prompts used by saved pairs']);
|
||
assert.deepEqual(blocked[4], ['Network', 'Downloads up to 1 example image from CivitAI']);
|
||
// A plan without a layout (no LoraManager row) and with no counts.
|
||
assert.deepEqual(importGrid({})[0], ['Scope', '0 LoRAs']);
|
||
assert.deepEqual(importGrid({})[1], ['Found', '0 metadata files · 0 LoRAs · 0 with local images']);
|
||
assert.deepEqual(importGrid({})[3], ['Network', 'No downloads']);
|
||
assert.deepEqual(importGrid({})[5], ['Media on disk', 'No files are removed']);
|
||
assert.deepEqual(importGrid({ ...plan, lora_files: 1, with_metadata: 1, with_local_media: 0 })[2],
|
||
['Found', '1 metadata file · 1 LoRA · 0 with local images']);
|
||
});
|
||
|
||
test('the LoraManager row names what the import read, and an unusable layout closes the review (#355)', async () => {
|
||
const { layoutText, closeNote, LAYOUT_UNUSABLE, BLOCKED_NOTE, NOTHING_TO_IMPORT } = await integrations;
|
||
assert.equal(layoutText({ source: 'environment', mode: 'alongside', library: 'default', error: null }),
|
||
'environment settings · alongside storage · library default');
|
||
assert.equal(layoutText({ source: 'user config', mode: 'alongside', library: 'x', error: 'the settings file is not valid JSON' }),
|
||
'Not usable: the settings file is not valid JSON');
|
||
assert.equal(layoutText(null), null);
|
||
assert.equal(layoutText('nope'), null);
|
||
const error = 'the sidecar folder does not exist';
|
||
assert.equal(closeNote({ token: null, layout: { error } }),
|
||
'LoraManager settings: not usable: the sidecar folder does not exist. Nothing was changed.');
|
||
assert.equal(LAYOUT_UNUSABLE(error), closeNote({ token: null, layout: { error }, blocked_by_pairs: 2 }));
|
||
assert.equal(closeNote({ token: null, blocked_by_pairs: 1, layout: { error: null } }), BLOCKED_NOTE);
|
||
assert.equal(closeNote({ token: null }), NOTHING_TO_IMPORT);
|
||
assert.equal(closeNote({ token: 't', with_metadata: 0, current_imports: 0 }), NOTHING_TO_IMPORT);
|
||
assert.equal(closeNote({ token: 't', with_metadata: 1, current_imports: 0 }), null);
|
||
assert.equal(closeNote({ token: 't', with_metadata: 0, current_imports: 3 }), null);
|
||
});
|
||
|
||
test('a LoRA import job reads in Activity: tiles, outcomes and the kept collection on failure', async () => {
|
||
const { kindOf, finishToast, outcomeLine, viewOf } = await kinds;
|
||
const view = kindOf('lora_import');
|
||
assert.equal(view.pillVerb, 'Importing LoRAs');
|
||
assert.deepEqual(view.tiles.map(([group]) => group), ['imported', 'linked', 'skipped', 'downloaded', 'download_errors', 'errors']);
|
||
const counters = { imported: 3, linked: 1, skipped: 0, downloaded: 2, download_errors: 0, errors: 0 };
|
||
const job = { kind: 'lora_import', title: 'LoRA reference import', state: 'finished', cancellable: false, counters };
|
||
assert.equal(outcomeLine(job), '3 imported · 0 errors');
|
||
assert.equal(finishToast(job), 'LoRA import finished · 3 imported · 0 errors');
|
||
assert.equal(finishToast({ ...job, state: 'cancelled' }), 'LoRA import cancelled · 3 imported');
|
||
const failed = { ...job, state: 'failed', status_line: 'The import failed; the previous LoRA imports were kept.' };
|
||
assert.equal(finishToast(failed), 'LoRA import failed · The import failed; the previous LoRA imports were kept.');
|
||
assert.equal(finishToast({ ...failed, status_line: '' }), 'LoRA import failed · 3 imported · 0 errors');
|
||
assert.equal(viewOf(job).tiles.length, 6);
|
||
// The legacy page's held import (no counters) reads as the generic job.
|
||
assert.equal(viewOf({ kind: 'lora_import', title: 'LoRA import (admin page)', cancellable: false, counters: {} }).tiles.length, 0);
|
||
});
|
||
|
||
test('a failed import the files or saved pairs overtook is reviewed again in Integrations', async () => {
|
||
const { reviewAgainOf } = await import('../../web/js/workspace/activity-job-view.mjs');
|
||
const failed = failure => ({ kind: 'lora_import', state: 'failed', scope: { operation: 'lora_import', failure } });
|
||
for (const failure of ['plan-changed', 'storage-changed', 'plan-expired', 'blocked-by-pairs']) {
|
||
assert.deepEqual(reviewAgainOf(failed(failure)), { section: '#/system/integrations' }, failure);
|
||
}
|
||
assert.equal(reviewAgainOf(failed('import-failed')), null);
|
||
assert.equal(reviewAgainOf({ ...failed('plan-changed'), state: 'cancelled' }), null);
|
||
});
|
||
|
||
test('a host save in two parts reports exactly which part saved (S10 review I3)', async () => {
|
||
const { writeHostInParts } = await integrations;
|
||
const saved = { lora_enabled: true, lora_trigger_words_enabled: false, lora_path: 'custom_nodes/LM' };
|
||
const calls = [];
|
||
const ok = revision => async body => { calls.push(body); return { success: true, persisted: true, revision }; };
|
||
const refuse = (code, message) => async body => { calls.push(body); throw Object.assign(new Error(message), { code }); };
|
||
const run = (changes, postLora, postSettings) => writeHostInParts({ changes, saved, expected_revision: 'r0', postLora, postSettings });
|
||
|
||
// Both parts: the second carries the revision the first returned.
|
||
assert.equal((await run({ lora_trigger_words_enabled: true, result_timeout: 5 }, ok('r1'), ok('r2'))).revision, 'r2');
|
||
assert.deepEqual(calls.map(body => body.expected_revision), ['r0', 'r1']);
|
||
// LoRA saved, settings refused: the LoRA keys and the new revision ride on the settings error.
|
||
calls.length = 0;
|
||
const later = await run({ lora_trigger_words_enabled: true, gallery_root_paths: ['x'] }, ok('r1'),
|
||
refuse('invalid-source', 'x cannot be used')).catch(error => error);
|
||
assert.equal(later.code, 'invalid-source');
|
||
assert.deepEqual(later.partial, { saved: ['lora_trigger_words_enabled'], revision: 'r1' });
|
||
// LoRA refused (not detected), settings still sent with the unchanged revision and saved.
|
||
calls.length = 0;
|
||
const first = await run({ lora_enabled: true, result_timeout: 5 }, refuse(null, 'LoraManager not found'), ok('r2'))
|
||
.catch(error => error);
|
||
assert.equal(first.message, 'LoraManager not found');
|
||
assert.deepEqual(first.partial, { saved: ['result_timeout'], revision: 'r2' });
|
||
assert.deepEqual(calls.map(body => body.expected_revision), ['r0', 'r0']);
|
||
// A conflict on the first write stops there; a lone part fails as itself.
|
||
calls.length = 0;
|
||
const conflict = await run({ lora_enabled: false, result_timeout: 5 }, refuse('settings-changed', 'changed'), ok('r2'))
|
||
.catch(error => error);
|
||
assert.equal(conflict.code, 'settings-changed');
|
||
assert.equal(conflict.partial, undefined);
|
||
assert.equal(calls.length, 1);
|
||
const alone = await run({ result_timeout: 5 }, ok('r1'), refuse('busy', 'scan running')).catch(error => error);
|
||
assert.equal(alone.code, 'busy');
|
||
assert.equal(alone.partial, undefined);
|
||
const both = await run({ lora_enabled: true, result_timeout: 5 }, refuse(null, 'a'), refuse(null, 'b')).catch(error => error);
|
||
assert.equal(both.message, 'b');
|
||
assert.equal(both.partial, undefined);
|
||
});
|