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

package/plugin-testing.js

@@ -1,124 +0,0 @@
-/**
- * @category saltcorn-data
- * @module plugin-testing
- */
-const { contract, is, auto_test } = require("contractis");
-const { is_plugin_wrap, is_plugin } = require("./contracts");
-const { getState } = require("./db/state");
-const { renderForm } = require("@saltcorn/markup");
-const { mockReqRes } = require("./tests/mocks");
-const Field = require("./models/field");
-
-const auto_test_wrap = (wrap) => {
-  auto_test(contract(is_plugin_wrap, wrap, { n: 5 }));
-};
-
-const generate_attributes = (typeattrs, validate, table_id) => {
-  var res = {};
-  const attrs = Field.getTypeAttributes(typeattrs, table_id);
-  (attrs || []).forEach((a) => {
-    if (a.type && (a.required || is.bool.generate())) {
-      const contract = a.type.contract || getState().types[a.type].contract;
-      const gen = contract({}).generate;
-      if (gen) res[a.name] = gen();
-    }
-  });
-  if (validate && !validate(res))
-    return generate_attributes(attrs, validate, table_id);
-  else return res;
-};
-
-const auto_test_type = (t) => {
-  const fvs = t.fieldviews || {};
-
-  //run edit field views without a value
-  Object.values(fvs).forEach((fv) => {
-    if (fv.isEdit) {
-      const attr = generate_attributes(t.attributes, t.validate_attributes);
-      is.str(fv.run("foo", undefined, attr, "myclass", true, { name: "foo" }));
-      is.str(fv.run("foo", undefined, attr, "myclass", false, { name: "foo" }));
-    }
-  });
-  //find examples, run all fieldview on each example
-
-  const has_contract = t.contract && t.contract.generate;
-  const numex = has_contract ? 20 : 200;
-  for (let index = 0; index < numex; index++) {
-    const x = has_contract ? t.contract.generate() : t.read(is.any.generate());
-
-    const attribs = generate_attributes(t.attributes, t.validate_attributes);
-    if (has_contract || (typeof x !== "undefined" && x !== null))
-      if ((t.validate && t.validate(attribs)(x)) || !t.validate) {
-        Object.values(fvs).forEach((fv) => {
-          if (fv.isEdit) {
-            is.str(fv.run("foo", x, attribs, "myclass", true, { name: "foo" }));
-            is.str(
-              fv.run("foo", x, attribs, "myclass", false, { name: "foo" })
-            );
-          } else {
-            is.str(fv.run(x));
-          }
-        });
-        if (t.readFromFormRecord) t.readFromFormRecord({ akey: x }, "akey");
-      }
-  }
-  if (t.readFromFormRecord) {
-    t.readFromFormRecord({}, "akey");
-  }
-  //todo: try creating a table with this type
-};
-const auto_test_workflow = async (wf, initialCtx) => {
-  const step = async (wf, ctx) => {
-    is.obj(ctx);
-    const res = await wf.run(ctx);
-
-    if (res.renderForm) {
-      is.str(renderForm(res.renderForm, ""));
-
-      const vs = await res.renderForm.generate();
-      return await step(wf, vs);
-    } else return res;
-  };
-  return await step(wf, initialCtx);
-};
-
-const auto_test_viewtemplate = async (vt) => {
-  if (vt.noAutoTest) return;
-  const wf = vt.configuration_workflow({ __: (s) => s });
-  is.class("Workflow")(wf);
-  for (let index = 0; index < 10; index++) {
-    var cfg;
-    if (vt.initial_config && Math.round() > 0.5)
-      cfg = await vt.initial_config({ table_id: 2 });
-    else
-      cfg = await auto_test_workflow(wf, {
-        table_id: 2,
-        viewname: "newview",
-      });
-    const sfs = vt.get_state_fields
-      ? await vt.get_state_fields(1, "newview", cfg)
-      : [];
-    const res = await vt.run(2, "newview", cfg, {}, mockReqRes);
-    is.or(is.str, is.array(is.str))(res);
-    if (sfs.some((sf) => sf.name === "id")) {
-      const resid = await vt.run(2, "newview", cfg, { id: 1 }, mockReqRes);
-      is.or(is.str, is.array(is.str))(resid);
-    }
-  }
-};
-
-const auto_test_plugin = async (plugin) => {
-  is_plugin(plugin);
-  getState().registerPlugin("test_plugin", plugin);
-  if (plugin.layout) {
-    auto_test_wrap(plugin.layout.wrap);
-  }
-  if (plugin.types) {
-    plugin.types.forEach(auto_test_type);
-  }
-  for (const vt of plugin.viewtemplates || []) await auto_test_viewtemplate(vt);
-
-  //is each header reachable
-};
-
-module.exports = { auto_test_plugin, generate_attributes };

