@gisce/ooui 0.1.0

package/src/spec/Selection.spec.ts

@@ -0,0 +1,52 @@
+import WidgetFactory from "../WidgetFactory";
+
+describe("A Selection", () => {
+  it("should have an id corresponding to field name", () => {
+    const widgetFactory = new WidgetFactory();
+    const props = {
+      name: "selection1",
+    };
+
+    const widget = widgetFactory.createWidget("selection", props);
+
+    expect(widget.id).toBe("selection1");
+  });
+
+  it("should properly set label", () => {
+    const widgetFactory = new WidgetFactory();
+    const props = {
+      name: "selection1",
+      string: "Language",
+    };
+    const widget = widgetFactory.createWidget("selection", props);
+
+    expect(widget.label).toBe("Language");
+  });
+
+  it("should properly set size", () => {
+    const widgetFactory = new WidgetFactory();
+    const props = {
+      name: "selection1",
+      size: 5,
+    };
+    const widget = widgetFactory.createWidget("selection", props);
+
+    expect(widget.size).toBe(5);
+  });
+
+  it("should parse selection values", () => {
+    const widgetFactory = new WidgetFactory();
+    const props = {
+      name: "selection1",
+      selection: [
+        ["en_US", "English"],
+        ["ca_ES", "Catalan / Català"],
+        ["es_ES", "Spanish / Español"],
+        ["", ""],
+      ],
+    };
+    const widget = widgetFactory.createWidget("selection", props);
+
+    expect(widget.selectionValues.size).toBe(4);
+  });
+});

package/src/spec/Separator.spec.ts

@@ -0,0 +1,14 @@
+import WidgetFactory from "../WidgetFactory";
+
+describe("A Separator", () => {
+  it("should have an id corresponding to field name", () => {
+    const widgetFactory = new WidgetFactory();
+    const props = {
+      string: "Text",
+    };
+
+    const widget = widgetFactory.createWidget("separator", props);
+
+    expect(widget.label).toBe("Text");
+  });
+});

package/src/spec/Tree.spec.ts

