Merge branch 'feat/444-tags-page-search' into feat/444-library-folder-or

# Conflicts:
#	TESTING.md
#	web/js/workspace/library.mjs

tests/js/workspace-images-category.test.js

@@ -59,3 +59,9 @@ test('the toolbar list merges prompt and image categories once each', async () =
     assert.deepEqual(mergeCategories(['A', '', '  ', 7], null), ['A']);
     assert.deepEqual(mergeCategories(undefined, ['landscapes', 'Landscapes']), ['landscapes', 'Landscapes']);
 });
+
+test('the outcome names what was set: images by default, prompts for the Library bar (#437)', async () => {
+    const {setOutcome} = await source;
+    assert.equal(setOutcome({updated:1, unchanged:0, not_found:0}, 'A', 'prompt'), 'Category “A” set on 1 prompt.');
+    assert.equal(setOutcome({updated:2, unchanged:0, not_found:0}, 'A', 'prompt'), 'Category “A” set on 2 prompts.');
+});

tests/js/workspace-library-selection.test.js

@@ -0,0 +1,44 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+// #437 D148: the Prompt library's selection bar sets one category on the selected prompts, fenced by the storage epoch.
+const source = import('../../web/js/workspace/library-selection.mjs');
+
+test('the dialog is the shared simpleInput with the prompt title, and the route and cap are the legacy ones', async () => {
+    const {PROMPT_CATEGORY_DIALOG, CATEGORY_URL, MAX_CATEGORY_PROMPTS, TOO_MANY_PROMPTS} = await source;
+    assert.deepEqual({...PROMPT_CATEGORY_DIALOG}, {title:'Categorize selected prompts', label:'Category', action:'Apply'});
+    assert.equal(CATEGORY_URL, '/prompt_manager/bulk/category');
+    assert.equal(MAX_CATEGORY_PROMPTS, 1000);
+    assert.equal(TOO_MANY_PROMPTS, 'Select at most 1,000 prompts.');
+});
+
+test('a confirmed write toasts the shared outcome with "prompt", invalidates and reloads', async () => {
+    const {writeOutcome} = await source;
+    assert.deepEqual(writeOutcome({success:true, category:'Studio', updated:2, unchanged:1, not_found:0}, null),
+        {toast:'Category “Studio” set on 3 prompts.', committed:true, reload:true});
+    assert.deepEqual(writeOutcome({success:true, category:'Studio', updated:1, unchanged:0, not_found:2}, null),
+        {toast:'Category “Studio” set on 1 prompt. 2 could not be found.', committed:true, reload:true});
+});
+
+test('none found, a restored storage, an unconfirmed answer and a refused write each say what happened', async () => {
+    const {writeOutcome, NONE_FOUND, STORAGE_CHANGED, UNCONFIRMED, CATEGORY_FAILED} = await source;
+    assert.deepEqual(writeOutcome({success:true, category:'X', updated:0, unchanged:0, not_found:3}, null),
+        {toast:NONE_FOUND, committed:false, reload:true});
+    assert.deepEqual(writeOutcome(null, {status:409, code:'storage-changed'}), {toast:STORAGE_CHANGED, committed:false, reload:true});
+    for (const failure of [new TypeError('Failed to fetch'), {status:502}, {status:503}, {status:504}]) {
+        assert.deepEqual(writeOutcome(null, failure), {toast:UNCONFIRMED, committed:true, reload:true});
+    }
+    assert.deepEqual(writeOutcome(null, null), {toast:UNCONFIRMED, committed:true, reload:true});
+    for (const status of [400, 500]) {
+        assert.deepEqual(writeOutcome(null, {status}), {toast:CATEGORY_FAILED, committed:false, reload:false});
+    }
+    assert.equal(STORAGE_CHANGED, 'Prompt storage was restored since this page loaded. No category was changed.');
+});
+
+test('the field refuses control characters as validate_category does', async () => {
+    const {categoryProblem, CONTROL_CHARACTERS} = await source;
+    assert.equal(categoryProblem('Studio portraits'), null);
+    assert.equal(categoryProblem('tab\there'), CONTROL_CHARACTERS);
+    assert.equal(categoryProblem('nul\u0000'), CONTROL_CHARACTERS);
+    assert.equal(categoryProblem('unicode ✓ é'), null);
+});

tests/js/workspace-library-state.test.js

@@ -129,3 +129,13 @@ test('tag mode untagged is sent, echoed and never combined with tags (#444)',asy
  await assert.rejects(s.reset({tagMode:'untagged',tags:['a']}),TypeError);await assert.rejects(s.reset({tagMode:'or'}),TypeError);
  assert.equal(calls.length,3);s.dispose();
 });
+test('the stream keeps the first page\'s storage epoch and refuses a later page from another one (#437)',async()=>{
+ const {createLibraryStream}=await source;const A='11111111-1111-4111-8111-111111111111',B='22222222-2222-4222-8222-222222222222';
+ const pending=[{...page([item(1)],'next'),library_epoch:A},{...page([item(2)],'more'),library_epoch:A},{...page([item(3)]),library_epoch:B}];
+ const s=createLibraryStream({api:{get:async()=>pending.shift()}});assert.equal(s.state.epoch,null);
+ await s.reset();assert.equal(s.state.epoch,A);await s.loadMore();assert.equal(s.state.epoch,A);assert.equal(s.state.items.length,2);
+ await s.loadMore();assert.ok(s.state.error);assert.equal(s.state.items.length,2);assert.equal(s.state.epoch,A);
+ const restored=createLibraryStream({api:{},restore:{filters:{},state:s.state}});assert.equal(restored.state.epoch,A);restored.dispose();
+ const fresh=[{...page([item(4)]),library_epoch:B}];const reset=s.reset({text:'x'});assert.equal(s.state.epoch,null);
+ s.dispose();const next=createLibraryStream({api:{get:async()=>fresh.shift()}});await next.reset();assert.equal(next.state.epoch,B);next.dispose();await reset;
+});