package/tests/actions.test.js

@@ -1,232 +0,0 @@
-const Table = require("../models/table");
-//const Field = require("../models/field");
-const Trigger = require("../models/trigger");
-const runScheduler = require("../models/scheduler");
-const db = require("../db");
-const { getState } = require("../db/state");
-const {
-  plugin_with_routes,
-  getActionCounter,
-  resetActionCounter,
-  sleep,
-} = require("./mocks");
-const EventLog = require("../models/eventlog");
-
-afterAll(db.close);
-
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-jest.setTimeout(10000);
-
-describe("Action", () => {
-  it("should add insert trigger", async () => {
-    getState().registerPlugin("mock_plugin", plugin_with_routes);
-    resetActionCounter();
-    expect(getActionCounter()).toBe(0);
-
-    const table = await Table.findOne({ name: "patients" });
-
-    const trigger = await Trigger.create({
-      action: "incrementCounter",
-      table_id: table.id,
-      when_trigger: "Insert",
-    });
-    expect(getActionCounter()).toBe(0);
-    await table.insertRow({ name: "Don Fabrizio" });
-    await sleep(10);
-    expect(getActionCounter()).toBe(1);
-    const trigger1 = await Trigger.findOne({ id: trigger.id });
-    expect(!!trigger1).toBe(true);
-    expect(trigger1.id).toBe(trigger.id);
-  });
-  it("should add update trigger", async () => {
-    expect(getActionCounter()).toBe(1);
-
-    const table = await Table.findOne({ name: "patients" });
-
-    await Trigger.create({
-      action: "setCounter",
-      table_id: table.id,
-      when_trigger: "Update",
-      configuration: { number: 17 },
-    });
-    expect(getActionCounter()).toBe(1);
-    const don = await table.getRow({ name: "Don Fabrizio" });
-    await table.updateRow({ name: "Don Fabrizio II" }, don.id);
-    expect(getActionCounter()).toBe(17);
-  });
-  it("should add update trigger", async () => {
-    expect(getActionCounter()).toBe(17);
-
-    const table = await Table.findOne({ name: "patients" });
-
-    await Trigger.create({
-      action: "setCounter",
-      table_id: table.id,
-      when_trigger: "Delete",
-      configuration: { number: 37 },
-    });
-    expect(getActionCounter()).toBe(17);
-    await table.deleteRows({ name: "Don Fabrizio" });
-    expect(getActionCounter()).toBe(17);
-
-    await table.deleteRows({ name: "Don Fabrizio II" });
-    expect(getActionCounter()).toBe(37);
-  });
-  it("should run js code", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    await Trigger.create({
-      action: "run_js_code",
-      table_id: table.id,
-      when_trigger: "Insert",
-      configuration: {
-        code: `
-        const table = await Table.findOne({ name: "patients" });
-        await table.insertRow({ name: "TriggeredInsert" });
-      `,
-      },
-    });
-    await table.insertRow({ author: "Giuseppe Tomasi", pages: 209 });
-    const patients = await Table.findOne({ name: "patients" });
-    await sleep(10);
-    const rows = await patients.getRows({ name: "TriggeredInsert" });
-
-    expect(rows.length).toBe(1);
-  });
-  it("should run webhook", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    await Trigger.create({
-      action: "webhook",
-      table_id: table.id,
-      when_trigger: "Update",
-      configuration: {
-        // from https://requestbin.com/
-        // to inspect https://pipedream.com/sources/dc_jku44wk
-        url: "https://b6af540a71dce96ec130de5a0c47ada6.m.pipedream.net",
-      },
-    });
-    const row = await table.getRow({ author: "Giuseppe Tomasi" });
-    await table.updateRow({ pages: 210 }, row.id);
-  });
-
-  it("should list triggers", async () => {
-    //const table = await Table.findOne({ name: "books" });
-
-    const triggers = await Trigger.findAllWithTableName();
-    expect(triggers.length).toBe(5);
-    expect(
-      triggers.find(
-        (tr) => tr.table_name === "books" && tr.when_trigger === "Update"
-      ).action
-    ).toBe("webhook");
-  });
-  it("should get triggers", async () => {
-    const table = await Table.findOne({ name: "books" });
-    const trigger = await Trigger.findOne({
-      table_id: table.id,
-      when_trigger: "Update",
-    });
-    expect(trigger.action).toBe("webhook");
-    await Trigger.update(trigger.id, { when_trigger: "Insert" });
-    const ins_trigger = Trigger.find({
-      table_id: table.id,
-      when_trigger: "Insert",
-    });
-    expect(ins_trigger.length).toBe(2);
-    await trigger.delete();
-    const ins_trigger1 = Trigger.find({
-      table_id: table.id,
-      when_trigger: "Insert",
-    });
-    expect(ins_trigger1.length).toBe(1);
-  });
-  it("should run webhook on insert", async () => {
-    const table = await Table.findOne({ name: "books" });
-
-    await Trigger.create({
-      action: "webhook",
-      table_id: table.id,
-      when_trigger: "Insert",
-      configuration: {
-        // from https://requestbin.com/
-        // to inspect https://pipedream.com/sources/dc_jku44wk
-        url: "https://b6af540a71dce96ec130de5a0c47ada6.m.pipedream.net",
-        body: "",
-      },
-    });
-    await table.insertRow({ author: "NK Jemisin", pages: 901 });
-  });
-});
-
-describe("Events", () => {
-  it("should add custom event", async () => {
-    await getState().setConfig("custom_events", [
-      {
-        name: "FooHappened",
-        hasChannel: false,
-      },
-      {
-        name: "BarWasHere",
-        hasChannel: true,
-      },
-    ]);
-    await getState().setConfig("event_log_settings", {
-      FooHappened: true,
-      BarWasHere: true,
-      BarWasHere_channel: "Baz",
-    });
-    await getState().refresh_config();
-  });
-  it("should emit custom event", async () => {
-    await Trigger.emitEvent("FooHappened");
-    const evs = await EventLog.find({ event_type: "FooHappened" });
-    expect(evs.length).toBe(0);
-    await sleep(100);
-    const evs1 = await EventLog.find({ event_type: "FooHappened" });
-    expect(evs1.length).toBe(1);
-  });
-  it("should find with user", async () => {
-    const ev = await EventLog.findOne({ event_type: "FooHappened" });
-    const evlog_w_user = await EventLog.findOneWithUser(ev.id);
-    expect(evlog_w_user.event_type).toBe("FooHappened");
-  });
-  it("should emit custom event with channel", async () => {
-    await Trigger.emitEvent("BarWasHere");
-    await Trigger.emitEvent("BarWasHere", "Zap");
-    await Trigger.emitEvent("BarWasHere", "Baz");
-    const evs = await EventLog.find({ event_type: "BarWasHere" });
-    expect(evs.length).toBe(0);
-    await sleep(100);
-    const evs1 = await EventLog.find({ event_type: "BarWasHere" });
-    expect(evs1.length).toBe(1);
-  });
-});
-
-describe("Scheduler", () => {
-  it("should run and tick", async () => {
-    getState().registerPlugin("mock_plugin", plugin_with_routes);
-    resetActionCounter();
-    expect(getActionCounter()).toBe(0);
-
-    await Trigger.create({
-      action: "incrementCounter",
-      when_trigger: "Often",
-    });
-    let stopSched = false;
-    runScheduler({
-      stop_when: () => stopSched,
-      tickSeconds: 1,
-    });
-    await sleep(500);
-    expect(getActionCounter()).toBe(1);
-    await sleep(1200);
-    expect(getActionCounter() > 1).toBe(true);
-    stopSched = true;
-    await sleep(1200);
-  });
-});

