@yuneta/gobj-ui 7.25.8 → 7.25.10

package/src/schema_editor_reload.wiring.test.js

@@ -16,6 +16,15 @@
  *      the reload of a late write that forgot this session's marks and
  *      never told the host a write had landed.
  *
+ *      The fourth independent review (same day) found what a reload
+ *      still left behind: a dialog opened on the model it replaced
+ *      (its Save wrote the old record over the newer one), a load
+ *      refused IN session that blanked the model, a late write whose
+ *      list_dict fkey marked nothing, a write answered with no record
+ *      that owed a second reload and dropped the rest of its queue in
+ *      silence, and a toolbar gated on the state instead of on the
+ *      treedb being there.
+ *
  *      Driven through the FSM on a document double, with a fake
  *      transport whose state is the one the library reads.
  *
@@ -264,6 +273,37 @@ function errors()
     return logged.filter((l) => l.level === "error").map((l) => l.msg);
 }
 
+function not_defined()
+{
+    return logged.filter((l) => /NOT DEFINED/i.test(l.msg)).map((l) => l.msg);
+}
+
+/*  The load, answered with records other than the ones it started on:
+ *  somebody else wrote the store meanwhile.  */
+function answer_the_load_with(editor, remote, records)
+{
+    const asked = take("nodes");
+    for(const c of asked) {
+        answer(editor, remote, c, 0, JSON.parse(JSON.stringify(records[c.kw.topic_name])));
+    }
+    return asked.length;
+}
+
+function records_with(change)
+{
+    const records = JSON.parse(JSON.stringify(RECORDS));
+    change(records);
+    return records;
+}
+
+/*  What the editor says while a load is in the air, and when one lands
+ *  under an open dialog.  */
+const WAIT = "the schemas are loading: wait for them";
+const STALE = "the schemas were read again: open the dialog again";
+const KEPT = "cannot read the schemas again: the ones shown may be out of date, your next change reads them first";
+const OWED = "the schemas shown may be out of date: they are read again, try again when they are in";
+const NOT_SENT = "the treedb did not describe a write back: the writes after it were not sent";
+
 describe("the screen of a reload", () => {
 
     test("Refresh on the columns: the old screen goes, the toolbar stops answering", () => {
@@ -318,7 +358,7 @@ describe("the screen of a reload", () => {
 
 describe("a form open when a reload starts", () => {
 
-    test("its Save is refused, said, the form stays, and it saves once the load is in", () => {
+    test("its Save is refused and said, and the load that lands closes it: nothing written", () => {
         const {editor, remote, host} = build("f1", "db/users");
         gobj_send_event(editor, "EV_ADD_COLUMN", {}, editor);
         expect(modals.length).toBe(1);
@@ -329,15 +369,17 @@ describe("a form open when a reload starts", () => {
         form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
 
         expect(errors()).toEqual([]);
-        expect(shown).toEqual(["the schemas are loading: try again when they are in"]);
+        /*  Not "try again": the same Save, once the load is in, wrote a
+         *  form built on the model the load replaced.  */
+        expect(shown).toEqual([WAIT]);
         expect(form.closed).toBe(false);
         expect(take("update-node")).toEqual([]);
 
         answer_the_load(editor, remote);
-        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
         expect(form.closed).toBe(true);
-        const [write] = take("update-node");
-        expect(write.kw.record.value).toBe("email");
+        expect(shown).toEqual([WAIT, STALE]);
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
         expect(errors()).toEqual([]);
     });
 
@@ -346,7 +388,7 @@ describe("a form open when a reload starts", () => {
         gobj_send_event(editor, "EV_REFRESH", {}, host);
         gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id"}, editor);
         expect(errors()).toEqual([]);
-        expect(shown).toEqual(["the schemas are loading: try again when they are in"]);
+        expect(shown).toEqual([WAIT]);
         expect(take("update-node")).toEqual([]);
         answer_the_load(editor, remote);
     });
@@ -439,8 +481,10 @@ describe("a write given up that was DONE", () => {
         expect(editor.priv.written).toEqual({"db.users": true});
         published.length = 0;
 
+        /*  The shape the store answers with: `nodes`/`update-node` ask
+         *  for list_dict, so a fkey comes back as a list of refs.  */
         answer(editor, remote, w2, 0, {id: "db.users.email", value: "email",
-            type: "string", topics: ["topics^db.users^cols"]});
+            type: "string", topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
         expect(published).toContain("EV_RECORD_WRITTEN");
         expect(gobj_current_state(editor)).toBe("ST_LOADING");
         answer_the_load(editor, remote);
@@ -471,3 +515,503 @@ describe("a write given up that was DONE", () => {
         expect(editor.priv.written).toEqual({});
     });
 });
+
+describe("a dialog built on the model a reload replaced (fourth review)", () => {
+
+    test("an edit form: the load that lands closes it, and its Save writes nothing", () => {
+        const {editor, remote, host} = build("s1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="description"]').value = "mine";
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols[0].description = "NEWER";
+            r.cols[0].header = "Newer header";
+        }));
+        expect(form.closed).toBe(true);
+        expect(shown).toEqual([STALE]);
+        expect(editor.priv.dialog).toBe(null);
+
+        /*  The form's button, pressed anyway (a stale screen, a keyboard):
+         *  the record it would write is the OLD one with one field changed,
+         *  over the newer one.  */
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the column of the open form is gone after the reload: closed, no ERROR", () => {
+        const {editor, remote, host} = build("s2", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols = [];
+        }));
+        expect(form.closed).toBe(true);
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(take("update-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("an import plan is not run on the model that replaced the one it was planned on", () => {
+        const {editor, remote, host} = build("s3", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {
+            prune: false,
+            text: JSON.stringify({id: "db", topics: [{id: "users", pkey: "id", cols: [
+                {id: "id", type: "string", flag: ["persistent", "required"]},
+                {id: "email", type: "string"}
+            ]}]})
+        }, editor);
+        expect(editor.priv.import_plan.writes.length).toBeGreaterThan(0);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.import_plan).toBe(null);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols.push({id: "db.users.email", value: "email", order: 2, type: "integer",
+                         topics: ["topics^db.users^cols"]});
+        }));
+        expect(dialog.closed).toBe(true);
+
+        dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled = false;
+        dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").click();
+        expect(take("update-node")).toEqual([]);
+        expect(take("delete-node")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a confirmation decided on the model a reload replaced is not applied", () => {
+        const {editor, remote, host} = build("s4", "db/users");
+        const kw = {what: "column", topic: "users", col: "id",
+                    model_gen: editor.priv.model_gen};
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load(editor, remote);
+        gobj_send_event(editor, "EV_CONFIRMED", kw, editor);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([STALE]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a load that fails IN session (fourth review)", () => {
+
+    test("keeps the model, the screen and the open form, says so, and owes the reload", () => {
+        const {editor, remote, host} = build("b1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        const form = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], -1, null, "deadline");
+        answer(editor, remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(editor, remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.reload_on_open).toBe(true);
+        expect(shown).toEqual([KEPT]);
+        expect(form.closed).toBe(false);
+        expect($in(editor, ".SCHEMA_BODY .SCHEMA_COLUMNS")).toBeTruthy();
+
+        /*  The form was built on a model that may be older than the
+         *  store: its Save would write every field of it. It runs the
+         *  reload owed instead (fifth review), and the load that lands
+         *  closes the form.  */
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(not_defined()).toEqual([]);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([KEPT, OWED]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(form.closed).toBe(true);
+        expect(shown).toEqual([KEPT, OWED, STALE]);
+        expect(editor.priv.reload_on_open).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("with no model before it, it is the empty screen it always was", () => {
+        const remote = gobj_create_service("b2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("b2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("b2_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "deadline");
+        }
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+        expect(editor.priv.model).toBe(null);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop that cuts a reload keeps the records the model was built on", () => {
+        const {editor, remote, host} = build("b3", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], 0, []);   /*  half a load  */
+        drop(editor, remote, host);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+    });
+});
+
+describe("a late write, in the shape the store answers (fourth review)", () => {
+
+    test("a list_dict fkey marks the topic the column belongs to", () => {
+        const {editor, remote, host} = build("c1", "db/users");
+        const w = start_a_write(editor, host, "name");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        expect(editor.priv.written).toEqual({});
+        answer(editor, remote, w, 0, {id: "db.users.name", value: "name", type: "string",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(editor.priv.written).toEqual({"db.users": true});
+        answer_the_load(editor, remote);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a write answered with no record (fourth review)", () => {
+
+    test("the reload it asks is the one owed: the next write does not load again", () => {
+        const {editor, remote, host} = build("n1", "db/users");
+        const w1 = start_a_write(editor, host, "a1");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        const w2 = start_a_write(editor, host, "a2");
+        answer(editor, remote, w1, 0, {id: "db.users.a1", value: "a1",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(editor.priv.reload_after_write).toBe(true);
+        answer(editor, remote, w2, 0, null);
+        expect(editor.priv.reload_after_write).toBe(false);
+        answer_the_load(editor, remote);
+
+        const w3 = start_a_write(editor, host, "a3");
+        answer(editor, remote, w3, 0, {id: "db.users.a3", value: "a3",
+            topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(take("nodes")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the writes queued after it are said, not dropped in silence", () => {
+        const {editor, remote, host} = build("n2", "db/users");
+        for(const name of ["a", "b"]) {
+            const w = start_a_write(editor, host, name);
+            answer(editor, remote, w, 0, {id: `db.users.${name}`, value: name, type: "string",
+                order: name === "a" ? 2 : 3, topics: ["topics^db.users^cols"]});
+        }
+        gobj_send_event(editor, "EV_MOVE_COLUMN", {from: 0, to: 3}, host);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        expect(editor.priv.save_queue.length).toBeGreaterThan(1);
+        const [first] = take("update-node");
+        answer(editor, remote, first, 0, null);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual([NOT_SENT]);
+        expect(logged.some((l) => l.level === "warning" && /not sent/.test(l.msg))).toBe(true);
+        answer_the_load(editor, remote);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the toolbar of a treedb that is not there (fourth review)", () => {
+
+    test("offers Back and Refresh, and nothing that needs the treedb", () => {
+        const {editor, remote, host} = build("t1", "db");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.treedbs = [{id: "other", schema_version: 1}];
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect($in(editor, ".SCHEMA_BACK")).toBeTruthy();
+        expect($in(editor, ".SCHEMA_REFRESH_BTN")).toBeTruthy();
+        for(const cls of ["SCHEMA_DIAGRAM_BTN", "SCHEMA_VALIDATE_BTN", "SCHEMA_EXPORT_BTN",
+                          "SCHEMA_IMPORT_BTN", "SCHEMA_ADD_TOPIC_BTN"]) {
+            expect([cls, !!$in(editor, `.${cls}`)]).toEqual([cls, false]);
+        }
+        for(const $b of $all(editor, ".SCHEMA_TOOLBAR button")) {
+            if($b.classList.contains("SCHEMA_REFRESH_BTN") || $b.classList.contains("SCHEMA_BACK")) {
+                continue;
+            }
+            $b.click();
+        }
+        expect(errors()).toEqual([]);
+    });
+
+    test("a topic that is not there offers no New column", () => {
+        const {editor, remote, host} = build("t2", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect(!!$in(editor, ".SCHEMA_ADD_COL_BTN")).toBe(false);
+        expect($in(editor, ".SCHEMA_BACK")).toBeTruthy();
+    });
+});
+
+describe("every control of the editor's dialogs is named (fourth review)", () => {
+
+    /*  A control a wrapping <label> names is the one shape that needs no
+     *  attribute (CLAUDE.md, "title + aria-label").  */
+    function unnamed($root)
+    {
+        const out = [];
+        for(const $c of $root.querySelectorAll("button, input, select, textarea")) {
+            if($c.getAttribute("type") === "checkbox" && $c.closest("label")) {
+                continue;
+            }
+            const ok = $c.getAttribute("title") !== null &&
+                $c.getAttribute("aria-label") !== null &&
+                !!$c.getAttribute("data-i18n-title") &&
+                !!$c.getAttribute("data-i18n-aria-label");
+            if(!ok) {
+                out.push(`${$c.tagName} ${$c.className || $c.getAttribute("data-name") || ""}`);
+            }
+        }
+        return out;
+    }
+
+    test("the column form, the topic form and the import", () => {
+        const {editor, remote, host} = build("a1", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        gobj_send_event(editor, "EV_EDIT_TOPIC", {topic: "users"}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        expect(unnamed(modals[modals.length - 1].$content)).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the export's two views are controls (fifth review)", () => {
+
+    test("each is a named button that says which one is shown, and switches the text", () => {
+        const {editor, remote, host} = build("x1", "db");
+        gobj_send_event(editor, "EV_EXPORT", {}, host);
+        const $content = modals[modals.length - 1].$content;
+        const $tabs = [...$content.querySelectorAll(".SCHEMA_EXPORT_TAB")];
+        expect($tabs.map(($b) => [
+            $b.tagName.toLowerCase(),
+            $b.getAttribute("type"),
+            $b.getAttribute("title") !== null,
+            $b.getAttribute("data-i18n-title"),
+            $b.getAttribute("aria-label") !== null,
+            $b.getAttribute("data-i18n-aria-label"),
+            $b.getAttribute("aria-pressed"),
+        ])).toEqual([
+            ["button", "button", true, "schema as c source", true, "schema as c source", "true"],
+            ["button", "button", true, "schema as json", true, "schema as json", "false"],
+        ]);
+
+        const $text = $content.querySelector(".SCHEMA_EXPORT_TEXT");
+        $tabs[1].click();
+        expect($text.value.trim().startsWith("{")).toBe(true);
+        expect($tabs.map(($b) => $b.getAttribute("aria-pressed"))).toEqual(["false", "true"]);
+        $tabs[0].click();
+        expect($text.value.trim().startsWith("{")).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a Refresh asked while a load is in flight (fifth review)", () => {
+
+    test("keeps the records of the model shown, not the half the first load got", () => {
+        const {editor, remote, host} = build("h1", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const first = take("nodes");
+        answer(editor, remote, first[0], 0, []);    /*  half a load  */
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const second = take("nodes");
+        expect(second.length).toBe(3);
+        drop(editor, remote, host);
+        expect(editor.priv.records.treedbs.length).toBe(1);
+        expect(editor.priv.records.topics.length).toBe(1);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("...and so does one that fails in session", () => {
+        const {editor, remote, host} = build("h2", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const first = take("nodes");
+        answer(editor, remote, first[0], 0, []);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const second = take("nodes");
+        answer(editor, remote, second[0], -1, null, "deadline");
+        answer(editor, remote, second[1], 0, []);
+        answer(editor, remote, second[2], 0, []);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the reload a load refused in session owes (fifth review)", () => {
+
+    function refused_load(name, subpath)
+    {
+        const built = build(name, subpath);
+        gobj_send_event(built.editor, "EV_REFRESH", {}, built.host);
+        const asked = take("nodes");
+        answer(built.editor, built.remote, asked[0], -1, null, "deadline");
+        answer(built.editor, built.remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(built.editor, built.remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+        expect(built.editor.priv.reload_on_open).toBe(true);
+        expect(shown).toEqual([KEPT]);
+        return built;
+    }
+
+    test("RUNS on the next edit, which is refused and said: nothing is opened on the old model", () => {
+        const {editor, remote, host} = refused_load("o1", "db/users");
+        const before = modals.length;
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(shown).toEqual([KEPT, OWED]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.reload_on_open).toBe(false);
+
+        /*  Once: the next edit opens its form.  */
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before + 1);
+        expect(take("nodes")).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test.each([
+        ["EV_ADD_COLUMN", {}],
+        ["EV_DUPLICATE_COLUMN", {col: "id"}],
+        ["EV_DELETE_COLUMN", {col: "id"}],
+        ["EV_MOVE_COLUMN", {from: 0, to: 1}],
+        ["EV_EXPORT", {}],
+        ["EV_IMPORT", {}],
+        ["EV_VALIDATE", {}],
+        ["EV_CONFIRMED", {what: "column", topic: "users", col: "id"}],
+    ])("%s runs it too, and writes nothing", (event, kw) => {
+        const {editor, remote, host} = refused_load(`o2_${event}`, "db/users");
+        kw = Object.assign({model_gen: editor.priv.model_gen}, kw);
+        const before = modals.length;
+        gobj_send_event(editor, event, kw, host);
+        expect(modals.length).toBe(before);
+        expect(take("update-node")).toEqual([]);
+        expect(take("delete-node")).toEqual([]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("a move goes where it was going, and reads the schemas there", () => {
+        const {editor, remote, host} = refused_load("o3", "db/users");
+        gobj_send_event(editor, "EV_BACK", {}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(shown).toEqual([KEPT]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.reload_on_open).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("keeps what this session wrote", () => {
+        const {editor, remote, host} = build("o4", "db/users");
+        const w = start_a_write(editor, host, "name");
+        answer(editor, remote, w, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(editor.priv.written).toEqual({"db.users": true});
+        editor.priv.reload_on_open = true;      /*  as a refused load leaves it  */
+        gobj_send_event(editor, "EV_ADD_COLUMN", {}, host);
+        answer_the_load(editor, remote);
+        expect(editor.priv.written).toEqual({"db.users": true});
+    });
+});
+
+describe("the import plan (fifth review)", () => {
+
+    const IMPORT = JSON.stringify({id: "db", topics: [{id: "users", pkey: "id", cols: [
+        {id: "id", type: "string", flag: ["persistent", "required"]},
+        {id: "email", type: "string"}
+    ]}]});
+
+    test("a load that could not be sent keeps it: the model it was planned on stays", () => {
+        const {editor, remote, host} = build("i1", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        const plan = editor.priv.import_plan;
+        expect(plan.writes.length).toBeGreaterThan(0);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.import_plan).toBe(plan);
+        expect(dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a Yes that finds it gone is a warning, and said -- not an ERROR", () => {
+        const {editor, remote, host} = build("i2", "db");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "import",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(errors()).toEqual([]);
+        expect(logged.some((l) => l.level === "warning" && /import plan is gone/.test(l.msg))).toBe(true);
+        expect(shown).toEqual(["the import plan is gone: preview it again"]);
+        expect(take("update-node")).toEqual([]);
+    });
+});
+
+describe("a confirmation answered where no treedb is open (fifth review)", () => {
+
+    test("after a reload that landed on zero treedbs: refused as stale, not NOT DEFINED", () => {
+        const {editor, remote, host} = build("e1", "db/users");
+        const kw = {what: "column", topic: "users", col: "id", model_gen: editor.priv.model_gen};
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.treedbs = [];
+            r.topics = [];
+            r.cols = [];
+        }));
+        expect(gobj_current_state(editor)).toBe("ST_EMPTY");
+        gobj_send_event(editor, "EV_CONFIRMED", kw, editor);
+        expect(not_defined()).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(shown).toEqual([STALE]);
+        expect(take("delete-node")).toEqual([]);
+    });
+
+    test("with no model at all (ST_IDLE): refused and said", () => {
+        const remote = gobj_create_service("e2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("e2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("e2_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "deadline");
+        }
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id",
+            model_gen: editor.priv.model_gen - 1}, editor);
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "column", topic: "users", col: "id",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(not_defined()).toEqual([]);
+        expect(errors()).toEqual([]);
+        expect(shown).toEqual([STALE, STALE]);
+    });
+});

package/src/shell_modals.js

@@ -153,7 +153,8 @@ function show_notification(shell, kind, message, opts)
         ["div", {class: `TOAST notification yui-notification ${yui_tint(kind)}`,
                  role: kind === "danger" ? "alert" : "status"},
             [
-                ["button", {class: "TOAST_CLOSE delete", "aria-label": t("close"), "data-i18n-aria-label": "close"}],
+                ["button", {class: "TOAST_CLOSE delete", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}],
                 ["p", {...p_attrs, class: "TOAST_MSG"}, message]
             ]
         ]
@@ -277,14 +278,16 @@ export function yui_shell_show_modal(shell, content, opts)
     let modal_children;
     if(dialog) {
         let header = ["div", {class: "MODAL_HEADER yui-dialog-header"}, [
-            ["button", {class: "MODAL_BACK yui-dialog-back", type: "button", "aria-label": t("back"), "data-i18n-aria-label": "back"},
+            ["button", {class: "MODAL_BACK yui-dialog-back", type: "button", title: t("back"), "data-i18n-title": "back",
+                    "aria-label": t("back"), "data-i18n-aria-label": "back"},
                 [["i", {class: "yi-arrow-left"}]]],
             ["span", {class: "MODAL_TITLE yui-dialog-title"},
                 (title_prefix ? [["span", {class: "MODAL_TITLE_PREFIX"}, title_prefix]] : [])
                     .concat(title
                         ? [["span", {class: "MODAL_TITLE_KIND", i18n: title}, title]]
                         : [])],
-            ["button", {class: "MODAL_CLOSE yui-dialog-x", type: "button", "aria-label": t("close"), "data-i18n-aria-label": "close"},
+            ["button", {class: "MODAL_CLOSE yui-dialog-x", type: "button", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"},
                 [["i", {class: "yi-xmark"}]]],
         ]];
         let body = ["div", {class: "MODAL_BODY yui-dialog-body"}, inner ? [inner] : []];
@@ -304,7 +307,8 @@ export function yui_shell_show_modal(shell, content, opts)
         if(with_close) {
             modal_children.push(
                 ["button", {class: "MODAL_CLOSE modal-close is-large",
-                            "aria-label": t("close"), "data-i18n-aria-label": "close"}]
+                            title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}]
             );
         }
     }
@@ -501,8 +505,15 @@ function build_dialog(shell, message, buttons, opts)
         }
         let btn_attrs = {class: cls, type: "button",
                          "data-modal-button-value": b.value};
+        /*  Named by its own label key: its text is its name for the eye,
+         *  and the title and aria-label say the same to the pointer and
+         *  to a reader, re-translated with it.  */
         if(typeof b.label === "string") {
             btn_attrs.i18n = b.label;
+            btn_attrs.title = t(b.label);
+            btn_attrs["data-i18n-title"] = b.label;
+            btn_attrs["aria-label"] = t(b.label);
+            btn_attrs["data-i18n-aria-label"] = b.label;
         }
         return ["button", btn_attrs, b.label];
     });
@@ -519,7 +530,8 @@ function build_dialog(shell, message, buttons, opts)
         );
     }
     $card_children.push(
-        ["button", {class: "CONFIRM_CLOSE delete yui-confirm-x", "aria-label": t("close"), "data-i18n-aria-label": "close"}],
+        ["button", {class: "CONFIRM_CLOSE delete yui-confirm-x", title: t("close"), "data-i18n-title": "close",
+                    "aria-label": t("close"), "data-i18n-aria-label": "close"}],
         ["section", {class: "CONFIRM_BODY modal-card-body has-text-centered"},
             $body_children],
         ["footer", {class: "CONFIRM_FOOT modal-card-foot"}, $footer_children]