sdc_client 0.58.5 → 0.158.0

package/test/model.test.js

@@ -0,0 +1,332 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from "@jest/globals";
+import $ from "jquery";
+import { registerModel } from "../src/index.js";
+import Author from "./models/Author.js";
+import Book from "./models/Book.js";
+import BookContent from "./models/BookContent.js";
+import SdcUser from "./models/SdcUser.js";
+
+window.$ = $;
+global.$ = $;
+
+class MockModelSocket {
+  static server = null;
+
+  constructor(url) {
+    this.url = url;
+    this.sentMessages = [];
+    queueMicrotask(() => {
+      this.onopen && this.onopen();
+    });
+  }
+
+  send(rawMessage) {
+    this.sentMessages.push(JSON.parse(rawMessage));
+    MockModelSocket.server.receive(this, JSON.parse(rawMessage));
+  }
+
+  close() {
+    this.onclose && this.onclose({ code: 1000, reason: "client-close" });
+  }
+}
+
+class MockModelSocketServer {
+  constructor() {
+    this.records = {
+      Author: [
+        { pk: 1, id: 1, fields: {name: "Ada Lovelace", age: 36, book_set: [11]} },
+        { pk: 2, id: 2, fields: {name: "Grace Hopper", age: 85, book_set: [21, 22]} },
+      ],
+      Book: [
+        { pk: 11, id: 11, fields: {title: "Notes", author: 1 }},
+        { pk: 21, id: 21, fields: {title: "Compiler Notes", author: 2 }},
+        { pk: 22, id: 22, fields: {title: "COBOL", author: 2 }},
+      ],
+      BookContent: [],
+      SdcUser: [{ pk: 7, id: 7, fields: {username: "tester" }}],
+    };
+  }
+
+  emit(socket, payload) {
+    queueMicrotask(() => {
+      socket.onmessage && socket.onmessage({ data: JSON.stringify(payload) });
+    });
+  }
+
+  receive(socket, message) {
+    const { event_type: eventType, event_id: eventId, args } = message;
+
+    if (eventType === "connect") {
+      this.emit(socket, {
+        type: "connect",
+        event_id: eventId,
+        args: {},
+      });
+      return;
+    }
+
+    if (eventType === "load") {
+      const rows = this.filterRows(args.model_name, args.model_query);
+      this.emit(socket, {
+        type: "load",
+        event_id: eventId,
+        args: {
+          data: JSON.stringify(rows),
+        },
+      });
+      return;
+    }
+
+    if (eventType === "save") {
+      const saved = this.saveRow(args.model_name, args.data);
+      this.emit(socket, {
+        event_id: eventId,
+        data: {
+          instance: JSON.stringify([saved]),
+        },
+      });
+      return;
+    }
+
+    if (eventType === "create") {
+      const created = this.createRow(args.model_name, args.data);
+      this.emit(socket, {
+        event_id: eventId,
+        data: {
+          instance: JSON.stringify([created]),
+        },
+      });
+    }
+  }
+
+  filterRows(modelName, query = {}) {
+    return this.records[modelName].filter((row) =>
+      Object.entries(query || {}).every(([key, value]) => row[key] === value || row.fields[key] === value),
+    );
+  }
+
+  saveRow(modelName, data) {
+    const records = this.records[modelName];
+    const id = data.pk ?? data.id;
+    const idx = records.findIndex((row) => row.id === id);
+
+    records[idx].fields = {
+      ...records[idx].fields,
+      ...data
+    };
+    return records[idx];
+  }
+
+  createRow(modelName, data) {
+    const records = this.records[modelName];
+    const newId = Math.max(0, ...records.map((row) => row.id ?? 0)) + 1;
+    if (data.hasOwnProperty('id')) {
+      delete data.id;
+    }
+    const created = {
+      fields: {...data},
+      id: newId,
+    };
+
+    records.push(created);
+    return created;
+  }
+}
+
+describe("model fixtures", () => {
+  beforeAll(() => {
+    registerModel("Author", Author);
+    registerModel("Book", Book);
+    registerModel("BookContent", BookContent);
+    registerModel("SdcUser", SdcUser);
+  });
+
+  beforeEach(() => {
+    window.location.host = "localhost";
+    window.location.protocol = "http:";
+    MockModelSocket.server = new MockModelSocketServer();
+    global.WebSocket = MockModelSocket;
+    jest.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    $("body").empty();
+    delete global.WebSocket;
+  });
+
+  test("Author stores scalar fields and related book ids from fixture payloads", () => {
+    const author = new Author({
+      id: 3,
+      name: "Ada Lovelace",
+      age: 36,
+      book_set: [11, 15],
+    });
+
+    expect(author.id).toBe(3);
+    expect(author.name).toBe("Ada Lovelace");
+    expect(author.age).toBe(36);
+    expect(author.book_set.getIds()).toEqual([11, 15]);
+    expect(author.book_set.modelName).toBe("Book");
+  });
+
+  test("Book serializes many-to-one relations as a single related id", () => {
+    const book = new Book({
+      id: 8,
+      title: "Analytical Engine Notes",
+    });
+
+    book.author = 3;
+
+    expect(book.author.id).toBe(3);
+    expect(book.serialize()).toEqual({
+      id: 8,
+      title: "Analytical Engine Notes",
+      author: 3,
+    });
+  });
+
+  test("Author serializes one-to-many relations as an id list", () => {
+    const author = new Author({
+      id: 5,
+      name: "Grace Hopper",
+      age: 85,
+    });
+    const firstBook = new Book({ id: 21, title: "Compiler Notes" });
+    const secondBook = new Book({ id: 22, title: "COBOL" });
+
+    firstBook.author = 5;
+    secondBook.author = 5;
+    author.book_set.valuesList = [firstBook, secondBook];
+
+    expect(author.serialize()).toEqual({
+      book_set: [21, 22],
+      id: 5,
+      name: "Grace Hopper",
+      age: 85,
+    });
+  });
+
+  test("syncModelToForm copies model values into matching form elements", () => {
+    const author = new Author({
+      id: 9,
+      name: "Margaret Hamilton",
+      age: 33,
+    });
+    const $form = $(`
+      <form class="${author.formId}">
+        <input name="name" value="" />
+        <input name="age" value="" />
+      </form>
+    `).data("model_pk", 9);
+
+    $("body").append($form);
+    author.syncModelToForm($form);
+
+    expect($form.find("[name=name]").val()).toBe("Margaret Hamilton");
+    expect($form.find("[name=age]").val()).toBe("33");
+  });
+
+  test("syncForm parses hidden ids and file uploads into the model", () => {
+    const content = new BookContent();
+    const file = new File(["chapter"], "chapter.txt", { type: "text/plain" });
+    const $form = $(`
+      <form class="${content.formId}">
+        <input type="hidden" name="user" value="7" />
+        <input type="file" name="text" />
+      </form>
+    `).data("model_pk", -1);
+    const fileInput = $form.find("[name=text]")[0];
+
+    Object.defineProperty(fileInput, "files", {
+      configurable: true,
+      value: [file],
+    });
+
+    $("body").append($form);
+    const result = content.syncForm($form);
+
+    expect(result.user).toBe(7);
+    expect(result.text).toBe(file);
+    expect(content.user.id).toBe(7);
+    expect(content.text).toBe(file);
+  });
+
+  test("fixture validation still rejects invalid required values", () => {
+    const author = new Author();
+
+    expect(() => {
+      author.name = "";
+    }).toThrow("This field is required");
+  });
+
+  test("queryset load receives rows through the mocked socket receiver", async () => {
+    const books = new Author({ id: 2 }).book_set;
+
+    const result = await books.load();
+
+    expect(result).toMatchObject({
+      type: "load",
+    });
+    expect(books.getIds()).toEqual([21, 22]);
+    expect(books[0].title).toBe("Compiler Notes");
+    expect(books[1].author.id).toBe(2);
+    expect(books.socket.sentMessages.map((x) => x.event_type)).toEqual([
+      "connect",
+      "load",
+    ]);
+  });
+
+  test("queryset save sends model payloads and updates cached rows from the socket response", async () => {
+    const books = new Author({ id: 2 }).book_set;
+
+    await books.load({ author: 2 });
+    books[0].title = "Compiler Notes Revised";
+
+    const [response] = await books.save({ pk: 21 });
+
+    expect(response.data.instance).toHaveLength(1);
+    expect(response.data.instance[0].title).toBe("Compiler Notes Revised");
+    expect(books.byId(21).title).toBe("Compiler Notes Revised");
+    expect(books.socket.sentMessages.at(-1)).toMatchObject({
+      event_type: "save",
+      args: {
+        pk: 21,
+        data: {
+          id: 21,
+          title: "Compiler Notes Revised",
+          author: 2,
+          pk: 21,
+        },
+      },
+    });
+  });
+
+  test("queryset create uses the mocked socket receiver to append new rows", async () => {
+    const books = new Author({ id: 2 }).book_set;
+    const newBook = new Book({
+      title: "New Language Manual",
+    });
+
+    newBook.author = 2;
+
+    const response = await books.create({ elem: newBook });
+
+    expect(response.data.instance.id).toBe(23);
+    expect(response.data.instance.title).toBe("New Language Manual");
+    expect(books.byId(23).author.id).toBe(2);
+    expect(books.socket.sentMessages.at(-1)).toMatchObject({
+      event_type: "create",
+      args: {
+        data: {
+          id: null,
+          title: "New Language Manual",
+          author: 2,
+        },
+      },
+    });
+  });
+});

