sdc_client 0.58.6 → 0.158.1

package/test/models/SdcUser.js

@@ -0,0 +1,75 @@
+import {SdcModel} from '../../src/index.js';
+
+export default class SdcUser extends SdcModel {
+
+  static fields = {
+      "id": {
+        "type": "BigAutoField",
+        "required": false,
+        "max_length": null,
+        "is_relation": false,
+        "many_to_many": null,
+        "one_to_many": null,
+        "many_to_one": null,
+        "one_to_one": null,
+        "related_model": null,
+        "remote_field": null
+      },
+      "username": {
+        "type": "CharField",
+        "required": false,
+        "max_length": 255,
+        "is_relation": false,
+        "many_to_many": null,
+        "one_to_many": null,
+        "many_to_one": null,
+        "one_to_one": null,
+        "related_model": null,
+        "remote_field": null
+      }
+    }
+
+  constructor(data = {}) {
+    super("SdcUser");
+    this._id = null;
+    this._username = null;
+    this.setValues(data);
+  }
+
+  setValues(data = {}) {
+    try {
+      this.id = data.id ?? data.pk ?? null;
+    } catch {}
+    try {
+      this.username = data.username ?? null;
+    } catch {}
+  }
+
+  set id(value){
+    this.setid(value);
+    this._updateForm('id');
+  }
+
+  set username(value){
+    this.setusername(value);
+    this._updateForm('username');
+  }
+
+  setid(value){
+    this.validate(value, SdcUser.fields.id);
+    this._id = this.parseValue(value, SdcUser.fields.id);
+  }
+
+  setusername(value){
+    this.validate(value, SdcUser.fields.username);
+    this._username = this.parseValue(value, SdcUser.fields.username);
+  }
+
+  get id(){
+    return this._id;
+  }
+
+  get username(){
+    return this._username;
+  }
+}

package/test/models/src.js

@@ -0,0 +1,8 @@
+import BookContent from './BookContent.js';
+import Book from './Book.js';
+import Author from './Author.js';
+import { registerModel } from '../../src/index.js';
+
+registerModel("Author", Author);
+registerModel("Book", Book);
+registerModel("BookContent", BookContent);

package/test/sdc_model_dates.ai.test.js

@@ -0,0 +1,57 @@
+/**
+ * @jest-environment jsdom
+ */
+import { jest } from "@jest/globals";
+import SdcModel from "../src/simpleDomControl/sdc_model.js";
+
+const FROZEN_NOW = new Date("2026-04-03T10:15:30.000Z");
+
+describe("SdcModel date parsing and validation", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(FROZEN_NOW);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("parseValue converts ISO datetime strings to timestamps deterministically", () => {
+    const model = new SdcModel("AuditLog");
+
+    const parsed = model.parseValue("2026-04-03T10:15:30.000Z", {
+      type: "DateTimeField",
+    });
+
+    expect(parsed).toBe(Date.parse("2026-04-03T10:15:30.000Z"));
+    expect(parsed).toBe(FROZEN_NOW.getTime());
+  });
+
+  test("validate accepts valid date and datetime payloads from the server", () => {
+    const model = new SdcModel("AuditLog");
+
+    expect(() =>
+      model.validate("2026-04-03", {
+        type: "DateField",
+        required: true,
+      }),
+    ).not.toThrow();
+    expect(() =>
+      model.validate("2026-04-03T10:15:30.000Z", {
+        type: "DateTimeField",
+        required: true,
+      }),
+    ).not.toThrow();
+  });
+
+  test("validate rejects invalid date payloads with a stable error", () => {
+    const model = new SdcModel("AuditLog");
+
+    expect(() =>
+      model.validate("not-a-date", {
+        type: "DateTimeField",
+        required: true,
+      }),
+    ).toThrow("Must be a valid date");
+  });
+});

package/test/sdc_server_call.ai.test.js

