@yuneta/gobj-ui 7.25.17 → 7.25.19

package/src/treedb_topics_transport.wiring.test.js

@@ -29,6 +29,7 @@ const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c
 const {register_c_yui_treedb_topics} = await import("./c_yui_treedb_topics.js");
 
 const logged = [];
+const written = [];         /*  the EV_RECORD_WRITTEN the host heard  */
 const answers = [];         /*  what the fake forms were told  */
 const loaded = [];          /*  the rows each fake form was loaded with  */
 const commands = [];        /*  what the fake transport was asked  */
@@ -103,7 +104,10 @@ beforeAll(() => {
         "C_TEST_VIEW_HOST",
         [["EV_RECORD_WRITTEN", 0], ["EV_TOPIC_SELECTED", 0]],
         [["ST_IDLE", [
-            ["EV_RECORD_WRITTEN", () => 0, null],
+            ["EV_RECORD_WRITTEN", (gobj, event, kw) => {
+                written.push(kw);
+                return 0;
+            }, null],
             ["EV_TOPIC_SELECTED", () => 0, null]
         ]]],
         {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
@@ -121,6 +125,7 @@ beforeAll(() => {
 
 beforeEach(() => {
     logged.length = 0;
+    written.length = 0;
     answers.length = 0;
     commands.length = 0;
     loaded.length = 0;
@@ -228,16 +233,26 @@ describe("a Save in flight when the backend drops", () => {
         save(topics, forms.roles, 1);
 
         /*  The answer of the users write, the way C_IEVENT_CLI delivers it:
-         *  the request's frame on top of the command_stack.  */
-        const ok = {result: 0, comment: "", data: [{id: "x"}], __md_iev__: {
-            command_stack: [{command: "update-node", kw: {
-                topic_name: "users", treedb_name: "treedb_test", form_write: 1, record: {id: "x"}
-            }}]
+         *  the request's `__md_command__` as the frame on top of the
+         *  command_stack, and nothing else of the request.  */
+        const users_write = commands.find((c) => c.command === "update-node" &&
+            c.kw.topic_name === "users");
+        const ok = {result: 0, comment: "", data: [{id: "x", name: "stored"}], __md_iev__: {
+            command_stack: [{command: "update-node", kw: users_write.kw.__md_command__}]
         }};
         gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", ok, remote);
         expect(answers).toEqual([
             {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
         ]);
+        /*  What the host is told names the treedb and carries the record
+         *  the store answered: read off that frame, both arrived empty.  */
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "users",
+            record: {id: "x", name: "stored"},
+            created: false,
+            command: "update-node"
+        }]);
 
         yui_shell_set_connection_state(shell, false);
         expect(answers).toEqual([
@@ -247,13 +262,102 @@ describe("a Save in flight when the backend drops", () => {
     });
 });
 
+/*
+ *  The success answer of a request, the way C_IEVENT_CLI delivers it: the
+ *  request's `__md_command__` as the frame, and nothing else of it.
+ */
+function answer_ok(request, data)
+{
+    return {result: 0, comment: "", data: data, __md_iev__: {
+        command_stack: [{command: request.command, kw: request.kw.__md_command__}]
+    }};
+}
+
+/*
+ *  Before gobj-ui 7.25.19 a delete answered published nothing (the case
+ *  was an empty `break`), and `created` compared the command with
+ *  "create-node" -- which the view never sends: its +New goes out as an
+ *  update-node with `create_only`, so `created` was always false.
+ */
+describe("EV_RECORD_WRITTEN of a create and of a delete", () => {
+
+    test("a +New answered says created: true", () => {
+        const {shell, topics, forms} = build("tc1");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_CREATE_RECORD",
+            {record: {id: "n1"}, form_write: 1}, forms.users);
+
+        const request = commands.find((c) => c.command === "update-node");
+        expect(request.kw.options.create_only).toBe(true);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "n1", name: "new"}]), remote);
+
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "users",
+            record: {id: "n1", name: "new"},
+            created: true,
+            command: "update-node"
+        }]);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edit answered says created: false", () => {
+        const {shell, topics, forms} = build("tc2");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        const request = commands.find((c) => c.command === "update-node");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "x"}]), remote);
+        expect(written.map((w) => w.created)).toEqual([false]);
+    });
+
+    test("a delete answered is published with the node deleted", () => {
+        const {shell, topics, forms} = build("tc3");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_DELETE_RECORD", {record: {id: "x"}}, forms.roles);
+
+        const request = commands.find((c) => c.command === "delete-node");
+        expect(request).toBeTruthy();
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "x", name: "gone"}]), remote);
+
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "roles",
+            record: {id: "x", name: "gone"},
+            created: false,
+            command: "delete-node"
+        }]);
+        /*  A delete has no form waiting for its answer.  */
+        expect(answers).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a delete refused publishes nothing", () => {
+        const {shell, topics, forms} = build("tc4");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_DELETE_RECORD", {record: {id: "x"}}, forms.roles);
+        const request = commands.find((c) => c.command === "delete-node");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", {
+            result: -1, comment: "linked", data: null, __md_iev__: {
+                command_stack: [{command: "delete-node", kw: request.kw.__md_command__}]
+            }
+        }, remote);
+        expect(written).toEqual([]);
+    });
+});
+
 /*
  *  The answer the routing adapter gives a write it had in flight when
  *  its session closed: a failure, settled by the adapter itself.
  */
 function failed_write(topic_name, form_write)
 {
-    const md = {topic_name: topic_name, treedb_name: "treedb_test", record: {id: "x"}};
+    const md = {topic_name: topic_name};   /*  the request's __md_command__, and only it  */
     if(form_write) {
         md.form_write = form_write;
     }

package/src/uplot_add_serie.test.js

@@ -0,0 +1,92 @@
+/***********************************************************************
+ *          uplot_add_serie.test.js
+ *
+ *      C_YUI_UPLOT's EV_ADD_SERIE gives a series the palette's stroke
+ *      and fill only when the host gave none. It did it through
+ *      kw_get_str(KW_CREATE), which reads a stroke that is a FUNCTION
+ *      (uPlot takes one, and a gradient) as a value of the wrong type:
+ *      since gobj-js 7.25.5, which logs that as C does, every series
+ *      added with one logged an error.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+/*  uPlot draws on a canvas the document double does not have: the
+ *  chart gets a stand-in, and the test writes its own over it.  */
+vi.mock("uplot", () => ({
+    default: class {
+        constructor() {
+            this.series = [{}];
+        }
+        setSize() {}
+        addSeries() {}
+        destroy() {}
+    }
+}));
+
+const {
+    gobj_start_up, gobj_create_yuno, gobj_create_pure_child, gclass_create,
+    gobj_send_event, gobj_write_attr, set_log_callback, SDATA_END,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_uplot} = await import("./c_yui_uplot.js");
+
+const logged = [];
+let yuno = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+    gclass_create("C_TEST_UPLOT_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    register_c_yui_uplot();
+    yuno = gobj_create_yuno("uplot_yuno", "C_TEST_UPLOT_HOST", {});
+});
+
+beforeEach(() => {
+    logged.length = 0;
+});
+
+let seq = 0;
+
+/*  The chart, with uPlot replaced by what EV_ADD_SERIE asks of it.  */
+function build()
+{
+    const chart = gobj_create_pure_child(`chart_${++seq}`, "C_YUI_UPLOT", {}, yuno);
+    const added = [];
+    gobj_write_attr(chart, "uplot", {
+        series: [{}],
+        addSeries: (kw) => {
+            added.push(kw);
+        }
+    });
+    logged.length = 0;
+    return {chart, added};
+}
+
+describe("EV_ADD_SERIE", () => {
+
+    test("a series with no colours takes the palette's", () => {
+        const {chart, added} = build();
+        gobj_send_event(chart, "EV_ADD_SERIE", {id: "a", label: "A"}, chart);
+        expect(added.length).toBe(1);
+        expect(typeof added[0].stroke).toBe("string");
+        expect(added[0].stroke.length).toBeGreaterThan(0);
+        expect(logged.filter((l) => l.level === "error")).toEqual([]);
+    });
+
+    test("a stroke and a fill that are functions are kept, and nothing is logged", () => {
+        const {chart, added} = build();
+        const stroke = () => "red";
+        const fill = () => "pink";
+        gobj_send_event(chart, "EV_ADD_SERIE", {id: "b", stroke, fill}, chart);
+        expect(added[0].stroke).toBe(stroke);
+        expect(added[0].fill).toBe(fill);
+        expect(logged.filter((l) => l.level === "error")).toEqual([]);
+    });
+});