package/test/models/Author.js

@@ -0,0 +1,145 @@
+import {SdcModel, SdcQuerySet} from '../../src/index.js';
+
+export default class Author extends SdcModel {
+
+
+  static fields = {
+      "book_set": {
+        "type": "ForeignKey",
+        "required": false,
+        "max_length": null,
+        "is_relation": true,
+        "many_to_many": false,
+        "one_to_many": true,
+        "many_to_one": false,
+        "one_to_one": false,
+        "related_model": "Book",
+        "remote_field": "author"
+      },
+      "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
+      },
+      "name": {
+        "type": "CharField",
+        "required": true,
+        "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
+      },
+      "age": {
+        "type": "IntegerField",
+        "required": true,
+        "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
+      }
+    }
+
+  constructor(data = {}) {
+    super("Author");
+    this._toManyFields = [];
+    this._book_set = new SdcQuerySet('Book');
+    this._toManyFields.push([this._book_set, 'author']);
+    this._id = null;
+    this._name = null;
+    this._age = null;
+    this.setValues(data);
+  }
+
+  setValues(data = {}) {
+    data.id ??= data.pk ?? null;
+    try {
+    this.book_set.setFilter({ author:  data.id });
+    this.book_set = data.book_set || [];
+    } catch {} 
+    try {
+      this.id = data.id ?? null;
+    } catch {} 
+    try {
+      this.name = data.name ?? null;
+    } catch {} 
+    try {
+      this.age = data.age ?? null;
+    } catch {} 
+  }
+
+  set book_set(value){
+    this.setbook_set(value);
+    this._updateForm('book_set');
+  }
+
+  set id(value){
+    this.setid(value);
+    this._updateForm('id');
+  }
+
+  set name(value){
+    this.setname(value);
+    this._updateForm('name');
+  }
+
+  set age(value){
+    this.setage(value);
+    this._updateForm('age');
+  }
+
+
+  setbook_set(value){
+    this.validate(value, Author.fields.book_set);
+    const a = this.parseValue(value, Author.fields.book_set)
+    this._book_set.setIds(this.parseValue(value, Author.fields.book_set));
+  }
+
+  setid(value){
+    this.validate(value, Author.fields.id);
+    this._toManyFields.forEach(([x, fn]) => x.setFilter({[fn]: value}));
+    this._id = this.parseValue(value, Author.fields.id);
+  }
+
+  setname(value){
+    this.validate(value, Author.fields.name);
+    this._name = this.parseValue(value, Author.fields.name);
+  }
+
+  setage(value){
+    this.validate(value, Author.fields.age);
+    this._age = this.parseValue(value, Author.fields.age);
+  }
+
+
+  get book_set(){
+    return this._book_set;
+  }
+
+  get id(){
+    return this._id;
+  }
+
+  get name(){
+    return this._name;
+  }
+
+  get age(){
+    return this._age;
+  }
+
+}

