@saltcorn/data 0.6.2-beta.0 → 0.6.2-beta.4

package/tests/calc.test.js

@@ -1,243 +0,0 @@
-const Table = require("../models/table");
-const Field = require("../models/field");
-const db = require("../db");
-const { getState } = require("../db/state");
-const { plugin_with_routes, sleep } = require("./mocks");
-const {
-  get_expression_function,
-  transform_for_async,
-  expressionValidator,
-  jsexprToWhere,
-} = require("../models/expression");
-
-getState().registerPlugin("base", require("../base-plugin"));
-
-afterAll(db.close);
-
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-describe("calculated", () => {
-  it("how to use functions", () => {
-    const f = new Function("{x,y}", "return x+y");
-    expect(f({ x: 1, y: 2 })).toBe(3);
-  });
-  it("build table", async () => {
-    const table = await Table.create("withcalcs");
-    await Field.create({
-      table,
-      label: "x",
-      type: "Integer",
-    });
-    await Field.create({
-      table,
-      label: "y",
-      type: "Integer",
-    });
-    const fz = await Field.create({
-      table,
-      label: "z",
-      type: "Integer",
-      calculated: true,
-      expression: "x+y",
-    });
-    const fzid = await Field.create({
-      table,
-      label: "zid",
-      type: "Integer",
-      calculated: true,
-      expression: "x+y+id",
-    });
-    const fw = await Field.create({
-      table,
-      label: "w",
-      type: "Integer",
-      calculated: true,
-      expression: "y-x",
-      stored: true,
-    });
-    const fields = await table.getFields();
-    const fzf = get_expression_function(fz.expression, fields);
-    expect(fzf({ x: 4, y: 2 })).toBe(6);
-    await table.insertRow({ x: 5, y: 8 });
-    const [row] = await table.getRows();
-    expect(row.z).toBe(13);
-    expect(row.zid).toBe(14);
-    expect(row.w).toBe(3);
-    const [row1] = await table.getJoinedRows();
-    expect(row1.z).toBe(13);
-    expect(row1.w).toBe(3);
-    const row0 = await table.getRow({});
-    expect(row0.z).toBe(13);
-    expect(row0.w).toBe(3);
-    await table.updateRow({ y: 9 }, row.id);
-    const row2 = await table.getRow({});
-    expect(row2.z).toBe(14);
-    expect(row2.w).toBe(4);
-    await table.update({ versioned: true });
-    const newid = await table.insertRow({ x: 2, y: 4 });
-    const row3 = await table.getRow({ id: newid });
-    expect(row3.z).toBe(6);
-    expect(row3.w).toBe(2);
-    await fz.delete();
-    await fw.delete();
-  });
-  it("cannot exit", async () => {
-    const table = await Table.create("withcalcs2");
-    await Field.create({
-      table,
-      label: "x",
-      type: "Integer",
-    });
-
-    const fz = await Field.create({
-      table,
-      label: "z",
-      type: "Integer",
-      calculated: true,
-      expression: "process.exit(0)",
-    });
-    const fields = await table.getFields();
-    const fzf = get_expression_function(fz.expression, fields);
-    let error;
-    try {
-      fzf({ x: 4 });
-    } catch (e) {
-      error = e;
-    }
-    expect(error.constructor.name).toBe("ReferenceError");
-  });
-  it("stored existing", async () => {
-    const table = await Table.create("withcalcs3");
-    await Field.create({
-      table,
-      label: "x",
-      type: "Integer",
-    });
-    await Field.create({
-      table,
-      label: "y",
-      type: "Integer",
-    });
-    const id1 = await table.insertRow({ x: 6, y: 9 });
-    for (let index = 0; index < 25; index++) {
-      await table.insertRow({ x: 1, y: 1 });
-    }
-    const id201 = await table.insertRow({ x: 7, y: 2 });
-
-    const fz = await Field.create({
-      table,
-      label: "z",
-      type: "Integer",
-      calculated: true,
-      expression: "x+y",
-      stored: true,
-    });
-    const row0 = await table.getRow({ id: id1 });
-    expect(row0.x).toBe(6);
-    expect([null, 15]).toContain(row0.z);
-    const row201 = await table.getRow({ id: id201 });
-    expect(row201.x).toBe(7);
-    expect([null, 9]).toContain(row201.z);
-    await sleep(3000);
-    const row1 = await table.getRow({ id: id1 });
-    expect(row1.x).toBe(6);
-    expect(row1.z).toBe(15);
-    const rowlast = await table.getRow({ id: id201 });
-    expect(rowlast.z).toBe(9);
-    expect(rowlast.x).toBe(7);
-  });
-  it("use supplied function", async () => {
-    const table = await Table.create("withcalcs5");
-    await Field.create({
-      table,
-      label: "x",
-      type: "Integer",
-    });
-    getState().registerPlugin("mock_plugin", plugin_with_routes);
-    await Field.create({
-      table,
-      label: "z",
-      type: "Integer",
-      calculated: true,
-      expression: "add3(x)",
-    });
-    await Field.create({
-      table,
-      label: "w",
-      type: "Integer",
-      calculated: true,
-      expression: "add5(x)",
-    });
-    await table.insertRow({ x: 13 });
-    const row0 = await table.getRow({});
-    expect(row0.z).toBe(16);
-    expect(row0.w).toBe(18);
-  });
-  it("use supplied function", async () => {
-    const table = await Table.create("withcalcs7");
-    await Field.create({
-      table,
-      label: "x",
-      type: "Integer",
-    });
-    getState().registerPlugin("mock_plugin", plugin_with_routes);
-    const xres = transform_for_async(
-      "add5(1)+ add3(4)+asyncAdd2(x)",
-      getState().functions
-    );
-    expect(xres).toEqual({
-      expr_string: "add5(1) + add3(4) + await asyncAdd2(x)",
-      isAsync: true,
-    });
-    await Field.create({
-      table,
-      label: "z",
-      type: "Integer",
-      calculated: true,
-      expression: "1+asyncAdd2(x)",
-      stored: true,
-    });
-
-    const id = await table.insertRow({ x: 14 });
-    const row0 = await table.getRow({});
-    expect(row0.z).toBe(17);
-    await table.updateRow({ x: 15 }, id);
-    const rows = await table.getRows({});
-    expect(rows[0].z).toBe(18);
-  });
-});
-describe("expressions", () => {
-  it("validates correct", () => {
-    expect(expressionValidator("2+2")).toBe(true);
-  });
-  it("validates correct", () => {
-    expect(expressionValidator("name.toUpperCase()")).toBe(true);
-  });
-  it("invalidates incorrect", () => {
-    expect(expressionValidator("2+")).toBe("Unexpected end of input");
-  });
-});
-describe("jsexprToWhere", () => {
-  it("translates equality", () => {
-    expect(jsexprToWhere("foo==4")).toEqual({ foo: 4 });
-  });
-  it("translates equal to col", () => {
-    expect(jsexprToWhere("foo==bar").foo.description).toBe("bar");
-  });
-  it("translates context", () => {
-    expect(jsexprToWhere("foo==$bar", { bar: 5 })).toEqual({ foo: 5 });
-  });
-  it("translates context", () => {
-    const w = jsexprToWhere("$father !== null && married_to === $father", {
-      father: "1",
-    });
-    expect(w).toEqual({ married_to: "1", not: { eq: ["1", null] } });
-  });
-  it("translates context", () => {
-    const w = jsexprToWhere("$father !== null && married_to === $father", {});
-    expect(w).toEqual({ married_to: null, not: { eq: [null, null] } });
-  });
-});

