@garrix82/reactgenie-dsl 1.0.0

package/lib/decorators/__test__/decorators.test.ts

@@ -0,0 +1,177 @@
+import "../decorators";
+import * as assert from "assert";
+import {
+  ClassDescriptor,
+  FieldDescriptor,
+  FuncDescriptor,
+  DataClass, HelperClass, GenieObject
+} from "../../dsl-descriptor";
+import {GenieClass, GenieKey, GenieProperty, initGenie} from "../decorators";
+import {
+  DateTime,
+  Food,
+  Order,
+  Restaurant,
+} from "../../__test__/example_descriptor";
+import {genieDispatch} from "../store";
+
+initGenie();
+
+function essentialFuncDescriptor(original: FuncDescriptor) {
+  return {
+    name: original.func_name,
+    // comment: original.comment, // don't compare comments
+    params: original.parameters,
+    returnType: original.returnType,
+    isStatic: original.isStatic,
+  };
+}
+
+function essentialFieldDescriptor(original: FieldDescriptor) {
+  return {
+    name: original.field,
+    // comment: original.comment, // don't compare comments
+    type: original.fieldType,
+    isStatic: original.isStatic,
+  };
+}
+
+function sortDescriptor(a: { name: string }, b: { name: string }) {
+  return a.name.localeCompare(b.name);
+}
+
+function compareClassDescriptor(
+  a: ClassDescriptor<GenieObject>,
+  b: ClassDescriptor<GenieObject>
+) {
+  assert.equal(a.className, b.className);
+  assert.equal(a.classConstructor, b.classConstructor);
+  assert.equal(a.functions.size, b.functions.size);
+  assert.equal(a.fields.size, b.fields.size);
+  expect(
+    Array.from(a.functions).map(essentialFuncDescriptor).sort(sortDescriptor)
+  ).toEqual(
+    Array.from(b.functions).map(essentialFuncDescriptor).sort(sortDescriptor)
+  );
+  expect(
+    Array.from(a.fields).map(essentialFieldDescriptor).sort(sortDescriptor)
+  ).toEqual(
+    Array.from(b.fields).map(essentialFieldDescriptor).sort(sortDescriptor)
+  );
+}
+test("Restaurant Descriptor", async () => {
+  compareClassDescriptor(
+    Restaurant.ClassDescriptor,
+    Restaurant._ClassDescriptor
+  );
+  Restaurant.all();
+  const restaurant1 = Restaurant.GetObject({ name: "McDonald's" });
+  const restaurant2 = Restaurant.GetObject({ name: "McDonald's" });
+  restaurant2.rating = 5;
+  assert.equal(restaurant1.rating, 5);
+  restaurant2.rating = 3;
+  assert.equal(restaurant1.rating, 3);
+});
+
+test("Food Descriptor", async () => {
+  console.log("Food descriptor", Food.ClassDescriptor);
+  console.log("Food descriptor", Food._ClassDescriptor);
+  compareClassDescriptor(Food.ClassDescriptor, Food._ClassDescriptor);
+  Restaurant.all();
+  Food.all();
+  const foodItem1 = Food.GetObject({ name: "Hamburger" });
+  const foodItem2 = Food.GetObject({ name: "Hamburger" });
+  foodItem2.price = 6.99;
+  assert.equal(foodItem1.price, 6.99);
+  foodItem2.price = 5.99;
+  assert.equal(foodItem1.price, 5.99);
+});
+
+test("Order Descriptor", async () => {
+  compareClassDescriptor(Order.ClassDescriptor, Order._ClassDescriptor);
+  Restaurant.all();
+  Order.all();
+  const order1 = Order.GetObject({ orderId: 1 });
+  const order2 = Order.GetObject({ orderId: 1 });
+  order2.dateTime = DateTime.CreateObject({
+    year: 2023,
+    month: 1,
+    day: 1,
+    hour: 13,
+    minute: 0,
+  });
+  assert.equal(
+    order1.dateTime.toString(),
+    new DateTime({
+      year: 2023,
+      month: 1,
+      day: 1,
+      hour: 13,
+      minute: 0,
+    }).toString()
+  );
+  order2.dateTime =  DateTime.CreateObject({
+    year: 2023,
+    month: 1,
+    day: 2,
+    hour: 13,
+    minute: 0,
+  });
+  assert.equal(
+    order1.dateTime.toString(),
+    new DateTime({
+      year: 2023,
+      month: 1,
+      day: 2,
+      hour: 13,
+      minute: 0,
+    }).toString()
+  );
+});
+
+@GenieClass("To-do list item")
+class TodoListItem extends HelperClass {
+  @GenieProperty("Name of the item")
+  name: string;
+  @GenieProperty("Whether the item is done")
+  done: boolean;
+
+  constructor({name, done}: {name: string, done: boolean}) {
+    super({});
+    this.name = name;
+    this.done = done;
+  }
+}
+
+@GenieClass("To-do list")
+class TodoList extends DataClass {
+  @GenieKey
+  @GenieProperty("Name of the list")
+  name: string;
+  @GenieProperty("Items in the list")
+  items: TodoListItem[];
+
+  constructor({name, items}: {name: string, items: TodoListItem[]}) {
+    super({});
+    this.name = name;
+    this.items = items;
+  }
+
+  static setup() {
+    TodoList.CreateObject({name: "Groceries", items: [
+        TodoListItem.CreateObject({name: "Milk", done: false}),
+        TodoListItem.CreateObject({name: "Eggs", done: false}),
+        TodoListItem.CreateObject({name: "Bread", done: false}),
+        ]});
+  }
+}
+
+test("Change TodoList", async () => {
+  genieDispatch(() => {
+    const groceriesList = TodoList.GetObject({ name: "Groceries" });
+    const item = groceriesList.items[0];
+    item.done = true;
+    const groceriesListItems = groceriesList.items;
+    groceriesListItems.push(TodoListItem.CreateObject({name: "Butter", done: false}));
+  });
+});