package/test/models/Book.js

@@ -0,0 +1,112 @@
+import {SdcModel, SdcQuerySet} from '../../src/index.js';
+
+export default class Book 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
+      },
+      "title": {
+        "type": "CharField",
+        "required": true,
+        "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
+      },
+      "author": {
+        "type": "ForeignKey",
+        "required": true,
+        "max_length": null,
+        "is_relation": true,
+        "many_to_many": false,
+        "one_to_many": false,
+        "many_to_one": true,
+        "one_to_one": false,
+        "related_model": "Author",
+        "remote_field": "book"
+      }
+    }
+
+  constructor(data = {}) {
+    super("Book");
+    this._toManyFields = [];
+    this._id = null;
+    this._title = null;
+    this._author = new SdcQuerySet('Author');
+    this.setValues(data);
+  }
+
+  setValues(data = {}) {
+    data.id ??= data.pk ?? null;
+    try {
+      this.id = data.id ?? null;
+    } catch {} 
+    try {
+      this.title = data.title ?? null;
+    } catch {} 
+    try {
+      if (data.author) { this.author = data.author; }
+    } catch {} 
+  }
+
+  set id(value){
+    this.setid(value);
+    this._updateForm('id');
+  }
+
+  set title(value){
+    this.settitle(value);
+    this._updateForm('title');
+  }
+
+  set author(value){
+    this.setauthor(value);
+    this._updateForm('author');
+  }
+
+
+  setid(value){
+    this.validate(value, Book.fields.id);
+    this._toManyFields.forEach(([x, fn]) => x.setFilter({[fn]: value}));
+    this._id = this.parseValue(value, Book.fields.id);
+  }
+
+  settitle(value){
+    this.validate(value, Book.fields.title);
+    this._title = this.parseValue(value, Book.fields.title);
+  }
+
+  setauthor(value){
+    this.validate(value, Book.fields.author);
+    this._author.setIds(this.parseValue(value, Book.fields.author));
+  }
+
+
+  get id(){
+    return this._id;
+  }
+
+  get title(){
+    return this._title;
+  }
+
+  get author(){
+    return this._author.length > 0 ? this._author[0] : this._author.new();
+  }
+
+}