@@ -0,0 +1,267 @@
+/**
+ * @jest-environment jsdom
+ */
+import { jest } from "@jest/globals";
+import $ from "jquery";
+
+window.$ = $;
+global.$ = $;
+
+const FROZEN_NOW = new Date("2026-04-03T10:15:30.000Z");
+
+class EventSink {
+  constructor() {
+    this.calls = [];
+  }
+
+  pushMsg(...args) {
+    this.calls.push(["pushMsg", ...args]);
+  }
+
+  pushErrorMsg(...args) {
+    this.calls.push(["pushErrorMsg", ...args]);
+  }
+
+  onNavLink(...args) {
+    this.calls.push(["onNavLink", ...args]);
+  }
+
+  serverEvent(...args) {
+    this.calls.push(["serverEvent", ...args]);
+  }
+}
+
+class MockWebSocket {
+  static instances = [];
+
+  constructor(url) {
+    this.url = url;
+    this.send = jest.fn();
+    this.close = jest.fn(() => {
+      if (this.onclose) {
+        this.onclose({ code: 1000, reason: "client-close" });
+      }
+    });
+    MockWebSocket.instances.push(this);
+  }
+
+  emitOpen() {
+    this.onopen && this.onopen();
+  }
+
+  emitMessage(data) {
+    this.onmessage && this.onmessage({ data: JSON.stringify(data) });
+  }
+
+  emitClose(event = { code: 1006, reason: "server-close" }) {
+    this.onclose && this.onclose(event);
+  }
+}
+
+async function loadFreshModules() {
+  jest.resetModules();
+  window.$ = $;
+  global.$ = $;
+  const events = await import("../src/simpleDomControl/sdc_events.js");
+  const serverCall = await import("../src/simpleDomControl/sdc_server_call.js");
+  return { events, serverCall };
+}
+
+async function createEventSink(events) {
+  const sink = new EventSink();
+  ["pushMsg", "pushErrorMsg", "onNavLink", "serverEvent"].forEach((eventName) => {
+    events.setEvent(eventName);
+    events.on(eventName, sink);
+  });
+  return sink;
+}
+
+describe("sdc_server_call", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(FROZEN_NOW);
+    jest.restoreAllMocks();
+    window.CSRF_TOKEN = "csrf-token";
+    window.SERVER_CALL_VIA_WEB_SOCKET = false;
+    MockWebSocket.instances = [];
+    global.WebSocket = MockWebSocket;
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+    delete global.WebSocket;
+  });
+
+  test("posts server calls and forwards success messages", async () => {
+    const { events, serverCall } = await loadFreshModules();
+    const sink = await createEventSink(events);
+    const postSpy = jest.spyOn($, "post").mockImplementation((options) => {
+      const xhr = { setRequestHeader: jest.fn() };
+      options.beforeSend(xhr, options);
+      expect(xhr.setRequestHeader).toHaveBeenCalledWith("X-CSRFToken", "csrf-token");
+      return Promise.resolve({
+        _return_data: {
+          header: "Saved",
+          msg: "Server accepted request",
+          data: { id: 7 },
+        },
+      });
+    });
+
+    const result = await serverCall.callServer(
+      "demo_app",
+      "demo-controller",
+      "/sdc_view/demo_app",
+      "saveItem",
+      { name: "Ada" },
+    );
+
+    expect(postSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: "/sdc_view/demo_app",
+        data: {
+          data: JSON.stringify({ name: "Ada" }),
+          _sdc_func_name: "saveItem",
+          _method: "sdc_server_call",
+        },
+      }),
+    );
+    expect(result).toEqual({
+      header: "Saved",
+      msg: "Server accepted request",
+      data: { id: 7 },
+    });
+    expect(sink.calls).toEqual([["pushMsg", "Saved", "Server accepted request"]]);
+  });
+
+  test("marks failed post responses as errors and forwards error messages", async () => {
+    const { events, serverCall } = await loadFreshModules();
+    const sink = await createEventSink(events);
+    const responseError = {
+      responseJSON: {
+        header: "Invalid",
+        msg: "Payload was rejected",
+      },
+    };
+
+    jest.spyOn($, "post").mockRejectedValue(responseError);
+
+    await expect(
+      serverCall.callServer(
+        "demo_app",
+        "demo-controller",
+        "/sdc_view/demo_app",
+        "saveItem",
+        { bad: true },
+      ),
+    ).rejects.toBe(responseError);
+
+    expect(responseError.responseJSON.is_error).toBe(true);
+    expect(sink.calls).toEqual([["pushErrorMsg", "Invalid", "Payload was rejected"]]);
+  });
+
+  test("sends websocket calls, resolves recalls, and forwards server events", async () => {
+    window.SERVER_CALL_VIA_WEB_SOCKET = true;
+    const { events, serverCall } = await loadFreshModules();
+    const sink = await createEventSink(events);
+
+    const connection = serverCall.isConnected();
+    expect(MockWebSocket.instances).toHaveLength(1);
+    const socket = MockWebSocket.instances[0];
+    expect(socket.url).toBe("ws://localhost/sdc_ws/ws/");
+    socket.emitOpen();
+    await connection;
+
+    const responsePromise = serverCall.callServer(
+      "demo_app",
+      "demo-controller",
+      "/ignored",
+      "loadDashboard",
+      { filter: "recent" },
+    );
+
+    await Promise.resolve();
+
+    expect(socket.send).toHaveBeenCalledTimes(1);
+    const requestPayload = JSON.parse(socket.send.mock.calls[0][0]);
+    expect(requestPayload).toMatchObject({
+      event: "sdc_call",
+      controller: "demo-controller",
+      app: "demo_app",
+      function: "loadDashboard",
+      args: { filter: "recent" },
+    });
+
+    socket.emitMessage({
+      header: "Ready",
+      msg: "Dashboard loaded",
+      type: "sdc_event",
+      event: "serverEvent",
+      payload: { generatedAt: FROZEN_NOW.toISOString() },
+    });
+    socket.emitMessage({
+      id: requestPayload.id,
+      type: "sdc_recall",
+      data: {
+        rows: 3,
+        generatedAt: FROZEN_NOW.toISOString(),
+      },
+    });
+
+    await expect(responsePromise).resolves.toEqual({
+      rows: 3,
+      generatedAt: "2026-04-03T10:15:30.000Z",
+    });
+    expect(sink.calls).toEqual([
+      ["pushMsg", "Ready", "Dashboard loaded"],
+      ["serverEvent", { generatedAt: "2026-04-03T10:15:30.000Z" }],
+    ]);
+  });
+
+  test("forwards websocket redirects through onNavLink", async () => {
+    window.SERVER_CALL_VIA_WEB_SOCKET = true;
+    const { events, serverCall } = await loadFreshModules();
+    const sink = await createEventSink(events);
+
+    const connection = serverCall.isConnected();
+    const socket = MockWebSocket.instances[0];
+    socket.emitOpen();
+    await connection;
+
+    socket.emitMessage({
+      type: "sdc_redirect",
+      link: "/target/path",
+    });
+
+    expect(sink.calls).toEqual([["onNavLink", "/target/path"]]);
+  });
+
+  test("rejects open websocket requests on close and reconnects after one second", async () => {
+    window.SERVER_CALL_VIA_WEB_SOCKET = true;
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+    const { serverCall } = await loadFreshModules();
+
+    const pendingResponse = serverCall.callServer(
+      "demo_app",
+      "demo-controller",
+      "/ignored",
+      "loadDashboard",
+      { filter: "recent" },
+    );
+
+    const firstSocket = MockWebSocket.instances[0];
+    firstSocket.emitOpen();
+    await Promise.resolve();
+
+    firstSocket.emitClose({ code: 1011, reason: "server-failure" });
+
+    await expect(pendingResponse).rejects.toEqual({});
+    expect(consoleErrorSpy).toHaveBeenCalledWith("SDC Socket closed unexpectedly");
+
+    expect(MockWebSocket.instances).toHaveLength(1);
+    jest.advanceTimersByTime(1000);
+    expect(MockWebSocket.instances).toHaveLength(2);
+  });
+});