package/tests/auxtest.test.js

@@ -1,52 +0,0 @@
-const View = require("../models/view");
-const db = require("../db/index.js");
-const Table = require("../models/table");
-
-const { get_parent_views, get_child_views } = require("../plugin-helper");
-const { getState } = require("../db/state");
-const { satisfies } = require("../utils");
-
-getState().registerPlugin("base", require("../base-plugin"));
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-afterAll(db.close);
-
-describe("plugin helper", () => {
-  it("get parent views", async () => {
-    const patients = await Table.findOne({ name: "patients" });
-    const x = await get_parent_views(patients, "foobar");
-    expect(x[0].views.map((v) => v.name)).toStrictEqual([
-      "authoredit",
-      "authorshow",
-    ]);
-  });
-  it("get child views", async () => {
-    const books = await Table.findOne({ name: "books" });
-    const x = await get_child_views(books, "foobar");
-    expect(x[1].views.map((v) => v.name)).toStrictEqual(["patientlist"]);
-  });
-});
-
-describe("satisfies", () => {
-  it("works", async () => {
-    expect(satisfies({ x: 5 })({ x: 5 })).toBe(true);
-    expect(satisfies({ x: 5 })({ x: 5, y: 7 })).toBe(true);
-    expect(satisfies({ x: 5 })({ x: 6 })).toBe(false);
-    expect(satisfies({ x: 5 })({ y: 6 })).toBe(false);
-    expect(satisfies({})({ y: 6 })).toBe(true);
-    expect(satisfies()({ y: 6 })).toBe(true);
-    expect(satisfies({ x: { or: [5, 6] } })({ x: 5 })).toBe(true);
-    expect(satisfies({ x: { or: [5, 6] } })({ x: 8 })).toBe(false);
-    expect(satisfies({ x: { or: [5, 6] } })({ y: 8 })).toBe(false);
-    expect(satisfies({ x: { in: [5, 6] } })({ x: 5 })).toBe(true);
-    expect(satisfies({ x: { in: [5, 6] } })({ x: 8 })).toBe(false);
-    expect(satisfies({ x: { in: [5, 6] } })({ y: 8 })).toBe(false);
-
-    expect(satisfies({ x: 5, y: 7 })({ x: 5, y: 7 })).toBe(true);
-    expect(satisfies({ x: 5, y: 8 })({ x: 5, y: 7 })).toBe(false);
-    expect(satisfies({ x: 4, y: 8 })({ x: 5, y: 7 })).toBe(false);
-  });
-});