@@ -0,0 +1,214 @@
+import Tree from "../Tree";
+import Char from "../Char";
+
+const XML_VIEW_TREE = `<tree string="Partners">
+  <field name="name"/>
+  <field name="title"/>
+  <field name="ref"/>
+  <field name="city" select="2"/>
+  <field name="country" select="2"/>
+  <field name="lang"/>
+</tree>
+`;
+
+const FIELDS = {
+  city: {
+    digits: [16, 2],
+    string: "City",
+    type: "char",
+    views: {},
+  },
+  country: {
+    context: "",
+    digits: [16, 2],
+    domain: [],
+    relation: "res.country",
+    string: "Country",
+    type: "many2one",
+    views: {},
+  },
+  lang: {
+    help:
+      "If the selected language is loaded in the system, all documents related to this partner will be printed in this language. If not, it will be english.",
+    selection: [
+      ["en_US", "English"],
+      ["ca_ES", "Catalan / Català"],
+      ["es_ES", "Spanish / Español"],
+      ["", ""],
+    ],
+    size: 5,
+    string: "Language",
+    type: "selection",
+    views: {},
+  },
+  name: {
+    required: true,
+    select: true,
+    size: 128,
+    string: "Name",
+    type: "char",
+    views: {},
+  },
+  ref: {
+    select: true,
+    size: 64,
+    string: "Code",
+    type: "char",
+    views: {},
+  },
+  title: {
+    selection: [
+      ["Corp.", "Corp."],
+      ["ltd", "Ltd"],
+      ["", ""],
+    ],
+    size: 32,
+    string: "Title",
+    type: "selection",
+    views: {},
+  },
+};
+describe("A Tree", () => {
+  it("should parse xml", () => {
+    const tree = new Tree(FIELDS);
+    tree.parse(XML_VIEW_TREE);
+
+    expect(tree.fields).toBeDefined();
+    expect(tree.columns.length).toBe(6);
+    const nameWidget = tree.findById("name") as Char;
+    expect(nameWidget.label).toBe("Name");
+  });
+  it("Must throw an error if a field isn't present in field definitions", () => {
+    const parseInvalidTree = () => {
+      const tree = new Tree({});
+      tree.parse(`<tree string="Partners"><field name="name"/></tree>`);
+    };
+
+    expect(parseInvalidTree).toThrow(
+      "Field name doesn't exist in fields defintion"
+    );
+  });
+
+  it("Should parse tree string title properly", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(`<tree string="Partners"><field name="name"/></tree>`);
+    const treeTitle = tree.string;
+    expect(treeTitle).toBe("Partners");
+  });
+
+  it("Should parse tree string title as null if we don't pass it", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(`<tree><field name="name"/></tree>`);
+    const treeTitle = tree.string;
+    expect(treeTitle).toBeNull();
+  });
+
+  it("Should be able to retrieve type from Tree instance", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(`<tree><field name="name"/></tree>`);
+    expect(tree.type).toBe("tree");
+  });
+
+  it("Must parse colors", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(
+      `<tree string="Partners" colors="red:type=='updated'"><field name="name"/></tree>`
+    );
+    expect(tree.colors!).toBe("red:type=='updated'");
+  });
+
+  it("Must parse sum fields", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(
+      `<tree string="Partners" colors="red:type=='updated'"><field name="name" sum="Name" /></tree>`
+    );
+    const nameWidget = tree.findById("name") as Char;
+    expect(nameWidget.sum).toBe("Name");
+  });
+
+  it("Must ignore invisible fields as columns", () => {
+    const tree = new Tree({
+      name: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Name",
+        type: "char",
+        views: {},
+      },
+      surnames: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "Surnames",
+        type: "char",
+        views: {},
+        invisible: true,
+      },
+      city: {
+        required: true,
+        select: true,
+        size: 128,
+        string: "City",
+        type: "char",
+        views: {},
+      },
+    });
+    tree.parse(
+      `<tree string="Partners" colors="red:type=='updated'"><field name="name" sum="Name" invisible="1" /><field name="surnames" sum="Surnames" /><field name="city" sum="City" /></tree>`
+    );
+
+    const nameWidget = tree.findById("name") as Char;
+    const surnamesWidget = tree.findById("surnames") as Char;
+    const cityWidget = tree.findById("city") as Char;
+
+    expect(nameWidget).toBeUndefined();
+    expect(surnamesWidget).toBeUndefined();
+    expect(cityWidget!.id).toBe("city");
+  });
+});

package/src/spec/Widget.spec.ts

@@ -0,0 +1,45 @@
+import Widget from "../Widget";
+import WidgetImpl from "./fixtures/WidgetImpl";
+
+describe('A Widget', () => {
+    it('should be constructed with a colspan by default', () => {
+        const widget = new WidgetImpl();
+        
+        expect(widget.colspan).toBe(Widget.defaultColspan);
+    });
+
+    it("should have colspan 1 by default", () => {
+        const widget = new WidgetImpl();
+        expect(widget.colspan).toBe(1);
+    });
+
+    it('should properly set colspan', () => {
+        const widget = new WidgetImpl();
+        widget.colspan = 3;
+
+        expect(widget.colspan).toBe(3);
+    });
+
+    it('should be readOnly false by default', () => {
+        const widget = new WidgetImpl();
+
+        expect(widget.readOnly).toBe(false);
+    });
+
+    it('colspan should be of type Number', () => {
+        const widget = new WidgetImpl();
+
+        expect(typeof widget.colspan).toBe("number");
+    });
+
+    /*
+    it('set colspan as string should store as a number', () => {
+        const widget = new WidgetImpl();
+
+        widget.colspan = "3";
+        
+        expect(typeof widget.colspan).toBe("number");
+        expect(widget.colspan).toBe(3);
+    });
+    */
+});

package/src/spec/WidgetFactory.spec.ts