package/tests/config.test.js

@@ -1,91 +0,0 @@
-const Table = require("../models/table");
-const Field = require("../models/field");
-const db = require("../db");
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-const {
-  getConfig,
-  getAllConfig,
-  setConfig,
-  getAllConfigOrDefaults,
-  get_base_url,
-  check_email_mask,
-  get_latest_npm_version,
-} = require("../models/config");
-afterAll(db.close);
-
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-describe("Config", () => {
-  it("should get default", async () => {
-    const d = await getConfig("noval", 5);
-    expect(d).toBe(5);
-    const sn = await getConfig("site_name");
-    expect(sn).toBe("Saltcorn");
-  });
-  it("should set value", async () => {
-    await setConfig("cfg1", 8);
-    const d = await getConfig("cfg1", 5);
-    expect(d).toBe(8);
-    await setConfig("cfg1", 9);
-    const x = await getConfig("cfg1", 5);
-    expect(x).toBe(9);
-    await setConfig("cfgStr", "HelloWorld");
-    const s = await getConfig("cfgStr", "");
-    expect(s).toBe("HelloWorld");
-    await setConfig("log_sql", false);
-  });
-  it("should set value via state", async () => {
-    await getState().setConfig("cfgStr1", "FooBaz");
-    const s = getState().getConfig("cfgStr1", "");
-    expect(s).toBe("FooBaz");
-    const s1 = await getConfig("cfgStr1", "");
-    expect(s1).toBe("FooBaz");
-  });
-  it("should set list int", async () => {
-    await setConfig("list_ints", [8]);
-    const d = await getConfig("list_ints", 5);
-    expect(d).toStrictEqual([8]);
-  });
-  it("should set list strings", async () => {
-    await setConfig("list_strs", ["hello", "World"]);
-    const d = await getConfig("list_strs", 5);
-    expect(d).toStrictEqual(["hello", "World"]);
-  });
-  it("should get all value", async () => {
-    const d = await getAllConfig();
-    expect(d.cfg1).toBe(9);
-  });
-  it("should get all value", async () => {
-    const d = await getAllConfigOrDefaults();
-    expect(d.cfg1).toBe(undefined);
-    expect(d.log_sql.value).toBe(false);
-  });
-  it("should get base url", async () => {
-    expect(get_base_url()).toBe("/");
-    await getState().setConfig("base_url", "foo");
-    const s = get_base_url();
-    expect(s).toBe("foo/");
-    await getState().setConfig("base_url", "bar/");
-    const s1 = get_base_url();
-    expect(s1).toBe("bar/");
-  });
-  it("should check email mask", async () => {
-    expect(check_email_mask("foo@bar.com")).toBe(true);
-    await getState().setConfig("email_mask", "bar.com");
-    expect(check_email_mask("foo@bar.com")).toBe(true);
-    expect(check_email_mask("foo@baz.com")).toBe(false);
-  });
-  it("should check email mask", async () => {
-    await getState().setConfig("latest_npm_version", {
-      foopkg: { version: "1.2.3", time: new Date() },
-    });
-    const foov = await get_latest_npm_version("foopkg");
-    expect(foov).toBe("1.2.3");
-    const lpv = await get_latest_npm_version("left-pad");
-    expect(lpv).toBe("1.3.0");
-  });
-});