package/tests/backup.test.js

@@ -1,92 +0,0 @@
-const db = require("../db");
-const { getState } = require("../db/state");
-getState().registerPlugin("base", require("../base-plugin"));
-const { create_backup, restore } = require("../models/backup");
-const reset = require("../db/reset_schema");
-const fs = require("fs").promises;
-const Table = require("../models/table");
-const View = require("../models/view");
-const User = require("../models/user");
-const { setConfig, getConfig } = require("../models/config");
-const Trigger = require("../models/trigger");
-const Library = require("../models/library");
-const Role = require("../models/role");
-afterAll(db.close);
-
-beforeAll(async () => {
-  await require("../db/reset_schema")();
-  await require("../db/fixtures")();
-});
-
-describe("Backup and restore", () => {
-  it("should create and restore backup", async () => {
-    await setConfig("site_name", "backups rule!");
-    const sn1 = await getConfig("site_name");
-    expect(sn1).toBe("backups rule!");
-    await Role.create({ role: "paid", id: 6 });
-    await Table.create("myblanktable", { min_role_read: 6 });
-    await Trigger.create({
-      name: "footrig",
-      table_id: 1,
-      when_trigger: "Insert",
-      action: "run_js_code",
-      configuration: { code: "console.log('new user')" },
-    });
-    await Trigger.create({
-      name: "hourtrig",
-      when_trigger: "Hourly",
-      action: "run_js_code",
-      configuration: { code: "console.log('cuckoo')" },
-    });
-    await Library.create({
-      name: "foo",
-      icon: "fa-bar",
-      layout: { baz: "bar" },
-    });
-
-    const fnm = await create_backup();
-    const t1 = await Table.findOne({ name: "books" });
-    const t1c = await t1.countRows();
-    const v1 = await View.find();
-    expect(!!t1).toBe(true);
-
-    await reset();
-    const admu = await User.create({
-      email: "admin@foo.com",
-      password: "AhGGr6rhu45",
-      role_id: 1,
-    });
-    expect(typeof admu.password).toBe("string");
-
-    const t2 = await Table.findOne({ name: "books" });
-    expect(t2).toBe(null);
-    const sn0 = await getConfig("site_name");
-    expect(sn0).toBe("Saltcorn");
-    const restore_res = await restore(fnm, (p) => {});
-    await fs.unlink(fnm);
-    expect(restore_res).toBe(undefined);
-    const t3 = await Table.findOne({ name: "books" });
-    expect(!!t3).toBe(true);
-    const t5 = await Table.findOne({ name: "myblanktable" });
-    expect(!!t5).toBe(true);
-    expect(t5.min_role_read).toBe(6);
-    const t3c = await t3.countRows();
-    expect(t1c).toBe(t3c);
-    const v2 = await View.find();
-    expect(v1.length).toBe(v2.length);
-    const sn = await getConfig("site_name");
-    expect(sn).toBe("backups rule!");
-    await t3.insertRow({ author: "Marcus Rediker", pages: 224 });
-    const staff = await User.findOne({ email: "staff@foo.com" });
-    expect(!!staff).toBe(true);
-    expect(typeof staff.password).toBe("string");
-    const trig = await Trigger.findOne({ name: "footrig" });
-    expect(!!trig).toBe(true);
-    const htrig = await Trigger.findOne({ name: "hourtrig" });
-    expect(!!htrig).toBe(true);
-    const lib = await Library.findOne({ name: "foo" });
-    expect(!!lib).toBe(true);
-
-    expect(staff.checkPassword("ghrarhr54hg")).toBe(true);
-  });
-});