package/test/models/BookContent.js

@@ -0,0 +1,114 @@
+import {SdcModel, SdcQuerySet} from '../../src/index.js';
+
+export default class BookContent 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
+      },
+      "user": {
+        "type": "ForeignKey",
+        "required": false,
+        "max_length": null,
+        "is_relation": true,
+        "many_to_many": false,
+        "one_to_many": false,
+        "many_to_one": true,
+        "one_to_one": false,
+        "related_model": "SdcUser",
+        "remote_field": "bookcontent"
+      },
+      "text": {
+        "type": "FileField",
+        "required": true,
+        "max_length": 100,
+        "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,
+        "max_size": 5368709120,
+        "allowed_types": null
+      }
+    }
+
+  constructor(data = {}) {
+    super("BookContent");
+    this._toManyFields = [];
+    this._id = null;
+    this._user = new SdcQuerySet('SdcUser');
+    this._text = null;
+    this.setValues(data);
+  }
+
+  setValues(data = {}) {
+    data.id ??= data.pk ?? null;
+    try {
+      this.id = data.id ?? null;
+    } catch {} 
+    try {
+      if (data.user) { this.user = data.user; }
+    } catch {} 
+    try {
+      this.text = data.text ?? null;
+    } catch {} 
+  }
+
+  set id(value){
+    this.setid(value);
+    this._updateForm('id');
+  }
+
+  set user(value){
+    this.setuser(value);
+    this._updateForm('user');
+  }
+
+  set text(value){
+    this.settext(value);
+    this._updateForm('text');
+  }
+
+
+  setid(value){
+    this.validate(value, BookContent.fields.id);
+    this._toManyFields.forEach(([x, fn]) => x.setFilter({[fn]: value}));
+    this._id = this.parseValue(value, BookContent.fields.id);
+  }
+
+  setuser(value){
+    this.validate(value, BookContent.fields.user);
+    this._user.setIds(this.parseValue(value, BookContent.fields.user));
+  }
+
+  settext(value){
+    this.validate(value, BookContent.fields.text);
+    this._text = this.parseValue(value, BookContent.fields.text);
+  }
+
+
+  get id(){
+    return this._id;
+  }
+
+  get user(){
+    return this._user.length > 0 ? this._user[0] : this._user.new();
+  }
+
+  get text(){
+    return this._text;
+  }
+
+}