@@ -0,0 +1,40 @@
+import Char from "../Char";
+import Button from "../Button";
+import NewLine from "../NewLine";
+import WidgetFactory from "../WidgetFactory";
+
+
+describe('A WidgetFactory', () => {
+    it('should be able to build a Char widget', () => {
+        const widgetFactory = new WidgetFactory();
+        const props = {
+            name: "char1",
+        };
+        const widget = widgetFactory.createWidget("char", props);
+        expect(widget).toBeInstanceOf(Char);
+    });
+
+    it('should be able to build a Button widget', () => {
+        const widgetFactory = new WidgetFactory();
+        const props = {
+            name: "button1"
+        };
+        const widget = widgetFactory.createWidget("button", props);
+        expect(widget).toBeInstanceOf(Button);
+    });
+
+    it('should be able to build a Newline widget', () => {
+        const widgetFactory = new WidgetFactory();
+        const props = {};
+        const widget = widgetFactory.createWidget("newline", props);
+        expect(widget).toBeInstanceOf(NewLine);
+    });
+
+    it('should be able to retrieve widget type', () => {
+        const widgetFactory = new WidgetFactory();
+        const props = {};
+        const widget = widgetFactory.createWidget("newline", props);
+        expect(widget).toBeInstanceOf(NewLine);
+        expect(widget.type).toBe("newline");
+    });
+});

package/src/spec/attributeParser.spec.ts

@@ -0,0 +1,173 @@
+import { evaluateAttributes } from "../helpers/attributeParser";
+
+const fields = {
+  force_potencia_adscrita: {
+    type: "boolean",
+  },
+  per_enviar: {
+    type: "char",
+  },
+  rectificative_type: {
+    type: "char",
+  },
+  in_refund: {
+    type: "char",
+  },
+  check_total: {
+    type: "float",
+  },
+  type: {
+    type: "char",
+  },
+  id: {
+    type: "integer",
+  },
+  link: {
+    type: "char",
+  },
+  change_adm: {
+    type: "boolean",
+  },
+};
+
+describe("An Attribute Parser", () => {
+  describe("in evaluateAttributes method", () => {
+    it("should properly parse a simple attribute with = operator", () => {
+      const tagAttributes = {
+        attrs: "{'invisible':[('per_enviar', '=', 'postal')]}",
+      };
+      const values = {
+        per_enviar: "postal",
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+    it("should properly parse a simple attribute with == operator and numeric value", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('check_total', '==',0.00)]}",
+      };
+      const values = {
+        check_total: 0.0,
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+    it("should properly parse a simple attribute with 'in' operator", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('rectificative_type', 'in', ('N', 'C', 'G'))]}",
+      };
+      const values = {
+        rectificative_type: "G",
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+    it("should properly parse a simple attribute with 'not_in' operator", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('type','not in',('in_refund','in_invoice'))]}",
+      };
+      const values = {
+        type: "not_found_type",
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+    it("should properly parse a boolean attribute with '=' operator", () => {
+      const tagAttributes = {
+        attrs: "{'readonly':[('force_potencia_adscrita','=',0)]}",
+      };
+      const values = {
+        force_potencia_adscrita: false,
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.readonly).toBeTruthy();
+    });
+    it("should properly parse a boolean attribute with '=' operator", () => {
+      const tagAttributes = {
+        attrs: "{'readonly':[('force_potencia_adscrita','=',0)]}",
+      };
+      const values = {
+        force_potencia_adscrita: true,
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.readonly).toBeFalsy();
+    });
+    it("should properly parse a boolean attribute with '=' operator with True", () => {
+      const tagAttributes = {
+        attrs: "{'readonly':[('force_potencia_adscrita','=',True)]}",
+      };
+      const values = {
+        force_potencia_adscrita: true,
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.readonly).toBeTruthy();
+    });
+    it("should properly parse a boolean attribute with several conditions", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('id', '!=', False), ('link', '!=', False)]}",
+      };
+      const values = {
+        id: 1,
+        link: false,
+      };
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeFalsy();
+    });
+    it("should properly parse a boolean attribute without value (default false)", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('change_adm', '!=', True)]}",
+      };
+      const values = {};
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+    it("should properly parse a boolean attribute without value (default true)", () => {
+      const tagAttributes = {
+        attrs: "{'invisible': [('change_adm', '=', False)]}",
+      };
+      const values = {};
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields,
+      });
+      expect(evaluatedAttrs.invisible).toBeTruthy();
+    });
+  });
+});