tests/js/workspace-system-backups.test.js

@@ -192,6 +192,71 @@ test('views reload once after a restore this page saw finish; a failed restore c
     assert.equal(listeners.size, 0);
 });
 
+// #415: a fake document whose open dialogs the test sets, and a MutationObserver stand-in it triggers.
+function dialogPage() {
+    const page = { open: 0, observers: new Set() };
+    page.doc = { documentElement: {}, querySelector: selector => (selector === 'dialog[open]' && page.open > 0 ? {} : null) };
+    page.Observer = class {
+        constructor(callback) { this.callback = callback; }
+        observe(target, options) { this.target = target; this.options = options; page.observers.add(this); }
+        disconnect() { page.observers.delete(this); }
+    };
+    page.mutate = open => { page.open = open; for (const observer of [...page.observers]) observer.callback([]); };
+    return page;
+}
+
+test('the restore reload runs at once when no dialog is open', async () => {
+    const { createRestoreReload } = await backups;
+    const page = dialogPage();
+    let reloads = 0;
+    const reload = createRestoreReload(() => { reloads += 1; }, { doc: page.doc, Observer: page.Observer });
+    reload.request();
+    assert.equal(reloads, 1);
+    assert.equal(page.observers.size, 0, 'nothing waits');
+    reload.request();
+    assert.equal(reloads, 2);
+});
+
+test('the restore reload waits for every open dialog to close, then runs once (#415)', async () => {
+    const { createRestoreReload } = await backups;
+    const page = dialogPage();
+    page.open = 1;
+    let reloads = 0;
+    const reload = createRestoreReload(() => { reloads += 1; }, { doc: page.doc, Observer: page.Observer });
+    reload.request();
+    reload.request();
+    assert.equal(reloads, 0, 'an open dialog holds the reload');
+    assert.equal(page.observers.size, 1, 'one observer for repeated requests');
+    const [observer] = page.observers;
+    assert.equal(observer.target, page.doc.documentElement);
+    assert.deepEqual(observer.options, { subtree: true, childList: true, attributes: true, attributeFilter: ['open'] });
+    page.mutate(1);
+    assert.equal(reloads, 0, 'a dialog swapped for another keeps it waiting');
+    page.mutate(0);
+    assert.equal(reloads, 1);
+    assert.equal(page.observers.size, 0, 'the observer stops once it ran');
+    page.mutate(0);
+    assert.equal(reloads, 1);
+    page.open = 1;
+    reload.request();
+    page.mutate(0);
+    assert.equal(reloads, 2, 'a later restore waits again');
+});
+
+test('disposing drops a waiting restore reload', async () => {
+    const { createRestoreReload } = await backups;
+    const page = dialogPage();
+    page.open = 1;
+    let reloads = 0;
+    const reload = createRestoreReload(() => { reloads += 1; }, { doc: page.doc, Observer: page.Observer });
+    reload.request();
+    reload.dispose();
+    assert.equal(page.observers.size, 0);
+    page.mutate(0);
+    assert.equal(reloads, 0);
+    reload.dispose();
+});
+
 test('a downloaded backup the server could not verify says so', async () => {
     const { downloadDatabaseBackup, BACKUP_DONE, backupUnverified } = await scan;
     const toasts = [];

tests/js/workspace-toolbar.test.js

@@ -908,6 +908,34 @@ test('openReviewDialog lays out heading, grid, options, sentence, backup box and
     }
 });
 
+// #415: a finished restore ends an open review (its reviewed plan no longer describes storage) as a dismissal, and
+// leaves any other dialog, with what was typed in it, open.
+test('closeReviewDialog closes only an open review, as dismissed', async () => {
+    const { openReviewDialog, openInputDialog, closeReviewDialog, closeWorkspaceDialog } = await dialogsModule;
+    const { createScope } = await coreModule;
+    const dom = fakeDOM();
+    const scope = createScope();
+    try {
+        closeReviewDialog();
+        const outcomes = [];
+        openInputDialog({ scope, title: 'Save view', label: 'Name', value: 'typed', action: 'Save', onApply() {} });
+        closeReviewDialog();
+        assert.equal(modal(dom).open, true, 'an input dialog stays');
+        assert.equal(byId(dom, 'action-input').value, 'typed');
+        openReviewDialog({ scope, title: 'Restore preview', grid: [['Integrity', 'Verified']], cancelLabel: 'Cancel',
+            primary: { label: 'Restore', danger: true }, onStart: () => outcomes.push('start'), onDismiss: () => outcomes.push('dismiss') });
+        closeReviewDialog();
+        assert.deepEqual(outcomes, ['dismiss']);
+        assert.equal(modal(dom), undefined, 'the shell is gone');
+        closeReviewDialog();
+        assert.deepEqual(outcomes, ['dismiss']);
+    } finally {
+        scope.dispose();
+        closeWorkspaceDialog();
+        dom.restore();
+    }
+});
+
 test('review dialog backup box keeps the dialog open and toasts the outcome', async () => {
     const { openReviewDialog, closeWorkspaceDialog, SCAN_BACKUP_COPY } = await dialogsModule;
     const { downloadDatabaseBackup, BACKUP_DONE, BACKUP_FAILED } = await scanModule;