package/tests/discover.test.js

@@ -1,114 +0,0 @@
-const {
-  discoverable_tables,
-  discover_tables,
-  implement_discovery,
-} = require("../models/discovery");
-const { getState } = require("../db/state");
-const db = require("../db");
-
-getState().registerPlugin("base", require("../base-plugin"));
-
-afterAll(db.close);
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-jest.setTimeout(30000);
-
-describe("Table Discovery", () => {
-  if (!db.isSQLite) {
-    it("should create tables", async () => {
-      await db.query(
-        `create table discperson(id serial primary key, name text, age integer not null);`
-      );
-      await db.query(
-        `create table discdog(id serial primary key, name text, owner int references discperson(id));`
-      );
-    });
-    it("should list tables", async () => {
-      const tbls = await discoverable_tables();
-      expect(tbls.map((t) => t.table_name).sort()).toStrictEqual([
-        "discdog",
-        "discperson",
-      ]);
-    });
-    it("should make simple pack", async () => {
-      const pack = await discover_tables(["discperson"]);
-      expect(pack).toStrictEqual({
-        tables: [
-          {
-            fields: [
-              {
-                label: "id",
-                name: "id",
-                required: true,
-                type: "Integer",
-                primary_key: true,
-                is_unique: true,
-              },
-              { label: "name", name: "name", required: false, type: "String" },
-              { label: "age", name: "age", required: true, type: "Integer" },
-            ],
-            name: "discperson",
-            min_role_read: 1,
-            min_role_write: 1,
-          },
-        ],
-      });
-    });
-    it("should make and implement pack with fkey", async () => {
-      const pack = await discover_tables(["discperson", "discdog"]);
-      expect(pack).toStrictEqual({
-        tables: [
-          {
-            fields: [
-              {
-                label: "id",
-                name: "id",
-                required: true,
-                type: "Integer",
-                primary_key: true,
-                is_unique: true,
-              },
-              { label: "name", name: "name", required: false, type: "String" },
-              { label: "age", name: "age", required: true, type: "Integer" },
-            ],
-            name: "discperson",
-            min_role_read: 1,
-            min_role_write: 1,
-          },
-          {
-            fields: [
-              {
-                label: "id",
-                name: "id",
-                required: true,
-                type: "Integer",
-                primary_key: true,
-                is_unique: true,
-              },
-              { label: "name", name: "name", required: false, type: "String" },
-              {
-                label: "owner",
-                name: "owner",
-                required: false,
-                refname: "id",
-                reftable_name: "discperson",
-                reftype: "Integer",
-                type: "Key",
-              },
-            ],
-            name: "discdog",
-            min_role_read: 1,
-            min_role_write: 1,
-          },
-        ],
-      });
-      await implement_discovery(pack);
-    });
-  } else {
-    it("doesnt run on sqlite", async () => {
-      expect(2 + 2).toBe(4);
-    });
-  }
-});