package/src/spec/contextParser.spec.ts

@@ -0,0 +1,57 @@
+import { parseContext } from "../helpers/contextParser";
+
+describe("A Context Parser", () => {
+  describe("in parseContext method", () => {
+    it("should properly parse a blank context", () => {
+      const str = "";
+
+      const parsedContext = parseContext({ context: str });
+
+      expect(parsedContext).toBeUndefined();
+    });
+
+    it("should properly parse a context", () => {
+      const context =
+        "{'power': potencia, 'tarifa_id': tarifa, 'o2m': tensio_o2m, 'tensio_id': tensio_normalitzada, 'model': 'giscedata.polissa', 'field': 'potencia'}";
+      const values = {
+        potencia: 45,
+        tarifa: "test",
+        tensio_normalitzada: [43, "Test"],
+        tensio_o2m: [
+          { operation: "original", id: 1 },
+          { operation: "original", id: 2 },
+        ],
+      };
+      const fields = {
+        potencia: {
+          type: "float",
+        },
+        tarifa: {
+          type: "char",
+        },
+        tensio_normalitzada: {
+          type: "many2one",
+        },
+        tensio_o2m: {
+          type: "one2many",
+        },
+      };
+
+      const parsedContext: any = parseContext({ context, values, fields });
+      expect(parsedContext!["power"]).toBe(45);
+      expect(parsedContext!["tarifa_id"]).toBe("test");
+      expect(parsedContext!["tensio_id"]).toBe(43);
+      expect(parsedContext!["o2m"][0]).toBe(1);
+      expect(parsedContext!["o2m"][1]).toBe(2);
+    });
+
+    it("should properly parse a boolean context", () => {
+      const str = "{'active_test': False}";
+
+      const parsedContext = parseContext({ context: str });
+
+      expect(parsedContext!["active_test"]).toBeDefined();
+      expect(parsedContext!["active_test"]).toBeFalsy();
+    });
+  });
+});

package/src/spec/domainParser.spec.ts

@@ -0,0 +1,40 @@
+import { transformDomainForChildWidget } from "../helpers/domainParser";
+
+describe("A Domain Parser", () => {
+  it("should properly transform domain for inner widgets", () => {
+    const prevDomain = [
+      ["project_id", "=", 62],
+      ["foo", "=", "bar"],
+      ["stage_id.name.process", "ilike", "backlog"],
+    ];
+
+    const fields = {
+      project_id: {
+        type: "numeric",
+      },
+      stage_id: {
+        type: "numeric",
+      },
+    };
+
+    const domainForProjectId = transformDomainForChildWidget({
+      domain: prevDomain,
+      widgetFieldName: "project_id",
+    }) as any;
+
+    expect(domainForProjectId!.length).toBe(1);
+    expect(domainForProjectId![0][0]).toBe("id");
+    expect(domainForProjectId![0][1]).toBe("=");
+    expect(domainForProjectId![0][2]).toBe(62);
+
+    const domainForStageId = transformDomainForChildWidget({
+      domain: prevDomain,
+      widgetFieldName: "stage_id",
+    }) as any;
+
+    expect(domainForStageId!.length).toBe(1);
+    expect(domainForStageId![0][0]).toBe("name.process");
+    expect(domainForStageId![0][1]).toBe("ilike");
+    expect(domainForStageId![0][2]).toBe("backlog");
+  });
+});

package/src/spec/fixtures/WidgetImpl.ts

@@ -0,0 +1,10 @@
+import Widget from "../../Widget";
+
+// Widget implementation stub to test the class
+class WidgetImpl extends Widget {
+    findById(id: string): Widget {
+        throw new Error("Not implemented");
+    }
+}
+
+export default WidgetImpl;