package/lib/decorators/__test__/inheritance-descriptor.test.ts

@@ -0,0 +1,92 @@
+import "..";
+import { GenieClass, GenieFunction, GenieProperty } from "..";
+import { HelperClass } from "../../dsl-descriptor";
+
+@GenieClass("Parent helper")
+class ParentHelper extends HelperClass {
+  @GenieProperty("Parent field")
+  parentField: string;
+
+  constructor({ parentField = "parent" }: { parentField?: string } = {}) {
+    super({});
+    this.parentField = parentField;
+  }
+
+  @GenieFunction("Parent instance method")
+  parentInstance(): ParentHelper {
+    return this;
+  }
+
+  @GenieFunction("Parent static method")
+  static parentStatic(): ParentHelper {
+    return ParentHelper.CreateObject({ parentField: "from-parent-static" });
+  }
+}
+
+@GenieClass("Child helper")
+class ChildHelper extends ParentHelper {
+  @GenieProperty("Child field")
+  childField: string;
+
+  constructor({
+    parentField = "parent",
+    childField = "child",
+  }: {
+    parentField?: string;
+    childField?: string;
+  } = {}) {
+    super({ parentField });
+    this.childField = childField;
+  }
+
+  @GenieFunction("Child instance method")
+  childInstance(): ChildHelper {
+    return this;
+  }
+
+  @GenieFunction("Child static method")
+  static childStatic(): ChildHelper {
+    return ChildHelper.CreateObject({
+      parentField: "from-child-static",
+      childField: "from-child-static",
+    });
+  }
+}
+
+describe("Genie descriptor inheritance isolation", () => {
+  test("creates an own ClassDescriptor for subclass and keeps parent descriptor clean", () => {
+    expect(Object.prototype.hasOwnProperty.call(ParentHelper, "ClassDescriptor")).toBe(true);
+    expect(Object.prototype.hasOwnProperty.call(ChildHelper, "ClassDescriptor")).toBe(true);
+
+    expect(ParentHelper.ClassDescriptor.className).toBe("ParentHelper");
+    expect(ChildHelper.ClassDescriptor.className).toBe("ChildHelper");
+
+    const parentFunctions = Array.from(ParentHelper.ClassDescriptor.functions).map(
+      (func: any) => func.func_name
+    );
+    expect(parentFunctions).toContain("parentInstance");
+    expect(parentFunctions).toContain("parentStatic");
+    expect(parentFunctions).not.toContain("childInstance");
+    expect(parentFunctions).not.toContain("childStatic");
+
+    const childFunctions = Array.from(ChildHelper.ClassDescriptor.functions).map(
+      (func: any) => func.func_name
+    );
+    expect(childFunctions).toContain("parentInstance");
+    expect(childFunctions).toContain("parentStatic");
+    expect(childFunctions).toContain("childInstance");
+    expect(childFunctions).toContain("childStatic");
+
+    const parentFields = Array.from(ParentHelper.ClassDescriptor.fields).map(
+      (field: any) => field.field
+    );
+    expect(parentFields).toContain("parentField");
+    expect(parentFields).not.toContain("childField");
+
+    const childFields = Array.from(ChildHelper.ClassDescriptor.fields).map(
+      (field: any) => field.field
+    );
+    expect(childFields).toContain("parentField");
+    expect(childFields).toContain("childField");
+  });
+});